@vibecook/ice 0.10.0 → 0.14.0

package/dist/types/packages/objects/src/calendar/writing.d.ts

@@ -0,0 +1,42 @@
+import { type Entity, type World } from "../../../core/src/index";
+import type { PadDraft, Pads } from "./kind";
+import { type TypingDocs } from "../../../desk/src/index";
+export interface CalendarWritingOptions {
+    readonly world: World;
+    readonly docs: TypingDocs;
+    /** The calendar kind's state on this desk (the draft is printed through it). */
+    readonly pads: () => Pads | undefined;
+    /** A fresh seed for a glyph just written (`Math.random` unless a test says). */
+    readonly fresh?: () => number;
+}
+/** What is being written: its pad, and the entry (an event entity) or the draft (a new line not yet in the document). */
+export interface WritingTarget {
+    readonly pad: Entity;
+    readonly entry: Entity | null;
+    readonly draft: PadDraft | null;
+}
+export interface CalendarWriting {
+    current(): WritingTarget | null;
+    /** A NEW line on days `start` … `end` of `pad`, in `ink` — a draft until its session ends. False for a dead pad. */
+    beginNew(pad: Entity, start: number, end: number, ink: string): boolean;
+    /** Write into an existing entry (the `Editing` claim on it). False for a dead entry or one not of `pad`. */
+    beginEntry(pad: Entity, entry: Entity): boolean;
+    /** The platform's value (a line: a newline is a space): the draft's text, or the entry's cell written LIVE; the inserted run, or null. */
+    input(value: string): {
+        readonly from: number;
+        readonly to: number;
+    } | null;
+    /** The text as it stands (the draft's, or the entry's live cell). */
+    text(): string;
+    /** A session is open: text written and not yet committed. */
+    open(): boolean;
+    /** End the SESSION — ONE transaction (the draft spawned, the cell committed, an emptied entry removed) or none; the writing stays on. */
+    commit(): boolean;
+    /** Take the session back — a draft gone, an entry's cell as found — and end the writing. */
+    cancel(): void;
+    /** End the writing: commit, then lift the claim. */
+    end(): void;
+    /** Transactions committed since creation (a rig's witness). */
+    commits(): number;
+}
+export declare function createCalendarWriting(opts: CalendarWritingOptions): CalendarWriting;

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

@@ -0,0 +1,22 @@
+export { MINIMAT_TYPE, MiniMat, VINYL_ACT, VINYLS, type VinylName } from "./minimat/object";
+export { NOTE_INK, NOTE_PROPS, NOTE_TYPE, Note, type PaperDriver, PAPERS, type PaperName, PENS, type PenName } from "./paper/object";
+export { createNoteTyping, type NoteTyping, type NoteTypingOptions, type TypingDocs } from "./paper/typing";
+export { BOARD_TYPE, Board, MARKERS, type MarkerName, TIPS } from "./board/object";
+export { CALENDAR_TYPE, Calendar, type CalendarDriver, type CalendarInputDoors, TAPES, type TapeName } from "./calendar/object";
+export { addEvent, calEventOf, CalendarEvent, dayOr, daySlot, EVENT_TYPE, EventPrefab, type EventRow, type EventSpec, monthKeyOf, monthOfKey, NotePin, PadSelection, PIN_TYPE, PinPrefab, pinnedNotes, pinNote, PinsNote } from "./calendar/data";
+export { keyOf as keyOfDay } from "./calendar/month";
+export { type CalendarWriting, type CalendarWritingOptions, createCalendarWriting, type WritingTarget } from "./calendar/writing";
+export { type CalendarHand, type CalendarHandOptions, createCalendarHand } from "./calendar/hand";
+export { COVERS, type CoverName, NOTEBOOK_TYPE, Notebook, RULING_NAMES } from "./notebook/object";
+export { PHOTO_TYPE, Photo, printExtent } from "./photo/object";
+export { createPhotoCarry, type PhotoCarry, type PhotoCarryOptions, TWIST_PER_WHEEL } from "./photo/carry";
+export { type BoardPen, type BoardPenOptions, createBoardPen } from "./board/board-pen";
+export { createNotebookHand, type NotebookHand, type NotebookHandOptions } from "./notebook/leaf";
+export { addStroke, BoardStroke, boardOps, decodePoints, decodeTimes, encodePoints, encodeTimes, feedStroke, type MarkerInk, meanSpeed, seedOfRow, STROKE_TYPE, StrokePrefab, type StrokeRow, strokeRow, strokeSeed, type StrokeSpec } from "./board/data";
+export { DESK_ENGINE, DESK_OBJECTS, DESK_TOOLS, DeskCanvas, deskSelect } from "./preset";
+export { type DeskPalette, deskPalette, deskTheme, PRESENCE_INKS } from "./palette";
+export * from "./kinds";
+export { createNoteBody, NOTE_BODY, type NoteBody, type NoteBodyOptions } from "./paper/host/body";
+export { printRaster, type PrintRasterOptions } from "./calendar/host/print";
+export { CALENDAR_LINE, type CalendarInput, type CalendarInputOptions, caretIndexAt, createCalendarInput } from "./calendar/host/input";
+export { shaderText } from "./shaders";

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

@@ -0,0 +1,24 @@
+import type { KindProgram, ShaderText } from "../../desk/src/index";
+export { BOARD_KIND, BOARD_TOOLS, type BoardInk, boardInked, BoardKind, type BoardKindOptions, type BoardObjectLook, type BoardPalette, boardFrame, boardKind, boardPose, boardProgram, boardReach, boardRest, createBoardInk, ERASER_TOOL_ID, inking, inkOfTool, markerToolId, type PenHand, type PenPin } from "./board/kind";
+export { CALENDAR_KIND, type CalendarAlpha, calendarFrame, type CalendarGeometry, CalendarKind, type CalendarKindOptions, calendarKind, type CalendarObjectLook, type CalendarPalette, calendarProgram, calendarReach, type CalendarPart, type CalendarPartName, createPads, DRAFT_ID, type PadDraft, type PadMarks, type PadPose, type Pads, partAt, sheetDayBox, sheetDraw, sheetOnScreen, sheetPoint } from "./calendar/kind";
+export type { EventLine, PrintLook, SheetPrint } from "./calendar/print";
+export type { PinnedSheet } from "./calendar/printing";
+export { INSIDE_GRID, MINIMAT_KIND, MiniMatKind, type MiniMatKindOptions, type MiniMatLook, type MiniMatPalette, miniMatFrame, miniMatProgram, miniMatReach, minimatKind, SAGE } from "./minimat/kind";
+export { INK_H, INK_W } from "./notebook/ink";
+export { BOARD } from "./board/theme";
+export { MINIMAT } from "./minimat/theme";
+export { BOOK } from "./notebook/theme";
+export { PAPER } from "./paper/theme";
+export { askTurn, bookAngle, bookFrame, type BookPose, type Books, createBooks, DEFAULT_PEN, inTurnZone, NOTEBOOK_KIND, NOTEBOOK_PAGE, NOTEBOOK_PENS, NOTEBOOK_TOOLS, notebookFrame, type NotebookGeometry, NotebookKind, type NotebookKindOptions, notebookKind, type NotebookObjectLook, type NotebookPalette, notebookProgram, notebookReach, PageTurns, pageHitAt, partOf, penOfTool, penToolId } from "./notebook/kind";
+export { PAPER_KIND, type PaperAsset, PaperKind, type PaperKindOptions, type PaperLook, type PaperPalette, paperFrame, paperProgram, paperReach, paperKind } from "./paper/kind";
+export { createPrints, type FlickWitness, PHOTO_KIND, photoFrame, photoKind, PhotoKind, type PhotoKindOptions, type PhotoPose, photoProgram, photoReach, PRINT_RETURN_MS, printExtent, printRect, type PrintRest, type Prints } from "./photo/kind";
+export { createWriting, DEFAULT_BLEED, DEFAULT_FACE, DEFAULT_HAND_LAW, type InkPages, type NoteInk, type NoteRasterInfo, type Writing, type WritingStats } from "./paper/writing";
+/**
+ * The desk's kinds in the order they prepare — the prototype's (the notes, the mini mats, the whiteboards; its prints
+ * after the ground, as its photo lab drew them; then its two layers in the order its lab rendered them: the calendar's
+ * before the frame, the notebooks' after it) — each made from `text`: the kinds' shader text (theirs and the kit's — ./shaders.ts)
+ * unless a host says (the Node oracle hands the .wgsl files on disk).
+ */
+export declare function deskKinds(text?: ShaderText): readonly KindProgram[];
+/** The desk's kinds on the kinds' generated shader text (and the kit's) — what a browser host registers: `Ground.create({ device, canvas, mat, kinds: DESK_KINDS })`. */
+export declare const DESK_KINDS: readonly KindProgram[];

package/dist/types/packages/objects/src/minimat/inside.d.ts

@@ -0,0 +1,17 @@
+import { type GridConfig, type CameraState, type FitBand, type Rect, type Viewport, type InsideView } from "../../../desk/src/kit/index";
+import type { MiniMatInstance } from "./layout";
+import { type Chip, type MiniMatGeometry, type MiniMatLaw } from "./minimat";
+/**
+ * A mini mat's inside under the host camera `cam`: `content` the bounds of the inside (null = empty
+ * — it arrives on its origin at zoom 1). The arrival and the embedding are the flight's own
+ * (`arrivalCamera`, `portalAffine` on the same inputs), so a live inside rendered under `cam` IS the
+ * flight's first frame. Null only for a face with no area.
+ */
+export declare function insideView(G: MiniMatGeometry, content: Rect | null, cam: CameraState, vp: Viewport, fit?: FitBand, gate?: readonly [number, number]): InsideView | null;
+/**
+ * What the pass takes for one mini mat: `grid` is the INSIDE's (its fade-in and its line law — the
+ * face's far-LOD lattice is the live inside's, dressed for its arrival when `dress`; its vinyl — the
+ * inside's mat is the same vinyl, `grid.mat.ground`), `name` what its foot prints; the ruler numbers
+ * the rung the law says at the inside's zoom.
+ */
+export declare function miniMatInstance(G: MiniMatGeometry, view: InsideView, grid: GridConfig, chips: readonly Chip[], name?: string, dress?: boolean, law?: MiniMatLaw): MiniMatInstance;

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

@@ -0,0 +1,51 @@
+import { type KindExtra, type KindPass, type KindProgram, type SlotContext, type Palette, type RGB, type TokenRef, type ObjectKind } from "../../../desk/src/index";
+import { type GridConfig, type MatPass, type MarkFrame, type ShaderText } from "../../../desk/src/kit/index";
+import type { MiniMatInstance } from "./layout";
+import { type MiniMatGeometry, type MiniMatLaw } from "./minimat";
+import { MiniMatPass } from "./pass";
+/** The mini mat's kind name — its key in the registry and in every slot's `objects`. */
+export declare const MINIMAT_KIND = "minimat";
+export declare class MiniMatKind implements KindPass<MiniMatInstance> {
+    /** The mini mat pass itself: a host's door to its law (`law`) and this frame's chips. */
+    readonly pass: MiniMatPass;
+    constructor(pass: MiniMatPass);
+    spawn(mat: MatPass): MiniMatKind;
+    tune(root: KindPass<MiniMatInstance>): void;
+    setLaw(law: unknown): void;
+    /**
+     * The pass's own `prepare`, argument for argument; the ground's word on each mini mat's live inside (`extra.live`,
+     * by this kind's record index) overrides the instance's own — absent, the instances say.
+     */
+    prepare(_encoder: GPUCommandEncoder, s: SlotContext, records: readonly MiniMatInstance[], extra?: KindExtra): number;
+    dropped(): number;
+    drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
+    records(): import("../../../desk/src/index").RecordStoreStats;
+    /** Mini mat `index`'s chips over its live inside, while the inside's objects are not whole. */
+    drawOver(pass: GPURenderPassEncoder, index: number): void;
+    dispose(): void;
+}
+/** The mini mat's program for a host's shader text: its pass made on the root's mat. */
+export declare function miniMatProgram(text: ShaderText): KindProgram<MiniMatInstance>;
+/** What the mini mat's kind takes from the host's palette: the vinyls by the `vinyl` prop's value (`sage` needs none — it is the desk's own ground). */
+export interface MiniMatPalette extends Palette {
+    readonly vinyls?: Readonly<Record<string, TokenRef>>;
+}
+/** The mini mat's look for a theme: its vinyls, parsed. */
+export interface MiniMatLook {
+    readonly vinyls: Readonly<Record<string, RGB>>;
+}
+/** The vinyl the desk's own mat is: the `vinyl` prop's value that means "the ground's colour". */
+export declare const SAGE = "sage";
+/** How far a mini mat's drawing reaches past its rect, world units: the slab's shadow swept from its top, its penumbra and contact term, the held scale. */
+export declare function miniMatReach(law?: MiniMatLaw): number;
+export interface MiniMatKindOptions {
+    /** The host's shader text; the generated module unless a host says. */
+    readonly text?: ShaderText;
+    /** The mini mat's numbers (theme.ts `MINIMAT`) — the engine's unless a host tweaks them. */
+    readonly law?: MiniMatLaw;
+}
+export declare function minimatKind(opts?: MiniMatKindOptions): ObjectKind<MiniMatGeometry, MiniMatInstance, MiniMatLook>;
+/** The grid a mini mat's inside is drawn with when a host names none: the engine's (re-exported for D2b's live insides). */
+export declare const INSIDE_GRID: GridConfig;
+/** The mini mat's silhouette for the desk's marks (D4a): the sheet as drawn, square to the mat, its die-cut corner. */
+export declare function miniMatFrame(G: MiniMatGeometry): MarkFrame;

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

@@ -0,0 +1,83 @@
+import { type PortalAffine, type GlyphAtlasMeta } from "../../../desk/src/kit/index";
+import type { RGB } from "../../../desk/src/index";
+import { type Chip, type FaceLattice, type MiniMatGeometry, type MiniMatLaw, type Numerals } from "./minimat";
+export declare const MiniMat: import("../../../desk/src/engine/index").StructDef<"ground" | "ring" | "lamp" | "inside" | "name" | "live" | "rungs" | "centre" | "half" | "lift" | "alpha" | "margin" | "slope" | "radius" | "thick" | "lampZ" | "chipFirst" | "chipCount" | "nameLen" | "pad0" | "weights" | "widths" | "numerals">;
+export declare const ChipRecord: import("../../../desk/src/engine/index").StructDef<"kind" | "frame" | "ink" | "centre" | "half" | "colour" | "radius" | "rot" | "lines">;
+export declare const MiniMatUniforms: import("../../../desk/src/engine/index").StructDef<"shadow" | "shadow2" | "select" | "edge" | "ticks" | "atlas" | "print" | "text" | "cream" | "castTint" | "digits" | "atlas2">;
+export declare const MAX_MINIMATS = 256;
+export declare const MAX_CHIPS = 4096;
+/** One mini mat for the pass: its geometry, its vinyl, its inside's embedding and lattice, the live inside's presence, its chips. */
+export interface MiniMatInstance {
+    readonly geometry: MiniMatGeometry;
+    /** The vinyl (sRGB) — the mat's own sage unless the host says. */
+    readonly ground: RGB;
+    /** The grain's amplitude on the vinyl (theme.ts `MAT_GRID.grain`). */
+    readonly grain: number;
+    /** The inside's embedding (host = o + inside · s) and the lattice the face shows on it. */
+    readonly inside: {
+        readonly M: PortalAffine;
+        readonly lattice: FaceLattice;
+    };
+    /** The live inside over the face: absent or −1 = none (the face is the mini mat's own drawing), else its objects' presence 0..1. */
+    readonly live?: number | undefined;
+    /** The children as the face draws them small (the far LOD), in the host's world. */
+    readonly chips?: readonly Chip[] | undefined;
+    /** The name printed in the foot of the border (capitals; minimat.ts `nameGlyphs`). */
+    readonly name?: string | undefined;
+    /** The rung the ruler numbers (minimat.ts `numeralsOf`); absent = none. */
+    readonly numerals?: Numerals | null | undefined;
+}
+export declare function miniMatValues(m: MiniMatInstance, chipFirst: number, chipCount: number): {
+    centre: readonly [number, number];
+    half: readonly [number, number];
+    slope: readonly [number, number];
+    lamp: number[];
+    radius: number;
+    margin: number;
+    lift: number;
+    thick: number;
+    alpha: number;
+    ring: number;
+    live: number;
+    lampZ: number;
+    chipFirst: number;
+    chipCount: number;
+    ground: number[];
+    inside: number[];
+    rungs: number[];
+    weights: number[];
+    widths: number[];
+    numerals: number[];
+    nameLen: number;
+    name: number[];
+};
+export declare function chipValues(c: Chip): {
+    centre: readonly [number, number];
+    half: readonly [number, number];
+    rot: number[];
+    radius: number;
+    kind: number;
+    colour: number[];
+    ink: number[];
+    frame: number[];
+    lines: number[];
+};
+/** The knobs from the law, the colours the pass is handed and the glyph atlas it prints with. */
+export declare function miniMatUniformValues(law: MiniMatLaw, colours: {
+    readonly cream: RGB;
+    readonly cast: RGB;
+    readonly select: RGB;
+}, glyphs: GlyphAtlasMeta): {
+    print: number[];
+    ticks: number[];
+    edge: number[];
+    shadow: number[];
+    shadow2: number[];
+    cream: number[];
+    castTint: number[];
+    select: number[];
+    digits: number[];
+    text: number[];
+    atlas: number[];
+    atlas2: number[];
+};

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

@@ -0,0 +1,179 @@
+import { type FadeIn, type LineLaw, type CameraState, type PortalAffine, type Rect, type PortalClip, type Lamp, type ChildShape, type ChipFinish } from "../../../desk/src/kit/index";
+import type { RGB } from "../../../desk/src/index";
+/** The mini mat's numbers (theme.ts `MINIMAT`) — the engine's unless a host tweaks them. */
+export interface MiniMatLaw {
+    readonly size: {
+        readonly w: number;
+        readonly h: number;
+    };
+    readonly radius: number;
+    readonly margin: number;
+    readonly thick: number;
+    readonly lift: {
+        readonly height: number;
+        readonly scale: number;
+    };
+    readonly hover: 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 edge: {
+        readonly width: number;
+        readonly light: number;
+        readonly dark: number;
+    };
+    readonly print: {
+        readonly frame: number;
+        readonly tick: number;
+        readonly width: number;
+        readonly ticks: readonly [number, number, number];
+        readonly digits: {
+            readonly cap: number;
+            readonly gap: number;
+            readonly top: number;
+        };
+        readonly labelsFrom: readonly [number, number];
+        readonly name: {
+            readonly cap: number;
+            readonly tracking: number;
+        };
+        readonly legible: readonly [number, number];
+    };
+    readonly ring: number;
+    readonly chips: {
+        readonly max: number;
+        readonly minPx: number;
+        readonly greekPx: number;
+        readonly greekAlpha: number;
+        readonly greekWeight: number;
+    };
+    readonly gate: readonly [number, number];
+}
+export declare const DEFAULT_MINIMAT_LAW: MiniMatLaw;
+export interface MiniMatRect {
+    /** World centre, in the frame of the desk it lies on. */
+    readonly cx: number;
+    readonly cy: number;
+    /** The sheet, world units. */
+    readonly w: number;
+    readonly h: number;
+}
+/** What moves: the hold's lift (0..1), the hover's rise (0..1), the selection ring's presence (0..1), the presence itself (1 … 0 gone). */
+export interface MiniMatMotion {
+    readonly held: number;
+    readonly hover: number;
+    readonly ring: number;
+    readonly fade: number;
+}
+export declare const MINIMAT_REST: MiniMatMotion;
+export interface MiniMatGeometry {
+    readonly centre: readonly [number, number];
+    /** Half extents as drawn (the hold's scale applied). */
+    readonly half: readonly [number, number];
+    /** The die-cut corner and the printed border, as drawn. */
+    readonly radius: number;
+    readonly margin: number;
+    /** The sheet's underside off the desk (the hold's and the hover's rise) and its thickness, world units. */
+    readonly lift: number;
+    readonly thick: 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;
+}
+export declare function resolveMiniMat(r: MiniMatRect, m: MiniMatMotion, law: MiniMatLaw, lamp: Lamp): MiniMatGeometry;
+/** The sheet's signed distance at a world point. */
+export declare const sdMiniMat: (G: MiniMatGeometry, wx: number, wy: number) => number;
+/** The FACE — the cutting area inside the printed border, world units: what the inside shows through. */
+export declare function faceOf(G: MiniMatGeometry): Rect;
+export type MiniMatHit = "face" | "border" | "outside";
+/** What is under a world point: the face (the inside's window), the border (the sheet round it), or nothing. */
+export declare function pickMiniMat(G: MiniMatGeometry, wx: number, wy: number): MiniMatHit;
+/** How far the shadow can reach past the sheet, world units — the vertex quad's pad (the slab's sweep and its penumbra). */
+export declare function shadowReach(G: MiniMatGeometry, law?: MiniMatLaw): number;
+/** The face on screen under a camera — the portal's clip. */
+export declare const faceClip: (G: MiniMatGeometry, cam: CameraState) => PortalClip;
+/** The lattice a face shows at the far LOD — the inside's three rungs, their presences and half-widths. */
+export interface FaceLattice {
+    /** Fine, mid, coarse spacing, inside units. */
+    readonly rungs: readonly [number, number, number];
+    /** Each rung's line presence. */
+    readonly weights: readonly [number, number, number];
+    /** Each rung's line half-width, DEVICE px. */
+    readonly widths: readonly [number, number, number];
+}
+/**
+ * The lattice a face draws at the far LOD: the inside's three rungs at the zoom it is seen at
+ * (`insideZoom` — M.s × the host camera's zoom: the live inside's own camera zoom), each rung's
+ * line weight by the mat's line law under the fade-in window DRESSED for the inside's arrival
+ * (`lodZoom`, floored — mat/grid.ts `dressScale`), exactly as the live inside dresses its mat —
+ * so the face and the live inside draw the same lines, and the one fades into the other unseen.
+ */
+export declare function faceLattice(insideZoom: number, fadeIn: FadeIn, law: LineLaw, lodZoom?: number): FaceLattice;
+/**
+ * The finishes a mini mat's face draws its chips in (K8a — its `faceLaw`, the kit's shared vocabulary: never the children's kind
+ * names): `paper` — a sheet in the chip's colour, its writing greeked; `vinyl` — grained vinyl with its frame line at the chip's margin.
+ */
+export declare const MINIMAT_FINISHES: readonly ChipFinish[];
+/** The most lines of a note's writing a chip greeks. */
+export declare const CHIP_LINES = 6;
+/** A chip as the pass takes it: the child mapped into the HOST's world through the inside's embedding `M` (host = o + child · s). */
+export interface Chip {
+    /** The finish it is drawn in — one of the mini mat's own (`MINIMAT_FINISHES`), the builder's pick among the child's. */
+    readonly finish: ChipFinish;
+    readonly centre: readonly [number, number];
+    readonly half: readonly [number, number];
+    readonly cos: number;
+    readonly sin: number;
+    readonly radius: number;
+    readonly colour: RGB;
+    readonly height: number;
+    /** Greeked lines in the chip's own frame, host units: x from, x to, the stroke's centre y — at most CHIP_LINES. */
+    readonly lines: readonly (readonly [number, number, number])[];
+    /** The lines' stroke half-thickness, host units, and their ink. */
+    readonly stroke: number;
+    readonly ink: RGB;
+    /** A mini mat chip's border, host units. */
+    readonly margin: number;
+}
+/** A child through the embedding: its footprint scaled by `M.s` about the host's origin; a note's lines greeked at `weight` × the line pitch (MINIMAT.chips). */
+export declare function chipOf(c: ChildShape, M: PortalAffine, weight?: number): Chip;
+/** The most characters of a NAME the border prints. */
+export declare const NAME_CHARS = 32;
+/** A name as the atlas's glyph indices (mat/layout.ts `GLYPHS`): capitals, a letter it lacks printed as a space; at most NAME_CHARS. */
+export declare function nameGlyphs(name: string, glyphs?: string): number[];
+/**
+ * Glyph indices packed four to a float (6 bits each, base 64 — an integer under 2²⁴, exact in
+ * an f32), NAME_CHARS / 4 floats: what the record's `name` carries. The shader unpacks slot k
+ * as `(u32(f[k / 4]) >> (6 · (k % 4))) & 63`.
+ */
+export declare function packGlyphs(indices: readonly number[]): number[];
+/** Which rung of the face's lattice the ruler numbers, and how: its spacing (inside units), the label's `mult · 10^exp` per site index, and the presence of the sites it numbers that the next rung does not. */
+export interface Numerals {
+    readonly spacing: number;
+    readonly mult: number;
+    readonly exp: number;
+    readonly fade: number;
+}
+/**
+ * The ruler's numerals at the zoom the inside is seen at (`insideZoom`): the finest of the face's rungs
+ * whose sites are `from[0]` CSS px apart on screen, its own sites fading in by `from` and every tenth
+ * (the next rung's) at full — the rulers' law (RULER.md), on three rungs. A spacing is 2·10^k (lod.ts),
+ * so a site's value is `index · 2 · 10^k`. Null = no rung is far enough apart to number.
+ */
+export declare function numeralsOf(L: FaceLattice, insideZoom: number, from: readonly [number, number]): Numerals | null;
+/** Is a chip worth drawing at a zoom — its short side at least `minPx` CSS px? */
+export declare const chipVisible: (ch: Chip, zoom: number, minPx?: number) => boolean;

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

@@ -0,0 +1,8 @@
+/** The vinyls a mini mat is sold in (MINIMAT.md §2) — names; `sage` is the desk's ground, the rest the host's. */
+export declare const VINYLS: readonly ["sage", "slate", "charcoal"];
+export type VinylName = (typeof VINYLS)[number];
+/** The mini mat's durable type id. */
+export declare const MINIMAT_TYPE = "desk.minimat";
+/** Its selection-menu act's id (K8a): the vinyl cycles — an app's key (`t`) runs it through `ops.runMenuAction`. */
+export declare const VINYL_ACT = "vinyl";
+export declare const MiniMat: import("../../../core/src/index").WidgetType;

package/dist/types/packages/objects/src/minimat/pass.d.ts

@@ -0,0 +1,61 @@
+import { type RGB } from "../../../desk/src/index";
+import { type FadeIn, type View, type MatConfig, type MatFrame, type SlotLight, type MatPass, type Presentation, type MatLight } from "../../../desk/src/kit/index";
+import { type MiniMatInstance } from "./layout";
+import { type MiniMatLaw } from "./minimat";
+import type { MiniMatShaders } from "./shaders";
+/** Chips a mini mat's record may name — its BLOCK in the chips buffer (engine/records.ts; the law's `chips.max` caps within it). */
+export declare const CHIPS_PER_MAT: number;
+export declare class MiniMatPass {
+    readonly name = "minimat/mats";
+    private readonly knobs;
+    /** The mini mats' PERSISTENT records and their chips (engine/records.ts, design-015 §4.3; D6): a slot per mini mat while drawn, its chips a fixed block, written when it changed. */
+    private readonly store;
+    /** The records the last prepare turned away at the pass's cap — not drawn; the ground reports them (`GroundStats.dropped`, D7). */
+    dropped: number;
+    private readonly knobBuf;
+    /** What the GPU holds of the knobs: they are written only when they change (K4a — a standing value costs a frame nothing). */
+    private readonly knobsSent;
+    private group;
+    private boundAssets;
+    private boundStore;
+    private count;
+    private chipsUsed;
+    private lawNow;
+    /** The mini mat's numbers (theme.ts `MINIMAT`) — the print, the edge, the shadow, the chips. A host tweaks the root's; every slot copies it. A new law repacks every record (the chips' cap is packed). */
+    get law(): MiniMatLaw;
+    set law(next: MiniMatLaw);
+    private readonly device;
+    private readonly shared;
+    private readonly mat;
+    private constructor();
+    /** The root's pass, on the root's mat. */
+    static create(device: GPUDevice, format: GPUTextureFormat, src: MiniMatShaders, mat: MatPass): Promise<MiniMatPass>;
+    /** A second slot on the same pipeline, reading ITS mat's silhouette — a flight's departed desk, a mini mat's inside. */
+    spawn(mat: MatPass): MiniMatPass;
+    /** Copy the root's tuning — what every slot takes each frame. */
+    tune(from: MiniMatPass): void;
+    private rebind;
+    /**
+     * Upload this frame's mini mats in paint order, their chips back to back (a mini mat's
+     * beyond the law's cap, or past the buffer, are dropped — the face shows fewer, honestly),
+     * and the mat's block for this slot's camera and light (`light` the Sun or the Moon, `lit`
+     * the lamp it is seen by — MINIMAT.md §4). `live` is the ground's word on each one's live
+     * inside — −1 where none is drawn this frame, else its objects' presence — overriding the
+     * instance's own (a portal the ground could not draw leaves the face to the far LOD).
+     * Returns the count that will draw.
+     */
+    prepare(view: View & {
+        readonly dpr: number;
+    }, fadeIn: FadeIn, cfg: MatConfig, frame: MatFrame | undefined, instances: readonly MiniMatInstance[], present: Presentation | undefined, light?: MatLight, select?: RGB, lit?: SlotLight, live?: (index: number) => number, keys?: readonly number[]): number;
+    get drawn(): number;
+    /** The chips drawn this frame, every mini mat's together. */
+    get chips(): number;
+    /** The store's counters (a rig's witness): records written, bytes, draw-list writes, slots in use. */
+    get records(): import("../../../desk/src/index").RecordStoreStats;
+    draw(pass: GPURenderPassEncoder): void;
+    /** Mini mat `at`'s chips OVER its live inside, fading out as the inside's objects fade in — only while the objects are not whole (MINIMAT.md §5). */
+    drawChips(pass: GPURenderPassEncoder, at: number): void;
+    /** Mini mats [first, end) — paint order is the list's; `drawSlot` cuts the range where a live inside goes. */
+    drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,10 @@
+import type { ComposeOptions } from "../../../desk/src/engine/index";
+import { type ShaderText } from "../../../desk/src/kit/index";
+/** The mini mat's own shader files (the kit's pieces come by name). */
+export declare const MINIMAT_SHADER_FILES: {
+    readonly minimat: "minimat/minimat.wgsl";
+    readonly minimatPass: "minimat/minimat-pass.wgsl";
+};
+/** The mini mat pass's program: the kit's view · portal · sdf · light · ruler, then the mini mat's records, module and entry. */
+export type MiniMatShaders = ComposeOptions;
+export declare function miniMatShaders(text: ShaderText): MiniMatShaders;

package/dist/types/packages/objects/src/minimat/theme.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The MINI MAT (MINIMAT.md) — the desk's CONTAINER: a smaller self-healing cutting mat lying on
+ * the big one, and inside it another desk (a nested canvas: double-click it, or zoom into it, and
+ * it becomes the desk). Its sheet is the mat's own vinyl — the sage and the cream print (`MAT`),
+ * the mat's chain by day and the Moon by night — so it is told from the desk by what a real small
+ * mat has: its cut edge and its shadow, the printed BORDER round its cutting area (a frame line,
+ * a ruler along the top and left edges — its ticks on the very lattice the face shows, numbered
+ * in the inside's own units — and its NAME in the foot, as a mat's maker prints its own), and the
+ * finer grid of the miniature desk inside. It is thin, so it lies flat and lifts as little as a
+ * sheet does, casting the desk's one shadow (`BOOK.shadow`: the note's penumbra with a contact
+ * term at the base). World units (CSS px at zoom 1).
+ */
+export declare const MINIMAT: {
+    /** A new mini mat: 8 × 6 of the tree-shadow design's 80-unit modules (mat.css `--module`). */
+    readonly size: {
+        readonly w: 640;
+        readonly h: 480;
+    };
+    /** The die-cut corner; the printed border's width (the FACE is the sheet inset by it); the vinyl's thickness. */
+    readonly radius: 10;
+    readonly margin: 32;
+    readonly thick: 3;
+    /** Held it rises and reads a touch larger — a thin sheet lifts less than a note (PAPER.lift 12 · 1.03); hovered it rises a fifth of that (Marks on the Mat: hover is a rise, never an outline). */
+    readonly lift: {
+        readonly height: 10;
+        readonly scale: 1.02;
+    };
+    readonly hover: 0.2;
+    /** The shadow: the desk's one law. */
+    readonly shadow: {
+        readonly penumbra: {
+            readonly sigma0: 2.2;
+            readonly sigmaPerHeight: 0.9;
+            readonly alpha: 0.36;
+        };
+        readonly contact: {
+            readonly sigma: 1.1;
+            readonly alpha: 0.3;
+            readonly reach: 2.5;
+        };
+        readonly slopeMax: 2.2;
+    };
+    /** The cut edge: a bevel this wide, catching the lamp on its near side (× 1 + light) and falling away on the far (× 1 − dark). */
+    readonly edge: {
+        readonly width: 1.5;
+        readonly light: 0.1;
+        readonly dark: 0.18;
+    };
+    /**
+     * The print, in the mat's cream at the tree-shadow design's print-strong (55 %): the frame round the
+     * face, the ruler's ticks, its numerals and the name. Its lines this wide (world units: a print
+     * scales with the sheet — but never under a device px, the ink thinning instead); the ticks' lengths
+     * — minor, medium, major, for the lattice's fine, mid and coarse rungs. The NUMERALS: the rulers' own
+     * mono digits (RULER.md), this tall (cap, world units), after their tick by `gap`, their cap's top
+     * `top` in from the sheet's edge; a rung is numbered once its sites are `labelsFrom` CSS px apart on
+     * screen (its every tenth site, the next rung's, stays numbered). The NAME: the design's print label
+     * (mono capitals, tracked 0.16 em) this tall, in the foot of the border from the face's left edge.
+     * Text fades in as its cap grows from 4 to 6 CSS px (smaller is a smudge, never a word).
+     */
+    readonly print: {
+        readonly frame: 0.55;
+        readonly tick: 0.55;
+        readonly width: 1;
+        readonly ticks: readonly [5, 9, 14];
+        readonly digits: {
+            readonly cap: 6;
+            readonly gap: 2.5;
+            readonly top: 4;
+        };
+        readonly labelsFrom: readonly [48, 64];
+        readonly name: {
+            readonly cap: 8;
+            readonly tracking: 0.16;
+        };
+        readonly legible: readonly [4, 6];
+    };
+    /** The sole-selection ring (DESIGN.md §7), CSS px, in `--vf-select`. */
+    readonly ring: 1.5;
+    /**
+     * The face's far LOD (MINIMAT.md §5): its children drawn as CHIPS — at most this many (ICE's preview
+     * record keeps 128), none smaller than this many CSS px; a note's writing GREEKED as lines of ink once
+     * its chip is this tall (CSS px), at this presence, its lines this thick (× the line pitch).
+     */
+    readonly chips: {
+        readonly max: 64;
+        readonly minPx: 1;
+        readonly greekPx: 18;
+        readonly greekAlpha: 0.42;
+        readonly greekWeight: 0.3;
+    };
+    /**
+     * The face's corner (MINIMAT.md §5; D2b): the inside is clipped SQUARE — the live inside, the far LOD and a flight through it
+     * (`faceClip`; its `faceLaw.radius`, K8a — the mini mat's own number, which the kit held as `FACE_RADIUS` until then).
+     */
+    readonly faceRadius: 0;
+    /** The live inside's GATE (CSS px of the face's short side): the portal's law (theme.ts `PORTAL`), by name. */
+    readonly gate: readonly [140, 220];
+};