@vibecook/ice 0.11.0 → 0.14.0

package/dist/types/packages/objects/src/board/board.d.ts

@@ -0,0 +1,104 @@
+import { type CameraState, type Viewport, type Lamp } from "../../../desk/src/kit/index";
+/** The board's numbers (theme.ts `BOARD`) — the engine's unless a host tweaks them. */
+export interface BoardLaw {
+    readonly spec: {
+        readonly width: number;
+        readonly height: number;
+        readonly frame: number;
+        readonly radius: number;
+        readonly thick: number;
+        readonly recess: number;
+    };
+    readonly lift: {
+        readonly height: number;
+        readonly scale: number;
+    };
+    readonly shadow: {
+        readonly penumbra: {
+            readonly sigma0: number;
+            readonly sigmaPerHeight: number;
+            readonly alpha: number;
+        };
+        readonly contact: {
+            readonly sigma: number;
+            readonly alpha: number;
+            readonly reach: number;
+        };
+        readonly slopeMax: number;
+    };
+    readonly focus: {
+        readonly pad: number;
+        readonly tray: number;
+        readonly minZoom: number;
+        readonly maxZoom: number;
+        readonly close: number;
+    };
+}
+export declare const DEFAULT_BOARD_LAW: BoardLaw;
+/** Where a board lies: its world centre and its outer size (world units). Boards stay square to the desk — an open one is drawn on under a camera that never turns. */
+export interface BoardRect {
+    readonly cx: number;
+    readonly cy: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** What moves: the hold's lift (0..1), the selection ring's presence (0..1), the presence itself (1 … 0 gone). */
+export interface BoardMotion {
+    readonly held: number;
+    readonly ring: number;
+    readonly fade: number;
+}
+export declare const BOARD_REST: BoardMotion;
+export interface BoardGeometry {
+    readonly centre: readonly [number, number];
+    /** The outer half extents as drawn (the hold's scale applied). */
+    readonly half: readonly [number, number];
+    /** The melamine's half extents and corner radius (inside the frame). */
+    readonly inner: readonly [number, number];
+    readonly innerR: number;
+    readonly frame: number;
+    readonly radius: number;
+    /** The slab: its height, the melamine's recess below the frame's top, how far its underside floats (the hold's rise). */
+    readonly thick: number;
+    readonly recess: number;
+    readonly lift: number;
+    readonly scale: number;
+    /** The shadow's ground offset per unit of height, world axes — away from the lamp, capped. */
+    readonly slope: readonly [number, number];
+    /** The unit direction TO the lamp, world axes (x right, y down the screen, z off the desk). */
+    readonly lamp: readonly [number, number, number];
+    readonly ring: number;
+    readonly alpha: number;
+}
+/** The melamine's corner: the frame's outer radius less its width, never sharper than this. */
+export declare const INNER_RADIUS_MIN = 1.5;
+export declare function resolveBoard(b: BoardRect, m: BoardMotion, lamp: Lamp, law?: BoardLaw): BoardGeometry;
+/** The outer silhouette's signed distance at a world point. */
+export declare const sdBoard: (G: BoardGeometry, wx: number, wy: number) => number;
+/** The melamine's signed distance at a world point. */
+export declare const sdSurface: (G: BoardGeometry, wx: number, wy: number) => number;
+export type BoardHit = "surface" | "frame" | "outside";
+/** What is under a world point: the melamine (drawn on when open), the frame, or nothing. */
+export declare function pickBoard(G: BoardGeometry, wx: number, wy: number): BoardHit;
+/** A world point in the melamine's own units: world units from its top-left (what a stamp carries). */
+export declare function toSurface(G: BoardGeometry, wx: number, wy: number): readonly [number, number];
+/** The melamine's size in world units at scale 1 — what its raster covers, whatever the hold's scale. */
+export declare const surfaceSize: (G: BoardGeometry) => readonly [number, number];
+/** The raster a melamine of this size takes at `density` texels per world unit (BOARD.ink.density). */
+export declare function rasterSize(surface: readonly [number, number], density: number): readonly [number, number];
+/** How far the slab's shadow can reach past the board, world units: the top's offset along the slope, and 2.5 σ of its penumbra. */
+export declare function shadowReach(G: BoardGeometry, law?: BoardLaw): number;
+export interface WorldBox {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/** The world rect the fragment may paint: the board and its shadow's reach, grown to take in `extra` (the pen in the hand, when it is shown). */
+export declare function quadOf(G: BoardGeometry, extra?: WorldBox, law?: BoardLaw): WorldBox;
+/**
+ * The camera an OPEN board is seen under: the whole board, `pad` CSS px clear on every side, in
+ * the view above the marker tray's `tray` px band — its zoom in the band, its centre at the
+ * centre of what the tray leaves. The focus glide (book/focus.ts `glideTo`) flies here.
+ */
+export declare function framing(b: BoardRect, vp: Viewport, law?: BoardLaw): CameraState;

package/dist/types/packages/objects/src/board/data.d.ts

@@ -0,0 +1,31 @@
+import { type StrokeRow, type StrokeSpec } from "../../../desk/src/kit/index";
+import type { RGB } from "../../../desk/src/index";
+import { type BoardOp } from "./history";
+export { addStroke, BoardStroke, decodePoints, decodeTimes, encodePoints, encodeTimes, meanSpeed, seedOfRow, STROKE_TYPE, StrokePrefab, type StrokeRow, strokeRow, strokeSeed, type StrokeSpec } from "../../../desk/src/kit/index";
+import { StrokeBuilder } from "./stroke";
+/** The dry-erase markers a board is written with (BOARD.md §3) — names; the inks are the host's palette. */
+export declare const MARKERS: readonly ["black", "blue", "red", "green"];
+export type MarkerName = (typeof MARKERS)[number];
+/** A marker's ink as the palette gives it: the colour (sRGB) and the coverage one pass lays. */
+export interface MarkerInk {
+    readonly color: RGB;
+    readonly opacity: number;
+}
+/**
+ * Feed a stroke's samples to the pen, as the hand did: the first is the press (`begin`), a sample that repeats its point exactly is
+ * the pen RESTING (`hold` — its bleed), any other a move, the last the lift (`end`). Timed (`times`, one per point), the samples keep
+ * their own clocks; else they are spaced by distance / `speed` (an old stroke — the bench's `sketch`, which never rests).
+ */
+export declare function feedStroke(builder: StrokeBuilder, points: readonly (readonly [number, number])[], times: readonly number[] | null, speed: number, upto?: number): void;
+/**
+ * The pen a spec is drawn with and its builder at seed `seed` — the replay's own choice (`boardOps`): the eraser's felt, or the
+ * marker in the palette's ink (the first it names when it names not this one) at the spec's tip; undefined = no ink to draw with.
+ */
+export declare function strokePen(s: StrokeSpec, markers: Readonly<Record<string, MarkerInk>>, seed: number): StrokeBuilder | undefined;
+/**
+ * A board's strokes as the history a replay walks — the bench's `sketch` (and the oracle's `opsOf`), stroke for stroke: each
+ * through the StrokeBuilder at the bench's seed (`strokeSeed` of the ops before it), its samples fed as the hand laid them
+ * (`feedStroke`), committed dry; a wipe clears what came before. An ink the palette does not name draws in the first it does
+ * (never a blank); no ink at all draws no marker.
+ */
+export declare function boardOps(rows: readonly StrokeRow[], markers: Readonly<Record<string, MarkerInk>>): readonly BoardOp[];

package/dist/types/packages/objects/src/board/history.d.ts

@@ -0,0 +1,33 @@
+import { type Tool } from "./stroke";
+export type BoardOp = {
+    readonly kind: "stroke";
+    readonly tool: Tool;
+    readonly stamps: Float32Array;
+    readonly ink?: string;
+} | {
+    readonly kind: "wipe";
+};
+export declare class BoardHistory {
+    private ops;
+    private cursor;
+    /** Bumps on every change — what a host compares to know the raster is stale. */
+    version: number;
+    /** Do something new: anything undone past the cursor is forgotten. */
+    push(op: BoardOp): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /** What is on the board now, in the order it was done. */
+    get done(): readonly BoardOp[];
+    /** What a replay needs: everything after the last wipe (a wipe clears all before it). */
+    get replay(): readonly BoardOp[];
+    /** Is there ink on the board? (A stroke after the last wipe — the eraser's count too: it may leave a ghost.) */
+    get inked(): boolean;
+    /** The board as a reader sees it: each stroke's tool, ink and path since the last wipe. */
+    read(every?: number): Array<{
+        tool: "marker" | "eraser";
+        ink: string | null;
+        path: Array<readonly [number, number]>;
+    }>;
+}

package/dist/types/packages/objects/src/board/kind.d.ts

@@ -0,0 +1,208 @@
+import { BoardPass } from "./board-pass";
+import { type BoardGeometry, type BoardLaw } from "./board";
+import { type MarkerInk, type StrokeSpec } from "./data";
+import type { BoardInstance } from "./layout";
+import { type PenState } from "./pen";
+import { type StrokeBuilder, type TipName } from "./stroke";
+import { type KindExtra, type KindPass, type KindProgram, type SlotContext, type Palette, type RGB, type TokenRef, type KindHost, type KindLocal, type ObjectKind } from "../../../desk/src/index";
+import { type MarkFrame, type MatPass, type ShaderText, inking } from "../../../desk/src/kit/index";
+import { type Entity, type HeldToolDef, type World } from "../../../core/src/index";
+/** The whiteboard's kind name — its key in the registry and in every slot's `objects`. */
+export declare const BOARD_KIND = "board";
+export declare class BoardKind implements KindPass<BoardInstance> {
+    /** The board pass itself: a host's door to the rasters (`ensure`, `lay`, `commit`, `replay`, `dry`) and the look (`look`, `chain`). */
+    readonly pass: BoardPass;
+    constructor(pass: BoardPass);
+    spawn(mat: MatPass): BoardKind;
+    tune(root: KindPass<BoardInstance>): void;
+    /** The pass's own `prepare`, argument for argument: the slot's camera, grid, clocks, the objects' presence, the light and the theme (its ring's colour) — and the records' keys (D6). */
+    prepare(_encoder: GPUCommandEncoder, s: SlotContext, records: readonly BoardInstance[], extra?: KindExtra): number;
+    dropped(): number;
+    /** Records [first, end) — a board whose raster is missing draws nothing (the pass counts in the list it was handed). */
+    drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
+    cardResources(): {
+        readonly version: number;
+        readonly resources: readonly (GPUBuffer | GPUTextureView | GPUSampler)[];
+    };
+    cardSlot(index: number): number;
+    records(): import("../../../desk/src/index").RecordStoreStats;
+    dispose(): void;
+}
+/** The whiteboard's program for a host's shader text: its passes made on the root's mat. */
+export declare function boardProgram(text: ShaderText): KindProgram<BoardInstance>;
+/** The whiteboard's silhouette for the desk's marks (D4a): its aluminium frame's outside as drawn, square to the mat. */
+export declare function boardFrame(G: BoardGeometry): MarkFrame;
+/**
+ * What the board's kind takes from the host's palette: its materials (BOARD.md — the melamine, the anodised frame, the
+ * marker's barrel, the eraser's felt and wooden back) and the dry-erase markers by name, each an ink and the coverage one
+ * pass lays. The product's (the theme gate), never the engine's.
+ */
+export interface BoardPalette extends Palette {
+    readonly board?: {
+        readonly surface: TokenRef;
+        readonly frame: TokenRef;
+        readonly barrel: TokenRef;
+        readonly felt: TokenRef;
+        readonly wood: TokenRef;
+    };
+    readonly markers?: Readonly<Record<string, TokenRef & {
+        readonly opacity: number;
+    }>>;
+}
+/** The board's look for a theme, parsed: the melamine and the frame a record takes, the pen's materials the pass takes, the markers' inks the replay takes, and each marker's CSS the held bar's swatch shows (by tool id). */
+export interface BoardObjectLook {
+    readonly surface: RGB;
+    readonly metal: RGB;
+    readonly pen: {
+        readonly barrel: RGB;
+        readonly felt: RGB;
+        readonly wood: RGB;
+    };
+    readonly markers: Readonly<Record<string, MarkerInk>>;
+    readonly swatches: Readonly<Record<string, string>>;
+}
+/** A marker's tool id in the held bar ("marker:blue"); the eraser's is `ERASER_TOOL_ID`. */
+export declare const markerToolId: (ink: string) => string;
+export declare const ERASER_TOOL_ID = "eraser";
+/** The ink a tool id names, or undefined (the eraser, anything else). */
+export declare const inkOfTool: (id: string) => string | undefined;
+export { inking };
+/** Is there ink on board `e` — a stroke (the eraser's too: it may leave a ghost) after its last wipe? */
+export declare function boardInked(world: World, e: Entity): boolean;
+/**
+ * The whiteboard's tools in hand (BOARD.md §5, *Marks on the Mat*'s contract: "four markers, eraser, undo, redo"; the tray merged
+ * into the held bar, Q-o): the four markers (`1`–`4`) and the eraser (`e`, a toggle — chosen again, the marker it took over from
+ * comes back) are MODES — core's `HeldTool`, the user's fact — whose cursor is none over the melamine (the pen draws itself);
+ * undo and redo are the DOCUMENT's history (a stroke is one transaction, D-D5) and wait for a stroke in hand to land; on keys
+ * alone, the tip (`t`: fine → bullet → chisel, the capped marker's durable `tip`) and the wipe (⌘⌫, one transaction — itself
+ * undoable, as the bench's was). The pen's own state is written off the undo stack: ⌘Z undoes ink, never a pick of the pen.
+ */
+export declare const BOARD_TOOLS: readonly HeldToolDef[];
+/**
+ * A board at rest as the bench draws it (`BoardDesk.instances` + `poseOf` with no board open), all but its raster: THE
+ * marker lying where a hand put it down — the pen's flux at rest (board/pen.ts: every hand term at e = 0, kept as the bench
+ * computes them) —, the world rect the fragment may paint (the board, its shadow, the pen's box), the eye straight over it
+ * (the parallax at rest).
+ */
+export declare function boardRest(G: BoardGeometry, w: number, h: number, tip: TipName, capInk: RGB, look: BoardObjectLook, law?: BoardLaw): Omit<BoardInstance, "id">;
+/**
+ * A board as drawn with its pen in whatever pose its flux has reached (D3t-a — board/pen.ts `penPose`): lying, taken up, in the
+ * hand at `at` (a desk point), the eraser rubbing there; the quad grown to take in both. At rest it is `boardRest`, byte for byte.
+ */
+export declare function boardPose(G: BoardGeometry, w: number, h: number, tip: TipName, ink: RGB, look: BoardObjectLook, pen: PenState, at: readonly [number, number] | null, law?: BoardLaw): Omit<BoardInstance, "id">;
+/**
+ * How far a board's drawing reaches past its rect, world units: the slab's shadow at full lift, or the resting pen's box
+ * (it lies near the bottom edge and its box is wide), whichever is further; the held scale.
+ */
+export declare function boardReach(law?: BoardLaw): number;
+/** What the hand is doing over a board in hand this frame, as the pen driver (objects/pen.ts) reads the world: where (a desk point), over the melamine or not, laying a stroke or not, with which tool and ink, and the pointer on screen (its velocity leans the pen). */
+export interface PenHand {
+    readonly at: readonly [number, number] | null;
+    readonly over: boolean;
+    readonly pressing: boolean;
+    readonly erasing: boolean;
+    /** The ink in hand (the marker's, or the one it lies down in while the eraser rubs); absent = the capped marker's. */
+    readonly ink?: string;
+    /** The pointer on screen, CSS px, and the clock (ms) it was read at. */
+    readonly screen?: readonly [number, number];
+    readonly t?: number;
+}
+/** A still's pen (a pinned hand): its desk point, pressed or hovering, the eraser or the marker, the ink. */
+export interface PenPin {
+    readonly x: number;
+    readonly y: number;
+    readonly press?: boolean;
+    readonly erase?: boolean;
+    readonly ink?: string;
+}
+/**
+ * The board's own state on one desk: each board's raster on the root pass, a cache of its strokes — and (D3t-a) what the hand
+ * does to it in hand: the stroke laid LIVE into its stroke layer, committed WET and drying, its entity adopted when it lands
+ * rather than replayed; the pen's flux and the hand it follows.
+ */
+export interface BoardInk extends KindLocal {
+    /** When the kind is next live (K7a — `KindLocal.due`, declared: the six built-ins all say). */
+    due(now: number): number;
+    /**
+     * The raster board `e` draws with (its id on the pass): made the first time, its children REPLAYED into it whenever
+     * their stamp turned over or the look changed — unless the turnover is the stroke the hand just committed (adopted: the
+     * raster holds it already, wet) —; a stroke in hand is laid again over a replay; a fading ghost keeps what it had. 0 before
+     * the pass is here. `zd` — device px a world unit where it is drawn (zoom × dpr): a raster made now is made at its ZOOM
+     * RUNG (K6a, `boardRung`); the pass's step raises it when the board grows on screen. K6b: a raster to MAKE (none held — never
+     * made, or evicted — or its density raised) is asked of the desk's frame raster queue when the host has one, `px` (screen px
+     * from the view's centre) its place: the board draws its old raster, its thumbnail, else its melamine bare until its turn.
+     */
+    raster(e: Entity, G: BoardGeometry, look: BoardObjectLook, ghost: boolean, zd?: number, px?: number): number;
+    /** How many replays since the desk was made (a rig's witness). */
+    replays(): number;
+    /** Board `e`'s raster on the pass (`BoardPass.readInk` reads it — a rig's witness); undefined before it is met. */
+    rasterOf(e: Entity): number | undefined;
+    /** Board `e`'s residency (K6a — a rig's witness): its raster's density (null: evicted or not made), whether the pool binds it this frame, whether its thumbnail is cut. */
+    residency(e: Entity): {
+        readonly density: number | null;
+        readonly bound: boolean;
+        readonly thumb: boolean;
+    } | undefined;
+    /**
+     * The boards' residency in sum (K9 R5 — rig:scale's row): how many boards the desk has, how many were ever inked (replayed),
+     * how many keep a far-LOD thumbnail (every inked board should, until the array's layer cap reclaims one — K9 R1), hold a raster,
+     * are bound in the pool this frame; the thumbnail array's layers in use and capacity.
+     */
+    stats(): {
+        readonly boards: number;
+        readonly inked: number;
+        readonly thumbed: number;
+        readonly rastered: number;
+        readonly bound: number;
+        readonly layers: number;
+        readonly capacity: number;
+    };
+    /** The stroke in hand on `e`: the builder's stamps since the last call into the stroke layer (sent at the next prepare). */
+    lay(e: Entity, builder: StrokeBuilder): void;
+    /** The lift: the stroke in hand laid into the ink and marked WET; its entity (its cell's `points`) is adopted when it lands. */
+    commit(e: Entity, points: string): void;
+    /** A stroke in hand abandoned (or its transaction refused): its stamps dropped, the raster replayed from the children. */
+    cancel(e: Entity): void;
+    /** The stroke being laid on `e` — its ink (LINEAR) and whether it erases — for the record; undefined when none. */
+    laying(e: Entity): {
+        readonly color: RGB;
+        readonly erase: boolean;
+    } | undefined;
+    /** The hand over board `e` this frame (the pen driver's word). */
+    hand(e: Entity, h: PenHand): void;
+    /** Pin the hand for a still (`undefined` unpins): the pen sits where the pin says, its springs snapped. */
+    pinPen(e: Entity, pin: PenPin | undefined): void;
+    /** The pen's flux of board `e` (a rig's witness). */
+    penOf(e: Entity): PenState | undefined;
+    /** The world half's: the hand over `e` as the record reads it (the pin's, else the driver's), and the pen's flux. */
+    handFor(e: Entity): {
+        readonly hand: PenHand | undefined;
+        readonly pen: PenState;
+        readonly pinned: boolean;
+    };
+    /** A pen still moving (the record says so): the next tick asks a frame. */
+    moving(e: Entity): void;
+    /**
+     * A STILL's ink on board `e` (a rig's door — the oracle's `wet`/`live` board, D3t-a): after its children replayed, `wet` laid
+     * LIVE and committed wet, then `live` mid-draw — its first `upto` samples in the stroke layer, the pen never lifted — each at the
+     * seed of the op it would be. False before the board's raster is here.
+     */
+    sketch(e: Entity, s: {
+        readonly wet?: StrokeSpec;
+        readonly live?: StrokeSpec & {
+            readonly upto: number;
+        };
+    }): boolean;
+    /** Hold the ink still (a still): no drying, no frame asked for a stroke in hand. */
+    pinStill(on: boolean): void;
+}
+/** The board's `local()`: rasters by entity, released when the builder forgets a board. */
+export declare function createBoardInk(host: KindHost): BoardInk;
+export interface BoardKindOptions {
+    /** The host's shader text; the generated module unless a host says. */
+    readonly text?: ShaderText;
+    /** The board's numbers (theme.ts `BOARD`) — the engine's unless a host tweaks them. */
+    readonly law?: BoardLaw;
+}
+/** The whiteboard's kind, whole (kinds/world.ts `ObjectKind`): the program, and the world half on the bench's laws. */
+export declare function boardKind(opts?: BoardKindOptions): ObjectKind<BoardGeometry, BoardInstance, BoardObjectLook>;

package/dist/types/packages/objects/src/board/layout.d.ts

@@ -0,0 +1,102 @@
+import type { RGB } from "../../../desk/src/index";
+import type { BoardGeometry, WorldBox } from "./board";
+export declare const Board: import("../../../desk/src/engine/index").StructDef<"ring" | "lamp" | "tier" | "tool" | "pen" | "frame" | "surface" | "inner" | "centre" | "half" | "quad" | "lift" | "alpha" | "slope" | "radius" | "thick" | "eraser" | "sheen" | "texels" | "innerR" | "recess" | "density" | "wet" | "laying" | "scale" | "metal" | "penPose" | "penInk">;
+export declare const BoardUniforms: import("../../../desk/src/engine/index").StructDef<"light" | "shadow" | "shadow2" | "select" | "pen" | "felt" | "block" | "castTint" | "sheen" | "mel" | "lip" | "glint" | "barrel" | "wood" | "pen2" | "block2">;
+/** One footprint of the pen (stroke.ts `STAMP_FLOATS` — the same eight floats, in the same order). */
+export declare const Stamp: import("../../../desk/src/engine/index").StructDef<"size" | "s" | "seed" | "dir" | "pos" | "flow">;
+export declare const StampUniforms: import("../../../desk/src/engine/index").StructDef<"felt" | "tip" | "tex" | "lanes">;
+export declare const InkUniforms: import("../../../desk/src/engine/index").StructDef<"color">;
+export declare const MAX_BOARDS = 64;
+/**
+ * THE marker of a board, in whatever pose it is in: lying capped on the melamine, in the hand at
+ * the pointer with its cap posted, or anywhere between as it is picked up or put down (lab/board.ts
+ * moves it; the shader draws it). Heights are over the melamine.
+ */
+export interface BoardPen {
+    /** The nib's end, world units. */
+    readonly x: number;
+    readonly y: number;
+    /** Radians: the direction from the nib along the barrel. */
+    readonly angle: number;
+    /** The axis' height over the melamine at the nib's end, and how steeply it rises along the barrel. */
+    readonly height: number;
+    readonly rise: number;
+    /** Where the cap is: 0 on the nib … 1 posted on the back. */
+    readonly cap: number;
+    /** The nib's half-width (the tip in use). */
+    readonly nib: number;
+    readonly presence: number;
+    /** Its colour as it looks (sRGB). */
+    readonly ink: RGB;
+}
+/** The eraser in the hand of an open board. */
+export interface BoardEraser {
+    readonly x: number;
+    readonly y: number;
+    readonly height: number;
+    readonly presence: number;
+}
+/** One board for the pass: its geometry, its materials, its raster, and what is on and over it this frame. */
+export interface BoardInstance {
+    /** Its raster (BoardPass.ensure) — the ink the melamine shows. */
+    readonly id: number;
+    readonly geometry: BoardGeometry;
+    readonly surface: RGB;
+    readonly metal: RGB;
+    /** The world rect it may paint (board.ts `quadOf`). */
+    readonly quad: WorldBox;
+    /** The eye's offset over the board, −1..1 each way (the pointer's parallax); absent = straight over its centre. */
+    readonly sheen?: readonly [number, number] | undefined;
+    /** The stroke being laid: its ink (LINEAR) and whether it erases. */
+    readonly stroke?: {
+        readonly color: RGB;
+        readonly erase: boolean;
+    } | undefined;
+    readonly pen?: BoardPen | undefined;
+    readonly eraser?: BoardEraser | undefined;
+    /**
+     * The pen's MATERIALS (a marker's barrel, the eraser's felt and back) when the record was made WITHOUT the desk's local — a tray
+     * specimen (K5b): nobody else sets them on the pass that draws it (the local's raster sets the root's, and only for a desk board
+     * drawn), so the specimen carries its look's; else the one its slot's pass copied from the root showed whatever the last desk board
+     * left there — black before any was drawn (an order-dependent still). Absent: the pass's own.
+     */
+    readonly materials?: {
+        readonly barrel: RGB;
+        readonly felt: RGB;
+        readonly wood: RGB;
+    } | undefined;
+}
+export declare function boardValues(b: BoardInstance, raster: {
+    readonly size: readonly [number, number];
+    readonly density: number;
+    readonly wet: boolean;
+}, tier?: readonly [number, number, number, number]): {
+    centre: readonly [number, number];
+    half: readonly [number, number];
+    inner: readonly [number, number];
+    slope: readonly [number, number];
+    sheen: readonly [number, number];
+    texels: readonly [number, number];
+    frame: number;
+    radius: number;
+    innerR: number;
+    thick: number;
+    recess: number;
+    lift: number;
+    alpha: number;
+    ring: number;
+    density: number;
+    wet: number;
+    laying: number;
+    scale: number;
+    lamp: number[];
+    quad: number[];
+    surface: number[];
+    metal: number[];
+    tool: number[];
+    pen: number[];
+    penPose: number[];
+    penInk: number[];
+    eraser: number[];
+    tier: number[];
+};

package/dist/types/packages/objects/src/board/object.d.ts

@@ -0,0 +1,7 @@
+/** The dry-erase markers a board is written with (BOARD.md §3) — names; the inks are the host's (board/data.ts). */
+export { MARKERS, type MarkerName } from "./data";
+/** The marker's tips (board/stroke.ts `TIPS`). */
+export declare const TIPS: readonly ["fine", "bullet", "chisel"];
+/** The board's durable type id. */
+export declare const BOARD_TYPE = "desk.board";
+export declare const Board: import("../../../core/src/index").WidgetType;

package/dist/types/packages/objects/src/board/pen.d.ts

@@ -0,0 +1,71 @@
+import type { RGB } from "../../../desk/src/index";
+import type { BoardGeometry, WorldBox } from "./board";
+import type { BoardEraser, BoardPen } from "./layout";
+import { type TipName } from "./stroke";
+/** A right hand holds a marker with its barrel rising away to the upper right (lab/board.ts). */
+export declare const HAND_ANGLE: number;
+/**
+ * A board's pen as flux: `take` (0 lying … 1 in the hand), `shown` (present at the hand — over the melamine), `rub` (the eraser at
+ * the hand), `press` (0 hovering … 1 on the board), each a spring with its velocity; `lean` (radians across the barrel) and the
+ * hand's smoothed velocity (CSS px/s) it follows.
+ */
+export interface PenState {
+    take: number;
+    takeV: number;
+    shown: number;
+    shownV: number;
+    rub: number;
+    rubV: number;
+    press: number;
+    pressV: number;
+    lean: number;
+    vx: number;
+    vy: number;
+}
+export declare const penAtRest: () => PenState;
+/** What the hand is doing this frame, as the board's pen reads it. */
+export interface PenInput {
+    /** The pen is in hand: the board held and open (past 42 % of the pickup) — false on the desk and flying home. */
+    readonly held: boolean;
+    /** The eraser is the tool in hand (the marker lies down). */
+    readonly erasing: boolean;
+    /** The hand is over the melamine or laying a stroke: the pen (or the eraser) shows at it. */
+    readonly over: boolean;
+    /** A stroke is being laid: the nib meets the board. */
+    readonly pressing: boolean;
+}
+/** The springs' numbers (lab/board.ts `step`): take 2.4 Hz critically damped, shown and rub 7 Hz, press 9 Hz ζ .85; the lean's decay and follow. */
+export declare const PEN_SPRINGS: {
+    readonly take: readonly [2.4, 1];
+    readonly shown: readonly [7, 1];
+    readonly rub: readonly [7, 1];
+    readonly press: readonly [9, 0.85];
+    readonly leanDecay: 6;
+    readonly leanFollow: 12;
+};
+/**
+ * Advance the pen's flux by `dt` seconds toward what the hand is doing (lab/board.ts `step`, the pen's rows); `snap` sits every
+ * spring at its target (a still). Returns true while anything still moves.
+ */
+export declare function stepPen(s: PenState, input: PenInput, dt: number, snap?: boolean): boolean;
+/** The hand moved: its velocity, CSS px/s, folded into the pen's (the bench's per-event smoothing, a frame at a time). */
+export declare function followHand(s: PenState, dx: number, dy: number, dt: number): void;
+/** Where the marker lies on a board of `w × h`: its centre from the board's (× the hold's scale) and its angle — BOARD.md §5's rest. */
+export declare const penRest: (w: number, h: number) => {
+    readonly x: number;
+    readonly y: number;
+    readonly angle: number;
+};
+/** The hand's world point kept on the melamine (lab/board.ts `handOf`); none seen: the board's centre. */
+export declare function handOnMelamine(G: BoardGeometry, at: readonly [number, number] | null): readonly [number, number];
+/**
+ * THE marker's pose this frame between where it lies and the hand (lab/board.ts `poseOf`, number for number): the nib slides from
+ * its resting place to the hand and turns to the hand's angle (plus the lean); it rises in an arc, its barrel tilting up from the
+ * nib as a held pen does; its cap slides back along the barrel and posts on the end; present in the hand only where the hand is
+ * over the board. The eraser at the hand while it rubs. And the world box both may paint, shadows and all.
+ */
+export declare function penPose(G: BoardGeometry, w: number, h: number, tip: TipName, ink: RGB, s: PenState, at: readonly [number, number] | null): {
+    readonly pen: BoardPen;
+    readonly eraser: BoardEraser | undefined;
+    readonly box: WorldBox;
+};

package/dist/types/packages/objects/src/board/shaders.d.ts

@@ -0,0 +1,36 @@
+import type { CardMaterial } from "../../../desk/src/index";
+import type { ComposeOptions } from "../../../desk/src/engine/index";
+import { type ShaderText } from "../../../desk/src/kit/index";
+export interface BoardShaders {
+    readonly board: ComposeOptions;
+    readonly stamp: ComposeOptions;
+    readonly ink: ComposeOptions;
+    readonly mip: ComposeOptions;
+}
+/** The board's own shader files (the kit's pieces come by name). */
+export declare const BOARD_SHADER_FILES: {
+    readonly felt: "board/felt.wgsl";
+    readonly board: "board/board.wgsl";
+    readonly boardCard: "board/board-card.wgsl";
+    readonly boardPass: "board/board-pass.wgsl";
+    readonly stamp: "board/stamp.wgsl";
+    readonly ink: "board/ink.wgsl";
+    readonly mip: "board/mip.wgsl";
+};
+export declare function boardShaders(text: ShaderText): BoardShaders;
+/**
+ * The whiteboard's CARD MATERIAL (K7b, design-016 §6 K7): the flat-card pipeline draws a board with board-card.wgsl's quad and
+ * fragment over the board pass's own records, knobs, samplers and thumbnail array (`BoardPass.cardResources`, in this order) —
+ * every board drawn from its thumbnail (the card binds no pool and no live layers: its `board_ink` is the thumbnail's, its
+ * stroke and wet none).
+ */
+export declare function boardCard(text: ShaderText): CardMaterial;
+/**
+ * The board's fragment as the flat-card pipeline splices it (K7b): board-pass.wgsl's `fs`, statement for statement — its `in.idx`
+ * the card's `slot`, its shade `cb`, its return the card's `c` — because shade_board reached through one more function compiles to
+ * one LSB off on a pixel a scene (measured on the oracle): the card runs the very code the pass runs. `boardFsOf` is the pass's `fs`
+ * the same statements make (test/card.test.ts holds board-pass.wgsl to it).
+ */
+export declare const BOARD_FRAGMENT: string;
+/** The pass's `fs` body BOARD_FRAGMENT's statements make — as board-pass.wgsl writes it (a test holds the two equal). */
+export declare const boardFsOf: (fragment: string) => string;