@vibecook/ice 0.10.0 → 0.14.0

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

@@ -0,0 +1,8 @@
+/** The covers a notebook is bound in (NOTEBOOK.md §4) — names; the cloths and designs are the host's. */
+export declare const COVERS: readonly ["ink", "orbit", "tiles", "label", "linen"];
+export type CoverName = (typeof COVERS)[number];
+/** The rulings its pages are printed with (notebook/layout.ts `RULINGS`). */
+export declare const RULING_NAMES: readonly ["plain", "dots", "rules", "grid"];
+/** The notebook's durable type id. */
+export declare const NOTEBOOK_TYPE = "desk.notebook";
+export declare const Notebook: import("../../../core/src/index").WidgetType;

package/dist/types/packages/objects/src/notebook/pages.d.ts

@@ -0,0 +1,56 @@
+import type { RasterBudget, RGB } from "../../../desk/src/index";
+import { type InkPoint } from "./ink";
+import { PageRaster } from "./raster";
+/**
+ * A stroke's identity on its page — what a raster compares: its pen, its pace (the cell's `times`; an untimed stroke's `speed`) and
+ * its path (the cell's `points`). Two dots on one spot in two pens are two strokes.
+ */
+export declare const pageStrokeKey: (ink: string, points: string, times: string, speed: number) => string;
+/** A stroke as a page's raster draws it: its identity (`pageStrokeKey`), its pen by name, its samples with their widths. */
+export interface PageStroke {
+    readonly key: string;
+    readonly ink: string;
+    readonly points: readonly InkPoint[];
+}
+/** The pen in hand's stroke (the pen driver's): its page, its pen, its samples so far (grown in place), lifted or not; its key once lifted. */
+export interface LiveStroke {
+    readonly page: number;
+    readonly ink: string;
+    readonly points: InkPoint[];
+    lifted: boolean;
+    key: string;
+}
+/** The pages a record names and the layer each is in (the pass's `NotebookDraw.ink`). */
+export interface InkTable {
+    readonly pages: readonly number[];
+    readonly layers: readonly number[];
+}
+/** Where a raster's bytes go: the notebook pass's layers (`NotebookPass.uploadInk`). */
+export interface InkUploader {
+    uploadInk(layer: number, bytes: Uint8Array<ArrayBuffer>, x?: number, y?: number, w?: number, h?: number): void;
+}
+export declare class PageInk {
+    private readonly slots;
+    private clock;
+    /** Whole-page replays since the cache was made (a witness: the pen's own stroke lands with none). */
+    replays: number;
+    /** THE BUDGET (D6): each layer's CPU raster (5.6 MB) charged as it is made; evicted, the layer replays from its strokes when next used. */
+    private readonly budget;
+    constructor(budget?: RasterBudget);
+    /** The budget's ask (D6): a layer's raster is kept while its page was in a table this frame. */
+    keeps(key: string): boolean;
+    /**
+     * The table for one book's pages in view this frame (`pages` in the pass's order): every page with ink — strokes, or the live
+     * stroke on it — gets a layer (kept if it has one, else the least recently used is taken), its raster brought up to its
+     * strokes (replayed, or the live stroke's new final segments drawn) and uploaded (whole after a replay, else the touched
+     * rectangle). `book` is the book's id on this desk; `len × height` the page's open extent in page units. Without an uploader
+     * (no pass yet) nothing is drawn and the table is empty — the next frame tries again.
+     */
+    table(book: number, pages: readonly number[], strokesOf: (page: number) => readonly PageStroke[], live: LiveStroke | null, colourOf: (ink: string) => RGB, look: unknown, up: InkUploader | undefined, len: number, height: number): InkTable;
+    /** A page's raster as its layer holds it (a witness), or undefined when it has none. */
+    rasterOf(book: number, page: number): PageRaster | undefined;
+    /** A book left the desk: its layers are free (their rasters kept for the next page to take). */
+    forget(book: number): void;
+    /** Everything dropped (the desk ends). */
+    dispose(): void;
+}

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

@@ -0,0 +1,197 @@
+import type { RenderTarget, RGB, RGBA } from "../../../desk/src/index";
+import { type FadeIn, type View, type MatConfig, type MatFrame, type MatPass, type MatLight, type DeskEye, type BuiltMesh, type Rigid } from "../../../desk/src/kit/index";
+import type { NotebookLaw } from "./law";
+import { type NotebookLook, type Ruling } from "./layout";
+import type { Frame } from "./shape";
+import type { NotebookShaders } from "./shaders";
+/** One book as the pass draws it this frame. */
+export interface NotebookDraw {
+    /** A stable id: the book's GPU buffers are kept under it. */
+    readonly id: number;
+    readonly mesh: BuiltMesh;
+    /** Bumped whenever the mesh was rebuilt — the upload's key. */
+    readonly version: number;
+    readonly frame: Frame;
+    readonly rigid: Rigid;
+    /** The unit direction toward the lamp. */
+    readonly lamp: readonly [number, number, number];
+    readonly theta: number;
+    readonly gamma: number;
+    readonly look: NotebookLook;
+    readonly ruling: Ruling;
+    readonly seed: number;
+    /** The selection ring's presence, 0..1. */
+    readonly ring: number;
+    /** Something of the book rises over the rest (a sheet in the air, the cover swinging): its surfaces read the shadow map. */
+    readonly selfShadow: boolean;
+    /** The pages whose ink is on the device, and the layer each is in (at most `INK_TABLE`). */
+    readonly ink: {
+        readonly pages: readonly number[];
+        readonly layers: readonly number[];
+    };
+    /** The look's ruling ink — the pass's fallback where no host set its own (a record made without the desk's local: a tray specimen, K5a). */
+    readonly rule?: RGBA;
+}
+export interface NotebookStats {
+    readonly books: number;
+    readonly triangles: number;
+    readonly shadowed: number;
+}
+export declare class NotebookPass {
+    readonly name = "notebook/books";
+    private readonly device;
+    private readonly format;
+    private readonly mat;
+    private readonly knobs;
+    private readonly records;
+    /** What the GPU holds of the records: a prefix is written only when it changed (K4a). */
+    private readonly recordsSent;
+    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 readonly recordBuf;
+    private readonly layoutMain;
+    private readonly layoutShadow;
+    private readonly layoutComp;
+    private readonly bookPipe;
+    private readonly recvPipe;
+    private readonly shadowPipe;
+    private readonly compPipe;
+    private readonly goboSampler;
+    private readonly noiseSampler;
+    private readonly cmpSampler;
+    /**
+     * The shadow maps (K6a, design-016 §6): a placeholder until a book is drawn, then a layer a book drawn (up to MAX_SHADOWED — they
+     * are drawn again every frame, so growing them keeps nothing): a desk with no notebook holds none of their 33.5 MB, one with one
+     * book 4 MB. With the frame's layer targets they are let go when no book was drawn for a while (`releaseLayer`, the kind's tick)
+     * and with the last book — render targets, never under the raster budget (D-K6a.3; sizing them to the books' box is K7's).
+     */
+    private shadowTex;
+    private shadowLayers;
+    /**
+     * What each shadow map holds (K7a — cached while the lamp and the book stand still): the book's id, its mesh's version, its
+     * placement and its light's frame as the map was drawn — the map is drawn again only when one of them moved. The lamp stands
+     * in world space and the eye is not in the map, so a pan, a zoom or a frame drawn for another object draws none.
+     */
+    private readonly shadowKeys;
+    private readonly recordFloats;
+    /** Shadow maps drawn and kept since the pass was made (a witness). */
+    private shadowDraws;
+    private shadowKept;
+    /**
+     * Turns over at every pass-wide resource a layer reads changing (K7a) — a page's ink uploaded, the main group made again (the
+     * mat's assets, the ink or the shadow maps' texture): with the target's meshes' generation, the silhouette's key, what the pass
+     * lists and the box — and by CONTENT the knobs, the records and the slot's view block — what a target's layer is laid again by,
+     * undrawn (`BoxTargets.holds`). A shadow map drawn is not in it: its content is its book, mesh and light — in the records.
+     */
+    private gen;
+    private readonly sig;
+    private readonly read;
+    /** Layers drawn and laid again undrawn since the pass was made (a witness). */
+    private layerDraws;
+    private layerKept;
+    private drawnAt;
+    private readonly shadowGroup;
+    private readonly inkSampler;
+    private readonly paperTex;
+    private readonly paperSampler;
+    /** The pages' ink rasters: a placeholder until the first stroke, then `INK_LAYERS` full pages. */
+    private inkTex;
+    private inkReady;
+    private mainGroup;
+    private boundAssets;
+    private boundInk;
+    /** The frame's target (the canvas; the hand) and the held desk copy's, apart (D7) — `t` the one this prepare is for (`use`). */
+    private readonly frameT;
+    private copyT;
+    private t;
+    /** The records the last prepare turned away at the pass's cap — not drawn; the ground reports them (`GroundStats.dropped`, D7). */
+    dropped: number;
+    /** Profiling switches (a harness's): 1 no PCSS · 2 no material detail · 4 no gobo · 8 no shadow maps · 16 no composite · 32 no book draw · 64 no mat draw. */
+    debug: number;
+    private constructor();
+    static create(device: GPUDevice, format: GPUTextureFormat, src: NotebookShaders, mat: MatPass): Promise<NotebookPass>;
+    private rebind;
+    /**
+     * Copy part of a page's raster (its bytes — notebook/raster.ts: RGBA8, straight alpha, `INK_W` texels a row) into its layer:
+     * only the rectangle the pen touched goes (D3t-b — the bytes, not a canvas: the Node oracle writes the same layers). The first
+     * call makes the layers — a book with no ink costs the device nothing.
+     */
+    uploadInk(layer: number, bytes: Uint8Array<ArrayBuffer>, x?: number, y?: number, w?: number, h?: number): void;
+    /** The layer's targets at the books' screen `box` (K7a) — and a shadow map a book drawn — made on the first book drawn (K6a). */
+    private fit;
+    /** Was a book drawn within the last `ms`? (The kind lets the layer go once none was for a while.) */
+    drawnWithin(ms: number): boolean;
+    /** When the layer was last drawn (`performance.now()`; -Infinity before the first) — the kind's registered wake lets it go LAYER_IDLE_MS after (K7a). */
+    get lastDrawn(): number;
+    /** Is the frame's layer made (its targets and shadow maps on the device)? */
+    get layerMade(): boolean;
+    /** The pages' ink layers let go (the desk has no notebook — K6a): the placeholder again, made anew by the next page's ink. */
+    releaseInk(): void;
+    /**
+     * Every mesh on the device given back — the frame's and the held copy's (K7a: the desk has none of this kind's objects left, and
+     * no prepare will come to sweep the ones it no longer lists).
+     */
+    releaseMeshes(): void;
+    /**
+     * The frame's layer targets and the shadow maps let go (no book drawn for a while, or none on the desk): made again at the next
+     * book drawn. The meshes stay (the books'); the held copy's targets are the hold's (`endHold`).
+     */
+    releaseLayer(): void;
+    /** Every shadow map's content forgotten (its texture made again or let go): each is drawn afresh at its next book. */
+    private forgetShadows;
+    /** The shadow maps drawn and the ones kept (not drawn: their book, mesh and light stood) since the pass was made (K7a). */
+    get shadows(): {
+        readonly drawn: number;
+        readonly kept: number;
+    };
+    /** The layers drawn and the ones laid again undrawn (nothing they are drawn from moved) since the pass was made (K7a). */
+    get layerFrames(): {
+        readonly drawn: number;
+        readonly kept: number;
+    };
+    /** A book's mesh on the device — uploaded when its version moved, the buffers grown when too small. */
+    private upload;
+    /**
+     * This frame's books, the mat's block for the camera and the light, the pass's knobs, the
+     * eye. Records every book's placement, lamp, shadow frame, pose and palette; uploads what
+     * moved. Returns the count that will draw.
+     */
+    prepare(view: View & {
+        readonly dpr: number;
+    }, fadeIn: FadeIn, cfg: MatConfig, frame: MatFrame | undefined, light: MatLight | undefined, eye: DeskEye, law: NotebookLaw, colours: {
+        readonly cast: RGB;
+        readonly select: RGB;
+        readonly ruleInk: RGBA;
+    }, books: readonly NotebookDraw[]): number;
+    get drawn(): NotebookStats;
+    /** The render target the next prepare, layer and composite are for (D7): the frame's, or the held desk copy's — made on first use. */
+    use(target: RenderTarget): void;
+    /** The hold is over: the desk copy's target gives its layer and meshes back (D7). */
+    endHold(): void;
+    /** The books' screen box on an attachment of `size` device px, clamped to it — the layer's scissor and the composite's; null when none shows. */
+    private boxOf;
+    /** The books' screen box of the last `layer`, device px [x, y, w, h] — what the composite paints at most; null: no layer to lay. */
+    get screenBox(): readonly [number, number, number, number] | null;
+    /** Draw the prepared books onto `target` (the canvas, holding what the ground drew). Its own command buffer: the layer, then the composite. */
+    render(target: GPUTextureView, size: {
+        readonly w: number;
+        readonly h: number;
+    }, dpr: number): void;
+    /**
+     * Record this frame's books into their LAYER, into `encoder` — ahead of the pass the layer is laid in (the host's own, `render`;
+     * or the desk's frame, the notebook a kind of its registry — kinds/notebook.ts): (1) each book's shadow map, (2) the 4× layer —
+     * the books, then the mat under them — resolved. `size`: the attachment's device px. Returns whether there is a layer to lay
+     * (its box: `screenBox`).
+     */
+    layer(encoder: GPUCommandEncoder, size: {
+        readonly w: number;
+        readonly h: number;
+    }, dpr: number): boolean;
+    /**
+     * (3) Lay the last `layer` over what `pass` holds — premultiplied, one fullscreen triangle — scissored to `scissor` (the books'
+     * box, or a part of it a host narrows it to). Nothing without a layer, or with the debug bit 16 (no composite).
+     */
+    composite(pass: GPURenderPassEncoder, scissor?: readonly [number, number, number, number] | null): void;
+    dispose(): void;
+}

package/dist/types/packages/objects/src/notebook/pick.d.ts

@@ -0,0 +1,30 @@
+import { type DeskEye, type Rigid } from "../../../desk/src/kit/index";
+import type { NotebookLaw } from "./law";
+import { type Frame, type NotebookPose } from "./shape";
+export type NotebookHit = {
+    readonly part: "case";
+    readonly t: number;
+} | {
+    readonly part: "page";
+    readonly side: 0 | 1;
+    readonly s: number;
+    readonly y: number;
+    readonly len: number;
+    readonly t: number;
+};
+/** The ray from the eye through a desk point, in the book's own coordinates. */
+export declare function localRay(e: DeskEye, g: Rigid, dx: number, dy: number): {
+    o: [number, number, number];
+    d: [number, number, number];
+};
+/**
+ * The notebook under a desk point, and where. Closed (or mostly), the whole case is one hit;
+ * open, a page on either side (the left one found in the right model, through the mirror the
+ * cover's full swing is), else the case's margins. Null when the ray misses the book.
+ */
+export declare function pickNotebook(F: Frame, pose: NotebookPose, law: NotebookLaw, g: Rigid, e: DeskEye, dx: number, dy: number, bounds: {
+    readonly min: readonly number[];
+    readonly max: readonly number[];
+}): NotebookHit | null;
+/** The x a pointer's ray reaches at height z in the book's own coordinates (the right model's x for a drag). */
+export declare function localXAt(e: DeskEye, g: Rigid, dx: number, dy: number, z: number): number;

package/dist/types/packages/objects/src/notebook/raster.d.ts

@@ -0,0 +1,28 @@
+import type { RGB } from "../../../desk/src/index";
+import { type InkPoint } from "./ink";
+/** A texel rectangle of a page's raster (x, y its top-left; w, h ≥ 0), clipped to the raster. */
+export interface InkRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** One page's ink: RGBA8, straight alpha, `INK_W × INK_H` texels, row by row — the layer the pass holds is a copy of these bytes. */
+export declare class PageRaster {
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    clear(): void;
+}
+/** The union of two rects (either may be null — nothing touched). */
+export declare function unionRect(a: InkRect | null, b: InkRect | null): InkRect | null;
+/** How many segments a stroke of `n` samples is drawn as, and how many of them are FINAL — known whole (all of them once lifted). */
+export declare function segmentsOf(n: number, lifted: boolean): number;
+/**
+ * Segment `k` of a stroke into a raster (1 ≤ k < n; for a stroke of one sample, k = 1 is its dot): the midpoint quadratic from
+ * the midpoint before sample k (sample 0 itself for k = 1) through sample k to the midpoint after it (sample k itself when it is
+ * the last), `sx`/`sy` texels per page unit. Returns the rect it touched, or null.
+ */
+export declare function drawSegment(r: PageRaster, colour: RGB, p: readonly InkPoint[], k: number, sx: number, sy: number): InkRect | null;
+/** A page's texels per page unit across and down (the raster spans the page's open width `len` and its height). */
+export declare const scaleOf: (len: number, height: number) => readonly [number, number];
+/** A whole stroke into a raster — every segment, as the pen laid them; the rect it touched. */
+export declare function drawStroke(r: PageRaster, colour: RGB, p: readonly InkPoint[], sx: number, sy: number): InkRect | null;

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

@@ -0,0 +1,11 @@
+import type { ComposeOptions } from "../../../desk/src/engine/index";
+import { type ShaderText } from "../../../desk/src/kit/index";
+/** The notebook's own shader file (the kit's pieces come by name). */
+export declare const NOTEBOOK_SHADER_FILES: {
+    readonly pass: "notebook/notebook-pass.wgsl";
+};
+export interface NotebookShaders {
+    readonly program: ComposeOptions;
+    readonly composite: ComposeOptions;
+}
+export declare function notebookShaders(text: ShaderText): NotebookShaders;

package/dist/types/packages/objects/src/notebook/shape.d.ts

@@ -0,0 +1,155 @@
+import type { NotebookLaw } from "./law";
+/** One notebook's dimensions (the law's, unless a scene gives its own). */
+export interface NotebookSpec {
+    readonly width: number;
+    readonly height: number;
+    readonly board: number;
+    readonly coverRadius: number;
+    readonly sheets: number;
+    readonly sheet: number;
+    readonly square: number;
+    readonly joint: number;
+    readonly pageRadius: number;
+    readonly band: number;
+    readonly bulge: number;
+}
+export declare const specOf: (law: NotebookLaw, over?: Partial<NotebookSpec>) => NotebookSpec;
+/** The numbers derived from a spec that every part reads. */
+export interface Frame {
+    readonly spec: NotebookSpec;
+    /** Cover width, height, board. */
+    readonly W: number;
+    readonly H: number;
+    readonly b: number;
+    /** The whole block's thickness. */
+    readonly T: number;
+    /** The spine's width (the closed book's thickness) — the gap between the two covers when open. */
+    readonly sw: number;
+    /** A page: its height; its width as bound in the closed book (`Wp`) and as it lies open, out of the gutter (`Wo`). */
+    readonly Hp: number;
+    readonly Wp: number;
+    readonly Wo: number;
+    /** The closed block's spine edge, x. */
+    readonly xp0: number;
+    /** The gutter, open: x, and the valley floor's height. */
+    readonly xg: number;
+    readonly zg: number;
+}
+export declare function frameOf(spec: NotebookSpec): Frame;
+/** The ease every curve here uses. */
+export declare const smooth: (u: number) => number;
+/** A swing past either end bounces back up off the desk or the block — never through it. */
+export declare const swingOf: (theta: number) => number;
+/** How far the gutter has relaxed into its open curve: none until the cover is nearly down. */
+export declare const relaxOf: (theta: number) => number;
+/**
+ * The front cover's frame at a swing θ: its origin (the INNER face's spine edge), its u axis
+ * (across, spine → fore-edge) and its w axis (through the board, inner → outer), all in the
+ * x–z plane. Closed it rests on the block (inner face at b + T); open it lies on the desk to
+ * the left of the spine. The hinge travels on the spine's own arc — up like a door, over, and
+ * down onto the desk — the spine rotating a quarter turn while the cover rotates a half.
+ */
+export interface CoverFrame {
+    readonly ox: number;
+    readonly oz: number;
+    readonly ux: number;
+    readonly uz: number;
+    readonly wx: number;
+    readonly wz: number;
+}
+export declare function coverFrame(F: Frame, theta: number): CoverFrame;
+/** A point in the cover's frame (u across from the spine edge, w through the board from the inner face) → book x, z. */
+export declare const coverPoint: (C: CoverFrame, u: number, w: number) => readonly [number, number];
+/**
+ * The RIDE: a point of the right model (x′, z′) carried by the front cover — the left stack.
+ * At the full swing this is the mirror about the gutter (x ↦ 2·xg − x, z unchanged).
+ */
+export declare const ride: (F: Frame, C: CoverFrame, x: number, z: number) => readonly [number, number];
+/** A right-model direction (nx, nz) carried by the cover (the ride's linear part — a reflection with a turn). */
+export declare const rideDir: (C: CoverFrame, nx: number, nz: number) => readonly [number, number];
+/**
+ * A sheet's rise out of the gutter: tangent angle a·(1 − smooth(s/dc)) for s < dc, flat beyond —
+ * `a` from the rise (steeper for a thicker stack), `dc` the length the climb takes.
+ */
+export interface Profile {
+    readonly a: number;
+    readonly dc: number;
+}
+export declare function profileOf(rise: number, law: NotebookLaw["gutter"]): Profile;
+export declare const angleAt: (p: Profile, s: number) => number;
+/**
+ * A resting sheet of the right model at height `h` (its mid-plane) with the gutter relaxed by
+ * `gamma`: where it starts, how long it is, and its climb. Closed (γ 0) it is flat from the
+ * block's spine edge; open (γ 1) it is bound at the gutter and climbs to `h`.
+ */
+export interface RestSheet {
+    readonly x0: number;
+    readonly z0: number;
+    readonly len: number;
+    readonly profile: Profile;
+}
+export declare function restSheet(F: Frame, h: number, gamma: number, law: NotebookLaw["gutter"]): RestSheet;
+/**
+ * Integrate a curve of tangent angle α(s) from (x0, z0) and sample it at `ss` (ascending, from 0):
+ * out[i] = x, z, cos α, sin α. Midpoint rule, at least `sub` steps per interval and none longer
+ * than `STEP` — the one integrator every curve here goes through, so a sheet in the air, the
+ * stack it lands on and the hit test agree however each is sampled.
+ */
+export declare function integrate(alpha: (s: number) => number, x0: number, z0: number, ss: ArrayLike<number>, sub?: number, out?: Float64Array): Float64Array;
+/** A resting sheet sampled at arc lengths `ss`: x, z, cos, sin per sample. */
+export declare function sampleRest(r: RestSheet, ss: ArrayLike<number>, out?: Float64Array): Float64Array;
+/** A sheet in the air: its root's angle φ and its free edge's ψ (0 = lying right … π = lying left), and the twist that lets one corner lead. */
+export interface Air {
+    readonly index: number;
+    readonly phi: number;
+    readonly psi: number;
+    readonly twist: number;
+}
+/** What the mesh needs: the swing, the counts at rest on each side, and the sheets in the air. */
+export interface NotebookPose {
+    readonly theta: number;
+    /** Sheets at rest on the right (on the back cover) and on the left (on the front cover). */
+    readonly right: number;
+    readonly left: number;
+    /** The right stack's top sheet (its recto shows) and the left stack's (its verso shows); −1 = none. */
+    readonly rightTop: number;
+    readonly leftTop: number;
+    readonly airs: readonly Air[];
+    /** Where the desk is under the book, in its own z (0 lying; −lift held) — what the ribbon hangs down to. */
+    readonly desk?: number;
+}
+export declare const CLOSED_POSE: NotebookPose;
+/** A stack's top and bottom mid-plane heights for k sheets (right model: on a board at z = b). */
+export declare const stackHeights: (F: Frame, k: number) => readonly [number, number];
+/**
+ * A sheet in the air, sampled on the grid (ss × ys), in BOOK coordinates (valid at the full
+ * swing — sheets only turn in an open book): each row's tangent angle blends the right stack's
+ * resting curve into the left's, by a turn fraction that runs from the root's φ to the edge's
+ * ψ (bent by `bend` — the edge curls most), the edge's ψ twisted along the row so one corner
+ * leads. Out: per vertex x, y, z and the tangent along s (cos, sin in x–z).
+ */
+export declare function sampleAir(F: Frame, air: Air, right: number, left: number, gamma: number, ss: ArrayLike<number>, ys: ArrayLike<number>, law: NotebookLaw, rowSS?: (j: number) => ArrayLike<number>): {
+    pos: Float64Array;
+    tan: Float64Array;
+};
+/**
+ * A page's rows, down from the head: a few tracing each fore-edge corner's arc (so the grid's
+ * last column IS the rounded corner — no pixel is cut away in the shader, and the GPU can hide
+ * what lies under a page before shading it), `mid` between. `extent(len, j)` is how far along
+ * the page row j reaches.
+ */
+export declare function pageRows(Hp: number, r: number, mid?: number, arc?: number): {
+    ys: Float64Array;
+    extent: (len: number, j: number) => number;
+};
+/** A resting sheet as a dense table (one sample per world unit), read by `curveAt` — rows of any extent from one integration. */
+export interface CurveTable {
+    readonly data: Float64Array;
+    readonly step: number;
+    readonly n: number;
+}
+export declare function curveTable(r: RestSheet, step?: number): CurveTable;
+/** x, z, cos, sin at arc length s (linear between the table's samples). */
+export declare function curveAt(t: CurveTable, s: number, out: Float64Array): Float64Array;
+/** Arc-length samples across a page: denser toward the gutter, where the curves are. */
+export declare function sheetSamples(len: number, n: number): Float64Array;

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

@@ -0,0 +1,76 @@
+/**
+ * The NOTEBOOK (BOOK.md) — a desk object under the mat's lamp, ONE PHYSICS with the sticky
+ * note: it lifts as the note lifts and casts as the note casts (`PAPER`'s numbers, by name),
+ * plus what a slab has and a sheet has not — a CONTACT shadow at its base (the tree-shadow
+ * design system's paper elevation, mat.css `--lift-1`: a tight `-1px 2px 0 cast/.22` under the
+ * soft `-3px 5px 10px`), the lamp's fill on a face turned from it (the cover mid-swing), and
+ * the materials: the page's fibre is the note's grain; the board wears a cloth, a rolled edge
+ * and the spine's roll; a bound page dips into the gutter; a stack shows its sheets' edges.
+ * Lengths are world units (CSS px at zoom 1); the colours are the product's (lab/theme.ts).
+ */
+export declare const BOOK: {
+    readonly lift: {
+        readonly height: 12;
+        readonly scale: 1.03;
+    };
+    /** The slab's shadow: the note's penumbra with a contact term at its base — the one physics's (kit/physics.ts). */
+    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 lamp's fill on a face: the one physics's. */
+    readonly light: {
+        readonly ambient: 0.5;
+        readonly cap: 1.35;
+    };
+    /**
+     * The leaves' dapple on the object, as a share of the mat's own (1 = the reference's shade, floor 0.5):
+     * a PAGE takes it gently so writing under the palm stays legible (thinking-the-desk §6 guardrail 3),
+     * a board takes it whole. BOOK.md Q-b — James's to rule.
+     */
+    readonly dapple: {
+        readonly page: 0.55;
+        readonly board: 1;
+    };
+    /** The fibre (the note's grain, a touch more — a notebook's sheet is heavier than a Post-it's), the gutter's depth and width, the sheets' edge pitch (device px). */
+    readonly paper: {
+        readonly fibre: number;
+        readonly gutterDepth: 0.35;
+        readonly gutterWidth: 14;
+        readonly edgeStep: 1.3;
+    };
+    /** The board: its cloth (±/255), the rolled edge's width and tilt (rad), the spine's roll. */
+    readonly cover: {
+        readonly cloth: number;
+        readonly bevel: 2.2;
+        readonly bevelTilt: 0.96;
+        readonly roll: 5;
+    };
+    /** The ruling: the pitch (the fine lattice at zoom 1), a dot's radius, a rule's width. */
+    readonly rule: {
+        readonly pitch: 20;
+        readonly dot: 0.7;
+        readonly width: 0.6;
+    };
+    readonly ring: 1.5;
+    /** A notebook as a host spawns one: A6 at the card grid's scale — 176 × 248, a 16 px tape, 9 px fore-edge corners, 1.8 px boards, 80 sheets of 0.12, 2.5 px squares. */
+    readonly spec: {
+        readonly width: 176;
+        readonly height: 248;
+        readonly spine: 16;
+        readonly radius: 9;
+        readonly board: 1.8;
+        readonly sheet: 0.12;
+        readonly sheets: 80;
+        readonly inset: 2.5;
+    };
+};