@vibecook/ice 0.10.0 → 0.14.0

package/dist/types/packages/desk/src/theme.d.ts

@@ -0,0 +1,475 @@
+import { type MatLight } from "./mat/night";
+export type RGB = readonly [number, number, number];
+export type RGBA = readonly [number, number, number, number];
+export type ThemeName = "light" | "dark";
+/**
+ * Parse the CSS colour syntaxes tokens.css uses — `#rrggbb`, `rgb(r g b / p%)`,
+ * `rgba(r, g, b, a)` — into sRGB 0..1 + alpha. The swap chain is a plain
+ * 8-bit format, so what CSS shows is what the shader writes.
+ */
+export declare function cssColor(css: string): RGBA;
+export declare const rgb: (css: string) => RGB;
+/** A colour as the design kit names it, with its CSS value verbatim. */
+export interface TokenRef {
+    /** `--vf-*` = a tokens.css token (checked by name); anything else names its DESIGN.md source. */
+    readonly token: string;
+    readonly css: string;
+}
+/** The roles the ground paints from a product's palette, one token each, per theme. */
+export interface Palette {
+    readonly canvasBg: TokenRef;
+    readonly select: TokenRef;
+}
+/**
+ * The GRID's fade-in window — the lattice's one law for every rung (lod.ts `FadeIn`,
+ * line.ts): a rung fades in as its OWN cell grows from 10 to 20 CSS px, one octave
+ * under the decade's 20 px bottom, so zoom 1 lands on a full lattice. The mat's
+ * lines, the rulers' ticks and a mini mat's face all read it. (It was the magnet
+ * field's `fadeIn` — ICE's `worldGrid.fadeIn` — and is the one number of that set
+ * the mat kept.) And the DRESSING's floor (PORTAL.md §9, MINIMAT.md §5): a mini mat's inside is dressed
+ * for its arrival — its lattice as it will look when entered, scaled — but the window is never scaled
+ * below this share of itself, so a miniature's grid is never finer than half the desk's: a tiny mini
+ * mat shows its inside's major lines, not a haze of its minor ones. The live inside, the face's far
+ * LOD and a flight's two desks all take the same floor, so none of them can disagree.
+ */
+export declare const GRID: {
+    readonly fadeIn: readonly [10, 20];
+    readonly dressFloor: 0.5;
+};
+/**
+ * The CUTTING MAT — the ground's one grid: a hairline lattice on a green mat, ported
+ * from research/tree-shadow/prototype (the oryzo "hero desk"). Its colours are
+ * a material's, carried across both themes like an object's own colours;
+ * the numbers are the reference's, transcribed with their names. DESIGN.md has
+ * no cutting-mat row yet (it is a research port) — the token names below say
+ * where each value came from, and adding the material to the doc is the step
+ * before any of this leaves draft/.
+ *
+ * The reference draws its albedo through `srgbToLinear` and then `pow(2.2)`
+ * again, grades in HSB, and writes `pow(1/2.2)` straight to the swap chain: the
+ * mat on screen is the LINEARISED sage, a dark green. That chain is the look
+ * and is kept verbatim (mat.wgsl), so `ground` and `line` below are the values
+ * the chain STARTS from, not what a pixel measures.
+ */
+export declare const MAT: {
+    readonly ground: {
+        readonly token: "hero cuttingMatAlbedo `sage`";
+        readonly css: "#86a078";
+    };
+    readonly line: {
+        readonly token: "hero cuttingMatAlbedo `cream`";
+        readonly css: "#e8dcbe";
+    };
+    /** The colour a desk object's shadow casts ON the mat — the tree-shadow design system's `--cast-rgb` (mat.css: "the world's darkest value"). */
+    readonly cast: {
+        readonly token: "tree-shadow design mat.css `--cast-rgb`";
+        readonly css: "#0e1a0a";
+    };
+};
+/** The same, parsed — what a pass reads (nothing outside this file parses a colour). */
+export declare const MAT_COLORS: {
+    readonly ground: RGB;
+    readonly line: RGB;
+    readonly cast: RGB;
+};
+/**
+ * The mat's line law and the gobo's numbers (research/tree-shadow/prototype:
+ * shaders.js `cuttingMatAlbedo` · `sampleGobo` · `heroFrag`, scenes.js `hero`).
+ * Line widths are DEVICE px — the reference's hairlines are 0.5 / 0.75 of a
+ * framebuffer pixel; the alphas ride the engine's `fadeIn` window (line.ts).
+ */
+export declare const MAT_GRID: {
+    readonly line: {
+        readonly thin: 0.5;
+        readonly thick: 0.75;
+        readonly alphaThin: 0.14;
+        readonly alphaThick: 0.28;
+    };
+    /** ±8/255 on the green channel (0.4× red, 0.35× blue): static hash + drifting value noise + blue noise. */
+    readonly grain: number;
+    readonly gobo: {
+        readonly opacity: 1;
+        /** `getGoboBlurRatio(z, params) * 2.0` — the blur radius in plate texels at full softness. */
+        readonly blurTexels: 2;
+        /** heroFrag: `shade = mix(1, coaster·(0.5 + 0.5·gobo), 0.975)`; then HSB s += (1−shade)·0.1, v *= shade. */
+        readonly shadeMix: 0.975;
+        readonly darkFloor: 0.5;
+        readonly saturate: 0.1;
+        /** scenes.js `hero.params` — the blur ramp's two linear depths (metres from the projector). */
+        readonly sharp: 0.372991;
+        readonly soft: 0.79059;
+        /** The plates: R silhouette, G wind amp 1, B phase, A amps 2+3; each with its wind strength. */
+        readonly plates: {
+            readonly c: {
+                readonly strength: 0.38847005;
+            };
+            readonly b: {
+                readonly strength: 0.4630597;
+            };
+        };
+        readonly plate: "c" | "b";
+        /** gobo.js: `time += dt·(speed + 1 + r)` at speed 4; the lab's 0 = frozen. */
+        readonly wind: 5;
+        /** hero `mouseStrength` — radians of projector tilt per unit of smoothed pointer NDC. */
+        readonly tilt: 0.003;
+    };
+    /**
+     * The RULERS printed along the mat's top and left edges (RULER.md — James's mockup of
+     * 2026-09-23, measured at its 1.6×: a 41 px band under a 41 px margin, 12 px numerals,
+     * ticks 9 · 15 · 24, 1–2 px lines): one MODULE for the unprinted margin and one for the
+     * band; 1 px lines; the text 10 px mono (DESIGN.md §3's caption size, the product's
+     * `--vf-font-mono`) 5 px in from the outer line and 3 px after its tick; the ink the
+     * mat's own cream at these presences. The fine rung's ticks arrive over a 6 → 9 px pitch
+     * (a ruler's mm under its cm; at 5 the comb read busy) and a level's labels over 50 → 70 px,
+     * so labels sit 50–250 px apart at every zoom (lattice/ruler.ts).
+     */
+    readonly ruler: {
+        readonly band: 26;
+        readonly margin: 26;
+        readonly tick: readonly [6, 9, 15];
+        readonly line: 1;
+        readonly alpha: {
+            readonly frame: 0.55;
+            readonly tick: 0.85;
+            readonly label: 0.85;
+        };
+        readonly ticksFrom: readonly [6, 9];
+        readonly labelsFrom: readonly [50, 70];
+        readonly text: {
+            readonly size: 10;
+            readonly top: 5;
+            readonly gap: 3;
+        };
+        readonly maxChars: 9;
+    };
+    /**
+     * World → desk: the hero's view at its default height is 0.2227 m over the
+     * window's height (900 px in the reference shots), so one world unit (a CSS
+     * px at zoom 1) is 0.2227 / 900 m and the dapple spans the same screen at
+     * zoom 1. The mat's centre (the reference's coaster) is world (0, 0); the
+     * desk plane is `y = 0.7471` in the projector's frame.
+     */
+    readonly plane: {
+        readonly metresPerUnit: number;
+        readonly originX: -0.0105761;
+        readonly originZ: -0.0485146;
+        readonly deskY: 0.7471;
+    };
+};
+/**
+ * The NIGHT — the cutting mat in the dark theme (MAT.md). The mat is a material and
+ * keeps its sage and cream in both themes; what the theme changes is the LIGHT: the
+ * Sun by day (the reference's chain, verbatim), the Moon by night — and the eye that
+ * sees by it. Every number here is a choice with its source; `mat/night.ts` turns
+ * them into the shader's numbers.
+ */
+export declare const NIGHT: {
+    /** Full moonlight is REDDER than sunlight — ≈ 4100 K against the Sun's ≈ 5500 (Ciocca & Wang 2013); the blue of a moonlit scene is the eye's, not the light's. */
+    readonly kelvin: 4100;
+    /** A full Moon high in a clear sky: 0.1–0.3 lux on the ground, a million times under the Sun's. Where on the mesopic ramp the eye sits. */
+    readonly lux: 0.2;
+    /** The sky's share in the shadow — the same air scatters the same fraction of the Moon as of the Sun, ≈ 0.15–0.2 of the direct light at 45°. */
+    readonly fill: 0.18;
+    /** The rods' signal drawn as a colour: white pulled 18 % toward 485 nm — the low-purity blue the night-rendering literature gives scotopic vision (Jensen et al. 2000; Khan & Pattanaik 2004). */
+    readonly rodHue: {
+        readonly nm: 485;
+        readonly purity: 0.18;
+    };
+    /** Eigengrau — the "intrinsic grey" the eye reports with no light at all (the rods' own dark noise); the value the term is given. */
+    readonly eigengrau: {
+        readonly token: "Eigengrau (the dark's own grey)";
+        readonly css: "#16161d";
+    };
+    /** The appearance's one scale: the moonlit sage is drawn at HALF the sunlit one's displayed luminance — the million can't be shown; the adapted eye's report is. */
+    readonly litOverDay: 0.5;
+    /** The rods' own noise on the display: ±2/255, blue noise, achromatic. */
+    readonly snow: number;
+    /** CIECAM02's surround factor for the eye's adaptation to the Moon's colour: 0.8, a dark surround. */
+    readonly surround: 0.8;
+};
+/** The night's model, for a host that rebuilds the Moon from its own numbers (the desk's dev panel — D5a; the prototype's lab/params.ts). */
+export { dayLuminance, type MatLight, nightLight } from "./mat/night";
+/** Eigengrau, parsed — what a host hands `nightLight` (lab/params.ts rebuilds the night from its panel). */
+export declare const EIGENGRAU: RGB;
+/** The light the mat pass reads, per theme: the Sun (the reference's chain, bit for bit) by day, the Moon by night. */
+export declare const MAT_LIGHT: Record<ThemeName, MatLight>;
+/**
+ * The PORTAL's law (PORTAL.md §2.5, MINIMAT.md §5) — the live inside's GATE: a container's face shows its live inside
+ * only when its short side on screen is at least `lo` CSS px, fading in fully by `hi` (the rung law applied to portals).
+ * Under it the face is drawn by the container itself (the mini mat's lattice and chips); across it the nested desk fades
+ * in over them; past it the face is the nested desk, the flight's first frame. The engine's (nav/portal.ts
+ * `PORTAL_GATE`) since K4a — the mini mat's law (minimat/theme.ts) takes it by name, and the kinds' specs moved to their
+ * own folders (paper/, notebook/, board/, minimat/ `theme.ts`; the hand's law to kit/text.ts; what they share to
+ * kit/physics.ts).
+ */
+export declare const PORTAL: {
+    readonly gate: readonly [140, 220];
+};
+/**
+ * The MARKS — the desk's chrome as the renderer draws it over every object (stratum 5; design-015 §7,
+ * D4a): *Marks on the Mat* v2 (claude.ai artifact W9xB23bF9JkSoZhxqKpjaQ, sources
+ * `vibe-field/draft/desk-chrome/`; Q-a…Q-k agreed 2026-09-25), its proposed DESIGN.md §14 "the
+ * desk's hands". Every mark has one hand and every hand one ink: YOU draw in the PENCIL — the
+ * selection's focus brackets, a several's union and its members' ticks, the knobs, the vellum
+ * marquee, your extent on the rulers (`--vf-select`'s hue, OKLCH 252°, lifted to L .76: 3.62:1 on
+ * the lit mat) — with a dark KEYLINE under every stroke so it holds on paper and on the whiteboard;
+ * the DESK states facts about space in the LASER — the snap guides, the equal gaps and their numbers
+ * — which is light, so it is ADDED; and the TAPE is masking tape across a taped object's top corners,
+ * an attachment of the OBJECT (it zooms with it) and so moonlit by night, where the pencil and the
+ * laser are light and the Moon does not dim them (Q-k). Lengths are SCREEN px (the chrome keeps its
+ * size at every zoom) unless named; the numbers are chrome.js's `CHROME`/`INK` and its `drawSelection`
+ * · `drawMember` · `drawUnion` · `drawMarquee` · `drawGuides` · `flare` · `pill` · `drawRulerBand`,
+ * number for number, and desk.css's tape; the clocks are the page's §14 motion table (ms).
+ */
+export declare const MARKS: {
+    /** The inks, each with its token (the page's §14; desk.css; chrome.js `INK`). */
+    readonly inks: {
+        readonly pencil: {
+            readonly token: "--desk-pencil (Marks on the Mat §14, proposed)";
+            readonly css: "#79b5f8";
+        };
+        /** The keyline under a pencil stroke: the mat's cast at 34 % (`--desk-keyline`). */
+        readonly keyline: {
+            readonly token: "--desk-keyline — the tree-shadow design's `--cast-rgb`";
+            readonly css: "rgb(14 26 10 / .34)";
+        };
+        /** A resize knob's face: chrome.js `INK.paper`. */
+        readonly paper: {
+            readonly token: "chrome.js INK.paper";
+            readonly css: "#fffdf8";
+        };
+        readonly laser: {
+            readonly token: "--desk-laser (the bloom, added)";
+            readonly css: "#ff2e93";
+        };
+        readonly laserLine: {
+            readonly token: "--desk-laser-line";
+            readonly css: "#ff4fa3";
+        };
+        readonly laserCore: {
+            readonly token: "--desk-laser-core (5.94:1 on the lit mat)";
+            readonly css: "#ffd6ea";
+        };
+        /** The pencil pill's numerals: the tray's ink (`--desk-ink`, solid); the laser pill's: white. */
+        readonly tray: {
+            readonly token: "--desk-ink, solid (the tree-shadow design's `--ink`)";
+            readonly css: "#100904";
+        };
+        readonly white: {
+            readonly token: "chrome.js `pill` — the laser pill's numerals";
+            readonly css: "#ffffff";
+        };
+        readonly tape: {
+            readonly token: "--desk-tape";
+            readonly css: "rgb(238 228 204 / .88)";
+        };
+        /** The vellum's veil: cream by day, a cool milk by night (chrome.js `drawMarquee`). */
+        readonly vellumDay: {
+            readonly token: "chrome.js vellum, day";
+            readonly css: "rgb(255 250 238 / .11)";
+        };
+        readonly vellumNight: {
+            readonly token: "chrome.js vellum, night";
+            readonly css: "rgb(214 226 255 / .07)";
+        };
+    };
+    /** The keyline is this much wider than the stroke it lies under. */
+    readonly keyline: {
+        readonly grow: 2;
+    };
+    /** One object selected: the frame 6 out, brackets reaching 16 (≤ 30 % of a side, never under r + 2), 1.5 thick, the hairline between them one DEVICE px at 42 %, the corner r + 6 ≤ 10; the lock-on arrives from 8 further out, its presence full by 1/2.2 of the way; knobs (radius 3.5, a cast ring 1 wider at 28 %) where the object resizes; under 24 px on screen, one ring. */
+    readonly select: {
+        readonly gap: 6;
+        readonly reach: 16;
+        readonly share: 0.3;
+        readonly minOverR: 2;
+        readonly stroke: 1.5;
+        readonly hair: 0.42;
+        readonly radiusMax: 10;
+        readonly arrive: 8;
+        readonly rise: 2.2;
+        readonly knob: 3.5;
+        readonly knobShadow: 0.28;
+        readonly knobStroke: 1.5;
+        readonly collapse: 24;
+    };
+    /** A member of several: quiet ticks — 4 out, reaching 8, 1.25 thick, at 62 %; the union carries the weight. */
+    readonly member: {
+        readonly gap: 4;
+        readonly reach: 8;
+        readonly radiusMax: 8;
+        readonly stroke: 1.25;
+        readonly alpha: 0.62;
+    };
+    /** Several: one union, 10 out, square to the mat, its corner 4. */
+    readonly union: {
+        readonly gap: 10;
+        readonly radius: 4;
+    };
+    /** The vellum: its pencil edge at 80 % (one device px), brackets reaching 12 at its corners once both sides pass 14, the count riding the cursor at +14, +18. */
+    readonly marquee: {
+        readonly edge: 0.8;
+        readonly reach: 12;
+        readonly minSide: 14;
+        readonly count: readonly [14, 18];
+    };
+    /** A number the desk states: 10 px mono, 8 wider than its text, 15 tall, corner 3.5. */
+    readonly pill: {
+        readonly size: 10;
+        readonly pad: 8;
+        readonly height: 15;
+        readonly radius: 3.5;
+    };
+    /** The tray's name tags as LABEL TAPE (K5b, D-K5b.7 — marks/layout.ts `tagMarks`): the embosser's near-black tape and the pale plastic of its raised capitals. */
+    readonly label: {
+        readonly tape: "#17181b";
+        readonly letters: "#ecebe4";
+    };
+    /**
+     * The laser: a faint line wall to wall (3 px at 12 %, then 1 device px + 0.5 at 34 %, both added), and between the
+     * objects it aligns, 14 past them, the bloom (9 · 5 · 2.6 px at 7 · 16 · 32 %, added) under a 1.25 px line at 95 %
+     * with a 0.6 px core at 95 %; a centre is dotted (a dot every 4.51 px: the bloom 0.7 as wide, the line 2, the core 1);
+     * a new alignment strikes at 1.8×; a flare (radius 7) at every aligned corner; a gap, a 4 px bloom at 18 % under a
+     * 1.1 px line with 4 px ticks at its ends, its number in a laser pill on it (off it, under 26 px).
+     */
+    readonly laser: {
+        readonly wall: readonly [readonly [3, 0.12], readonly [0.5, 0.34]];
+        readonly bloom: readonly [readonly [9, 0.07], readonly [5, 0.16], readonly [2.6, 0.32]];
+        readonly line: 1.25;
+        readonly core: 0.6;
+        readonly alpha: 0.95;
+        readonly dotted: {
+            readonly period: 4.51;
+            readonly bloom: 0.7;
+            readonly line: 2;
+            readonly core: 1;
+        };
+        readonly past: 14;
+        readonly strike: 0.8;
+        readonly flare: {
+            readonly radius: 7;
+            readonly stop: 0.25;
+            readonly core: 0.9;
+            readonly mid: 0.55;
+        };
+        readonly bar: {
+            readonly bloom: readonly [4, 0.18];
+            readonly line: 1.1;
+            readonly tick: 4;
+            readonly pillFrom: 26;
+            readonly off: readonly [16, 14];
+        };
+    };
+    /** Your extent on the rulers (the mat's RULER band): a pencil wash at 16 %, its edges at 95 %, the edge coordinates 4 off them, 7 up from the band's inner line, over a 3 px cast halo at 55 %; a guide ticks the band in laser (1.5 px at 90 %, added). */
+    readonly ruler: {
+        readonly wash: 0.16;
+        readonly edge: 0.95;
+        readonly label: {
+            readonly gap: 4;
+            readonly lift: 7;
+            readonly halo: 1.5;
+            readonly haloAlpha: 0.55;
+        };
+        readonly tick: {
+            readonly width: 1.5;
+            readonly alpha: 0.9;
+            readonly inset: 3;
+        };
+    };
+    /** Masking tape (desk.css `.obj-tape`): two strips 60 × 17 (object units) crossing the top corners, 5 over the top edge and 20 past each side, turned 37°; fibres 1 in 3 at 10 % white, a light from above (18 % white → 4 % black); moonlit by night. */
+    readonly tape: {
+        readonly w: 60;
+        readonly h: 17;
+        readonly over: 5;
+        readonly past: 20;
+        readonly turn: 37;
+        readonly fibre: {
+            readonly every: 3;
+            readonly alpha: 0.1;
+        };
+        readonly sheen: readonly [0.18, 0.04];
+        readonly night: {
+            readonly saturate: 0.3;
+            readonly brightness: 0.46;
+        };
+        readonly press: 1.22;
+    };
+    /** The clocks, ms: the lock-on (on `--vf-ease-lift`) and the leave; several's union and its fade; the vellum's fold (`--vf-ease-island`); the strike; the tape pressed (the second strip 60 later) and lifted; the tape's GIVE — a drag that meets it shivers 2.2 px and settles. */
+    readonly clocks: {
+        readonly lockOn: 180;
+        readonly leave: 120;
+        readonly union: 220;
+        readonly unionFade: 120;
+        readonly fold: 240;
+        readonly strike: 160;
+        readonly tapePress: 240;
+        readonly tapeStagger: 60;
+        readonly tapeLift: 160;
+        readonly give: 360;
+    };
+    readonly give: {
+        readonly px: 2.2;
+        readonly rate: 44;
+    };
+};
+/**
+ * THE PEGBOARD TRAY (design-017 §6.5–§6.6; K3; design-018 §3) — the research board (research/sdf-pegboard, shader.js) under the desk's
+ * light, lying ON the mat. The face is its own render's (preview.jpg): lit flat, a flat face is drawn at this byte (the paper's law — a
+ * configured byte is the drawn byte). The punched edge keeps the research's edge/face albedo ratio. A hole shows the DESK as drawn under
+ * it (design-018 §3 — the research's plaster wall retired): the cavity is the share of the room's light that reaches the mat through a
+ * hole — at the hole's edge, at its heart, over what width (pitches) — kept near 1, so the densest hole is the mat's own shade under a
+ * leaf (one shadow language). The LAMP is the research's HOME lamp (D-K3.4, decided): from the upper left at 48°, so its light lays a
+ * patch through each slot on the mat, a shadow crescent along the lamp's side — its direction as the research states it (shader.js
+ * `lightDir`: azimuth from the eye's axis toward +x, elevation up the board, degrees), its angular radius the research's too (D-K3.5);
+ * the colour law and the room are the desk's.
+ */
+export declare const TRAY: {
+    readonly face: {
+        readonly token: "research/sdf-pegboard preview.jpg — the face, lit flat";
+        readonly css: "#cdb491";
+    };
+    /** shader.js FACE_ALB · EDGE_ALB, linear. */
+    readonly research: {
+        readonly face: readonly [0.42, 0.26, 0.135];
+        readonly edge: readonly [0.56, 0.41, 0.25];
+    };
+    readonly cavity: {
+        readonly edge: 0.9;
+        readonly heart: 1;
+        readonly width: 0.1;
+    };
+    readonly lamp: {
+        readonly azimuth: -36;
+        readonly elevation: 48;
+    };
+    readonly lampSize: 0.06;
+    /**
+     * K5a — the ACCESSORIES the specimens hang on (hooks, shelves, clips, rails): SKÅDIS's white powder coat warmed to sit on the
+     * hardboard; how far each stands off the board (pitches — its shadow's reach on the board under the lamp); the shadow's strength.
+     */
+    readonly accessory: {
+        readonly token: "SKÅDIS white, warmed";
+        readonly css: "#e8e3d9";
+        readonly height: {
+            readonly hook: 0.45;
+            readonly shelf: 0.6;
+            readonly clip: 0.3;
+            readonly rail: 0.4;
+        };
+        readonly shadow: 0.38;
+    };
+    /** K5a — a specimen under the mouse lifts this share of the hold's lift (its own kind's `lift`): its shadow grows. */
+    readonly hoverLift: 0.3;
+};
+/** Everything the passes read, as numbers. */
+export interface GroundTheme {
+    readonly name: ThemeName;
+    /** The clear colour — what shows where nothing is drawn (the mat covers it at rest). */
+    readonly canvasBg: RGB;
+    /** §2.5 the selection ring. */
+    readonly select: RGB;
+    /** The cutting mat's light (mat/night.ts): the Sun by day, the Moon by night. */
+    readonly matLight: MatLight;
+}
+/** A theme from a palette — the host's projection (lab/theme.ts builds VibeField's two). */
+export declare function themeFrom(name: ThemeName, p: Palette): GroundTheme;

package/dist/types/packages/desk/src/tray/carry.d.ts

@@ -0,0 +1,99 @@
+/** The carry's numbers: the lift's scale (widgetlab's ×1.06) and spring, the put-back's glide, the hand-off's patience, the grow's length. */
+export declare const CARRY: {
+    /** The copy at its full lift is this much larger than its specimen, about the grab point. */
+    readonly liftScale: 1.06;
+    readonly liftHz: 9;
+    /** A take put back glides home in this long (widgetlab's 240 ms), on the drawer's curve. */
+    readonly backMs: 240;
+    /** A handed copy waits this many frames for its ghost; none (the hand-off was refused), it is put back. */
+    readonly handFrames: 3;
+    /** The ghost grows to its own size in the drawer's slide (340 ms, its curve): it is itself as the drawer is gone. */
+    readonly growMs: 340;
+};
+/** The take as core holds it (`Tray`): the type lifted ("" none), the grab point across the object, the pointer, the hand-off count. */
+export interface CarryFacts {
+    readonly take: string;
+    readonly u: number;
+    readonly v: number;
+    readonly x: number;
+    readonly y: number;
+    readonly handed: number;
+}
+/** A specimen as the board drew it this frame: its type, the scale its kind drew it at, its object's rect on screen (CSS px). */
+export interface CarrySpecimen {
+    readonly type: string;
+    readonly zoom: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/** An insert ghost in the world: its entity and type, its rect (world, top-left), whether it flies home and how far (its tween, 0 … 1). */
+export interface CarryGhost {
+    readonly entity: number;
+    readonly type: string;
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    readonly retiring: boolean;
+    readonly progress: number;
+}
+/** The desk's camera (world → screen: `(p − cam) · zoom`). */
+export interface CarryCamera {
+    readonly x: number;
+    readonly y: number;
+    readonly zoom: number;
+}
+/**
+ * One carried object this frame. `ghost` — the insert ghost's entity (its rect is the world's, its props the world's), absent for a copy
+ * (its rect its natural size about the origin, its props what one taken is made with). The object's point `(u, v)` across its rect lies at
+ * `(px, py)` on screen, at `zoom` screen px per object unit; `lift` its hold (0 … 1).
+ */
+export interface CarryPose {
+    /** The carried thing's id — stable from its lift to its put-back or its hand-off (a copy's record key). */
+    readonly id: number;
+    readonly type: string;
+    readonly ghost?: number;
+    readonly u: number;
+    readonly v: number;
+    readonly px: number;
+    readonly py: number;
+    readonly zoom: number;
+    readonly lift: number;
+    /** The phase, a rig's witness. */
+    readonly phase: "lift" | "back" | "handing" | "grow" | "home";
+}
+export interface TrayCarry {
+    /**
+     * Step to `now` (frame clock, ms) with this frame's facts: the take (undefined: no tray), the specimens as drawn, the insert ghosts, the
+     * camera, the drawer's slide `p` (the ghost is the desk's again once it is its own size and the drawer is gone). Returns the poses.
+     */
+    step(now: number, facts: CarryFacts | undefined, specimens: readonly CarrySpecimen[], ghosts: readonly CarryGhost[], cam: CarryCamera, p: number): readonly CarryPose[];
+    /** The ghosts drawn here this frame — none of the desk's rows (the builder's `presented`). */
+    presented(): ReadonlySet<number>;
+    /** Something still moves: the next frame paints too. */
+    live(): boolean;
+    /** The types whose copy is up or on its way (their slots are made ahead of a hand-off — a composite kind's pass is made async). */
+    types(): readonly string[];
+    state(): {
+        readonly poses: readonly CarryPose[];
+        readonly handed: number;
+        readonly live: boolean;
+    };
+}
+export declare function createTrayCarry(): TrayCarry;
+/**
+ * A pose's VIEW: the camera under which the object's point `(u, v)` across `rect` (its own units — the world's for a ghost, its natural
+ * size about the origin for a copy) lies at the pose's pivot on screen, at its scale.
+ */
+export declare function carryView(pose: CarryPose, rect: {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}): {
+    readonly camX: number;
+    readonly camY: number;
+    readonly zoom: number;
+};