@vibecook/ice 0.14.0 → 0.15.0-desk.2

package/dist/types/packages/desk/src/host/layer.d.ts

@@ -1,12 +1,14 @@
-import { type Entity, type FramePickSlot, type HeldPoseSlot, type MarqueeBuffer, type NavFace, type NavGeometrySlot, type PresentationTransitionAdapter, type ReflectorDef, type TrayCategory, type TrayPoseSlot, type TrayScreenFrame, type WidgetType, type World } from "../../../core/src/index";
+import { type Entity, type FramePickSlot, type HeldPoseSlot, type MarqueeBuffer, type NavFace, type NavGeometrySlot, type PointPick, type PresentationTransitionAdapter, type ReflectorDef, type TrayCategory, type TrayPoseSlot, type TrayScreenFrame, type WidgetType, type World } from "../../../core/src/index";
 import { type Ambient, type AmbientMode, type AmbientPin } from "../compose/ambient";
 import { type DeskBuilder, type HeldBuild, type HoldPin, type SpatialSource } from "../compose/builder";
 import { type BudgetStats } from "../engine/budget";
 import { type RasterQueueStats } from "../engine/rasters";
 import type { RecordStoreStats } from "../engine/records";
+import { type HoldOptions } from "../hold/pose";
 import { type SelectionAnchor } from "../compose/marks";
 import { type DeskReflector, type DeskReflectorStats, type DeskWakes } from "../compose/reflector";
-import { Ground, type GroundFrameInputs } from "../ground";
+import { type KindFault } from "../faults";
+import { type CaptureOptions, Ground, type GroundFrameInputs } from "../ground";
 import type { KindProgram } from "../kind";
 import type { ObjectFlux } from "../kinds/world";
 import { type GridConfig } from "../mat/grid";
@@ -23,6 +25,7 @@ import { type MemoryLedger } from "../gpu-memory";
 import { type GpuProfiler } from "../gpu-profiler";
 import { type SubmitInstrument } from "../submit-instrument";
 import type { GroundTheme, Palette } from "../theme";
+import { type TrayOptions } from "../tray/drawer";
 import type { TrayFluxState, TrayPin } from "../tray/flux";
 import type { TrayLaid } from "../tray/pass";
 export interface DeskLayerOptions {
@@ -43,6 +46,27 @@ export interface DeskLayerOptions {
     readonly ambientIdleMs?: number;
     /** The root's grid at the mount: the mat's config (its gobo, its rulers) and the lattice's fade-in. */
     readonly grid?: GridConfig;
+    /**
+     * THE HAND as the host's chrome needs it (petition I20), read at the mount: the held object's reading fit keeps `top` CSS px under
+     * the view's top (`HOLD.top`, 56 — a phone keeps `HOLD.topPhone`) and `band` above its foot (`HOLD.band`, 72 — the held bar's band),
+     * and the held bar travels `travelMs` (M1; the bar is the host's — the anchor carries it, `HeldAnchor.travelMs`; absent, the bar's
+     * own). Each a finite number ≥ 0; absent, `HOLD`'s.
+     */
+    readonly hold?: HoldOptions;
+    /**
+     * THE DRAWER as the host's chrome needs it (petition I21), read at the mount: its `foot` inset, CSS px (0) — the pegboard's laid
+     * content ends this far above the board's bottom edge (the face's clip ends there, the veil lays the plain board over it and feathers
+     * out over `DRAWER.fade` above it — the header's mirror), where a host's line floats over the board; the scroll's range grows by it,
+     * so the last line is still reached; the board runs to its edge. A finite number ≥ 0; absent, 0.
+     */
+    readonly tray?: TrayOptions;
+    /**
+     * THE ROOM'S OTHER PEOPLE (petition I26), read at the mount: `false` — the host draws its peers itself (VibeField draws each by
+     * face, from `usePresencePeers`), so the host the layer is mounted in (`@ice/dom`'s `createDeskHost`, `<Desk>`) mounts no remote
+     * cursors — no plane, no reflector; the layer says so on its handle (`DeskLayerHandle.cursors`). The presence session,
+     * `usePresencePeers` and the local OS and open-hand cursors are untouched. Absent or `true`, the host draws them, as ever.
+     */
+    readonly cursors?: boolean;
     /** The objects' springs (springs.ts `SPRINGS`): the builder reads these numbers every frame, so a host that keeps the object may tune them live (the dev panel — D5a). */
     readonly springs?: ObjectSprings;
     /** The device pixel ratio the canvas is capped at (2). */
@@ -105,10 +129,17 @@ export interface MatPin extends AmbientPin {
  * nobody captured (out of memory, a validation or an internal error): the desk still draws what it can, but a frame — or every frame,
  * an attachment left invalid — may be lost, and the state never reads `ready` again on its own (D7); `failed` — no desk (refused, or
  * the device lost). `message` names the cause.
+ *
+ * `faults` (petition I24) — the KINDS this desk draws as MISSING, each its name and why, in the order they went: refused at create (a
+ * pass that would not compile, a pipeline that failed validation) or quarantined at three strikes (a `resolve`, `record`, `chip`, `hit`,
+ * `tick` or `due` that threw — src/faults.ts). Absent while none is. One kind's fault is that kind's: the state does not move for it
+ * (`ready` stays `ready`), its objects wear the desk's missing face, nothing of it is called again. Each is said ONCE — the status
+ * moves when a kind goes missing (`onStatus` hears it; a kind refused at the boot rides the boot's own `ready`), never again for it.
  */
 export interface DeskLayerStatus {
     readonly state: "pending" | "ready" | "degraded" | "failed";
     readonly message?: string;
+    readonly faults?: readonly KindFault[];
 }
 /** The mount context — the fields of `@ice/dom`'s `LayerContext` this layer reads, mirrored structurally (dom never imports the desk). */
 export interface DeskLayerContext {
@@ -117,6 +148,11 @@ export interface DeskLayerContext {
     };
     readonly world: World;
     readonly framePick?: FramePickSlot;
+    /**
+     * The interaction stack's exact pick out of the tick (`stack.pickAt`, petition I27 — what a press at a screen point would touch now,
+     * through `framePick` above): the handle's `pick` answers a host through it. Absent (a bare host), `pick` answers null.
+     */
+    readonly pickAt?: (sx: number, sy: number) => PointPick | undefined;
     /** The nav geometry seam (design-015 §9, D2b): the desk sets its word on its containers' drawn faces here, clears it at dispose. */
     readonly navGeometry?: NavGeometrySlot;
     /** The held pose seam (design-015 §8, D4b): the desk publishes where the object in hand is ON SCREEN as it drew it; core's held input maps every pointer through it. */
@@ -154,6 +190,26 @@ export interface SelectionSource {
     anchor(): SelectionAnchor;
     subscribe(listener: () => void): () => void;
 }
+/**
+ * The object under a screen point as the desk's own pick resolves it (petition I27 — `DeskLayerHandle.pick`): what a press there
+ * touches, so what a primary click there selects — the host selects it through the engine's ops (`ops.setSelection([entity])`) and
+ * reads its acts off the selection's anchor.
+ */
+export interface PickResult {
+    readonly entity: Entity;
+    /** Its object type (its `PrefabId`) — what the host names it by and finds its type with (`engine.catalog.widget(type)`). */
+    readonly type: string;
+    /**
+     * The canvas it lies in — the frame the pick is made in: the board root on the root desk, the container entered (a mini mat whose
+     * desk is the view); `NO_ENTITY` in a world with no document.
+     */
+    readonly canvas: Entity;
+    /**
+     * Its kind's PART under the point (design-014): `""` the object itself — its body or its frame, which a click selects; a named part
+     * (the calendar's roll, corner and foot) is the kind's own — a click there works the part and selects nothing.
+     */
+    readonly part: string;
+}
 /**
  * The desk's MAIN-THREAD time (D6): every flush of the layer's reflector — the kinds' ticks, the pull, the build and the
  * render when a frame is due — counted and timed since the mount; `frames` are the flushes that drew, `frameMs` their share.
@@ -168,6 +224,20 @@ export interface DeskLayerPerf {
     readonly kindTicks: Readonly<Record<string, number>>;
     /** The drivers asked (`idle`, then `follow`): none on a step a registered time alone started (K7a). */
     readonly driverAsks: number;
+    /** The mount's own cost as its boot went (petition I25). */
+    readonly boot: DeskLayerBoot;
+}
+/**
+ * THE MOUNT'S COST (petition I25 — a desk's kinds are compiled at its mount, so a host that changes them remounts, and may veil it):
+ * the boot's milestones, ms since the mount (the factory's call, on `performance.now()`'s clock), each absent until it happens — for
+ * good on a boot that failed. `device`: the device in hand (the adapter and the device asked for, or the engine's adopted); `compiled`:
+ * the passes compiled (`Ground.create` resolved — the status `ready`); `presented`: the first frame's GPU work done
+ * (`queue.onSubmittedWorkDone()` after its submit — the compositor's from then).
+ */
+export interface DeskLayerBoot {
+    readonly device?: number;
+    readonly compiled?: number;
+    readonly presented?: number;
 }
 /**
  * The pegboard tray's door (design-017; K3) — the app's `a` and a rig's hand: the facts through core's tray ops (the one writer beside
@@ -288,6 +358,11 @@ export interface DeskLayerHandle {
         available(): boolean;
     };
     dispose(): void;
+    /**
+     * Whether the host mounts the room's other people's cursors (petition I26): `deskLayer({ cursors })` as read at the mount, `true`
+     * when absent — `@ice/dom`'s `createDeskHost` reads it off the handle (its structural `LayerHandle.cursors`) before it registers them.
+     */
+    readonly cursors: boolean;
     /** The canvas in the ground slot. */
     readonly canvas: HTMLCanvasElement;
     /** The device is acquired and `Ground.create` resolved. */
@@ -304,6 +379,35 @@ export interface DeskLayerHandle {
     ground(): Ground | null;
     /** The theme changed (and, with it, the palette): the looks are remade, the next frame re-renders. */
     setTheme(theme: GroundTheme, palette?: Palette): void;
+    /**
+     * THE CAPTURE DOOR (petition I23 — the covers' still, the thumbnails, "Send to…"): the desk as the LAST PRESENTED frame showed
+     * it — the same camera, theme, selection marks, hand and tray (what to hide is the host's, by its own doors, before the call) —
+     * as an `ImageBitmap` of `rect` (CSS px of the view; the whole view when absent) at the view's dpr × `scale` (1; a thumbnail
+     * asks 0.25). Inside: that frame's inputs drawn ONCE MORE into a readable texture at the asked size and read back
+     * (`Ground.capture`) — never a copy kept of every frame, never a frame: the swap chain is not touched, the loop is not woken, no
+     * frame is counted (`redraws()`, `perf().frames`), and the memory ledger shows the still and its readback as a `capture` line of
+     * its own while they live and nothing after. Taken while the frame gate holds (`engine.frame.freeze`), it is the parked frame;
+     * live, the most recent. `undefined`, never a throw, while `status()` is `failed` or `degraded`, before the first frame has been
+     * presented, or when the device is lost mid-copy (a malformed option throws at the call). Captures serialize; one asked for the
+     * same picture (equal options, no frame since) while another is in flight resolves to that one's bitmap.
+     */
+    capture(opts?: CaptureOptions): Promise<ImageBitmap | undefined>;
+    /**
+     * THE DESK'S PICK (petition I27 — a host's right-click selects the object under the pointer before it grows the menu): the object
+     * at `point` (CSS px of the view, the container's top-left at 0, 0 — a pointer event's client point less the container's rect) as
+     * the desk's own pick resolves it. Inside: the interaction stack's exact pick (`stack.pickAt`, through the mount context) — the one
+     * body a press's `TouchesExact` is written by, never a second hit path — so the answer is what a primary click there selects: the
+     * topmost object by stratum and sibling order through its kind's mirror on the last frame's geometry, its PART reported; on a live
+     * mini mat's face the mini mat (its inside's objects are no members of this frame — entered, they pick with it as their canvas).
+     * Synchronous; reads the last frame's world — no redraw, no wake, no write; it never selects (the host decides). `null` over the
+     * bare mat and its rulers (printed on it), over what is not an object (a resize handle), while an object is in hand or the
+     * pegboard drawer is out (the desk inert to the pointer — D4b, design-017 §4), before the first frame, and while `status()` is
+     * `pending` or `failed` (`degraded` picks: the desk still draws, a click still selects). A point that is not two finite numbers throws.
+     */
+    pick(point: {
+        readonly x: number;
+        readonly y: number;
+    }): PickResult | null;
     /** The mat's config over the current one (the rulers, the gobo): the root's grid. */
     configureMat(mat: Partial<MatConfig>): void;
     /** The lattice's fade-in window. */
@@ -365,7 +469,7 @@ export interface DeskLayerHandle {
     ambient(): Ambient;
     /** The submit instrument on the layer's device — installed the first time it is asked for (K2, D-K2.1: never asked, the queue carries no wrapper), counting from then; undefined before the device. */
     submits(): SubmitInstrument | undefined;
-    /** The layer's own main-thread time since the mount (D6, design-015 §11.4's idle gate): a rig diffs two readings. */
+    /** The layer's own main-thread time since the mount (D6, design-015 §11.4's idle gate): a rig diffs two readings. And the boot's milestones (`boot`, petition I25). */
     perf(): DeskLayerPerf;
     /** The raster budget's ledger (D6): what the kinds' caches hold, by owner, against the cap; the evictions so far. */
     memory(): BudgetStats;
@@ -387,7 +491,9 @@ export interface DeskLayerHandle {
     /**
      * The desk's registered wake taken apart (K7a — "why is the desk awake?"): when each part is next due, on `performance.now()`'s
      * clock (`Infinity`: never on its own) — the reflector's, the drivers' (now while one follows), a kind woken, each kind's `due`,
-     * the tray's layers' let-go (`tray`, K7a over K5a) and the raster queue's waiting asks (`rasters`, K6b: now while any wait).
+     * the tray's layers' let-go (`tray`, K7a over K5a) and the raster queue's waiting asks (`rasters`, K6b: now while any wait). A
+     * MISSING kind (petition I24) is a row of `kinds` whatever it declares: `KIND_MISSING` (−1 — no time; it is never due, nothing of
+     * it runs), and `at` never counts it.
      */
     due(now: number): {
         readonly at: number;

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

@@ -4,9 +4,12 @@ export * from "./host/index";
 export * from "./compose/index";
 export * from "./kit/index";
 export * from "./object";
-export { type DataChildren, FLUX_REST, type HeldContext, type HeldToolDef, type InsideContext, isObjectKind, type KindDriver, type KindDriverHost, type KindHost, type KindLocal, numberProp, type ObjectContext, type ObjectDomHost, type ObjectFlux, type ObjectHit, type ObjectHost, type ObjectKind, type ObjectRect, type OpenBinding, rectFrame, rectOf, type RungContext, type StratumName, stringProp } from "./kinds/world";
-export { carryOf, focusOf, HELD_USER_REST, type HeldPose, type HeldUser, type HeldViewport, heldCamera, heldFrame, heldPose, HOLD, type HomePose, homePose, isNarrow, type ReadingTarget, readingTarget } from "./hold/pose";
+export { type DataChildren, FLUX_REST, type HeldContext, type HeldReadoutContext, type HeldToolDef, type InsideContext, isObjectKind, type KindDriver, type KindDriverHost, type KindHost, type KindLocal, numberProp, type ObjectContext, type ObjectDomHost, type ObjectFlux, type ObjectHit, type ObjectHost, type ObjectKind, type ObjectRect, type OpenBinding, rectFrame, rectOf, type RungContext, type StratumName, stringProp } from "./kinds/world";
+export { carryOf, focusOf, HELD_USER_REST, type HeldPose, type HeldUser, type HeldViewport, heldCamera, heldFrame, heldPose, HOLD, type HoldOptions, type HoldReserves, type HomePose, homePose, isNarrow, type ReadingTarget, readingTarget } from "./hold/pose";
 export { NO_DOCS, type TypingDocs, type WritableSession, writable } from "./docs";
+export { createKindFaults, faultText, KIND_MISSING, KIND_STRIKES, type KindFault, type KindFaults } from "./faults";
+export { MISSING_KIND, MISSING_OBJECT } from "./missing/object";
+export { isMissingRecord, missingFace, type MissingRecord } from "./missing/layout";
 export * from "./theme";
 export * from "./shaders";
 export { BLUE_NOISE_SIZE, blueNoise } from "./assets/blue-noise.gen";

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

@@ -23,12 +23,14 @@ export declare const STRATA: readonly StratumName[];
  */
 /**
  * The render a slot is prepared for (D7): the FRAME (the desk as it is), the COPY (the desk behind a carried object, made once
- * per stamp and blurred), or the HAND (K9 R4 — the carried object alone, prepared EVERY frame of the carry while the copy
- * stands). A pass that keeps state per render keeps the copy's apart; a pass whose residency asks are per prepare (the
- * pictures' details, the boards' pool) re-asks what it has bound under the hand, else the tick's step — seeing only the hand's
- * asks — would free every other detail on the desk behind it, a softness pop at every put-down.
+ * per stamp and blurred), the HAND (K9 R4 — the carried object alone, prepared EVERY frame of the carry while the copy
+ * stands), or a CAPTURE (petition I23, `ground.ts` `captureFrame` — the last presented frame's inputs drawn ONCE MORE into a
+ * readable texture at the asked scale, outside any frame; the desk's own frame stands as drawn). A pass that keeps state per
+ * render keeps the copy's apart; a pass whose residency asks are per prepare (the pictures' details, the boards' pool) re-asks
+ * what it has bound under the hand AND under a capture, else the tick's step — seeing only the hand's asks, or a thumbnail's
+ * coarser ones — would free every other detail on the desk behind it, a softness pop at every put-down.
  */
-export type RenderTarget = "frame" | "copy" | "hand";
+export type RenderTarget = "frame" | "copy" | "hand" | "capture";
 export interface SlotContext {
     /** The slot's camera and box (CSS px) and the device pixel ratio. */
     readonly view: View & {

package/dist/types/packages/desk/src/kinds/world.d.ts

@@ -1,4 +1,4 @@
-import type { Component, Entity, HeldToolDef, Relation, Tag, WidgetType, World } from "../../../core/src/index";
+import type { Component, Entity, HeldToolApi, HeldToolDef, Relation, Tag, WidgetType, World } from "../../../core/src/index";
 import type { TypingDocs } from "../docs";
 import type { RasterBudget } from "../engine/budget";
 import type { RasterQueue } from "../engine/rasters";
@@ -53,6 +53,14 @@ export type ObjectHit = "content" | "frame" | (string & {});
  * or — no `kind` — declared only (dim; a later slice builds it). `glyph` names one of the bar's.
  */
 export type { HeldToolDef } from "../../../core/src/index";
+/**
+ * What a kind's `open.readout` reads (petition I22): the READ side of what its held tools' acts are handed (core's `HeldToolApi` —
+ * the world, the object in hand, its props as the world holds them now) and the kind's own state on this desk (`local`, as `page`
+ * and `openness` read it: the spread a turn is heading for, the time a clock's hands show). A readout never writes.
+ */
+export interface HeldReadoutContext extends Pick<HeldToolApi, "world" | "entity" | "props"> {
+    readonly local: unknown;
+}
 /**
  * The kind's OPENING (design-015 §8; D4b) — what "pick it up" means for this kind. `extent`: the OPEN rect in the object's
  * own desk units, centred as its rect is and UNTURNED (the builder turns it with the object): a notebook's spread (twice the
@@ -64,7 +72,8 @@ export type { HeldToolDef } from "../../../core/src/index";
  * two-page extent that opens one page at a time on a portrait phone (Q-p); `page`: which of its two is in view there — 0 the
  * right (the default) … 1 the left, flux the view glides by (D3t-b: the notebook reads page by page). `tools`: the held bar's
  * slots (D3t-a: live — a mode or an action each); `tool`: the mode in hand when it is picked up, from its props (default: the first mode);
- * `swatches`: the colour a slot shows instead of its glyph (the board's four inks — the product's palette, through the look).
+ * `swatches`: the colour a slot shows instead of its glyph (the board's four inks — the product's palette, through the look), read
+ * with the anchor as `readout` is — a throw leaves the slots their glyphs, said once, never a strike (petition I24).
  */
 export interface OpenBinding {
     extent(ctx: Pick<ObjectContext, "rect" | "props">): ObjectRect;
@@ -75,6 +84,15 @@ export interface OpenBinding {
     readonly tools?: readonly HeldToolDef[];
     tool?(props: Readonly<Record<string, unknown>>): string;
     swatches?(look: unknown): Readonly<Record<string, string>>;
+    /**
+     * The kind's WORD IN HAND (petition I22 — MC-D9's readouts): where the hand is, said beside its tools — the notebook's "Page 2",
+     * the calendar's "September", a clock's time. A string, or read each time the selection's anchor is recomposed (the pickup, a
+     * mode taken up, a held tool's act run — every frame drawn while it is held) and surfaced as `HeldAnchor.readout`; `undefined`
+     * or "" — no word. A readout that throws is caught at the kind's boundary: the anchor keeps the tools and carries no word, and the
+     * desk says so once — never a strike against the kind (petition I24: the anchor is read at the host's rate and only in hand, and a
+     * word draws nothing of the desk).
+     */
+    readonly readout?: string | ((ctx: HeldReadoutContext) => string | undefined);
 }
 /**
  * What the builder hands the object IN HAND (D4b, beside its flux): the carry amount `e` (0 on the desk … 1 in hand — the

package/dist/types/packages/desk/src/kit/editor.d.ts

@@ -26,7 +26,8 @@ export interface EditorPlace {
 }
 /**
  * A LEASE on the ONE editor (D3t-c; K8a — any kind's): while lent, the textarea's value, keys, caret and blur are the lease's, and
- * it says where the textarea stands; another lease, a blur, `release`, or `live()` answering false ends it (`ended`).
+ * it says where the textarea stands; another lease, a blur, `release`, `live()` answering false or the editor's `dispose` (the desk
+ * unmounted — petition I25) ends it (`ended`).
  */
 export interface EditorLease {
     /** The TEXT PART this lease writes — its kind's declared `TextPart.part` ("note.body", "calendar.line"): what `lease()` names. */
@@ -74,6 +75,7 @@ export interface DeskEditor {
         readonly h: number;
         readonly angle: number;
     } | null;
+    /** The editor goes with its desk: a lease still held ends first (`ended` — a typing session commits), then the textarea leaves. */
     dispose(): void;
 }
 /**

package/dist/types/packages/desk/src/kit/hold.d.ts

@@ -1 +1 @@
-export { carryOf, HOLD, readingTarget } from "../hold/pose";
+export { carryOf, HOLD, type HoldReserves, readingTarget } from "../hold/pose";

package/dist/types/packages/desk/src/missing/layout.d.ts

@@ -0,0 +1,27 @@
+import type { ObjectRect } from "../kinds/world";
+import { type GroundTheme, type RGB } from "../theme";
+/** The face's record as the pass's WGSL reads it (shaders/missing/missing-pass.wgsl). */
+export declare const MissingFace: import("../engine").StructDef<"rect" | "ink" | "shape" | "mix">;
+/** What the missing face draws for one object: its box, its ink and its fade. `missing` brands it — the pass draws nothing else. */
+export interface MissingRecord {
+    readonly missing: true;
+    readonly cx: number;
+    readonly cy: number;
+    readonly hx: number;
+    readonly hy: number;
+    readonly ink: RGB;
+    readonly fade: number;
+}
+/** Is this record the missing face's? (A kind's own record handed to its missing pass — the frame before a quarantine took — is not.) */
+export declare const isMissingRecord: (r: unknown) => r is MissingRecord;
+/** The face of an object whose box is `rect` (centred, world units) under `theme`, at `fade` (1 whole … 0 gone). */
+export declare function missingFace(rect: ObjectRect, theme: Pick<GroundTheme, "name">, fade?: number): MissingRecord;
+/** The record's values by field — a record that is not the face's packs as nothing (fade 0: the vertex stage collapses it). */
+export declare function missingValues(r: unknown): {
+    rect: number[];
+    ink: number[];
+    mix: number[];
+    shape: number[];
+};
+/** The face's pick: the object itself (`content` — a tap selects it, a drag moves it) anywhere in its box; else a miss. */
+export declare function missingHit(g: ObjectRect, wx: number, wy: number): "content" | null;

package/dist/types/packages/desk/src/missing/object.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectKind, ObjectRect } from "../kinds/world";
+import { type MissingRecord } from "./layout";
+/** The name an object whose type has no kind is drawn under (a kind may not take it — ground.ts). */
+export declare const MISSING_KIND = "desk.missing";
+/** The missing face's kind: its program (the ground's own — never registered) and its world half. */
+export declare const MISSING_OBJECT: ObjectKind<ObjectRect, MissingRecord>;

package/dist/types/packages/desk/src/missing/pass.d.ts

@@ -0,0 +1,39 @@
+import { type RecordStoreStats } from "../engine/records";
+import type { KindExtra, KindPass, SlotContext } from "../kind";
+import type { MatPass } from "../kit/view";
+import type { ShaderText } from "../shaders";
+export declare class MissingPass implements KindPass<unknown> {
+    readonly name = "desk/missing";
+    private store;
+    private group;
+    private boundStore;
+    private boundAssets;
+    private count;
+    private readonly device;
+    private readonly shared;
+    private readonly mat;
+    private constructor();
+    /**
+     * The root's pass on `mat`, made NOW (no await — a quarantine asks for it mid-frame): its layout and its one pipeline (it is lit by
+     * nothing — the same in every slot). The desk's own WGSL, composed from the host's text; WebGPU compiles it before its first draw.
+     */
+    static make(device: GPUDevice, format: GPUTextureFormat, mat: MatPass, text?: ShaderText): MissingPass;
+    /** A slot's own faces on the shared pipeline, through `mat`'s view block. */
+    spawn(mat: MatPass): MissingPass;
+    prepare(_encoder: GPUCommandEncoder, _slot: SlotContext, records: readonly unknown[], extra?: KindExtra): number;
+    private rebind;
+    drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
+    /** The store's counters (a rig's witness) — nothing until the slot's first face. */
+    records(): RecordStoreStats;
+    dispose(): void;
+}
+/** A desk's missing faces (petition I24): a slot's own on its mat, at its first ask — the pipeline made at the desk's first. */
+export interface MissingFaces {
+    /** A slot's faces on `mat` (the desk's pipeline made now if this is the first). */
+    spawn(mat: MatPass): KindPass;
+    /** Has the desk made its pipeline (a face was ever asked for)? */
+    readonly made: boolean;
+    dispose(): void;
+}
+/** The missing faces of a desk on `device` — nothing made until the first `spawn` (then the pipeline, on the root's `mat`). */
+export declare function missingFaces(device: GPUDevice, format: GPUTextureFormat, mat: MatPass, text?: ShaderText): MissingFaces;

package/dist/types/packages/desk/src/missing/shaders.d.ts

@@ -0,0 +1,7 @@
+import type { ComposeOptions } from "../engine/shader";
+import { type ShaderText } from "../shaders";
+export declare const MISSING_SHADER_FILES: {
+    readonly entry: "missing/missing-pass.wgsl";
+};
+/** The missing face's program for a host's shader text (default: the desk's generated module). */
+export declare function missingShaders(text?: ShaderText): ComposeOptions;

package/dist/types/packages/desk/src/missing/slots.d.ts

@@ -0,0 +1,8 @@
+import type { KindPass } from "../kind";
+import type { SlotSet } from "../ground";
+import type { MissingFaces } from "./pass";
+/**
+ * Kind `name`'s entry in `s` becomes the desk's missing faces on the slot's mat (`faces` — the root's), under the kind's name and
+ * stratum. Returns the pass the entry held (the caller lets it go), or undefined when the slot holds no such kind, or the desk no faces.
+ */
+export declare function swapToMissing(s: SlotSet, name: string, faces: MissingFaces | undefined): KindPass | undefined;