@vibecook/ice 0.11.0 → 0.14.0

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

@@ -0,0 +1,577 @@
+import { type GroundTheme, type Palette, type RGB, type RGBA, type ThemeName } from "../../desk/src/index";
+import type { BoardPalette } from "./board/kind";
+import type { CalendarPalette } from "./calendar/kind";
+import type { MiniMatPalette } from "./minimat/kind";
+import type { NotebookPalette } from "./notebook/kind";
+import type { PaperPalette } from "./paper/kind";
+export declare const PALETTE: Record<ThemeName, Palette>;
+/**
+ * §2.2 committed content surfaces the desk's paper takes — a note's colour, carried across BOTH
+ * themes like an iOS widget on any wallpaper (the LIGHT is the desk's).
+ */
+export declare const SURFACES: {
+    readonly note: {
+        readonly token: "--vf-note-surface";
+        readonly css: "#f6e7a9";
+    };
+};
+export type SurfaceName = keyof typeof SURFACES;
+export declare const surface: (name: SurfaceName) => RGB;
+/**
+ * The NOTEBOOK's materials (BOOK.md) — the tree-shadow design system's paper layer
+ * (research/tree-shadow/prototype/design/mat.css, the cutting mat's own UI system),
+ * transcribed by token: `--cream` is a page ("text on the mat, primary paper"), `--paper` an
+ * endpaper ("index card, secondary paper"), the covers wear `--kraft` · `--ink` · `--cork` ·
+ * `--paper` and, the product's own black, `--vf-card` (DESIGN.md §2.2). Rules on paper are
+ * ink at 28 % (mat.css `--hair-paper`). Like a card's committed surface, a notebook keeps
+ * its colours in both themes; the LIGHT is the desk's.
+ */
+export declare const BOOK_PAPER: {
+    readonly page: {
+        readonly token: "tree-shadow mat.css --cream";
+        readonly css: "#ffedd7";
+    };
+    readonly end: {
+        readonly token: "tree-shadow mat.css --paper";
+        readonly css: "#f6e0c6";
+    };
+    readonly rule: {
+        readonly token: "tree-shadow mat.css --hair-paper (--ink at 28 %)";
+        readonly css: "rgb(16 9 4 / 28%)";
+    };
+};
+export declare const COVERS: {
+    readonly ink: {
+        readonly cover: {
+            readonly token: "tree-shadow mat.css --ink";
+            readonly css: "#100904";
+        };
+        readonly spine: {
+            readonly token: "tree-shadow mat.css --brass";
+            readonly css: "#c4a574";
+        };
+    };
+    readonly kraft: {
+        readonly cover: {
+            readonly token: "tree-shadow mat.css --kraft";
+            readonly css: "#d9b57c";
+        };
+        readonly spine: {
+            readonly token: "tree-shadow mat.css --ink-2";
+            readonly css: "#382416";
+        };
+    };
+    readonly cork: {
+        readonly cover: {
+            readonly token: "tree-shadow mat.css --cork";
+            readonly css: "#c48a52";
+        };
+        readonly spine: {
+            readonly token: "tree-shadow mat.css --cream";
+            readonly css: "#ffedd7";
+        };
+    };
+    readonly paper: {
+        readonly cover: {
+            readonly token: "tree-shadow mat.css --paper";
+            readonly css: "#f6e0c6";
+        };
+        readonly spine: {
+            readonly token: "tree-shadow mat.css --kraft";
+            readonly css: "#d9b57c";
+        };
+    };
+    readonly card: {
+        readonly cover: {
+            readonly token: "--vf-card";
+            readonly css: "#1c1c1e";
+        };
+        readonly spine: {
+            readonly token: "tree-shadow mat.css --brass-mute";
+            readonly css: "#9a7f55";
+        };
+    };
+};
+export type CoverName = keyof typeof COVERS;
+export declare const COVER_NAMES: CoverName[];
+/** A notebook's look, parsed: its cover and spine, the endpaper and the page every notebook shares, the rule ink. */
+export declare const bookLook: (name: CoverName) => {
+    cover: RGB;
+    spine: RGB;
+    end: RGB;
+    paper: RGB;
+    rule: RGBA;
+};
+/**
+ * The PENS a sticky note is written with (STICKY.md §3) — the host's colours, like a
+ * card's committed surface: a felt tip's near-black, a ballpoint's blue-black, a
+ * fountain pen's blue, a red marker. None is a DESIGN.md token yet; adding the pens
+ * to the doc's material book is the step before any of this leaves draft/ (STICKY.md §8).
+ */
+export declare const PENS: {
+    readonly felt: {
+        readonly token: "STICKY.md §3 felt tip";
+        readonly css: "#2b2a33";
+    };
+    readonly ball: {
+        readonly token: "STICKY.md §3 ballpoint";
+        readonly css: "#1f2f5c";
+    };
+    readonly fountain: {
+        readonly token: "STICKY.md §3 fountain pen";
+        readonly css: "#264a9a";
+    };
+    readonly red: {
+        readonly token: "STICKY.md §3 red marker";
+        readonly css: "#c0392b";
+    };
+};
+export type PenName = keyof typeof PENS;
+export declare const PEN_NAMES: readonly PenName[];
+export declare const pen: (name: PenName) => RGB;
+/**
+ * The WHITEBOARD's materials (BOARD.md) — the board's own colours, kept in both themes like a
+ * card's committed surface; the LIGHT is the desk's. The melamine is the research board's
+ * albedo as it displays (research/whiteboard board.wgsl); the frame is anodised aluminium in
+ * the tree-shadow design's warm greys ("no neutral grey — greys are grey-brown"); the eraser
+ * wears the design's `--kraft` back and `--ink-2` felt. None is a DESIGN.md token yet; the doc's
+ * material book moves first before any of this leaves draft/ (BOARD.md §8).
+ */
+export declare const BOARD_LOOK: {
+    readonly surface: {
+        readonly token: "research/whiteboard melamine (board.wgsl albedo, displayed)";
+        readonly css: "#f3f2ed";
+    };
+    readonly frame: {
+        readonly token: "anodised aluminium, warm (tree-shadow: greys are grey-brown)";
+        readonly css: "#cdc7ba";
+    };
+    readonly barrel: {
+        readonly token: "a marker's barrel, warm white plastic";
+        readonly css: "#ece8e0";
+    };
+    readonly felt: {
+        readonly token: "tree-shadow mat.css --ink-2 (the eraser's felt)";
+        readonly css: "#382416";
+    };
+    readonly wood: {
+        readonly token: "tree-shadow mat.css --kraft (the eraser's back)";
+        readonly css: "#d9b57c";
+    };
+};
+/** The board's colours, parsed. */
+export declare const boardLook: () => {
+    surface: RGB;
+    frame: RGB;
+    barrel: RGB;
+    felt: RGB;
+    wood: RGB;
+};
+/**
+ * The dry-erase MARKERS — the research whiteboard's inks (research/whiteboard tools.ts `MARKERS`)
+ * and the coverage one pass of each lays. Its orange is dropped: orange is the desk's `--hot`,
+ * reserved for state (the tree-shadow design). Content colours, like the note's pens.
+ */
+export declare const MARKERS: {
+    readonly black: {
+        readonly token: "research/whiteboard black marker";
+        readonly css: "#1b1c20";
+        readonly opacity: 0.985;
+    };
+    readonly blue: {
+        readonly token: "research/whiteboard blue marker";
+        readonly css: "#2350b5";
+        readonly opacity: 0.97;
+    };
+    readonly red: {
+        readonly token: "research/whiteboard red marker";
+        readonly css: "#c92a2e";
+        readonly opacity: 0.96;
+    };
+    readonly green: {
+        readonly token: "research/whiteboard green marker";
+        readonly css: "#1e8f4e";
+        readonly opacity: 0.95;
+    };
+};
+export type MarkerName = keyof typeof MARKERS;
+export declare const MARKER_NAMES: readonly MarkerName[];
+export declare const marker: (name: MarkerName) => RGB;
+/**
+ * The marker TRAY — the board's tools while it is open: the tree-shadow design's INK layer
+ * (mat.css: 94 % ink, cream on it, brass for mono labels, `--hot` for the active tool only, the
+ * shadows cast lower-left in the world's darkest value). The tray's stylesheet names these as
+ * custom properties; the values are set from here, so no colour lives in its CSS.
+ */
+export declare const TRAY: {
+    readonly ink: {
+        readonly token: "tree-shadow mat.css --ink";
+        readonly css: "#100904";
+    };
+    readonly cream: {
+        readonly token: "tree-shadow mat.css --cream";
+        readonly css: "#ffedd7";
+    };
+    readonly brass: {
+        readonly token: "tree-shadow mat.css --brass";
+        readonly css: "#c4a574";
+    };
+    readonly brassMute: {
+        readonly token: "tree-shadow mat.css --brass-mute";
+        readonly css: "#9a7f55";
+    };
+    readonly hot: {
+        readonly token: "tree-shadow mat.css --hot";
+        readonly css: "#dc5000";
+    };
+    readonly cast: {
+        readonly token: "tree-shadow mat.css --cast-rgb";
+        readonly css: "rgb(14 26 10)";
+    };
+};
+/**
+ * The MINI MATS' vinyls (MINIMAT.md §2) — the colours a self-healing mat is sold in, and the desk a
+ * mini mat opens onto: enter a slate mini mat and the whole desk is slate. `sage` is the desk's own
+ * (MAT.ground, whatever the panel has made it). Each is the colour the mat's chain STARTS from (the
+ * reference's double gamma darkens it, as it darkens the sage to #3d5a30): slate shows as #34505a,
+ * charcoal as #1e221e. None is a DESIGN.md token yet; the doc's material book moves first (§8).
+ */
+export declare const VINYLS: {
+    readonly slate: {
+        readonly token: "a blue self-healing mat (shows #34505a through the mat's chain)";
+        readonly css: "#7d98a0";
+    };
+    readonly charcoal: {
+        readonly token: "a black self-healing mat, green-black (shows #1e221e — no pure black on the desk)";
+        readonly css: "#616661";
+    };
+};
+export type VinylName = "sage" | keyof typeof VINYLS;
+export declare const VINYL_NAMES: readonly VinylName[];
+/** A vinyl's colour: the desk's own sage (`sage`, the host's), or one of the others. */
+export declare const vinyl: (name: VinylName, sage: RGB) => RGB;
+/** VibeField's two themes, as the passes read them. */
+export declare const THEMES: Record<ThemeName, GroundTheme>;
+/**
+ * The 3D NOTEBOOK's materials (NOTEBOOK.md §4) — five covers after the Paper app's shelf (a
+ * cloth or paper case, a band of cloth down the spine, a printed design) in the tree-shadow
+ * design system's paper layer (research/tree-shadow/prototype/design/mat.css), plus the page's
+ * own ivory. Every colour by token; the two that are not a mat.css token say what they are.
+ * Like a card's committed surface, a notebook keeps its colours in both themes; the LIGHT is
+ * the desk's. `--hot` is left out on purpose: the mat's orange is for state, never a cover.
+ */
+export declare const NOTEBOOK_LOOK: {
+    /** The page: an ivory a shade cooler than `--cream`, so the ink's dots and the dapple read on it. */
+    readonly paper: {
+        readonly token: "notebook ivory (a writing paper's white: warmer than --vf-canvas-bg, cooler than --cream)";
+        readonly css: "#f3ebdc";
+    };
+    /** The ruling's dots and the label's rules. */
+    readonly ink: {
+        readonly token: "tree-shadow mat.css --ink-3";
+        readonly css: "#6c5f51";
+    };
+    readonly covers: {
+        readonly ink: {
+            readonly cloth: {
+                readonly token: "bookcloth black (tree-shadow --ink, lifted to a cloth's black so the weave reads)";
+                readonly css: "#221b16";
+            };
+            readonly band: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+            readonly a: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+            readonly b: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly c: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+            readonly endpaper: {
+                readonly token: "tree-shadow mat.css --paper";
+                readonly css: "#f6e0c6";
+            };
+            readonly design: "plain";
+            readonly paperCover: false;
+        };
+        readonly orbit: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly band: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+            readonly a: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+            readonly b: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly c: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+            readonly endpaper: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly design: "orbit";
+            readonly paperCover: false;
+        };
+        readonly tiles: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --kraft";
+                readonly css: "#d9b57c";
+            };
+            readonly band: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly a: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly b: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly c: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+            readonly endpaper: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly design: "tiles";
+            readonly paperCover: false;
+        };
+        readonly label: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --kraft";
+                readonly css: "#d9b57c";
+            };
+            readonly band: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly a: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly b: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly c: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+            readonly endpaper: {
+                readonly token: "tree-shadow mat.css --kraft";
+                readonly css: "#d9b57c";
+            };
+            readonly design: "label";
+            readonly paperCover: true;
+        };
+        readonly linen: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --paper";
+                readonly css: "#f6e0c6";
+            };
+            readonly band: {
+                readonly token: "tree-shadow mat.css --brass-mute";
+                readonly css: "#9a7f55";
+            };
+            readonly a: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+            readonly b: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly c: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+            readonly endpaper: {
+                readonly token: "tree-shadow mat.css --cream";
+                readonly css: "#ffedd7";
+            };
+            readonly design: "bordered";
+            readonly paperCover: false;
+        };
+    };
+};
+export type NotebookCover = keyof typeof NOTEBOOK_LOOK.covers;
+export declare const NOTEBOOK_COVERS: NotebookCover[];
+/** A cover's look, parsed: what the notebook pass's record takes. */
+export declare const notebookLook: (name: NotebookCover) => {
+    cloth: RGB;
+    band: RGB;
+    accents: [RGB, RGB, RGB];
+    endpaper: RGB;
+    paper: RGB;
+    ink: RGB;
+    design: "plain" | "orbit" | "tiles" | "label" | "bordered";
+    paperCover: boolean;
+};
+/** The ruling's ink with its presence on the page. */
+export declare const notebookRuleInk: () => RGBA;
+/**
+ * The DESK CALENDAR's materials (CALENDAR.md §4) — a pad of the notebook's own ivory under a cloth
+ * tape, printed in the tree-shadow design's inks: the dates and the month in `--ink-2`, the year,
+ * the eyebrows and the weekend in `--ink-3`, the weekend's columns washed with `--kraft`; today is
+ * `--hot` (a state — "what is happening"), ringed by a marker. The pens are the sticky note's; the
+ * highlighters are new: the fluorescents a desk has, muted to sit on the ivory under the mat's
+ * light (the shader lays them in by MULTIPLY, as a highlighter's dye does). The chipboard back is
+ * kraft gone grey. None is a DESIGN.md token yet — the doc's material book moves first (§12).
+ */
+export declare const CALENDAR_LOOK: {
+    readonly paper: {
+        readonly token: "notebook ivory (NOTEBOOK_LOOK.paper — the desk's one writing paper)";
+        readonly css: "#f3ebdc";
+    };
+    readonly ink: {
+        readonly token: "tree-shadow mat.css --ink-2";
+        readonly css: "#382416";
+    };
+    readonly muted: {
+        readonly token: "tree-shadow mat.css --ink-3";
+        readonly css: "#6c5f51";
+    };
+    readonly weekend: {
+        readonly token: "tree-shadow mat.css --kraft";
+        readonly css: "#d9b57c";
+    };
+    readonly hot: {
+        readonly token: "tree-shadow mat.css --hot (a state: today)";
+        readonly css: "#dc5000";
+    };
+    readonly pencil: {
+        readonly token: "graphite — a warm grey-brown (the design has no neutral grey)";
+        readonly css: "#5f574f";
+    };
+    readonly chipboard: {
+        readonly token: "chipboard — kraft gone grey (the pad's back)";
+        readonly css: "#9c8b76";
+    };
+    /** The presences: the rules, the heading rule, the weekend's wash, a neighbour month's wash and its dates, a highlighter. */
+    readonly alpha: {
+        readonly rule: 0.3;
+        readonly head: 0.62;
+        readonly weekend: 0.1;
+        readonly outside: 0.06;
+        readonly faint: 0.26;
+        readonly highlight: 0.62;
+    };
+    readonly tapes: {
+        readonly ink: {
+            readonly cloth: {
+                readonly token: "bookcloth black (NOTEBOOK_LOOK.covers.ink)";
+                readonly css: "#221b16";
+            };
+            readonly foil: {
+                readonly token: "tree-shadow mat.css --brass";
+                readonly css: "#c4a574";
+            };
+        };
+        readonly tobacco: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+            readonly foil: {
+                readonly token: "tree-shadow mat.css --cork";
+                readonly css: "#c48a52";
+            };
+        };
+        readonly kraft: {
+            readonly cloth: {
+                readonly token: "tree-shadow mat.css --kraft";
+                readonly css: "#d9b57c";
+            };
+            readonly foil: {
+                readonly token: "tree-shadow mat.css --ink-2";
+                readonly css: "#382416";
+            };
+        };
+    };
+    readonly highlighters: {
+        readonly yellow: {
+            readonly token: "highlighter yellow";
+            readonly css: "#f2d64f";
+        };
+        readonly green: {
+            readonly token: "highlighter green";
+            readonly css: "#b4d98a";
+        };
+        readonly pink: {
+            readonly token: "highlighter pink";
+            readonly css: "#f0a9bf";
+        };
+        readonly blue: {
+            readonly token: "highlighter blue";
+            readonly css: "#a3cde8";
+        };
+        readonly orange: {
+            readonly token: "highlighter orange";
+            readonly css: "#f4b673";
+        };
+    };
+};
+export type CalendarTape = keyof typeof CALENDAR_LOOK.tapes;
+export declare const CALENDAR_TAPES: CalendarTape[];
+export type HighlighterName = keyof typeof CALENDAR_LOOK.highlighters;
+export declare const HIGHLIGHTER_NAMES: HighlighterName[];
+/** The print's colours, for the raster (lab/calendar-print.ts `PrintLook`). */
+export declare const calendarPrint: () => {
+    ink: string;
+    muted: string;
+    faint: 0.26;
+    hot: string;
+    pencil: string;
+    pens: Record<string, string>;
+    highlighters: Record<string, string>;
+    highlight: 0.62;
+};
+/** The pad's materials, for the pass: the paper, the print's rules and wash, the chipboard, the tape's cloth and foil. */
+export declare const calendarLook: (tape: CalendarTape) => {
+    paper: RGB;
+    ink: RGB;
+    muted: RGB;
+    weekend: RGB;
+    hot: RGB;
+    chipboard: RGB;
+    cloth: RGB;
+    foil: RGB;
+    alpha: typeof CALENDAR_LOOK.alpha;
+};
+/**
+ * The inks a PERSON takes in apps/desk's rooms (D5a) — the colour `@ice/dom`'s remote-cursors reflector paints a peer's cursor and
+ * name chip in (core's `PresenceInfo.color`): violet and the warm hues, which read over the green mat by day and under the Moon;
+ * none a green of the mat's, none the pencil's blue (YOUR hand's). A demo's choice, not yet a DESIGN.md token.
+ */
+export declare const PRESENCE_INKS: readonly ["#8e4ec6", "#e2a336", "#e5484d", "#d6409f", "#f76b15"];
+/** A palette every reference kind reads its look from: the roles, the note's papers and pens, the vinyls, the board's, the notebooks' and the calendars' materials. */
+export type DeskPalette = PaperPalette & MiniMatPalette & BoardPalette & NotebookPalette & CalendarPalette;
+/**
+ * THE DEFAULT PALETTE (D-D7-C.1) — complete for `DESK_OBJECTS`: the roles, the note's one paper (`yellow` — the product's
+ * `--vf-note-surface`), its pens, the mini mats' vinyls, the whiteboard's materials and markers (BOARD.md), the notebooks' page,
+ * ruling and covers (NOTEBOOK.md §4), the calendar's paper, print, tapes and presences (CALENDAR.md §4). `deskLayer({ palette })`
+ * takes it as it is; an app with its own tokens hands its own (the kinds read only what `theme()` is given).
+ */
+export declare const deskPalette: (name: ThemeName) => DeskPalette;
+/** The theme the passes read for a name — `themeFrom` on the default palette's roles (the oracle's `THEMES[name]` exactly). */
+export declare const deskTheme: (name: ThemeName) => GroundTheme;

package/dist/types/packages/objects/src/paper/host/body.d.ts

@@ -0,0 +1,30 @@
+import { type Entity, type World } from "../../../../core/src/index";
+import type { PaperDriver } from "../object";
+import { type HandLaw, type DeskEditor, type TextPart } from "../../../../desk/src/kit/index";
+/** The note's text part's name — what the editor's lease carries while a note is being written (`DeskEditor.lease().part`). */
+export declare const NOTE_BODY = "note.body";
+export interface NoteBodyOptions {
+    /** The desk's ONE editor (the desk makes it — `ObjectDomHost.editor`). */
+    readonly editor: DeskEditor;
+    readonly world: World;
+    /** The note's driver (`PaperDriver`, D-D7-A.3): the host hands the note's own; none, no body. */
+    readonly driver: PaperDriver | undefined;
+    /** The builder's drawn geometry for an entity. */
+    readonly geometryOf: (e: Entity) => unknown;
+    /** The hand's face for the platform's own layout of the text (arrow keys by line): family and weight (the paper's default face). */
+    readonly font?: {
+        readonly family: string;
+        readonly weight: number;
+    };
+    readonly hand?: Pick<HandLaw, "size" | "lineHeight" | "pad">;
+    /** The clock the writing's flux runs on (`performance.now`). */
+    readonly now?: () => number;
+}
+/** The note's body: its text part (the desk routes taps to it) and the doors a rig and the keys use. */
+export interface NoteBody extends TextPart {
+    /** Put the editor on note `e`, the caret before glyph `index` (the end by default). False for a still, a non-note or a read-only document. */
+    focus(e: Entity, index?: number): boolean;
+    /** The note being written, or undefined (the editor lent elsewhere, or to nothing). */
+    editing(): Entity | undefined;
+}
+export declare function createNoteBody(opts: NoteBodyOptions): NoteBody | undefined;

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

@@ -0,0 +1,81 @@
+import { type KindExtra, type KindPass, type KindProgram, type SlotContext, type Palette, type RGB, type TokenRef, type ObjectKind } from "../../../desk/src/index";
+import { type MatPass, type MarkFrame, type HandLaw, type ShaderText } from "../../../desk/src/kit/index";
+import type { PaperInstance } from "./layout";
+import { type PaperGeometry, type PaperLaw } from "./paper";
+import { PaperPass } from "./paper-pass";
+import type { UvRect } from "./pages";
+/** The note's kind name — its key in the registry and in every slot's `objects`. */
+export declare const PAPER_KIND = "paper";
+export declare class PaperKind implements KindPass<PaperInstance> {
+    /** The paper pass itself: a host's door to the ink pages (`alloc`, `write`, `reset`) and the note's law (`law`, `chain`, `wipeSoft`). */
+    readonly pass: PaperPass;
+    constructor(pass: PaperPass);
+    spawn(mat: MatPass): PaperKind;
+    tune(root: KindPass<PaperInstance>): void;
+    /** The pass's own `prepare`, argument for argument: the slot's camera, grid, clocks, the objects' presence, the light, the ring's colour, the lamp — and the records' keys (D6). */
+    prepare(_encoder: GPUCommandEncoder, s: SlotContext, records: readonly PaperInstance[], extra?: KindExtra): number;
+    dropped(): number;
+    drawRange(pass: GPURenderPassEncoder, first: number, end: number): void;
+    records(): import("../../../desk/src/index").RecordStoreStats;
+    cardResources(): {
+        readonly version: number;
+        readonly resources: readonly (GPUBuffer | GPUTextureView | GPUSampler)[];
+    };
+    cardSlot(index: number): number;
+    dispose(): void;
+}
+/** The note's program for a host's shader text: its pass made on the root's mat. */
+export declare function paperProgram(text: ShaderText): KindProgram<PaperInstance>;
+/**
+ * What the note's kind takes from the host's palette (theme.ts `Palette`, extended): the sheets by
+ * the `paper` prop's value and the pens' inks by the `pen` prop's — each a token (`--vf-note-surface`,
+ * STICKY.md §3's pens), the product's colours, never the engine's (the theme gate).
+ */
+export interface PaperPalette extends Palette {
+    readonly papers?: Readonly<Record<string, TokenRef>>;
+    readonly pens?: Readonly<Record<string, TokenRef>>;
+}
+/** The note's look for a theme: its sheets and inks, parsed. */
+export interface PaperLook {
+    readonly papers: Readonly<Record<string, RGB>>;
+    readonly pens: Readonly<Record<string, RGB>>;
+}
+/** A note's writing as the far LOD greeks it (MINIMAT.md §5): the text's left edge and em (note units from the sheet's top-left) and each line's baseline and width. */
+export interface PaperWriting {
+    readonly x0: number;
+    readonly em: number;
+    readonly lines: readonly {
+        readonly y: number;
+        readonly width: number;
+    }[];
+}
+/**
+ * What the host pins on a note (`ctx.asset`): a committed raster's place in the ink pages (`layer` + `uv`),
+ * and/or its writing's lines for the chip (`greek` — a still states them; the live text's layout is D2c's).
+ */
+export interface PaperAsset {
+    readonly layer?: number;
+    readonly uv?: UvRect;
+    readonly greek?: PaperWriting;
+}
+/**
+ * How far a note's drawing reaches past its rect, world units: its shadow at full lift and curl,
+ * cast along the lamp's slope and blurred; the held scale; the tilt's overhang of the sheet's box.
+ */
+export declare function paperReach(law?: PaperLaw): number;
+export interface PaperKindOptions {
+    /** The host's shader text; the generated module unless a host says (the Node oracle hands the .wgsl files on disk). */
+    readonly text?: ShaderText;
+    /** The paper's numbers (theme.ts `PAPER`) — the engine's unless a host tweaks them. */
+    readonly law?: PaperLaw;
+    /** The hand (D2c): its law (theme.ts `HAND`), its face (`caveat`) and the pen's bleed (0.3 note units). */
+    readonly hand?: {
+        readonly law?: HandLaw;
+        readonly face?: string;
+        readonly bleed?: number;
+    };
+}
+/** The note's kind, whole (kinds/world.ts `ObjectKind`): the program, and the world half on the prototype's laws. */
+export declare function paperKind(opts?: PaperKindOptions): ObjectKind<PaperGeometry, PaperInstance, PaperLook>;
+/** The note's silhouette for the desk's marks (D4a): the sheet as drawn — tilted, lifted to scale — its corner scaled with it. */
+export declare function paperFrame(G: PaperGeometry): MarkFrame;