01 · strata

Postgres, row security, the API and agents as four plates: the pointer pulls them apart and picks a layer.

02 · assembly

Constructive's six-cube mark hangs mid-build; bring the pointer near and the cubes slide home, nearest first.

03 · needle

A needle through a deck of notched cards: cards whole at that hole ride up, notched ones stay seated, so every row starts locked.

04 · grants

A console of grant switches, one row per role: only the privileges granted to that role are switched on, one by one.

05 · keychain

Agent keys cut from a member key hang below it, each narrower: pick one and it drops with every key below it, revoked in turn.

06 · orgchart

An org chart in three tiers: pick a person, and they and everyone under them lift; nobody above them does.

07 · vault

Tenants as safe-deposit boxes in one vault wall: the box under the pointer slides out with its own rows, and the rest stay shut.

08 · register

Changes as sheets on registration pins: pick one, and every sheet above it lifts off the pins, reverted.

09 · plan

pgpm packages stacked on what they require: lift one, and every package that depends on it comes with it.

10 · vectors

Rows with an embedding at the end: pick one as the query, and rows with the nearest vectors lift, wherever they sit.

11 · reembed

Edit a cell and the row re-embeds: its vector bars empty and regrow one after another, from the edited cell toward the end.

12 · tickets

Jobs hang as tickets on a rail and slide on to the worker; hovering slows the queue so one can be read.

13 · pantograph

A pantograph traces the schema's tables onto the client at twice the scale, so the client follows the schema.

14 · backups

A tape library: pick a point in time and the picker draws its cartridge out of the rack, a restore point.

15 · parse

SQL set as type: near the pointer each sort lifts to its node in the parse tree, then prints back into the line.

16 · sandbox

Three copies of one database: the pointer writes into one tray, its walls keep the others still, and leaving rolls it back.

17 · safegres-scan

Safegres reads every table's policies and grants from the live database and grades what it finds.

18 · drafting

A drafting board with a blank sheet: the pointer slides the parallel rule up and down, and there is nothing to draw against.

19 · stack-cloud-db

A database hosted in the cloud, its code on a wire into the drum. Pick a disc and the stack fans open under the clouds.

20 · stack-chip

A chip holds the keys: a key opens four of its pins, and the agent handed that key reaches only two of them.

21 · stack-gate

An agent reaches the database only through the shield, and only its key lets it through.

22 · stack-function

A cloud function runs its code, and each run writes to the records and to the database.

23 · stack-rack

A cloud function on a three-unit rack: the unit under the pointer lifts clear of the one below, and its wire to the bolt cloud lights.

24 · stack-afloat

Postgres afloat in a life ring of four bands, two per score: the band under the pointer lifts, and the one opposite follows.

25 · container

Four tests, each in its own container: the pointer lifts one cube out, and leaving sets it back where it was.

26 · network

A parse tree of rounded nodes: the pointer picks one, and it lifts away with every node under it.

27 · tiers

A database as tiers of changes: the pointer's height sets how far it is deployed, and the changes after it lift away.

28 · chip

A chip taken apart to be inspected: across it the pointer opens the layers, and its height picks the one to look at.

29 · inspect

A linter’s attention moving over a file: around it, fine statements settle flush with a seal and wrong ones rise with a pin.

30 · versions

Type definitions for every Postgres version as strata: pick a version and the plates above lift, and its node kinds stand up.

31 · presets

An enum as preset keys: exactly one is ever down, and pressing another latches it as the last one springs up.

32 · lacing

A traversal as a thread laced round a tree of pegs: the walk visits every node in turn, and each peg it reaches stands up.

33 · modules

pgpm packages as crates resting on what they require: lift one and every package that depends on it rises with it.