@vibecook/ice 0.10.0 → 0.14.0

package/dist/chunk-BA7XJC27.js

@@ -0,0 +1,2429 @@
+import {
+  bindLayout,
+  defineStruct
+} from "./chunk-QXOCF56A.js";
+import {
+  ChildOf,
+  HeldPress,
+  LocalPointer,
+  Pointer,
+  defineComponent,
+  definePrefab,
+  defineQuery,
+  field,
+  init
+} from "./chunk-DYK6KNLG.js";
+
+// ../desk/src/lattice/lod.ts
+var BASE_SPACING = 20;
+var LOD_TARGET = 20;
+var ZOOM_MIN = 1e-8;
+var ZOOM_MAX = 1e8;
+var boxOf = (v) => v.box ?? { x: 0, y: 0, w: v.width, h: v.height };
+var boxValues = (v) => {
+  const b = boxOf(v);
+  return [b.x, b.y, b.w, b.h];
+};
+var smoothstep = (a, b, x) => {
+  const t = Math.min(Math.max((x - a) / Math.max(b - a, 1e-3), 0), 1);
+  return t * t * (3 - 2 * t);
+};
+function lod(v) {
+  const screenCell = BASE_SPACING * v.zoom;
+  const logc = Math.log(Math.max(screenCell, 1e-20) / LOD_TARGET) / Math.LN10;
+  const floorLog = Math.floor(logc);
+  const k0 = Math.min(12, Math.max(-12, 0 - floorLog));
+  const fade = logc - floorLog;
+  const mid = BASE_SPACING * 10 ** k0;
+  return { k0, fade, fine: mid / 10, mid, coarse: mid * 10, wrapPeriod: mid * 10 };
+}
+
+// ../desk/src/mat/night.ts
+var DAY_LIGHT = { night: 0, lux: 0, exposure: 0, snow: 0, moon: [1, 1, 1], fill: 0, rod: [1, 1, 1], eigengrau: [0, 0, 0] };
+var RGB2XYZ = [[0.4124564, 0.3575761, 0.1804375], [0.2126729, 0.7151522, 0.072175], [0.0193339, 0.119192, 0.9503041]];
+var XYZ2RGB = [[3.2404542, -1.5371385, -0.4985314], [-0.969266, 1.8760108, 0.041556], [0.0556434, -0.2040259, 1.0572252]];
+var mul = (M, v) => [M[0][0] * v[0] + M[0][1] * v[1] + M[0][2] * v[2], M[1][0] * v[0] + M[1][1] * v[1] + M[1][2] * v[2], M[2][0] * v[0] + M[2][1] * v[1] + M[2][2] * v[2]];
+var tri = (f) => [f(0), f(1), f(2)];
+var srgbToLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var linear = (c) => [srgbToLinear(c[0]), srgbToLinear(c[1]), srgbToLinear(c[2])];
+var luminance = (c) => RGB2XYZ[1][0] * c[0] + RGB2XYZ[1][1] * c[1] + RGB2XYZ[1][2] * c[2];
+function scotopic(c) {
+  const [X, Y, Z] = mul(RGB2XYZ, c);
+  return Y * (1.33 * (1 + (Y + Z) / Math.max(X, 1e-6)) - 1.68);
+}
+var SCOTOPIC_WHITE = scotopic([1, 1, 1]);
+var rodSignal = (c) => Math.max(scotopic(c), 0) / SCOTOPIC_WHITE;
+var mesopicWeight = (L) => Math.min(Math.max(0.767 + 0.3334 * Math.log10(Math.max(L, 1e-9)), 0), 1);
+var degreeOfAdaptation = (LA, F) => F * (1 - 1 / 3.6 * Math.exp((-LA - 42) / 92));
+function planckianXY(T) {
+  const t = 1 / T;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const x = T <= 4e3 ? -266123900 * t3 - 234358.9 * t2 + 877.6956 * t + 0.17991 : -3025846900 * t3 + 21070379e-1 * t2 + 222.6347 * t + 0.24039;
+  const x2 = x * x;
+  const x3 = x2 * x;
+  const y = T <= 2222 ? -1.1063814 * x3 - 1.3481102 * x2 + 2.18555832 * x - 0.20219683 : T <= 4e3 ? -0.9549476 * x3 - 1.37418593 * x2 + 2.09137015 * x - 0.16748867 : 3.081758 * x3 - 5.8733867 * x2 + 3.75112997 * x - 0.37001483;
+  return [x, y];
+}
+var xyToLinear = (x, y) => mul(XYZ2RGB, [x / y, 1, (1 - x - y) / y]);
+var D65 = [0.3127, 0.329];
+var LOCUS = [[470, 0.1241, 0.0578], [475, 0.1096, 0.0868], [480, 0.0913, 0.1327], [485, 0.0687, 0.2007], [490, 0.0454, 0.295], [495, 0.0235, 0.4127], [500, 82e-4, 0.5384]];
+function spectralXY(nm) {
+  const w = Math.min(Math.max(nm, LOCUS[0][0]), LOCUS[6][0]);
+  let i = 0;
+  while (i < LOCUS.length - 2 && LOCUS[i + 1][0] <= w) i++;
+  const [w0, x0, y0] = LOCUS[i];
+  const [w1, x1, y1] = LOCUS[i + 1];
+  const t = (w - w0) / (w1 - w0);
+  return [x0 + (x1 - x0) * t, y0 + (y1 - y0) * t];
+}
+function hueTint(nm, purity) {
+  const [sx, sy] = spectralXY(nm);
+  return xyToLinear(D65[0] + (sx - D65[0]) * purity, D65[1] + (sy - D65[1]) * purity);
+}
+var dayLuminance = (groundSrgb) => luminance(linear(linear(groundSrgb)));
+function nightReport(light, albedoLinear, shade) {
+  const cone = [albedoLinear[0] * light.moon[0] * shade, albedoLinear[1] * light.moon[1] * shade, albedoLinear[2] * light.moon[2] * shade];
+  const rod = rodSignal(cone);
+  const m = mesopicWeight(light.lux * luminance(cone) / Math.PI);
+  return tri((i) => (1 - m) * rod * light.rod[i] + m * cone[i]);
+}
+function nightLight(spec, groundSrgb) {
+  const ground = linear(groundSrgb);
+  const [px, py] = planckianXY(spec.kelvin);
+  const moonRaw = xyToLinear(px, py);
+  const D = degreeOfAdaptation(spec.lux * luminance(ground) / Math.PI, spec.surround);
+  const moon = [1 + (1 - D) * (moonRaw[0] - 1), 1 + (1 - D) * (moonRaw[1] - 1), 1 + (1 - D) * (moonRaw[2] - 1)];
+  const eigengrau = linear(spec.eigengrau);
+  const light = { night: 1, lux: spec.lux, exposure: 1, snow: spec.snow, moon, fill: spec.fill, rod: hueTint(spec.rodHue.nm, spec.rodHue.purity), eigengrau };
+  const above = Math.max(spec.litLuminance - luminance(eigengrau), 0);
+  return { ...light, exposure: above / Math.max(luminance(nightReport(light, ground, 1)), 1e-9) };
+}
+function lightValues(l) {
+  return {
+    night: [l.night, l.lux, l.exposure, l.snow],
+    moon: [l.moon[0], l.moon[1], l.moon[2], l.fill],
+    rod: [l.rod[0], l.rod[1], l.rod[2], 0],
+    eigengrau: [l.eigengrau[0], l.eigengrau[1], l.eigengrau[2], 0]
+  };
+}
+function mixLight(a, b, t) {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  const l = (x, y) => x + (y - x) * t;
+  const c = (x, y) => [l(x[0], y[0]), l(x[1], y[1]), l(x[2], y[2])];
+  return { night: l(a.night, b.night), lux: l(a.lux, b.lux), exposure: l(a.exposure, b.exposure), snow: l(a.snow, b.snow), moon: c(a.moon, b.moon), fill: l(a.fill, b.fill), rod: c(a.rod, b.rod), eigengrau: c(a.eigengrau, b.eigengrau) };
+}
+
+// ../desk/src/theme.ts
+function cssColor(css) {
+  const s = css.trim().toLowerCase();
+  let m = /^#([0-9a-f]{6})$/.exec(s);
+  if (m) {
+    const v = Number.parseInt(m[1], 16);
+    return [(v >> 16 & 255) / 255, (v >> 8 & 255) / 255, (v & 255) / 255, 1];
+  }
+  m = /^rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)\s*(?:[/,]\s*([\d.]+)(%?))?\s*\)$/.exec(s);
+  if (m) {
+    const a = m[4] === void 0 ? 1 : m[5] === "%" ? Number(m[4]) / 100 : Number(m[4]);
+    return [Number(m[1]) / 255, Number(m[2]) / 255, Number(m[3]) / 255, a];
+  }
+  throw new Error(`theme: unparsed colour "${css}"`);
+}
+var rgb = (css) => cssColor(css).slice(0, 3);
+var GRID = { fadeIn: [10, 20], dressFloor: 0.5 };
+var MAT = {
+  ground: { token: "hero cuttingMatAlbedo `sage`", css: "#86a078" },
+  // 134 160 120
+  line: { token: "hero cuttingMatAlbedo `cream`", css: "#e8dcbe" },
+  // 232 220 190
+  /** The colour a desk object's shadow casts ON the mat — the tree-shadow design system's `--cast-rgb` (mat.css: "the world's darkest value"). */
+  cast: { token: "tree-shadow design mat.css `--cast-rgb`", css: "#0e1a0a" }
+  // 14 26 10
+};
+var MAT_COLORS = { ground: rgb(MAT.ground.css), line: rgb(MAT.line.css), cast: rgb(MAT.cast.css) };
+var MAT_GRID = {
+  line: { thin: 0.5, thick: 0.75, alphaThin: 0.14, alphaThick: 0.28 },
+  /** ±8/255 on the green channel (0.4× red, 0.35× blue): static hash + drifting value noise + blue noise. */
+  grain: 8 / 255,
+  gobo: {
+    opacity: 1,
+    /** `getGoboBlurRatio(z, params) * 2.0` — the blur radius in plate texels at full softness. */
+    blurTexels: 2,
+    /** heroFrag: `shade = mix(1, coaster·(0.5 + 0.5·gobo), 0.975)`; then HSB s += (1−shade)·0.1, v *= shade. */
+    shadeMix: 0.975,
+    darkFloor: 0.5,
+    saturate: 0.1,
+    /** scenes.js `hero.params` — the blur ramp's two linear depths (metres from the projector). */
+    sharp: 0.372991,
+    soft: 0.79059,
+    /** The plates: R silhouette, G wind amp 1, B phase, A amps 2+3; each with its wind strength. */
+    plates: { c: { strength: 0.38847005 }, b: { strength: 0.4630597 } },
+    plate: "c",
+    /** gobo.js: `time += dt·(speed + 1 + r)` at speed 4; the lab's 0 = frozen. */
+    wind: 5,
+    /** hero `mouseStrength` — radians of projector tilt per unit of smoothed pointer NDC. */
+    tilt: 3e-3
+  },
+  /**
+   * The RULERS printed along the mat's top and left edges (RULER.md — James's mockup of
+   * 2026-09-23, measured at its 1.6×: a 41 px band under a 41 px margin, 12 px numerals,
+   * ticks 9 · 15 · 24, 1–2 px lines): one MODULE for the unprinted margin and one for the
+   * band; 1 px lines; the text 10 px mono (DESIGN.md §3's caption size, the product's
+   * `--vf-font-mono`) 5 px in from the outer line and 3 px after its tick; the ink the
+   * mat's own cream at these presences. The fine rung's ticks arrive over a 6 → 9 px pitch
+   * (a ruler's mm under its cm; at 5 the comb read busy) and a level's labels over 50 → 70 px,
+   * so labels sit 50–250 px apart at every zoom (lattice/ruler.ts).
+   */
+  ruler: {
+    band: 26,
+    margin: 26,
+    tick: [6, 9, 15],
+    line: 1,
+    alpha: { frame: 0.55, tick: 0.85, label: 0.85 },
+    ticksFrom: [6, 9],
+    labelsFrom: [50, 70],
+    text: { size: 10, top: 5, gap: 3 },
+    maxChars: 9
+  },
+  /**
+   * World → desk: the hero's view at its default height is 0.2227 m over the
+   * window's height (900 px in the reference shots), so one world unit (a CSS
+   * px at zoom 1) is 0.2227 / 900 m and the dapple spans the same screen at
+   * zoom 1. The mat's centre (the reference's coaster) is world (0, 0); the
+   * desk plane is `y = 0.7471` in the projector's frame.
+   */
+  plane: { metresPerUnit: 0.2227 / 900, originX: -0.0105761, originZ: -0.0485146, deskY: 0.7471 }
+};
+var NIGHT = {
+  /** Full moonlight is REDDER than sunlight — ≈ 4100 K against the Sun's ≈ 5500 (Ciocca & Wang 2013); the blue of a moonlit scene is the eye's, not the light's. */
+  kelvin: 4100,
+  /** A full Moon high in a clear sky: 0.1–0.3 lux on the ground, a million times under the Sun's. Where on the mesopic ramp the eye sits. */
+  lux: 0.2,
+  /** The sky's share in the shadow — the same air scatters the same fraction of the Moon as of the Sun, ≈ 0.15–0.2 of the direct light at 45°. */
+  fill: 0.18,
+  /** The rods' signal drawn as a colour: white pulled 18 % toward 485 nm — the low-purity blue the night-rendering literature gives scotopic vision (Jensen et al. 2000; Khan & Pattanaik 2004). */
+  rodHue: { nm: 485, purity: 0.18 },
+  /** Eigengrau — the "intrinsic grey" the eye reports with no light at all (the rods' own dark noise); the value the term is given. */
+  eigengrau: { token: "Eigengrau (the dark's own grey)", css: "#16161d" },
+  /** The appearance's one scale: the moonlit sage is drawn at HALF the sunlit one's displayed luminance — the million can't be shown; the adapted eye's report is. */
+  litOverDay: 0.5,
+  /** The rods' own noise on the display: ±2/255, blue noise, achromatic. */
+  snow: 4 / 255,
+  /** CIECAM02's surround factor for the eye's adaptation to the Moon's colour: 0.8, a dark surround. */
+  surround: 0.8
+};
+var EIGENGRAU = rgb(NIGHT.eigengrau.css);
+var MAT_LIGHT = {
+  light: DAY_LIGHT,
+  dark: nightLight({
+    kelvin: NIGHT.kelvin,
+    lux: NIGHT.lux,
+    fill: NIGHT.fill,
+    rodHue: NIGHT.rodHue,
+    eigengrau: EIGENGRAU,
+    litLuminance: NIGHT.litOverDay * dayLuminance(MAT_COLORS.ground),
+    snow: NIGHT.snow,
+    surround: NIGHT.surround
+  }, MAT_COLORS.ground)
+};
+var PORTAL = { gate: [140, 220] };
+var MARKS = {
+  /** The inks, each with its token (the page's §14; desk.css; chrome.js `INK`). */
+  inks: {
+    pencil: { token: "--desk-pencil (Marks on the Mat \xA714, proposed)", css: "#79b5f8" },
+    /** The keyline under a pencil stroke: the mat's cast at 34 % (`--desk-keyline`). */
+    keyline: { token: "--desk-keyline \u2014 the tree-shadow design's `--cast-rgb`", css: "rgb(14 26 10 / .34)" },
+    /** A resize knob's face: chrome.js `INK.paper`. */
+    paper: { token: "chrome.js INK.paper", css: "#fffdf8" },
+    laser: { token: "--desk-laser (the bloom, added)", css: "#ff2e93" },
+    laserLine: { token: "--desk-laser-line", css: "#ff4fa3" },
+    laserCore: { token: "--desk-laser-core (5.94:1 on the lit mat)", css: "#ffd6ea" },
+    /** The pencil pill's numerals: the tray's ink (`--desk-ink`, solid); the laser pill's: white. */
+    tray: { token: "--desk-ink, solid (the tree-shadow design's `--ink`)", css: "#100904" },
+    white: { token: "chrome.js `pill` \u2014 the laser pill's numerals", css: "#ffffff" },
+    tape: { token: "--desk-tape", css: "rgb(238 228 204 / .88)" },
+    /** The vellum's veil: cream by day, a cool milk by night (chrome.js `drawMarquee`). */
+    vellumDay: { token: "chrome.js vellum, day", css: "rgb(255 250 238 / .11)" },
+    vellumNight: { token: "chrome.js vellum, night", css: "rgb(214 226 255 / .07)" }
+  },
+  /** The keyline is this much wider than the stroke it lies under. */
+  keyline: { grow: 2 },
+  /** One object selected: the frame 6 out, brackets reaching 16 (≤ 30 % of a side, never under r + 2), 1.5 thick, the hairline between them one DEVICE px at 42 %, the corner r + 6 ≤ 10; the lock-on arrives from 8 further out, its presence full by 1/2.2 of the way; knobs (radius 3.5, a cast ring 1 wider at 28 %) where the object resizes; under 24 px on screen, one ring. */
+  select: { gap: 6, reach: 16, share: 0.3, minOverR: 2, stroke: 1.5, hair: 0.42, radiusMax: 10, arrive: 8, rise: 2.2, knob: 3.5, knobShadow: 0.28, knobStroke: 1.5, collapse: 24 },
+  /** A member of several: quiet ticks — 4 out, reaching 8, 1.25 thick, at 62 %; the union carries the weight. */
+  member: { gap: 4, reach: 8, radiusMax: 8, stroke: 1.25, alpha: 0.62 },
+  /** Several: one union, 10 out, square to the mat, its corner 4. */
+  union: { gap: 10, radius: 4 },
+  /** The vellum: its pencil edge at 80 % (one device px), brackets reaching 12 at its corners once both sides pass 14, the count riding the cursor at +14, +18. */
+  marquee: { edge: 0.8, reach: 12, minSide: 14, count: [14, 18] },
+  /** A number the desk states: 10 px mono, 8 wider than its text, 15 tall, corner 3.5. */
+  pill: { size: 10, pad: 8, height: 15, radius: 3.5 },
+  /** The tray's name tags as LABEL TAPE (K5b, D-K5b.7 — marks/layout.ts `tagMarks`): the embosser's near-black tape and the pale plastic of its raised capitals. */
+  label: { tape: "#17181b", letters: "#ecebe4" },
+  /**
+   * The laser: a faint line wall to wall (3 px at 12 %, then 1 device px + 0.5 at 34 %, both added), and between the
+   * objects it aligns, 14 past them, the bloom (9 · 5 · 2.6 px at 7 · 16 · 32 %, added) under a 1.25 px line at 95 %
+   * with a 0.6 px core at 95 %; a centre is dotted (a dot every 4.51 px: the bloom 0.7 as wide, the line 2, the core 1);
+   * a new alignment strikes at 1.8×; a flare (radius 7) at every aligned corner; a gap, a 4 px bloom at 18 % under a
+   * 1.1 px line with 4 px ticks at its ends, its number in a laser pill on it (off it, under 26 px).
+   */
+  laser: {
+    wall: [[3, 0.12], [0.5, 0.34]],
+    bloom: [[9, 0.07], [5, 0.16], [2.6, 0.32]],
+    line: 1.25,
+    core: 0.6,
+    alpha: 0.95,
+    dotted: { period: 4.51, bloom: 0.7, line: 2, core: 1 },
+    past: 14,
+    strike: 0.8,
+    flare: { radius: 7, stop: 0.25, core: 0.9, mid: 0.55 },
+    bar: { bloom: [4, 0.18], line: 1.1, tick: 4, pillFrom: 26, off: [16, 14] }
+  },
+  /** Your extent on the rulers (the mat's RULER band): a pencil wash at 16 %, its edges at 95 %, the edge coordinates 4 off them, 7 up from the band's inner line, over a 3 px cast halo at 55 %; a guide ticks the band in laser (1.5 px at 90 %, added). */
+  ruler: { wash: 0.16, edge: 0.95, label: { gap: 4, lift: 7, halo: 1.5, haloAlpha: 0.55 }, tick: { width: 1.5, alpha: 0.9, inset: 3 } },
+  /** Masking tape (desk.css `.obj-tape`): two strips 60 × 17 (object units) crossing the top corners, 5 over the top edge and 20 past each side, turned 37°; fibres 1 in 3 at 10 % white, a light from above (18 % white → 4 % black); moonlit by night. */
+  tape: { w: 60, h: 17, over: 5, past: 20, turn: 37, fibre: { every: 3, alpha: 0.1 }, sheen: [0.18, 0.04], night: { saturate: 0.3, brightness: 0.46 }, press: 1.22 },
+  /** The clocks, ms: the lock-on (on `--vf-ease-lift`) and the leave; several's union and its fade; the vellum's fold (`--vf-ease-island`); the strike; the tape pressed (the second strip 60 later) and lifted; the tape's GIVE — a drag that meets it shivers 2.2 px and settles. */
+  clocks: { lockOn: 180, leave: 120, union: 220, unionFade: 120, fold: 240, strike: 160, tapePress: 240, tapeStagger: 60, tapeLift: 160, give: 360 },
+  give: { px: 2.2, rate: 44 }
+};
+var TRAY = {
+  face: { token: "research/sdf-pegboard preview.jpg \u2014 the face, lit flat", css: "#cdb491" },
+  /** shader.js FACE_ALB · EDGE_ALB, linear. */
+  research: { face: [0.42, 0.26, 0.135], edge: [0.56, 0.41, 0.25] },
+  cavity: { edge: 0.9, heart: 1, width: 0.1 },
+  lamp: { azimuth: -36, elevation: 48 },
+  lampSize: 0.06,
+  /**
+   * K5a — the ACCESSORIES the specimens hang on (hooks, shelves, clips, rails): SKÅDIS's white powder coat warmed to sit on the
+   * hardboard; how far each stands off the board (pitches — its shadow's reach on the board under the lamp); the shadow's strength.
+   */
+  accessory: { token: "SK\xC5DIS white, warmed", css: "#e8e3d9", height: { hook: 0.45, shelf: 0.6, clip: 0.3, rail: 0.4 }, shadow: 0.38 },
+  /** K5a — a specimen under the mouse lifts this share of the hold's lift (its own kind's `lift`): its shadow grows. */
+  hoverLift: 0.3
+};
+function themeFrom(name, p) {
+  return { name, canvasBg: rgb(p.canvasBg.css), select: rgb(p.select.css), matLight: MAT_LIGHT[name] };
+}
+
+// ../desk/src/nav/portal.ts
+var PORTAL_CHAIN = 6;
+var PORTAL_CHAIN_TYPE = `array<vec4f, ${PORTAL_CHAIN}>`;
+function chainOf(p) {
+  const out = [];
+  if (p?.portal) out.push(p.portal);
+  if (p?.within) out.push(...p.within);
+  return out;
+}
+function portalValues(p) {
+  const portals = new Array(4 * PORTAL_CHAIN).fill(0);
+  const clips = new Array(4 * PORTAL_CHAIN).fill(0);
+  const chain = chainOf(p);
+  if (chain.length > PORTAL_CHAIN) throw new Error(`nav/portal: a chain of ${chain.length} faces exceeds PORTAL_CHAIN ${PORTAL_CHAIN}`);
+  chain.forEach((c, i) => {
+    portals[4 * i] = c.cx;
+    portals[4 * i + 1] = c.cy;
+    portals[4 * i + 2] = c.hx;
+    portals[4 * i + 3] = c.hy;
+    clips[4 * i] = c.r;
+    clips[4 * i + 1] = 1;
+    clips[4 * i + 2] = c.feather ?? 0;
+  });
+  return { portals, clips };
+}
+function clipOf(K, radius, cam) {
+  const z = cam.zoom;
+  return { cx: (K.x + K.width / 2 - cam.x) * z, cy: (K.y + K.height / 2 - cam.y) * z, hx: K.width / 2 * z, hy: K.height / 2 * z, r: radius * z };
+}
+function boxOfPortal(c, attach) {
+  const x0 = Math.max(0, c.cx - c.hx - 1);
+  const y0 = Math.max(0, c.cy - c.hy - 1);
+  const x1 = Math.min(attach.width, c.cx + c.hx + 1);
+  const y1 = Math.min(attach.height, c.cy + c.hy + 1);
+  return { x: x0, y: y0, w: Math.max(0, x1 - x0), h: Math.max(0, y1 - y0) };
+}
+function intersectBox(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.w, b.x + b.w);
+  const y1 = Math.min(a.y + a.h, b.y + b.h);
+  return { x: x0, y: y0, w: Math.max(0, x1 - x0), h: Math.max(0, y1 - y0) };
+}
+var PORTAL_GATE = PORTAL.gate;
+var PORTAL_CAP = 16;
+var smoothstep2 = (a, b, x) => {
+  const t = Math.min(Math.max((x - a) / Math.max(b - a, 1e-3), 0), 1);
+  return t * t * (3 - 2 * t);
+};
+var portalPresence = (c, gate = PORTAL_GATE) => smoothstep2(gate[0], gate[1], 2 * Math.min(c.hx, c.hy));
+function faceCovers(c, vp, margin) {
+  const rr = Math.min(c.r, c.hx, c.hy);
+  const sd = (x, y) => {
+    const qx = Math.abs(x - c.cx) - c.hx + rr;
+    const qy = Math.abs(y - c.cy) - c.hy + rr;
+    return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - rr;
+  };
+  return sd(0, 0) <= -margin && sd(vp.width, 0) <= -margin && sd(0, vp.height) <= -margin && sd(vp.width, vp.height) <= -margin;
+}
+function scissorOf(p, dpr, size) {
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = size.w;
+  let y1 = size.h;
+  for (const c of chainOf(p)) {
+    x0 = Math.max(x0, Math.floor((c.cx - c.hx) * dpr) - 1);
+    y0 = Math.max(y0, Math.floor((c.cy - c.hy) * dpr) - 1);
+    x1 = Math.min(x1, Math.ceil((c.cx + c.hx) * dpr) + 1);
+    y1 = Math.min(y1, Math.ceil((c.cy + c.hy) * dpr) + 1);
+  }
+  return [x0, y0, Math.max(0, x1 - x0), Math.max(0, y1 - y0)];
+}
+
+// ../desk/src/lattice/ruler.ts
+var PER_WRAP = [100, 20, 10, 2, 1];
+var MULT = [2, 1, 2, 1, 2];
+var EXP_OFFSET = [0, 1, 1, 2, 2];
+var UNITS = [1, 5, 10, 50, 100];
+var mix = (a, b, t) => a + (b - a) * t;
+function rulerLevels(l, zoom, law, maxAbs = 0) {
+  const af = smoothstep(law.ticksFrom[0], law.ticksFrom[1], l.fine * zoom);
+  const [minor, medium, major] = law.tick;
+  const base = [minor, medium, mix(minor, major, af), mix(medium, major, af), major];
+  const tickAlpha = [af, af, 1, 1, 1];
+  const out = [];
+  for (let i = 0; i < 5; i++) {
+    const spacing = l.fine * UNITS[i];
+    const pitch = spacing * zoom;
+    const mult = MULT[i];
+    const exp = l.k0 + EXP_OFFSET[i];
+    let labelAlpha = smoothstep(law.labelsFrom[0], law.labelsFrom[1], pitch);
+    const chars = labelChars(maxAbs, mult, exp);
+    if (chars > law.maxChars || chars * law.text.size * ADVANCE_EM + law.text.gap > pitch) labelAlpha = 0;
+    out.push({ spacing, pitch, mult, exp, tickLen: mix(base[i], major, labelAlpha), tickAlpha: tickAlpha[i], labelAlpha, perWrap: PER_WRAP[i] });
+  }
+  return out;
+}
+var ADVANCE_EM = 0.6;
+function finestLabelled(levels) {
+  for (let i = 0; i < 5; i++) if (levels[i].labelAlpha > 0) return i;
+  return -1;
+}
+var wrapsOf = (cam, period) => Math.floor(cam / period);
+function formatLabel(index, mult, exp) {
+  const M = index * mult;
+  if (M === 0) return "0";
+  const neg = M < 0;
+  let digits = String(Math.abs(M));
+  let text;
+  if (exp >= 0) text = digits + "0".repeat(exp);
+  else {
+    const p = -exp;
+    digits = digits.padStart(p + 1, "0");
+    const int = digits.slice(0, digits.length - p);
+    const frac = digits.slice(digits.length - p).replace(/0+$/, "");
+    text = frac ? `${int}.${frac}` : int;
+  }
+  return neg ? `-${text}` : text;
+}
+function labelChars(maxAbs, mult, exp) {
+  const index = Math.ceil(maxAbs / (mult * 10 ** exp));
+  return Math.max(formatLabel(index, mult, exp).length, formatLabel(-index, mult, exp).length);
+}
+function labelReach(cam, zoom, span) {
+  return Math.max(Math.abs(cam), Math.abs(cam + span / zoom));
+}
+
+// ../desk/src/mat/projector.ts
+var cells = (m) => m;
+function perspective(fovDeg, aspect, near, far) {
+  const top = near * Math.tan(fovDeg * Math.PI / 360);
+  const height = 2 * top;
+  const width = aspect * height;
+  const left = -0.5 * width;
+  const right = left + width;
+  const bottom = top - height;
+  const x = 2 * near / (right - left);
+  const y = 2 * near / (top - bottom);
+  const a = (right + left) / (right - left);
+  const b = (top + bottom) / (top - bottom);
+  const c = -(far + near) / (far - near);
+  const d = -2 * far * near / (far - near);
+  const m = new Float32Array(16);
+  m[0] = x;
+  m[5] = y;
+  m[8] = a;
+  m[9] = b;
+  m[10] = c;
+  m[11] = -1;
+  m[14] = d;
+  return m;
+}
+function fromQuat(q) {
+  const [x, y, z, w] = q;
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const xy = x * y2;
+  const xz = x * z2;
+  const yy = y * y2;
+  const yz = y * z2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  const m = new Float32Array(16);
+  m[0] = 1 - (yy + zz);
+  m[4] = xy - wz;
+  m[8] = xz + wy;
+  m[1] = xy + wz;
+  m[5] = 1 - (xx + zz);
+  m[9] = yz - wx;
+  m[2] = xz - wy;
+  m[6] = yz + wx;
+  m[10] = 1 - (xx + yy);
+  m[15] = 1;
+  return m;
+}
+function mul4(a, b) {
+  const m = new Float32Array(16);
+  for (let col = 0; col < 4; col++) for (let row = 0; row < 4; row++) {
+    let s = 0;
+    for (let k = 0; k < 4; k++) s += a[k * 4 + row] * b[col * 4 + k];
+    m[col * 4 + row] = s;
+  }
+  return m;
+}
+function rigidInverse(position, q) {
+  const r = fromQuat(q);
+  const m = new Float32Array(16);
+  for (let col = 0; col < 3; col++) for (let row = 0; row < 3; row++) m[col * 4 + row] = r[row * 4 + col];
+  const [px, py, pz] = position;
+  const e = cells(m);
+  m[12] = -(e[0] * px + e[4] * py + e[8] * pz);
+  m[13] = -(e[1] * px + e[5] * py + e[9] * pz);
+  m[14] = -(e[2] * px + e[6] * py + e[10] * pz);
+  m[15] = 1;
+  return m;
+}
+function projectorMatrix(spec) {
+  return mul4(perspective(spec.fovDeg, spec.aspect, spec.near, spec.far), rigidInverse(spec.position, spec.quaternion));
+}
+function quatFromEuler(x, y, z) {
+  const c1 = Math.cos(x / 2);
+  const c2 = Math.cos(y / 2);
+  const c3 = Math.cos(z / 2);
+  const s1 = Math.sin(x / 2);
+  const s2 = Math.sin(y / 2);
+  const s3 = Math.sin(z / 2);
+  return [
+    s1 * c2 * c3 + c1 * s2 * s3,
+    c1 * s2 * c3 - s1 * c2 * s3,
+    c1 * c2 * s3 + s1 * s2 * c3,
+    c1 * c2 * c3 - s1 * s2 * s3
+  ];
+}
+function tilted(base, ex, ey, ez) {
+  return mul4(fromQuat(quatFromEuler(ex, ey, ez)), base);
+}
+var HERO_PROJECTOR = {
+  position: [0.466854, 0.992917, -0.252766],
+  quaternion: [0.16182, -0.776664, -0.221667, -0.566984],
+  fovDeg: 60,
+  aspect: 1,
+  near: 0.01,
+  far: 20
+};
+
+// ../desk/src/mat/layout.ts
+var MatUniforms = defineStruct("MatUniforms", [
+  ["cam", "vec4f"],
+  // camX, camY (world, UNwrapped — the projector is fixed in world), zoom, dpr
+  ["view", "vec4f"],
+  // cssW, cssH, grain time (s), the OBJECTS' presentation opacity (the slot's × their own presence — what every kind multiplies by)
+  ["phase", "vec4f"],
+  // wrapped camX, camY (the lattice's phase), unused ×2
+  ["rungs", "vec4f"],
+  // fine, mid, coarse spacing (world), unused
+  ["lod", "vec4f"],
+  // fadeIn lo, hi (CSS px), unused ×2
+  ["line", "vec4f"],
+  // half-width thin, thick (DEVICE px), alpha thin, thick
+  ["grain", "vec4f"],
+  // amplitude, unused ×3
+  ["ground", "vec4f"],
+  // the mat's green (sRGB), unused
+  ["ink", "vec4f"],
+  // the line cream (sRGB), unused
+  ["plane", "vec4f"],
+  // desk origin x, z (m), metres per world unit, desk y (m)
+  ["goboMatrix", "mat4x4f"],
+  ["goboParams", "vec4f"],
+  // sharp, soft, near, far — the blur ramp's depths and the projector's clip range
+  ["gobo", "vec4f"],
+  // opacity, blur radius (plate texels), shade mix, dark floor
+  ["grade", "vec4f"],
+  // saturation bump, unused ×3
+  ["noise", "vec4f"],
+  // blue-noise offset x, y, texel size, unused
+  ["wind", "vec4f"],
+  // gobo time (s), plate strength, unused ×2
+  ["night", "vec4f"],
+  // the NIGHT (mat/night.ts): amount (0 = the day's chain, exactly), the Moon's lux, exposure, snow
+  ["moon", "vec4f"],
+  // the Moon's colour as the adapted eye takes it (linear sRGB, Y = 1), the sky's share in the shadow
+  ["rod", "vec4f"],
+  // the rods' signal drawn as a colour (linear sRGB, Y = 1), unused
+  ["eigengrau", "vec4f"],
+  // the dark the eye adds (linear sRGB), unused
+  ["portals", PORTAL_CHAIN_TYPE],
+  // the portal CHAIN (nav/portal.ts): each face's centre xy, half extents xy (CSS px)
+  ["clips", PORTAL_CHAIN_TYPE],
+  // each face's corner radius, on (0/1 — a 0 ends the chain), unused ×2
+  ["ruler", "vec4f"],
+  // the RULERS (RULER.md; lattice/ruler.ts): on (0/1), margin, band, line width (CSS px)
+  ["rulerText", "vec4f"],
+  // the text's inset from the outer line, its gap after the tick, the major tick's length (CSS px), the atlas's texels per CSS px
+  ["rulerAlpha", "vec4f"],
+  // ink presence: the frame's lines, the ticks, the labels, unused
+  ["rulerOrigin", "vec4f"],
+  // the lattice's wrap count of camX, camY (exact integers), the finest labelled level (−1 = none), unused
+  ["rulerGlyph", "vec4f"],
+  // the glyph atlas: cell width, cell height, advance, baseline (texels)
+  ["rulerAtlas", "vec4f"],
+  // the glyph atlas: width, height, cap height (texels), glyph count
+  ["rulerSites", "array<vec4f, 5>"],
+  // per level: spacing (world), tick length (CSS px), tick presence, label presence
+  ["rulerFormat", "array<vec4f, 5>"],
+  // per level: mult, exp (a site's value = index · mult · 10^exp), wrap period over spacing, unused
+  ["box", "vec4f"],
+  // the slot's box on the attachment: x, y, w, h (CSS px) — stats only; the mat is fullscreen under the scissor
+  ["light", "vec4f"],
+  // the LIGHT (MINIMAT.md §4): the camera the lamp's gobo is sampled under — x, y, zoom — and the cross-fade toward `light2`
+  ["light2", "vec4f"],
+  // the second light a flight hands the slot to: x, y, zoom, unused
+  ["presence", "vec4f"]
+  // the SLOT's presentation opacity — what the mat itself is drawn at (K4a, K-L3: the one view block carries both), unused ×3
+]);
+var GLYPH_PAD = 2;
+var GLYPHS = "0123456789-.ABCDEFGHIJKLMNOPQRSTUVWXYZ &'/\xB7#()+:";
+var RULER_GLYPHS = 12;
+var NO_GLYPHS = { scale: 1, cellW: 1, cellH: 1, advance: 1, baseline: 1, cap: 1, width: 1, height: 1, count: 0 };
+var DEFAULT_MAT_CONFIG = {
+  line: MAT_GRID.line,
+  grain: MAT_GRID.grain,
+  ground: MAT_COLORS.ground,
+  ink: MAT_COLORS.line,
+  gobo: {
+    opacity: MAT_GRID.gobo.opacity,
+    blurTexels: MAT_GRID.gobo.blurTexels,
+    shadeMix: MAT_GRID.gobo.shadeMix,
+    darkFloor: MAT_GRID.gobo.darkFloor,
+    saturate: MAT_GRID.gobo.saturate,
+    sharp: MAT_GRID.gobo.sharp,
+    soft: MAT_GRID.gobo.soft,
+    plate: MAT_GRID.gobo.plate
+  },
+  plane: MAT_GRID.plane,
+  ruler: { on: false, ...MAT_GRID.ruler }
+};
+var HERO_MATRIX = projectorMatrix(HERO_PROJECTOR);
+var STILL_MAT_FRAME = { time: 0, goboTime: 0, goboMatrix: HERO_MATRIX, noise: [0, 0] };
+var NOISE_SIZE = 128;
+var PLATE_SIZE = 512;
+function matUniformValues(view, fadeIn, cfg, f, plateStrength, present, light = DAY_LIGHT, glyphs = NO_GLYPHS, lit) {
+  const l = lod(view);
+  const r = cfg.ruler;
+  const levels = rulerLevels(l, view.zoom, r, Math.max(labelReach(view.camX, view.zoom, view.width), labelReach(view.camY, view.zoom, view.height)));
+  return {
+    cam: [view.camX, view.camY, view.zoom, view.dpr],
+    view: [view.width, view.height, f.time, present === void 0 ? 1 : present.objects === void 0 ? present.opacity : present.opacity * present.objects],
+    phase: [(view.camX % l.wrapPeriod + l.wrapPeriod) % l.wrapPeriod, (view.camY % l.wrapPeriod + l.wrapPeriod) % l.wrapPeriod, 0, 0],
+    rungs: [l.fine, l.mid, l.coarse, 0],
+    lod: [fadeIn[0], Math.max(fadeIn[1], fadeIn[0] + 1e-3), 0, 0],
+    line: [cfg.line.thin, cfg.line.thick, cfg.line.alphaThin, cfg.line.alphaThick],
+    grain: [cfg.grain, 0, 0, 0],
+    ground: [cfg.ground[0], cfg.ground[1], cfg.ground[2], 0],
+    ink: [cfg.ink[0], cfg.ink[1], cfg.ink[2], 0],
+    plane: [cfg.plane.originX, cfg.plane.originZ, cfg.plane.metresPerUnit, cfg.plane.deskY],
+    goboMatrix: f.goboMatrix,
+    goboParams: [cfg.gobo.sharp, cfg.gobo.soft, HERO_PROJECTOR.near, HERO_PROJECTOR.far],
+    gobo: [cfg.gobo.opacity, cfg.gobo.blurTexels, cfg.gobo.shadeMix, cfg.gobo.darkFloor],
+    grade: [cfg.gobo.saturate, 0, 0, 0],
+    noise: [f.noise[0], f.noise[1], 1 / NOISE_SIZE, 0],
+    wind: [f.goboTime, plateStrength, 0, 0],
+    ...lightValues(light),
+    ...portalValues(present),
+    ruler: [r.on ? 1 : 0, r.margin, r.band, r.line],
+    rulerText: [r.text.top, r.text.gap, r.tick[2], glyphs.scale],
+    rulerAlpha: [r.alpha.frame, r.alpha.tick, r.alpha.label, 0],
+    rulerOrigin: [wrapsOf(view.camX, l.wrapPeriod), wrapsOf(view.camY, l.wrapPeriod), finestLabelled(levels), 0],
+    rulerGlyph: [glyphs.cellW, glyphs.cellH, glyphs.advance, glyphs.baseline],
+    rulerAtlas: [glyphs.width, glyphs.height, glyphs.cap, glyphs.count],
+    rulerSites: levels.flatMap((L) => [L.spacing, L.tickLen, L.tickAlpha, L.labelAlpha]),
+    rulerFormat: levels.flatMap((L) => [L.mult, L.exp, L.perWrap, 0]),
+    box: boxValues(view),
+    ...slotLightValues(view, lit),
+    // the slot's own opacity, which the mat is drawn at; `view.w` above is the objects' (what the ground's `objectsOf` hands the kinds'
+    // `SlotContext.present`). One view block per slot carries both (K4a, design-016 K-L3), so every kind reads it as it always read its copy
+    presence: [present?.opacity ?? 1, 0, 0, 0]
+  };
+}
+function settleLight(lit) {
+  if (!lit?.b) return lit;
+  const t = lit.t ?? 0;
+  return t <= 0 ? { a: lit.a } : t >= 1 ? { a: lit.b } : lit;
+}
+function litByOwn(view, lit) {
+  const s = settleLight(lit);
+  return !s || !s.b && s.a.x === view.camX && s.a.y === view.camY && s.a.zoom === view.zoom;
+}
+function slotLightValues(view, lit) {
+  const own = { x: view.camX, y: view.camY, zoom: view.zoom };
+  const s = settleLight(lit);
+  const a = s?.a ?? own;
+  const b = s?.b ?? a;
+  const t = s?.b ? s.t ?? 0 : 0;
+  return { light: [a.x, a.y, a.zoom, t], light2: [b.x, b.y, b.zoom, 0] };
+}
+
+// ../desk/src/mat/grid.ts
+var DEFAULT_GRID = { fadeIn: GRID.fadeIn, mat: DEFAULT_MAT_CONFIG };
+function dressScale(zoom, lodZoom) {
+  if (lodZoom === void 0 || !(lodZoom > 0) || lodZoom === zoom) return 1;
+  return Math.max(zoom / lodZoom, GRID.dressFloor);
+}
+function dressGrid(cfg, zoom, lodZoom) {
+  const s = dressScale(zoom, lodZoom);
+  if (s === 1) return cfg;
+  return { ...cfg, fadeIn: [cfg.fadeIn[0] * s, cfg.fadeIn[1] * s] };
+}
+var gridStats = (view, wind) => {
+  const l = lod(view);
+  return { k0: l.k0, fade: l.fade, wind };
+};
+
+// ../desk/src/kit/book.ts
+var NbUniforms = defineStruct("NbUniforms", [
+  ["eye", "vec4f"],
+  // the desk eye: foot x, y (world), height (world), zoom
+  ["view", "vec4f"],
+  // viewport w, h (CSS px), the depth range's near and far (distance from the eye)
+  ["light", "vec4f"],
+  // the sky's share, the lambert's cap, the dapple's share on paper, on cloth
+  ["shadow", "vec4f"],
+  // σ at contact, σ per unit of height, the shadow's alpha on the mat, the contact's alpha
+  ["shadow2", "vec4f"],
+  // the contact's σ, the height it lets go by, the shadow map's size (texels), dpr
+  ["paper", "vec4f"],
+  // fibre, mottle, tooth, cockle
+  ["rule", "vec4f"],
+  // pitch, dot radius, margin, unused
+  ["cloth", "vec4f"],
+  // the weave's pitch, its relief, the sheen's exponent and strength
+  ["castCol", "vec4f"],
+  // what a shadow is made of on this ground
+  ["select", "vec4f"],
+  // the ring's colour, its width (CSS px)
+  ["ruleInk", "vec4f"],
+  // the ruling's ink, alpha
+  ["ring", "vec4f"]
+  // the ring's offset from the footprint (CSS px), unused ×3
+]);
+var NbBook = defineStruct("NbBook", [
+  ["model", "mat4x4f"],
+  // book → world
+  ["inv", "mat4x4f"],
+  // world → book
+  ["light", "mat4x4f"],
+  // world → the shadow map's clip space
+  ["lamp", "vec4f"],
+  // the unit direction to the lamp (world), the shadow map's layer
+  ["sh", "vec4f"],
+  // a shadow texel (world), the map's depth range (world), mapped (0/1), the book's tallest point
+  ["size", "vec4f"],
+  // cover width, height, board, fore-edge radius
+  ["page", "vec4f"],
+  // unused, page height, page corner radius, the spine band's width
+  ["open", "vec4f"],
+  // the swing θ, the gutter's relax, the spine's width, the squares
+  ["look", "vec4f"],
+  // design, ruling, the ring's presence, a seed
+  ["foot", "vec4f"],
+  // the front board lies on the desk (0/1), the cover is paper (0/1), a sheet's thickness, the book shades itself (0/1)
+  ["recv", "vec4f"],
+  // the mat's rect this book darkens: x0, y0, x1, y1 (world)
+  ["inkPage", "array<vec4f, 2>"],
+  // the pages with ink on the device (−1 = none), eight
+  ["inkLayer", "array<vec4f, 2>"],
+  // … and the raster layer each is in
+  ["col0", "vec4f"],
+  ["col1", "vec4f"],
+  ["col2", "vec4f"],
+  ["col3", "vec4f"],
+  ["col4", "vec4f"],
+  ["col5", "vec4f"],
+  ["col6", "vec4f"],
+  ["col7", "vec4f"]
+]);
+
+// ../desk/src/shaders.gen.ts
+var WGSL = {
+  "hold/hold.wgsl": "// THE HAND'S FOCUS (design-015 \xA78; D4b) \u2014 the desk behind the object in hand goes out of focus, and the\n// object is laid over it in its own light. Four fullscreen fragments over one triangle, one binding set:\n//  - `fs_down` / `fs_up`: the dual-Kawase blur (Bj\xF8rge, ARM 2015) \u2014 a down pass takes the centre \xD74 and the\n//    four diagonals at \xB1offset half-texels; an up pass eight taps at \xB1offset (the axes once, the diagonals\n//    twice) \u2014 the desk's HALF-SIZE copy blurred through two levels and back, once per settled desk.\n//  - `fs_desk`: the frame's background \u2014 the sharp half-size copy mixed with the blurred one by the carry\n//    amount (half-way up, half the blur), dimmed by `dim` (8 % at the top).\n//  - `fs_hand`: the object in hand, drawn into a transparent target with the kinds' own straight-alpha\n//    \"source over\" \u2014 which, from a cleared target, accumulates PREMULTIPLIED colour \u2014 laid over the frame\n//    (one, one \u2212 src alpha), through the READING LIGHT (Q-n): saturate then brighten, both linear in the\n//    premultiplied colour, so the at-rest passes' bytes never move.\n// Pure of everything but its bindings (engine/shader.ts's rule): the CPU decides every number.\n\n@group(0) @binding(0) var<uniform> u: HoldUniforms;\n@group(0) @binding(1) var tex_a: texture_2d<f32>;\n@group(0) @binding(2) var tex_b: texture_2d<f32>;\n@group(0) @binding(3) var samp: sampler;\n\nstruct VSOut {\n  @builtin(position) clip: vec4f,\n  @location(0) uv: vec2f,\n}\n\n/** One triangle over the whole attachment; uv (0, 0) at the top-left, as the texture's rows run. */\n@vertex\nfn vs(@builtin(vertex_index) vid: u32) -> VSOut {\n  var out: VSOut;\n  let x = f32((vid << 1u) & 2u);\n  let y = f32(vid & 2u);\n  out.clip = vec4f(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);\n  out.uv = vec2f(x, y);\n  return out;\n}\n\n/** Dual Kawase, down: `u.texel.xy` = one texel of the SOURCE, `u.texel.z` = the offset in half-texels. */\n@fragment\nfn fs_down(in: VSOut) -> @location(0) vec4f {\n  let o = u.texel.xy * 0.5 * u.texel.z;\n  var c = textureSample(tex_a, samp, in.uv) * 4.0;\n  c += textureSample(tex_a, samp, in.uv + vec2f(-o.x, -o.y));\n  c += textureSample(tex_a, samp, in.uv + vec2f(o.x, -o.y));\n  c += textureSample(tex_a, samp, in.uv + vec2f(-o.x, o.y));\n  c += textureSample(tex_a, samp, in.uv + vec2f(o.x, o.y));\n  return c / 8.0;\n}\n\n/** Dual Kawase, up: the same offset, eight taps. */\n@fragment\nfn fs_up(in: VSOut) -> @location(0) vec4f {\n  let o = u.texel.xy * 0.5 * u.texel.z;\n  var c = textureSample(tex_a, samp, in.uv + vec2f(-o.x * 2.0, 0.0));\n  c += textureSample(tex_a, samp, in.uv + vec2f(-o.x, o.y)) * 2.0;\n  c += textureSample(tex_a, samp, in.uv + vec2f(0.0, o.y * 2.0));\n  c += textureSample(tex_a, samp, in.uv + vec2f(o.x, o.y)) * 2.0;\n  c += textureSample(tex_a, samp, in.uv + vec2f(o.x * 2.0, 0.0));\n  c += textureSample(tex_a, samp, in.uv + vec2f(o.x, -o.y)) * 2.0;\n  c += textureSample(tex_a, samp, in.uv + vec2f(0.0, -o.y * 2.0));\n  c += textureSample(tex_a, samp, in.uv + vec2f(-o.x, -o.y)) * 2.0;\n  return c / 12.0;\n}\n\n/** The desk out of focus: the sharp copy (tex_a) mixed with the blurred one (tex_b) by the carry `u.mix.x`, dimmed by `u.mix.y`. Opaque. */\n@fragment\nfn fs_desk(in: VSOut) -> @location(0) vec4f {\n  let sharp = textureSample(tex_a, samp, in.uv).rgb;\n  let soft = textureSample(tex_b, samp, in.uv).rgb;\n  return vec4f(mix(sharp, soft, u.mix.x) * (1.0 - u.mix.y), 1.0);\n}\n\n/** The hand over the frame: premultiplied (tex_a), through the reading light \u2014 saturate `u.mix.z`, brightness `u.mix.w`. Blend (one, one \u2212 src alpha). */\n@fragment\nfn fs_hand(in: VSOut) -> @location(0) vec4f {\n  let h = textureSample(tex_a, samp, in.uv);\n  let lum = dot(h.rgb, vec3f(0.2126, 0.7152, 0.0722));\n  let rgb = mix(vec3f(lum), h.rgb, u.mix.z) * u.mix.w;\n  return vec4f(rgb, h.a);\n}\n",
+  "kit/book.wgsl": "// (The kit's since K4a, design-016 \xA75 \u2014 moved from notebook/notebook.wgsl: the desk calendar composes it too, `kitWgsl([..., \"book\"])`.)\n//\n// The NOTEBOOK \u2014 a real 3D book under the desk's one lamp (NOTEBOOK.md). A PURE module: the\n// uniform blocks, the book records and the textures arrive as parameters, and it names no\n// colour (a book's palette is its record's). mat.wgsl comes first: its noise, its colour chain\n// (`shade_mat` by day, `night_mat` by night) and its gobo (`sample_gobo`) are the desk's, so a\n// page under the palm is dappled and graded exactly as the mat beside it.\n//\n// The pieces: the desk eye's projection (`nb_clip`, eye.ts is the same arithmetic); the\n// shadow \u2014 PCSS on the book's own shadow map, whose penumbra grows with the gap between caster\n// and receiver by the desk's law (\u03C3 = \u03C30 + k\xB7height, the note's and the photo's); the\n// materials \u2014 bookcloth with a weave and a sheen, the cover's printed design, the ivory page\n// with its fibre, tooth, cockle and dots, the stacked edges of the sheets, the endpaper framed\n// by the cloth's turn-in; and the light \u2014 a lambert normalised so a flat face reads its own\n// albedo, the sky's share where the lamp is blocked, the leaves' dapple.\n\nconst NB_PI = 3.14159265;\n\nfn nb_sat(x: f32) -> f32 { return clamp(x, 0.0, 1.0); }\n\n// ---- the desk eye: a world point \u2192 clip space (x, y 2\xB7zoom\xB7(p \u2212 E)/viewport; w = (H \u2212 z)/H; a perspective depth)\nfn nb_clip(k: NbUniforms, P: vec3f) -> vec4f {\n  let H = k.eye.z;\n  let d = H - P.z;\n  let x = 2.0 * k.eye.w * (P.x - k.eye.x) / k.view.x;\n  let y = -2.0 * k.eye.w * (P.y - k.eye.y) / k.view.y;\n  let n = k.view.z;\n  let f = k.view.w;\n  let z = (d - n) * f / ((f - n) * H);\n  return vec4f(x, y, z, d / H);\n}\n\n// A world point raised off the desk, in the projector's frame (mat.wgsl `desk_of` with a height).\nfn nb_desk_at(u: MatUniforms, P: vec3f) -> vec3f {\n  return vec3f(u.plane.x + P.x * u.plane.z, u.plane.w + P.z * u.plane.z, u.plane.y + P.y * u.plane.z);\n}\n\n// ---- noise in a face's own world units: an integer hash (no sin \u2014 a page fragment reads a dozen of these),\n// value noise with its analytic gradient (so a bump costs one evaluation, not three)\nfn nb_hash(p: vec2i) -> f32 {\n  var h = (u32(p.x) * 668265261u) ^ (u32(p.y) * 374761393u);\n  h = (h ^ (h >> 15u)) * 2246822519u;\n  h = (h ^ (h >> 13u)) * 3266489917u;\n  h = h ^ (h >> 16u);\n  return f32(h) * 2.3283064e-10;\n}\n\n// value (centred on 0), d/dx, d/dy\nfn nb_vn(p: vec2f) -> vec3f {\n  let fl = floor(p);\n  let i = vec2i(fl);\n  let f = p - fl;\n  let w = f * f * (3.0 - 2.0 * f);\n  let dw = 6.0 * f * (1.0 - f);\n  let a = nb_hash(i);\n  let b = nb_hash(i + vec2i(1, 0));\n  let c = nb_hash(i + vec2i(0, 1));\n  let d = nb_hash(i + vec2i(1, 1));\n  let k = a - b - c + d;\n  return vec3f(a + (b - a) * w.x + (c - a) * w.y + k * w.x * w.y - 0.5, dw.x * (b - a + k * w.y), dw.y * (c - a + k * w.x));\n}\n\n// three octaves, the gradient carried through\nfn nb_fbm(p: vec2f) -> vec3f {\n  let a = nb_vn(p);\n  let b = nb_vn(p * 2.03 + vec2f(17.1, 3.7));\n  let c = nb_vn(p * 4.11 + vec2f(-5.3, 11.9));\n  return vec3f(a.x + b.x * 0.5 + c.x * 0.25, a.yz + b.yz * 1.015 + c.yz * 1.0275);\n}\n\n// A pattern's detail faded as its period falls under the pixel: 1 while `period` spans \u2265 3 px of `px` world, 0 under 1.\nfn nb_detail(period: f32, px: f32) -> f32 { return smoothstep(1.2, 3.0, period / max(px, 1e-5)); }\n\n// Coverage of a signed distance (negative inside) at a pixel of `px` world units.\nfn nb_cov(d: f32, px: f32) -> f32 { return nb_sat(0.5 - d / max(px, 1e-5)); }\n\n// A rounded box, centred, half extents `b`, radius `r`.\nfn nb_sd_box(p: vec2f, b: vec2f, r: f32) -> f32 {\n  let q = abs(p) - b + vec2f(r);\n  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - r;\n}\n\n// A face [0, w] \xD7 [0, h] whose corners at u = w are rounded by r (the spine side square): signed distance.\nfn nb_sd_fore(q: vec2f, w: f32, h: f32, r: f32) -> f32 {\n  // mirror the square side out of reach: extend the box past u = 0 by r\n  let c = vec2f((w - r) * 0.5, h * 0.5);\n  let b = vec2f((w + r) * 0.5, h * 0.5);\n  return nb_sd_box(q - c, b, r);\n}\n\n// ---- the shadow: PCSS on the book's own map (the blocker's gap \u2192 the desk's penumbra law)\n// The golden angle as a rotation: a Vogel spiral's next direction is this times the last.\nconst NB_GOLDEN = mat2x2f(-0.7373688, 0.6754903, -0.6754903, -0.7373688);\n\nfn nb_shadow(k: NbUniforms, B: NbBook, P: vec3f, n: vec3f, rot: f32, tex: texture_depth_2d_array, cmp: sampler_comparison) -> f32 {\n  if (B.sh.z < 0.5 || (u32(k.ring.y) & 1u) != 0u) { return 1.0; }\n  let texel = B.sh.x;\n  let res = k.shadow2.z;\n  let layer = i32(B.lamp.w);\n  let Po = P + n * texel * 1.5;\n  let lc = B.light * vec4f(Po, 1.0);\n  let uv = vec2f(lc.x * 0.5 + 0.5, 0.5 - lc.y * 0.5);\n  if (uv.x <= 0.0 || uv.y <= 0.0 || uv.x >= 1.0 || uv.y >= 1.0) { return 1.0; }\n  // nothing was drawn at 1 (the clear): a receiver compares just inside it, so \"no caster here\" is lit wherever it lies\n  let depth = min(lc.z, 0.99995);\n  let bias = 0.35 / max(B.sh.y, 1.0);\n  // the blocker search: as far as the widest penumbra this book can cast\n  let widest = k.shadow.x + k.shadow.y * B.sh.w;\n  let search = clamp(2.2 * widest / texel, 2.0, 72.0);\n  var sum = 0.0;\n  var cnt = 0.0;\n  let base = uv * res;\n  var dir = vec2f(cos(rot), sin(rot));\n  for (var i = 0; i < 10; i++) {\n    let o = dir * sqrt((f32(i) + 0.5) / 10.0) * search;\n    dir = NB_GOLDEN * dir;\n    let t = clamp(vec2i(base + o), vec2i(0), vec2i(i32(res) - 1));\n    let d = textureLoad(tex, t, layer, 0);\n    if (d < depth - bias) { sum += d; cnt += 1.0; }\n  }\n  if (cnt < 0.5) { return 1.0; }\n  let gap = (depth - sum / cnt) * B.sh.y * B.lamp.z;   // the blocker's height over the receiver, world units\n  let sigma = k.shadow.x + k.shadow.y * max(gap, 0.0);\n  let r = clamp(sigma / texel * 1.7, 0.75, 72.0);\n  var lit = 0.0;\n  var wsum = 0.0;\n  dir = vec2f(-dir.y, dir.x);\n  let inv2s2 = 1.0 / (2.0 * (r / 1.7) * (r / 1.7) + 1e-4);\n  for (var i = 0; i < 14; i++) {\n    let o = dir * sqrt((f32(i) + 0.5) / 14.0) * r;\n    dir = NB_GOLDEN * dir;\n    let w = exp(-dot(o, o) * inv2s2);\n    lit += w * textureSampleCompareLevel(tex, cmp, (base + o) / res, layer, depth - bias);\n    wsum += w;\n  }\n  return lit / max(wsum, 1e-5);\n}\n\n// ---- the colour chain: the lamp's light on a face, then the desk's day or night\nfn nb_colour(u: MatUniforms, albedo: vec3f, light: f32, gobo: f32, noise: f32) -> vec3f {\n  let day = shade_mat(u, clamp(albedo * pow(max(light, 0.0), 1.0 / 2.2), vec3f(0.0), vec3f(1.0)), gobo);\n  if (u.night.x <= 0.0) { return day; }\n  let night = night_mat(u, srgb_to_linear(clamp(albedo, vec3f(0.0), vec3f(1.0))) * max(light, 0.0), gobo, noise);\n  if (u.night.x >= 1.0) { return night; }\n  return mix(day, night, u.night.x);\n}\n\n// ---- the cloth: a plain weave as a height, with its threads' own shades\nstruct NbCloth { h: f32, g: vec2f, shade: f32 }\nfn nb_cloth(q: vec2f, pitch: f32, px: f32) -> NbCloth {\n  let fade = 1.0 - smoothstep(0.35, 0.9, px / pitch);\n  let a = q / pitch;\n  let cell = floor(a);\n  let over = ((i32(cell.x) + i32(cell.y)) & 1) == 0;\n  let f = fract(a) - vec2f(0.5);\n  // warp (along v) over weft (along u) on alternate cells: a raised thread across each cell\n  let warp = 1.0 - 4.0 * f.x * f.x;\n  let weft = 1.0 - 4.0 * f.y * f.y;\n  let h = select(weft, warp, over) * 0.8 + 0.2 * (warp * weft);\n  let dwarp = -8.0 * f.x / pitch;\n  let dweft = -8.0 * f.y / pitch;\n  let g = select(vec2f(0.0, dweft), vec2f(dwarp, 0.0), over) * 0.8 + 0.2 * vec2f(dwarp * weft, warp * dweft);\n  // the threads' slubs: each thread a little thicker or lighter along its run\n  let slub = nb_vn(vec2f(select(cell.y, cell.x, over) * 1.7, select(a.x, a.y, over) * 0.21)).x;\n  var out: NbCloth;\n  out.h = (h - 0.55 + slub * 0.35) * fade;\n  out.g = g * fade;\n  out.shade = (slub * 0.9 + (h - 0.55) * 0.35) * fade;\n  return out;\n}\n\n// ---- the cover's DESIGNS, printed on the cloth past the spine band (u, v in the face's world units from the band's edge and the head)\nfn nb_ring(d: f32, r: f32, w: f32, px: f32) -> f32 { return nb_cov(abs(d - r) - w * 0.5, px); }\n\nfn nb_hash2(p: vec2f) -> f32 { return hash12(p * vec2f(0.1031, 0.1030) + vec2f(19.19, 7.7)); }\n\n// 0 plain cloth \xB7 1 orbit (rings round a brass sun) \xB7 2 tiles (a grid of quarter-rounds, halves and dots) \xB7 3 label (a cream label on kraft) \xB7 4 bordered (a blind-pressed frame)\nfn nb_design(B: NbBook, q: vec2f, w: f32, h: f32, px: f32, base: vec3f) -> vec4f {\n  let id = i32(B.look.x + 0.5);\n  var c = base;\n  var press = 0.0;   // a blind line pressed into the cloth (a height)\n  if (id == 1) {\n    let o = vec2f(w * 0.5, h * 0.47);\n    let d = length(q - o);\n    let ringW = 0.9;\n    for (var i = 1; i <= 6; i++) {\n      let r = f32(i) * min(w, h) * 0.075 + 4.0;\n      c = mix(c, B.col3.rgb, nb_ring(d, r, ringW, px) * 0.8);\n      // a planet on each ring\n      let a = nb_hash2(vec2f(f32(i), 3.0)) * 6.2831 + B.look.w;\n      let pc = o + vec2f(cos(a), sin(a)) * r;\n      let pr = 1.6 + 2.4 * nb_hash2(vec2f(f32(i), 9.0));\n      let pcol = select(select(B.col4.rgb, B.col2.rgb, i % 3 == 1), B.col3.rgb, i % 3 == 2);\n      c = mix(c, pcol, nb_cov(length(q - pc) - pr, px));\n    }\n    c = mix(c, B.col2.rgb, nb_cov(d - 9.0, px));\n  } else if (id == 2) {\n    let n = vec2f(3.0, 4.0);\n    let cs = vec2f(w, h) / n;\n    let cell = clamp(floor(q / cs), vec2f(0.0), n - vec2f(1.0));\n    let f = (q - cell * cs) / cs;   // 0..1 in the tile\n    let r = nb_hash2(cell + vec2f(B.look.w * 7.0, 1.0));\n    let r2 = nb_hash2(cell + vec2f(5.0, B.look.w * 3.0));\n    let bgI = i32(r2 * 4.0);\n    let fgI = (bgI + 1 + i32(r * 3.0)) % 4;\n    var bg = B.col2.rgb; var fg = B.col3.rgb;\n    if (bgI == 1) { bg = B.col3.rgb; } else if (bgI == 2) { bg = B.col4.rgb; } else if (bgI == 3) { bg = base; }\n    if (fgI == 0) { fg = B.col2.rgb; } else if (fgI == 2) { fg = B.col4.rgb; } else if (fgI == 3) { fg = base; }\n    let pxt = px / min(cs.x, cs.y);\n    var m = 0.0;\n    let kind = i32(r * 5.0);\n    if (kind == 0) { m = nb_cov(length(f) - 1.0, pxt); }                        // a quarter-round from a corner\n    else if (kind == 1) { m = nb_cov(length(f - vec2f(0.5, 1.0)) - 0.5, pxt); }  // a half-round on the edge\n    else if (kind == 2) { m = nb_cov((f.x - f.y) * 0.7071, pxt); }            // a diagonal half\n    else if (kind == 3) { m = nb_cov(length(f - vec2f(0.5)) - 0.3, pxt); }       // a dot\n    else { m = nb_cov(max(abs(f.x - 0.5), abs(f.y - 0.5)) - 0.22, pxt); }      // a square\n    c = mix(bg, fg, m);\n  } else if (id == 3) {\n    let lo = vec2f(w * 0.16, h * 0.16);\n    let hi = vec2f(w * 0.84, h * 0.33);\n    let d = nb_sd_box(q - (lo + hi) * 0.5, (hi - lo) * 0.5, 3.0);\n    let lab = nb_cov(d, px);\n    var lc = B.col3.rgb;\n    // two ruled lines on the label for a name\n    let ly = (q.y - lo.y) / (hi.y - lo.y);\n    let rule = max(nb_cov(abs(ly - 0.55) * (hi.y - lo.y) - 0.3, px), nb_cov(abs(ly - 0.8) * (hi.y - lo.y) - 0.3, px)) * step(lo.x + 6.0, q.x) * step(q.x, hi.x - 6.0);\n    lc = mix(lc, B.col7.rgb, rule * 0.35);\n    c = mix(c, lc, lab);\n  } else if (id == 4) {\n    let d = nb_sd_box(q - vec2f(w, h) * 0.5, vec2f(w, h) * 0.5 - vec2f(9.0), 2.5);\n    press = -exp(-(d * d) / 0.6) * 0.5;\n    c = c * (1.0 - exp(-(d * d) / 0.6) * 0.08);\n  }\n  return vec4f(c, press);\n}\n\n// ---- the paper: its albedo (fibre, mottle) and its height (tooth, cockle), in the page's world units\nfn nb_paper_seed(seed: f32) -> vec2f { return vec2f(fract(seed * 0.618034) * 97.0, fract(seed * 0.381966) * 89.0); }\n\n// The paper from its baked texture (src/notebook/paper-tex.ts): the mottle and the fibres over a 64-unit\n// tile, the tooth's slope over a 9.6-unit one, each page's tiles offset by its number; the cockle, slow\n// enough for one noise. Explicit gradients, so it may be read anywhere and filters by its mips.\nstruct NbPaperS { albedo: vec3f, g: vec2f }\nfn nb_paper(k: NbUniforms, base: vec3f, q: vec2f, dqdx: vec2f, dqdy: vec2f, seed: f32, tex: texture_2d<f32>, samp: sampler) -> NbPaperS {\n  let s = nb_paper_seed(seed);\n  let a = textureSampleGrad(tex, samp, q / 64.0 + s / 64.0, dqdx / 64.0, dqdy / 64.0);\n  let tt = 9.6;\n  let b = textureSampleGrad(tex, samp, q / tt + s.yx / 31.0, dqdx / tt, dqdy / tt);\n  let v = (a.r - 0.5) * k.paper.y * 2.0 + (a.g - 0.5) * k.paper.x * 3.0;\n  var out: NbPaperS;\n  out.albedo = base + vec3f(v * 1.05, v, v * 0.8);\n  let tooth = (b.ba - vec2f(0.5)) * (2.0 * 48.0 / tt) * (k.paper.z * 0.02);\n  let c = nb_vn(q / 55.0 + s * 0.5);\n  out.g = tooth + c.yz / 55.0 * (k.paper.w * 2.0);\n  return out;\n}\n\n// The ruling printed on a page: dots on a pitch, inside a margin, faded as they fall under the pixel.\nfn nb_ruling(k: NbUniforms, B: NbBook, q: vec2f, w: f32, h: f32, px: f32) -> f32 {\n  let kind = i32(B.look.y + 0.5);\n  if (kind == 0) { return 0.0; }\n  let pitch = k.rule.x;\n  let m = k.rule.z;\n  let inside = step(m, q.x) * step(q.x, w - m) * step(m, q.y) * step(q.y, h - m);\n  let vis = smoothstep(2.0, 5.0, pitch / px);\n  // the grid is laid from the page's head and fore-edge so it sits the same on every page\n  let g = (q - vec2f(w, 0.0)) / pitch;\n  let f = fract(g) - vec2f(0.5);\n  if (kind == 1) {\n    let d = length(f) * pitch - k.rule.y;\n    return nb_cov(d, max(px, 0.35)) * inside * vis;\n  }\n  if (kind == 2) {\n    let d = abs(f.y) * pitch - k.rule.y * 0.45;\n    return nb_cov(d, max(px, 0.3)) * inside * vis * 0.75;\n  }\n  let d = min(abs(f.x), abs(f.y)) * pitch - k.rule.y * 0.4;\n  return nb_cov(d, max(px, 0.3)) * inside * vis * 0.6;\n}\n\n// ---- the case: the cover's face (u from the spine edge, v from the head, world units)\n\n// Its height's slope (d/du, d/dv): the cloth rolling over the board's edge (the bevel), the groove\n// where the band's edge lies under the cover's cloth, the hinge's pressed groove, the weave, a blind press.\nfn nb_cover_g(k: NbUniforms, B: NbBook, q: vec2f, px: f32) -> vec2f {\n  let w = B.size.x;\n  let h = B.size.y;\n  let e = 0.05;\n  let d = nb_sd_fore(q, w, h, B.size.w);\n  let dg = vec2f(nb_sd_fore(q + vec2f(e, 0.0), w, h, B.size.w) - d, nb_sd_fore(q + vec2f(0.0, e), w, h, B.size.w) - d) / e;\n  // bevel: z = \u22121.1\xB7(1 + d/2.2)\xB2 over the last 2.2 units \u2014 its slope along the outline's normal\n  let t = nb_sat(1.0 + d / 2.2);\n  var g = dg * (-2.2 * t / 2.2) * select(0.0, 1.0, d > -2.2 && d < 0.0);\n  let band = B.page.w;\n  let xb = q.x - band;\n  g.x += 0.22 * exp(-(xb * xb) / 0.5) * (2.0 * xb / 0.5);\n  let xh = q.x - 7.0;\n  g.x += 0.55 * exp(-(xh * xh) / 2.2) * (2.0 * xh / 2.2);\n  if (B.foot.y < 0.5) { g += nb_cloth(q, k.cloth.x, px).g * k.cloth.y; }\n  else { g += nb_fbm(q * 1.1).yz * 1.1 * 0.05 * nb_detail(1.0, px); }\n  if (i32(B.look.x + 0.5) == 4 && q.x > band) {\n    // the blind-pressed frame\n    let p = q - vec2f(band, 0.0);\n    let hw = vec2f(w - band, h) * 0.5;\n    let db = nb_sd_box(p - hw, hw - vec2f(9.0), 2.5);\n    let dbg = vec2f(nb_sd_box(p + vec2f(e, 0.0) - hw, hw - vec2f(9.0), 2.5) - db, nb_sd_box(p + vec2f(0.0, e) - hw, hw - vec2f(9.0), 2.5) - db) / e;\n    g += dbg * (0.5 * exp(-(db * db) / 0.6) * (2.0 * db / 0.6));\n  }\n  return g;\n}\n\nfn nb_cover_albedo(k: NbUniforms, B: NbBook, q: vec2f, px: f32) -> vec3f {\n  let w = B.size.x;\n  let h = B.size.y;\n  let band = B.page.w;\n  let design = nb_design(B, q - vec2f(band, 0.0), w - band, h, px, B.col0.rgb).rgb;\n  var c = mix(design, B.col1.rgb, nb_cov(q.x - band, px));\n  if (B.foot.y < 0.5 || q.x < band) { c *= 1.0 + nb_cloth(q, k.cloth.x, px).shade * 0.16; }\n  else { c += vec3f(nb_fbm(q * 0.35).x * 0.035 + nb_fbm(q * 2.1).x * 0.02 * nb_detail(0.6, px)); }\n  return c;\n}\n\n// The inside of a board: the endpaper, framed by the cloth's turn-in along the head, the fore-edge and the tail.\nstruct NbEnd { albedo: vec3f, ao: f32 }\nfn nb_endpaper(k: NbUniforms, B: NbBook, q: vec2f, px: f32, stacked: bool, dqdx: vec2f, dqdy: vec2f, tex: texture_2d<f32>, samp: sampler) -> NbEnd {\n  let w = B.size.x;\n  let h = B.size.y;\n  let turn = 4.2;\n  let de = nb_sd_fore(q - vec2f(-2.0, turn), w - turn + 2.0, h - 2.0 * turn, max(B.size.w - turn * 0.6, 1.0));\n  let inside = nb_cov(de, px);\n  var cloth = B.col0.rgb;\n  if (B.foot.y < 0.5) { cloth *= 1.0 + nb_cloth(q, k.cloth.x, px).shade * 0.16; }\n  let paper = nb_paper(k, B.col5.rgb, q, dqdx, dqdy, 91.0 + B.look.w, tex, samp).albedo;\n  var out: NbEnd;\n  out.albedo = mix(cloth, paper, inside);\n  // the endpaper's edge: a hairline of shade where the paper lies over the cloth\n  out.ao = 1.0 - 0.3 * exp(-(de * de) / 0.35) * (1.0 - inside * 0.4);\n  if (stacked) {\n    // the text block standing on it: occlusion at its foot\n    let sq = B.open.w;\n    let ds = nb_sd_fore(q - vec2f(-4.0, sq), w - sq + 4.0, h - 2.0 * sq, B.page.z);\n    out.ao *= 1.0 - 0.34 * exp(-max(ds, 0.0) / 2.6);\n  }\n  return out;\n}\n\n// A board's edge: the cloth wrapped over it \u2014 the band's near the spine, the cover's beyond.\nfn nb_board(k: NbUniforms, B: NbBook, q: vec2f, px: f32) -> vec3f {\n  let w = B.size.x;\n  let h = B.size.y;\n  let r = B.size.w;\n  let total = 2.0 * (w - r) + NB_PI * r + h - 2.0 * r;\n  let band = B.page.w;\n  let inBand = max(1.0 - smoothstep(band - 0.5, band + 0.5, q.x), smoothstep(total - band - 0.5, total - band + 0.5, q.x));\n  var c = mix(B.col0.rgb, B.col1.rgb, inBand);\n  c *= 0.94 + nb_cloth(vec2f(q.x, q.y * 3.0), k.cloth.x, px).shade * 0.12;\n  return c;\n}\n\n// A stack's edge: the sheets' edges, one stripe each, each sheet a shade of its own; averaged as they fall under the pixel.\nfn nb_edge(k: NbUniforms, B: NbBook, q: vec2f, sheets: f32, side: f32, px: f32) -> vec3f {\n  let t = max(B.foot.z, 1e-3);\n  let f = q.y / t;\n  let i = floor(f);\n  let g = fract(f);\n  let vis = smoothstep(0.7, 2.2, t / px);\n  let own = hash12(vec2f(i + side * 131.0, 7.0)) - 0.5;\n  let gap = pow(1.0 - min(g, 1.0 - g) * 2.0, 6.0);\n  let rough = nb_vn(vec2f(q.x * 0.35, i * 1.7)).x * 0.05;\n  let shade = 0.9 + (own * 0.08 + rough) * vis - gap * 0.3 * vis;\n  return B.col6.rgb * shade;\n}\n",
+  "kit/composite.wgsl": "// (The kit's since K4a \u2014 moved from notebook/notebook-composite.wgsl: every layered kind lays its layer with it, kit/layer.ts `layerComposite`.)\n// A layered kind's layer onto the canvas: the resolved, premultiplied layer, over what the ground drew \u2014 through the slot's PORTAL CHAIN\n// (design-018 \xA74 \u2014 the kit's contract, which the kind's own passes cannot keep: they draw into the layer, not onto the canvas). The\n// whole layer is laid at the chain's cover, so its object fades as ONE (a book's cover never shows its pages through it \u2014 group\n// opacity, the tray's feather); at the root the chain is empty, the cover exactly 1, and the layer is laid as it always was.\n// K7a: the layer is its screen BOX's (kit/layer.ts `BoxTargets`) \u2014 the texel of a pixel is the pixel less the box's origin.\n\n@group(0) @binding(0) var layer: texture_2d<f32>;\n@group(0) @binding(1) var<uniform> origin: vec4f;\n@group(0) @binding(2) var<uniform> u: MatUniforms;\n\n@vertex\nfn vs(@builtin(vertex_index) vid: u32) -> @builtin(position) vec4f {\n  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));\n  return vec4f(p[vid], 0.0, 1.0);\n}\n\n@fragment\nfn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {\n  let dpr = u.cam.w;\n  return textureLoad(layer, vec2i(pos.xy) - vec2i(origin.xy), 0) * portal_cover(pos.xy / dpr, u.portals, u.clips, dpr);\n}\n",
+  "marks/marks-pass.wgsl": "// The marks pass \u2014 the desk's chrome over every stratum (design-015 \xA74.2 stratum 5, \xA77; D4a): one\n// instanced draw, one quad per mark over the screen rect the CPU gave it (`quad`, CSS px \u2014 the marks do\n// not zoom), one `marks_shade` per covered fragment, premultiplied out; a mark of light returns alpha 0,\n// so the blend (one, one \u2212 src alpha) adds it. The glyphs are the rulers' mono atlas (RULER.md), the\n// mat's own texture \u2014 the pills' and the rulers' numerals are one face.\n\n@group(0) @binding(0) var<uniform> u: MarksUniforms;\n@group(0) @binding(1) var<storage, read> marks: array<Mark>;\n@group(0) @binding(2) var glyph_tex: texture_2d<f32>;\n@group(0) @binding(3) var glyph_samp: sampler;\n\nstruct VSOut {\n  @builtin(position) clip: vec4f,\n  @location(0) @interpolate(flat) idx: u32,\n}\n\nconst CORNERS = array<vec2f, 6>(\n  vec2f(0.0, 0.0), vec2f(1.0, 0.0), vec2f(1.0, 1.0),\n  vec2f(0.0, 0.0), vec2f(1.0, 1.0), vec2f(0.0, 1.0),\n);\n\n@vertex\nfn vs(@builtin(vertex_index) vid: u32, @builtin(instance_index) iid: u32) -> VSOut {\n  var out: VSOut;\n  out.idx = iid;\n  let q = marks[iid].quad;\n  let pos = mix(q.xy, q.zw, CORNERS[vid]);   // CSS px\n  out.clip = vec4f(pos.x / u.view.x * 2.0 - 1.0, 1.0 - pos.y / u.view.y * 2.0, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs(in: VSOut) -> @location(0) vec4f {\n  let dpr = max(u.view.z, 1e-6);\n  var c = marks_shade(marks[in.idx], in.clip.xy / dpr, dpr, u.atlas, glyph_tex, glyph_samp);\n  // the tray's name tags fade in under the drawer's header as its specimens do (design-018 \xA74, R4) \u2014 from the first tag's record on\n  if (u.fade.y > 0.0 && f32(in.idx) >= u.fade.z) { c *= smoothstep(u.fade.x, u.fade.x + u.fade.y, in.clip.y / dpr); }\n  if (c.a <= 0.0 && max(c.r, max(c.g, c.b)) <= 0.0) { discard; }\n  return c;\n}\n",
+  "marks/marks.wgsl": "// The MARKS \u2014 the desk's chrome as SDF terms (design-015 \xA77, stratum 5; D4a): *Marks on the Mat*'s\n// reference drawing code (vibe-field/draft/desk-chrome/chrome.js) as distances. Every mark is ONE\n// record (a `Mark`, laid out on the CPU by src/marks/layout.ts in SCREEN px \u2014 the chrome keeps its size\n// at every zoom), shaded here into a premultiplied colour: an outline or a fill of a turned rounded\n// box (a frame, a ring, a knob, the vellum, a pill), the four brackets of a frame, a segment (solid or\n// dotted, a laser's line), a gap's bar with its end ticks, a flare, a glyph of the rulers' mono atlas\n// (with its halo), a strip of masking tape. Light is ADDED: a mark flagged so returns alpha 0 over its\n// colour, which the pass's premultiplied blend turns into dst + src \u2014 Canvas2D's \"lighter\".\n// Pure: every resource is a parameter (engine/shader.ts's rule).\n\nconst MARK_STROKE: f32 = 0.0;\nconst MARK_FILL: f32 = 1.0;\nconst MARK_BRACKETS: f32 = 2.0;\nconst MARK_SEGMENT: f32 = 3.0;\nconst MARK_BAR: f32 = 4.0;\nconst MARK_FLARE: f32 = 5.0;\nconst MARK_GLYPH: f32 = 6.0;\nconst MARK_TAPE: f32 = 7.0;\n\n/** Coverage of a distance (CSS px) over one DEVICE px of ramp. */\nfn marks_cov(sd: f32, dpr: f32) -> f32 { return clamp(0.5 - sd * dpr, 0.0, 1.0); }\n\n/** A screen point in a mark's own frame: about its centre, turned by \u2212angle (positive turns clockwise on screen, y down). */\nfn marks_local(p: vec2f, c: vec2f, angle: f32) -> vec2f {\n  let d = p - c;\n  let cs = cos(angle);\n  let sn = sin(angle);\n  return vec2f(cs * d.x + sn * d.y, -sn * d.x + cs * d.y);\n}\n\n/**\n * The distance to the four BRACKETS of a rounded frame (half extents X, Y, corner r), each reaching L from its\n * corner along both sides (chrome.js `bracketsPath`): folded into one quadrant, the run along the top edge from\n * its end to the arc, the arc, and the run down the side \u2014 round caps come from the distance itself.\n */\nfn marks_brackets(p: vec2f, X: f32, Y: f32, r: f32, L: f32) -> f32 {\n  let q = abs(p);\n  let top = length(q - vec2f(clamp(q.x, X - L, X - r), Y));\n  let side = length(q - vec2f(X, clamp(q.y, Y - L, Y - r)));\n  var d = min(top, side);\n  let v = q - vec2f(X - r, Y - r);\n  if (r > 0.0 && v.x >= 0.0 && v.y >= 0.0) { d = min(d, abs(length(v) - r)); }\n  return d;\n}\n\n/** The distance to a dotted line A\u2192B: a dot every `period` from A (Canvas2D's `[0.01, period \u2212 0.01]` dash with round caps). */\nfn marks_dotted(p: vec2f, a: vec2f, b: vec2f, period: f32) -> f32 {\n  let ab = b - a;\n  let len = length(ab);\n  let dir = ab / max(len, 1e-6);\n  let k = clamp(round(dot(p - a, dir) / period), 0.0, floor(len / period));\n  return length(p - (a + dir * (k * period)));\n}\n\n/** A gap's bar: the segment A\u2192B and a tick `tick` either side of it at each end, one stroke. */\nfn marks_bar(p: vec2f, a: vec2f, b: vec2f, tick: f32) -> f32 {\n  let ab = b - a;\n  let n = vec2f(-ab.y, ab.x) / max(length(ab), 1e-6) * tick;\n  return min(sdf_segment(p, a, b), min(sdf_segment(p, a - n, a + n), sdf_segment(p, b - n, b + n)));\n}\n\n/** Masking tape's torn outline (desk.css `.obj-tape i` clip-path), unit square, clockwise from the top-left. */\nconst TAPE_EDGE = array<vec2f, 12>(\n  vec2f(0.03, 0.0), vec2f(0.97, 0.04), vec2f(1.0, 0.22), vec2f(0.96, 0.40), vec2f(1.0, 0.60), vec2f(0.97, 0.80),\n  vec2f(1.0, 1.0), vec2f(0.02, 0.96), vec2f(0.0, 0.78), vec2f(0.04, 0.58), vec2f(0.0, 0.40), vec2f(0.03, 0.20),\n);\n\n/** The signed distance to the tape's outline, the strip `half` in its own frame (Quilez's polygon). */\nfn marks_tape_sd(p: vec2f, half: vec2f) -> f32 {\n  let v0 = (TAPE_EDGE[0] - 0.5) * 2.0 * half;\n  var d = dot(p - v0, p - v0);\n  var s = 1.0;\n  for (var i = 0u; i < 12u; i++) {\n    let j = (i + 11u) % 12u;\n    let vi = (TAPE_EDGE[i] - 0.5) * 2.0 * half;\n    let vj = (TAPE_EDGE[j] - 0.5) * 2.0 * half;\n    let e = vj - vi;\n    let w = p - vi;\n    let b = w - e * clamp(dot(w, e) / dot(e, e), 0.0, 1.0);\n    d = min(d, dot(b, b));\n    let c0 = p.y >= vi.y;\n    let c1 = p.y < vj.y;\n    let c2 = e.x * w.y > e.y * w.x;\n    if ((c0 && c1 && c2) || (!c0 && !c1 && !c2)) { s = -s; }\n  }\n  return s * sqrt(d);\n}\n\n/** CSS `saturate(s) brightness(b)` on an sRGB colour (the Filter Effects matrix). */\nfn marks_moonlit(c: vec3f, s: f32, b: f32) -> vec3f {\n  let r = vec3f(0.213 + 0.787 * s, 0.715 - 0.715 * s, 0.072 - 0.072 * s);\n  let g = vec3f(0.213 - 0.213 * s, 0.715 + 0.285 * s, 0.072 - 0.072 * s);\n  let bl = vec3f(0.213 - 0.213 * s, 0.715 - 0.715 * s, 0.072 + 0.928 * s);\n  return clamp(vec3f(dot(r, c), dot(g, c), dot(bl, c)) * b, vec3f(0.0), vec3f(1.0));\n}\n\n/** One texel sample of a cell (texels from its top-left, kept inside the cell: a neighbour's glyph never bleeds in). */\nfn marks_glyph_at(t: vec2f, cell: f32, size: vec2f, atlas: vec4f, tex: texture_2d<f32>, samp: sampler) -> f32 {\n  let at = vec2f(cell * atlas.w, 0.0) + clamp(t, vec2f(0.5), size - 0.5);\n  return textureSampleLevel(tex, samp, at / atlas.xy, 0.0).r;\n}\n\n/** The glyph atlas's coverage at a point of a cell's own frame (CSS px from its top-left; the cell `size` CSS px), `halo` > 0 = its coverage dilated that far. */\nfn marks_glyph_cov(q: vec2f, cell: f32, size: vec2f, atlas: vec4f, halo: f32, tex: texture_2d<f32>, samp: sampler) -> f32 {\n  let scale = atlas.z;\n  let t = q * scale;\n  let s = size * scale;\n  var c = marks_glyph_at(t, cell, s, atlas, tex, samp);\n  if (halo > 0.0) {\n    for (var i = 0; i < 8; i++) {\n      let a = f32(i) * 0.785398163;\n      let o = vec2f(cos(a), sin(a)) * halo * scale;\n      c = max(c, marks_glyph_at(t + o, cell, s, atlas, tex, samp));\n      c = max(c, marks_glyph_at(t + o * 0.5, cell, s, atlas, tex, samp));\n    }\n  }\n  return c;\n}\n\n/**\n * One mark at screen point `p` (CSS px), premultiplied \u2014 alpha 0 when it is light (added). `atlas` = the glyph atlas's\n * width, height (texels), texels per CSS px and cell width (texels).\n */\nfn marks_shade(M: Mark, p: vec2f, dpr: f32, atlas: vec4f, tex: texture_2d<f32>, samp: sampler) -> vec4f {\n  let kind = M.shape.x;\n  let width = M.shape.z;\n  var cov = 0.0;\n  var col = M.colour;\n  if (kind == MARK_STROKE || kind == MARK_FILL || kind == MARK_BRACKETS) {\n    let q = marks_local(p, M.centre.xy, M.centre.z);\n    let sd = sdf_round_box(q, M.half.xy, M.centre.w);\n    if (kind == MARK_STROKE) {\n      cov = marks_cov(abs(sd) - 0.5 * width, dpr);\n    } else if (kind == MARK_FILL) {\n      cov = marks_cov(sd, dpr);\n    } else {\n      cov = marks_cov(marks_brackets(q, M.half.x, M.half.y, M.centre.w, M.shape.w) - 0.5 * width, dpr);\n    }\n  } else if (kind == MARK_SEGMENT) {\n    let d = select(sdf_segment(p, M.centre.xy, M.half.xy), marks_dotted(p, M.centre.xy, M.half.xy, M.aux.x), M.aux.x > 0.0);\n    cov = marks_cov(d - 0.5 * width, dpr);\n  } else if (kind == MARK_BAR) {\n    cov = marks_cov(marks_bar(p, M.centre.xy, M.half.xy, M.aux.x) - 0.5 * width, dpr);\n  } else if (kind == MARK_FLARE) {\n    // a radial gradient: the core at the centre, the laser at `stop`, nothing at the rim \u2014 interpolated premultiplied\n    let t = length(p - M.centre.xy) / M.centre.w;\n    if (t >= 1.0) { return vec4f(0.0); }\n    let core = vec4f(M.aux.rgb * M.aux.a, M.aux.a);\n    let mid = vec4f(M.colour.rgb * M.colour.a, M.colour.a);\n    let stop = M.half.x;\n    let c = select(mix(mid, vec4f(0.0), (t - stop) / (1.0 - stop)), mix(core, mid, t / stop), t < stop);\n    return vec4f(c.rgb, select(c.a, 0.0, (u32(M.shape.y) & 1u) != 0u));\n  } else if (kind == MARK_GLYPH) {\n    // the cell turned about its centre (`centre.xy`), its own frame from its top-left; a halo reaches `aux.y` past it\n    let q = marks_local(p, M.centre.xy, M.centre.z) + 0.5 * M.half.xy;\n    let h = M.aux.y;\n    if (q.x < -h || q.y < -h || q.x > M.half.x + h || q.y > M.half.y + h) { return vec4f(0.0); }\n    cov = marks_glyph_cov(q, M.aux.x, M.half.xy, atlas, h, tex, samp);\n  } else if (kind == MARK_TAPE) {\n    // the strip in its own frame: its torn outline, its fibres (1 in `every` object units), a light from above, moonlit by night\n    let q = marks_local(p, M.centre.xy, M.centre.z);\n    let half = M.half.xy;\n    cov = marks_cov(marks_tape_sd(q, half), dpr);\n    let uv = (q + half) / (2.0 * half);\n    let units = M.aux.x;   // CSS px per object unit\n    let sheen = mix(vec4f(1.0, 1.0, 1.0, M.half.z), vec4f(0.0, 0.0, 0.0, M.half.w), clamp(uv.y, 0.0, 1.0));\n    var c = vec4f(M.colour.rgb * M.colour.a, M.colour.a);\n    c = vec4f(sheen.rgb * sheen.a, sheen.a) + c * (1.0 - sheen.a);\n    let every = M.shape.w;\n    let x = (q.x + half.x) / max(units, 1e-6);\n    let seen = clamp(every * units * dpr / 3.0 - 0.5, 0.0, 1.0);   // fibres under ~1.5 device px each fade to the mean\n    let fibre = select(0.0, 1.0, fract(x / every) < 1.0 / every) * seen + (1.0 - seen) / every;\n    let fa = M.aux.w * fibre;\n    c = vec4f(vec3f(fa), fa) + c * (1.0 - fa);\n    let rgb = marks_moonlit(c.rgb / max(c.a, 1e-6), M.aux.y, M.aux.z);\n    let a = c.a * cov * M.centre.w;\n    return vec4f(rgb * a, a);\n  }\n  let a = col.a * cov;\n  return vec4f(col.rgb * a, select(a, 0.0, (u32(M.shape.y) & 1u) != 0u));\n}\n",
+  "mat/mat-pass.wgsl": "// PASS 2, the cutting mat \u2014 one fullscreen triangle: the lattice's lines as\n// analytic coverage, the grain, the gobo projected onto the desk plane, the\n// reference's grade by day or the night's eye by night (MAT.md). Alpha 1 at\n// rest (a plain write); a flight fades it and clips it to the portal.\n\n@group(0) @binding(0) var<uniform> u: MatUniforms;\n@group(0) @binding(1) var gobo_tex: texture_2d<f32>;\n@group(0) @binding(2) var gobo_samp: sampler;\n@group(0) @binding(3) var noise_tex: texture_2d<f32>;\n@group(0) @binding(4) var noise_samp: sampler;\n@group(0) @binding(5) var glyph_tex: texture_2d<f32>;   // the rulers' glyph atlas (RULER.md); a 1\xD71 empty cell until a host uploads one\n\nstruct VSOut { @builtin(position) clip: vec4f }\n\n@vertex\nfn vs(@builtin(vertex_index) vid: u32) -> VSOut {\n  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));\n  var out: VSOut;\n  out.clip = vec4f(p[vid], 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs(in: VSOut) -> @location(0) vec4f {\n  let zoom = mat_zoom(u);\n  let dpr = mat_dpr(u);\n  let frag = in.clip.xy;                       // device px\n  let screen = frag / dpr;                     // CSS px\n  let px = 1.0 / (zoom * dpr);                 // world per device px\n  let bn = textureSampleLevel(noise_tex, noise_samp, frag * u.noise.z + u.noise.xy, 0.0).rgb;\n  // the rulers' print \u2014 screen-space ink mixed into the albedo before the light, so it is lit and shadowed like the lines\n  let ruler = ruler_ink(u, screen, frag, glyph_tex, gobo_samp);\n  let albedo = mat_albedo(u, u.phase.xy + screen / zoom, px, frag, bn, ruler);\n  // the lamp's gobo where the LIGHT sees this pixel (MINIMAT.md \xA74): the slot's own camera at rest\n  // (`light` = `cam`, so this is the desk under the pixel), the host desk's through a mini mat's face\n  var gobo = sample_gobo(u, gobo_tex, gobo_samp, desk_of(u, u.light.xy + screen / max(u.light.z, 1e-12)), bn.z);\n  if (u.light.w > 0.0) { gobo = mix(gobo, sample_gobo(u, gobo_tex, gobo_samp, desk_of(u, u.light2.xy + screen / max(u.light2.z, 1e-12)), bn.z), u.light.w); }\n  // Straight alpha: the presentation's opacity through the portal clip \u2014 both 1 at rest,\n  // when \"source over\" reduces to a plain write.\n  return vec4f(mat_colour(u, albedo, gobo, bn.y), u.presence.x * portal_cover(screen, u.portals, u.clips, dpr));\n}\n",
+  "mat/mat.wgsl": "// The cutting mat's maths \u2014 a PURE module: no bindings. The uniform block and\n// the textures arrive as parameters. Every function body is the reference's\n// (research/tree-shadow/prototype/src/shaders.js), transcribed to the engine's\n// units: world = CSS px at zoom 1, the lattice's decade rungs, `MatUniforms`\n// from src/mat/layout.ts prepended by the engine.\n\nfn mat_zoom(u: MatUniforms) -> f32 { return max(u.cam.z, 1e-12); }\nfn mat_dpr(u: MatUniforms) -> f32 { return max(u.cam.w, 1.0); }\n\n// ---- the reference's noise (hash12 \xB7 valueNoise), on framebuffer pixels\nfn hash12(p: vec2f) -> f32 {\n  let n = sin(dot(p, vec2f(127.1, 311.7))) * 43758.5453;\n  return n - floor(n);\n}\n\nfn value_noise(p: vec2f) -> f32 {\n  let i = floor(p);\n  var f = fract(p);\n  f = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash12(i), hash12(i + vec2f(1.0, 0.0)), f.x),\n    mix(hash12(i + vec2f(0.0, 1.0)), hash12(i + vec2f(1.0, 1.0)), f.x),\n    f.y);\n}\n\nfn srgb_to_linear(c: vec3f) -> vec3f {\n  return mix(c / 12.92, pow((c + 0.055) / 1.055, vec3f(2.4)), step(vec3f(0.04045), c));\n}\n\nfn rgb2hsb(c: vec3f) -> vec3f {\n  let K = vec4f(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n  let p = mix(vec4f(c.bg, K.wz), vec4f(c.gb, K.xy), step(c.b, c.g));\n  let q = mix(vec4f(p.xyw, c.r), vec4f(c.r, p.yzx), step(p.x, c.r));\n  let d = q.x - min(q.w, q.y);\n  let e = 1.0e-10;\n  return vec3f(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n}\n\nfn hsb2rgb(c: vec3f) -> vec3f {\n  let K = vec4f(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n  let p = abs(fract(K.xyz + c.x) * 6.0 - K.w);\n  return c.z * mix(K.xxx, clamp(p - K.x, vec3f(0.0), vec3f(1.0)), c.y);\n}\n\n// ---- the lines. `px` is world units per DEVICE pixel; half-widths are in device px.\nfn line_coverage(x: f32, spacing: f32, half_width: f32, px: f32) -> f32 {\n  let d = abs(fract(x / spacing - 0.5) - 0.5) * spacing;\n  return 1.0 - smoothstep(max(half_width - px, 0.0), half_width + px, d);\n}\n\nfn grid2(p: vec2f, spacing: f32, half_width: f32, px: f32) -> f32 {\n  return max(line_coverage(p.x, spacing, half_width, px), line_coverage(p.y, spacing, half_width, px));\n}\n\n// One law for every rung (src/lattice/line.ts `lineWeight`): fade in over the\n// engine's window by the rung's OWN cell, then thicken and darken over the\n// next decade. x = half-width (device px), y = alpha.\nfn line_weight(u: MatUniforms, cell_px: f32) -> vec2f {\n  let s = smoothstep(u.lod.x, u.lod.y, cell_px);\n  let t = saturate(log(max(cell_px, 1e-9) / u.lod.y) / 2.302585093);\n  return vec2f(mix(u.line.x, u.line.y, t), u.line.z * s + (u.line.w - u.line.z) * t);\n}\n\n// The mat's albedo at a point: the reference's `cuttingMatAlbedo` with the\n// three lattice rungs in place of its own decade, and the line law above in\n// place of its fade ladder. `world` is lattice-phase world (wrapped); `px` is\n// world per device pixel; `frag` is the framebuffer pixel; `ruler` the rulers'\n// print at it (ruler.wgsl) \u2014 ink over the lines, and at 0 exactly the mix below\n// returns the lined mat untouched, bit for bit.\nfn mat_albedo(u: MatUniforms, world: vec2f, px: f32, frag: vec2f, bn: vec3f, ruler: f32) -> vec3f {\n  var sage = u.ground.xyz;\n  let amp = u.grain.x;\n  var g = (hash12(frag * vec2f(0.73, 0.91)) - 0.5) * amp;\n  g += (value_noise(frag * 0.45 + vec2f(u.view.z * 0.9, -u.view.z * 0.6)) - 0.5) * amp;\n  g += (bn.x - 0.5) * amp * 0.5;\n  sage += vec3f(g * 0.4, g, g * 0.35);\n\n  // A rung under the window has alpha 0 and no coverage to compute \u2014 the\n  // fine rung at most zooms. The branches are uniform across the frame.\n  let zoom = mat_zoom(u);\n  var cover = 0.0;\n  let wf = line_weight(u, u.rungs.x * zoom);\n  if (wf.y > 0.0) { cover = grid2(world, u.rungs.x, wf.x * px, px) * wf.y; }\n  let wm = line_weight(u, u.rungs.y * zoom);\n  if (wm.y > 0.0) { cover = max(cover, grid2(world, u.rungs.y, wm.x * px, px) * wm.y); }\n  let wc = line_weight(u, u.rungs.z * zoom);\n  if (wc.y > 0.0) { cover = max(cover, grid2(world, u.rungs.z, wc.x * px, px) * wc.y); }\n  return srgb_to_linear(clamp(mix(mix(sage, u.ink.xyz, cover), u.ink.xyz, ruler), vec3f(0.0), vec3f(1.0)));\n}\n\n// ---- the gobo (the reference's sampleBlur \xB7 getGoboBlurRatio \xB7 sampleGobo)\nfn linearstep(edge0: f32, edge1: f32, x: f32) -> f32 {\n  return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n}\n\n// Linearise the WebGL-range NDC z with the projector's near/far, then ramp\n// between the two depths: sharp near the projector, soft far from it.\nfn blur_ratio(ndc_z: f32, p: vec4f) -> f32 {\n  return linearstep(p.x, p.y, (2.0 * p.z * p.w) / (p.w + p.z - ndc_z * (p.w - p.z)));\n}\n\n// Six taps on a golden-angle spiral, the start angle from blue noise so the\n// pattern differs per pixel (and per frame while the offset moves).\nfn sample_blur(tex: texture_2d<f32>, samp: sampler, uv: vec2f, texel: vec2f, blur: f32, n: f32) -> f32 {\n  // No blur: six taps at one point are one tap. The sharp end of the desk.\n  if (blur <= 0.0) { return textureSampleLevel(tex, samp, uv, 0.0).r; }\n  let G = 2.39996323;\n  let rot = mat2x2f(cos(G), sin(G), -sin(G), cos(G));\n  let a0 = n * 6.28318530718;\n  var d = vec2f(cos(a0), sin(a0));\n  let s = texel * blur * (1.0 / sqrt(6.0));\n  var c = 0.0;\n  for (var i = 0; i < 6; i++) {\n    c += textureSampleLevel(tex, samp, uv + d * sqrt(f32(i + 1)) * s, 0.0).r;\n    d = rot * d;\n  }\n  return c / 6.0;\n}\n\n// The gobo term at a desk point (metres): 1 = lit. Outside the projector's\n// frame the plate is not consulted at all \u2014 the cone is finite, as the\n// reference's is.\nfn sample_gobo(u: MatUniforms, tex: texture_2d<f32>, samp: sampler, desk: vec3f, n: f32) -> f32 {\n  if (u.gobo.x <= 0.0) { return 1.0; }\n  var clip = u.goboMatrix * vec4f(desk, 1.0);\n  let ndc = clip.xyz / clip.w;\n  // The wind target's row 0 is the plate's top row, so v runs downward.\n  let uv = vec2f(0.5 + 0.5 * ndc.x, 0.5 - 0.5 * ndc.y);\n  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\n  let g = sample_blur(tex, samp, uv, vec2f(1.0 / 512.0), blur_ratio(ndc.z, u.goboParams) * u.gobo.y, n);\n  return mix(1.0, g, u.gobo.x);\n}\n\n// World (CSS px at zoom 1, unwrapped) \u2192 the desk plane in the projector's frame.\nfn desk_of(u: MatUniforms, world: vec2f) -> vec3f {\n  return vec3f(u.plane.x + world.x * u.plane.z, u.plane.w, u.plane.y + world.y * u.plane.z);\n}\n\n// ---- the LIGHT a slot is lit by (MINIMAT.md \xA74; src/mat/layout.ts `SlotLight`). The lamp's gobo is\n// sampled where a light CAMERA sees a point, not where the slot's camera does: the same camera for the\n// root at rest; the host desk's for a mini mat's inside \u2014 the dapple runs across the mini mat as across\n// anything lying on the desk \u2014 and two of them cross-faded (`light.w`) while a flight hands one lamp to\n// the other. An object's world point `p` raised `h` world units, as light camera `L` (x, y, zoom) sees it:\n// the point on screen, back into L's world; a height scales as a length does.\nfn lit_desk(u: MatUniforms, L: vec4f, p: vec2f, h: f32) -> vec3f {\n  let s = max(u.cam.z, 1e-12) / max(L.z, 1e-12);\n  let w = L.xy + (p - u.cam.xy) * s;\n  return vec3f(u.plane.x + w.x * u.plane.z, u.plane.w + h * s * u.plane.z, u.plane.y + w.y * u.plane.z);\n}\n\n// The gobo on an object's world point `p` raised `h`: under the slot's own lamp the desk point itself,\n// `own` (the object's own `desk_at`, so a root's object reads exactly what it always read); else under\n// the light camera \u2014 then, while a flight hands it over, cross-faded to the second.\nfn lit_gobo(u: MatUniforms, tex: texture_2d<f32>, samp: sampler, p: vec2f, h: f32, own: vec3f, n: f32) -> f32 {\n  var g = 0.0;\n  if (all(u.light.xyz == u.cam.xyz)) { g = sample_gobo(u, tex, samp, own, n); }\n  else { g = sample_gobo(u, tex, samp, lit_desk(u, u.light, p, h), n); }\n  if (u.light.w > 0.0) { g = mix(g, sample_gobo(u, tex, samp, lit_desk(u, u.light2, p, h), n), u.light.w); }\n  return g;\n}\n\n// The reference's grade: `shade = mix(1, floor + (1 \u2212 floor)\xB7gobo, mix)`, then\n// HSB: saturation up by (1 \u2212 shade)\xB7k, brightness \xD7 shade. The reference did\n// this on pow(albedo, 2.2) and wrote pow(1/2.2) \u2014 kept verbatim: that chain is\n// the mat's colour on screen.\nfn shade_mat(u: MatUniforms, albedo: vec3f, gobo: f32) -> vec3f {\n  // Lit: shade is exactly 1, the saturation bump exactly 0, and the chain is\n  // pow(pow(albedo, 2.2), 1/2.2) \u2014 the identity. Every pixel outside the\n  // cone, and every lit one inside it, skips six pows and the HSB round trip.\n  if (gobo >= 1.0) { return albedo; }\n  let shade = mix(1.0, u.gobo.w + (1.0 - u.gobo.w) * gobo, u.gobo.z);\n  var hsb = rgb2hsb(pow(albedo, vec3f(2.2)));\n  hsb.y = min(hsb.y + (1.0 - shade) * u.grade.x, 1.0);\n  hsb.z = hsb.z * shade;\n  return pow(hsb2rgb(hsb), vec3f(1.0 / 2.2));\n}\n\n// ---- the NIGHT (MAT.md; src/mat/night.ts is the same arithmetic on the CPU):\n// the Moon in place of the Sun, and the eye that sees by it. The day's chain\n// above is untouched \u2014 `mat_colour` returns it, alone, when `night.x` is 0.\nfn night_luminance(c: vec3f) -> f32 { return dot(c, vec3f(0.2126729, 0.7151522, 0.0721750)); }\n\n// Scotopic luminance V' from XYZ \u2014 Larson, Rushmeier & Piatko 1997's regression:\n// the rods peak at 507 nm, so greens and blues keep their brightness by night and reds die.\nfn night_scotopic(c: vec3f) -> f32 {\n  let X = dot(c, vec3f(0.4124564, 0.3575761, 0.1804375));\n  let Y = dot(c, vec3f(0.2126729, 0.7151522, 0.0721750));\n  let Z = dot(c, vec3f(0.0193339, 0.1191920, 0.9503041));\n  return Y * (1.33 * (1.0 + (Y + Z) / max(X, 1e-6)) - 1.68);\n}\n\n// CIE 191:2010's mesopic weight \u2014 the cones' share of the seeing at L cd/m\xB2:\n// 0 at 0.005 (the rods alone), 1 at 5 (the cones alone).\nfn night_mesopic(L: f32) -> f32 { return saturate(0.767 + 0.3334 * log(max(L, 1e-9)) * 0.4342944819); }\n\nfn night_encode(c: vec3f) -> vec3f {\n  return mix(c * 12.92, 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - 0.055, step(vec3f(0.0031308), c));\n}\n\nfn night_mat(u: MatUniforms, albedo: vec3f, gobo: f32, noise: f32) -> vec3f {\n  let shade = u.moon.w + (1.0 - u.moon.w) * gobo;                         // the Moon, and the sky's share where it is blocked\n  let cone = albedo * u.moon.xyz * shade;                                  // the mat under the Moon, as the partly adapted cones take it\n  let rod = max(night_scotopic(cone), 0.0) / night_scotopic(vec3f(1.0));  // the rods' signal, white = 1\n  let L = u.night.y * night_luminance(cone) * 0.3183098862;               // cd/m\xB2 on the desk: E \xB7 \u03C1 / \u03C0\n  let see = mix(rod * u.rod.xyz, cone, night_mesopic(L));                 // what the eye reports\n  let disp = u.eigengrau.xyz + see * u.night.z;                            // the dark's own grey under it, at the appearance's scale\n  return night_encode(disp) + (noise - 0.5) * u.night.w;                   // encoded; then the rods' own noise\n}\n\n// The mat's colour on screen: the day's chain, the night, or a cross-fade of the two.\nfn mat_colour(u: MatUniforms, albedo: vec3f, gobo: f32, noise: f32) -> vec3f {\n  if (u.night.x <= 0.0) { return shade_mat(u, albedo, gobo); }\n  let night = night_mat(u, albedo, gobo, noise);\n  if (u.night.x >= 1.0) { return night; }\n  return mix(shade_mat(u, albedo, gobo), night, u.night.x);\n}\n",
+  "mat/ruler.wgsl": "// The RULERS printed on the mat (RULER.md) \u2014 a PURE module: no bindings. The\n// ink coverage at a fragment from the frame's lines, the ticks and the labels,\n// in screen space; the mat pass mixes it into the albedo before the light, so\n// the print is lit and shadowed like the lines. Every number is a uniform\n// `matUniformValues` fills from lattice/ruler.ts \u2014 the levels' spacings,\n// presences and tick lengths per frame; the shader only lays them out.\n//\n// Layout: the frame's outer rect one `margin` in from the viewport; the top\n// and left BANDS one `band` wide inside it, each closed by its inner line\n// (the ticks' baseline). A tick stands on the baseline at every site of every\n// level, its length the level's, its presence the level's. A label sits in\n// the band's outer half after its tick, laid out on the finest labelled\n// level's sites; the left ruler's labels are the top's rotated a quarter turn\n// clockwise (reading down the band, their tops toward the field) \u2014 James's\n// mockup. All distances are DEVICE px inside; positions arrive as CSS px.\n\nconst RULER_LEVELS = 5;\nconst GLYPH_PAD = 2.0;\n\n// A printed line's coverage across `d` device px at half-width `hw`: a 1 px AA ramp.\nfn ruler_line(d: f32, hw: f32) -> f32 { return 1.0 - smoothstep(hw - 0.5, hw + 0.5, abs(d)); }\n// Inside [a, b] \u2014 the ends of a segment and the extents of a band.\nfn ruler_in(x: f32, a: f32, b: f32) -> f32 { return step(a, x) * step(x, b); }\n\nfn ruler_digits(a: i32) -> i32 { var n = 1; var v = a; loop { if (v < 10) { break; } v = v / 10; n += 1; } return n; }\nfn ruler_pow10(p: i32) -> i32 { var r = 1; for (var i = 0; i < p; i++) { r = r * 10; } return r; }\n// The i-th digit (0 = leftmost) of `a` written with `nd` digits \u2014 leading zeros where `a` is short.\nfn ruler_digit_at(a: i32, i: i32, nd: i32) -> i32 { return (a / ruler_pow10(nd - 1 - i)) % 10; }\n\n// A label's text \u2014 lattice/ruler.ts `formatLabel`, per character: the glyph\n// index at slot `k` of `index \xB7 mult \xB7 10^exp` (0\u20139, 10 '-', 11 '.', -1 past\n// the end), and (x < 0) the character count. Plain digits, no suffix; a\n// fraction with its trailing zeros stripped, so \"1.0\" is \"1\" at every level.\nfn ruler_label(index: i32, mult: i32, exp: i32, k: i32) -> i32 {\n  let M = index * mult;\n  if (M == 0) { return select(-1, 0, k == 0); }\n  let neg = M < 0;\n  let a = abs(M);\n  var i = k;\n  if (neg) { if (i == 0) { return 10; } i -= 1; }\n  if (exp >= 0) {\n    let nd = ruler_digits(a);\n    if (i < nd) { return ruler_digit_at(a, i, nd); }\n    if (i < nd + exp) { return 0; }\n    return -1;\n  }\n  let p = -exp;\n  let nd = max(ruler_digits(a), p + 1);\n  let intDigits = nd - p;\n  var fracLen = p;\n  loop { if (fracLen == 0) { break; } if ((a / ruler_pow10(p - fracLen)) % 10 != 0) { break; } fracLen -= 1; }\n  if (i < intDigits) { return ruler_digit_at(a, i, nd); }\n  if (i == intDigits) { return select(-1, 11, fracLen > 0); }\n  let j = i - intDigits - 1;\n  if (j < fracLen) { return ruler_digit_at(a, intDigits + j, nd); }\n  return -1;\n}\nfn ruler_label_len(index: i32, mult: i32, exp: i32) -> i32 {\n  var n = 0;\n  loop { if (n >= 16) { break; } if (ruler_label(index, mult, exp, n) < 0) { break; } n += 1; }\n  return n;\n}\n\n// The ticks and the label along ONE band. `along` is the fragment's CSS px\n// along the band (x for the top, y for the left), `across` its device px in\n// from the outer line; `phase` the lattice's wrapped camera coordinate along\n// it, `wraps` the wrap count, `lim` the band's extent along (CSS px: the inner\n// corner, the far frame line), `turned` the left band. `glyph` receives the\n// atlas texel to sample when the fragment lies in a label (its .z the label's\n// presence), else .z 0.\nstruct RulerHit { ink: f32, glyph: vec3f }\n\nfn ruler_band(u: MatUniforms, along: f32, across: f32, phase: f32, wraps: f32, lim: vec2f, turned: bool) -> RulerHit {\n  var hit: RulerHit;\n  hit.ink = 0.0; hit.glyph = vec3f(0.0);\n  let dpr = mat_dpr(u); let zoom = mat_zoom(u);\n  let band_dev = u.ruler.z * dpr;\n  let hw = 0.5 * u.ruler.w * dpr;\n  // only the band's own pixels pay for the levels and the text \u2014 the rest of the mat returns here\n  if (across < -1.0 || across > band_dev + 1.0 || ruler_in(along, lim.x, lim.y) <= 0.0) { return hit; }\n  let w = phase + along / zoom;   // lattice-phase world along the band\n  // the ticks: on the baseline (the band's inner edge), up the level's length; the coarsest level owning a site wins the max\n  var tick = 0.0;\n  for (var i = 0; i < RULER_LEVELS; i++) {\n    let s = u.rulerSites[i].x;\n    let len = u.rulerSites[i].y * dpr;\n    let a = u.rulerSites[i].z;\n    if (a <= 0.0 || len <= 0.0) { continue; }\n    let d = (abs(fract(w / s - 0.5) - 0.5) * s) * zoom * dpr;\n    tick = max(tick, ruler_line(d, hw) * ruler_in(across, band_dev - len - 0.5, band_dev + 0.5) * a);\n  }\n  hit.ink = tick * u.rulerAlpha.y;\n  // the label: laid out on the finest labelled level's sites, the site at or before the fragment\n  let lf = i32(u.rulerOrigin.z);\n  if (lf < 0 || u.rulerAtlas.w <= 0.0) { return hit; }\n  let s = u.rulerSites[lf].x;\n  let nLocal = floor(w / s);\n  let site = (nLocal * s - phase) * zoom;   // CSS px along\n  if (site < lim.x) { return hit; }          // a site inside the corner square prints nothing\n  let index = i32(wraps) * i32(u.rulerFormat[lf].z) + i32(nLocal);\n  // the site's presence: the coarsest level it lies on\n  var presence = u.rulerSites[lf].w;\n  for (var j = RULER_LEVELS - 1; j > lf; j--) {\n    let ratio = i32(u.rulerFormat[lf].z) / i32(u.rulerFormat[j].z);\n    if (index % ratio == 0) { presence = u.rulerSites[j].w; break; }\n  }\n  if (presence <= 0.0) { return hit; }\n  let mult = i32(u.rulerFormat[lf].x); let exp = i32(u.rulerFormat[lf].y);\n  let texel = u.rulerText.w / dpr;           // atlas texels per device px\n  let adv = u.rulerGlyph.z / texel;          // a glyph's advance, device px\n  let origin = floor((site + u.rulerText.y) * dpr + 0.5);   // the text's start, on a whole device px\n  let t = along * dpr - origin;\n  if (t < 0.0) { return hit; }\n  let slot = i32(floor(t / adv));\n  let g = ruler_label(index, mult, exp, slot);\n  if (g < 0) { return hit; }\n  // the glyph cell. The top band: the cap's top `top` in from the outer line, the glyph read down the band. The left band: the\n  // glyph turned a quarter CLOCKWISE \u2014 read down the band still, but its baseline `top` in from the outer line and its top toward\n  // the field (the mockup's \"1\" above \"0\", the foot of the \"1\" at the outer side). Reading along +y with the cell's rows along \u2212x\n  // keeps the hand: a rotation, not the mirror a transpose would be.\n  var v = 0.0;\n  if (turned) { v = u.rulerGlyph.w - (across - u.rulerText.x * dpr) * texel; }\n  else { v = (across - (u.rulerText.x * dpr - (u.rulerGlyph.w - u.rulerAtlas.z) / texel)) * texel; }\n  if (v < 0.0 || v >= u.rulerGlyph.y) { return hit; }\n  let uu = f32(g) * u.rulerGlyph.x + GLYPH_PAD + (t - f32(slot) * adv) * texel;\n  hit.glyph = vec3f(uu, v, presence);\n  return hit;\n}\n\n// The whole print: the frame's lines, the two bands' ticks, the labels'\n// texels sampled from the atlas. Returns ink coverage 0..1 at this fragment.\nfn ruler_ink(u: MatUniforms, screen: vec2f, frag: vec2f, glyph_tex: texture_2d<f32>, samp: sampler) -> f32 {\n  if (u.ruler.x <= 0.0) { return 0.0; }\n  let dpr = mat_dpr(u);\n  let margin = u.ruler.y; let band = u.ruler.z;\n  let W = u.view.x; let H = u.view.y;\n  let hw = 0.5 * u.ruler.w * dpr;\n  let m = margin * dpr; let inner = (margin + band) * dpr;\n  let right = (W - margin) * dpr; let bottom = (H - margin) * dpr;\n  // the frame: the outer rect, and the two baselines closing the bands\n  var frame = 0.0;\n  frame = max(frame, ruler_line(frag.x - m, hw) * ruler_in(frag.y, m - hw, bottom + hw));\n  frame = max(frame, ruler_line(frag.x - right, hw) * ruler_in(frag.y, m - hw, bottom + hw));\n  frame = max(frame, ruler_line(frag.y - m, hw) * ruler_in(frag.x, m - hw, right + hw));\n  frame = max(frame, ruler_line(frag.y - bottom, hw) * ruler_in(frag.x, m - hw, right + hw));\n  frame = max(frame, ruler_line(frag.x - inner, hw) * ruler_in(frag.y, m, bottom));\n  frame = max(frame, ruler_line(frag.y - inner, hw) * ruler_in(frag.x, m, right));\n  var ink = frame * u.rulerAlpha.x;\n  // the top band (across = down from the outer line) and the left band (across = right from it); a pixel in neither pays nothing more.\n  // The labels: the top band's cell read along x, the left band's along y and turned \u2014 the same atlas texels either way.\n  if (ruler_in(frag.y, m - 1.0, inner + 1.0) * ruler_in(frag.x, inner - 1.0, right + 1.0) > 0.0) {\n    let top = ruler_band(u, screen.x, frag.y - m, u.phase.x, u.rulerOrigin.x, vec2f(margin + band, W - margin), false);\n    ink = max(ink, top.ink);\n    if (top.glyph.z > 0.0) { ink = max(ink, textureSampleLevel(glyph_tex, samp, top.glyph.xy / u.rulerAtlas.xy, 0.0).r * top.glyph.z * u.rulerAlpha.z); }\n  }\n  if (ruler_in(frag.x, m - 1.0, inner + 1.0) * ruler_in(frag.y, inner - 1.0, bottom + 1.0) > 0.0) {\n    let left = ruler_band(u, screen.y, frag.x - m, u.phase.y, u.rulerOrigin.y, vec2f(margin + band, H - margin), true);\n    ink = max(ink, left.ink);\n    if (left.glyph.z > 0.0) { ink = max(ink, textureSampleLevel(glyph_tex, samp, left.glyph.xy / u.rulerAtlas.xy, 0.0).r * left.glyph.z * u.rulerAlpha.z); }\n  }\n  return ink;\n}\n",
+  "mat/wind.wgsl": "// The wind pass \u2014 the reference's `goboWind`: one fragment per plate texel,\n// R silhouette + three sines whose amplitudes and phase the plate's other\n// channels carry, written to an r8 target the mat pass samples. Runs only when\n// the gobo time moved; the target is 512\xB2 like the plate.\n\n@group(0) @binding(0) var<uniform> u: MatUniforms;\n@group(0) @binding(1) var plate: texture_2d<f32>;\n\nstruct VSOut { @builtin(position) clip: vec4f }\n\n@vertex\nfn vs(@builtin(vertex_index) vid: u32) -> VSOut {\n  var p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));\n  var out: VSOut;\n  out.clip = vec4f(p[vid], 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs(in: VSOut) -> @location(0) vec4f {\n  let params = textureLoad(plate, vec2i(in.clip.xy), 0);\n  let time = u.wind.x;\n  let strength = u.wind.y;\n  let s = params.r;\n  let amp1 = params.g * strength;\n  let phase1 = (params.b - 0.5) * 6.283185;\n  let amp23 = params.a * strength;\n  let waves = sin(time * vec3f(1.0, 2.0, 3.0) + phase1 * vec3f(1.0, 2.0, 0.5));\n  let motion = (amp1 * waves.x) + (amp23 * 0.5 * waves.y) + (amp23 * 0.3 * waves.z);\n  let v = clamp(s + motion, 0.0, 1.0);\n  return vec4f(v, 0.0, 0.0, 1.0);\n}\n",
+  "portal.wgsl": "// The portal clip \u2014 a slot's ground and frames are visible only through a\n// rounded rect on screen (CSS px): its FACE and, for a nested slot, every face\n// above it \u2014 the CHAIN (src/nav/portal.ts `Presentation`, `within`). A PURE\n// module every pass includes: the records arrive as parameters. `clips[i].y`\n// < 0.5 ends the chain (an empty chain is no clip at all, and the loop is one\n// compare); `clips[i].x` is a face's corner radius; `clips[i].z` its top\n// FEATHER (CSS px; 0 = a hard edge \u2014 design-018 \xA74, the tray's face: what it\n// shows fades in over that band below its top edge, with no code of its own).\n\n// = nav/portal.ts PORTAL_CHAIN, the uniform arrays' length; a mismatch fails to compile.\nconst PORTAL_CHAIN = 6u;\n\nfn portal_sd(p: vec2f, half: vec2f, r: f32) -> f32 {\n  let rr = min(r, min(half.x, half.y));\n  let q = abs(p) - half + vec2f(rr, rr);\n  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - rr;\n}\n\n// Coverage at a CSS-px point through ONE face grown by `grow` device px: 1 inside, 0 outside, a one-device-px ramp across the edge \u2014\n// times, where the face has a feather, a smoothstep from 0 at its top edge to 1 the feather below it.\nfn portal_cover_one(p_css: vec2f, portal: vec4f, clip: vec4f, dpr: f32, grow: f32) -> f32 {\n  let px = 1.0 / max(dpr, 1.0);\n  let d = portal_sd(p_css - portal.xy, portal.zw, clip.x) - grow * px;\n  let c = clamp(0.5 - d / px, 0.0, 1.0);\n  if (clip.z <= 0.0) { return c; }\n  let top = portal.y - portal.w;\n  return c * smoothstep(top, top + clip.z, p_css.y);\n}\n\n// Coverage through the chain: the slot's own face grown by `grow` device px (the fill's one\n// px, so the hole's edge partitions with the plate \u2014 PORTAL.md \xA710) times every face above\n// it as it is. The product: a nested slot shows only where all of them agree.\nfn portal_cover_grown(p_css: vec2f, portals: array<vec4f, PORTAL_CHAIN>, clips: array<vec4f, PORTAL_CHAIN>, dpr: f32, grow: f32) -> f32 {\n  var c = 1.0;\n  for (var i = 0u; i < PORTAL_CHAIN; i++) {\n    if (clips[i].y < 0.5) { break; }\n    c *= portal_cover_one(p_css, portals[i], clips[i], dpr, select(0.0, grow, i == 0u));\n  }\n  return c;\n}\n\nfn portal_cover(p_css: vec2f, portals: array<vec4f, PORTAL_CHAIN>, clips: array<vec4f, PORTAL_CHAIN>, dpr: f32) -> f32 {\n  return portal_cover_grown(p_css, portals, clips, dpr, 0.0);\n}\n",
+  "primitives.wgsl": "// 2D primitives for the desk's objects \u2014 the note, the whiteboard, the photo,\n// the mini mat. Pure functions, exact Euclidean distances \u2014 which is what\n// everything downstream (1-px AA, the analytic shadows, the hit-test mirrors,\n// src/sdf.ts) relies on. Prefixed `sdf_` so this module can share a program\n// with the mat's module without a name clash. Moved out of shaders/card/ when\n// the card frame retired (2026-09-25).\n// (Lineage: research/sdf-card/src/sdf/primitives.wgsl.)\n\nfn sdf_box(p: vec2f, b: vec2f) -> f32 {\n  let q = abs(p) - b;\n  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0);\n}\n\nfn sdf_round_box(p: vec2f, b: vec2f, r: f32) -> f32 {\n  let rr = clamp(r, 0.0, min(b.x, b.y));\n  let q  = abs(p) - b + rr;\n  return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - rr;\n}\n\nfn sdf_circle(p: vec2f, r: f32) -> f32 { return length(p) - r; }\n\nfn sdf_segment(p: vec2f, a: vec2f, b: vec2f) -> f32 {\n  let pa = p - a;\n  let ba = b - a;\n  let h  = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);\n  return length(pa - ba * h);\n}\n\nfn sdf_rounded_x(p: vec2f, w: f32, r: f32) -> f32 {\n  let q = abs(p);\n  return length(q - min(q.x + q.y, w) * 0.5) - r;\n}\n\n// Exact circular fillet CSG (Quilez). Unlike smin/smax these put a TRUE circle\n// of radius r on the seam. Exact when the operands are perpendicular\n// half-planes (the retired card frame's corner was built to satisfy it).\n//\n// The union form clamps its operands to >= -r so the fillet stays local: the\n// unclamped hg_sdf form keeps growing once both surfaces are more than r\n// inside, and the field goes badly wrong in the interior.\nfn op_union_round(a: f32, b: f32, r: f32) -> f32 {\n  let m = min(a, b);\n  let A = max(a, -r);\n  let B = max(b, -r);\n  let u = max(vec2f(r - A, r - B), vec2f(0.0));\n  return min(m, max(r, min(A, B)) - length(u));\n}\n\nfn op_isect_round(a: f32, b: f32, r: f32) -> f32 {\n  let u = max(vec2f(r + a, r + b), vec2f(0.0));\n  return min(-r, max(a, b)) + length(u);\n}\n",
+  "tray/tray-pass.wgsl": "// The pegboard tray's pass (design-017 \xA75; K5a; design-018 \xA72): drawn in the ROOT's render pass after the marks, premultiplied, two kinds\n// of quad \u2014 one vertex entry that lays each by its instance, two fragment entries (two pipelines on one layout: a branch over both in one\n// entry cost the board a third of its time, the register budget of the largest path paid by every pixel): instance 0 the drawer UNDER\n// its specimens, its edge included (`fs` \u2192 tray.wgsl `tray_drawer` \u2014 the view whole while the slide shows the dim, the drawer's box grown\n// by its shadows' reach while nothing dims; shut, nothing is drawn at all); from instance 1, one quad per specimen's ACCESSORY with its\n// shadow (`fs_accessory`, the records in `acc`). The rim's strips over it all retired with the rim (design-018 \xA72).\n\n@group(0) @binding(0) var<uniform> u: MatUniforms;\n@group(0) @binding(1) var<uniform> t: TrayUniforms;\n@group(0) @binding(2) var noise_tex: texture_2d<f32>;\n@group(0) @binding(3) var noise_samp: sampler;\n@group(0) @binding(4) var hash_tex: texture_2d<f32>;\n@group(0) @binding(5) var<storage, read> acc: array<TrayAccessory>;\n\nstruct TrayOut {\n  @builtin(position) pos: vec4f,\n  @location(0) @interpolate(flat) mode: u32,\n  @location(1) @interpolate(flat) item: u32,\n}\n\n@vertex\nfn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> TrayOut {\n  var corners = array<vec2f, 6>(vec2f(0.0, 0.0), vec2f(1.0, 0.0), vec2f(0.0, 1.0), vec2f(0.0, 1.0), vec2f(1.0, 0.0), vec2f(1.0, 1.0));\n  let k = corners[vi % 6u];\n  let vw = t.view.x;\n  let vh = t.view.y;\n  var lo = vec2f(0.0, 0.0);\n  var hi = vec2f(vw, vh);\n  var o: TrayOut;\n  o.mode = 0u;\n  o.item = 0u;\n  if (ii == 0u) {\n    // dimming: the view whole; undimmed: the drawer's box from its shadows' reach above and beside it down to the view's bottom edge\n    if (t.dim <= 0.0) {\n      let reach = 3.0 * max(t.shadow.x, t.room.x) + length(t.shadow.zw);\n      lo = vec2f(max(t.rect.x - reach, 0.0), max(t.rect.y - reach, 0.0));\n      hi = vec2f(min(t.rect.x + t.rect.z + reach, vw), vh);\n    }\n  } else {\n    o.mode = 1u;\n    o.item = ii - 1u;\n    let b = acc[o.item].box;\n    lo = clamp(b.xy, vec2f(0.0), vec2f(vw, vh));\n    hi = clamp(b.zw, vec2f(0.0), vec2f(vw, vh));\n  }\n  let css = mix(lo, hi, k);\n  o.pos = vec4f(css.x / vw * 2.0 - 1.0, 1.0 - css.y / vh * 2.0, 0.0, 1.0);\n  return o;\n}\n\n@fragment\nfn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {\n  return tray_drawer(u, t, pos.xy, noise_tex, noise_samp, hash_tex);\n}\n\n@fragment\nfn fs_accessory(@builtin(position) pos: vec4f, @location(1) @interpolate(flat) item: u32) -> @location(0) vec4f {\n  return tray_accessory(u, t, acc[item], pos.xy, noise_tex, noise_samp, hash_tex);\n}\n\n// THE VEIL (design-018 rev 5): one quad over the drawer's top \u2014 from its edge down through the header and its ramp \u2014 laid LAST, over\n// everything the drawer holds (tray.wgsl `tray_veil`: the plain board, whole in the header, fading out over the ramp).\n@vertex\nfn vs_veil(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  var corners = array<vec2f, 6>(vec2f(0.0, 0.0), vec2f(1.0, 0.0), vec2f(0.0, 1.0), vec2f(0.0, 1.0), vec2f(1.0, 0.0), vec2f(1.0, 1.0));\n  let k = corners[vi % 6u];\n  let vw = t.view.x;\n  let vh = t.view.y;\n  let lo = clamp(vec2f(t.rect.x, t.rect.y), vec2f(0.0), vec2f(vw, vh));\n  let hi = clamp(vec2f(t.rect.x + t.rect.z, t.rect.y + t.shape.y + t.fade.y + t.fade.x + 1.0), vec2f(0.0), vec2f(vw, vh));\n  let css = mix(lo, hi, k);\n  return vec4f(css.x / vw * 2.0 - 1.0, 1.0 - css.y / vh * 2.0, 0.0, 1.0);\n}\n\n@fragment\nfn fs_veil(@builtin(position) pos: vec4f) -> @location(0) vec4f {\n  return tray_veil(u, t, pos.xy, noise_tex, noise_samp, hash_tex);\n}\n",
+  "tray/tray.wgsl": "// THE PEGBOARD TRAY (design-017 \xA75\u2013\xA76; design-018 \xA72\u2013\xA74) \u2014 the drawer, and the research board in it (research/sdf-pegboard, shader.js)\n// lying on the mat, shaded in CLOSED FORM for a head-on view: no march, no history, no jitter \u2014 every frame is final, so a scrolling\n// drawer is clean on every frame. Its edge is an arris in the face's material; its holes show the desk as drawn under it, black at the\n// board's shadow; under its top edge a clear HEADER (design-018 R4) where nothing hangs and no hole opens, then what hangs on it fades in\n// through the face's portal feather (every kind's `portal_cover`) and here, the accessories and the holes. A PURE module: the uniform blocks arrive as parameters \u2014 `u` the mat's struct carrying the DESK's light (the colour law\n// is mat.wgsl's own), `t` the tray's (src/tray/pass.ts) \u2014 and so does the blue noise.\n//\n// Board units are PITCHES (the research's 1). A board point is x from the drawer's left edge and Y down the board, Y split into a\n// whole row R (i32: the scroll's whole rows carried on the CPU plus the rows on screen) and fy \u2208 [0,1): nothing large ever enters\n// an f32, so the pattern is exact at any scroll (src/tray/lattice.ts is this arithmetic on the CPU, rounding half up as here).\n\n// ---- hashing: the research's pcg, on integer lattice points only (wrapping u32)\nfn peg_pcg(v: u32) -> u32 {\n  let s = v * 747796405u + 2891336453u;\n  let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;\n  return (w >> 22u) ^ w;\n}\n\n// Four independent uniforms for a lattice cell (the research's hash2i4).\nfn peg_hash4(x: u32, y: u32, seed: u32) -> vec4f {\n  let h0 = peg_pcg(x ^ peg_pcg(y + seed));\n  let h1 = peg_pcg(h0);\n  let h2 = peg_pcg(h1);\n  let h3 = peg_pcg(h2);\n  return vec4f(f32(h0), f32(h1), f32(h2), f32(h3)) * 2.3283064365386963e-10;\n}\n\n// ---- the board point\nstruct PegPoint { x: f32, R: i32, fy: f32 }\n\n// The same point moved by `d` pitches \u2014 the move's rows re-carried into R, so R stays exact.\nfn peg_move(p: PegPoint, d: vec2f) -> PegPoint {\n  let y = p.fy + d.y;\n  let fl = floor(y);\n  return PegPoint(p.x + d.x, p.R + i32(fl), y - fl);\n}\n\n// ---- value noise on the board (the research's noise2, its quintic fade): the value and its gradient in lattice units. The corners'\n// hashes come PRE-GATHERED (src/tray/pass.ts `hashTexels`: texel (i, j) holds the research's pcg hash of lattice points (i, j),\n// (i+1, j), (i, j+1), (i+1, j+1), 8 bits each, tiled every 256 cells) \u2014 one load where the pcg took eight rounds. Each band reads\n// it at its own offset (its seed); the lattice point is an integer, so the noise stays exact at any row.\nfn peg_vnoise(ht: texture_2d<f32>, x: u32, y: u32, f: vec2f, seed: u32) -> vec3f {\n  let u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let du = 30.0 * f * f * (f * (f - 2.0) + 1.0);\n  let k = textureLoad(ht, vec2u((x + seed) & 255u, (y + ((seed * 2654435761u) >> 24u)) & 255u), 0);\n  let a = k.r;\n  let b = k.g;\n  let c = k.b;\n  let d = k.a;\n  let v = mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n  return vec3f(v, du.x * mix(b - a, d - c, u.y), du.y * mix(c - a, d - b, u.x));\n}\n\n// One band at (fx, fy) cells per pitch (integers): its lattice row is R\xB7fy plus the cells within the row, in wrapping u32 \u2014 seamless\n// and exact at any R. The value, and its gradient in pitches.\nfn peg_band(ht: texture_2d<f32>, p: PegPoint, fx: u32, fy: u32, seed: u32) -> vec3f {\n  let X = p.x * f32(fx);\n  let ix = floor(X);\n  let Y = p.fy * f32(fy);\n  let iy = floor(Y);\n  let n = peg_vnoise(ht, u32(i32(ix)), u32(p.R) * fy + u32(i32(iy)), vec2f(X - ix, Y - iy), seed);\n  return vec3f(n.x, n.y * f32(fx), n.z * f32(fy));\n}\n\n// \u230Aa / b\u230B for b > 0 (WGSL's `/` truncates toward zero).\nfn peg_floor_div(a: i32, b: i32) -> i32 {\n  let q = a / b;\n  return select(q, q - 1, (a % b != 0) && (a < 0));\n}\n\n// Value noise on a TURNED lattice, exact at any row: lattice coordinates M\xB7(x, Y)\xB7num/den, M = [[a, \u2212b], [b, a]] an INTEGER rotation\n// and scale (cells turned atan(b/a), num\xB7\u221A(a\xB2 + b\xB2)/den of them to a pitch), so no octave's cells line up with the board or with\n// another octave's \u2014 value noise's square cells stop reading as squares. The carried row splits R = den\xB7Q + r: Q's share is an\n// exact integer (\u2212b\xB7num\xB7Q, a\xB7num\xB7Q); only x, r and fy, all small, are ever a float. One pre-gathered load.\nfn peg_rot(ht: texture_2d<f32>, p: PegPoint, a: i32, b: i32, num: i32, den: i32, seed: u32) -> f32 {\n  let q = peg_floor_div(p.R, den);\n  let r = f32(p.R - q * den) + p.fy;\n  let uv = vec2f(f32(a) * p.x - f32(b) * r, f32(b) * p.x + f32(a) * r) * (f32(num) / f32(den));\n  let cell = floor(uv);\n  let base = vec2i(i32(cell.x) - b * num * q, i32(cell.y) + a * num * q);\n  return peg_vnoise(ht, u32(base.x), u32(base.y), uv - cell, seed).x;\n}\n\n// The research's \"fine detail fading with pixel footprint\", per band: F cycles per pitch are kept while a cycle spans \u2265 4 device\n// px and gone at 2, so a scrolling board never shimmers (a fleck by its thin side, not its cell). The footprint is the frame's, so\n// every band's share is a UNIFORM (pass.ts `keep` \u2014 `1 \u2212 smoothstep(\xBC, \xBD, fp\xB7F)`): the face's grain (\u2248 19) \xB7 85 \xB7 190, then\n// 210 \xB7 42 \xB7 105, the punched fibre's 9 \xB7 18 \xB7 36.\n\n// Sparse fibre flecks (the research's `flecks`): one randomly turned ellipse per jittered cell at F per pitch, signed \u2014 dark\n// negative, pale positive. A stroke's thin side is sub-pixel long before its cell is (\u2248 0.3 of it): its edge is widened by the pixel's\n// footprint in the ellipse's own measure and its peak lowered to keep its ink \u2014 analytic AA, the stroke a faint line, never a dash\n// (the research averaged 1024 jittered samples to the same end). `fp` = pitches per device px.\nfn peg_flecks(p: PegPoint, F: u32, density: f32, seed: u32, fp: f32) -> f32 {\n  let X = p.x * f32(F);\n  let ix = floor(X);\n  let Y = p.fy * f32(F);\n  let iy = floor(Y);\n  let cx = u32(i32(ix));\n  let cy = u32(p.R) * F + u32(i32(iy));\n  let q = vec2f(X - ix, Y - iy);\n  var acc = 0.0;\n  for (var j = -1; j <= 1; j++) {\n    for (var i = -1; i <= 1; i++) {\n      let r = peg_hash4(cx + u32(i), cy + u32(j), seed);\n      if (r.w > density) { continue; }\n      let d = q - (vec2f(f32(i), f32(j)) + r.xy);\n      let ang = r.z * 3.14159265;\n      let ca = cos(ang);\n      let sa = sin(ang);\n      let dl = vec2f(d.x * ca + d.y * sa, -d.x * sa + d.y * ca);\n      let wid = 0.10 + 0.10 * r.y;\n      let e = length(vec2f(dl.x / (0.35 + 0.65 * r.x), dl.y / wid));\n      let aa = fp * f32(F) / wid;\n      acc += (1.0 - smoothstep(0.6 - aa, 1.0 + aa, e)) / (1.0 + 2.0 * aa) * select(-1.0, 0.8, r.z > 0.62);\n    }\n  }\n  return clamp(acc, -1.0, 1.0);\n}\n\n// ---- the lattice (the research's cellCoord \xB7 sdStadiumV)\nstruct PegHole { q: vec2f, d: f32, g: vec2f }\n\n// The vertical stadium at an offset from its centre: the distance (negative inside) and its gradient, pointing out of the hole.\nfn peg_stadium(t: TrayUniforms, q: vec2f) -> vec3f {\n  let e = vec2f(q.x, q.y - clamp(q.y, -t.hole.y, t.hole.y));\n  let len = max(length(e), 1.0e-6);\n  return vec3f(len - t.hole.x, e / len);\n}\n\n// The hole of the nearest row (a hole's half-height, 0.33, is under half a pitch): rows at Y = r + \xBE, odd rows shifted \xBD \u2014 the\n// stagger's parity from the exact row index. A hole whose centre lies within the solid border of a side is never punched.\nfn peg_hole(t: TrayUniforms, p: PegPoint) -> PegHole {\n  let dr = floor(p.fy - t.depth.w + 0.5);\n  let row = p.R + i32(dr);\n  let shift = t.depth.z + select(0.0, 0.5, (row & 1) != 0);\n  let hx = p.x - shift;\n  let col = floor(hx + 0.5);\n  var h: PegHole;\n  h.q = vec2f(hx - col, p.fy - dr - t.depth.w);\n  let s = peg_stadium(t, h.q);\n  h.d = s.x;\n  h.g = s.yz;\n  let cx = col + shift;\n  if ((cx < t.hole.w) || (cx > t.rect.z / t.view.w - t.hole.w)) { h.d = 1.0e3; }\n  return h;\n}\n\n// ---- the materials (the research's boardMat \xB7 wallMat), linear albedo\n// The tempered face: the TONE drift \u2014 two smooth octaves on lattices turned against the board and each other (cells 2.24 and 0.89\n// of a pitch), the research's big and mid fbm as a UI pitch shows them \u2014 and the fine fibre GRAIN on a third (cells 0.05 of a pitch,\n// \u2248 19 a pitch: what survives of the research's fine grain where its footprint lets it), then at a reading pitch the research's fine\n// height grain and its bump, the fibre flecks \u2014 every band faded by its own footprint. Out: the grain as one factor on the face's\n// linear albedo (`g`: the albedo is face\xB7(1 + g)), the height's gradient (the bump), and whether the face is FLAT (every bump faded).\nstruct PegFace { g: f32, grad: vec2f, flat: bool }\nfn peg_face(ht: texture_2d<f32>, t: TrayUniforms, p: PegPoint, fp: f32) -> PegFace {\n  let tone = 0.62 * (peg_rot(ht, p, 2, 1, 1, 5, 0x3a1u) - 0.5) + 0.38 * (peg_rot(ht, p, 1, -2, 1, 2, 0x5c7u) - 0.5);\n  var grain = 0.0;\n  let kg = t.keepFace.x;\n  if (kg > 0.0) { grain = kg * (peg_rot(ht, p, 3, 1, 6, 1, 0x2b1u) - 0.5); }\n  // the fine height (the research's faceHeight: 0.55 \xB7 85, 0.30 \xB7 190\xD770, 0.15 \xB7 60\xD7210) \u2014 at a UI pitch its footprint fades it\n  var h = 0.0;\n  var grad = vec2f(0.0);\n  let k85 = t.keepFace.z;\n  let k190 = t.keepFace.w;\n  let k210 = t.keepFine.x;\n  if (k85 > 0.0) { let n = peg_band(ht, p, 85u, 85u, 0x1f3u); h += 0.55 * k85 * (n.x - 0.5); grad += 0.55 * k85 * n.yz; }\n  if (k190 > 0.0) { let n = peg_band(ht, p, 190u, 70u, 0x4a7u); h += 0.30 * k190 * (n.x - 0.5); grad += 0.30 * k190 * n.yz; }\n  if (k210 > 0.0) { let n = peg_band(ht, p, 60u, 210u, 0x7c9u); h += 0.15 * k210 * (n.x - 0.5); grad += 0.15 * k210 * n.yz; }\n  let k42 = t.keepFine.y;\n  let k105 = t.keepFine.z;\n  var fl = 0.0;\n  if (k42 > 0.0) { fl += 0.30 * k42 * peg_flecks(p, 42u, 0.40, 0xa13u, fp); }\n  if (k105 > 0.0) { fl += 0.18 * k105 * peg_flecks(p, 105u, 0.35, 0xc35u, fp); }\n  var f: PegFace;\n  f.g = (1.0 + 0.12 * tone + 0.08 * grain + 0.40 * h) * (1.0 + fl) - 1.0;\n  f.grad = grad;\n  f.flat = (k85 <= 0.0) && (k190 <= 0.0) && (k210 <= 0.0);\n  return f;\n}\n\n// The paler, fuzzier punched fibre (the research's edge): its clumps at 9 \xB7 18 \xB7 36 per pitch, faded by the footprint.\nfn peg_edge(ht: texture_2d<f32>, t: TrayUniforms, p: PegPoint, fp: f32) -> vec3f {\n  var clump = 0.0;\n  let k9 = t.keepEdge.x;\n  let k18 = t.keepEdge.y;\n  let k36 = t.keepEdge.z;\n  if (k9 > 0.0) { clump += 0.5 * k9 * (peg_band(ht, p, 9u, 9u, 0x3e5u).x - 0.5); }\n  if (k18 > 0.0) { clump += 0.25 * k18 * (peg_band(ht, p, 18u, 18u, 0x5a9u).x - 0.5); }\n  if (k36 > 0.0) { clump += 0.125 * k36 * (peg_band(ht, p, 36u, 36u, 0x7bdu).x - 0.5); }\n  return t.edge.xyz * (1.0 + 0.30 * clump / 0.875);\n}\n\n// ---- the light: the research's HOME lamp (D-K3.4), in the desk's colour law and room\n// The desk's colour law on the tray (the paper's `paper_colour`, chain 0): by day the mat's grade on the sRGB albedo \u2014 lit (`gobo`\n// 1) the identity, a configured byte is the drawn byte; in shadow the room's \xBD and its touch of saturation \u2014 by night the Moon and\n// the eye (mat.wgsl `night_mat`) on the linear albedo; between, the cross-fade.\nfn tray_colour(u: MatUniforms, albedo: vec3f, gobo: f32, noise: f32) -> vec3f {\n  let day = shade_mat(u, albedo, gobo);\n  if (u.night.x <= 0.0) { return day; }\n  let night = night_mat(u, srgb_to_linear(albedo), gobo, noise);\n  if (u.night.x >= 1.0) { return night; }\n  return mix(day, night, u.night.x);\n}\n\n// A surface under the lamp, its linear albedo and normal \u2192 the colour on screen. The relief is the paper's \u2014 `(N\xB7L/L_z)^(1/2.2)`, the\n// flat face exactly 1 \u2014 and only brightens; a normal turned from the lamp takes the room's grade instead (`gobo` = the Lambert term),\n// so a face turned away reads as a shadow does, never black. `vis`: the lamp seen at all. The glint is the photo's.\nfn tray_lit(u: MatUniforms, t: TrayUniforms, alb: vec3f, n: vec3f, vis: f32, noise: f32) -> vec3f {\n  let L = t.lamp.xyz;\n  let lam = clamp(dot(n, L) / max(L.z, 1.0e-3), 0.0, 1.6);\n  let srgb = clamp(night_encode(alb) * pow(max(lam, 1.0), 1.0 / 2.2), vec3f(0.0), vec3f(1.0));\n  var c = tray_colour(u, srgb, min(lam, 1.0) * vis, noise);\n  let H = normalize(L + vec3f(0.0, 0.0, 1.0));\n  let spec = pow(saturate(dot(n, H)), 48.0) * 0.08 * vis;\n  let glint = mix(vec3f(1.0, 0.985, 0.95), vec3f(0.78, 0.86, 1.0) * 0.5, saturate(u.night.x));\n  return c + glint * spec;\n}\n\n// ---- the board: the face and the rim fillet, and the desk through a hole\n// The front surface at a board point: the face, or \u2014 within k of a hole \u2014 the fillet. On smax(slab, \u2212hole, k) = 0 seen head-on the\n// surface's blend weight is h = \u221A(d/k) for d \u2208 [0,k], and its normal normalize(((h \u2212 1)\xB7\u2207d, h)) sweeps from the hole's wall to the\n// face: the rim's lit edge and its shadowed one, in the paler punched fibre where the normal is steep (the research's faceness).\nfn peg_surface(ht: texture_2d<f32>, u: MatUniforms, t: TrayUniforms, p: PegPoint, h: PegHole, fp: f32, noise: f32) -> vec3f {\n  let k = t.hole.z;\n  let face = peg_face(ht, t, p, fp);\n  // the PLAIN FACE \u2014 clear of every fillet, its bump faded: N\xB7L is L_z exactly, the relief 1, the glint nothing; the grain's small\n  // linear factor rides the configured byte to first order ((1 + g)^(1/2.4) \u2248 1 + g/2.4 \u2014 the byte itself where the grain is 0)\n  if ((h.d >= k) && face.flat) {\n    return tray_colour(u, clamp(t.faceSrgb.xyz * (1.0 + face.g / 2.4), vec3f(0.0), vec3f(1.0)), 1.0, noise);\n  }\n  var n = normalize(vec3f(-face.grad * 0.003, 1.0));   // the research's bump: 0.0030 per unit of the height's slope\n  if (h.d < k) {\n    let s = sqrt(max(h.d, 0.0) / k);\n    n = normalize(vec3f((s - 1.0) * h.g, s));\n  }\n  let faceness = smoothstep(0.35, 0.75, n.z);\n  var alb = t.face.xyz * (1.0 + face.g);\n  if (faceness < 1.0) { alb = mix(peg_edge(ht, t, p, fp) * 0.86, alb, faceness); }   // the punched rim, burnished at the front\n  return tray_lit(u, t, alb, n, 1.0, noise);\n}\n\n// Through a hole: THE DESK AS DRAWN (design-018 \xA73). A hole is cut through the board, so it shows what lies under the drawer this\n// frame \u2014 the mat's green, its grid lines, the leaf shadows, anything laid there \u2014 in the board's shadow: premultiplied BLACK over the\n// frame, at the alpha that leaves `f` of the light. THE TWO PLANES (design-017 \xA76.4) give the lamp at the mat: the ray from the mat\n// toward the lamp crosses the board's back face at A and its front face at B; the mat is lit iff both lie in the SAME hole \u2014 B's, with\n// A tested against it (a convex prism holds the segment iff it holds both ends) \u2014 the penumbra from the SDF distance, widened by the\n// lamp's size over each plane's height. The room's light reaches the mat through the hole, cut by the cavity. f = a\xB7cav + (1 \u2212 a)\xB7vis,\n// `a` the room's share (the mat's own shade-in-shadow: shade_mat at gobo 0) \u2014 ENCODED as the mat's own chain encodes its shade (its\n// grade lives in pow-2.2 space), so the densest hole is the mat's shade under a leaf \u2014 over the desk dimmed as the rest of it is.\nfn peg_through(u: MatUniforms, t: TrayUniforms, p: PegPoint, h: PegHole, fp: f32) -> f32 {\n  let L = t.lamp.xyz;\n  let lz = max(L.z, 1.0e-3);\n  let off = L.xy / lz;\n  let thick = t.depth.x;\n  let gap = t.depth.y;\n  let hb = peg_hole(t, peg_move(p, off * (gap + thick)));\n  let da = peg_stadium(t, hb.q - off * thick).x;\n  // the penumbra: the lamp's angular radius over the ray's length to each plane's edge (height / L_z), and a pixel\n  let wa = t.lamp.w * gap / lz + fp;\n  let wb = t.lamp.w * (gap + thick) / lz + fp;\n  let vis = smoothstep(-wb, wb, -hb.d) * smoothstep(-wa, wa, -da);\n  let cav = mix(t.cavity.x, t.cavity.y, smoothstep(0.0, t.cavity.z, -h.d));\n  let a = 1.0 - u.gobo.z * (1.0 - u.gobo.w);\n  let f = a * cav + (1.0 - a) * vis;\n  return 1.0 - (1.0 - t.dim) * pow(f, 1.0 / 2.2);\n}\n\n// ---- the drawer\nfn tray_erf(x: f32) -> f32 {\n  let s = sign(x);\n  let a = abs(x);\n  let k = 1.0 / (1.0 + 0.3275911 * a);\n  let y = 1.0 - (((((1.061405429 * k - 1.453152027) * k) + 1.421413741) * k - 0.284496736) * k + 0.254829592) * k * exp(-a * a);\n  return s * y;\n}\n\n// Gaussian-blurred coverage of an outline at distance d (the shadow, straight out of the field \u2014 the paper's).\nfn tray_blur(d: f32, sigma: f32) -> f32 { return 0.5 - 0.5 * tray_erf(d / max(sigma * 1.4142136, 1.0e-4)); }\n\n// The drawer's outline (CSS px, negative inside): a box whose top corners round and whose bottom lies past the view \u2014 what is drawn\n// and what casts the shadows (the finger notch retired \u2014 design-018 \xA72).\nfn tray_outline(t: TrayUniforms, p: vec2f) -> f32 {\n  let r = t.shape.x;\n  let ext = vec2f(0.5 * t.rect.z, 0.5 * t.rect.w + r);\n  return sdf_round_box(p - vec2f(t.rect.x + ext.x, t.rect.y + ext.y), ext, r);\n}\n\n// The board point under a pixel (CSS px) \u2014 the rows on screen added to the carried rows in i32.\nfn tray_point(t: TrayUniforms, p: vec2f) -> PegPoint {\n  let ly = (p.y - t.rect.y) / t.view.w + t.frac;\n  let fl = floor(ly);\n  return PegPoint((p.x - t.rect.x) / t.view.w, t.rowBase + i32(fl), ly - fl);\n}\n\n// The board's EDGE (design-018 \xA72): an ARRIS \u2014 a quarter-round `A` px wide where the face meets the outline, in the FACE's own\n// material (its tone at the board point under it, so the grain runs on without a seam; not the paler punched fibre). Its normal turns\n// from the eye (on the face's side) to the outline's outward direction (at the outline): it catches the lamp where the outline faces\n// it \u2014 the top and the left \u2014 and falls to the room's shade on the far side. `o`: the outline's distance there (\u2212A \u2026 0).\nfn tray_arris(ht: texture_2d<f32>, u: MatUniforms, t: TrayUniforms, p: vec2f, o: f32, noise: f32) -> vec3f {\n  let e = 0.5;\n  let gx = tray_outline(t, p + vec2f(e, 0.0)) - tray_outline(t, p - vec2f(e, 0.0));\n  let gy = tray_outline(t, p + vec2f(0.0, e)) - tray_outline(t, p - vec2f(0.0, e));\n  let g = vec2f(gx, gy) / max(length(vec2f(gx, gy)), 1.0e-6);\n  let s = clamp(1.0 + o / t.shape.y, 0.0, 1.0);\n  let n = vec3f(s * g, sqrt(max(1.0 - s * s, 0.0)));\n  let face = peg_face(ht, t, tray_point(t, p), t.fp);\n  return tray_lit(u, t, t.face.xyz * (1.0 + face.g), n, 1.0, noise);\n}\n\n// The board to its edge, PREMULTIPLIED: the point under the carry, its hole \u2014 the front surface over it by its analytic coverage, and\n// where the surface is not, the desk seen through (black at the hole's alpha). `holes` scales every hole's OPENING: 1 as punched (the\n// board under the specimens), 0 CLOSED \u2014 the plain face, its fillets' relief flattened into it (the VEIL's board, `tray_veil`).\nfn tray_board(ht: texture_2d<f32>, u: MatUniforms, t: TrayUniforms, p: vec2f, noise: f32, holes: f32) -> vec4f {\n  let pt = tray_point(t, p);\n  let h = peg_hole(t, pt);\n  let cg = clamp(0.5 + h.d / t.fp, 0.0, 1.0);   // the surface's analytic coverage as punched\n  let open = (1.0 - cg) * holes;                  // what of the pixel the hole opens\n  var col = vec4f(0.0);\n  if (holes < 1.0) {\n    // closing: the plain face where the hole no longer opens, and the fillet (within `hole.z` of it) turning to the face\n    var plain = h;\n    plain.d = 1.0e3;\n    let face = peg_surface(ht, u, t, pt, plain, t.fp, noise);\n    var s = face;\n    if (cg > 0.0 && h.d < t.hole.z) { s = mix(face, peg_surface(ht, u, t, pt, h, t.fp, noise), holes); }\n    col = vec4f(s, 1.0) * cg + vec4f(face, 1.0) * ((1.0 - cg) * (1.0 - holes));\n  } else if (cg > 0.0) {\n    col = vec4f(peg_surface(ht, u, t, pt, h, t.fp, noise), 1.0) * cg;\n  }\n  if (open > 0.0) { col += vec4f(0.0, 0.0, 0.0, peg_through(u, t, pt, h, t.fp) * open); }\n  return col;\n}\n\n// A pixel INSIDE the drawer's outline (`o` its distance there, `px` a device px in CSS px), premultiplied: the edge within `A` of the\n// outline, the board inside it with its holes at `holes` \u2014 blended across the pixel where they meet \u2014 and the edge's INNER SHADOW over\n// the board (D-R1.2): the window's lip on the lamp's side, black at up to `shape.z`, fading over `shape.w` px inside the edge, where the\n// outline faces the lamp (the push of the drawer's lamp shadow points away from it).\nfn tray_inside(ht: texture_2d<f32>, u: MatUniforms, t: TrayUniforms, p: vec2f, px: f32, o: f32, noise: f32, holes: f32) -> vec4f {\n  let k = clamp(0.5 + (o + t.shape.y) / px, 0.0, 1.0);\n  var col = vec4f(0.0);\n  if (k > 0.0) { col = vec4f(tray_arris(ht, u, t, p, o, noise), 1.0); }\n  if (k < 1.0) {\n    var b = tray_board(ht, u, t, p, noise, holes);\n    if (t.shape.z > 0.0 && -o - t.shape.y < t.shape.w) {\n      let e = 0.5;\n      let g = normalize(vec2f(tray_outline(t, p + vec2f(e, 0.0)) - tray_outline(t, p - vec2f(e, 0.0)), tray_outline(t, p + vec2f(0.0, e)) - tray_outline(t, p - vec2f(0.0, e))) + vec2f(1.0e-6, 0.0));\n      let facing = max(dot(g, -normalize(t.shadow.zw)), 0.0);\n      let sh = t.shape.z * facing * (1.0 - smoothstep(0.0, t.shape.w, -o - t.shape.y));\n      b = vec4f(b.rgb * (1.0 - sh), 1.0 - (1.0 - b.a) * (1.0 - sh));\n    }\n    col = mix(b, col, k);\n  }\n  return col;\n}\n\n// One pixel of the tray UNDER its specimens (`frag` in device px), the view whole: the dim over the desk, the drawer's shadows on it,\n// the board to the outline and its edge, every hole as punched \u2014 premultiplied, each pixel drawn once. The board scrolls under its edge\n// (the drawer is a window onto it). The specimens hang over the board inside the edge and under the header (their face clip,\n// tray/specimens.ts `faceClip`); the VEIL (`tray_veil`) is laid over them all at the top.\nfn tray_drawer(u: MatUniforms, t: TrayUniforms, frag: vec2f, noise_tex: texture_2d<f32>, noise_samp: sampler, ht: texture_2d<f32>) -> vec4f {\n  let dpr = t.view.z;\n  let p = frag / dpr;\n  let px = 1.0 / dpr;\n  let dim = vec4f(0.0, 0.0, 0.0, t.dim);\n  // beyond the shadows' reach: the dim alone\n  let reach = 3.0 * max(t.shadow.x, t.room.x) + length(t.shadow.zw);\n  if ((p.x < t.rect.x - reach) || (p.x > t.rect.x + t.rect.z + reach) || (p.y < t.rect.y - reach)) { return dim; }\n  // the blue noise is the NIGHT's (the rods' snow, mat.wgsl `night_mat`): by day the board takes none \u2014 its own grain never bands,\n  // and a scrolled board is then the same pixels, moved\n  var bn = vec3f(0.5);\n  if (u.night.x > 0.0) { bn = textureSampleLevel(noise_tex, noise_samp, frag * u.noise.z + u.noise.xy, 0.0).rgb; }\n  // DEEP INSIDE \u2014 clear of the rounded corners, the edge, its inner shadow and two px more: no edge, no shadow, no outline to evaluate\n  // (premultiplied \u2014 a hole's alpha is its shadow over the desk, no longer 1)\n  let m = t.shape.y + t.shape.w + 2.0;\n  if ((p.x > t.rect.x + m) && (p.x < t.rect.x + t.rect.z - m) && (p.y > t.rect.y + t.shape.x + m)) {\n    return tray_board(ht, u, t, p, bn.y, 1.0);\n  }\n  let o = tray_outline(t, p);\n  let cover = clamp(0.5 - o / px, 0.0, 1.0);\n  // the shadows on the desk \u2014 the room's round the outline, the lamp's pushed along its ground direction, one over the other \u2014 where\n  // the drawer does not cover them\n  var under = dim;\n  if (cover < 1.0) {\n    let room = t.room.y * tray_blur(o, t.room.x);\n    let lamp = t.shadow.y * tray_blur(tray_outline(t, p - t.shadow.zw), t.shadow.x);\n    under = vec4f(0.0, 0.0, 0.0, 1.0 - (1.0 - room) * (1.0 - lamp) * (1.0 - t.dim));\n  }\n  if (cover <= 0.0) { return under; }\n  return tray_inside(ht, u, t, p, px, o, bn.y, 1.0) * cover + under * (1.0 - cover);\n}\n\n// THE VEIL (design-018 rev 5 \u2014 James, 2026-09-28: \"at the edge fading, somehow the holes are displayed on top of objects\"): the PLAIN\n// board \u2014 its face with every hole closed, its edge, the edge's inner shadow: `tray_drawer`'s own pixel, less its holes \u2014 laid OVER\n// everything the drawer holds (the accessories, the specimens, their tags), whole in the HEADER (`fade.y` under the edge's inside) and\n// fading out over the ramp below it (`fade.x`): `1 \u2212 smoothstep(foot, foot + fade.x, y)`. What hangs there and the holes behind it fade\n// INTO THE BOARD together \u2014 a specimen never turns see-through, so no hole shows through it (the specimens are opaque to the face\n// clip's top; a hard clip at the header's foot lies under the veil's whole). Only pixels wholly inside the outline: its antialiased rim\n// is `tray_drawer`'s, and the veil there would lay the edge twice.\nfn tray_veil(u: MatUniforms, t: TrayUniforms, frag: vec2f, noise_tex: texture_2d<f32>, noise_samp: sampler, ht: texture_2d<f32>) -> vec4f {\n  let p = frag / t.view.z;\n  let px = 1.0 / t.view.z;\n  let foot = t.rect.y + t.shape.y + t.fade.y;\n  let a = 1.0 - smoothstep(foot, foot + t.fade.x, p.y);\n  if (a <= 0.0) { return vec4f(0.0); }\n  let o = tray_outline(t, p);\n  if (o > -0.5 * px) { return vec4f(0.0); }\n  var bn = vec3f(0.5);\n  if (u.night.x > 0.0) { bn = textureSampleLevel(noise_tex, noise_samp, frag * u.noise.z + u.noise.xy, 0.0).rgb; }\n  return tray_inside(ht, u, t, p, px, o, bn.y, 0.0) * a;\n}\n\n// ---- the accessories (K5a): what the specimens hang on, plugged into real holes \u2014 SK\xC5DIS's hook, shelf, clip and rail seen head-on, in\n// their powder coat under the lamp, each casting its shadow on the board. One instance per specimen (tray-pass.wgsl), its quad the\n// accessory and its shadow's reach; CSS px, the pitch `P` the unit of every length (kernel/tray.ts TRAY_ACCESSORY's numbers).\nfn acc_peg(a: TrayAccessory, i: u32) -> vec2f {\n  if (i == 0u) { return a.pegs0.xy; }\n  if (i == 1u) { return a.pegs0.zw; }\n  if (i == 2u) { return a.pegs1.xy; }\n  return a.pegs1.zw;\n}\n\n// The accessory's silhouette: its signed distance at `p` (negative inside) \u2014 every peg's PLUG in its hole, and the accessory's body.\nfn acc_sdf(a: TrayAccessory, p: vec2f, P: f32) -> f32 {\n  let kind = u32(a.kind.x + 0.5);\n  let n = min(u32(a.kind.y + 0.5), 4u);\n  let r = a.rect;\n  var d = 1.0e4;\n  var lo = 1.0e9;\n  var hi = -1.0e9;\n  for (var i = 0u; i < n; i++) {\n    let g = acc_peg(a, i);\n    lo = min(lo, g.x);\n    hi = max(hi, g.x);\n    d = min(d, sdf_round_box(p - g, vec2f(0.1, 0.28) * P, 0.09 * P));   // the plug, in its hole\n    if (kind == 0u) { d = min(d, sdf_segment(p, g, g + vec2f(0.0, 0.58 * P)) - 0.07 * P); }   // a hook: down to its tip\n    if (kind == 1u) { d = min(d, sdf_segment(p, g, vec2f(g.x, r.w + 0.1 * P)) - 0.06 * P); }   // a shelf's bracket, up to the plank\n    if (kind == 2u) {   // a clip: its spring from the hole down over the specimen's top edge\n      let top = g.y - 0.22 * P;\n      let foot = max(g.y, r.y) + 0.5 * P;\n      d = min(d, sdf_round_box(p - vec2f(g.x, 0.5 * (top + foot)), vec2f(0.24 * P, 0.5 * (foot - top)), 0.08 * P));\n    }\n  }\n  if (kind == 1u) {   // the shelf's plank, under the specimen and past its sides\n    let hw = 0.5 * (r.z - r.x) + 0.3 * P;\n    d = min(d, sdf_round_box(p - vec2f(0.5 * (r.x + r.z), r.w + 0.12 * P), vec2f(hw, 0.12 * P), 0.05 * P));\n  }\n  if (kind == 3u && n > 0u) {   // the rail: a bar through its holes, past the outer two\n    let y = acc_peg(a, 0u).y;\n    d = min(d, sdf_round_box(p - vec2f(0.5 * (lo + hi), y), vec2f(0.5 * (hi - lo) + 0.4 * P, 0.11 * P), 0.11 * P));\n  }\n  return d;\n}\n\n// One pixel of an accessory's quad: its shadow on the board (the silhouette seen from the lamp, pushed off by how far it stands off the\n// board, softened by the lamp's size over that), then the accessory over it \u2014 its rounded relief from the silhouette's gradient, lit as\n// the board's edge is; both kept inside that edge. Premultiplied.\nfn tray_accessory(u: MatUniforms, t: TrayUniforms, a: TrayAccessory, frag: vec2f, noise_tex: texture_2d<f32>, noise_samp: sampler, ht: texture_2d<f32>) -> vec4f {\n  let p = frag / t.view.z;\n  let px = 1.0 / t.view.z;\n  let P = t.view.w;\n  // inside the board's edge \u2014 whole: in the header and its ramp the VEIL lays the plain board over it, as over the specimens (design-018\n  // rev 5, `tray_veil`)\n  let inside = clamp(0.5 - (tray_outline(t, p) + t.shape.y) / px, 0.0, 1.0);\n  if (inside <= 0.0) { return vec4f(0.0); }\n  let L = t.lamp.xyz;\n  let lz = max(L.z, 1.0e-3);\n  let off = L.xy / lz * a.kind.z;\n  let sig = t.lamp.w * a.kind.z / lz + px;\n  let ds = acc_sdf(a, p + off, P);\n  let shadow = t.accessory.w * (1.0 - smoothstep(-sig, sig, ds));\n  let d = acc_sdf(a, p, P);\n  let c = clamp(0.5 - d / px, 0.0, 1.0);\n  if ((c <= 0.0) && (shadow <= 1.0e-4)) { return vec4f(0.0); }\n  var col = vec3f(0.0);\n  if (c > 0.0) {\n    let e = 0.5;\n    let gx = acc_sdf(a, p + vec2f(e, 0.0), P) - acc_sdf(a, p - vec2f(e, 0.0), P);\n    let gy = acc_sdf(a, p + vec2f(0.0, e), P) - acc_sdf(a, p - vec2f(0.0, e), P);\n    let g = vec2f(gx, gy) / max(length(vec2f(gx, gy)), 1.0e-6);\n    let s = clamp(-d / (0.07 * P), 0.0, 1.0);\n    let n = normalize(vec3f(g * (1.0 - s) * 1.2, max(s, 0.2)));\n    var bn = vec3f(0.5);\n    if (u.night.x > 0.0) { bn = textureSampleLevel(noise_tex, noise_samp, frag * u.noise.z + u.noise.xy, 0.0).rgb; }\n    col = tray_lit(u, t, t.accessory.xyz, n, 1.0, bn.y);\n  }\n  let body = c * inside;\n  let under = shadow * inside;\n  return vec4f(col * body, body + under * (1.0 - body));\n}\n"
+};
+
+// ../desk/src/shaders.ts
+function shaderText(files) {
+  const out = {};
+  for (const [key, file] of Object.entries(files)) {
+    const text = WGSL[file];
+    if (text === void 0) throw new Error(`shaders: no generated text for "${file}" \u2014 run gen:shaders`);
+    out[key] = text;
+  }
+  return out;
+}
+
+// ../desk/src/kit/wgsl.ts
+var PIECES = {
+  view: { structs: [MatUniforms] },
+  portal: { file: "portal.wgsl" },
+  sdf: { file: "primitives.wgsl" },
+  light: { file: "mat/mat.wgsl" },
+  ruler: { file: "mat/ruler.wgsl" },
+  book: { structs: [NbUniforms, NbBook], file: "kit/book.wgsl" }
+};
+var ALIASES = { lamp: "light", gobo: "light", night: "light", noise: "light" };
+var KIT_WGSL_FILES = Object.fromEntries(
+  Object.entries(PIECES).flatMap(([name, p]) => "file" in p ? [[name, p.file]] : [])
+);
+function kitWgsl(names, own, text = shaderText) {
+  const want = /* @__PURE__ */ new Set();
+  for (const n of names) {
+    const piece = ALIASES[n] ?? n;
+    if (!(piece in PIECES)) throw new Error(`kitWgsl: no piece "${n}" (the kit's: ${[...Object.keys(PIECES), ...Object.keys(ALIASES)].join(", ")})`);
+    want.add(piece);
+  }
+  const files = {};
+  for (const [name, p] of Object.entries(PIECES)) if (want.has(name) && p.file) files[name] = p.file;
+  const read = text(files);
+  const structs = [];
+  const modules = [];
+  for (const [name, p] of Object.entries(PIECES)) {
+    if (!want.has(name)) continue;
+    if (p.structs) structs.push(...p.structs);
+    if (p.file) modules.push({ label: p.file, text: read[name] });
+  }
+  return { structs: [...structs, ...own.structs ?? []], modules: [...modules, ...own.modules ?? []], entry: own.entry };
+}
+
+// ../desk/src/kit/layer.ts
+var LAYER_COMPOSITE_FILE = "kit/composite.wgsl";
+function layerComposite(text) {
+  return kitWgsl(["view", "portal"], { entry: { label: LAYER_COMPOSITE_FILE, text: text({ composite: LAYER_COMPOSITE_FILE }).composite } }, text);
+}
+function layerCompositeLayout(device, label) {
+  return bindLayout(device, [{ binding: 0, stages: ["fragment"], texture: "float" }, { binding: 1, stages: ["fragment"], buffer: "uniform" }, { binding: 2, stages: ["fragment"], buffer: "uniform" }], label);
+}
+var attachmentOf = (v) => ({
+  w: Math.max(1, Math.round(v.width * v.dpr)),
+  h: Math.max(1, Math.round(v.height * v.dpr))
+});
+function clip(a, b) {
+  const x0 = Math.max(a[0], b[0]);
+  const y0 = Math.max(a[1], b[1]);
+  const x1 = Math.min(a[0] + a[2], b[0] + b[2]);
+  const y1 = Math.min(a[1] + a[3], b[1] + b[3]);
+  return [x0, y0, Math.max(0, x1 - x0), Math.max(0, y1 - y0)];
+}
+var LayeredKind = class {
+  /** The root slot's pass — the host's door to its own API (the ink, the tiles, the law); null in a spawned slot (root only). */
+  pass;
+  /** The slot's scissor this frame, device px — the layer is laid inside it and it is given back after (null: nothing to lay). */
+  within = null;
+  /** How many records `prepare` was handed: the whole range the layer lays. */
+  handed = 0;
+  constructor(pass) {
+    this.pass = pass;
+  }
+  prepare(encoder, s, records) {
+    this.within = null;
+    this.handed = records.length;
+    const p = this.pass;
+    if (!p) return 0;
+    p.use?.(s.target ?? "frame");
+    const n = this.prepareOwn(p, s, records);
+    if (n === 0) return 0;
+    const size = attachmentOf(s.view);
+    if (p.layer(encoder, size, s.view.dpr)) this.within = scissorOf(s.present, s.view.dpr, size);
+    return n;
+  }
+  /** The layer over the frame: once, for the whole range [0, count) — one draw lays every object; a part of it cannot be drawn from one layer. */
+  drawRange(pass, first, end) {
+    const p = this.pass;
+    const within = this.within;
+    if (!p || !within || first !== 0 || end < this.handed || end === 0) return;
+    const box = p.screenBox;
+    if (!box) return;
+    const r = clip(box, within);
+    if (r[2] <= 0 || r[3] <= 0) return;
+    p.composite(pass, r);
+    pass.setScissorRect(within[0], within[1], within[2], within[3]);
+  }
+  endHold() {
+    this.pass?.endHold?.();
+  }
+  /**
+   * Let this slot's layer go when none of its objects was drawn within `ms` (D-K6a.3 for a slot the host keeps beyond the root — the
+   * tray's specimen, K5a; the ROOT's layer goes by its kind's own tick). Made again at the next object drawn.
+   */
+  idle(ms) {
+    const p = this.pass;
+    if (p !== null && p.layerMade === true && p.drawnWithin?.(ms) === false) p.releaseLayer?.();
+  }
+  /** When `idle(ms)` next lets the layer go — its last object drawn + `ms` (K7a: the host's registered TIME wake); ∞ with none. */
+  idleAt(ms) {
+    const p = this.pass;
+    return p !== null && p.layerMade === true && p.lastDrawn !== void 0 ? p.lastDrawn + ms : Number.POSITIVE_INFINITY;
+  }
+  dropped() {
+    return this.pass?.dropped ?? 0;
+  }
+  dispose() {
+    this.pass?.dispose();
+  }
+};
+var BOX_STEP = 256;
+var SIGNATURE = 8;
+var BoxTargets = class {
+  /** `view`: the slot's view block (`MatPass.view`) — the composite lays the layer through its portal chain (`layerCompositeLayout`). */
+  constructor(device, label, layoutComp, samples, view) {
+    this.device = device;
+    this.label = label;
+    this.layoutComp = layoutComp;
+    this.samples = samples;
+    this.view = view;
+  }
+  device;
+  label;
+  layoutComp;
+  samples;
+  view;
+  msaa = null;
+  depth = null;
+  resolve = null;
+  compGroup = null;
+  /** The box's top-left on the attachment, device px (the layer's texel 0, 0). */
+  origin = [0, 0];
+  /** The targets' size as made, device px (0 × 0: none). */
+  size = { w: 0, h: 0 };
+  originBuf = null;
+  sent = new Float32Array(4).fill(Number.NaN);
+  next = new Float32Array(4);
+  /** What the layer the targets hold was drawn from — its pass's signature at the draw (K7a); NaN: nothing drawn since made. */
+  drawnFrom = new Float64Array(SIGNATURE).fill(Number.NaN);
+  /** …and the content it read, by value (the knobs, the records, the view block), with each copy's length. */
+  drawnBytes = [];
+  drawnLen = [];
+  /** The targets are made (a layer holds device memory). */
+  get made() {
+    return this.msaa !== null;
+  }
+  /**
+   * Fit the targets to `box` [x0, y0, x1, y1] (device px) on an `attach` of its size: made when none are or the box outgrew them,
+   * made smaller when they are more than four times its area — never larger than the attachment; the origin written for the
+   * composite when it moved.
+   */
+  fit(box, attach) {
+    const [x0, y0, x1, y1] = box;
+    const w = Math.min(Math.ceil(Math.max(1, x1 - x0) / BOX_STEP) * BOX_STEP, Math.max(1, attach.w));
+    const h = Math.min(Math.ceil(Math.max(1, y1 - y0) / BOX_STEP) * BOX_STEP, Math.max(1, attach.h));
+    const outgrown = this.size.w < x1 - x0 || this.size.h < y1 - y0;
+    const loose = this.size.w * this.size.h > 4 * w * h;
+    if (this.msaa === null || outgrown || loose) {
+      this.release();
+      const d = this.device;
+      this.msaa = d.createTexture({ label: `${this.label}/layer \xD74`, size: [w, h], format: "rgba8unorm", sampleCount: this.samples, usage: GPUTextureUsage.RENDER_ATTACHMENT });
+      this.depth = d.createTexture({ label: `${this.label}/depth \xD74`, size: [w, h], format: "depth24plus", sampleCount: this.samples, usage: GPUTextureUsage.RENDER_ATTACHMENT });
+      this.resolve = d.createTexture({ label: `${this.label}/layer`, size: [w, h], format: "rgba8unorm", usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING });
+      this.originBuf ??= d.createBuffer({ label: `${this.label}/layer origin`, size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.compGroup = d.createBindGroup({ label: `${this.label}/composite`, layout: this.layoutComp, entries: [{ binding: 0, resource: this.resolve.createView() }, { binding: 1, resource: { buffer: this.originBuf } }, { binding: 2, resource: { buffer: this.view } }] });
+      this.size.w = w;
+      this.size.h = h;
+      this.sent.fill(Number.NaN);
+      this.drawnFrom.fill(Number.NaN);
+    }
+    this.origin[0] = x0;
+    this.origin[1] = y0;
+    const n = this.next;
+    n[0] = x0;
+    n[1] = y0;
+    n[2] = 0;
+    n[3] = 0;
+    if (n[0] !== this.sent[0] || n[1] !== this.sent[1]) {
+      this.device.queue.writeBuffer(this.originBuf, 0, n);
+      this.sent.set(n);
+    }
+  }
+  /**
+   * Begin the layer's pass into the fitted targets: cleared, the viewport the whole `attach` shifted by the origin, the scissor the
+   * box — `box` [x0, y0, x1, y1] as fitted.
+   */
+  begin(encoder, label, attach, box) {
+    const pass = encoder.beginRenderPass({
+      label,
+      colorAttachments: [{ view: this.msaa.createView(), resolveTarget: this.resolve.createView(), clearValue: { r: 0, g: 0, b: 0, a: 0 }, loadOp: "clear", storeOp: "discard" }],
+      depthStencilAttachment: { view: this.depth.createView(), depthClearValue: 1, depthLoadOp: "clear", depthStoreOp: "discard" }
+    });
+    pass.setViewport(-box[0], -box[1], attach.w, attach.h, 0, 1);
+    pass.setScissorRect(0, 0, box[2] - box[0], box[3] - box[1]);
+    return pass;
+  }
+  /**
+   * The layer the targets hold was drawn from exactly `sig` and `bytes` (K7a — every input of its draw the same since: the pass's
+   * numbers — its resources' generation, what it lists, the box — and the CONTENT the draw read, compared by value: this target's
+   * knobs and records as prepared, the slot's view block. By content, not by version: a held frame's desk copy writes the shared
+   * buffers between two of the hand's frames, and the hand's layer is still what they held): it may be laid again undrawn.
+   */
+  holds(sig, bytes) {
+    if (this.msaa === null) return false;
+    for (let i = 0; i < SIGNATURE; i++) if (this.drawnFrom[i] !== (i < sig.length ? sig[i] : 0)) return false;
+    if (bytes.length !== this.drawnBytes.length) return false;
+    for (let i = 0; i < bytes.length; i++) {
+      const a = bytes[i];
+      const b = this.drawnBytes[i];
+      if (this.drawnLen[i] !== a.byteLength) return false;
+      for (let k = 0; k < a.byteLength; k++) if (a[k] !== b[k]) return false;
+    }
+    return true;
+  }
+  /** The layer was drawn from `sig` and `bytes` (copied; the copies grow once and are reused). */
+  drew(sig, bytes) {
+    for (let i = 0; i < SIGNATURE; i++) this.drawnFrom[i] = i < sig.length ? sig[i] : 0;
+    this.drawnBytes.length = bytes.length;
+    this.drawnLen.length = bytes.length;
+    for (let i = 0; i < bytes.length; i++) {
+      const a = bytes[i];
+      let b = this.drawnBytes[i];
+      if (b === void 0 || b.byteLength < a.byteLength) {
+        b = new Uint8Array(Math.max(a.byteLength, 64));
+        this.drawnBytes[i] = b;
+      }
+      b.set(a);
+      this.drawnLen[i] = a.byteLength;
+    }
+  }
+  /** The targets let go, the origin's uniform with them (the next `fit` makes them again). */
+  release() {
+    this.drawnFrom.fill(Number.NaN);
+    this.msaa?.destroy();
+    this.depth?.destroy();
+    this.resolve?.destroy();
+    this.originBuf?.destroy();
+    this.msaa = null;
+    this.depth = null;
+    this.resolve = null;
+    this.compGroup = null;
+    this.originBuf = null;
+    this.size.w = 0;
+    this.size.h = 0;
+  }
+  dispose() {
+    this.release();
+  }
+};
+var LAYER_IDLE_MS = 5e3;
+
+// ../desk/src/kit/springs.ts
+function spring(x0, v0, target, hz, damping, dt, substeps = 8) {
+  let x = x0;
+  let v = v0;
+  const w = 2 * Math.PI * hz;
+  const h = Math.min(dt, 0.05) / substeps;
+  for (let i = 0; i < substeps; i++) {
+    v += (w * w * (target - x) - 2 * damping * w * v) * h;
+    x += v * h;
+  }
+  return [x, v];
+}
+function settled(x, v, target, eps = 1e-3) {
+  return Math.abs(x - target) < eps && Math.abs(v) < eps * 10;
+}
+var SPRINGS = { liftHz: 4.5, liftDamp: 0.78 };
+
+// ../desk/src/nav/flight.ts
+function visibleRect(cam, vpW, vpH) {
+  return { x: cam.x, y: cam.y, width: vpW / cam.zoom, height: vpH / cam.zoom };
+}
+function portalAffine(arrival, portal) {
+  const s = Math.min(portal.width / arrival.width, portal.height / arrival.height);
+  return {
+    s,
+    ox: portal.x + portal.width / 2 - (arrival.x + arrival.width / 2) * s,
+    oy: portal.y + portal.height / 2 - (arrival.y + arrival.height / 2) * s
+  };
+}
+function solveFlightStart(A, camPre) {
+  return { x: A.ox + camPre.x * A.s, y: A.oy + camPre.y * A.s, zoom: camPre.zoom / A.s };
+}
+function outgoingCamera(A, destination) {
+  return { x: (destination.x - A.ox) / A.s, y: (destination.y - A.oy) / A.s, zoom: A.s * destination.zoom };
+}
+function flightCamera(c0, c1, p, vpW, vpH) {
+  const zoom = Math.exp(Math.log(c0.zoom) + (Math.log(c1.zoom) - Math.log(c0.zoom)) * p);
+  const inv0 = 1 / c0.zoom;
+  const inv1 = 1 / c1.zoom;
+  const inv = 1 / zoom;
+  const w = Math.abs(inv1 - inv0) < 1e-12 ? p : (inv - inv0) / (inv1 - inv0);
+  const cx = c0.x + vpW * inv0 * 0.5 + (c1.x + vpW * inv1 * 0.5 - (c0.x + vpW * inv0 * 0.5)) * w;
+  const cy = c0.y + vpH * inv0 * 0.5 + (c1.y + vpH * inv1 * 0.5 - (c0.y + vpH * inv0 * 0.5)) * w;
+  return { x: cx - vpW * inv * 0.5, y: cy - vpH * inv * 0.5, zoom };
+}
+function fitCamera(content, vpW, vpH, opts) {
+  const fit = Math.min(vpW / (content.width + opts.pad * 2), vpH / (content.height + opts.pad * 2));
+  const zoom = Math.min(opts.maxZoom, Math.max(opts.minZoom, fit));
+  return { x: content.x + content.width / 2 - vpW / (2 * zoom), y: content.y + content.height / 2 - vpH / (2 * zoom), zoom };
+}
+var FIT = { pad: 80, minZoom: 0.5, maxZoom: 1 };
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+var smooth = (v) => {
+  const x = clamp01(v);
+  return x * x * (3 - 2 * x);
+};
+var ramp = (v, from, to) => to <= from ? v >= to ? 1 : 0 : smooth((v - from) / (to - from));
+function flightOpacity(kind, p, frozen) {
+  if (frozen) return { outgoing: 1 - ramp(p, 0.05, 0.45), incoming: ramp(p, 0.3, 0.7) };
+  return { outgoing: kind === "enter" ? 1 - ramp(p, 0.3, 0.75) : 1 - ramp(p, 0.85, 1), incoming: 1 };
+}
+function boundsOf(rects) {
+  if (rects.length === 0) return null;
+  let x0 = Number.POSITIVE_INFINITY;
+  let y0 = Number.POSITIVE_INFINITY;
+  let x1 = Number.NEGATIVE_INFINITY;
+  let y1 = Number.NEGATIVE_INFINITY;
+  for (const r of rects) {
+    x0 = Math.min(x0, r.x);
+    y0 = Math.min(y0, r.y);
+    x1 = Math.max(x1, r.x + r.width);
+    y1 = Math.max(y1, r.y + r.height);
+  }
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function arrivalCamera(content, vp, fit = FIT) {
+  if (content === null) return { x: -vp.width / 2, y: -vp.height / 2, zoom: 1 };
+  return fitCamera(content, vp.width, vp.height, fit);
+}
+
+// ../desk/src/marks/ease.ts
+var clamp012 = (x) => Math.min(Math.max(x, 0), 1);
+function bezier(x1, y1, x2, y2, x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  let t = x;
+  for (let i = 0; i < 8; i++) {
+    const cx = 3 * x1 * t * (1 - t) ** 2 + 3 * x2 * t * t * (1 - t) + t ** 3 - x;
+    const dx = 3 * x1 * (1 - t) ** 2 + 6 * (x2 - x1) * t * (1 - t) + 3 * (1 - x2) * t * t;
+    if (Math.abs(dx) < 1e-6) break;
+    t = clamp012(t - cx / dx);
+  }
+  return 3 * y1 * t * (1 - t) ** 2 + 3 * y2 * t * t * (1 - t) + t ** 3;
+}
+var easeLift = (x) => bezier(0.2, 0.9, 0.3, 1.2, x);
+var easeIsland = (x) => bezier(0.25, 1, 0.3, 1, x);
+
+// ../desk/src/hold/pose.ts
+var HOLD = {
+  inMs: 560,
+  outMs: 440,
+  closeLead: 0.14,
+  openAt: 0.42,
+  blur: 14,
+  blurPhone: 10,
+  dim: 0.08,
+  margin: 56,
+  marginPhone: 16,
+  top: 56,
+  topPhone: 60,
+  band: 72,
+  max: 3,
+  zoomMin: 0.72,
+  zoomMax: 3,
+  narrow: 640,
+  /** The reading light by night (Q-n): the held object keeps its day light, filtered. */
+  light: { saturate: 0.62, brightness: 0.82 },
+  /** The cover's spring in hand (desk.js `COVER`): a palm, not a desk. */
+  cover: { hz: 1.4, zeta: 0.78 },
+  /** The held bar's travel (M1 morph) and its return after the landing. */
+  bar: { travelMs: 340, backMs: 200 }
+};
+var isNarrow = (vp) => vp.width < HOLD.narrow;
+function readingTarget(extent, vp, spread = false, face = 0) {
+  const narrow = isNarrow(vp);
+  const m = narrow ? HOLD.marginPhone : HOLD.margin;
+  const top = narrow ? HOLD.topPhone : HOLD.top;
+  const boxW = Math.max(40, vp.width - 2 * m);
+  const boxH = Math.max(40, vp.height - top - HOLD.band);
+  let s = Math.min(boxW / extent.w, boxH / extent.h, HOLD.max);
+  let single = false;
+  if (spread && narrow && vp.width < vp.height * 0.85) {
+    const s1 = Math.min(boxW / (extent.w / 2), boxH / extent.h, HOLD.max);
+    if (s1 > s * 1.3) {
+      s = s1;
+      single = true;
+    }
+  }
+  return { cx: vp.width / 2 - (single ? extent.w / 4 * s * (1 - 2 * face) : 0), cy: top + boxH / 2, s, single };
+}
+function homePose(extent, angle, cam) {
+  return { cx: (extent.cx - cam.x) * cam.zoom, cy: (extent.cy - cam.y) * cam.zoom, s: cam.zoom, angle };
+}
+var HELD_USER_REST = { zoom: 1, panX: 0, panY: 0 };
+function heldPose(home, target, user, e) {
+  const s1 = target.s * user.zoom;
+  const s = Math.exp(Math.log(Math.max(home.s, 1e-9)) + (Math.log(Math.max(s1, 1e-9)) - Math.log(Math.max(home.s, 1e-9))) * e);
+  return { cx: home.cx + (target.cx + user.panX - home.cx) * e, cy: home.cy + (target.cy + user.panY - home.cy) * e, s, angle: home.angle * (1 - e), e };
+}
+var carryOf = (p) => easeIsland(Math.min(Math.max(p, 0), 1));
+function progressOf(e) {
+  if (e <= 0) return 0;
+  if (e >= 1) return 1;
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (carryOf(mid) < e) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function heldFocus(e, vp, theme) {
+  const night = theme.name === "dark";
+  return {
+    blur: isNarrow(vp) ? HOLD.blurPhone : HOLD.blur,
+    dim: HOLD.dim * e,
+    filter: night ? { saturate: 1 - (1 - HOLD.light.saturate) * e, brightness: 1 - (1 - HOLD.light.brightness) * e } : { saturate: 1, brightness: 1 },
+    light: night ? mixLight(theme.matLight, DAY_LIGHT, e) : theme.matLight
+  };
+}
+function heldCamera(pose, rect, extent, deskZoom, eye, vp) {
+  const zoom = eye ? Math.min(deskZoom, pose.s) : pose.s;
+  const grow = pose.s / zoom;
+  const ox = rect.cx - extent.cx;
+  const oy = rect.cy - extent.cy;
+  const c = Math.cos(pose.angle);
+  const sn = Math.sin(pose.angle);
+  const sx = pose.cx + (c * ox - sn * oy) * pose.s;
+  const sy = pose.cy + (sn * ox + c * oy) * pose.s;
+  if (!eye || grow <= 1 + 1e-9) return { cam: { x: rect.cx - sx / zoom, y: rect.cy - sy / zoom, zoom }, grow: 1 };
+  const ex = rect.cx - (sx - vp.width / 2) / (grow * zoom);
+  const ey = rect.cy - (sy - vp.height / 2) / (grow * zoom);
+  return { cam: { x: ex - vp.width / (2 * zoom), y: ey - vp.height / (2 * zoom), zoom }, grow };
+}
+function heldFrame(pose, extent, single, face = 0) {
+  if (!single) return { cx: pose.cx, cy: pose.cy, hx: extent.w / 2 * pose.s, hy: extent.h / 2 * pose.s, s: pose.s };
+  const half = extent.w / 4 * pose.s;
+  const q = half * (1 - 2 * face);
+  return { cx: pose.cx + q * Math.cos(pose.angle), cy: pose.cy + q * Math.sin(pose.angle), hx: half, hy: extent.h / 2 * pose.s, s: pose.s };
+}
+var focusOf = (e, vp) => ({ blur: (isNarrow(vp) ? HOLD.blurPhone : HOLD.blur) * e, dim: HOLD.dim * e });
+
+// ../desk/src/kit/inside.ts
+var PAPER_FINISH = "paper";
+var VINYL_FINISH = "vinyl";
+function finishOf(finish, drawn) {
+  if (typeof finish === "string") return drawn.includes(finish) ? finish : void 0;
+  return finish.find((f) => drawn.includes(f));
+}
+function insideViewOfFace(K, radius, content, cam, vp, fit = FIT, gate = PORTAL_GATE) {
+  if (!(K.width > 0) || !(K.height > 0)) return null;
+  const clip2 = clipOf(K, radius, cam);
+  const arrival = arrivalCamera(content, vp, fit);
+  const M = portalAffine(visibleRect(arrival, vp.width, vp.height), K);
+  return { M, arrival, cam: outgoingCamera(M, cam), clip: clip2, presence: portalPresence(clip2, gate), box: boxOfPortal(clip2, vp) };
+}
+var insidePresent = (view) => ({ opacity: 1, objects: view.presence, portal: view.clip });
+function flightPresent(f, clip2, gate = PORTAL_GATE) {
+  const op = flightOpacity(f.kind, f.p, f.frozen);
+  if (f.frozen || !clip2) return { incoming: { opacity: op.incoming }, outgoing: { opacity: op.outgoing } };
+  if (f.kind === "enter") return { incoming: { opacity: op.incoming, objects: portalPresence(clip2, gate), portal: clip2 }, outgoing: { opacity: op.outgoing } };
+  return { incoming: { opacity: op.incoming }, outgoing: { opacity: op.outgoing, portal: clip2 } };
+}
+var HANDOVER = { enter: [0.3, 1], exit: [0, 0.5] };
+var ease = (p, [a, b]) => {
+  const x = (p - a) / (b - a);
+  return x <= 0 ? 0 : x >= 1 ? 1 : x * x * (3 - 2 * x);
+};
+function flightLights(f, cam, outCam) {
+  if (f.frozen) return {};
+  return f.kind === "enter" ? { incoming: { a: outCam, b: cam, t: ease(f.p, HANDOVER.enter) } } : { outgoing: { a: outCam, b: cam, t: ease(f.p, HANDOVER.exit) } };
+}
+
+// ../desk/src/mat/lamp.ts
+function lampOf(plane, p = HERO_PROJECTOR) {
+  const m = plane.metresPerUnit;
+  return { x: (p.position[0] - plane.originX) / m, y: (p.position[2] - plane.originZ) / m, h: (p.position[1] - plane.deskY) / m };
+}
+
+// ../desk/src/kit/services.ts
+var serviceKey = (name) => ({ name });
+var service = (key, value) => ({ key, value });
+function createServices(entries = [], by = "the host") {
+  const lent = /* @__PURE__ */ new Map();
+  const registry = {
+    use: (key) => lent.get(key.name)?.value,
+    lend(more, lender) {
+      for (const { key, value } of more) {
+        const had = lent.get(key.name);
+        if (had !== void 0) throw new Error(`desk: the service "${key.name}" is lent twice \u2014 by ${had.by} and by ${lender} (a name is lent once per desk)`);
+        if (value !== void 0) lent.set(key.name, { value, by: lender });
+      }
+    },
+    names: () => [...lent.keys()]
+  };
+  registry.lend(entries, by);
+  return registry;
+}
+
+// ../desk/src/kit/blobs.ts
+var BLOB_STORE = serviceKey("blobs");
+var PICTURE_DECODER = serviceKey("decode");
+var RGBA_TYPE = "image/x-ice-rgba";
+async function hashBytes(bytes) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function createMemoryBlobStore() {
+  const blobs = /* @__PURE__ */ new Map();
+  return {
+    async put(bytes, type) {
+      const hash2 = await hashBytes(bytes);
+      if (!blobs.has(hash2)) blobs.set(hash2, { bytes: bytes.slice(), type });
+      return hash2;
+    },
+    async get(hash2) {
+      return blobs.get(hash2);
+    },
+    size: () => blobs.size
+  };
+}
+
+// ../desk/src/kit/raster.ts
+var TEXT_RASTER = serviceKey("text");
+
+// ../desk/src/kit/text.ts
+function hashHand(seed, code) {
+  let h = (Math.imul(seed | 0, 2654435761) ^ Math.imul(code | 0, 2246822519)) >>> 0;
+  const out = [];
+  for (let i = 0; i < 4; i++) {
+    h = (h ^ h >>> 16) >>> 0;
+    h = Math.imul(h, 2146121005) >>> 0;
+    h = (h ^ h >>> 15) >>> 0;
+    h = Math.imul(h, 2221713035) >>> 0;
+    h = (h ^ h >>> 16) >>> 0;
+    out.push(h / 4294967296);
+    h = h + 1831565813 >>> 0;
+  }
+  return out;
+}
+var glyphSeed = (noteSeed, index) => Math.imul(noteSeed | 0, 668265263) + Math.imul(index + 1, 374761393) | 0;
+function layoutText(text, box, law, metrics, noteSeed = 1, seeds) {
+  const em = law.size;
+  const lineH = law.lineHeight * em;
+  const x0 = law.pad;
+  const xMax = Math.max(box.w - law.pad, x0 + 1);
+  const yMax = box.h - law.pad;
+  const glyphs = [];
+  const lines = [];
+  const positions = new Float32Array(2 * (text.length + 1));
+  const phase = hashHand(noteSeed, 7)[0] * Math.PI * 2;
+  let x = x0;
+  let y = law.pad + metrics.ascent * em;
+  let line = 0;
+  let lineStart = 0;
+  let prev = "";
+  let overflow = false;
+  const adv = (ch) => metrics.advance(ch) * em;
+  const newline = (i) => {
+    lines.push({ start: lineStart, end: i, y, width: x - x0 });
+    lineStart = i;
+    line += 1;
+    x = x0;
+    y += lineH;
+    prev = "";
+  };
+  const wordWidth = (i) => {
+    let w = 0;
+    let p = "";
+    for (let j = i; j < text.length; j++) {
+      const c = text[j];
+      if (c === " " || c === "\n") break;
+      if (p && metrics.kern) w += metrics.kern(p, c) * em;
+      w += adv(c);
+      p = c;
+    }
+    return w;
+  };
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "\n") {
+      positions[2 * i] = x;
+      positions[2 * i + 1] = y;
+      newline(i + 1);
+      continue;
+    }
+    const wordStart = i === 0 || text[i - 1] === " " || text[i - 1] === "\n";
+    if (ch !== " " && wordStart && x > x0 && x + wordWidth(i) > xMax) newline(i);
+    if (ch !== " " && !wordStart && prev && metrics.kern) x += metrics.kern(prev, ch) * em;
+    if (ch !== " " && x > x0 && x + adv(ch) > xMax) newline(i);
+    positions[2 * i] = x;
+    positions[2 * i + 1] = y;
+    if (ch === " ") {
+      x += adv(ch);
+      prev = ch;
+      continue;
+    }
+    const seed = seeds && i < seeds.length ? seeds[i] : glyphSeed(noteSeed, i);
+    const [r0, r1, r2, r3] = hashHand(seed, ch.codePointAt(0) ?? 0);
+    const scale = 1 + (r2 - 0.5) * 2 * law.jitter.scale;
+    const a = adv(ch) * scale;
+    const wander = law.wander.amp * em * Math.sin(2 * Math.PI * (x - x0) / Math.max(law.wander.period * em, 1e-6) + phase);
+    glyphs.push({
+      ch,
+      index: i,
+      x,
+      y: y + wander + (r1 - 0.5) * 2 * law.jitter.rise * em,
+      advance: a,
+      rot: (r0 - 0.5) * 2 * law.jitter.rot,
+      scale,
+      press: law.jitter.press[0] + (law.jitter.press[1] - law.jitter.press[0]) * r3,
+      line
+    });
+    if (y + metrics.descent * em > yMax) overflow = true;
+    x += a;
+    prev = ch;
+  }
+  positions[2 * text.length] = x;
+  positions[2 * text.length + 1] = y;
+  lines.push({ start: lineStart, end: text.length, y, width: x - x0 });
+  if (y + metrics.descent * em > yMax && text.length > 0) overflow = true;
+  return { glyphs, lines, positions, overflow, em, ascent: metrics.ascent * em, descent: metrics.descent * em };
+}
+function caretAt(L, index) {
+  const i = Math.min(Math.max(index, 0), L.positions.length / 2 - 1);
+  return { x: L.positions[2 * i], y: L.positions[2 * i + 1], above: L.ascent, below: L.descent };
+}
+function glyphBox(L, g) {
+  const grow = L.em * 0.12;
+  return { x0: g.x - grow, y0: g.y - L.ascent * g.scale - grow, x1: g.x + g.advance + grow, y1: g.y + L.descent * g.scale + grow };
+}
+function carrySeeds(oldText, oldSeeds, newText, fresh) {
+  let pre = 0;
+  const maxPre = Math.min(oldText.length, newText.length);
+  while (pre < maxPre && oldText[pre] === newText[pre]) pre += 1;
+  let suf = 0;
+  const maxSuf = Math.min(oldText.length, newText.length) - pre;
+  while (suf < maxSuf && oldText[oldText.length - 1 - suf] === newText[newText.length - 1 - suf]) suf += 1;
+  const seeds = [];
+  for (let i = 0; i < pre; i++) seeds.push(i < oldSeeds.length ? oldSeeds[i] : fresh());
+  const inserted = newText.length - pre - suf;
+  for (let i = 0; i < inserted; i++) seeds.push(fresh());
+  for (let i = 0; i < suf; i++) {
+    const j = oldText.length - suf + i;
+    seeds.push(j < oldSeeds.length ? oldSeeds[j] : fresh());
+  }
+  return { seeds, from: pre, to: pre + inserted };
+}
+var HAND = {
+  size: 24,
+  lineHeight: 1.16,
+  pad: 16,
+  jitter: { rot: 0.028, rise: 0.03, scale: 0.05, press: [0.8, 0.97] },
+  wander: { amp: 0.022, period: 9 },
+  wipeMs: 110
+};
+var PENS = ["felt", "ball", "fountain", "red"];
+var PEN_FACES = {
+  caveat: { family: "Caveat", weight: 500 },
+  "caveat-bold": { family: "Caveat", weight: 600 },
+  kalam: { family: "Kalam", weight: 400 },
+  marker: { family: "Marker Felt", weight: 400 },
+  noteworthy: { family: "Noteworthy", weight: 400 }
+};
+
+// ../desk/src/kit/arrays.ts
+function tailBase(w, h, side) {
+  let k = 0;
+  while (Math.max(w >> k, 1) > side || Math.max(h >> k, 1) > side) k += 1;
+  return k;
+}
+function chainBytes(w, h, levels, texel = 4) {
+  let b = 0;
+  for (let l = 0; l < levels; l++) b += Math.max(w >> l, 1) * Math.max(h >> l, 1) * texel;
+  return b;
+}
+var Layers = class {
+  constructor(first = 4, max = 256) {
+    this.first = first;
+    this.max = max;
+  }
+  first;
+  max;
+  free = [];
+  next = 0;
+  capacity = 0;
+  take() {
+    if (this.free.length > 0) {
+      this.free.sort((a, b) => a - b);
+      return { layer: this.free.shift(), capacity: this.capacity };
+    }
+    if (this.next >= this.max) return null;
+    const layer = this.next++;
+    if (layer >= this.capacity) this.capacity = Math.min(Math.max(this.first, this.capacity * 2), this.max);
+    return { layer, capacity: this.capacity };
+  }
+  give(layer) {
+    if (layer >= 0 && layer < this.next && !this.free.includes(layer)) this.free.push(layer);
+  }
+  get used() {
+    return this.next - this.free.length;
+  }
+  /** The highest layer in use (−1 when none): what a smaller array must still hold. */
+  get highest() {
+    let h = this.next - 1;
+    while (h >= 0 && this.free.includes(h)) h -= 1;
+    return h;
+  }
+  /**
+   * The capacity an array holding these layers may shrink to (K9 R2): halved while fewer than a QUARTER of it is in use and the
+   * highest layer in use fits the half — down to `first`; 0 when none is in use; the current capacity when it cannot shrink.
+   */
+  shrunk() {
+    if (this.used === 0) return 0;
+    let c = this.capacity;
+    while (c > this.first && this.used * 4 < c && this.highest < c / 2) c /= 2;
+    return c;
+  }
+  /** The allocator's word after the array was remade at `capacity` (from `shrunk()`): the layers past it are forgotten. */
+  shrinkTo(capacity) {
+    if (capacity === 0) {
+      this.free = [];
+      this.next = 0;
+      this.capacity = 0;
+      return;
+    }
+    this.next = Math.min(this.next, capacity);
+    this.free = this.free.filter((l) => l < this.next);
+    this.capacity = capacity;
+  }
+};
+var FILL = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var src: texture_2d<f32>;
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+  let p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0))[i];
+  return vec4f(p, 0.0, 1.0);
+}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  let last = vec2i(textureDimensions(src)) - vec2i(1);
+  return textureLoad(src, min(vec2i(pos.xy), last), 0);
+}
+`
+);
+var plainFormat = (f) => f.endsWith("-srgb") ? f.slice(0, -5) : f;
+var LayerArray = class {
+  side;
+  mips;
+  format;
+  device;
+  label;
+  layers;
+  tex = null;
+  /** The texture's layers (kept here: a fake device's texture has no count of its own). */
+  cap = 0;
+  /** Bumped whenever the texture is remade (a bind group holding its view must be made again). */
+  version = 0;
+  /** The fill's pipeline, made on the first fill — labelled with the array's own name, so the profiler counts its passes as the kind's. */
+  fillPipe = null;
+  constructor(device, opts) {
+    this.device = device;
+    this.label = opts.label;
+    this.format = opts.format;
+    this.side = opts.side;
+    this.mips = Math.floor(Math.log2(opts.side)) + 1;
+    const max = device.limits?.maxTextureArrayLayers ?? 256;
+    this.layers = new Layers(opts.first ?? 4, max);
+  }
+  /** The array (null before its first layer). */
+  get texture() {
+    return this.tex;
+  }
+  /** Layers in use; the array's capacity. */
+  get used() {
+    return this.layers.used;
+  }
+  get capacity() {
+    return this.tex === null ? 0 : this.layers.capacity;
+  }
+  /** What the array weighs on the device, every layer of its capacity with its chain (the GPU ledger's row). */
+  get bytes() {
+    return this.capacity * chainBytes(this.side, this.side, this.mips);
+  }
+  /** What the layers IN USE weigh (K9 R2: the budget's resident charge — the capacity's slack is the ledger's to show, bounded by `give`'s shrink). */
+  get usedBytes() {
+    return this.used * chainBytes(this.side, this.side, this.mips);
+  }
+  /** A layer for a new object (the array grown — its old layers copied — when it must be); null when the device holds no more. */
+  take() {
+    const t = this.layers.take();
+    if (t === null) return null;
+    if (this.tex === null || t.capacity > this.cap) this.remake(t.capacity);
+    return t.layer;
+  }
+  /**
+   * A layer given back — and the array SHRUNK when fewer than a quarter of its layers are in use and the ones in use fit the
+   * half (K9 R2: an array never shrank before, so its charge survived a document switch): remade at half, its low layers copied;
+   * let go entirely when none is in use. The version moves as on a growth — a holder rebinds its view.
+   */
+  give(layer) {
+    this.layers.give(layer);
+    if (this.tex === null) return;
+    const to = this.layers.shrunk();
+    if (to >= this.cap) return;
+    if (to === 0) {
+      this.tex.destroy();
+      this.tex = null;
+      this.cap = 0;
+      this.layers.shrinkTo(0);
+      this.version += 1;
+      return;
+    }
+    this.layers.shrinkTo(to);
+    this.remake(to);
+  }
+  /**
+   * Layer `layer`'s every level from `src`'s chain: level `base + m` at the origin, its edge carried to the layer's; a level past
+   * the chain's end takes its last. `src` must allow the plain view of its format (`viewFormats`) when that format is `-srgb`.
+   */
+  fill(src, srcMips, layer, base, encoder) {
+    const tex = this.tex;
+    if (tex === null) return;
+    const plain = plainFormat(this.format);
+    const pipe = this.pipeline(plain);
+    const enc = encoder ?? this.device.createCommandEncoder({ label: `${this.label} fill` });
+    for (let m = 0; m < this.mips; m++) {
+      const from = src.createView({ format: plainFormat(src.format ?? this.format), dimension: "2d", baseMipLevel: Math.min(base + m, srcMips - 1), mipLevelCount: 1 });
+      const to = tex.createView({ format: plain, dimension: "2d", baseArrayLayer: layer, arrayLayerCount: 1, baseMipLevel: m, mipLevelCount: 1 });
+      const group = this.device.createBindGroup({ label: `${this.label} fill`, layout: pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: from }] });
+      const pass = enc.beginRenderPass({ label: `${this.label} fill`, colorAttachments: [{ view: to, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }] });
+      pass.setPipeline(pipe);
+      pass.setBindGroup(0, group);
+      pass.draw(3);
+      pass.end();
+    }
+    if (encoder === void 0) this.device.queue.submit([enc.finish()]);
+  }
+  /** A `2d-array` view of the whole array — or of `blank` (a 1 × 1 × 1 stand-in the caller keeps) before its first layer. */
+  view(blank) {
+    return (this.tex ?? blank).createView({ dimension: "2d-array" });
+  }
+  destroy() {
+    this.tex?.destroy();
+    this.tex = null;
+    this.cap = 0;
+  }
+  /** The array made again at `capacity` layers — the old one's layers copied, as many as both hold — and the old destroyed. */
+  remake(capacity) {
+    const next = this.device.createTexture({
+      label: this.label,
+      size: [this.side, this.side, capacity],
+      format: this.format,
+      mipLevelCount: this.mips,
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+      ...plainFormat(this.format) !== this.format ? { viewFormats: [plainFormat(this.format)] } : {}
+    });
+    const old = this.tex;
+    if (old !== null) {
+      const enc = this.device.createCommandEncoder({ label: `${this.label} ${capacity > this.cap ? "grow" : "shrink"}` });
+      const layers = Math.min(this.cap, capacity);
+      for (let m = 0; m < this.mips; m++) {
+        const s = Math.max(this.side >> m, 1);
+        enc.copyTextureToTexture({ texture: old, mipLevel: m }, { texture: next, mipLevel: m }, [s, s, layers]);
+      }
+      this.device.queue.submit([enc.finish()]);
+      old.destroy();
+    }
+    this.tex = next;
+    this.cap = capacity;
+    this.version += 1;
+  }
+  pipeline(format) {
+    if (this.fillPipe === null) {
+      const module = this.device.createShaderModule({ label: `${this.label} fill`, code: FILL });
+      this.fillPipe = this.device.createRenderPipeline({ label: `${this.label} fill`, layout: "auto", vertex: { module, entryPoint: "vs" }, fragment: { module, entryPoint: "fs", targets: [{ format }] } });
+    }
+    return this.fillPipe;
+  }
+};
+
+// ../desk/src/kit/eye.ts
+function eyeOf(cam, vp, law) {
+  const zoom = Math.max(cam.zoom, 1e-9);
+  const diag = Math.hypot(vp.width, vp.height) / zoom;
+  return { ex: cam.x + vp.width / (2 * zoom), ey: cam.y + vp.height / (2 * zoom), h: Math.max(law.min, law.k * diag), zoom, vw: vp.width, vh: vp.height };
+}
+function project(e, x, y, z) {
+  const k = e.h / Math.max(e.h - z, 1e-6);
+  return [e.vw / 2 + (x - e.ex) * k * e.zoom, e.vh / 2 + (y - e.ey) * k * e.zoom];
+}
+function deskAt(e, sx, sy) {
+  return [e.ex + (sx - e.vw / 2) / e.zoom, e.ey + (sy - e.vh / 2) / e.zoom];
+}
+function unproject(e, dx, dy, z) {
+  const f = (e.h - z) / e.h;
+  return [e.ex + (dx - e.ex) * f, e.ey + (dy - e.ey) * f];
+}
+function rayThrough(e, dx, dy) {
+  return { o: [e.ex, e.ey, e.h], d: [dx - e.ex, dy - e.ey, -e.h] };
+}
+function eyeValues(e, reach = 900) {
+  const near = Math.max(e.h - reach, 1);
+  const far = e.h + 40;
+  return { eye: [e.ex, e.ey, e.h, e.zoom], view: [e.vw, e.vh, near, far] };
+}
+
+// ../desk/src/kit/mesh.ts
+var VERTEX_FLOATS = 16;
+var VERTEX_BYTES = VERTEX_FLOATS * 4;
+var FLAG_TWO_SIDED = 1;
+var MeshWriter = class {
+  v;
+  ix;
+  nv = 0;
+  ni = 0;
+  min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  constructor(vcap = 8192, icap = 24576) {
+    this.v = new Float32Array(vcap * VERTEX_FLOATS);
+    this.ix = new Uint32Array(icap);
+  }
+  reset() {
+    this.nv = 0;
+    this.ni = 0;
+    this.min.fill(Number.POSITIVE_INFINITY);
+    this.max.fill(Number.NEGATIVE_INFINITY);
+  }
+  vert(px, py, pz, nx, ny, nz, u, v, mat, page, flags, ao, sx, sy, e0 = 0, e1 = 0) {
+    if ((this.nv + 1) * VERTEX_FLOATS > this.v.length) {
+      const g = new Float32Array(this.v.length * 2);
+      g.set(this.v);
+      this.v = g;
+    }
+    const o = this.nv * VERTEX_FLOATS;
+    const a = this.v;
+    const nl = Math.hypot(nx, ny, nz) || 1;
+    a[o] = px;
+    a[o + 1] = py;
+    a[o + 2] = pz;
+    a[o + 3] = nx / nl;
+    a[o + 4] = ny / nl;
+    a[o + 5] = nz / nl;
+    a[o + 6] = u;
+    a[o + 7] = v;
+    a[o + 8] = mat;
+    a[o + 9] = page;
+    a[o + 10] = flags;
+    a[o + 11] = ao;
+    a[o + 12] = sx;
+    a[o + 13] = sy;
+    a[o + 14] = e0;
+    a[o + 15] = e1;
+    if (px < this.min[0]) this.min[0] = px;
+    if (py < this.min[1]) this.min[1] = py;
+    if (pz < this.min[2]) this.min[2] = pz;
+    if (px > this.max[0]) this.max[0] = px;
+    if (py > this.max[1]) this.max[1] = py;
+    if (pz > this.max[2]) this.max[2] = pz;
+    return this.nv++;
+  }
+  tri(a, b, c) {
+    if (this.ni + 3 > this.ix.length) {
+      const g = new Uint32Array(this.ix.length * 2);
+      g.set(this.ix);
+      this.ix = g;
+    }
+    this.ix[this.ni++] = a;
+    this.ix[this.ni++] = b;
+    this.ix[this.ni++] = c;
+  }
+  quad(a, b, c, d) {
+    this.tri(a, b, c);
+    this.tri(a, c, d);
+  }
+  /** A grid's quads: `cols` × `rows` vertices laid out row-major from `first`. */
+  gridQuads(first, cols, rows) {
+    for (let j = 0; j + 1 < rows; j++) for (let i = 0; i + 1 < cols; i++) {
+      const a = first + j * cols + i;
+      this.quad(a, a + 1, a + cols + 1, a + cols);
+    }
+  }
+};
+
+// ../desk/src/kit/mips.ts
+var WGSL2 = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var src: texture_2d<f32>;
+@group(0) @binding(1) var samp: sampler;
+struct VO { @builtin(position) pos: vec4f, @location(0) uv: vec2f }
+@vertex fn vs(@builtin(vertex_index) i: u32) -> VO {
+  let p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0))[i];
+  var o: VO; o.pos = vec4f(p, 0.0, 1.0); o.uv = vec2f(0.5 * p.x + 0.5, 0.5 - 0.5 * p.y); return o;
+}
+@fragment fn fs(v: VO) -> @location(0) vec4f { return textureSampleLevel(src, samp, v.uv, 0.0); }
+`
+);
+var cache = /* @__PURE__ */ new WeakMap();
+var mipCount = (w, h) => Math.floor(Math.log2(Math.max(w, h, 1))) + 1;
+function generateMips(device, texture) {
+  let c = cache.get(device);
+  if (!c) {
+    c = { module: device.createShaderModule({ label: "photo/mips", code: WGSL2 }), sampler: device.createSampler({ minFilter: "linear", magFilter: "linear" }), pipes: /* @__PURE__ */ new Map() };
+    cache.set(device, c);
+  }
+  let pipe = c.pipes.get(texture.format);
+  if (!pipe) {
+    pipe = device.createRenderPipeline({
+      label: `photo/mips ${texture.format}`,
+      layout: "auto",
+      vertex: { module: c.module, entryPoint: "vs" },
+      fragment: { module: c.module, entryPoint: "fs", targets: [{ format: texture.format }] }
+    });
+    c.pipes.set(texture.format, pipe);
+  }
+  const encoder = device.createCommandEncoder({ label: "photo/mips" });
+  for (let level = 1; level < texture.mipLevelCount; level++) {
+    const src = texture.createView({ baseMipLevel: level - 1, mipLevelCount: 1 });
+    const dst = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
+    const group = device.createBindGroup({ layout: pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }, { binding: 1, resource: c.sampler }] });
+    const pass = encoder.beginRenderPass({ colorAttachments: [{ view: dst, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }] });
+    pass.setPipeline(pipe);
+    pass.setBindGroup(0, group);
+    pass.draw(3);
+    pass.end();
+  }
+  device.queue.submit([encoder.finish()]);
+}
+
+// ../desk/src/kit/paper-tex.ts
+var PAPER_TEX = 256;
+var TOOTH_SCALE = 48;
+var fract = (x) => x - Math.floor(x);
+function hash(i, j, seed) {
+  let h = (Math.imul(i, 668265261) ^ Math.imul(j, 374761393) ^ Math.imul(seed, 1274126177)) >>> 0;
+  h = Math.imul(h ^ h >>> 15, 2246822519) >>> 0;
+  h = Math.imul(h ^ h >>> 13, 3266489917) >>> 0;
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function vnoise(u, v, cells2, seed) {
+  const x = u * cells2;
+  const y = v * cells2;
+  const i = Math.floor(x);
+  const j = Math.floor(y);
+  const fx = x - i;
+  const fy = y - j;
+  const w = (t) => t * t * (3 - 2 * t);
+  const dw = (t) => 6 * t * (1 - t);
+  const at = (a2, b2) => hash((a2 % cells2 + cells2) % cells2, (b2 % cells2 + cells2) % cells2, seed);
+  const a = at(i, j);
+  const b = at(i + 1, j);
+  const c = at(i, j + 1);
+  const d = at(i + 1, j + 1);
+  const k = a - b - c + d;
+  const wx = w(fx);
+  const wy = w(fy);
+  return [a + (b - a) * wx + (c - a) * wy + k * wx * wy - 0.5, dw(fx) * (b - a + k * wy) * cells2, dw(fy) * (c - a + k * wx) * cells2];
+}
+function paperTexture(seed = 7) {
+  const N = PAPER_TEX;
+  const out = new Uint8Array(N * N * 4);
+  const fib = new Float32Array(N * N);
+  let r = seed * 9973;
+  const rnd = () => {
+    r = Math.imul(r, 1664525) + 1013904223 >>> 0;
+    return r / 4294967296;
+  };
+  for (let f = 0; f < 420; f++) {
+    const x0 = rnd() * N;
+    const y0 = rnd() * N;
+    const a = rnd() < 0.65 ? Math.PI / 2 + (rnd() - 0.5) * 0.9 : rnd() * Math.PI;
+    const len = 5 + rnd() * 16;
+    const bend = (rnd() - 0.5) * 0.12;
+    const tone = (rnd() < 0.55 ? 1 : -1) * (0.35 + rnd() * 0.65);
+    const wid = 0.45 + rnd() * 0.5;
+    let x = x0;
+    let y = y0;
+    let ang = a;
+    for (let s = 0; s < len; s += 0.5) {
+      x += Math.cos(ang) * 0.5;
+      y += Math.sin(ang) * 0.5;
+      ang += bend;
+      const fade = Math.sin(s / len * Math.PI);
+      for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) {
+        const px = Math.floor(x) + dx;
+        const py = Math.floor(y) + dy;
+        const ddx = px + 0.5 - x;
+        const ddy = py + 0.5 - y;
+        const g = Math.exp(-(ddx * ddx + ddy * ddy) / (2 * wid * wid));
+        const ix = (px % N + N) % N;
+        const iy = (py % N + N) % N;
+        fib[iy * N + ix] = fib[iy * N + ix] + tone * g * fade * 0.18;
+      }
+    }
+  }
+  for (let j = 0; j < N; j++) for (let i = 0; i < N; i++) {
+    const u = (i + 0.5) / N;
+    const v = (j + 0.5) / N;
+    const m = vnoise(u, v, 4, seed)[0] + 0.5 * vnoise(u, v, 8, seed + 1)[0];
+    const t1 = vnoise(u, v, 32, seed + 2);
+    const t2 = vnoise(u, v, 64, seed + 3);
+    const gx = t1[1] + 0.5 * t2[1];
+    const gy = t1[2] + 0.5 * t2[2];
+    const o = (j * N + i) * 4;
+    out[o] = Math.round(Math.min(Math.max(0.5 + m * 0.9, 0), 1) * 255);
+    out[o + 1] = Math.round(Math.min(Math.max(0.5 + fib[j * N + i], 0), 1) * 255);
+    out[o + 2] = Math.round(Math.min(Math.max(0.5 + gx / TOOTH_SCALE / 2, 0), 1) * 255);
+    out[o + 3] = Math.round(Math.min(Math.max(0.5 + gy / TOOTH_SCALE / 2, 0), 1) * 255);
+  }
+  void fract;
+  return out;
+}
+
+// ../desk/src/kit/physics.ts
+var SHADOW = { sigma: 2.2, alpha: 0.36, sigmaPerUnit: 0.9, alphaHeld: 0.4, slopeMax: 2.2 };
+var PHYSICS = {
+  /** How far a HELD note rises (§7's lift, as a height), and the scale it reads at (§7's 1.05, kept). */
+  lift: { height: 12, scale: 1.03 },
+  /**
+   * The contact shadow on the mat: Gaussian-blurred coverage of the sheet cast along the lamp's
+   * ground direction by its height — σ and alpha at contact, σ growing per unit of height, the
+   * alpha a held note casts, and the slope's cap (a note far from the lamp keeps a finite shadow).
+   */
+  shadow: SHADOW,
+  /**
+   * A SLAB's shadow (a notebook, a whiteboard, a mini mat): the note's penumbra swept down its height, with a contact
+   * term at its base (the tree-shadow design system's paper elevation, mat.css `--lift-1`) — theme.ts `BOOK.shadow` until K4a.
+   */
+  slab: {
+    penumbra: { sigma0: SHADOW.sigma, sigmaPerHeight: SHADOW.sigmaPerUnit, alpha: SHADOW.alpha },
+    /** The contact term: σ, alpha, and the gap (world units) it has faded over once the object floats. */
+    contact: { sigma: 1.1, alpha: 0.3, reach: 2.5 },
+    slopeMax: SHADOW.slopeMax
+  },
+  /** The lamp's fill on a face turned away from it; how far past a flat face one turned toward it may brighten. */
+  light: { ambient: 0.5, cap: 1.35 },
+  /** The sole-selection ring (DESIGN.md §7), CSS px, in `--vf-select`. */
+  ring: 1.5
+};
+
+// ../desk/src/kit/place.ts
+function rigidOf(p) {
+  const cz = Math.cos(p.angle);
+  const sz = Math.sin(p.angle);
+  const cx = Math.cos(p.tiltX);
+  const sx = Math.sin(p.tiltX);
+  const cy = Math.cos(p.tiltY);
+  const sy = Math.sin(p.tiltY);
+  const rx = [1, 0, 0, 0, cx, -sx, 0, sx, cx];
+  const ry = [cy, 0, sy, 0, 1, 0, -sy, 0, cy];
+  const rz = [cz, -sz, 0, sz, cz, 0, 0, 0, 1];
+  const mul2 = (a, b) => {
+    const o = [];
+    for (let i = 0; i < 3; i++) for (let j = 0; j < 3; j++) o.push(a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j]);
+    return o;
+  };
+  const r = mul2(rz, mul2(rx, ry));
+  const t = [p.cx - r[2] * p.zc, p.cy - r[5] * p.zc, p.lift + p.zc - r[8] * p.zc];
+  return { r, t };
+}
+function toWorld(g, x, y, z) {
+  const r = g.r;
+  return [r[0] * x + r[1] * y + r[2] * z + g.t[0], r[3] * x + r[4] * y + r[5] * z + g.t[1], r[6] * x + r[7] * y + r[8] * z + g.t[2]];
+}
+function dirToWorld(g, x, y, z) {
+  const r = g.r;
+  return [r[0] * x + r[1] * y + r[2] * z, r[3] * x + r[4] * y + r[5] * z, r[6] * x + r[7] * y + r[8] * z];
+}
+function toLocal(g, x, y, z) {
+  const r = g.r;
+  const dx = x - g.t[0];
+  const dy = y - g.t[1];
+  const dz = z - g.t[2];
+  return [r[0] * dx + r[3] * dy + r[6] * dz, r[1] * dx + r[4] * dy + r[7] * dz, r[2] * dx + r[5] * dy + r[8] * dz];
+}
+function dirToLocal(g, x, y, z) {
+  const r = g.r;
+  return [r[0] * x + r[3] * y + r[6] * z, r[1] * x + r[4] * y + r[7] * z, r[2] * x + r[5] * y + r[8] * z];
+}
+function matrixOf(g) {
+  const r = g.r;
+  const m = new Float32Array(16);
+  m[0] = r[0];
+  m[1] = r[3];
+  m[2] = r[6];
+  m[4] = r[1];
+  m[5] = r[4];
+  m[6] = r[7];
+  m[8] = r[2];
+  m[9] = r[5];
+  m[10] = r[8];
+  m[12] = g.t[0];
+  m[13] = g.t[1];
+  m[14] = g.t[2];
+  m[15] = 1;
+  return m;
+}
+function lampDir(lamp, x, y, slopeMax) {
+  let dx = lamp.x - x;
+  let dy = lamp.y - y;
+  const h = Math.max(lamp.h, 1e-6);
+  const s = Math.hypot(dx, dy) / h;
+  if (s > slopeMax) {
+    dx *= slopeMax / s;
+    dy *= slopeMax / s;
+  }
+  const l = Math.hypot(dx, dy, h);
+  return [dx / l, dy / l, h / l];
+}
+function lightFrame(L, lo, hi, res, pad = 6, receivers = []) {
+  const f = [-L[0], -L[1], -L[2]];
+  let r = Math.abs(f[2]) > 0.999 ? [1, 0, 0] : [f[1] * 1 - f[2] * 0, f[2] * 0 - f[0] * 1, 0];
+  const rl = Math.hypot(r[0], r[1], r[2]) || 1;
+  r = [r[0] / rl, r[1] / rl, r[2] / rl];
+  const u = [r[1] * f[2] - r[2] * f[1], r[2] * f[0] - r[0] * f[2], r[0] * f[1] - r[1] * f[0]];
+  let x0 = Number.POSITIVE_INFINITY;
+  let x1 = Number.NEGATIVE_INFINITY;
+  let y0 = Number.POSITIVE_INFINITY;
+  let y1 = Number.NEGATIVE_INFINITY;
+  let d0 = Number.POSITIVE_INFINITY;
+  let d1 = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < 8; i++) {
+    const P = [i & 1 ? hi[0] : lo[0], i & 2 ? hi[1] : lo[1], i & 4 ? hi[2] : lo[2]];
+    const lx = P[0] * r[0] + P[1] * r[1] + P[2] * r[2];
+    const ly = P[0] * u[0] + P[1] * u[1] + P[2] * u[2];
+    const d = P[0] * f[0] + P[1] * f[1] + P[2] * f[2];
+    x0 = Math.min(x0, lx);
+    x1 = Math.max(x1, lx);
+    y0 = Math.min(y0, ly);
+    y1 = Math.max(y1, ly);
+    d0 = Math.min(d0, d);
+    d1 = Math.max(d1, d);
+  }
+  for (const P of receivers) d1 = Math.max(d1, P[0] * f[0] + P[1] * f[1] + P[2] * f[2]);
+  const half = Math.max(x1 - x0, y1 - y0) / 2 + pad;
+  const mx = (x0 + x1) / 2;
+  const my = (y0 + y1) / 2;
+  x0 = mx - half;
+  x1 = mx + half;
+  y0 = my - half;
+  y1 = my + half;
+  d0 -= pad;
+  d1 += pad;
+  const sx = 2 / (x1 - x0);
+  const sy = 2 / (y1 - y0);
+  const sd = 1 / (d1 - d0);
+  const m = new Float32Array(16);
+  m[0] = sx * r[0];
+  m[4] = sx * r[1];
+  m[8] = sx * r[2];
+  m[12] = -sx * x0 - 1;
+  m[1] = sy * u[0];
+  m[5] = sy * u[1];
+  m[9] = sy * u[2];
+  m[13] = -sy * y0 - 1;
+  m[2] = sd * f[0];
+  m[6] = sd * f[1];
+  m[10] = sd * f[2];
+  m[14] = -sd * d0;
+  m[15] = 1;
+  return { matrix: m, texel: (x1 - x0) / res, depth: d1 - d0 };
+}
+function worldBounds(g, lo, hi) {
+  const a = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const b = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (let i = 0; i < 8; i++) {
+    const p = toWorld(g, i & 1 ? hi[0] : lo[0], i & 2 ? hi[1] : lo[1], i & 4 ? hi[2] : lo[2]);
+    for (let k = 0; k < 3; k++) {
+      a[k] = Math.min(a[k], p[k]);
+      b[k] = Math.max(b[k], p[k]);
+    }
+  }
+  return { lo: a, hi: b };
+}
+function inverseOf(g) {
+  const r = g.r;
+  const rt = [r[0], r[3], r[6], r[1], r[4], r[7], r[2], r[5], r[8]];
+  const t = g.t;
+  return { r: rt, t: [-(rt[0] * t[0] + rt[1] * t[1] + rt[2] * t[2]), -(rt[3] * t[0] + rt[4] * t[1] + rt[5] * t[2]), -(rt[6] * t[0] + rt[7] * t[1] + rt[8] * t[2])] };
+}
+
+// ../desk/src/kit/print.ts
+var PRINT_RASTER = serviceKey("print");
+
+// ../desk/src/kit/sdf.ts
+var sdRoundBox = (px, py, bx, by, r) => {
+  const rr = Math.min(Math.max(r, 0), Math.min(bx, by));
+  const qx = Math.abs(px) - bx + rr;
+  const qy = Math.abs(py) - by + rr;
+  return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - rr;
+};
+
+// ../desk/src/kit/seeds.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var INDEX = Object.fromEntries([...ALPHABET].map((c, i) => [c, i]));
+function encodeSeeds(seeds) {
+  const n = seeds.length;
+  const bytes = new Uint8Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    const v = seeds[i] >>> 0;
+    bytes[4 * i] = v & 255;
+    bytes[4 * i + 1] = v >>> 8 & 255;
+    bytes[4 * i + 2] = v >>> 16 & 255;
+    bytes[4 * i + 3] = v >>> 24 & 255;
+  }
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    const t = a << 16 | b << 8 | c;
+    out += ALPHABET[t >>> 18 & 63];
+    out += ALPHABET[t >>> 12 & 63];
+    if (i + 1 < bytes.length) out += ALPHABET[t >>> 6 & 63];
+    if (i + 2 < bytes.length) out += ALPHABET[t & 63];
+  }
+  return out;
+}
+function decodeSeeds(s) {
+  const bytes = [];
+  let acc = 0;
+  let bits = 0;
+  for (const ch of s) {
+    const v = INDEX[ch];
+    if (v === void 0) break;
+    acc = (acc << 6 | v) & 16777215;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(acc >>> bits & 255);
+    }
+  }
+  const out = [];
+  for (let i = 0; i + 3 < bytes.length; i += 4) {
+    out.push(bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24 | 0);
+  }
+  return out;
+}
+function seedsFor(text, stored, noteSeed) {
+  const got = decodeSeeds(stored);
+  const out = new Array(text.length);
+  for (let i = 0; i < text.length; i++) out[i] = i < got.length ? got[i] : glyphSeed(noteSeed, i);
+  return out;
+}
+var freshSeed = () => Math.random() * 2147483647 | 0;
+
+// ../desk/src/kit/strokes.ts
+var BoardStroke = defineComponent("desk.stroke", {
+  tool: field("string", { default: "marker" }),
+  ink: field("string", { default: "black" }),
+  tip: field("string", { default: "bullet" }),
+  erase: field("bool", { default: false }),
+  points: field("string", { default: "" }),
+  speed: field("f64", { default: 400 }),
+  times: field("string", { default: "" }),
+  page: field("u32", { default: 0 }),
+  seed: field("f64", { default: -1 })
+});
+var STROKE_TYPE = "desk.stroke";
+var StrokePrefab = definePrefab(STROKE_TYPE, {
+  store: "durable",
+  version: 4,
+  components: [init(BoardStroke, { tool: "marker", ink: "black", tip: "bullet", erase: false, points: "", speed: 400, times: "", page: 0, seed: -1 })],
+  relations: [ChildOf],
+  // v4 (D7 #13): `seed` — the fibre seed the pen laid with; a v3 stroke keeps the seed its position gives it (−1), so nothing it drew changes
+  migrate: { 1: (v) => ({ ...v, times: "" }), 2: (v) => ({ ...v, page: 0 }), 3: (v) => ({ ...v, seed: -1 }) }
+});
+var seedOfRow = (s, n) => s.seed !== null && s.seed !== void 0 && s.seed >= 0 ? s.seed : strokeSeed(n);
+function encodePoints(points) {
+  const f = new Float32Array(points.length * 2);
+  points.forEach(([x, y], i) => {
+    f[2 * i] = x;
+    f[2 * i + 1] = y;
+  });
+  return encodeSeeds(new Uint32Array(f.buffer));
+}
+function decodePoints(s) {
+  const words = decodeSeeds(s);
+  const f = new Float32Array(new Int32Array(words).buffer);
+  const out = [];
+  for (let i = 0; i + 1 < f.length; i += 2) out.push([f[i], f[i + 1]]);
+  return out;
+}
+function encodeTimes(times) {
+  return encodeSeeds(new Uint32Array(Float32Array.from(times).buffer));
+}
+function decodeTimes(s) {
+  return Array.from(new Float32Array(new Int32Array(decodeSeeds(s)).buffer));
+}
+function meanSpeed(points, times) {
+  let length = 0;
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    length += Math.hypot(b[0] - a[0], b[1] - a[1]);
+  }
+  const ms = (times[times.length - 1] ?? 0) - (times[0] ?? 0);
+  return length > 0 && ms > 0 ? length / ms * 1e3 : 400;
+}
+function strokeRow(s) {
+  const points = s.points ?? [];
+  const timed = s.times !== void 0 && s.times.length === points.length && points.length > 0;
+  return {
+    tool: s.tool ?? "marker",
+    ink: s.ink ?? "black",
+    tip: s.tip ?? "bullet",
+    erase: s.erase === true,
+    points: encodePoints(points),
+    speed: s.speed ?? (timed ? meanSpeed(points, s.times ?? []) : 400),
+    times: timed ? encodeTimes(s.times ?? []) : "",
+    page: Math.max(0, Math.floor(s.page ?? 0)),
+    seed: s.seed !== void 0 && Number.isFinite(s.seed) && s.seed >= 0 ? s.seed : -1
+  };
+}
+function addStroke(tx, board, s) {
+  const e = tx.spawnPrefab(StrokePrefab, [init(BoardStroke, strokeRow(s))]);
+  tx.setRelation(e, ChildOf, board);
+  return e;
+}
+var strokeSeed = (n) => n * 97.13 % 1e3;
+var heldPressesQ = defineQuery([Pointer, LocalPointer, HeldPress]);
+function inking(world) {
+  let yes = false;
+  world.query(heldPressesQ).each((b) => {
+    for (const r of b) if (world.read(b.entity(r), HeldPress).kind === "tool") yes = true;
+  });
+  return yes;
+}
+
+// ../desk/src/kit/uniform.ts
+var sentBytes = (size) => new Uint8Array(size);
+function writeChanged(queue, buffer, block, sent, elements) {
+  const bytes = block.view(elements);
+  if (bytes.byteLength > sent.byteLength) throw new Error(`writeChanged: ${bytes.byteLength} bytes into a ${sent.byteLength}-byte record of what was sent`);
+  let same = true;
+  for (let i = 0; i < bytes.byteLength; i++) if (bytes[i] !== sent[i]) {
+    same = false;
+    break;
+  }
+  if (same) return false;
+  queue.writeBuffer(buffer, 0, bytes);
+  sent.set(bytes);
+  return true;
+}
+
+// ../desk/src/lattice/line.ts
+var clamp013 = (x) => Math.min(Math.max(x, 0), 1);
+function lineWeight(cellPx, fadeIn, law) {
+  const s = smoothstep(fadeIn[0], fadeIn[1], cellPx);
+  const t = clamp013(Math.log10(Math.max(cellPx, 1e-9) / Math.max(fadeIn[1], 1e-9)));
+  return {
+    halfWidth: law.thin + (law.thick - law.thin) * t,
+    alpha: law.alphaThin * s + (law.alphaThick - law.alphaThin) * t
+  };
+}
+
+export {
+  ZOOM_MIN,
+  ZOOM_MAX,
+  boxOf,
+  smoothstep,
+  lod,
+  DAY_LIGHT,
+  linear,
+  dayLuminance,
+  nightLight,
+  lightValues,
+  cssColor,
+  rgb,
+  GRID,
+  MAT,
+  MAT_COLORS,
+  MAT_GRID,
+  NIGHT,
+  EIGENGRAU,
+  MAT_LIGHT,
+  PORTAL,
+  MARKS,
+  TRAY,
+  themeFrom,
+  PORTAL_CHAIN,
+  chainOf,
+  clipOf,
+  boxOfPortal,
+  intersectBox,
+  PORTAL_GATE,
+  PORTAL_CAP,
+  portalPresence,
+  faceCovers,
+  scissorOf,
+  tilted,
+  MatUniforms,
+  GLYPH_PAD,
+  GLYPHS,
+  RULER_GLYPHS,
+  NO_GLYPHS,
+  DEFAULT_MAT_CONFIG,
+  HERO_MATRIX,
+  STILL_MAT_FRAME,
+  NOISE_SIZE,
+  PLATE_SIZE,
+  matUniformValues,
+  litByOwn,
+  DEFAULT_GRID,
+  dressScale,
+  dressGrid,
+  gridStats,
+  easeLift,
+  easeIsland,
+  NbUniforms,
+  NbBook,
+  shaderText,
+  KIT_WGSL_FILES,
+  kitWgsl,
+  LAYER_COMPOSITE_FILE,
+  layerComposite,
+  layerCompositeLayout,
+  attachmentOf,
+  clip,
+  LayeredKind,
+  BOX_STEP,
+  BoxTargets,
+  LAYER_IDLE_MS,
+  spring,
+  settled,
+  SPRINGS,
+  visibleRect,
+  portalAffine,
+  solveFlightStart,
+  outgoingCamera,
+  flightCamera,
+  FIT,
+  flightOpacity,
+  boundsOf,
+  arrivalCamera,
+  HOLD,
+  isNarrow,
+  readingTarget,
+  homePose,
+  HELD_USER_REST,
+  heldPose,
+  carryOf,
+  progressOf,
+  heldFocus,
+  heldCamera,
+  heldFrame,
+  focusOf,
+  PAPER_FINISH,
+  VINYL_FINISH,
+  finishOf,
+  insideViewOfFace,
+  insidePresent,
+  flightPresent,
+  HANDOVER,
+  flightLights,
+  lampOf,
+  serviceKey,
+  service,
+  createServices,
+  BLOB_STORE,
+  PICTURE_DECODER,
+  RGBA_TYPE,
+  hashBytes,
+  createMemoryBlobStore,
+  TEXT_RASTER,
+  hashHand,
+  glyphSeed,
+  layoutText,
+  caretAt,
+  glyphBox,
+  carrySeeds,
+  HAND,
+  PENS,
+  PEN_FACES,
+  tailBase,
+  chainBytes,
+  Layers,
+  plainFormat,
+  LayerArray,
+  eyeOf,
+  project,
+  deskAt,
+  unproject,
+  rayThrough,
+  eyeValues,
+  VERTEX_FLOATS,
+  VERTEX_BYTES,
+  FLAG_TWO_SIDED,
+  MeshWriter,
+  mipCount,
+  generateMips,
+  PAPER_TEX,
+  TOOTH_SCALE,
+  paperTexture,
+  PHYSICS,
+  rigidOf,
+  toWorld,
+  dirToWorld,
+  toLocal,
+  dirToLocal,
+  matrixOf,
+  lampDir,
+  lightFrame,
+  worldBounds,
+  inverseOf,
+  PRINT_RASTER,
+  sdRoundBox,
+  encodeSeeds,
+  decodeSeeds,
+  seedsFor,
+  freshSeed,
+  BoardStroke,
+  STROKE_TYPE,
+  StrokePrefab,
+  seedOfRow,
+  encodePoints,
+  decodePoints,
+  encodeTimes,
+  decodeTimes,
+  meanSpeed,
+  strokeRow,
+  addStroke,
+  strokeSeed,
+  inking,
+  sentBytes,
+  writeChanged,
+  lineWeight
+};
+//# sourceMappingURL=chunk-BA7XJC27.js.map