@vibecook/ice 0.10.0 → 0.14.0

package/dist/types/packages/core/src/catalog/desk.d.ts

@@ -0,0 +1,326 @@
+/** A desk stratum an object can declare (design-015 §4.2). The mat, the held set and the marks are the renderer's, never declared. */
+export type DeskStratum = "pads" | "sheets" | "things";
+/**
+ * `Stratum.band` per declared stratum — ascending = paint order: pads lie under
+ * everything on a desk (the calendar pad), sheets lie flat on the mat and hold a
+ * desk (the mini mats), things are every other object.
+ */
+export declare const STRATUM_BANDS: Readonly<Record<DeskStratum, number>>;
+/**
+ * The band an entity WITHOUT a `Stratum` sorts in: things. Every pre-desk widget
+ * is one, so an all-dom board stays in one band and its order is exactly its
+ * sibling order, as before (design-015 §4.2: "things … every future kind").
+ */
+export declare const DEFAULT_STRATUM_BAND: number;
+/** Runtime: the object's desk stratum (equip, from the type's `stratum`). Read by `compareStackOrder`. */
+export declare const Stratum: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly band: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
+}>, {
+    readonly band: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
+}>;
+/** Durable: taped down (design-015 §5.1, Q-e). One writer: `ops.setLocked`. */
+export declare const Locked: import("@vibecook/strata-ecs").Tag;
+/**
+ * Runtime: the ONE focused editor is on this object (design-015 §5.1, §6.1 — D2c): a note being
+ * written. One writer, the desk's typing session (`@ice/desk` objects/typing.ts); a runtime rider,
+ * never in the document (a peer's editor is its own). While present it is a GESTURE CLAIM on the
+ * object's cells — `makeDefaultMayDiverge` grants the divergence — so the session writes the note's
+ * text LIVE through the guarded live writer and commits it ONCE when the session ends (design-001
+ * §3's gesture protocol with the keyboard as the gesture: ⌘Z undoes a typing session, never a key).
+ */
+export declare const Editing: import("@vibecook/strata-ecs").Tag;
+/**
+ * Runtime: this object is IN HAND (design-015 §8 — "`Held` is the fact"). ONE writer, the open
+ * op: `ops.open(entity)` adds it (with a fresh `HeldView`) and `ops.putDown()` removes it; at most
+ * one object on a desk carries it. The pickup's clock, the flight home, the blur amount and the
+ * cover spring are the renderer's FLUX, never facts — the tag says only "in hand"; an object whose
+ * tag just left is flying home in the renderer alone. While an object is held every pointer is
+ * the held object's and the desk behind is inert (systems/held.ts). Never in the document.
+ */
+export declare const Held: import("@vibecook/strata-ecs").Tag;
+/**
+ * Runtime: the user's facts about the object in hand — how close it was brought (`zoom`, 1 = the
+ * reading size, 0.72 … 3) and where it was moved under the eye (`panX`/`panY`, CSS px from the
+ * reading pose's centre). Written by the held input system from the wheel, a pinch and a pan; put
+ * on with `Held` at the open and taken off with it. The renderer reads it to pose the object.
+ */
+export declare const HeldView: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
+/**
+ * Runtime, on the object in hand: its ACTIVE tool (design-015 §8; D3t-a — widget/held-tools.ts) — the
+ * id of the held bar's `mode` in hand (the board's marker in blue, its eraser), and `prev` the one
+ * before it (a `toggle` mode chosen again hands that one back). The USER's fact, never in the document.
+ * Put on with `Held` by `ops.open` (the type's `heldTool` of its props, else its first mode; "" = none)
+ * and taken off with it; `ops.useHeldTool` its only other writer. The kind's held behaviours read it.
+ */
+export declare const HeldTool: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly id: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly prev: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly id: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly prev: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * A system's IN-TICK request to pick an object up or put it down (D2b's `NavIntent`, applied the
+ * same way): the double-tap on an openable object asks to `open`; the ways back that are
+ * gestures — a click on the soft desk, a pinch or ⌘-wheel in past 0.72×, a double-tap on the
+ * held object's case — ask to `putDown`. The ops are structural (a tag and a component come and
+ * go) and run outside the tick: the facade applies the request once `engine.step` returns.
+ * `epoch` bumps per request; `target` is the object to open (unused on a put-down).
+ */
+export declare const HeldIntent: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"open" | "putDown">, true>;
+    readonly target: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"open" | "putDown">, true>;
+    readonly target: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * A zoom-out put the object down and the REST OF THAT GESTURE is muted (design-015 §8 — "the v2
+ * lesson"): until `until` (the frame clock, ms) every wheel fact is swallowed before the camera
+ * can read it, and each swallowed event pushes the mute 250 ms further. One writer: the held
+ * input system.
+ */
+export declare const HeldMute: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly until: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly until: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
+/**
+ * Runtime, on a LOCAL pointer while an object is held: where the pointer is in the held object's
+ * OWN frame — its open extent's units, centred, mapped through the same pose the renderer drew
+ * (`HeldPoseSource`) — and whether it is over the object at all. Change-only. What a kind's held
+ * behaviours (its parts, its pen — D3t) read; absent when nothing is held or before the first frame.
+ * `part` (D3t-a): the kind's part under it as the renderer drew it (the pose seam's `part` — the
+ * board's melamine `content`, its aluminium `frame`), "" over nothing.
+ */
+export declare const HeldPointer: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly inside: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly inside: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * Runtime, on a local pointer: a press that began while an object was held — on the soft desk
+ * (`desk`: released unmoved, it puts the object down; dragged with the object brought close, it
+ * pans), as a pan (`pan`: a middle button or Space, the object brought close), on the object's
+ * drawing surface with a mode in hand (`tool`, D3t-a: the TOOL's press — the board's stroke; never
+ * a tap that puts it down), on one of the kind's named PARTS (`part`, D3t-b: the kind's own — a
+ * notebook's turn, its click and its drag; never a tap that puts it down) or elsewhere on the object
+ * itself (`object`: two instant taps put it down). `part`: the part it began on ("" — none); `x`/`y`
+ * where it began (CSS px), the pan it began from, and whether it has moved past the slop.
+ */
+export declare const HeldPress: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"object" | "pan" | "part" | "desk" | "tool">, true>;
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panX0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panY0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+}>, {
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"object" | "pan" | "part" | "desk" | "tool">, true>;
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panX0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly panY0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+}>;
+/** The last instant tap on the held object: where and when — a second within the window puts it down (the notebook's case, generalised). */
+export declare const HeldTapMemo: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly at: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly seq: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly at: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly seq: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * Runtime, ONE per view: THE TRAY (design-016 §7, K-L6; design-017 §2 — K3) — the pegboard drawer's facts. `open`; `scroll`, CSS px
+ * of board past its top, within `[0, max]` (the renderer's word on `max` rides the tray pose seam, systems/tray.ts); `stretch`, the
+ * rubber band's pull past an end (raw px, signed; 0 at rest); `wheelAt`, the frame clock (ms) of the last scroll input (every wheel
+ * the drawer takes while out, a drag on its board) — the band lets go once it is quiet, and a drawer shut before then keeps the wheel
+ * until it is (K9). Never in the document, never synced:
+ * a peer's tray is its own. Writers: the tray ops (ops/tray.ts) and `trayInput` — and `trayLay`, which clamps `scroll` when a lay
+ * or the drawer's face moves its range (K9, D-K9-c.2); the renderer reads it, and owns the motion (the
+ * slide, the band's settle — flux). The entity is ensured at install and after every reset (a document switch
+ * closes the tray); it roots the tray's runtime canvas (K5's specimens will be its children). design-018 §5 (R2): the lip's hover
+ * fact retired with its handle — a closed drawer takes no pointer; its handle is the app's DOM bar (`<TrayBar>`, @ice/react).
+ */
+export declare const Tray: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly open: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly scroll: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly stretch: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly wheelAt: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /**
+     * K9 (S11, D-K9-c.3): the last wheel `dy` the drawer scrolled by, and how many deltas in a row have SHRUNK while pushing the band
+     * further — a fading tail (the OS's momentum decays; a push does not, steadily). At `TRAY_INPUT.fadeDeltas` the band lets go and
+     * the rest of that tail is spent — swallowed, scroll and band untouched — until a reversal, a growing delta or quiet.
+     */
+    readonly wheelDy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly fade: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** K5a: the type of the specimen under the mouse while the drawer is out ("" — none): the hover that lifts it (flux). */
+    readonly hover: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    /**
+     * K5b — TAKING ONE (design-017 §9): the type whose copy a pointer has lifted off the board ("" — none): pressed on its specimen and
+     * moved past the slop, still inside the drawer. `takeU`/`takeV` the grab point (0 … 1 across the object as the board draws it — the
+     * spot under the finger stays that spot of the object), `takeX`/`takeY` the pointer as last seen (CSS px) — the copy follows it
+     * (flux). `handed` counts the takes handed to the desk: it bumps on the tick the copy leaves the drawer's open rect (the drawer slides
+     * away, `TrayIntent` spawns the insert ghost after the step); a take that ends without the bump was put back.
+     */
+    readonly take: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly takeU: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeV: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly handed: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /**
+     * design-018 §6 (R2) — THE FILTER: the tray category the drawer shows ("" — all), a tray entry's `category` string (`defineObject({
+     * tray: { category } })`). A fact of the view beside `open` — never durable, never synced (each tab its own). Writers: the op
+     * `setTrayCategory` (the bar's chips, the desk handle's door) and `trayLay` — which lays only that category's entries, zeroes the
+     * scroll and the band when it moves, and falls back to all ("") when the frame hangs none of it.
+     */
+    readonly category: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly open: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly scroll: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly stretch: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly wheelAt: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /**
+     * K9 (S11, D-K9-c.3): the last wheel `dy` the drawer scrolled by, and how many deltas in a row have SHRUNK while pushing the band
+     * further — a fading tail (the OS's momentum decays; a push does not, steadily). At `TRAY_INPUT.fadeDeltas` the band lets go and
+     * the rest of that tail is spent — swallowed, scroll and band untouched — until a reversal, a growing delta or quiet.
+     */
+    readonly wheelDy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly fade: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** K5a: the type of the specimen under the mouse while the drawer is out ("" — none): the hover that lifts it (flux). */
+    readonly hover: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    /**
+     * K5b — TAKING ONE (design-017 §9): the type whose copy a pointer has lifted off the board ("" — none): pressed on its specimen and
+     * moved past the slop, still inside the drawer. `takeU`/`takeV` the grab point (0 … 1 across the object as the board draws it — the
+     * spot under the finger stays that spot of the object), `takeX`/`takeY` the pointer as last seen (CSS px) — the copy follows it
+     * (flux). `handed` counts the takes handed to the desk: it bumps on the tick the copy leaves the drawer's open rect (the drawer slides
+     * away, `TrayIntent` spawns the insert ghost after the step); a take that ends without the bump was put back.
+     */
+    readonly take: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly takeU: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeV: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly takeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly handed: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /**
+     * design-018 §6 (R2) — THE FILTER: the tray category the drawer shows ("" — all), a tray entry's `category` string (`defineObject({
+     * tray: { category } })`). A fact of the view beside `open` — never durable, never synced (each tab its own). Writers: the op
+     * `setTrayCategory` (the bar's chips, the desk handle's door) and `trayLay` — which lays only that category's entries, zeroes the
+     * scroll and the band when it moves, and falls back to all ("") when the frame hangs none of it.
+     */
+    readonly category: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * K5b — the tray's IN-TICK request to hand a taken copy to the desk (design-017 §9; `HeldIntent`'s shape): the copy left the drawer, so
+ * the facade calls `ops.insertByDrag` once the step returns — the op spawns and enqueues, which no system does mid-tick. `type` the
+ * object type; `x`/`y` the pointer (CSS px) and `pointerId`/`device`/`buttons` its press, which the insert ghost's synthetic down takes
+ * over; `u`/`v` the grab point (the insert's `anchor` — no centre-snap); `homeX`/`homeY` the specimen's spot on screen (the insert's
+ * `home`, where a cancel flies the ghost back). `epoch` bumps per request.
+ */
+export declare const TrayIntent: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly type: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly pointerId: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly device: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"mouse" | "touch" | "pen">, true>;
+    readonly buttons: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly u: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly type: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly pointerId: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly device: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"mouse" | "touch" | "pen">, true>;
+    readonly buttons: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly u: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * Runtime, on the TRAY entity (design-017 §8; K5a): what the lattice law last laid (systems/tray.ts `createTrayLay`) — the drawer's
+ * width it laid for (CSS px, the renderer's word through the pose seam), the content's foot (board px — the scroll's range is that
+ * plus a pitch less the face, the renderer's to say) and how many lays so far (a renderer re-reads the specimens when it moves).
+ * design-018 §6 (R2): `present`, what the frame could hang before the category's filter — its entries' categories in the lay's
+ * order with their counts, JSON `[id, count][]` ("" for an entry that names none); `trayCategories` reads it.
+ */
+export declare const TrayContent: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly width: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly bottom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly laid: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly present: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly width: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly bottom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly laid: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly present: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * Runtime tag: a SPECIMEN (design-017 §8; K5a) — a kind hung on the pegboard tray: `ChildOf` the tray entity (which roots its
+ * runtime canvas), `PrefabId` the kind's widget type, `Position` board px (x from the drawer's left edge, y down from the board's
+ * top at scroll 0), `Size` its hang's, its entry's props over the widget's defaults. Spawned equipped (no capability tag, no
+ * rider, no behaviour — nothing acts on it) and under a canvas that is no frame, so never `Active`: the desk's stack never picks,
+ * selects, culls or saves one; never durable, never synced. A host that walks "the document's widgets" by `[Position, Size, PrefabId]`
+ * excludes it (`Not(Specimen)`) — a durable transaction over a runtime entity is refused ("op references an entity not in this store").
+ */
+export declare const Specimen: import("@vibecook/strata-ecs").Tag;
+/**
+ * Runtime, on a local pointer: a press the TRAY took (design-017 §4) — on the open drawer (`board`: a drag scrolls it), on the dimmed
+ * desk (`desk`: released unmoved, it closes the drawer); a closed drawer takes none (design-018 §5: the lip's `lip` press retired).
+ * Where it began (CSS px), the scroll it began from, whether it moved past the slop. K5b (§9): on a SPECIMEN (`specimen`: past the
+ * slop its copy lifts; out of the drawer it is handed to the desk) — its `type`, the grab point `u`/`v` across the object as drawn,
+ * the specimen's centre on screen `homeX`/`homeY`; and, once handed, the take CARRIED (`carry`: the insert ghost's drag is this
+ * pointer's — released back over the drawer as drawn, still sliding away, it is cancelled and the ghost flies home).
+ */
+export declare const TrayPress: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"desk" | "board" | "specimen" | "carry">, true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly scroll0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly type: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly u: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"desk" | "board" | "specimen" | "carry">, true>;
+    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly scroll0: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly moved: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly type: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly u: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly v: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly homeY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;

package/dist/types/packages/core/src/catalog/gesture.d.ts

@@ -145,6 +145,12 @@ export declare const RoutedResize: import("@vibecook/strata-ecs").Tag;
 export declare const RoutedConnect: import("@vibecook/strata-ecs").Tag;
 export declare const RoutedMarquee: import("@vibecook/strata-ecs").Tag;
 export declare const RoutedPan: import("@vibecook/strata-ecs").Tag;
+/**
+ * A move drag that STARTED with ⌥ held (latched by moveClaim, like a route): its release leaves a copy of every
+ * widget it carried where that widget lay, just under it, in the move's one transaction (*Marks on the Mat*'s
+ * keys — "⌥ as the drag starts leaves a copy behind"; design-015 D4a). Runtime, on the recognizer.
+ */
+export declare const LeavesCopy: import("@vibecook/strata-ecs").Tag;
 /** Draw-tool drag: the release rect creates a widget (design-005 §3, M10). */
 export declare const RoutedDraw: import("@vibecook/strata-ecs").Tag;
 /**
@@ -230,6 +236,39 @@ export declare const SnapState: import("@vibecook/strata-ecs").Component<import(
     readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
 }>;
+/**
+ * The dragged set's POST-MOVE UNION BOUNDS, on the Drag RECOGNIZER — the heat's
+ * one world fact (design-013 §5 rev 6; `draft/ground` GLOW.md §3).
+ *
+ * The overlap glow is CAST LIGHT: the lifted card's own SDF lights the target
+ * beneath it, so the compose reflector needs to know where the lifted set IS.
+ * That is not a new computation — `dropSystem` already unions the dragged
+ * widgets' post-move `Position + Size` every frame to run its spatial query,
+ * and then throws the number away. It writes it here instead, change-only over
+ * all four fields, and the heat gets its geometry for free.
+ *
+ * The rest of the heat needs no component at all: the tier is the tags
+ * `dropSystem` already writes (`OverlapCandidate` accept / `OverlapRejected`
+ * reject), the target is the `DropTarget` relation, and the presence spring and
+ * the held source are FLUX in the compose reflector's per-entity motion cache
+ * (§3) — never in the world.
+ *
+ * In the Drag prefab's essential set beside {@link SnapState}: present from
+ * spawn, zeroed, so writers never race an attach. Nothing clears it — the
+ * recognizer is reaped at terminal + 1 (`systems/cleanup.ts`), and the
+ * component dies with the entity.
+ */
+export declare const DragBounds: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly minX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly minY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly maxX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly maxY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly minX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly minY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly maxX: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly maxY: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
 /**
  * The down point + timestamp latched on the recognizer at spawn (design-003 §4.1). Bare: it must
  * carry the real down sample.
@@ -243,6 +282,18 @@ export declare const Down: import("@vibecook/strata-ecs").Component<import("@vib
     readonly y: "f64";
     readonly ms: "f64";
 }>;
+/**
+ * The card program's PART the pointer was on at the down (design-014, B3b) —
+ * attached at recognizer spawn from the pointer's `PointerPart` when it names
+ * one. Arbitration withholds the move route from a recognizer that carries
+ * it (a press on a control never lifts the card); the tap behaviour hands the
+ * tap to the app as a `PartTap` instead of selecting.
+ */
+export declare const DownPart: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly part: "string";
+}>, {
+    readonly part: "string";
+}>;
 /** On widgets, toggled O(1) when the drop candidate changes (design-001 §5.5). */
 export declare const OverlapCandidate: import("@vibecook/strata-ecs").Tag;
 /**

package/dist/types/packages/core/src/catalog/graph.d.ts

@@ -15,11 +15,11 @@ export declare const WirePorts: import("@vibecook/strata-ecs").Component<import(
 /** A widget port descriptor — spawned only for interaction (connect tool / hover proximity). */
 export declare const Port: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
     readonly id: "string";
-    readonly side: import("@vibecook/strata-ecs").EnumType<"s" | "w" | "n" | "e">;
+    readonly side: import("@vibecook/strata-ecs").EnumType<"w" | "n" | "e" | "s">;
     readonly index: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
 }>, {
     readonly id: "string";
-    readonly side: import("@vibecook/strata-ecs").EnumType<"s" | "w" | "n" | "e">;
+    readonly side: import("@vibecook/strata-ecs").EnumType<"w" | "n" | "e" | "s">;
     readonly index: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
 }>;
 /** port → widget. */

package/dist/types/packages/core/src/catalog/index.d.ts

@@ -31,3 +31,5 @@ export * from "./insert";
 export * from "./selection-presence";
 export * from "./camera-derived";
 export * from "./settings-resources";
+export * from "./surface";
+export * from "./desk";

package/dist/types/packages/core/src/catalog/pointer.d.ts

@@ -52,6 +52,18 @@ export declare const PointerWheel: import("@vibecook/strata-ecs").Component<impo
     readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly pinch: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
 }>;
+/**
+ * Runtime, on a local pointer whose press holds a `WheelTurns` widget (D3t-a — systems/press-wheel.ts): the wheel's deltas
+ * since the press, summed (never zeroed while the press lasts — a reflector reads it after the tick, when `PointerWheel` is
+ * gone); taken off when the press ends.
+ */
+export declare const PressWheel: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly dx: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly dy: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
 /** Touch-forgiveness radius, screen px (0 = exact, for mouse/pen). */
 export declare const PointerRadius: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
     readonly r: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
@@ -66,6 +78,36 @@ export declare const WentUp: import("@vibecook/strata-ecs").Tag;
 export declare const WentCancelled: import("@vibecook/strata-ecs").Tag;
 /** The down was consumed by a widget's own DOM handler — recognizers skip it. */
 export declare const HandledByWidget: import("@vibecook/strata-ecs").Tag;
+/**
+ * The PART of a card program under the pointer's exact hit (design-014, B3b):
+ * a control the ground draws — `close`, `lock`, whatever the registered
+ * program names — or `""` for the content, the frame band, the canvas. Written
+ * change-only by `picking` from the interaction stack's frame pick source (the
+ * ground's `pick()` over its last-drawn geometry); absent while no source is
+ * registered. A press that lands on a part is a CLICK on a control, never a
+ * move — the recognizer copies it into `DownPart` at spawn.
+ */
+export declare const PointerPart: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly part: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>;
+/**
+ * A tap that landed on a card program's PART (design-014, B3b): the select
+ * behaviour writes this instead of selecting — `seq` advances per tap, so a
+ * reflector (the ground's) observing it hands `(target, part)` to the app's
+ * `onPart`. One record: two part taps in one frame keep the last (a
+ * frame-rate event, accepted).
+ */
+export declare const PartTap: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly seq: "u32";
+    readonly target: "eid";
+    readonly part: "string";
+}>, {
+    readonly seq: "u32";
+    readonly target: "eid";
+    readonly part: "string";
+}>;
 /**
  * ONE-TICK: this tick's wheel deltas were ceded to scrollable widget content
  * (design-007 §3.5, petition I4) — the adapter let native scroll proceed and

package/dist/types/packages/core/src/catalog/selection-presence.d.ts

@@ -12,6 +12,13 @@ export declare const SnapTarget: import("@vibecook/strata-ecs").Tag;
  * path). Drag a member out and it simply stops being inside.
  */
 export declare const SweepsContained: import("@vibecook/strata-ecs").Tag;
+/**
+ * `interaction.wheelTurns` (design-015 §6's photo — PHOTO.md "wheel while holding turns the print about the finger";
+ * D3t-a): while a press holds this widget, the wheel on that pointer is the WIDGET's — neither the camera nor the
+ * recognizers hear it (`WheelHandled`) — and its deltas add up in the pointer's `PressWheel` for the widget's own
+ * behaviour to read (systems/press-wheel.ts).
+ */
+export declare const WheelTurns: import("@vibecook/strata-ecs").Tag;
 /**
  * `interaction.keyboard: "exclusive"` (design-007 §3.1, petitions I1/I4): while
  * a node inside this widget holds browser focus, the engine's keyboard surfaces

package/dist/types/packages/core/src/catalog/settings-resources.d.ts

@@ -1,8 +1,8 @@
 /**
  * Selection-chrome live mirror (2026-07-17): `liftScale` = the app's visual
  * drag-lift scale factor; `selectionChrome` inflates a Grab-bed member's rect
- * by it (about the rect center) so the union box always wraps the card the
- * user SEES, not just its ECS footprint.
+ * by it (about the rect center) so the resize handles wrap the card the user
+ * SEES, not just its ECS footprint (the union box it also inflated left at D7).
  */
 export declare const ChromeSettings: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
     readonly liftScale: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
@@ -24,6 +24,10 @@ export declare const GestureSettings: import("@vibecook/strata-ecs").Resource<im
     readonly multiTapSlopPx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly wheelZoomSensitivity: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly wheelZoomMaxStep: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    /** A plain wheel's job (design-015 §9, D-D11): "pan" (default, today) or the desk's "zoom" about the pointer. */
+    readonly wheel: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"pan" | "zoom">, true>;
+    /** "zoom" mode's law: `zoom · exp(−Δ · wheelZoomRate)` for a plain wheel and a pinch. f64: the prototype's 0.0016, exactly. */
+    readonly wheelZoomRate: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
 }>, {
     readonly tapMaxMs: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly tapSlopPx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
@@ -38,6 +42,10 @@ export declare const GestureSettings: import("@vibecook/strata-ecs").Resource<im
     readonly multiTapSlopPx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly wheelZoomSensitivity: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
     readonly wheelZoomMaxStep: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    /** A plain wheel's job (design-015 §9, D-D11): "pan" (default, today) or the desk's "zoom" about the pointer. */
+    readonly wheel: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"pan" | "zoom">, true>;
+    /** "zoom" mode's law: `zoom · exp(−Δ · wheelZoomRate)` for a plain wheel and a pinch. f64: the prototype's 0.0016, exactly. */
+    readonly wheelZoomRate: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
 }>;
 /** Pick radii + retarget dead-band live mirror (design-003 §3 L1 targeting). */
 export declare const PointerSettings: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
@@ -65,3 +73,21 @@ export declare const NavTransitionSettings: import("@vibecook/strata-ecs").Resou
 }>, {
     readonly responseMs: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
 }>;
+/**
+ * The zoom-through's live mirror (design-015 §9 — D2b; `settings.nav.zoomThrough`): `enabled`
+ * (off unless the app says), the dead band `in`/`out` (CSS px) and the gate `gate0` → `gate1`
+ * (the face's short side, CSS px). The `zoomThrough` system consumes it.
+ */
+export declare const ZoomThroughSettings: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly enabled: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly in: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly out: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly gate0: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly gate1: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>, {
+    readonly enabled: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly in: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly out: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly gate0: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly gate1: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>;

package/dist/types/packages/core/src/catalog/surface.d.ts

@@ -0,0 +1 @@
+export declare const Retained: import("@vibecook/strata-ecs").Tag;

package/dist/types/packages/core/src/doc/doc-commit-sink.d.ts

@@ -16,8 +16,24 @@
  */
 import type { DurableStore } from "@vibecook/strata-ecs/durable";
 import type { Entity, World } from "@vibecook/strata-ecs";
-import type { CommitSink } from "../engine/commit-sink";
+import type { CommitIntent, CommitSink } from "../engine/commit-sink";
+import { type GuardedTx } from "../guards/guarded-tx";
 export declare function drainCreatedSelections(world: World): Entity[];
-export declare function createDocCommitSink(store: DurableStore, world: World): CommitSink;
+/**
+ * A layer's word on a gesture's LANDING (design-001 §3 step 3a, widened 2026-09-26 by the desk's D7 #2): called inside the
+ * intent's transaction, after the intent's own writes, with the intent that made them — so what the layer adds (the desk's
+ * pin when a note is let go on a calendar's day, and the note at the day's slot) is the gesture's own undo step: one gesture,
+ * one transaction, one ⌘Z. A cancelled gesture never reaches a sink, so it never reaches an extender either. A throwing
+ * extender is reported and what it wrote before the throw stays in the step — the user's gesture never rolls back for a
+ * layer's fault.
+ */
+export type CommitExtender = (intent: CommitIntent, tx: GuardedTx) => void;
+export interface DocCommitSinkOpts {
+    /** Whole-intent final authority; undefined means reject without a transaction. */
+    readonly guard?: (intent: CommitIntent) => CommitIntent | undefined;
+    /** The layers' word on the landing, inside the same transaction (see {@link CommitExtender}). */
+    readonly extend?: CommitExtender;
+}
+export declare function createDocCommitSink(store: DurableStore, world: World, opts?: DocCommitSinkOpts): CommitSink;
 /** The version-gate's read-only posture: gestures run, nothing commits. */
 export declare function createReadOnlyCommitSink(): CommitSink;