@vibecook/ice 0.11.0 → 0.15.0-desk.1

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

@@ -0,0 +1,44 @@
+export declare const PHYSICS: {
+    /** How far a HELD note rises (§7's lift, as a height), and the scale it reads at (§7's 1.05, kept). */
+    readonly lift: {
+        readonly height: 12;
+        readonly scale: 1.03;
+    };
+    /**
+     * The contact shadow on the mat: Gaussian-blurred coverage of the sheet cast along the lamp's
+     * ground direction by its height — σ and alpha at contact, σ growing per unit of height, the
+     * alpha a held note casts, and the slope's cap (a note far from the lamp keeps a finite shadow).
+     */
+    readonly shadow: {
+        readonly sigma: 2.2;
+        readonly alpha: 0.36;
+        readonly sigmaPerUnit: 0.9;
+        readonly alphaHeld: 0.4;
+        readonly slopeMax: 2.2;
+    };
+    /**
+     * A SLAB's shadow (a notebook, a whiteboard, a mini mat): the note's penumbra swept down its height, with a contact
+     * term at its base (the tree-shadow design system's paper elevation, mat.css `--lift-1`) — theme.ts `BOOK.shadow` until K4a.
+     */
+    readonly slab: {
+        readonly penumbra: {
+            readonly sigma0: 2.2;
+            readonly sigmaPerHeight: 0.9;
+            readonly alpha: 0.36;
+        };
+        /** The contact term: σ, alpha, and the gap (world units) it has faded over once the object floats. */
+        readonly contact: {
+            readonly sigma: 1.1;
+            readonly alpha: 0.3;
+            readonly reach: 2.5;
+        };
+        readonly slopeMax: 2.2;
+    };
+    /** The lamp's fill on a face turned away from it; how far past a flat face one turned toward it may brighten. */
+    readonly light: {
+        readonly ambient: 0.5;
+        readonly cap: 1.35;
+    };
+    /** The sole-selection ring (DESIGN.md §7), CSS px, in `--vf-select`. */
+    readonly ring: 1.5;
+};

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

@@ -0,0 +1,44 @@
+import type { Lamp } from "./light";
+export interface Placement {
+    readonly cx: number;
+    readonly cy: number;
+    /** Radians in the mat's plane; positive turns clockwise on screen. */
+    readonly angle: number;
+    /** Units off the mat. */
+    readonly lift: number;
+    /** Radians about the book's own x (its head dips for +) and y (its fore-edge dips for +) axes, through its middle `zc` up. */
+    readonly tiltX: number;
+    readonly tiltY: number;
+    readonly zc: number;
+}
+/** A rigid transform: 3×3 rotation (row-major) and a translation. */
+export interface Rigid {
+    readonly r: readonly number[];
+    readonly t: readonly [number, number, number];
+}
+export declare function rigidOf(p: Placement): Rigid;
+export declare function toWorld(g: Rigid, x: number, y: number, z: number): [number, number, number];
+export declare function dirToWorld(g: Rigid, x: number, y: number, z: number): [number, number, number];
+export declare function toLocal(g: Rigid, x: number, y: number, z: number): [number, number, number];
+export declare function dirToLocal(g: Rigid, x: number, y: number, z: number): [number, number, number];
+/** Column-major 4×4 (WGSL's mat4x4f) of a rigid transform. */
+export declare function matrixOf(g: Rigid): Float32Array;
+/** The unit direction toward the lamp from a desk point, the ground slope capped (a book far from the lamp keeps a finite shadow). */
+export declare function lampDir(lamp: Lamp, x: number, y: number, slopeMax: number): [number, number, number];
+/**
+ * The shadow map's frame for a book: an orthographic view along the light, square, fitted to
+ * the book's world-space box (grown by `pad`). Out: the world → clip matrix (x, y in −1…1, z
+ * 0 nearest the lamp … 1), the world size of one texel at `res`, and the depth range (world).
+ */
+export declare function lightFrame(L: readonly [number, number, number], lo: readonly [number, number, number], hi: readonly [number, number, number], res: number, pad?: number, receivers?: readonly (readonly [number, number, number])[]): {
+    matrix: Float32Array;
+    texel: number;
+    depth: number;
+};
+/** A local box through the rigid transform → its world-space bounds. */
+export declare function worldBounds(g: Rigid, lo: readonly [number, number, number], hi: readonly [number, number, number]): {
+    lo: [number, number, number];
+    hi: [number, number, number];
+};
+/** The inverse of a rigid transform. */
+export declare function inverseOf(g: Rigid): Rigid;

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

@@ -0,0 +1,30 @@
+import { type ServiceKey } from "./services";
+import type { HandMetrics } from "./text";
+/** The hand's face as a print sets it: a family and a weight (the host loads it — desk/host/ink.ts `PEN_FACES`). */
+export interface PrintFace {
+    readonly family: string;
+    readonly weight: number;
+}
+/** What a pass takes a tile as: the host's canvas (TILE_TEX², straight alpha) — a type only. */
+export type TileSource = HTMLCanvasElement | OffscreenCanvas;
+/**
+ * THE PRINT'S RASTER (the host's seam, as `TextRaster` is the note's): the hand's face and its metrics (undefined while the
+ * face loads — the print waits rather than set the hand in a stand-in face), a version that turns over when a face lands,
+ * the type's widths, and a rectangle of a print drawn into a tile at `band` texels a unit.
+ */
+export interface PrintRaster<P = unknown> {
+    hand(): {
+        readonly face: PrintFace;
+        readonly metrics: HandMetrics;
+    } | undefined;
+    version(): number;
+    measure(font: string, text: string): number;
+    tile(print: P, x: number, y: number, w: number, h: number, band: number): TileSource;
+    /** The same rectangle as RGBA bytes, TILE_TEX² × 4, row 0 at the top — a fixture's (a rig reads the live print through it). */
+    bytes(print: P, x: number, y: number, w: number, h: number, band: number): Uint8Array<ArrayBuffer>;
+}
+/**
+ * The print raster as a desk SERVICE (K8a, kit/services.ts): lent by the object whose DOM half makes it (the desk calendar's,
+ * over the host's text raster) and `use`d by any kind that prints — `host.use?.(PRINT_RASTER)`.
+ */
+export declare const PRINT_RASTER: ServiceKey<PrintRaster>;

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

@@ -0,0 +1,34 @@
+import { type ServiceKey } from "./services";
+import type { HandLayout, HandMetrics } from "./text";
+/** r8 coverage rows, row 0 at the top — what the ink pages take (`PaperPass.write`). */
+export interface InkBitmap {
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly w: number;
+    readonly h: number;
+}
+export interface TextRaster {
+    /**
+     * The face's metrics in em (advances and kerning measured at 100 px, the box from the font's own
+     * ascent and descent) — `undefined` while the face loads: a sheet waits, blank, rather than write
+     * in a stand-in hand and re-write itself a moment later.
+     */
+    metrics(face: string): HandMetrics | undefined;
+    /** Bumped whenever a face lands: every layout keyed by it is laid again (the prototype's `fontVersion`). */
+    version(): number;
+    /**
+     * Tell `fn` whenever `version` moves — a face landed between frames (K7a: the desk wakes for it; a loop at rest polls no
+     * version). Returns an unsubscribe. Absent (a fake, a raster with fixed faces): the version never moves on its own.
+     */
+    onVersion?(fn: () => void): () => void;
+    /**
+     * Draw a layout's glyphs for a `box` (note units) at `band` texels per note unit: each glyph in its
+     * own frame — turned, scaled, at its pressure — over a faint stroke `bleed` note units wide (the pen's
+     * spread), the canvas's alpha read back as coverage.
+     */
+    raster(layout: HandLayout, face: string, box: {
+        readonly w: number;
+        readonly h: number;
+    }, band: number, bleed: number): InkBitmap;
+}
+/** The app's text raster as a desk SERVICE (K8a, kit/services.ts — `deskLayer({ text })` lends it): `host.use?.(TEXT_RASTER)`. */
+export declare const TEXT_RASTER: ServiceKey<TextRaster>;

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

@@ -0,0 +1 @@
+export declare const sdRoundBox: (px: number, py: number, bx: number, by: number, r: number) => number;

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

@@ -0,0 +1,11 @@
+/** The seeds as the cell stores them: base64 (no padding) of little-endian u32s. */
+export declare function encodeSeeds(seeds: ArrayLike<number>): string;
+/** The seeds a cell holds, as i32s (the layout's `seeds`) — whole seeds only; anything unreadable ends the run. */
+export declare function decodeSeeds(s: string): number[];
+/**
+ * The seeds a note's text is written with: the stored ones, index for index, and for every glyph
+ * past them the note's own `glyphSeed(noteSeed, i)` — exactly `text.length` of them.
+ */
+export declare function seedsFor(text: string, stored: string, noteSeed: number): number[];
+/** A fresh seed for a glyph just written — the host's randomness (`Math.random` in a browser). */
+export declare const freshSeed: () => number;

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

@@ -0,0 +1,34 @@
+/** A service's KEY (K8a): its name — the registry's identity — and, as a phantom, the type of what is lent under it. */
+export interface ServiceKey<T> {
+    readonly name: string;
+    /** Never set: carries `T` so `use(key)` answers the lent thing's own type. */
+    readonly __service?: T;
+}
+/** A key for a service of type `T` under `name` — namespace a plugin's own (`"clock.face"`); the desk's are bare words. */
+export declare const serviceKey: <T>(name: string) => ServiceKey<T>;
+/** One service as it is LENT: its key and the thing. Made by `service(key, value)`, which checks the pair's type. */
+export interface Lent<T = unknown> {
+    readonly key: ServiceKey<T>;
+    readonly value: T;
+}
+/** An entry to lend: `service(PRINT_RASTER, printRaster({ text }))`. */
+export declare const service: <T>(key: ServiceKey<T>, value: T) => Lent<T>;
+/** Where a service is found: `use(key)` answers what is lent under the key's name, or undefined — none on this desk. */
+export interface Services {
+    use<T>(key: ServiceKey<T>): T | undefined;
+}
+/**
+ * What an object's DOM half is handed to LEND (K8a): what is lent so far, and the desk's WAKE — a service whose work LANDS later (a
+ * face loaded, a picture decoded, a feed arrived) calls it when it does, so a sleeping loop steps and every kind is asked again (K7a's
+ * law: nothing is polled at rest; what arrives outside a step says so). The kinds that read the service see the landing in their tick.
+ */
+export interface LendHost extends Services {
+    wake(): void;
+}
+/** A registry of what has been lent so far (the desk layer's): `lend` adds entries — a name lent twice throws, naming both lenders. */
+export interface ServiceRegistry extends Services {
+    lend(entries: readonly Lent[], by: string): void;
+    /** The names lent, in lending order (a rig's and a test's witness). */
+    names(): readonly string[];
+}
+export declare function createServices(entries?: readonly Lent[], by?: string): ServiceRegistry;

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

@@ -0,0 +1,12 @@
+export declare function spring(x0: number, v0: number, target: number, hz: number, damping: number, dt: number, substeps?: number): [number, number];
+export declare function settled(x: number, v: number, target: number, eps?: number): boolean;
+/**
+ * The objects' springs: the hold's lift (the hover's rise rides the same numbers). The selection RING's spring is gone (D6): the
+ * kinds' own ring retired at D4a — the marks draw the selection — and a spring that only ever fed a zero kept the desk live for
+ * a second after every selection change (the D4a landing's owed item).
+ */
+export interface ObjectSprings {
+    readonly liftHz: number;
+    readonly liftDamp: number;
+}
+export declare const SPRINGS: ObjectSprings;

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

@@ -0,0 +1,93 @@
+import { type Entity, type GuardedTx, type World } from "../../../core/src/index";
+/** A board's data child: a stroke (`marker`, with `erase` for the eraser) or a wipe. */
+export declare const BoardStroke: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly tool: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly ink: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly tip: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly erase: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly points: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly speed: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly times: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly page: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly seed: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>, {
+    readonly tool: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly ink: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly tip: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly erase: import("@vibecook/strata-ecs").FieldSpec<"bool", true>;
+    readonly points: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly speed: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    readonly times: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly page: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly seed: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
+/** A stroke's cell as the board reads it (a tolerant reader: a string field strata hands back as null reads as its default). */
+export interface StrokeRow {
+    readonly tool: string | null;
+    readonly ink: string | null;
+    readonly tip: string | null;
+    readonly erase: boolean | null;
+    readonly points: string | null;
+    readonly speed: number | null;
+    readonly times?: string | null;
+    /** The notebook page it is on (D3t-b — v3): 2i + 1 a sheet's recto, 2i + 2 its verso; 0 (or absent, a v2 reader's) = none. */
+    readonly page?: number | null;
+    /** Its fibre seed (D7 #13 — v4): the one the live pen laid with; −1 (or absent, a v3 reader's) = the seed its position gives it. */
+    readonly seed?: number | null;
+}
+/** The durable id a stroke entity carries (`PrefabId`) — a data child, never a widget. */
+export declare const STROKE_TYPE = "desk.stroke";
+/**
+ * A stroke's durable prefab: its one cell and its `ChildOf` edge to the board (or the book) it is on. Version 2 (D3t-a) added
+ * `times`; a v1 stroke migrates to an empty one — it keeps its `speed` (the replay spaces it as before). Version 3 (D3t-b) added
+ * `page`; a v2 stroke — a board's — migrates to page 0. The Board and the Notebook declare it as their `data`, so the engine's
+ * catalog stamps, gates and migrates it with them.
+ */
+export declare const StrokePrefab: import("../../../core/src/index").Prefab;
+/** A row's fibre seed: its own (v4, the pen's) — or, for a row from before or without one, the `n`-th op's positional seed. */
+export declare const seedOfRow: (s: Pick<StrokeRow, "seed">, n: number) => number;
+/**
+ * A stroke as an author states one: the path in melamine units (a notebook's: page units, on its `page`) and its pace — each
+ * sample's time (ms from the first), or one speed; a wipe has no path.
+ */
+export interface StrokeSpec {
+    readonly tool?: "marker" | "wipe" | "pen";
+    readonly ink?: string;
+    readonly tip?: string;
+    readonly erase?: boolean;
+    readonly points?: readonly (readonly [number, number])[];
+    readonly times?: readonly number[];
+    readonly speed?: number;
+    /** The notebook page (D3t-b): 2i + 1 sheet i's recto, 2i + 2 its verso; absent = 0, a board's. */
+    readonly page?: number;
+    /** The fibre seed the pen laid with (D7 #13): stored, so the replay lays the same stamps whatever lands before it; absent = the position's. */
+    readonly seed?: number;
+}
+/** A path as the cell stores it: base64 (no padding) of LE f32 (x, y) pairs. */
+export declare function encodePoints(points: readonly (readonly [number, number])[]): string;
+/** A cell's path back: whole points only (a tolerant reader — anything unreadable ends the path). */
+export declare function decodePoints(s: string): Array<readonly [number, number]>;
+/** The samples' times as the cell stores them (D3t-a): base64 (no padding) of LE f32 milliseconds from the first sample. */
+export declare function encodeTimes(times: readonly number[]): string;
+/** A cell's times back (a tolerant reader: "" — an old stroke — is none). */
+export declare function decodeTimes(s: string): number[];
+/** A path's mean pace, world units/s — what a v2 stroke leaves in `speed` for a reader that knows no `times`; the default for a dot. */
+export declare function meanSpeed(points: readonly (readonly [number, number])[], times: readonly number[]): number;
+/** The row a spec is — defaults as the prefab has them; timed, its `speed` is the path's mean pace unless the spec names one. */
+export declare function strokeRow(s: StrokeSpec): {
+    tool: string;
+    ink: string;
+    tip: string;
+    erase: boolean;
+    points: string;
+    speed: number;
+    times: string;
+    page: number;
+    seed: number;
+};
+/** Lay a stroke on a board (or a book's page) — one entity, the object's newest child — inside the caller's transaction (one stroke, one undo step). */
+export declare function addStroke(tx: GuardedTx, board: Entity, s: StrokeSpec): Entity;
+/** The fibre seed of the `n`-th op a replay walks — the bench's `97.13 ×` the ops before it; the live pen seeds its stroke with the next. */
+export declare const strokeSeed: (n: number) => number;
+/** A stroke is in hand (a local pointer's press is a tool's): a history waits for it to land (BOARD.md §5 — the bench's `!this.open?.stroke`). */
+export declare function inking(world: World): boolean;

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

@@ -0,0 +1,142 @@
+export interface HandMetrics {
+    /** em above the baseline, em below — the face's own box. */
+    readonly ascent: number;
+    readonly descent: number;
+    /** A glyph's advance, em. */
+    advance(ch: string): number;
+    /** Optional pair kerning, em (negative tightens). */
+    kern?(a: string, b: string): number;
+}
+/** The hand's law (theme.ts `HAND`): the size in world units, and how far each glyph may stray. */
+export interface HandLaw {
+    /** The pen's size, world units (CSS px at zoom 1). */
+    readonly size: number;
+    /** Line pitch, × size. */
+    readonly lineHeight: number;
+    /** The margin the writing keeps from the paper's edge, world units. */
+    readonly pad: number;
+    readonly jitter: {
+        /** Each glyph's tilt, ± radians. */
+        readonly rot: number;
+        /** Each glyph's rise off the baseline, ± em. */
+        readonly rise: number;
+        /** Each glyph's size, ± fraction. */
+        readonly scale: number;
+        /** The pen's pressure — the ink's presence — between these. */
+        readonly press: readonly [number, number];
+    };
+    readonly wander: {
+        /** The line's slow drift, ± em. */
+        readonly amp: number;
+        /** …over this many em along the line. */
+        readonly period: number;
+    };
+}
+export interface HandGlyph {
+    readonly ch: string;
+    /** Its index in the text. */
+    readonly index: number;
+    /** The glyph's origin on its baseline, note units from the paper's top-left. */
+    readonly x: number;
+    readonly y: number;
+    /** The advance it takes, note units. */
+    readonly advance: number;
+    readonly rot: number;
+    readonly scale: number;
+    readonly press: number;
+    readonly line: number;
+}
+export interface HandLine {
+    /** Text indices [start, end). */
+    readonly start: number;
+    readonly end: number;
+    /** The baseline, note units. */
+    readonly y: number;
+    readonly width: number;
+}
+export interface HandLayout {
+    readonly glyphs: readonly HandGlyph[];
+    readonly lines: readonly HandLine[];
+    /** The caret's place BEFORE each index (and after the last): x, baseline y — `2 × (text.length + 1)`. */
+    readonly positions: Float32Array;
+    /** The writing ran past the bottom margin. */
+    readonly overflow: boolean;
+    /** The em, and the caret's height above and below the baseline. */
+    readonly em: number;
+    readonly ascent: number;
+    readonly descent: number;
+}
+/**
+ * Four floats in [0, 1) from a glyph's seed and its character — a 32-bit mix
+ * (Wang's hash twice, xorshift between) that changes wholly for a change of
+ * one bit in either. Deterministic across hosts: only integer arithmetic.
+ */
+export declare function hashHand(seed: number, code: number): readonly [number, number, number, number];
+/** A glyph's seed when the host carries none: the note's seed and the glyph's place. */
+export declare const glyphSeed: (noteSeed: number, index: number) => number;
+/**
+ * Lay `text` into a `box` (note units) under `law` with the face's `metrics`.
+ * `seeds[i]` is glyph i's own seed (the host's, carried through edits) — absent,
+ * it is derived from `noteSeed` and the index.
+ */
+export declare function layoutText(text: string, box: {
+    readonly w: number;
+    readonly h: number;
+}, law: HandLaw, metrics: HandMetrics, noteSeed?: number, seeds?: ArrayLike<number>): HandLayout;
+/** The caret before `index`: its left edge on the baseline, and its extent above and below. */
+export declare function caretAt(L: HandLayout, index: number): {
+    readonly x: number;
+    readonly y: number;
+    readonly above: number;
+    readonly below: number;
+};
+/** The box a glyph's ink can reach (its advance wide, the face's box tall, grown by the hand's jitter), note units — what the wipe reveals. */
+export declare function glyphBox(L: HandLayout, g: HandGlyph): {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+};
+/**
+ * The hand's seeds carried through an edit: the common prefix and suffix of
+ * the old and new text keep their seeds, the inserted run gets fresh ones from
+ * `fresh()`. Returns the new seeds and the inserted range [from, to).
+ */
+export declare function carrySeeds(oldText: string, oldSeeds: ArrayLike<number>, newText: string, fresh: () => number): {
+    seeds: number[];
+    from: number;
+    to: number;
+};
+/**
+ * The HAND — how the pen writes on the paper (STICKY.md §3; `paper/text.ts`). The face is
+ * the host's (the lab's Caveat, an OFL hand); its size is in world units; the jitter is
+ * each glyph's own — a tilt, a rise, a size, a pressure — and the line wanders slowly.
+ * The wipe is how a typed glyph arrives: revealed left to right in `wipeMs`, the pen's stroke.
+ */
+export declare const HAND: {
+    readonly size: 24;
+    readonly lineHeight: 1.16;
+    readonly pad: 16;
+    readonly jitter: {
+        readonly rot: 0.028;
+        readonly rise: 0.03;
+        readonly scale: 0.05;
+        readonly press: readonly [number, number];
+    };
+    readonly wander: {
+        readonly amp: 0.022;
+        readonly period: 9;
+    };
+    readonly wipeMs: 110;
+};
+/** The pens a hand writes with (STICKY.md §3) — names; the inks are the host's (the note's, and the desk calendar's lines). */
+export declare const PENS: readonly ["felt", "ball", "fountain", "red"];
+export type PenName = (typeof PENS)[number];
+/** A face: its family and weight, and the file it loads from (absent = the platform's own). */
+export interface FaceSpec {
+    readonly family: string;
+    readonly weight: number;
+    readonly url?: string;
+}
+/** The hand's faces by name (STICKY.md §3) — the families and weights; the app supplies the files (desk/host/ink.ts `penFaces`). */
+export declare const PEN_FACES: Readonly<Record<string, Omit<FaceSpec, "url">>>;

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

@@ -0,0 +1,8 @@
+import type { StructBuffer } from "../engine/struct";
+/** What a pass keeps beside a buffer it writes change-only: the bytes the GPU holds (sized to the buffer). */
+export declare const sentBytes: (size: number) => Uint8Array;
+/**
+ * Write `block` (its first `elements`, or all) into `buffer` at 0 only when its bytes differ from `sent` — which then holds
+ * them. Returns whether it wrote.
+ */
+export declare function writeChanged(queue: GPUQueue, buffer: GPUBuffer, block: StructBuffer<string>, sent: Uint8Array, elements?: number): boolean;

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

@@ -0,0 +1,39 @@
+import type { GlyphAtlasMeta } from "../mat/layout";
+export { type Box, type FadeIn, type Lod, lod, type View } from "../lattice/lod";
+export { type LineLaw, type LineWeight, lineWeight } from "../lattice/line";
+export type { RulerLaw } from "../lattice/ruler";
+export { DEFAULT_GRID, dressScale, type GridConfig } from "../mat/grid";
+export { type GlyphAtlasMeta, GLYPHS, litByOwn, type MatConfig, type MatFrame, MatUniforms, type PlateName, type RulerConfig, type SlotLight } from "../mat/layout";
+export type { Mat4 } from "../mat/projector";
+/** The silhouette a kind's marks go around (`ObjectKind.frame`) — the marks' own type (marks/layout.ts). */
+export type { MarkFrame } from "../marks/layout";
+/**
+ * A SLOT'S MAT as a kind's pass reads it: what the slot lends every kind drawn in it — the mat's animated silhouette (the
+ * lamp's gobo through the wind, this slot's own), the blue noise, the rulers' glyph atlas and its metrics, and the version
+ * of those assets (a pass rebinds when it turns over). `KindProgram.create` makes a kind's root pass on the root's; every
+ * other slot's pass is `spawn`ed onto that slot's. The ground's `CuttingMat` is the one there is; a kind never makes one.
+ */
+export interface MatPass {
+    /**
+     * The slot's ONE VIEW BLOCK (design-016 K-L3): a `MatUniforms` buffer the slot writes once a frame — the camera and box, the
+     * clocks, the lamp's gobo, the night, the portal chain, the objects' presence (`view.w`; the mat's own is `presence.x`) — which every kind pass binds at
+     * `@group(0) @binding(0)` as `u` (`kitWgsl`'s `view` piece). A kind never writes it and never keeps a copy.
+     */
+    readonly view: GPUBuffer;
+    /** The slot's animated gobo silhouette (r8, PLATE_SIZE²) — what an object's shadow and dapple sample. */
+    readonly silhouette: GPUTextureView;
+    /** The blue-noise tile (NOISE_SIZE², shared by every slot). */
+    readonly noiseTexture: GPUTexture;
+    /** The rulers' glyph atlas (a 1×1 empty cell until a host uploads one) and its metrics. */
+    readonly glyphTexture: GPUTexture;
+    readonly glyphs: GlyphAtlasMeta;
+    /** Turns over whenever a plate, the noise or the glyphs land: a pass holding a bind group over them rebinds. */
+    readonly assetVersion: number;
+    /**
+     * The view block's bytes as the slot last uploaded them, and the key of what the silhouette holds (K7a): a layered kind whose
+     * layer was drawn from the same bytes and key, with nothing of its own moved, lays it again without drawing it. Absent (a host's
+     * own mat): the layer is always drawn.
+     */
+    readonly viewBytes?: Uint8Array;
+    readonly silhouetteKey?: number;
+}

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

@@ -0,0 +1,15 @@
+import type { ComposeOptions } from "../engine/shader";
+import { type ShaderText } from "../shaders";
+export { type ShaderText, shaderText } from "../shaders";
+/** The kit's pieces of WGSL (below, in compose order). */
+export type KitWgslPiece = "view" | "portal" | "sdf" | "light" | "ruler" | "book";
+/** A name of the kit's WGSL: a piece, or another name for one (`lamp`, `gobo`, `night` and `noise` are `light`). */
+export type KitWgslName = KitWgslPiece | "lamp" | "gobo" | "night" | "noise";
+/** The .wgsl file behind each of the kit's module pieces — what a host's `ShaderText` is asked for. */
+export declare const KIT_WGSL_FILES: Readonly<Partial<Record<KitWgslPiece, string>>>;
+/**
+ * A kind's program with the kit's named pieces before its own: the kit's structs, then its modules (each labelled by its
+ * file, as a kind's own map labelled it), in the kit's order; then the kind's `own` structs, modules and entry. `text` is
+ * the host's (default: the generated module). An unknown name throws — a misspelt piece never composes silently.
+ */
+export declare function kitWgsl(names: readonly KitWgslName[], own: ComposeOptions, text?: ShaderText): ComposeOptions;

package/dist/types/packages/desk/src/lattice/line.d.ts

@@ -0,0 +1,15 @@
+import { type FadeIn } from "./lod";
+export interface LineLaw {
+    /** Half-widths at the window's top and a decade above it, DEVICE px (the reference's hairlines). */
+    readonly thin: number;
+    readonly thick: number;
+    /** Coverage alphas at the same two points. */
+    readonly alphaThin: number;
+    readonly alphaThick: number;
+}
+export interface LineWeight {
+    readonly halfWidth: number;
+    readonly alpha: number;
+}
+/** mat.wgsl `line_weight`, for a rung whose on-screen cell is `cellPx` (CSS px). */
+export declare function lineWeight(cellPx: number, fadeIn: FadeIn, law: LineLaw): LineWeight;

package/dist/types/packages/desk/src/lattice/lod.d.ts

@@ -0,0 +1,52 @@
+export declare const BASE_SPACING = 20;
+export declare const LOD_TARGET = 20;
+export declare const ZOOM_MIN = 1e-8;
+export declare const ZOOM_MAX = 100000000;
+export interface View {
+    readonly camX: number;
+    readonly camY: number;
+    readonly zoom: number;
+    /** CSS px — the attachment. */
+    readonly width: number;
+    readonly height: number;
+    /**
+     * The slot's BOX on the attachment, CSS px (PORTAL.md §2.3): what is
+     * culled — a mini mat's face for a nested slot.
+     * Absent = the whole attachment. Positions never change with it: a site
+     * lands where it lands under the camera; the box only decides which sites
+     * exist. A root slot's box is the attachment and every number is what it
+     * always was.
+     */
+    readonly box?: Box;
+}
+export interface Box {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** The effective box: the view's own, or the attachment. */
+export declare const boxOf: (v: View) => Box;
+/** The `box` record the uniform blocks carry: x, y, w, h. */
+export declare const boxValues: (v: View) => number[];
+export interface Lod {
+    readonly k0: number;
+    readonly fade: number;
+    readonly fine: number;
+    readonly mid: number;
+    readonly coarse: number;
+    readonly wrapPeriod: number;
+}
+export declare const wrap: (v: number, p: number) => number;
+/**
+ * How a rung presents itself: ONE size for every rung, and a rung's alpha is
+ * `smoothstep(fadeIn, cellPx)` of its OWN cell — so a decade wrap (the fine rung
+ * becoming the mid rung at the same cell) is continuous by construction, and
+ * nothing is drawn below `fadeIn[0]` px of pitch: the product's classic-grid law
+ * (`worldGrid.fadeIn`). The prototype's size LADDER (fine 0.55× · mid 0.85→1.25×
+ * · coarse 1.55×, the fine rung's alpha the decade fade — every tenth site bigger,
+ * a size pop at every wrap) was retired on 2026-09-04; nothing of it remains.
+ */
+export type FadeIn = readonly [number, number];
+export declare const smoothstep: (a: number, b: number, x: number) => number;
+export declare function lod(v: View): Lod;