@vibecook/ice 0.11.0 → 0.15.0-desk.1

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

@@ -0,0 +1,88 @@
+import { type Lod } from "./lod";
+export interface RulerLaw {
+    /** CSS px: the band's width, and the mat's unprinted margin between the viewport's edge and the frame. */
+    readonly band: number;
+    readonly margin: number;
+    /** CSS px: the ticks' lengths — minor · medium · major. */
+    readonly tick: readonly [number, number, number];
+    /** CSS px: the width of every printed line — the ticks and the frame. */
+    readonly line: number;
+    /** Ink presence of the frame's lines, the ticks and the labels (1 = the mat's cream, full). */
+    readonly alpha: {
+        readonly frame: number;
+        readonly tick: number;
+        readonly label: number;
+    };
+    /** CSS px of pitch between which the fine rung's ticks (and its fifths) fade in. */
+    readonly ticksFrom: readonly [number, number];
+    /** CSS px of pitch between which a level's labels fade in. */
+    readonly labelsFrom: readonly [number, number];
+    /** The text: its size (CSS px — the atlas's em), its inset from the outer line, its gap after the tick. */
+    readonly text: {
+        readonly size: number;
+        readonly top: number;
+        readonly gap: number;
+    };
+    /** The most characters a label may have; a level whose labels would be wider than its pitch carries none. */
+    readonly maxChars: number;
+}
+/** One level of sites, with everything the pass draws for it this frame. */
+export interface RulerLevel {
+    /** World units between sites. */
+    readonly spacing: number;
+    /** CSS px between sites. */
+    readonly pitch: number;
+    /** A site's value is `index · mult · 10^exp` (index = its count from the world origin). */
+    readonly mult: 1 | 2;
+    readonly exp: number;
+    /** CSS px; the label pulls a tick to the major length as it appears. */
+    readonly tickLen: number;
+    readonly tickAlpha: number;
+    readonly labelAlpha: number;
+    /** The lattice's wrap period over this spacing — an exact integer (100 · 20 · 10 · 2 · 1). */
+    readonly perWrap: number;
+}
+export type RulerLevels = readonly [RulerLevel, RulerLevel, RulerLevel, RulerLevel, RulerLevel];
+/**
+ * The five levels this frame. `maxAbs` is the largest |value| a label on
+ * screen can carry (`labelReach`) — a level whose widest label would not fit
+ * its pitch carries none, so labels never overlap whatever the coordinates.
+ */
+export declare function rulerLevels(l: Lod, zoom: number, law: RulerLaw, maxAbs?: number): RulerLevels;
+/** A mono glyph's advance as a fraction of its em — the layout's estimate (the atlas carries the measured one; SF Mono is 0.6). */
+export declare const ADVANCE_EM = 0.6;
+/** The finest level that carries labels this frame, or -1 — the level the pass lays text out on. */
+export declare function finestLabelled(levels: RulerLevels): number;
+/** The lattice's wrap count of a camera coordinate: `cam = wraps · period + phase`, exact in doubles (lod.ts wraps the phase). */
+export declare const wrapsOf: (cam: number, period: number) => number;
+/**
+ * The text of a site's label: `index · mult · 10^exp`, plain digits — no
+ * suffixes (a "1k" that reads "1000" at the next zoom would change under the
+ * eye), and no trailing zeros in a fraction ("1.0" is "1" at every level, so
+ * a label's text never changes while it is visible). ruler.wgsl `ruler_char`
+ * is the same arithmetic per character.
+ */
+export declare function formatLabel(index: number, mult: 1 | 2, exp: number): string;
+/** How many characters the widest label of magnitude ≤ `maxAbs` takes at this level (the sign included). */
+export declare function labelChars(maxAbs: number, mult: 1 | 2, exp: number): number;
+/** The largest |world coordinate| a label along an axis can show: the far edge of the band's reach. */
+export declare function labelReach(cam: number, zoom: number, span: number): number;
+export interface RulerLabel {
+    /** The site's world coordinate and its count from the origin at the finest labelled level. */
+    readonly value: number;
+    readonly index: number;
+    /** CSS px along the axis where the site (its tick) stands. */
+    readonly at: number;
+    readonly text: string;
+    readonly alpha: number;
+    /** The site's level — the coarsest it lies on. */
+    readonly level: number;
+}
+/**
+ * The labels along one axis this frame, in order — the CPU mirror of what
+ * ruler.wgsl lays out, site for site: the finest labelled level's sites from
+ * the band's inner corner to the frame's far line, each with the alpha of the
+ * coarsest level it lies on. `cam` is the camera's UNWRAPPED coordinate;
+ * `span` the attachment's extent along the axis (CSS px).
+ */
+export declare function labelsAlong(cam: number, zoom: number, span: number, levels: RulerLevels, law: RulerLaw): RulerLabel[];

package/dist/types/packages/desk/src/marks/assemble.d.ts

@@ -0,0 +1,65 @@
+import { type LaserCamera, type WorldBar, type WorldBox, type WorldGuide } from "./laser";
+import { type MarkBox, type MarkFrame, type MarksInput } from "./layout";
+/** One object as its marks need it — the builder's cached facts and flux, or a still's. */
+export interface MarkedObject {
+    /** Its silhouette AS DRAWN, world units (the kind's `frame` on this frame's geometry). */
+    readonly frame: MarkFrame;
+    /** ICE's rect (Position + Size), unturned, world units — what the snap aligned and the vellum touches. */
+    readonly rect: WorldBox;
+    readonly selected: boolean;
+    /** Taped down (`Locked`): no knobs, and the vellum passes over it. */
+    readonly locked: boolean;
+    /** Carried (`Grab`): its knobs hide, and it is the laser's dragged set. */
+    readonly moving: boolean;
+    readonly resizable: boolean;
+    /** The selection's clocks: the lock-on's LINEAR progress and the presence (1 at rest; the leave fades it). */
+    readonly lock: {
+        readonly t: number;
+        readonly a: number;
+    };
+    /** The tape's clocks: each strip's press (0..1, linear) and the tape's presence (0 = none drawn). */
+    readonly tape: {
+        readonly press: readonly [number, number];
+        readonly a: number;
+    };
+}
+export interface MarksState {
+    readonly view: MarksInput["view"];
+    /** The ROOT slot's camera (`Camera.x/y` = the view's world top-left). */
+    readonly cam: LaserCamera;
+    readonly night: boolean;
+    /** The desk's objects in paint order. */
+    readonly objects: readonly MarkedObject[];
+    /** Several's union: its lock-on (linear) and presence. */
+    readonly union: {
+        readonly t: number;
+        readonly a: number;
+    };
+    /** The vellum being drawn: its WORLD rect (core's `MarqueeBuffer.rect`) and the cursor on screen. */
+    readonly marquee: {
+        readonly rect: WorldBox;
+        readonly pointer: {
+            readonly x: number;
+            readonly y: number;
+        } | null;
+    } | null;
+    /** The vellum released: its last rect ON SCREEN and the fold's linear progress. */
+    readonly fold: {
+        readonly rect: MarkBox;
+        readonly t: number;
+    } | null;
+    /** The snap's facts, world units (core's `GuideLine` / `SpacingBar`). */
+    readonly guides: readonly WorldGuide[];
+    readonly bars: readonly WorldBar[];
+    readonly strike: number;
+    /** The rulers printed on this desk (their margin and band, CSS px), or null. */
+    readonly ruler: {
+        readonly margin: number;
+        readonly band: number;
+    } | null;
+}
+/** The vellum's world rect, normalised (a drag may run any way). */
+export declare const normalBox: (b: WorldBox) => WorldBox;
+/** What the vellum touches — never the tape (Q-g); core's `queryHits` on the same rects. */
+export declare function vellumHits(objects: readonly MarkedObject[], rect: WorldBox): MarkedObject[];
+export declare function assembleMarks(s: MarksState): MarksInput;

package/dist/types/packages/desk/src/marks/ease.d.ts

@@ -0,0 +1,4 @@
+/** `--vf-ease-lift`: cubic-bezier(0.2, 0.9, 0.3, 1.2) — overshoots past 1 on the way. */
+export declare const easeLift: (x: number) => number;
+/** `--vf-ease-island`: cubic-bezier(0.25, 1, 0.3, 1). */
+export declare const easeIsland: (x: number) => number;

package/dist/types/packages/desk/src/marks/laser.d.ts

@@ -0,0 +1,41 @@
+import type { MarkBar, MarkGuide } from "./layout";
+/** A world rect, top-left to bottom-right. */
+export interface WorldBox {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/** A guide as the world states it: a line along `axis` at world `at` (kernel `SnapGuide.position`); its type when the caller knows it. */
+export interface WorldGuide {
+    readonly axis: "x" | "y";
+    readonly at: number;
+    readonly type?: "edge" | "center";
+}
+/** An equal gap as the world states it (core `SpacingBar`): world units. */
+export interface WorldBar {
+    readonly axis: "x" | "y";
+    readonly from: number;
+    readonly to: number;
+    readonly perp: number;
+    readonly gap: number;
+}
+export interface LaserCamera {
+    readonly x: number;
+    readonly y: number;
+    readonly zoom: number;
+}
+/** desk.js `setGuides`: the span a guide is bright over reaches this far (CSS px) past the objects it aligns. */
+export declare const LASER_PAST = 14;
+/**
+ * The laser on screen: each guide's line, type, bright span and flares; each gap's bar. `others` are the rects the
+ * snap aligned against (the objects not dragged), `dragged` the dragged set's union (null: none — a guide with nothing
+ * dragged is still drawn, over what lies on it). An object lies on a line when its edge or centre is within half a
+ * screen px of it (desk.js's 0.05 world units at zoom 1 — relative here, so it holds at every zoom).
+ */
+export declare function laserOf(guides: readonly WorldGuide[], bars: readonly WorldBar[], others: readonly WorldBox[], dragged: WorldBox | null, cam: LaserCamera, past?: number): {
+    readonly guides: MarkGuide[];
+    readonly bars: MarkBar[];
+};
+/** The key a guide set strikes on (desk.js: a NEW alignment flashes) — the axes and positions, then the gaps, at 0.1 (desk.js ran the two lists together; a `#` keeps them apart). */
+export declare function laserKey(guides: readonly WorldGuide[], bars: readonly WorldBar[]): string;

package/dist/types/packages/desk/src/marks/layout.d.ts

@@ -0,0 +1,167 @@
+import { type GlyphAtlasMeta } from "../mat/layout";
+/** One mark, as the shader reads it — see each field's use per kind in marks.wgsl. */
+export declare const MarkStruct: import("../engine").StructDef<"aux" | "shape" | "centre" | "half" | "colour" | "quad">;
+/** The pass's block: the view (CSS px, dpr) and the glyph atlas (width, height in texels, texels per CSS px, cell width in texels). */
+export declare const MarksUniformsStruct: import("../engine").StructDef<"view" | "fade" | "atlas">;
+/** The primitives (marks.wgsl's `MARK_*`). */
+export declare const MARK: {
+    readonly stroke: 0;
+    readonly fill: 1;
+    readonly brackets: 2;
+    readonly segment: 3;
+    readonly bar: 4;
+    readonly flare: 5;
+    readonly glyph: 6;
+    readonly tape: 7;
+};
+/** A mark of light: added, never painted over. */
+export declare const LIGHT = 1;
+export type V4 = readonly [number, number, number, number];
+export interface MarkRecord {
+    readonly shape: V4;
+    readonly centre: V4;
+    readonly half: V4;
+    readonly colour: V4;
+    readonly aux: V4;
+    readonly quad: V4;
+}
+/** A screen rect, CSS px. */
+export interface MarkBox {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/** An object's silhouette as the marks go around it: its centre, half extents, turn and corner — world units from a kind (`frame`), CSS px on screen. */
+export interface MarkFrame {
+    readonly cx: number;
+    readonly cy: number;
+    readonly hx: number;
+    readonly hy: number;
+    readonly angle: number;
+    readonly r: number;
+}
+/**
+ * One object's marks: `brackets` (a sole selection — `t` the lock-on's LINEAR progress 0..1, eased here on
+ * `--vf-ease-lift`; `alpha` its presence, 0 when it has left) or `member` (one of several, or touched by the
+ * vellum: quiet ticks at `alpha`); `knobs` where it resizes and nothing moves it.
+ */
+export interface MarkObject {
+    readonly frame: MarkFrame;
+    readonly style: "brackets" | "member";
+    readonly t: number;
+    readonly alpha: number;
+    readonly knobs: boolean;
+}
+/** Several's union: the members' screen box (the frames' extents), its lock-on and presence. */
+export interface MarkUnion {
+    readonly box: MarkBox;
+    readonly t: number;
+    readonly alpha: number;
+}
+/** The vellum being drawn: its screen rect, what it touches (the count by the cursor), the cursor. */
+export interface MarkMarquee {
+    readonly rect: MarkBox;
+    readonly count: number;
+    readonly pointer: {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+}
+/** A laser guide (kernel `SnapGuide` on screen): its line's `at`, edge or centre, the span it is bright over (the aligned objects' extent), the aligned corners (flares). */
+export interface MarkGuide {
+    readonly axis: "x" | "y";
+    readonly at: number;
+    readonly type: "edge" | "center";
+    readonly span: readonly [number, number];
+    readonly points: readonly (readonly [number, number])[];
+}
+/** An equal gap (core `SpacingBar` on screen): along `axis` from → to at `perp`, its size in WORLD units (the number). */
+export interface MarkBar {
+    readonly axis: "x" | "y";
+    readonly from: number;
+    readonly to: number;
+    readonly perp: number;
+    readonly gap: number;
+}
+/** A taped object's tape: its frame on screen, CSS px per object unit (the zoom, the lift), each strip's press (0..1, linear), the tape's presence. */
+export interface MarkTape {
+    readonly frame: MarkFrame;
+    readonly units: number;
+    readonly press: readonly [number, number];
+    readonly alpha: number;
+}
+/** Your extent on the rulers: the selection's screen box, its world edges, and the rulers' margin and band (CSS px). */
+export interface MarkRuler {
+    readonly sel: MarkBox;
+    readonly world: MarkBox;
+    readonly margin: number;
+    readonly band: number;
+}
+export interface MarksInput {
+    readonly view: {
+        readonly width: number;
+        readonly height: number;
+        readonly dpr: number;
+    };
+    /** The Moon is up: the tape is moonlit and the vellum cooler; the pencil and the laser are light and do not change. */
+    readonly night: boolean;
+    readonly tape: readonly MarkTape[];
+    readonly objects: readonly MarkObject[];
+    readonly union: MarkUnion | null;
+    readonly marquee: MarkMarquee | null;
+    readonly guides: readonly MarkGuide[];
+    readonly bars: readonly MarkBar[];
+    /** A new alignment's strike, 1 … 0 over 160 ms: the bloom and the flares at up to 1.8×. */
+    readonly strike: number;
+    readonly ruler: MarkRuler | null;
+}
+/** A frame with nothing marked. */
+export declare const NO_MARKS: (view: MarksInput["view"], night?: boolean) => MarksInput;
+/** A bracket's reach: never over 30 % of the frame's side, never under its corner + 2 (chrome.js `bracketsPath`). */
+export declare const bracketReach: (reach: number, X: number, Y: number, R: number) => number;
+/** A sole selection's frame at lock-on progress `t`: how far out it stands (6 at rest, 8 further as it arrives), its corner, its presence at `alpha`. */
+export declare function selectionGeometry(f: MarkFrame, t: number, alpha: number): {
+    readonly gap: number;
+    readonly X: number;
+    readonly Y: number;
+    readonly R: number;
+    readonly a: number;
+    readonly collapsed: boolean;
+};
+/** How wide a string sets in the atlas, CSS px (10 px mono: a 6 px advance before an atlas is here). */
+export declare function textWidth(text: string, atlas: GlyphAtlasMeta): number;
+/** A number the desk states: a rounded pill 8 wider than its text and 15 tall, the text centred in it (chrome.js `pill`). */
+export declare function pillBox(x: number, y: number, s: string, align: "center" | "left" | "right", atlas: GlyphAtlasMeta): MarkBox;
+/**
+ * The tray's name tags' look (K5b, D-K5b.7 — a call for James; one word switches back): `"tape"` — a strip of LABEL-MAKER tape stuck
+ * to the board under each specimen, its capitals embossed; `"pill"` — K5a's marks-style chip.
+ */
+export declare const TRAY_TAG_STYLE: "tape" | "pill";
+/**
+ * A NAME TAG (design-017 §8; K5a — under each of the tray's specimens), centred at (x, y) — screen px, the label in the rulers' capitals
+ * (the atlas holds no other case): by `TRAY_TAG_STYLE`, a strip of embossed label tape (K5b) or the marks' pill in the paper's white with
+ * the pencil's ink (K5a). By night (`night` 0 … 1) each steps back as a card does under the Moon.
+ */
+export declare function tagMarks(label: string, x: number, y: number, atlas: GlyphAtlasMeta, dpr: number, night?: number, style?: "tape" | "pill"): MarkRecord[];
+/** The two strips on screen: centre, half extents, turn, presence — each pressed from 1.22× on `--vf-ease-lift`. */
+export declare function tapeStrips(t: MarkTape): {
+    readonly cx: number;
+    readonly cy: number;
+    readonly hx: number;
+    readonly hy: number;
+    readonly angle: number;
+    readonly alpha: number;
+}[];
+/** Every mark this frame, in paint order, for the pass. `atlas` = the rulers' glyph atlas (the numbers; none = no numbers). */
+export declare function layoutMarks(input: MarksInput, atlas?: GlyphAtlasMeta): MarkRecord[];
+/** The screen box of the frames (each turned frame's extent) — several's union, the menu's anchor. */
+export declare function framesBox(frames: readonly MarkFrame[]): MarkBox | null;
+/** A world frame under a camera (`Camera.x/y` = the view's world top-left), CSS px — the marks' one conversion. */
+export declare function frameOnScreen(f: MarkFrame, cam: {
+    readonly x: number;
+    readonly y: number;
+    readonly zoom: number;
+}): MarkFrame;
+/** The box the marks around a selection occupy on screen — the brackets' (6 out) or the union's (10 out): the selection menu's anchor. */
+export declare function selectionBox(frames: readonly MarkFrame[]): MarkBox | null;

package/dist/types/packages/desk/src/marks/pass.d.ts

@@ -0,0 +1,59 @@
+import type { MatPass } from "../kit/view";
+import { type MarkRecord, type MarksInput } from "./layout";
+import type { MarksShaders } from "./shaders";
+export declare class MarksPass {
+    private readonly device;
+    private readonly mat;
+    private readonly pipeline;
+    private readonly layout;
+    private readonly sampler;
+    private readonly uniformBuf;
+    private readonly uniforms;
+    private records;
+    private recordBuf;
+    private group;
+    private boundAssets;
+    private count;
+    private tags;
+    private last;
+    private lastTags;
+    private constructor();
+    /** The pipeline on `format`, sampling `mat`'s glyph atlas (the root's: its assets are every slot's). */
+    static create(device: GPUDevice, format: GPUTextureFormat, src: MarksShaders, mat: MatPass): Promise<MarksPass>;
+    /**
+     * Lay this frame's marks out and upload them (before the frame's pass begins); after them, the tray's NAME TAGS (K5a — drawn apart,
+     * `drawTags`, where the tray says). Returns the count of the frame's marks that will draw (`draw`).
+     */
+    prepare(input: MarksInput | undefined, tray?: {
+        readonly view: {
+            readonly width: number;
+            readonly height: number;
+            readonly dpr: number;
+        };
+        readonly tags: readonly {
+            readonly label: string;
+            readonly x: number;
+            readonly y: number;
+        }[];
+        readonly night?: number;
+        readonly fade?: {
+            readonly top: number;
+            readonly band: number;
+        } | undefined;
+    }): number;
+    /** The pipeline and its group, bound (rebound when the mat's assets or the records' buffer changed). */
+    private bind;
+    /** The marks into the open pass — over everything drawn so far (the caller resets the scissor to the view). */
+    draw(pass: GPURenderPassEncoder): void;
+    /** The tray's name tags (K5a) into the open pass, under the caller's scissor (the drawer's face). */
+    drawTags(pass: GPURenderPassEncoder): void;
+    /** The tray's name tags laid by the last prepare. */
+    get tagCount(): number;
+    /** …and their records (a rig's witness). */
+    get tagsLaid(): readonly MarkRecord[];
+    /** Marks drawn by the last prepare. */
+    get drawn(): number;
+    /** The last prepare's records — a rig's and a check's witness (what was drawn, where). */
+    get laid(): readonly MarkRecord[];
+    dispose(): void;
+}

package/dist/types/packages/desk/src/marks/shaders.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderPart } from "../engine/shader";
+export interface MarksShaders {
+    readonly modules: readonly ShaderPart[];
+    readonly entry: ShaderPart;
+}
+export interface MarksShaderText {
+    readonly primitives: string;
+    readonly marks: string;
+    readonly marksPass: string;
+}
+export declare const MARKS_SHADER_FILES: Record<keyof MarksShaderText, string>;
+export declare function marksShaders(t: MarksShaderText): MarksShaders;

package/dist/types/packages/desk/src/mat/grid.d.ts

@@ -0,0 +1,50 @@
+import { type FadeIn, type View } from "../lattice/lod";
+import type { Presentation } from "../nav/portal";
+import { type MatConfig, type MatFrame, type SlotLight } from "./layout";
+export interface GridConfig {
+    /** A rung fades in between these cell sizes, CSS px (lod.ts `FadeIn`) — the mat's lines, the rulers' ticks, a mini mat's face. */
+    readonly fadeIn: FadeIn;
+    /** The cutting mat's tuning (mat/layout.ts) — theme.ts's numbers unless a host tweaks them. */
+    readonly mat: MatConfig;
+}
+/** The engine's grid: the fade-in law and the mat as theme.ts has them. */
+export declare const DEFAULT_GRID: GridConfig;
+/** One slot's frame: the root's, a flight's departed one, or a mini mat's inside. */
+export interface SlotFrame {
+    readonly view: View & {
+        readonly dpr: number;
+    };
+    /**
+     * The zoom this slot's lattice is DRESSED for (PORTAL.md §9): its fade-in window scales by
+     * `view.zoom / lodZoom`, so the grid looks like the grid at `lodZoom`, scaled — a mini mat's
+     * face shows its inside as it will look at the arrival, an arriving slot lands on its own
+     * dressing, a departed one keeps the cut's. Absent = the view's zoom: the root at rest.
+     */
+    readonly lodZoom?: number;
+    /** The mat's clocks and tilt for this frame; absent = a still (STILL_MAT_FRAME). */
+    readonly mat?: MatFrame;
+    /** Opacity and the portal clip (nav/portal.ts); absent = everything, at full strength. */
+    readonly present?: Presentation;
+    /**
+     * The lamp this slot is lit by (MINIMAT.md §4; mat/layout.ts `SlotLight`). Absent = the
+     * host's: a mini mat's inside lies under the lamp of the desk the mini mat lies on, so the
+     * ground hands every nested slot its parent's light, and the root its own camera.
+     */
+    readonly light?: SlotLight;
+}
+/**
+ * The scale a lattice is dressed by for `lodZoom` (PORTAL.md §9): `σ = zoom / lodZoom` — the
+ * lattice at `lodZoom` scaled whole — floored at `GRID.dressFloor` (a miniature's grid is never
+ * finer than that share of the desk's). 1 = the identity: the object itself, not a copy.
+ */
+export declare function dressScale(zoom: number, lodZoom?: number): number;
+/** The grid a slot renders with when dressed for `lodZoom`: its fade-in window scaled by `dressScale`. */
+export declare function dressGrid(cfg: GridConfig, zoom: number, lodZoom?: number): GridConfig;
+/** What a slot's grid did this frame: the lattice's decade and its fade, and whether the wind blew. */
+export interface GridStats {
+    readonly k0: number;
+    readonly fade: number;
+    readonly wind: boolean;
+}
+/** The stats of a view's lattice (the wind the pass reports). */
+export declare const gridStats: (view: View, wind: boolean) => GridStats;

package/dist/types/packages/desk/src/mat/lamp.d.ts

@@ -0,0 +1,14 @@
+import { type ProjectorSpec } from "./projector";
+/** The lamp over the desk in WORLD units: where it stands on the plane, and how high above it. */
+export interface Lamp {
+    readonly x: number;
+    readonly y: number;
+    readonly h: number;
+}
+/** The gobo projector as a lamp on the world plane (mat.wgsl `desk_of` inverted: world = (desk − origin) / metresPerUnit). */
+export declare function lampOf(plane: {
+    readonly originX: number;
+    readonly originZ: number;
+    readonly metresPerUnit: number;
+    readonly deskY: number;
+}, p?: ProjectorSpec): Lamp;

package/dist/types/packages/desk/src/mat/layout.d.ts

@@ -0,0 +1,144 @@
+import { type FadeIn, type View } from "../lattice/lod";
+import type { LineLaw } from "../lattice/line";
+import { type RulerLaw } from "../lattice/ruler";
+import { type RGB } from "../theme";
+import { type Presentation } from "../nav/portal";
+import type { CameraState } from "../nav/flight";
+import { type Mat4 } from "./projector";
+import { type MatLight } from "./night";
+export declare const MatUniforms: import("../engine").StructDef<"ground" | "view" | "light" | "phase" | "presence" | "cam" | "rungs" | "lod" | "line" | "grain" | "ink" | "plane" | "goboMatrix" | "goboParams" | "gobo" | "grade" | "noise" | "wind" | "night" | "moon" | "rod" | "eigengrau" | "portals" | "clips" | "ruler" | "rulerText" | "rulerAlpha" | "rulerOrigin" | "rulerGlyph" | "rulerAtlas" | "rulerSites" | "rulerFormat" | "box" | "light2">;
+export type PlateName = "c" | "b";
+/** The rulers printed on the mat (RULER.md): the law's numbers, and whether this slot prints them at all — the ROOT does, a portal's inside never. */
+export interface RulerConfig extends RulerLaw {
+    readonly on: boolean;
+}
+/**
+ * What the pass knows about the glyph atlas it samples for the labels
+ * (`MatPass.setGlyphs`): "0123456789-." in that order, one cell each, drawn
+ * `PAD` texels in from the cell's left edge with the baseline `baseline`
+ * texels under the cell's top, at `scale` texels per CSS px of the ruler's
+ * text size. The lab renders it from the product's mono stack at the device's
+ * ratio; the oracle reads a committed one (lab/assets/glyphs-mono-2x.r8).
+ */
+export interface GlyphAtlasMeta {
+    readonly scale: number;
+    readonly cellW: number;
+    readonly cellH: number;
+    readonly advance: number;
+    readonly baseline: number;
+    readonly cap: number;
+    readonly width: number;
+    readonly height: number;
+    readonly count: number;
+}
+/** Texels between a cell's left edge and its glyph's origin — room for a bearing either way. */
+export declare const GLYPH_PAD = 2;
+/**
+ * The glyphs the atlas holds, in cell order: the rulers' twelve first (ruler.wgsl indexes them by
+ * this), then the capitals and the few marks a mini mat's printed NAME may use (MINIMAT.md §2) —
+ * the design's print label is mono capitals. An atlas holds at least the rulers' twelve.
+ */
+export declare const GLYPHS: string;
+/** The rulers' own glyphs — the first this many of `GLYPHS`, what every atlas must hold. */
+export declare const RULER_GLYPHS = 12;
+/** No atlas uploaded: a 1×1 empty cell — labels sample nothing. */
+export declare const NO_GLYPHS: GlyphAtlasMeta;
+/** The mat's tuning — theme.ts's numbers unless a host tweaks them. */
+export interface MatConfig {
+    readonly line: LineLaw;
+    readonly grain: number;
+    readonly ground: RGB;
+    readonly ink: RGB;
+    readonly gobo: {
+        readonly opacity: number;
+        readonly blurTexels: number;
+        readonly shadeMix: number;
+        readonly darkFloor: number;
+        readonly saturate: number;
+        readonly sharp: number;
+        readonly soft: number;
+        readonly plate: PlateName;
+    };
+    readonly plane: {
+        readonly metresPerUnit: number;
+        readonly originX: number;
+        readonly originZ: number;
+        readonly deskY: number;
+    };
+    /** The rulers (RULER.md); off unless a host prints them on this slot. */
+    readonly ruler: RulerConfig;
+}
+/**
+ * The LIGHT a slot is lit by (MINIMAT.md §4) — the camera the lamp's gobo is sampled under, not the one
+ * the slot draws under. The root at rest is lit by its own lamp (absent = that). A mini mat's inside is
+ * lit by the lamp of the desk the mini mat lies on — `a` is the host's camera — so the dapple runs across
+ * the mini mat as across any object on the desk. While a flight, or a zoom-through's re-dressing, hands
+ * one desk's lamp to the other, the two are cross-faded: `t` of the way to `b`. Each camera is in the
+ * frame it belongs to; none need share the slot's.
+ */
+export interface SlotLight {
+    readonly a: CameraState;
+    readonly b?: CameraState;
+    readonly t?: number;
+}
+/** What moves per frame — the host owns every clock and the tilt. */
+export interface MatFrame {
+    /** Seconds; drives the grain's drift. */
+    readonly time: number;
+    /** Seconds; drives the wind. Advanced by the host at its wind speed. */
+    readonly goboTime: number;
+    /** `projection · view` (· tilt), column-major — `projector.ts`. */
+    readonly goboMatrix: Mat4;
+    /** Blue-noise UV offset for this frame — random while animating, fixed for a still. */
+    readonly noise: readonly [number, number];
+}
+export declare const DEFAULT_MAT_CONFIG: MatConfig;
+export declare const HERO_MATRIX: Mat4;
+export declare const STILL_MAT_FRAME: MatFrame;
+export declare const NOISE_SIZE = 128;
+export declare const PLATE_SIZE = 512;
+export declare function matUniformValues(view: View & {
+    readonly dpr: number;
+}, fadeIn: FadeIn, cfg: MatConfig, f: MatFrame, plateStrength: number, present?: Presentation, light?: MatLight, glyphs?: GlyphAtlasMeta, lit?: SlotLight): {
+    presence: number[];
+    light: number[];
+    light2: number[];
+    ruler: number[];
+    rulerText: number[];
+    rulerAlpha: number[];
+    rulerOrigin: number[];
+    rulerGlyph: number[];
+    rulerAtlas: number[];
+    rulerSites: number[];
+    rulerFormat: number[];
+    box: number[];
+    portals: number[];
+    clips: number[];
+    night: number[];
+    moon: number[];
+    rod: number[];
+    eigengrau: number[];
+    cam: number[];
+    view: number[];
+    phase: number[];
+    rungs: number[];
+    lod: number[];
+    line: number[];
+    grain: number[];
+    ground: number[];
+    ink: number[];
+    plane: number[];
+    goboMatrix: Mat4;
+    goboParams: number[];
+    gobo: number[];
+    grade: number[];
+    noise: number[];
+    wind: number[];
+};
+/**
+ * A light with its ends collapsed: a handover at t ≤ 0 is `a` alone, at t ≥ 1 `b` alone — so a slot
+ * at either end of one is lit through exactly the path a slot lit by that camera always takes.
+ */
+export declare function settleLight(lit: SlotLight | undefined): SlotLight | undefined;
+/** Is a slot lit by its own camera — no light, or one that settles on the camera it draws under? */
+export declare function litByOwn(view: View, lit: SlotLight | undefined): boolean;