@vibecook/ice 0.11.0 → 0.14.0

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;

package/dist/types/packages/desk/src/mat/mat-pass.d.ts

@@ -0,0 +1,83 @@
+import type { FadeIn, View } from "../lattice/lod";
+import type { Presentation } from "../nav/portal";
+import { type GlyphAtlasMeta, type MatConfig, type MatFrame, type PlateName, type SlotLight } from "./layout";
+import { type MatLight } from "./night";
+import type { MatPass } from "../kit/view";
+import type { MatShaders } from "./shaders";
+export declare class CuttingMat implements MatPass {
+    readonly name = "mat/mat";
+    private readonly uniforms;
+    private readonly uniformBuf;
+    /** The wind target this slot samples: its plate's shared one, or its own (`own`) after a clash in one frame. */
+    private wind;
+    /** This slot's own wind target, made only when two keys meet on one plate in one frame. */
+    private own;
+    private windGroups;
+    private matGroup;
+    private bound;
+    private boundWind;
+    /** Turns over whenever this slot's bind groups are made again — a shared asset landed, or the slot samples another silhouette. */
+    private assets;
+    private windRuns;
+    /** The view block as last uploaded (K7a: uploaded only when its bytes moved; a layered kind compares a layer's view by it). */
+    private readonly sentView;
+    private viewSent;
+    private readonly device;
+    private readonly shared;
+    private constructor();
+    static create(device: GPUDevice, format: GPUTextureFormat, src: MatShaders): Promise<CuttingMat>;
+    /** A second slot on the same pipelines and plates — a flight's departed mat, a mini mat's inside. */
+    spawn(): CuttingMat;
+    /** Which assets a host has uploaded — stats, and the lab's boot line. Shared by every slot. */
+    get loaded(): {
+        readonly c: boolean;
+        readonly b: boolean;
+        readonly noise: boolean;
+        readonly glyphs: boolean;
+    };
+    /** What the pass knows about the glyph atlas it samples (RULER.md). */
+    get glyphs(): GlyphAtlasMeta;
+    /** This slot's animated silhouette — the wind target the mat samples; the paper pass (STICKY.md) samples the same, so a note takes the mat's dapple. */
+    get silhouette(): GPUTextureView;
+    /** The slot's ONE VIEW BLOCK (K4a, design-016 K-L3): the uniforms this mat writes once a frame, which every kind in the slot binds. */
+    get view(): GPUBuffer;
+    /** The glyph atlas as uploaded (a 1×1 empty cell until a host uploads one) — the mini mat pass prints with it. */
+    get glyphTexture(): GPUTexture;
+    /** The shared blue noise, as uploaded (a 1×1 grey until a host uploads the tile). */
+    get noiseTexture(): GPUTexture;
+    /** Bumped whenever a shared asset lands or the slot samples another silhouette — a pass that binds them rebinds on a change. */
+    get assetVersion(): number;
+    get viewBytes(): Uint8Array;
+    get silhouetteKey(): number;
+    /** A new frame (the ground's `prepareFrame`, before its slots prepare): a wind key drawn before it may be drawn over. */
+    newFrame(): void;
+    /** A plate's shared wind target, made on first use. */
+    private windOf;
+    private upload;
+    /** (Re)build this slot's bind groups against the shared assets' current version. */
+    private rebind;
+    /** A 512×512 rgba8 plate: R silhouette, G wind amp 1, B phase, A amps 2+3 (assets/gobo-*.rgba). Every slot samples it. */
+    setPlate(name: PlateName, bytes: Uint8Array<ArrayBuffer>): void;
+    /** The 128×128 rgba8 blue-noise tile (assets/blue-noise.rgba). Every slot samples it. */
+    setNoise(bytes: Uint8Array<ArrayBuffer>): void;
+    /**
+     * The glyph atlas (RULER.md): r8 coverage, `meta.width × meta.height` texels, the
+     * first `meta.count` glyphs of `GLYPHS` in a row of `meta.cellW` cells — at least the
+     * rulers' twelve; the capitals after them print a mini mat's name (MINIMAT.md §2).
+     * Every slot samples it (the mini mat pass too); a host re-uploads when the device's
+     * ratio or the text size changes.
+     */
+    setGlyphs(bytes: Uint8Array<ArrayBuffer>, meta: GlyphAtlasMeta): void;
+    get windPasses(): number;
+    /**
+     * Upload the uniforms (under `light` — the theme's Sun or Moon, mat/night.ts — through the lamp `lit`
+     * says: the slot's own when absent, the host desk's for a mini mat's inside, MINIMAT.md §4); run the
+     * wind pass if the silhouette it holds is stale. Returns whether it ran.
+     */
+    prepare(encoder: GPUCommandEncoder, view: View & {
+        readonly dpr: number;
+    }, fadeIn: FadeIn, cfg: MatConfig, frame: MatFrame, present?: Presentation, light?: MatLight, lit?: SlotLight): boolean;
+    draw(pass: GPURenderPassEncoder): void;
+    /** This slot's buffers; the shared plates go with the last slot standing. */
+    dispose(): void;
+}