@jokerized/decksmith 0.9.0 → 0.9.1

package/dist/mcp.js

@@ -58,22 +58,43 @@ var VERSION = createRequire2(import.meta.url)("../package.json").version;
 
 // src/mcp/tools.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir12, mkdtemp as mkdtemp3, readFile as readFile14, rm as rm8 } from "node:fs/promises";
+import { mkdir as mkdir13, mkdtemp as mkdtemp3, readFile as readFile15, rm as rm8 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename5, isAbsolute as isAbsolute2, join as join15, resolve as resolve8, sep as sep3 } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute2, join as join16, resolve as resolve9, sep as sep4 } from "node:path";
 import { zipSync as zipSync2 } from "fflate";
 import { z as z5 } from "zod";
 
 // src/index.ts
-import { cp as cp2, mkdir as mkdir10, readFile as readFile12, writeFile as writeFile12 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir11, readFile as readFile13, writeFile as writeFile13 } from "node:fs/promises";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname5, join as join13, resolve as resolve6 } from "node:path";
+import { dirname as dirname5, join as join14, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
+// src/bespoke/art.ts
+import { copyFile, mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { join as join2, resolve as resolve2, sep as sep2 } from "node:path";
+var MAX_ART_BYTES = 12 * 1024 * 1024;
+async function copyArt(entries, out) {
+  const written = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (!e.art || seen.has(e.art.name)) continue;
+    seen.add(e.art.name);
+    const dir = join2(out, "assets", "bespoke");
+    await mkdir(dir, { recursive: true });
+    await copyFile(e.art.file, join2(dir, e.art.name));
+    written.push(join2(dir, e.art.name));
+  }
+  return written;
+}
+function artHref(art) {
+  return `assets/bespoke/${art.name}`;
+}
+
 // src/build/files.ts
-import { cp, mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { cp, mkdir as mkdir3, readdir, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/emit/faces.ts
@@ -1065,11 +1086,11 @@ function reshape(target, to, at, seconds, first) {
     sec(at)
   );
 }
-function travel(target, route, at, seconds) {
+function travel(target, route2, at, seconds) {
   if (!(seconds > 0)) throw new Error(`travel ${target}: ${seconds}s is no time to travel in`);
   const legs = [];
   let prev;
-  for (const p of route) {
+  for (const p of route2) {
     const q = { x: nv(p.x), y: nv(p.y) };
     if (prev === void 0) {
       prev = q;
@@ -1610,8 +1631,8 @@ function fitBoxes(req) {
 
 // src/source/fonts.ts
 import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 function serifFamilyFor(lang) {
   return familyFor(lang)?.replace("Noto Sans", "Noto Serif") ?? null;
 }
@@ -1631,9 +1652,9 @@ async function bundleFont(lang, glyphs, dir, opts = {}) {
   const text2 = [...new Set(glyphs)].filter((c) => c > " ").sort().join("");
   const stamp = `/* decksmith ${createHash("sha256").update(`${families.join("+")}
 ${text2}`).digest("hex").slice(0, 16)} */`;
-  await mkdir(dir, { recursive: true });
-  const cssPath = join2(dir, "fonts.css");
-  const cached2 = await readFile(cssPath, "utf8").catch(() => "");
+  await mkdir2(dir, { recursive: true });
+  const cssPath = join3(dir, "fonts.css");
+  const cached2 = await readFile2(cssPath, "utf8").catch(() => "");
   if (cached2.startsWith(stamp)) return { family, css: cached2, files: localNames(cached2) };
   const res = await fetch(
     `https://fonts.googleapis.com/css2?${families.map((f) => `family=${f.replaceAll(" ", "+")}:wght@400;500;700`).join("&")}&text=${encodeURIComponent(text2)}&display=block`,
@@ -1648,13 +1669,13 @@ ${text2}`).digest("hex").slice(0, 16)} */`;
     const font = await fetch(url);
     if (!font.ok) throw new Error(`${url}: HTTP ${font.status}`);
     const name = `${slug}-${i}.woff2`;
-    await writeFile(join2(dir, name), Buffer.from(await font.arrayBuffer()));
+    await writeFile2(join3(dir, name), Buffer.from(await font.arrayBuffer()));
     css = css.replaceAll(url, name);
     files.push(name);
   }
   css = `${stamp}
 ${css}`;
-  await writeFile(cssPath, css);
+  await writeFile2(cssPath, css);
   return { family, css, files };
 }
 function localNames(css) {
@@ -1960,9 +1981,9 @@ function scenePadding(format) {
   return reserve > 0 ? `${base} ${PAD_Y + reserve}px` : base;
 }
 function referenceSpaceCss(format) {
-  const zoom = zoomOf(format);
-  if (zoom === 1) return "";
-  return `      .scene { width: ${refWidth(format)}px; height: ${refHeight(format)}px; zoom: ${zoom}; }
+  const zoom2 = zoomOf(format);
+  if (zoom2 === 1) return "";
+  return `      .scene { width: ${refWidth(format)}px; height: ${refHeight(format)}px; zoom: ${zoom2}; }
       .scene:has(.scene) { width: 100%; height: 100%; padding: 0; zoom: 1; }`;
 }
 function pace(scene, speed) {
@@ -2017,26 +2038,26 @@ function audioNames(narration) {
 }
 async function vendorKatex(out) {
   const require2 = createRequire3(import.meta.url);
-  const dist = join3(dirname2(require2.resolve("katex/package.json")), "dist");
-  const css = await readFile2(join3(dist, "katex.min.css"), "utf8");
+  const dist = join4(dirname2(require2.resolve("katex/package.json")), "dist");
+  const css = await readFile3(join4(dist, "katex.min.css"), "utf8");
   const written = [];
-  await mkdir2(join3(out, "katex/fonts"), { recursive: true });
-  for (const file of await readdir(join3(dist, "fonts"))) {
+  await mkdir3(join4(out, "katex/fonts"), { recursive: true });
+  for (const file of await readdir(join4(dist, "fonts"))) {
     if (!file.endsWith(".woff2")) continue;
-    await cp(join3(dist, "fonts", file), join3(out, "katex/fonts", file));
-    written.push(join3(out, "katex/fonts", file));
+    await cp(join4(dist, "fonts", file), join4(out, "katex/fonts", file));
+    written.push(join4(out, "katex/fonts", file));
   }
   const woff2Only = css.replace(/src:([^;}]*)/g, (whole, list) => {
     const kept = list.split(",").filter((part) => part.includes(".woff2")).join(",");
     return kept ? `src:${kept}` : whole;
   });
-  await writeFile2(join3(out, "katex/katex.min.css"), woff2Only);
-  written.push(join3(out, "katex/katex.min.css"));
+  await writeFile3(join4(out, "katex/katex.min.css"), woff2Only);
+  written.push(join4(out, "katex/katex.min.css"));
   return written;
 }
 async function vendorScripts(out, composition) {
   const require2 = createRequire3(import.meta.url);
-  await mkdir2(join3(out, "vendor"), { recursive: true });
+  await mkdir3(join4(out, "vendor"), { recursive: true });
   const wanted = (name) => composition.includes(`./vendor/${name}`);
   const written = [];
   for (const [pkg, rel, name] of [
@@ -2046,62 +2067,62 @@ async function vendorScripts(out, composition) {
     ["katex/package.json", "dist/katex.min.js", "katex.min.js"]
   ]) {
     if (!wanted(name)) continue;
-    const from = join3(dirname2(require2.resolve(pkg)), rel);
-    await cp(from, join3(out, "vendor", name));
-    written.push(join3(out, "vendor", name));
+    const from = join4(dirname2(require2.resolve(pkg)), rel);
+    await cp(from, join4(out, "vendor", name));
+    written.push(join4(out, "vendor", name));
   }
   if (wanted("ds-morph.js")) {
     await cp(
       fileURLToPath(new URL("./ds-morph.js", import.meta.url)),
-      join3(out, "vendor", "ds-morph.js")
+      join4(out, "vendor", "ds-morph.js")
     );
-    written.push(join3(out, "vendor", "ds-morph.js"));
+    written.push(join4(out, "vendor", "ds-morph.js"));
   }
   return written;
 }
 async function copyAssets(sourceDir, out, figures, step) {
-  const from = join3(resolve2(sourceDir), "assets");
-  if (!await stat(from).catch(() => null)) {
+  const from = join4(resolve3(sourceDir), "assets");
+  if (!await stat2(from).catch(() => null)) {
     step(`build: no assets/ beside source.json, skipping`);
     return [];
   }
   const wanted = new Set(
     figures.flatMap((f) => [f.src, f.poster]).filter((n3) => n3 !== void 0).map((n3) => n3.replace(/^\.?\//, ""))
   );
-  await mkdir2(join3(out, "assets"), { recursive: true });
+  await mkdir3(join4(out, "assets"), { recursive: true });
   const written = [];
   let copied = 0;
   for (const name of wanted) {
-    const src = resolve2(join3(from, name));
+    const src = resolve3(join4(from, name));
     if (!src.startsWith(`${from}/`)) continue;
-    if (!await stat(src).catch(() => null)) continue;
-    await mkdir2(dirname2(join3(out, "assets", name)), { recursive: true });
-    await cp(src, join3(out, "assets", name));
-    written.push(join3(out, "assets", name));
+    if (!await stat2(src).catch(() => null)) continue;
+    await mkdir3(dirname2(join4(out, "assets", name)), { recursive: true });
+    await cp(src, join4(out, "assets", name));
+    written.push(join4(out, "assets", name));
     copied++;
   }
-  const fonts = join3(from, "fonts");
-  if (await stat(fonts).catch(() => null)) {
-    await cp(fonts, join3(out, "assets", "fonts"), { recursive: true });
-    written.push(join3(out, "assets", "fonts"));
+  const fonts = join4(from, "fonts");
+  if (await stat2(fonts).catch(() => null)) {
+    await cp(fonts, join4(out, "assets", "fonts"), { recursive: true });
+    written.push(join4(out, "assets", "fonts"));
   }
   step(`build: copied ${copied} referenced figure(s)`);
   return written;
 }
 async function copyAudio(from, narration, out, step) {
-  const dir = join3(out, narration.dir);
-  await mkdir2(dir, { recursive: true });
+  const dir = join4(out, narration.dir);
+  await mkdir3(dir, { recursive: true });
   const names = audioNames(narration);
   for (const name of names) {
-    await cp(join3(resolve2(from), name), join3(dir, name)).catch(() => {
+    await cp(join4(resolve3(from), name), join4(dir, name)).catch(() => {
       throw new Error(`Narration names ${name}, but it is not in ${from}. Re-run \`narrate\`.`);
     });
   }
   step(`narration: ${names.length} audio file(s) \u2192 ${dir}`);
-  return names.map((n3) => join3(dir, n3));
+  return names.map((n3) => join4(dir, n3));
 }
 async function refreshFont(storyboard, source, out, step, theme) {
-  const dir = join3(out, "assets", "fonts");
+  const dir = join4(out, "assets", "fonts");
   const look = deckLook(storyboard, theme).theme;
   const type = typeOf(faceOf(look.fontStack));
   const serif = /"Noto Serif /.test(`${look.fontStack} ${look.displayStack ?? ""}`);
@@ -2147,10 +2168,10 @@ async function vendorFace(face, dir) {
 var PACK_DISPLAY = "font-display: block;\n  ascent-override: 96.875%;\n  descent-override: 24.1211%;\n  line-gap-override: 0%";
 async function vendorFontsource(pkgName, family, dir) {
   const pkg = dirname2(createRequire3(import.meta.url).resolve(pkgName));
-  const css = await readFile2(join3(pkg, "index.css"), "utf8");
-  await mkdir2(dir, { recursive: true });
+  const css = await readFile3(join4(pkg, "index.css"), "utf8");
+  await mkdir3(dir, { recursive: true });
   for (const [, name] of css.matchAll(/url\(\.\/files\/([^)]+)\)/g)) {
-    await cp(join3(pkg, "files", name ?? ""), join3(dir, name ?? ""));
+    await cp(join4(pkg, "files", name ?? ""), join4(dir, name ?? ""));
   }
   const declared = `${family} Variable`;
   const ours = css.replaceAll(`font-family: '${declared}'`, `font-family: '${family}'`).replaceAll("font-display: swap", family === "Inter" ? "font-display: block" : PACK_DISPLAY).replace(/url\(\.\/files\/([^)]+)\) format\('woff2-variations'\)/g, "url($1) format('woff2')");
@@ -2160,43 +2181,6 @@ async function vendorFontsource(pkgName, family, dir) {
   return ours;
 }
 
-// src/deck/playback.ts
-var PLAYER_META = "decksmith-player";
-var PLAYER_MARKER = `<meta name="${PLAYER_META}" content="2" />`;
-function markV2(page) {
-  const existing = new RegExp(`<meta name="${PLAYER_META}"[^>]*>`);
-  if (existing.test(page)) return page.replace(existing, PLAYER_MARKER);
-  const head = /<head[^>]*>/i.exec(page);
-  if (!head) throw new Error("not a deck page: it has no <head> to mark");
-  const at = head.index + head[0].length;
-  return `${page.slice(0, at)}
-    ${PLAYER_MARKER}${page.slice(at)}`;
-}
-
-// src/emit/fit.ts
-function fitOf(ink2, region) {
-  const r = (n3) => Math.round(n3 * 1e3) / 1e3;
-  return { fill: region > 0 ? r(ink2 / region) : 0, region: r(region), ink: r(ink2) };
-}
-var GROWTH = 1.6;
-function growToFit(height, budget2, lo = 1, hi = GROWTH) {
-  if (height(hi) <= budget2) return hi;
-  if (height(lo) > budget2) return lo;
-  let a = lo;
-  let b = hi;
-  for (let i = 0; i < 24; i++) {
-    const mid = (a + b) / 2;
-    if (height(mid) <= budget2) a = mid;
-    else b = mid;
-  }
-  return Math.floor(a * 128) / 128;
-}
-var MEASURE_SLACK = 0.92;
-function isV2(ctx) {
-  return ctx.design === "v2";
-}
-var FIT_FILE = "fit.json";
-
 // src/emit/archetypes/title.ts
 function isPortrait(format) {
   return format.height > format.width;
@@ -2396,6 +2380,452 @@ var title = (beat, ctx) => {
   };
 };
 
+// src/bespoke/callouts.ts
+var LABEL_PX = 56;
+var LABEL_MIN_PX = 44;
+var ZONE_H = Math.round(LABEL_PX * 1.7);
+var GAP = 12;
+var ZONE_W = 560;
+var EDGE = 8;
+var DOT_IN = 14;
+function calloutZones(subjects, W) {
+  const cx = subjects.map((s) => s.x + s.w / 2);
+  const order = cx.map((_, i) => i).sort((a, b) => cx[a] - cx[b]);
+  const zones = [];
+  order.forEach((i, rank) => {
+    const s = subjects[i];
+    const c = cx[i];
+    const left = rank > 0 ? (c - cx[order[rank - 1]]) / 2 - GAP / 2 : c - EDGE;
+    const right = rank < order.length - 1 ? (cx[order[rank + 1]] - c) / 2 - GAP / 2 : W - EDGE - c;
+    const half = Math.max(80, Math.min(ZONE_W / 2, left, right));
+    const x0 = Math.max(EDGE, Math.min(W - EDGE - 2 * half, c - half));
+    const above = s.y - GAP - ZONE_H;
+    const side = above >= EDGE ? "above" : "top";
+    const y = side === "above" ? above : Math.max(EDGE, s.y + GAP);
+    const dotY = side === "above" ? Math.min(s.y + s.h - 10, s.y + DOT_IN) : Math.min(s.y + s.h - 10, y + ZONE_H + DOT_IN);
+    zones.push({
+      subject: i + 1,
+      side,
+      x: Math.round(x0),
+      y: Math.round(y),
+      w: Math.round(2 * half),
+      h: ZONE_H,
+      dot: { x: Math.round(c), y: Math.round(dotY) }
+    });
+  });
+  return zones.sort((a, b) => a.subject - b.subject);
+}
+function halves(text2) {
+  const t2 = text2.trim();
+  const spaces = [...t2.matchAll(/ /g)].map((m) => m.index ?? 0);
+  if (spaces.length) {
+    const mid = t2.length / 2;
+    const at = spaces.reduce((a, b) => Math.abs(b - mid) < Math.abs(a - mid) ? b : a);
+    return [t2.slice(0, at), t2.slice(at + 1)];
+  }
+  const chars = [...t2];
+  if (chars.length < 4 || chars.every((c) => (c.codePointAt(0) ?? 0) < 128)) return void 0;
+  const k = Math.ceil(chars.length / 2);
+  return [chars.slice(0, k).join(""), chars.slice(k).join("")];
+}
+var plateH = (n3, fs) => Math.round(n3 === 1 ? fs * 1.6 : fs * (1.25 * n3 + 0.5));
+function fitLabel(text2, zone, theme, boxH = Infinity) {
+  const face = faceOf(theme.fontStack);
+  const w = (s, fs) => textWidth(s, fs, 700, 0, false, face) + 0.8 * fs;
+  for (let fs = LABEL_PX; fs >= LABEL_MIN_PX; fs -= 2)
+    if (w(text2, fs) <= zone.w) return { fs, lines: [text2] };
+  const two = halves(text2);
+  if (!two) return void 0;
+  for (let fs = LABEL_PX; fs >= LABEL_MIN_PX; fs -= 2) {
+    if (Math.max(w(two[0], fs), w(two[1], fs)) > zone.w) continue;
+    const h = plateH(2, fs);
+    const ok = zone.side === "above" ? zone.y + zone.h - h >= EDGE : zone.y + h <= boxH - EDGE;
+    if (ok) return { fs, lines: two };
+  }
+  return void 0;
+}
+function withZone(s, z7) {
+  if (!z7) return s;
+  const x0 = Math.min(s.x, z7.x);
+  const y0 = Math.min(s.y, z7.y);
+  const x1 = Math.max(s.x + s.w, z7.x + z7.w);
+  const y1 = Math.max(s.y + s.h, z7.y + z7.h);
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+var esc2 = (s) => s.replace(
+  /[&<>"]/g,
+  (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]
+);
+function place(label, zone, theme, boxH) {
+  const fit = fitLabel(label.text, zone, theme, boxH);
+  if (!fit) return void 0;
+  const { fs, lines } = fit;
+  const face = faceOf(theme.fontStack);
+  const pw = Math.ceil(
+    Math.max(...lines.map((l) => textWidth(l, fs, 700, 0, false, face))) + 0.8 * fs
+  );
+  const ph = plateH(lines.length, fs);
+  const cx = Math.max(zone.x + pw / 2, Math.min(zone.x + zone.w - pw / 2, zone.dot.x));
+  const py = lines.length === 1 ? zone.y + (zone.h - ph) / 2 : zone.side === "above" ? zone.y + zone.h - ph : zone.y;
+  const plate2 = { x: Math.round(cx - pw / 2), y: Math.round(py), w: pw, h: ph };
+  const lx = Math.max(plate2.x + 24, Math.min(plate2.x + plate2.w - 24, zone.dot.x));
+  const dotY = Math.max(zone.dot.y, plate2.y + plate2.h + 22);
+  return {
+    k: label.subject,
+    fs,
+    lines,
+    plate: plate2,
+    text: { x: Math.round(cx), y: Math.round(py + ph / 2) },
+    lead: { x1: lx, y1: plate2.y + plate2.h, x2: zone.dot.x, y2: dotY - 10 },
+    dot: { x: zone.dot.x, y: dotY }
+  };
+}
+function entrances(moves, subjects) {
+  const out = /* @__PURE__ */ new Map();
+  for (const m of moves)
+    if (m.subject > 0 && !out.has(m.subject)) out.set(m.subject, m.t + 0.6 * m.dur);
+  const reveal = moves.find((m, i) => m.subject === 0 && i === moves.length - 1);
+  for (let k = 1; k <= subjects; k++) if (!out.has(k)) out.set(k, reveal ? reveal.t + 0.4 : 0.5);
+  return out;
+}
+function calloutLayer(sid, labels, zones, moves, theme, W, H) {
+  const seen = /* @__PURE__ */ new Set();
+  const placed = [];
+  for (const l of labels) {
+    const z7 = zones.find((x) => x.subject === l.subject);
+    if (!z7 || seen.has(l.subject)) continue;
+    const p = place(l, z7, theme, H);
+    if (!p) continue;
+    seen.add(l.subject);
+    placed.push({ ...p, k: l.subject });
+  }
+  if (!placed.length) return { markup: "", script: "" };
+  const tone2 = [theme.tones.a, theme.tones.b, theme.tones.c, theme.tones.d];
+  const markup = `<svg class="ds-callouts" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" style="position:absolute;left:0;top:0;overflow:visible;pointer-events:none">${placed.map((p) => {
+    const lab = labels.find((l) => l.subject === p.k);
+    const len = Math.round(Math.hypot(p.lead.x2 - p.lead.x1, p.lead.y2 - p.lead.y1));
+    return `<g id="${sid}-callout${p.k}" data-subject="${p.k}"><line id="${sid}-callout${p.k}-lead" x1="${p.lead.x1}" y1="${p.lead.y1}" x2="${p.lead.x2}" y2="${p.lead.y2}" stroke="${theme.fg}" stroke-width="5" stroke-linecap="round" stroke-dasharray="${len}" stroke-dashoffset="0"/><circle id="${sid}-callout${p.k}-dot" cx="${p.dot.x}" cy="${p.dot.y}" r="11" fill="${theme.fg}" stroke="${theme.bg}" stroke-width="4"/><g id="${sid}-callout${p.k}-tag"><rect x="${p.plate.x}" y="${p.plate.y}" width="${p.plate.w}" height="${p.plate.h}" rx="${Math.round(p.fs * 0.4)}" fill="${theme.panel}" stroke="${tone2[(p.k - 1) % 4]}" stroke-width="5"/><text x="${p.text.x}" y="${p.text.y}" font-size="${p.fs}" font-weight="700" fill="${theme.fg}" text-anchor="middle" dominant-baseline="middle">${p.lines.length === 1 ? esc2(lab.text) : p.lines.map(
+      (l, i) => `<tspan x="${p.text.x}" dy="${i === 0 ? -0.625 * p.fs : 1.25 * p.fs}">${esc2(l)}</tspan>`
+    ).join("")}</text></g></g>`;
+  }).join("")}</svg>`;
+  const at = entrances(moves, Math.max(...placed.map((p) => p.k)));
+  const r2 = (n3) => Math.round(n3 * 100) / 100;
+  const lines = [
+    "// The shell's labels (src/bespoke/callouts.ts): each enters as the camera arrives on its subject."
+  ];
+  for (const p of placed) {
+    const g = JSON.stringify(`#${sid}-callout${p.k}`);
+    const tag = JSON.stringify(`#${sid}-callout${p.k}-tag`);
+    const lead = JSON.stringify(`#${sid}-callout${p.k}-lead`);
+    const dot = JSON.stringify(`#${sid}-callout${p.k}-dot`);
+    const len = Math.round(Math.hypot(p.lead.x2 - p.lead.x1, p.lead.y2 - p.lead.y1));
+    const t2 = r2(at.get(p.k) ?? 0.5);
+    lines.push(
+      `gsap.set(${g}, { opacity: 0 });`,
+      `gsap.set(${tag}, { y: 14 });`,
+      `gsap.set(${lead}, { strokeDashoffset: ${len} });`,
+      `gsap.set(${dot}, { scale: 0, transformOrigin: "50% 50%" });`,
+      `tl.fromTo(${g}, { opacity: 0 }, { opacity: 1, duration: 0.3, ease: "power2.out", immediateRender: false }, ${t2});`,
+      `tl.fromTo(${tag}, { y: 14 }, { y: 0, duration: 0.45, ease: "power3.out", immediateRender: false }, ${t2});`,
+      `tl.fromTo(${lead}, { strokeDashoffset: ${len} }, { strokeDashoffset: 0, duration: 0.4, ease: "power2.out", immediateRender: false }, ${r2(t2 + 0.1)});`,
+      `tl.fromTo(${dot}, { scale: 0, transformOrigin: "50% 50%" }, { scale: 1, duration: 0.3, ease: "back.out(2)", immediateRender: false }, ${r2(t2 + 0.4)});`
+    );
+  }
+  return { markup, script: lines.join("\n") };
+}
+
+// src/bespoke/contract.ts
+import { parse } from "acorn";
+var SID_TOKEN = "SCENEID";
+function instantiate(f, sid) {
+  const swap = (s) => s.split(SID_TOKEN).join(sid);
+  return {
+    markup: swap(f.markup),
+    css: swap(f.css),
+    script: swap(f.script),
+    ...f.shots ? { shots: f.shots } : {},
+    ...f.labels ? { labels: f.labels } : {}
+  };
+}
+var SCOPED = new RegExp(`^#${SID_TOKEN}(?![A-Za-z0-9_])`);
+var LOCAL_URL = new RegExp(`url\\(\\s*['"]?#${SID_TOKEN}-[\\w-]+['"]?\\s*\\)`, "g");
+
+// src/bespoke/shots.ts
+var CAMERA_MAX_SCALE = 2.2;
+var CLOSE_MIN = 1.6;
+var MOVE = 1.1;
+var REVEAL = 1.3;
+var MIN_HOLD = 1.6;
+var ESTABLISH = 1.6;
+var CREEP = 1.03;
+var CREEP_GAP = 0.05;
+var ART_BAND = 120;
+function artPlacement(box) {
+  return { x: 0, y: ART_BAND, w: box.width, h: Math.max(1, box.height - ART_BAND) };
+}
+function subjectsInBox(units, art, box) {
+  const at = artPlacement(box);
+  const k = Math.max(at.w / art.width, at.h / art.height);
+  const ox = at.x + (at.w - art.width * k) / 2;
+  const oy = at.y + (at.h - art.height * k) / 2;
+  const out = [];
+  for (const [ux, uy, uw, uh] of units) {
+    const x0 = ox + ux * art.width * k;
+    const y0 = oy + uy * art.height * k;
+    const x1 = x0 + uw * art.width * k;
+    const y1 = y0 + uh * art.height * k;
+    const cx0 = Math.max(at.x, x0);
+    const cy0 = Math.max(at.y, y0);
+    const cx1 = Math.min(at.x + at.w, x1);
+    const cy1 = Math.min(at.y + at.h, y1);
+    if (cx1 <= cx0 || cy1 <= cy0) continue;
+    if ((cx1 - cx0) * (cy1 - cy0) < 0.5 * (x1 - x0) * (y1 - y0)) continue;
+    out.push({
+      x: Math.round(cx0),
+      y: Math.round(cy0),
+      w: Math.round(cx1 - cx0),
+      h: Math.round(cy1 - cy0)
+    });
+  }
+  return out;
+}
+function frameOn(b, W, H) {
+  const padX = Math.max(40, 0.15 * b.w);
+  const padY = Math.max(40, 0.15 * b.h);
+  const fit = Math.min(W / (b.w + 2 * padX), H / (b.h + 2 * padY));
+  const s = Math.min(CAMERA_MAX_SCALE, Math.max(CLOSE_MIN, fit));
+  const cx = b.x + b.w / 2;
+  const cy = fit < CLOSE_MIN ? b.y - 12 + H / (2 * s) : b.y + b.h / 2;
+  const clamp3 = (v, lo) => Math.min(0, Math.max(lo, v));
+  const r = (v) => Math.round(v * 1e3) / 1e3;
+  return {
+    s: r(s),
+    x: Math.round(clamp3(W / 2 - cx * s, W - W * s)),
+    y: Math.round(clamp3(H / 2 - cy * s, H - H * s))
+  };
+}
+function defaultShots(cues, subjects) {
+  if (subjects === 0 || cues === 0) return [];
+  const out = [];
+  if (cues <= 2) {
+    out.push({ cue: 1, at: 0.5, subject: 1 });
+    if (subjects > 1 && cues === 2) out.push({ cue: 2, at: 0, subject: 2 });
+    return out;
+  }
+  for (let c = 2; c < cues; c++) out.push({ cue: c, at: 0, subject: (c - 2) % subjects + 1 });
+  return out;
+}
+function compileShots(shots, cues, duration, subjects, W, H) {
+  const n3 = cues.length;
+  if (n3 === 0 || subjects.length === 0) return [];
+  const valid = shots.filter(
+    (s) => Number.isInteger(s.cue) && s.cue >= 1 && s.cue <= n3 && Number.isInteger(s.subject) && s.subject >= 0 && s.subject <= subjects.length && Number.isFinite(s.at)
+  );
+  const list = valid.some((s) => s.subject > 0) ? valid : defaultShots(n3, subjects.length);
+  const first = cues[0];
+  const last = cues[n3 - 1];
+  const latest = Math.max(0, duration - 0.6 - REVEAL);
+  const timed = list.map((s) => {
+    const c = cues[s.cue - 1];
+    const share2 = s.at > 1 ? s.at / Math.max(0.1, c.t1 - c.t0) : s.at;
+    const at2 = Math.min(0.85, Math.max(0, share2));
+    return { t: c.t0 + at2 * (c.t1 - c.t0), subject: s.subject };
+  }).sort((a, b) => a.t - b.t);
+  const earliest = Math.min(first.t0 + ESTABLISH, Math.max(first.t0, first.t1 - MOVE));
+  const r2 = (v) => Math.round(v * 100) / 100;
+  const moves = [];
+  let at = earliest;
+  let current = 0;
+  for (const s of timed) {
+    const t2 = Math.max(s.t, at);
+    if (t2 > latest - MIN_HOLD) break;
+    if (s.subject === current) continue;
+    const f = s.subject === 0 ? { s: 1, x: 0, y: 0 } : frameOn(subjects[s.subject - 1], W, H);
+    moves.push({ t: r2(t2), dur: MOVE, ...f, ease: "power3.inOut", subject: s.subject });
+    current = s.subject;
+    at = t2 + Math.max(MIN_HOLD, MOVE + 0.5);
+  }
+  if (current !== 0) {
+    const t2 = Math.min(latest, Math.max(last.t0, at));
+    moves.push({ t: r2(t2), dur: REVEAL, s: 1, x: 0, y: 0, ease: "power2.inOut", subject: 0 });
+  }
+  return moves;
+}
+function cameraScript(sid, moves, W, H) {
+  const cam = JSON.stringify(`#${sid}-cam`);
+  const lines = [
+    "// The shell's camera (src/bespoke/shots.ts): establishing, push in, reveal.",
+    `gsap.set(${cam}, { scale: 1, x: 0, y: 0, transformOrigin: "0 0" });`
+  ];
+  const v = (f) => `scale: ${f.s}, x: ${f.x}, y: ${f.y}`;
+  const crept = (f) => ({
+    s: Math.round(f.s * CREEP * 1e3) / 1e3,
+    x: Math.round(W / 2 - (W / 2 - f.x) * CREEP),
+    y: Math.round(H / 2 - (H / 2 - f.y) * CREEP)
+  });
+  let from = { s: 1, x: 0, y: 0 };
+  let free2 = 0;
+  for (const m of moves) {
+    const start = Math.ceil((free2 + (free2 > 0 ? CREEP_GAP : 0)) * 100) / 100;
+    const hold = Math.floor((m.t - CREEP_GAP - start) * 100) / 100;
+    if (hold > 0.6) {
+      const to = crept(from);
+      lines.push(
+        `tl.fromTo(${cam}, { ${v(from)} }, { ${v(to)}, duration: ${hold}, ease: "sine.inOut", immediateRender: false }, ${start});`
+      );
+      from = to;
+    }
+    lines.push(
+      `tl.fromTo(${cam}, { ${v(from)} }, { ${v(m)}, duration: ${m.dur}, ease: "${m.ease}", immediateRender: false }, ${m.t});`
+    );
+    from = { s: m.s, x: m.x, y: m.y };
+    free2 = m.t + m.dur;
+  }
+  return lines.join("\n");
+}
+
+// src/bespoke/scene.ts
+var BODY_TOP = 34;
+function bespokeRegion(beat, ctx) {
+  const p = beat.params;
+  const face = faceOf(ctx.theme.fontStack);
+  return {
+    width: contentW(ctx.format),
+    height: Math.round(bodyBudget(ctx.format, p.eyebrow, p.headline, 0, BODY_TOP, 320, face))
+  };
+}
+function usesCamera(script) {
+  return /#[\w]+-cam(?![\w-])/.test(script);
+}
+function withArt(markup, art, box) {
+  if (!art) return markup;
+  const href = (s) => s.replace(
+    /<image\b([^>]*?)\sdata-art\s*=\s*(["']?)1\2/gi,
+    (m) => `${m} href="${artHref(art)}"`
+  );
+  if (!box) return href(markup);
+  return href(
+    markup.replace(/<image\b([^>]*?)(\/?)>/gi, (m, attrs2, close) => {
+      if (!/\sdata-art\s*=\s*(["']?)1\1/i.test(` ${attrs2}`)) return m;
+      const kept = attrs2.replace(
+        /\s(x|y|width|height|preserveAspectRatio)\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi,
+        ""
+      );
+      const at = artPlacement(box);
+      return `<image${kept} x="${at.x}" y="${at.y}" width="${at.w}" height="${at.h}" preserveAspectRatio="xMidYMid slice"${close}>`;
+    })
+  );
+}
+function subjectLayer(subjects, width, height) {
+  if (!subjects.length) return "";
+  return `<svg class="ds-subjects" aria-hidden="true" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" style="position:absolute;left:0;top:0;overflow:visible;pointer-events:none">${subjects.map(
+    (b, i) => `<rect data-ds-subject="${i + 1}" x="${b.x}" y="${b.y}" width="${b.w}" height="${b.h}" fill="none" visibility="hidden"/>`
+  ).join("")}</svg>`;
+}
+function staging(entry, box) {
+  const art = entry.art;
+  if (!art?.subjects?.length || !entry.stage) return { subjects: [], zones: [], moves: [] };
+  const subjects = subjectsInBox(art.subjects, art, box);
+  const zones = calloutZones(subjects, box.width);
+  const labelled = new Set((entry.fragment.labels ?? []).map((l) => l.subject));
+  const targets = subjects.map(
+    (s, i) => labelled.has(i + 1) ? withZone(
+      s,
+      zones.find((z7) => z7.subject === i + 1)
+    ) : s
+  );
+  const moves = compileShots(
+    entry.fragment.shots ?? [],
+    entry.stage.cues,
+    entry.stage.duration,
+    targets,
+    box.width,
+    box.height
+  );
+  return { subjects, zones, moves };
+}
+var ART_FEATHER = "-webkit-mask-image:linear-gradient(to right,transparent,#000 6%,#000 94%,transparent),linear-gradient(to bottom,transparent,#000 10%,#000 90%,transparent);-webkit-mask-composite:source-in;mask-composite:intersect";
+function usesMorph(script) {
+  return /\bmorphSVG\b/.test(script);
+}
+function bespokeScene(beat, ctx, entry) {
+  const p = beat.params;
+  const { sid, theme } = ctx;
+  const face = faceOf(theme.fontStack);
+  const f = instantiate(entry.fragment, sid);
+  const { width, height } = bespokeRegion(beat, ctx);
+  const { subjects, zones, moves } = staging(entry, { width, height });
+  const shot = moves.length ? cameraScript(sid, moves, width, height) : "";
+  const callouts = subjects.length ? calloutLayer(sid, f.labels ?? [], zones, moves, theme, width, height) : { markup: "", script: "" };
+  const script = [shot, callouts.script, f.script].filter(Boolean).join("\n");
+  const camera = usesCamera(script) || /\bviewBox\b/.test(script);
+  return {
+    html: `${chrome(sid, p.eyebrow, p.headline, contentW(ctx.format), face)}
+<div class="ds-bespoke" id="${sid}-g"${camera ? " data-ds-clip" : ""}>
+<div class="ds-cam" id="${sid}-cam">
+${withArt(f.markup, entry.art, subjects.length ? { width, height } : void 0)}
+${subjectLayer(subjects, width, height)}
+${callouts.markup}
+</div>
+</div>`,
+    tl: chromeIn(sid, p.eyebrow !== void 0),
+    script,
+    holds: entry.holds,
+    // Vendored only when a scene morphs, so no other deck carries its bytes.
+    ...usesMorph(f.script) ? { plugins: ["morphSVG"] } : {},
+    css: [
+      chromeCss(theme),
+      `#${sid}-g{position:relative;flex:none;width:${width}px;height:${height}px;margin-top:${BODY_TOP}px;color:${theme.fg}${camera ? ";overflow:hidden" : ""}}`,
+      `#${sid}-cam{position:absolute;left:0;top:0;width:${width}px;height:${height}px;transform-origin:0 0}`,
+      // The illustration's edges, feathered by the shell unless the scene masks
+      // it itself: its flat ground meets a pack ground that is often a
+      // gradient, and an unmasked picture showed as a lighter rectangle.
+      // A picture whose copy is feathered already (alpha baked in by the pass)
+      // needs none: MEASURED 2026-10-09, this CSS mask made every screenshot of
+      // its scene ~0.7s slower (13.5s against 4.1s for one scene's 13 frames).
+      ...entry.art && !entry.art.feathered ? [`#${sid}-g image[data-art]:not([mask]){${ART_FEATHER}}`] : [],
+      f.css
+    ].join("\n")
+  };
+}
+
+// src/deck/playback.ts
+var PLAYER_META = "decksmith-player";
+var PLAYER_MARKER = `<meta name="${PLAYER_META}" content="2" />`;
+function markV2(page) {
+  const existing = new RegExp(`<meta name="${PLAYER_META}"[^>]*>`);
+  if (existing.test(page)) return page.replace(existing, PLAYER_MARKER);
+  const head = /<head[^>]*>/i.exec(page);
+  if (!head) throw new Error("not a deck page: it has no <head> to mark");
+  const at = head.index + head[0].length;
+  return `${page.slice(0, at)}
+    ${PLAYER_MARKER}${page.slice(at)}`;
+}
+
+// src/emit/fit.ts
+function fitOf(ink2, region) {
+  const r = (n3) => Math.round(n3 * 1e3) / 1e3;
+  return { fill: region > 0 ? r(ink2 / region) : 0, region: r(region), ink: r(ink2) };
+}
+var GROWTH = 1.6;
+function growToFit(height, budget2, lo = 1, hi = GROWTH) {
+  if (height(hi) <= budget2) return hi;
+  if (height(lo) > budget2) return lo;
+  let a = lo;
+  let b = hi;
+  for (let i = 0; i < 24; i++) {
+    const mid = (a + b) / 2;
+    if (height(mid) <= budget2) a = mid;
+    else b = mid;
+  }
+  return Math.floor(a * 128) / 128;
+}
+var MEASURE_SLACK = 0.92;
+function isV2(ctx) {
+  return ctx.design === "v2";
+}
+var FIT_FILE = "fit.json";
+
 // src/emit/archetypes/annotated-figure.ts
 var STAGE_GAP = 30;
 var CAP_GAP = 26;
@@ -2403,7 +2833,7 @@ var CAP_LH = 1.35;
 var CAP_LINES = 2;
 var PLATE = 15;
 var LEAD = 18;
-var EDGE = 10;
+var EDGE2 = 10;
 var LAB = MIN_FONT;
 var LAB_WEIGHT = 600;
 var LAB_LH = 1.3;
@@ -2469,8 +2899,8 @@ function attempt(stageW, notes, fig, stageH, want, tall, face, sides = { l: true
   const stacks = row ? 1 : Math.max(1, Math.ceil(notes.length / 2));
   const bandMin = tall ? stacks * (ASCENT + RULE_LIFT + RULE_W) + (stacks - 1) * LAB_GAP + BAND_GAP : 0;
   const asked = Math.min(want, stageW / 3);
-  const margin = (s) => tall || !sides[s] ? EDGE : asked + LEAD + EDGE;
-  const plateMax = tall ? stageW - 2 * EDGE : stageW - margin("l") - margin("r");
+  const margin = (s) => tall || !sides[s] ? EDGE2 : asked + LEAD + EDGE2;
+  const plateMax = tall ? stageW - 2 * EDGE2 : stageW - margin("l") - margin("r");
   const scale = Math.min(
     (plateMax - 2 * PLATE) / fig.width,
     (stageH - bandMin - 2 * PLATE) / fig.height,
@@ -2487,7 +2917,7 @@ function attempt(stageW, notes, fig, stageH, want, tall, face, sides = { l: true
     // band under it, so centring it would open a gap the labels then hang off.
     y: tall ? PLATE : (stageH - fig.height * scale) / 2
   };
-  const col = row ? band[0]?.w ?? stageW : tall ? (stageW - MID_GAP) / 2 : sides.l ? img.x - PLATE - LEAD - EDGE : stageW - (img.x + img.w) - PLATE - LEAD - EDGE;
+  const col = row ? band[0]?.w ?? stageW : tall ? (stageW - MID_GAP) / 2 : sides.l ? img.x - PLATE - LEAD - EDGE2 : stageW - (img.x + img.w) - PLATE - LEAD - EDGE2;
   const stackTop = tall ? img.y + img.h + PLATE + BAND_GAP : 0;
   const room = stageH - stackTop;
   const innerOf = (side) => tall ? side === "l" ? col : stageW - col : side === "l" ? img.x - PLATE - LEAD : img.x + img.w + PLATE + LEAD;
@@ -3041,7 +3471,7 @@ function asideFor(ctx, input, railW, room) {
 }
 
 // src/emit/archetypes/bar-compare.ts
-var BODY_TOP = 34;
+var BODY_TOP2 = 34;
 var NOTE_H = noteHeight("x", MIN_FONT, 26);
 var UNIT_BAND = 58;
 var FOOT = 40;
@@ -3201,7 +3631,7 @@ var barCompare = (beat, ctx) => {
   const face = faceOf(ctx.theme.fontStack);
   const tall = isPortrait(ctx.format);
   const unitBand = p.unit ? UNIT_BAND : 0;
-  const avail = F.budget(p.note ? NOTE_H : 0, BODY_TOP, 0);
+  const avail = F.budget(p.note ? NOTE_H : 0, BODY_TOP2, 0);
   const variant = variantOf(ctx, "bar-compare");
   if (variant === "columns") return columns2(beat, ctx, F, face, avail);
   if (variant === "versus") return versus(beat, ctx, F, face, avail);
@@ -3210,7 +3640,7 @@ var barCompare = (beat, ctx) => {
   let L;
   if (v2) {
     const noteBand = p.note ? Math.max(NOTE_H, noteHeight(p.note, F.noteW * MEASURE_SLACK, 26, face)) : 0;
-    const grownAvail = F.budget(noteBand, BODY_TOP, 0);
+    const grownAvail = F.budget(noteBand, BODY_TOP2, 0);
     try {
       L = barLayout({ ...args, avail: grownAvail, caps: GROWN });
     } catch {
@@ -3414,7 +3844,7 @@ ${svg(id(sid, "chart"), W, H, body)}
   }
   if (p.unit || p.note) holds.push(tailAt + 0.7);
   const region = F.budget(0, 0, 0);
-  const fit = v2 ? { fit: fitOf(p.note ? region - BODY_TOP : H, region) } : {};
+  const fit = v2 ? { fit: fitOf(p.note ? region - BODY_TOP2 : H, region) } : {};
   return {
     html,
     tl,
@@ -3423,7 +3853,7 @@ ${svg(id(sid, "chart"), W, H, body)}
     fill: Math.min(1, H / avail),
     css: [
       chromeCss(theme),
-      `.bc-wrap{margin-top:${BODY_TOP}px}`,
+      `.bc-wrap{margin-top:${BODY_TOP2}px}`,
       // Scoped to the scene, so a classic scene in the same document — there is
       // none today, but the dedup set does not know that — keeps its centring.
       ...v2 && p.note ? [`#${sid} .bc-wrap{margin-bottom:auto}`] : [],
@@ -3646,7 +4076,7 @@ ${svg(id(sid, "chart"), W, H, body)}
     fill: Math.min(1, H / avail),
     css: [
       chromeCss(theme),
-      `.bc-wrap{margin-top:${BODY_TOP}px}`,
+      `.bc-wrap{margin-top:${BODY_TOP2}px}`,
       `.bc-rail{fill:${theme.panel}}`,
       noteCss("bc-note", theme, 26),
       ambient(sid, `-bar${focal.i}`, BREATHE),
@@ -3865,7 +4295,7 @@ ${svg(id(sid, "chart"), W, Math.max(H, avail), body)}
     fill: Math.min(1, H / avail),
     css: [
       chromeCss(theme),
-      `.bc-wrap{margin-top:${BODY_TOP}px}`,
+      `.bc-wrap{margin-top:${BODY_TOP2}px}`,
       `.bc-rail{fill:${theme.panel}}`,
       noteCss("bc-note", theme, 26),
       ambient(sid, `-bar${focal.i}`, BREATHE),
@@ -5004,6 +5434,7 @@ ${slide}`;
   const holds = [];
   const spot = spotlighter(sid, ".term");
   const swell = (t2) => raw(`dsSwell.${t2.tone}`);
+  const later = v2 ? { immediateRender: false } : {};
   terms.forEach((term, i) => {
     const at = first + i * step;
     const colour = theme.tones[term.tone];
@@ -5027,7 +5458,12 @@ ${slide}`;
     const prev = terms[i - 1];
     if (prev) {
       tl.push(
-        tween(`#${sid} .t-${prev.tone}`, { scale: swell(prev) }, { scale: 1, duration: 0.4 }, at)
+        tween(
+          `#${sid} .t-${prev.tone}`,
+          { scale: swell(prev) },
+          { scale: 1, duration: 0.4, ...later },
+          at
+        )
       );
     }
     holds.push(at + 0.6);
@@ -5036,7 +5472,12 @@ ${slide}`;
   if (last) {
     const at = first + terms.length * step;
     tl.push(
-      tween(`#${sid} .t-${last.tone}`, { scale: swell(last) }, { scale: 1, duration: 0.4 }, at),
+      tween(
+        `#${sid} .t-${last.tone}`,
+        { scale: swell(last) },
+        { scale: 1, duration: 0.4, ...later },
+        at
+      ),
       ...spot.restore(at)
     );
   }
@@ -5259,7 +5700,7 @@ var equationMorph = (beat, ctx) => {
 var LABEL = 42;
 var LH = 1.25;
 var PAD = 16;
-var GAP = 0.14;
+var GAP2 = 0.14;
 var CELL_MAX2 = 280;
 var MARGIN = 6;
 var MAX_LINES = 2;
@@ -5275,8 +5716,8 @@ function noteColumn(note, size, face) {
 function solveCell(cols, rows, boxW, boxH) {
   return Math.min(
     CELL_MAX2,
-    (boxW - 2 * MARGIN) / (cols + GAP * (cols - 1)),
-    (boxH - 2 * MARGIN) / (rows + GAP * (rows - 1))
+    (boxW - 2 * MARGIN) / (cols + GAP2 * (cols - 1)),
+    (boxH - 2 * MARGIN) / (rows + GAP2 * (rows - 1))
   );
 }
 var grid = (beat, ctx) => {
@@ -5305,7 +5746,7 @@ var grid = (beat, ctx) => {
   );
   const solve3 = (boxW, budget3) => {
     const cell = solveCell(p.cols, p.rows, boxW, budget3);
-    const gap = cell * GAP;
+    const gap = cell * GAP2;
     return {
       cell,
       gap,
@@ -5881,10 +6322,10 @@ var lineChart = (beat, ctx) => {
   }
   const walk = cmp ? sec(step * count2) : DRAW_SECONDS;
   if (count2 > 1) {
-    const route = p.points.map((pt, i) => ({ x: nv(x(i) - first.x), y: nv(y(pt.y) - first.y) }));
+    const route2 = p.points.map((pt, i) => ({ x: nv(x(i) - first.x), y: nv(y(pt.y) - first.y) }));
     tl.push(
       tween(`#${sid}-ring`, { opacity: 0 }, { opacity: 1, duration: 0.25 }, settled),
-      ...travel(`#${sid}-ring`, route, settled, walk),
+      ...travel(`#${sid}-ring`, route2, settled, walk),
       // And it leaves once the curve is whole: a marker parked on the last
       // point for the rest of the beat reads as a defect, not as emphasis.
       tween(
@@ -5984,7 +6425,7 @@ var NOTE_TOP = 16;
 var PAD_X_EM = 0.45;
 var PAD_Y2 = 34;
 var MIN_BOX_H = 172;
-var GAP2 = 120;
+var GAP3 = 120;
 var MIN_GAP = 30;
 var MAX_BOX_W = 430;
 var MAX_BOX_H = 340;
@@ -6131,7 +6572,7 @@ function fitAt(stages, k, width, stageW, face, size = LABEL2, noteK = k, split =
     ),
     width,
     size,
-    gap: GAP2,
+    gap: GAP3,
     minGap: MIN_GAP,
     padEm: PAD_X_EM,
     weight: 600,
@@ -6146,7 +6587,7 @@ function solve(stages, width, stageW, face, size = LABEL2) {
 function pipeLayout(stageW, stages, loop, face = "latin", grow) {
   const width = stageW - 2 * M;
   if (grow) return grownRow(stageW, stages, loop, face, grow);
-  const capped = Math.min(width, stages.length * MAX_BOX_W + (stages.length - 1) * GAP2);
+  const capped = Math.min(width, stages.length * MAX_BOX_W + (stages.length - 1) * GAP3);
   let fit = solve(stages, capped, stageW, face);
   if (!fit.ok && capped < width) fit = solve(stages, width, stageW, face);
   const row = measureRow(fit, stages, loop, face, stageW, width);
@@ -6191,7 +6632,7 @@ function measureRow(fit, stages, loop, face, stageW, width, grow) {
 }
 function grownRow(stageW, stages, loop, face, grow) {
   const width = stageW - 2 * M;
-  const capped = Math.min(width, stages.length * GROWN_BOX_W + (stages.length - 1) * GAP2);
+  const capped = Math.min(width, stages.length * GROWN_BOX_W + (stages.length - 1) * GAP3);
   const preferred = LABEL2 * GROWTH;
   let best;
   for (const span of capped < width ? [capped, width] : [width]) {
@@ -6342,7 +6783,7 @@ var pipeline = (beat, ctx) => {
     const selfSpan = loop.self ? Math.min((L.boxes[loop.from]?.w ?? 200) * 0.55, 180) : 0;
     const leaveAt = cx(loop.from) + selfSpan / 2;
     const landAt = cx(loop.to) - selfSpan / 2;
-    const route = elbow(
+    const route2 = elbow(
       sid,
       L.vertical ? { x: edge, y: leaveAt } : { x: leaveAt, y: edge },
       L.vertical ? { x: edge, y: landAt } : { x: landAt, y: edge },
@@ -6369,7 +6810,7 @@ var pipeline = (beat, ctx) => {
     const a0 = Math.max(0, Math.min(cx(loop.to) - 30, mid - half));
     sweep = Math.min(span, Math.max(cx(loop.from) + 30, mid + half)) - a0;
     const clip3 = L.vertical ? { x: 0, y: a0, w: W, h: sweep } : { x: a0, y: 0, w: sweep, h: L.svgH };
-    loopSvg = `<defs><clipPath id="${id(sid, "loopclip")}">${rect(clip3, { id: id(sid, "sweep") })}</clipPath></defs>` + group([route, label], { "clip-path": `url(#${id(sid, "loopclip")})` });
+    loopSvg = `<defs><clipPath id="${id(sid, "loopclip")}">${rect(clip3, { id: id(sid, "sweep") })}</clipPath></defs>` + group([route2, label], { "clip-path": `url(#${id(sid, "loopclip")})` });
   }
   const body = [
     arrowDefs(sid, loop ? [theme.muted, loopColour] : [theme.muted]),
@@ -6909,7 +7350,7 @@ function depthCss(sid, pose, part) {
 }
 
 // src/emit/archetypes/stack.ts
-var GAP3 = 44;
+var GAP4 = 44;
 var NUM_X = 48;
 function numSpine(floor) {
   return Math.round(NUM_X * floor * 100 / MIN_FONT) / 100;
@@ -6922,7 +7363,7 @@ var RISE_MAX = { wide: 180, tall: 230 };
 var RISE_MIN = 24;
 var SY_MAX = { wide: 100, tall: 132 };
 var T_MAX = { wide: 18, tall: 24 };
-var EDGE2 = 10;
+var EDGE3 = 10;
 var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
 function stackLayout(p, format, face = "latin", grow = false) {
   if (grow) {
@@ -6989,7 +7430,7 @@ function solve2(p, format, inline2, face, growth = 1) {
       (l) => inline2 ? Math.max(l.label.length * labelSize, l.note.length * floor) * 1.16 : l.label.length * labelSize * 1.16 + (l.note.length > 0 ? 6 + l.note.length * floor * 1.16 : 0)
     )
   );
-  const pad = Math.max(EDGE2, blockH / 2);
+  const pad = Math.max(EDGE3, blockH / 2);
   const chromeH = chromeHeight(p.eyebrow, p.headline, width, face);
   const noteH = noteHeight(p.note, noteWidth(format), 28, face);
   const free2 = boxH - chromeH - 20 - noteH;
@@ -6998,7 +7439,7 @@ function solve2(p, format, inline2, face, growth = 1) {
   const rise = clamp(room, RISE_MIN, riseMax);
   const sy = clamp(rise * 0.62, 46, syMax);
   const t2 = clamp(rise * 0.14, 10, tMax);
-  const span = width - NUM_W - GAP3 - colW;
+  const span = width - NUM_W - GAP4 - colW;
   const sx = clamp(span * 0.2, 110, 220);
   const height = 2 * pad + (count2 - 1) * rise + sy + t2;
   return {
@@ -7158,12 +7599,12 @@ var stack = (beat, ctx) => {
     holds.push(at + 0.62);
   });
   if (mids.length > 1) {
-    const route = mids.map((mid) => ({ x: 0, y: nv(mid - probeY) }));
+    const route2 = mids.map((mid) => ({ x: 0, y: nv(mid - probeY) }));
     const walkFrom = first + 0.3;
     const walkTo = first + (mids.length - 1) * step + 0.55;
     tl.push(
       tween(`#${sid}-probe`, { opacity: 0 }, { opacity: 1, duration: 0.3 }, walkFrom),
-      ...travel(`#${sid}-probe`, route, walkFrom, Math.max(0.4, walkTo - walkFrom))
+      ...travel(`#${sid}-probe`, route2, walkFrom, Math.max(0.4, walkTo - walkFrom))
     );
   }
   if (p.note) {
@@ -7218,6 +7659,8 @@ var emitters = {
   callout
 };
 function emitScene(beat, ctx) {
+  const bespoke = ctx.bespoke?.[beat.id];
+  if (bespoke) return bespokeScene(beat, ctx, bespoke);
   return emitters[beat.archetype](beat, ctx);
 }
 
@@ -7798,7 +8241,15 @@ var beatCore = {
   /** Salience, 0–1. Decides what survives a 30-second cut. */
   weight: z.number().min(0).max(1).default(0.5),
   /** Seconds this beat holds in a linear render. Deck mode is human-paced. */
-  seconds: z.number().positive().max(60).default(7)
+  seconds: z.number().positive().max(60).default(7),
+  /**
+   * OPTIONAL, and only read by `build --design v2 --bespoke`: the planner's hint
+   * that this beat explains a mechanism worth a generated scene (`true`), or
+   * must keep its archetype (`false`). A hint, not an order — see
+   * src/bespoke/select.ts. Hidden from the planner's schema unless the plan was
+   * asked for with `--bespoke`, so every other plan is byte-for-byte unchanged.
+   */
+  bespoke: z.boolean().optional()
 };
 var beatTail = {
   /** What the presenter says over this beat. Written last, knowing the picture. */
@@ -8046,7 +8497,50 @@ var prefsSchema = z.object({
      * Zero is legal and means "every picture by the tool".
      */
     max: z.int().min(0).default(4)
-  }).default({ enabled: false, provider: "codex", style: "flat vector illustration", max: 4 })
+  }).default({ enabled: false, provider: "codex", style: "flat vector illustration", max: 4 }),
+  /* --- bespoke scenes --- */
+  /**
+   * `--design v2` only: a few beats per deck drawn by a model-written GSAP+SVG
+   * scene instead of their archetype (src/bespoke/). OPTIONAL WITH NO DEFAULT,
+   * unlike the two blocks above, and that is deliberate: a resolved prefs
+   * object travels into `.deck` manifests, and a defaulted block would move the
+   * bytes of every pack built without it.
+   */
+  bespoke: z.object({
+    enabled: z.boolean().default(false),
+    /** Hard cap on Codex calls for one deck. Each bespoke beat costs two. */
+    maxCalls: z.int().min(0).max(40).default(12),
+    /** Hard cap on the bespoke pass's wall time, seconds. */
+    maxSeconds: z.int().min(60).max(7200).default(1800),
+    /** Passed to `codex exec --model`. Absent: whatever the account is configured for. */
+    model: z.string().optional(),
+    /** The Codex CLI to run. Absent: `codex` on PATH. */
+    cli: z.string().optional(),
+    /** Where generated scenes are cached. Absent: the user cache directory. */
+    cache: z.string().optional(),
+    /**
+     * Codex calls in flight at once. Five: MEASURED 2026-10-08, a deck's
+     * five drafts at three in flight took two waves (252s) where one wave is
+     * ~150s, and the second wave alone put the pass over ten minutes. Still
+     * bounded by `maxCalls` per deck.
+     */
+    concurrency: z.int().min(1).max(8).default(5),
+    /**
+     * `model_reasoning_effort` for the bespoke calls. MEASURED 2026-10-08, one
+     * draft prompt, tools off: medium 166s and 24k tokens, high 371s and 50k.
+     * The references and the gates carry the look; the extra reasoning bought
+     * time. Absent from a config file means medium; "default" leaves the
+     * account's own setting.
+     */
+    effort: z.enum(["low", "medium", "high", "default"]).default("medium"),
+    /**
+     * Illustrations per deck: each bespoke beat may first have ONE picture
+     * drawn by the same account's image tool (src/bespoke/art.ts), which its
+     * scene is built around. 0 turns them off. Counted apart from `maxCalls`:
+     * MEASURED 2026-10-09, one picture is 36-49s and 19-25k tokens.
+     */
+    art: z.int().min(0).max(6).default(6)
+  }).optional()
 });
 var cueSchema = z.object({
   /** Seconds from the start of this segment's audio. */
@@ -8239,9 +8733,9 @@ function resizeFormat(base, width, height) {
 // src/narrate/tts.ts
 import { spawn } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir3, readFile as readFile3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, rm, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 var MISSING = [
   "edge-tts is not installed, so narration cannot be synthesised.",
   "",
@@ -8258,8 +8752,8 @@ function candidates2() {
     ["edge-tts"],
     // pip --user on macOS and on Linux respectively. Neither is on PATH by
     // default, and both are where this actually lands in practice.
-    [join4(home, "Library", "Python", "3.9", "bin", "edge-tts")],
-    [join4(home, ".local", "bin", "edge-tts")],
+    [join5(home, "Library", "Python", "3.9", "bin", "edge-tts")],
+    [join5(home, ".local", "bin", "edge-tts")],
     // Last resort: the module is installed even though its console script is
     // nowhere findable, which is the normal state of a pip --user install.
     ["python3", "-m", "edge_tts"]
@@ -8284,7 +8778,7 @@ async function find(can) {
   throw new Error(MISSING);
 }
 function runArgv(cmd, args) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -8294,8 +8788,8 @@ function runArgv(cmd, args) {
     child.stderr.on("data", (b) => {
       stderr += b.toString();
     });
-    child.on("error", (e) => resolve9({ code: -1, stderr: String(e), stdout }));
-    child.on("close", (code) => resolve9({ code: code ?? -1, stderr, stdout }));
+    child.on("error", (e) => resolve10({ code: -1, stderr: String(e), stdout }));
+    child.on("close", (code) => resolve10({ code: code ?? -1, stderr, stdout }));
   });
 }
 var edgeTts = {
@@ -8362,7 +8856,7 @@ function edgeProvider(runner = edgeTts) {
     async speak(req) {
       const subs = `${req.audio.replace(/\.mp3$/, "")}.srt`;
       await runner.speak({ ...req, subs });
-      const raw2 = await readFile3(subs, "utf8").catch(() => "");
+      const raw2 = await readFile4(subs, "utf8").catch(() => "");
       await rm(subs, { force: true });
       const cues = parseCues(raw2);
       const measured = await runner.measure(req.audio);
@@ -8380,11 +8874,11 @@ async function synthesize(text2, opts) {
   const provider = opts.provider ?? edgeProvider(opts.runner ?? edgeTts);
   const key = cacheKey(text2, opts.voice, rate, pitch);
   const file = `${key}.mp3`;
-  const audio = join4(opts.dir, file);
-  const sidecar = join4(opts.dir, `${key}.json`);
+  const audio = join5(opts.dir, file);
+  const sidecar = join5(opts.dir, `${key}.json`);
   const cached2 = await readSidecar(sidecar);
   if (cached2) return { audio, file, seconds: cached2.seconds, cues: cached2.cues };
-  await mkdir3(opts.dir, { recursive: true });
+  await mkdir4(opts.dir, { recursive: true });
   const spoken = await provider.speak({ text: text2, voice: opts.voice, rate, pitch, audio });
   const { cues, seconds } = spoken;
   const clamped = cues.map((c) => ({
@@ -8393,13 +8887,13 @@ async function synthesize(text2, opts) {
     text: c.text
   }));
   const body = { seconds, cues: clamped, text: text2, voice: opts.voice };
-  await writeFile3(sidecar, `${JSON.stringify(body, null, 2)}
+  await writeFile4(sidecar, `${JSON.stringify(body, null, 2)}
 `);
   return { audio, file, seconds, cues: clamped };
 }
 async function readSidecar(path2) {
   try {
-    const parsed = JSON.parse(await readFile3(path2, "utf8"));
+    const parsed = JSON.parse(await readFile4(path2, "utf8"));
     const s = parsed;
     return typeof s?.seconds === "number" && s.seconds > 0 && Array.isArray(s.cues) ? s : null;
   } catch {
@@ -8576,7 +9070,7 @@ function assertNarrationStaging(narration, staged, format) {
 
 // src/pack/media.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { extname } from "node:path";
 var PLAYERS = [
   "youtube.com",
@@ -8785,7 +9279,7 @@ async function fetchAsset(url) {
       mime: res.headers.get("content-type") ?? void 0
     };
   }
-  return { bytes: new Uint8Array(await readFile4(url)) };
+  return { bytes: new Uint8Array(await readFile5(url)) };
 }
 
 // src/plan/direct.ts
@@ -9332,15 +9826,15 @@ function fnv1a2(s) {
 var RISE_SHARE = 0.25;
 function planMotion(seed, beats) {
   const n3 = beats.length;
-  const entrances = [];
+  const entrances2 = [];
   const riseCap = Math.floor(n3 * RISE_SHARE);
   let rises = 0;
   for (const [i, beat] of beats.entries()) {
-    const prev = entrances[i - 1];
+    const prev = entrances2[i - 1];
     const allowed = ENTRANCES.filter((v) => v !== prev && (v !== "rise" || rises < riseCap));
     const pick = allowed[fnv1a2(`${seed}|enter|${beat.id}|${i}`) % allowed.length];
     if (pick === "rise") rises++;
-    entrances.push(pick);
+    entrances2.push(pick);
   }
   const seams = [];
   for (let i = 0; i + 1 < n3; i++) {
@@ -9371,7 +9865,7 @@ function planMotion(seed, beats) {
     const start = fnv1a2(`${seed}|emph|${beat.id}|${i}`) % EMPHASES.length;
     return EMPHASES.map((_, k) => EMPHASES[(start + k) % EMPHASES.length]);
   });
-  return { entrances, seams, emphases };
+  return { entrances: entrances2, seams, emphases };
 }
 function ensureSeamKinds(seams, want) {
   const kinds = () => new Set(seams.filter((s) => s !== "dive"));
@@ -9876,8 +10370,9 @@ function layout(storyboard, source, format, options = {}) {
     };
     const segments2 = opts.narration?.beats[beat.id];
     const emitted = emitScene(beat, ctx);
+    const bespoke = opts.bespoke?.[beat.id] !== void 0;
     const { scene } = stageScene(
-      motion ? restyleEntrance(emitted, sid, motion.entrances[i] ?? "rise") : emitted,
+      motion && !bespoke ? restyleEntrance(emitted, sid, motion.entrances[i] ?? "rise") : emitted,
       speed
     );
     const seconds = beatSeconds(beat.seconds * speed, scene, segments2);
@@ -9886,7 +10381,7 @@ function layout(storyboard, source, format, options = {}) {
     const duration = dive ? seconds + diveTail(dive) : seconds;
     const start = at;
     at += duration;
-    return { beat, sid, scene, segments: segments2, inside, dive, duration, start, seconds };
+    return { beat, sid, scene, segments: segments2, inside, dive, duration, start, seconds, bespoke };
   });
   let builds = false;
   const plugins = /* @__PURE__ */ new Set();
@@ -9967,11 +10462,17 @@ function layout(storyboard, source, format, options = {}) {
     } : void 0,
     looks,
     motion,
-    holdMotion
+    holdMotion,
+    // Whether any scene runs generated code — the one thing that puts a CSP in
+    // the head. Classic and plain v2 decks never set it, so their heads are unchanged.
+    scripted: cuts.some((c) => c.bespoke)
   };
 }
 function design(opts) {
-  return opts.design ? { design: opts.design } : {};
+  return {
+    ...opts.design ? { design: opts.design } : {},
+    ...opts.bespoke ? { bespoke: opts.bespoke } : {}
+  };
 }
 function withMotion(motion, i, cut, scene, accent, speed, holdMotion) {
   const { sid } = cut;
@@ -9983,7 +10484,17 @@ function withMotion(motion, i, cut, scene, accent, speed, holdMotion) {
     const incoming = Number.isFinite(firstHold) ? seamIn(before, sid, over, firstHold) : [];
     if (incoming.length) out = { ...out, tl: [...out.tl, ...incoming] };
   }
-  if (cut.segments?.length) {
+  if (cut.segments?.length && cut.bespoke) {
+    const windows = bespokeWindows(out, cut.segments, cut.seconds);
+    if (windows.length) {
+      holdMotion[sid] = windows.map((w) => ({
+        stop: w.stop,
+        at: rnd(cut.start + w.at),
+        from: rnd(cut.start + w.from),
+        to: rnd(cut.start + w.to)
+      }));
+    }
+  } else if (cut.segments?.length) {
     const { scene: emphasised, windows } = emphasize(out, sid, {
       segments: cut.segments,
       starts: spokenStarts(out, cut.segments).starts,
@@ -10003,6 +10514,23 @@ function withMotion(motion, i, cut, scene, accent, speed, holdMotion) {
   }
   return out;
 }
+function bespokeWindows(scene, segments2, end) {
+  const holds = [...new Set(scene.holds.filter((h) => Number.isFinite(h) && h > 0))].sort(
+    (a, b) => a - b
+  );
+  const { starts } = spokenStarts(scene, segments2);
+  const out = [];
+  segments2.forEach((segment2, i) => {
+    const index = Math.min(segment2.stop, holds.length - 1);
+    const at = holds[index];
+    if (at === void 0) return;
+    const next = holds[index + 1];
+    const to = rnd((next ?? end) - 1e-3);
+    if (to <= at) return;
+    out.push({ stop: segment2.stop, at, from: rnd(starts[i] ?? at), to });
+  });
+  return out;
+}
 function motionIsland(holds) {
   const json = JSON.stringify({ version: 1, seams: true, holds }, null, 2).replace(/</g, "\\u003c");
   return `
@@ -10099,7 +10627,8 @@ ${emitIsland(slides)}` : "";
   return `<!doctype html>
 <html lang="${esc(storyboard.lang)}" data-resolution="${orientation}">
   <head>
-    <meta charset="UTF-8" />
+    <meta charset="UTF-8" />${laid.scripted ? `
+    <meta http-equiv="Content-Security-Policy" content="${BESPOKE_CSP}" />` : ""}
     <title>${esc(storyboard.title)}</title>
     <meta name="viewport" content="width=${format.width}, height=${format.height}" />
     <script src="${GSAP_SRC}"></script>
@@ -10136,6 +10665,17 @@ ${scenes.join("\n")}
 </html>
 `;
 }
+var BESPOKE_CSP = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; media-src 'self' data: blob:; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
+function bespokeCall(sid, script) {
+  return `try {
+  (function (tl, root) {
+    "use strict";
+${closeSafe(script)}
+  })(tl, document.getElementById("${sid}"));
+} catch (e) {
+  console.error("decksmith bespoke #${sid}: " + (e && e.message));
+}`;
+}
 function buildingFlag() {
   return `
     <script>window.__hfTimelinesBuilding = true;</script>`;
@@ -10234,6 +10774,9 @@ function sceneHtml(sid, start, clip3, label, scene, transit) {
     `// times relative to its start \u2014 one absolute root timeline yields a`,
     `// deck the slideshow controller cannot bind to.`,
     `var tl = gsap.timeline({ paused: true });`,
+    // A bespoke scene's generated script, checked before it got here. Before
+    // the shell's tweens so its `gsap.set` baselines are in place first.
+    ...scene.script ? [bespokeCall(sid, scene.script)] : [],
     // `tweenText` is the ONLY place a tween becomes GSAP source. Everything
     // above this line is a typed object the checker can see; below it is text.
     ...scene.tl.map(tweenText),
@@ -10288,11 +10831,9 @@ function rnd(n3) {
 var AFFINITY = {
   signal: { quantity: 0.6, frame: 0.3 },
   blueprint: { structure: 0.7, formal: 0.2 },
-  atlas: { frame: 0.6, structure: 0.2 },
-  folio: { formal: 0.8, frame: 0.2 },
-  chalk: { quantity: 0.5, structure: 0.4 },
-  journal: { formal: 0.4, frame: 0.4 }
+  atlas: { frame: 0.6, structure: 0.2 }
 };
+var PICKED = Object.keys(PACKS).filter((n3) => PACKS[n3]?.ground === "dark");
 function fnv1a3(text2) {
   let h = 2166136261;
   for (let i = 0; i < text2.length; i++) {
@@ -10309,7 +10850,7 @@ function mix(beats) {
 function packWeights(beats) {
   const m = mix(beats);
   const out = {};
-  for (const name of Object.keys(PACKS)) {
+  for (const name of PICKED) {
     const a = AFFINITY[name] ?? {};
     out[name] = 1 + Object.entries(a).reduce((s, [f, w]) => s + (w ?? 0) * m[f], 0);
   }
@@ -10321,7 +10862,7 @@ function rankPacks(beats, seed) {
     const u = (fnv1a3(`${seed}\0${name}`) + 0.5) / 2 ** 32;
     return -Math.log(u) / (weights[name] ?? 1);
   };
-  return Object.keys(PACKS).map((name) => ({ name, d: draw2(name) })).sort((a, b) => a.d - b.d || (a.name < b.name ? -1 : 1)).map((r) => r.name);
+  return PICKED.map((name) => ({ name, d: draw2(name) })).sort((a, b) => a.d - b.d || (a.name < b.name ? -1 : 1)).map((r) => r.name);
 }
 function chooseLook(c) {
   if (c.stated) return c.stated;
@@ -10445,8 +10986,15 @@ function readFragments(html) {
   }
   return out;
 }
-function holdsFor(beat, source, format, theme, sid, speed) {
-  const ctx = { source, format, theme, sid, start: 0 };
+function holdsFor(beat, source, format, theme, sid, speed, bespoke) {
+  const ctx = {
+    source,
+    format,
+    theme,
+    sid,
+    start: 0,
+    ...bespoke ? { bespoke } : {}
+  };
   const { scene, open } = stageScene(emitScene(beat, ctx), speed);
   return {
     holds: [...new Set(scene.holds.filter((h) => Number.isFinite(h) && h > 0))].sort(
@@ -10467,7 +11015,7 @@ function assertHoldsAgree(scenes, fragments) {
     }
   }
 }
-function place(scenes, spoken) {
+function place2(scenes, spoken) {
   const out = [];
   for (const scene of scenes) {
     const segments2 = [...spoken[scene.id] ?? []].sort((a, b) => a.stop - b.stop);
@@ -10536,10 +11084,10 @@ function planTiming(input) {
   const stops = /* @__PURE__ */ new Map();
   beats.forEach((beat, i) => {
     const scene = scenes[i];
-    const staging = holdsFor(beat, source, format, theme, scene.id, speed);
-    scene.holds = staging.holds;
-    scene.open = staging.open;
-    stops.set(beat.id, stopCount(staging.holds));
+    const staging2 = holdsFor(beat, source, format, theme, scene.id, speed, input.bespoke);
+    scene.holds = staging2.holds;
+    scene.open = staging2.open;
+    stops.set(beat.id, stopCount(staging2.holds));
     const segments3 = narration?.beats[beat.id];
     if (segments3?.length) spoken[scene.id] = segments3;
   });
@@ -10551,7 +11099,7 @@ function planTiming(input) {
       fragments
     );
   }
-  const segments2 = place(scenes, spoken);
+  const segments2 = place2(scenes, spoken);
   assertFits(scenes, segments2);
   return {
     version: 1,
@@ -10866,8 +11414,8 @@ function textOf(node) {
 
 // src/source/harvest.ts
 import { createHash as createHash6 } from "node:crypto";
-import { copyFile, mkdir as mkdir5, rm as rm3, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename3, join as join7, resolve as resolve3 } from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir6, rm as rm3, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename3, join as join8, resolve as resolve4 } from "node:path";
 
 // src/net/fetch.ts
 import { lookup as resolveHost } from "node:dns/promises";
@@ -10929,10 +11477,10 @@ function expandV6(v6) {
     const head = text2.slice(0, text2.length - quad[1].length);
     text2 = `${head}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`;
   }
-  const halves = text2.split("::");
-  if (halves.length > 2) return null;
-  const left = halves[0] ? halves[0].split(":") : [];
-  const right = halves.length === 2 ? halves[1] ? halves[1].split(":") : [] : null;
+  const halves2 = text2.split("::");
+  if (halves2.length > 2) return null;
+  const left = halves2[0] ? halves2[0].split(":") : [];
+  const right = halves2.length === 2 ? halves2[1] ? halves2[1].split(":") : [] : null;
   const fill = 8 - left.length - (right?.length ?? 0);
   if (right !== null && fill < 0) return null;
   const parts = right === null ? left : [...left, ...new Array(fill).fill("0"), ...right];
@@ -11067,8 +11615,8 @@ async function send(url, target, headers, signal2, opts) {
     ...secure && isIP(host2) === 0 ? { servername: host2 } : {}
   };
   try {
-    return await new Promise((resolve9, reject) => {
-      const req = (secure ? httpsRequest : httpRequest)(options, resolve9);
+    return await new Promise((resolve10, reject) => {
+      const req = (secure ? httpsRequest : httpRequest)(options, resolve10);
       req.on("error", reject);
       req.end();
     });
@@ -11152,7 +11700,7 @@ function message(err) {
 
 // src/render/capture.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function resolveChrome(need = "open the deck with") {
   const env2 = process.env.HYPERFRAMES_BROWSER_PATH || process.env.DECKSMITH_CHROME || process.env.CHROME_PATH;
   if (env2) return { path: env2, source: "env" };
@@ -11162,9 +11710,9 @@ async function resolveChrome(need = "open the deck with") {
     const ordered = [...installed2].sort((a, b) => b.buildId.localeCompare(a.buildId, "en"));
     return ordered.find((b) => b.browser === "chrome-headless-shell") ?? ordered.find((b) => b.browser === "chrome");
   };
-  const hf = await pick(join5(homedir2(), ".cache", "hyperframes", "chrome"));
+  const hf = await pick(join6(homedir2(), ".cache", "hyperframes", "chrome"));
   if (hf) return { path: hf.executablePath, source: "hyperframes" };
-  const pup = await pick(process.env.PUPPETEER_CACHE_DIR || join5(homedir2(), ".cache", "puppeteer"));
+  const pup = await pick(process.env.PUPPETEER_CACHE_DIR || join6(homedir2(), ".cache", "puppeteer"));
   if (pup) return { path: pup.executablePath, source: "puppeteer" };
   throw new Error(
     `no Chrome to ${need} \u2014 run \`npx puppeteer browsers install chrome\`, or set DECKSMITH_CHROME to a Chrome binary.`
@@ -11192,12 +11740,12 @@ async function launchOwnPage(launch, args, what) {
 
 // src/source/assets.ts
 import { createHash as createHash5 } from "node:crypto";
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { extname as extname2, join as join6 } from "node:path";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
+import { extname as extname2, join as join7 } from "node:path";
 import { z as z2 } from "zod";
 async function fetchFigures(source, dir, warnings) {
   const drops = warnings ?? [];
-  await mkdir4(dir, { recursive: true });
+  await mkdir5(dir, { recursive: true });
   const cached2 = await readdir2(dir).catch(() => []);
   const figures = [];
   for (const figure of source.figures) {
@@ -11223,11 +11771,11 @@ async function fetchFigures(source, dir, warnings) {
 async function localize(figure, dir, cached2) {
   const stem = assetStem(figure.id, figure.src);
   const hit = cached2.find((name) => name.startsWith(`${stem}.`));
-  const bytes = hit ? await readFile5(join6(dir, hit)) : await load(figure.src);
+  const bytes = hit ? await readFile6(join7(dir, hit)) : await load(figure.src);
   const size = imageSize(bytes);
   if (hit) return { ...figure, src: hit, ...size };
   const src = `${stem}${assetExt(bytes, figure.src)}`;
-  await writeFile4(join6(dir, src), bytes);
+  await writeFile5(join7(dir, src), bytes);
   cached2.push(src);
   return { ...figure, src, ...size };
 }
@@ -11252,7 +11800,7 @@ function assetExt(bytes, src) {
 var FIGURE_MAX_BYTES = 32 * 1024 * 1024;
 var FIGURE_TIMEOUT_MS = 2e4;
 async function load(src) {
-  if (!/^https?:/i.test(src)) return readFile5(src);
+  if (!/^https?:/i.test(src)) return readFile6(src);
   const got = await fetchGuarded(src, {
     maxBytes: FIGURE_MAX_BYTES,
     timeoutMs: FIGURE_TIMEOUT_MS
@@ -11788,7 +12336,7 @@ function readContentRegion() {
 }
 
 // src/source/transcode.ts
-import { readFile as readFile6, rm as rm2 } from "node:fs/promises";
+import { readFile as readFile7, rm as rm2 } from "node:fs/promises";
 import { basename as basename2 } from "node:path";
 
 // src/render/ffmpeg.ts
@@ -11814,7 +12362,7 @@ ${tail}`);
   }
 }
 function runLive(file, args) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn2(file, args, { stdio: ["ignore", "inherit", "inherit"] });
     child.on("error", (err) => {
       reject(
@@ -11822,7 +12370,7 @@ function runLive(file, args) {
       );
     });
     child.on("close", (code, signal2) => {
-      if (code === 0) resolve9();
+      if (code === 0) resolve10();
       else if (signal2) {
         reject(
           new Error(
@@ -12024,7 +12572,7 @@ async function transcode(input, out, opts = {}) {
   const maxSeconds = opts.maxSeconds ?? MAX_CLIP_SECONDS;
   const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
   const name = basename2(input);
-  const source = videoSize(await readFile6(input));
+  const source = videoSize(await readFile7(input));
   const box = fitBox(source.width, source.height, opts.maxEdgePx ?? CLIP_EDGE_PX);
   const kept = (why2) => ({
     path: input,
@@ -12056,7 +12604,7 @@ async function transcode(input, out, opts = {}) {
   }
   let measured;
   try {
-    measured = videoSize(await readFile6(out));
+    measured = videoSize(await readFile7(out));
   } catch (err) {
     await rm2(out, { force: true });
     return kept(
@@ -12092,8 +12640,8 @@ var HTML_TYPES = /^text\/html$|^application\/xhtml\+xml$/;
 async function harvest(url, dir, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS2;
   const warnings = [];
-  const assets = resolve3(dir);
-  await mkdir5(assets, { recursive: true });
+  const assets = resolve4(dir);
+  await mkdir6(assets, { recursive: true });
   const page = await fetchGuarded(url, {
     maxBytes: opts.maxBytes ?? HTML_MAX_BYTES,
     timeoutMs,
@@ -12483,8 +13031,8 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
           `it is ${size.width}x${size.height}, under ${MIN_FIGURE_PX}px \u2014 spacers, icons and tracking pixels look like this, and a slide cannot use one`
         );
       }
-      const path2 = join7(dir, assetName(url, extFor2(sniffFormat(bytes))));
-      await writeFile5(path2, bytes);
+      const path2 = join8(dir, assetName(url, extFor2(sniffFormat(bytes))));
+      await writeFile6(path2, bytes);
       assets.push(path2);
       got = { path: path2, width: size.width, height: size.height };
     } catch (err) {
@@ -12496,7 +13044,7 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
   };
   const shrink = async (url, path2, measured, what) => {
     if (opts.transcode === false) return { path: path2, ...measured };
-    const out2 = join7(dir, assetName(url, ".vp9.webm"));
+    const out2 = join8(dir, assetName(url, ".vp9.webm"));
     let small;
     try {
       small = await transcode(path2, out2, {
@@ -12538,8 +13086,8 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
     try {
       const bytes = await bytesOf(url);
       const measured = videoSize(bytes);
-      const path2 = join7(dir, assetName(url, `.${measured.container}`));
-      await writeFile5(path2, bytes);
+      const path2 = join8(dir, assetName(url, `.${measured.container}`));
+      await writeFile6(path2, bytes);
       return await shrink(url, path2, measured, what);
     } catch (err) {
       warnings.push(`${what} was not downloaded: ${url} \u2014 ${why(err)}`);
@@ -12628,7 +13176,7 @@ function unheld(policy) {
   return "the file could not be held";
 }
 async function sizeOf(path2) {
-  return await stat2(path2).then(
+  return await stat3(path2).then(
     (s) => s.size,
     () => 0
   );
@@ -12902,9 +13450,9 @@ ${fence}`;
 
 // src/plan/codex.ts
 import { spawn as spawn3 } from "node:child_process";
-import { mkdtemp, readFile as readFile7, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdtemp, readFile as readFile8, rm as rm4, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { z as z3 } from "zod";
 
 // src/plan/arc.ts
@@ -13408,9 +13956,19 @@ nothing, so it can never dangle.
   - At most ${images.max} pictures in the whole deck; a split-compare with two
     briefs spends two. Past that, find the point's shape and draw it.`;
 }
+var BESPOKE_HINT = `
+
+BESPOKE SCENES
+
+Set \`bespoke: true\` on the four to six beats that explain a MECHANISM \u2014 a
+process that runs, an equation whose terms act, a curve that moves, a
+comparison that is a distance \u2014 and that the narration talks over for a while.
+Those beats get a custom animation drawn for them; everything else keeps its
+archetype. Set \`bespoke: false\` on a beat whose archetype must stay (a real
+figure the viewer must see). Leave it null otherwise.`;
 function systemPrompt(prefs) {
   const plan = durationPlan(prefs);
-  return `${rules(cadenceFor(prefs, plan))}${paperArcRequested(prefs) ? paperArc(prefs.slides) : ""}${prefs.images.enabled ? illustrations(prefs.images) : ""}
+  return `${rules(cadenceFor(prefs, plan))}${paperArcRequested(prefs) ? paperArc(prefs.slides) : ""}${prefs.images.enabled ? illustrations(prefs.images) : ""}${prefs.bespoke?.enabled ? BESPOKE_HINT : ""}
 
 PREFERENCES \u2014 chosen by the person who asked for this deck.
 ${prefs.duration === void 0 ? "" : `
@@ -13704,7 +14262,10 @@ function stripNulls(node) {
 }
 var PLANNER_INVISIBLE = /* @__PURE__ */ new Set(["tilt"]);
 function plannerInvisible(prefs) {
-  return paperArcRequested(prefs) ? PLANNER_INVISIBLE : /* @__PURE__ */ new Set([...PLANNER_INVISIBLE, "role"]);
+  const hidden = new Set(PLANNER_INVISIBLE);
+  if (!paperArcRequested(prefs)) hidden.add("role");
+  if (!prefs.bespoke?.enabled) hidden.add("bespoke");
+  return hidden;
 }
 function hideFromPlanner(node, hidden) {
   if (Array.isArray(node)) return node.map((n3) => hideFromPlanner(n3, hidden));
@@ -13736,11 +14297,11 @@ function schemaFor(prefs) {
 var SCHEMA = schemaFor({ genre: "general" });
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
-  const dir = await mkdtemp(join8(tmpdir2(), "decksmith-plan-"));
+  const dir = await mkdtemp(join9(tmpdir2(), "decksmith-plan-"));
   try {
-    const schemaPath = join8(dir, "storyboard.schema.json");
-    const outPath = join8(dir, "storyboard.json");
-    await writeFile6(schemaPath, JSON.stringify(schemaFor(prefs)));
+    const schemaPath = join9(dir, "storyboard.schema.json");
+    const outPath = join9(dir, "storyboard.json");
+    await writeFile7(schemaPath, JSON.stringify(schemaFor(prefs)));
     await (opts.run ?? runCodex)({
       prompt: buildPrompt(source, prefs),
       schemaPath,
@@ -13748,7 +14309,7 @@ async function codexPlanner(source, opts = {}) {
       ...opts.model === void 0 ? {} : { model: opts.model },
       timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
     });
-    const raw2 = await readFile7(outPath, "utf8").catch(() => "");
+    const raw2 = await readFile8(outPath, "utf8").catch(() => "");
     if (raw2.trim() === "") {
       throw new Error("Codex produced no final message. Re-run, or try a shorter source.");
     }
@@ -13815,18 +14376,24 @@ function codexCommand(args) {
     "--color",
     "never",
     ...args.model ? ["--model", args.model] : [],
+    ...(args.config ?? []).flatMap((c) => ["-c", c]),
+    ...(args.images ?? []).flatMap((path2) => ["-i", path2]),
     "-"
   ];
   return sandbox === "workspace-write" && args.cwd !== void 0 ? { argv, env: { ...process.env, TMPDIR: args.cwd } } : { argv };
 }
 function runCodex(args) {
   const { argv, env: env2 } = codexCommand(args);
-  return new Promise((resolve9, reject) => {
-    const child = spawn3("codex", argv, {
-      stdio: ["pipe", "ignore", "pipe"],
+  return new Promise((resolve10, reject) => {
+    const child = spawn3(args.bin ?? "codex", argv, {
+      stdio: ["pipe", args.onUsage ? "pipe" : "ignore", "pipe"],
       ...env2 === void 0 ? {} : { env: env2 }
     });
     let stderr = "";
+    let stdout = "";
+    child.stdout?.on("data", (c) => {
+      stdout = (stdout + c.toString()).slice(-4e3);
+    });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
       reject(new Error(`Codex did not finish within ${Math.round(args.timeoutMs / 1e3)}s.`));
@@ -13838,32 +14405,35 @@ function runCodex(args) {
       clearTimeout(timer);
       reject(
         err.code === "ENOENT" ? new Error(
-          'The "codex" CLI is not on PATH. Install it, or sign in with `codex login`, then retry.'
+          `The "${args.bin ?? "codex"}" CLI is not on PATH. Install it, or sign in with \`codex login\`, then retry.`
         ) : err
       );
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (code === 0) return resolve9();
+      const used = /tokens used\s*\n?\s*([\d,]+)/i.exec(`${stdout}
+${stderr}`);
+      if (used?.[1] && args.onUsage) args.onUsage(Number(used[1].replace(/,/g, "")));
+      if (code === 0) return resolve10();
       reject(
         new Error(`codex exec exited ${code}.
 ${stderr.trim().split("\n").slice(-8).join("\n")}`)
       );
     });
-    child.stdin.end(args.prompt);
+    child.stdin?.end(args.prompt);
   });
 }
 
 // src/images/illustrate.ts
 import { createHash as createHash8 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile9, rename, rm as rm6, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile10, rename as rename2, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 
 // src/images/providers.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdtemp as mkdtemp2, readFile as readFile8, rm as rm5, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile9, rm as rm5, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join9, resolve as resolve4 } from "node:path";
+import { join as join10, resolve as resolve5 } from "node:path";
 import { z as z4 } from "zod";
 var SIZE = {
   landscape: { width: 1536, height: 1024 },
@@ -13995,11 +14565,11 @@ function codexImages(opts = {}) {
     async check() {
     },
     async generate(req) {
-      const dir = await mkdtemp2(join9(tmpdir3(), "decksmith-image-"));
+      const dir = await mkdtemp2(join10(tmpdir3(), "decksmith-image-"));
       try {
-        const schemaPath = join9(dir, "answer.schema.json");
-        const outPath = join9(dir, "answer.json");
-        await writeFile7(schemaPath, JSON.stringify(ANSWER_SCHEMA));
+        const schemaPath = join10(dir, "answer.schema.json");
+        const outPath = join10(dir, "answer.json");
+        await writeFile8(schemaPath, JSON.stringify(ANSWER_SCHEMA));
         await run5({
           prompt: codexPrompt(req),
           schemaPath,
@@ -14008,7 +14578,7 @@ function codexImages(opts = {}) {
           cwd: dir,
           sandbox: "workspace-write"
         });
-        const raw2 = await readFile8(outPath, "utf8").catch(() => "");
+        const raw2 = await readFile9(outPath, "utf8").catch(() => "");
         const answer = answerSchema.safeParse(parseJson(Buffer.from(raw2)));
         if (!answer.success) throw new Error("codex could not generate a picture: no final answer");
         if (!answer.data.ok) {
@@ -14016,10 +14586,10 @@ function codexImages(opts = {}) {
             `codex could not generate a picture: ${answer.data.reason ?? "no reason given"}`
           );
         }
-        const candidates3 = [join9(dir, "picture.png")];
-        if (answer.data.file) candidates3.push(resolve4(dir, answer.data.file));
+        const candidates3 = [join10(dir, "picture.png")];
+        if (answer.data.file) candidates3.push(resolve5(dir, answer.data.file));
         for (const path2 of candidates3) {
-          const bytes = await readFile8(path2).catch(() => null);
+          const bytes = await readFile9(path2).catch(() => null);
           if (bytes) return raster(bytes, "codex");
         }
         throw new Error("codex said ok but wrote no picture.png");
@@ -14151,7 +14721,7 @@ async function illustrate(storyboard, source, opts) {
   const tool = last?.id === "svg" ? last : toolSvg();
   if (tool !== last) chain.push(tool);
   const dropped = /* @__PURE__ */ new Set();
-  if (pending.length > 0) await mkdir6(opts.assetsDir, { recursive: true });
+  if (pending.length > 0) await mkdir7(opts.assetsDir, { recursive: true });
   for (const [i, slot] of pending.entries()) {
     let rungs = chain;
     if (i >= images.max) {
@@ -14248,16 +14818,16 @@ function cacheKey2(providerId, req) {
 async function draw(provider, req, name, dir) {
   for (const ext of Object.values(EXT2)) {
     const src2 = `${name}${ext}`;
-    const bytes = await readFile9(join10(dir, src2)).catch(() => null);
+    const bytes = await readFile10(join11(dir, src2)).catch(() => null);
     if (bytes) return { src: src2, ...sizeOf2(bytes, ext), cached: true };
   }
   await provider.check();
   const img = await provider.generate(req);
   const src = `${name}${EXT2[img.mime]}`;
-  const tmp = join10(dir, `.${name}.tmp`);
+  const tmp = join11(dir, `.${name}.tmp`);
   try {
-    await writeFile8(tmp, img.bytes);
-    await rename(tmp, join10(dir, src));
+    await writeFile9(tmp, img.bytes);
+    await rename2(tmp, join11(dir, src));
   } finally {
     await rm6(tmp, { force: true });
   }
@@ -14272,6 +14842,353 @@ import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var run2 = promisify2(execFile2);
 
+// src/verify/scenes.ts
+var TYPE_FLOOR_PX2 = 39.5;
+var MEASURE = `(sid, wantGeo) => {
+  const root = document.getElementById(sid);
+  if (!root) return { crossings: [], occlusions: [], overlaps: [], small: [], off: [], strays: [] };
+  const W = window.innerWidth, H = window.innerHeight;
+  // A bespoke scene that moves the camera is clipped to its body box: what the
+  // push-in leaves outside it is not drawn, so it is neither off the frame nor
+  // crossing anything.
+  const bodyEl = document.getElementById(sid + "-g");
+  const bodyClip = bodyEl && getComputedStyle(bodyEl).overflow !== "visible" ? bodyEl.getBoundingClientRect() : null;
+  const meet = (a, b) => {
+    const x0 = Math.max(a.x, b.x), y0 = Math.max(a.y, b.y);
+    const x1 = Math.min(a.x + a.width, b.x + b.width), y1 = Math.min(a.y + a.height, b.y + b.height);
+    return { x: x0, y: y0, width: Math.max(0, x1 - x0), height: Math.max(0, y1 - y0) };
+  };
+  const alpha = (el) => {
+    let o = 1;
+    for (let e = el; e && e !== document.body; e = e.parentElement) {
+      const cs = getComputedStyle(e);
+      if (cs.display === "none" || cs.visibility === "hidden") return 0;
+      o *= Number(cs.opacity);
+    }
+    return o;
+  };
+  const name = (el) => el.id || (el.tagName.toLowerCase() + ":" + (el.textContent || "").trim().slice(0, 16));
+  // What an element's box is after any clipping <svg> (overflow other than
+  // visible) \u2014 a camera move zooms a viewBox, and what it leaves outside is
+  // not drawn, so it is neither off the frame nor crossing anything.
+  const clipOf = (el) => {
+    const svg = el.ownerSVGElement || (el.closest && el.closest("svg"));
+    let c = svg && getComputedStyle(svg).overflow !== "visible" ? svg.getBoundingClientRect() : null;
+    if (bodyClip && bodyEl.contains(el)) c = c ? meet(c, bodyClip) : bodyClip;
+    return c;
+  };
+  const boxOf = (el) => {
+    const r = el.getBoundingClientRect();
+    const c = clipOf(el);
+    if (!c) return { x: r.x, y: r.y, width: r.width, height: r.height, clip: null };
+    const x0 = Math.max(r.x, c.x), y0 = Math.max(r.y, c.y);
+    const x1 = Math.min(r.x + r.width, c.x + c.width), y1 = Math.min(r.y + r.height, c.y + c.height);
+    // >=, not >: a horizontal line has no height and is still drawn.
+    return x1 >= x0 && y1 >= y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0, clip: c } : { x: 0, y: 0, width: 0, height: 0, clip: c };
+  };
+  // Text boxes: SVG <text>, a KaTeX run, or an HTML element with its own text.
+  const texts = [];
+  // Where a label sits, in the body box's own px (= the scene's svg units when it
+  // has no camera move): a fix round can act on "x 1210-1330" where it cannot on
+  // "these two overlap" \u2014 round 2's drafts failed on overlaps it could not see.
+  const origin = document.getElementById(sid + "-g");
+  const o0 = origin ? origin.getBoundingClientRect() : { x: 0, y: 0 };
+  const at = (t) => t.id + " [x " + Math.round(t.x - o0.x) + "-" + Math.round(t.x + t.w - o0.x) + ", y " + Math.round(t.y - o0.y) + "-" + Math.round(t.y + t.h - o0.y) + "]";
+  const walk = (el) => {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "script" || tag === "style" || tag === "defs") return;
+    const own = [...el.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim());
+    const katex = el.classList && el.classList.contains("katex");
+    if (tag === "text" || katex || (own && !(el instanceof SVGElement))) {
+      const r = boxOf(el);
+      const o = alpha(el);
+      if (r.width > 0 && r.height > 0 && o > 0.15) {
+        let fs = parseFloat(getComputedStyle(el).fontSize) || 0;
+        if (el instanceof SVGGraphicsElement && el.getScreenCTM) {
+          const m = el.getScreenCTM();
+          if (m) fs *= Math.hypot(m.a, m.b);
+        }
+        texts.push({ el, id: name(el), x: r.x, y: r.y, w: r.width, h: r.height, fs, o });
+      }
+      if (tag === "text" || katex) return;
+    }
+    for (const c of el.children) walk(c);
+  };
+  walk(root);
+
+  const overlaps = [];
+  for (let i = 0; i < texts.length; i++)
+    for (let j = i + 1; j < texts.length; j++) {
+      const a = texts[i], b = texts[j];
+      if (a.el.contains(b.el) || b.el.contains(a.el)) continue;
+      const ix = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
+      const iy = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
+      if (ix > 4 && iy > 4) overlaps.push(at(a) + " \xD7 " + at(b));
+    }
+  const small = texts.filter((t) => t.fs > 0 && t.fs < ${TYPE_FLOOR_PX2}).map((t) => t.id + "@" + t.fs.toFixed(1) + "px");
+
+  // Strokes and fills. Every shape that paints something at this instant is a
+  // LEAF: what the stage-fill and early-reveal measures below are made of.
+  const crossings = [], occlusions = [], off = [], strays = [], leaves = [];
+  // <image> is a bespoke scene's illustration: it paints its whole box.
+  const shapes = root.querySelectorAll("path, line, polyline, polygon, circle, ellipse, rect, image");
+  // Repair geometry (bespoke scenes, on request): stroke points, filled boxes.
+  const geoPoints = [], geoBoxes = [];
+  const inset = 4;
+  const inside = (p, t) => p.x > t.x + inset && p.x < t.x + t.w - inset && p.y > t.y + inset && p.y < t.y + t.h - inset;
+  for (const g of shapes) {
+    if (g.closest("defs, marker, clipPath, mask, pattern, symbol")) continue;
+    const o = alpha(g);
+    if (o <= 0.15) continue;
+    const cs = getComputedStyle(g);
+    const r = boxOf(g);
+    if (r.width === 0 && r.height === 0) continue;
+    if (r.x < -2 || r.y < -2 || r.x + r.width > W + 2 || r.y + r.height > H + 2) off.push(name(g));
+    // A shape that wholly contains a text box is that label's plate, not a collision.
+    const plate = (t) => r.x <= t.x + 1 && r.y <= t.y + 1 && r.x + r.width >= t.x + t.w - 1 && r.y + r.height >= t.y + t.h - 1;
+    const sw = parseFloat(cs.strokeWidth) || 0;
+    const stroked = cs.stroke && cs.stroke !== "none" && sw > 0 && Number(cs.strokeOpacity) * o > 0.15;
+    // A <line> has no inside, and a shape scaled flat paints no area, whatever its fill says.
+    const filled = cs.fill && cs.fill !== "none" && Number(cs.fillOpacity) * o > 0.15 &&
+      g.tagName.toLowerCase() !== "line" && r.width >= 1 && r.height >= 1;
+    // A marker paints with the element's opacity, not its stroke's, and DrawSVG
+    // draws by dashing: an arrowhead stays where it is while its line is drawn
+    // to 0%, or half way \u2014 the "stray arrowhead" of an undrawn line.
+    const markerStart = cs.markerStart && cs.markerStart !== "none";
+    const markerEnd = cs.markerEnd && cs.markerEnd !== "none";
+    const picture = g.tagName.toLowerCase() === "image";
+    let paints = filled;
+    if (!stroked && (markerStart || markerEnd)) strays.push(name(g) + " (its arrowhead shows, its line does not)");
+    if (stroked && typeof g.getTotalLength !== "function") paints = true;
+    if (stroked && typeof g.getTotalLength === "function") {
+      let len = 0;
+      try { len = g.getTotalLength(); } catch (e) { len = 0; }
+      const m = g.getScreenCTM();
+      if (len > 0 && m) {
+        const dash = (cs.strokeDasharray && cs.strokeDasharray !== "none")
+          ? cs.strokeDasharray.split(/[ ,]+/).map(parseFloat).filter((v) => v >= 0)
+          : [];
+        const pattern = dash.length % 2 ? dash.concat(dash) : dash;
+        const period = pattern.reduce((a, b) => a + b, 0);
+        const offset = parseFloat(cs.strokeDashoffset) || 0;
+        const visible = (d) => {
+          if (!period) return true;
+          let pos = ((d + offset) % period + period) % period;
+          for (let k = 0; k < pattern.length; k++) {
+            if (pos < pattern[k]) return k % 2 === 0;
+            pos -= pattern[k];
+          }
+          return true;
+        };
+        const step = Math.max(4, len / 400);
+        const hit = new Set();
+        let drawn = 0;
+        let kept = -1e9;
+        for (let d = 0; d <= len; d += step) {
+          if (!visible(d)) continue;
+          drawn += step;
+          const q = g.getPointAtLength(d);
+          const p = { x: m.a * q.x + m.c * q.y + m.e, y: m.b * q.x + m.d * q.y + m.f };
+          if (r.clip && (p.x < r.clip.x || p.y < r.clip.y || p.x > r.clip.x + r.clip.width || p.y > r.clip.y + r.clip.height)) continue;
+          if (wantGeo && d - kept >= 8 && geoPoints.length < 6000) { kept = d; geoPoints.push({ el: g, x: p.x, y: p.y }); }
+          // No plate exemption here: a long curve's bounding box contains half
+          // the labels on a chart, and its stroke still runs through them.
+          for (const t of texts) if (!hit.has(t) && inside(p, t)) hit.add(t);
+        }
+        for (const t of hit) crossings.push(name(g) + " through " + at(t));
+        if (drawn > 2) paints = true;
+        const edge = Math.min(2, len / 100);
+        if (markerEnd && !visible(len - edge)) strays.push(name(g) + " (an arrowhead at the end of a line not drawn that far)");
+        else if (markerStart && !visible(edge)) strays.push(name(g) + " (an arrowhead at the start of a line not drawn from there)");
+      } else if (len > 0) paints = true;
+    }
+    if (paints) leaves.push({ el: g, x: r.x, y: r.y, w: r.width, h: r.height, o });
+    if (wantGeo && filled) geoBoxes.push({ el: g, x: r.x, y: r.y, w: r.width, h: r.height });
+    if (filled) {
+      for (const t of texts) {
+        // A picture over a label is never its plate: it covers it.
+        if (plate(t) && !picture) continue;
+        // Only a shape painted AFTER the text can cover it.
+        if (!(t.el.compareDocumentPosition(g) & Node.DOCUMENT_POSITION_FOLLOWING)) continue;
+        const ix = Math.min(r.x + r.width, t.x + t.w) - Math.max(r.x, t.x);
+        const iy = Math.min(r.y + r.height, t.y + t.h) - Math.max(r.y, t.y);
+        if (ix > inset && iy > inset && ix * iy > 0.15 * t.w * t.h) occlusions.push(name(g) + " over " + at(t));
+      }
+    }
+  }
+  for (const t of texts)
+    if (t.x < -1 || t.y < -1 || t.x + t.w > W + 1 || t.y + t.h > H + 1) off.push(t.id);
+
+  // The body box a bespoke scene draws in. Absent on an archetype's scene, and
+  // then there is no stage to fill and no cue group to reveal.
+  const box = document.getElementById(sid + "-g");
+  let fill, maxType, cells, groups, revealed, dimmed;
+  if (box) {
+    const b = box.getBoundingClientRect();
+    const mine = texts.filter((t) => box.contains(t.el)).map((t) => ({ el: t.el, x: t.x, y: t.y, w: t.w, h: t.h }))
+      .concat(leaves.filter((l) => box.contains(l.el)));
+    // A backdrop the size of the box fills it by being there; it is not content.
+    // A picture is content however big it is: it is what the stage shows.
+    const content = mine.filter((l) => l.w * l.h < 0.85 * b.width * b.height || l.el.tagName.toLowerCase() === "image");
+    const clip = (l) => {
+      const x0 = Math.max(b.x, l.x), y0 = Math.max(b.y, l.y);
+      const x1 = Math.min(b.x + b.width, l.x + l.w), y1 = Math.min(b.y + b.height, l.y + l.h);
+      return x1 > x0 && y1 > y0 ? { x0, y0, x1, y1 } : null;
+    };
+    const parts = content.map(clip).filter(Boolean);
+    if (parts.length && b.width > 0 && b.height > 0) {
+      const u = parts.reduce((a, p) => ({ x0: Math.min(a.x0, p.x0), y0: Math.min(a.y0, p.y0), x1: Math.max(a.x1, p.x1), y1: Math.max(a.y1, p.y1) }));
+      fill = ((u.x1 - u.x0) * (u.y1 - u.y0)) / (b.width * b.height);
+      // How many of a 6x4 grid's cells something is drawn in: a bbox can be
+      // stretched by one stray dot, a grid cannot.
+      let n = 0;
+      for (let cx = 0; cx < 6; cx++)
+        for (let cy = 0; cy < 4; cy++) {
+          const gx0 = b.x + (cx * b.width) / 6, gx1 = b.x + ((cx + 1) * b.width) / 6;
+          const gy0 = b.y + (cy * b.height) / 4, gy1 = b.y + ((cy + 1) * b.height) / 4;
+          if (parts.some((p) => p.x0 < gx1 && p.x1 > gx0 && p.y0 < gy1 && p.y1 > gy0)) n++;
+        }
+      cells = n / 24;
+    } else fill = 0;
+    maxType = texts.filter((t) => box.contains(t.el)).reduce((a, t) => Math.max(a, t.fs), 0);
+    // How much of what is drawn is drawn dimmed (focus): at the end, a summary
+    // that is mostly ghosts is not one.
+    const shown = texts.filter((t) => box.contains(t.el)).concat(leaves.filter((l) => box.contains(l.el)));
+    dimmed = shown.length ? shown.filter((x) => x.o < 0.6).length / shown.length : 0;
+    // Cue groups: what the scene says each cue introduces, and which are showing now.
+    const tagged = [...box.querySelectorAll("[data-cue]")];
+    groups = [...new Set(tagged.map((e) => Number(e.getAttribute("data-cue"))))].sort((a, c) => a - c);
+    const showing = (e) => texts.some((t) => e === t.el || e.contains(t.el)) || leaves.some((l) => e === l.el || e.contains(l.el));
+    revealed = tagged.filter(showing).map((e) => ({ id: name(e), cue: Number(e.getAttribute("data-cue")) }));
+  }
+  // Where the camera is, for \`camera_end\`: the shell's wrapper, and a viewBox camera.
+  let camOff;
+  const cam = document.getElementById(sid + "-cam");
+  if (cam) {
+    const t = getComputedStyle(cam).transform;
+    if (t && t !== "none") {
+      const v = t.slice(t.indexOf("(") + 1, t.lastIndexOf(")")).split(",").map(Number);
+      if (v.length === 6 && (Math.abs(v[0] - 1) > 0.01 || Math.abs(v[4]) > 2 || Math.abs(v[5]) > 2))
+        camOff = "#" + sid + "-cam at scale " + v[0].toFixed(2) + ", x " + Math.round(v[4]) + ", y " + Math.round(v[5]);
+    }
+  }
+  // Round 4: the shell's camera (scale, x, y and the box it moves), the
+  // subjects of an illustrated scene, and how its labels sit on them.
+  let shot, subjects, anchors, onPicture;
+  if (cam && box) {
+    const t = getComputedStyle(cam).transform;
+    const v = t && t !== "none" ? t.slice(t.indexOf("(") + 1, t.lastIndexOf(")")).split(",").map(Number) : [1, 0, 0, 1, 0, 0];
+    const s = v.length === 6 ? v[0] : 1;
+    shot = [Math.round(s * 1000) / 1000, Math.round(v[4] || 0), Math.round(v[5] || 0), cam.offsetWidth, cam.offsetHeight];
+    const subs = [...cam.querySelectorAll("[data-ds-subject]")].map((e) => ({ k: Number(e.getAttribute("data-ds-subject")), r: e.getBoundingClientRect() }));
+    subjects = subs.length;
+    if (subs.length) {
+      const area = (r) => Math.max(0, r.width) * Math.max(0, r.height);
+      anchors = [];
+      for (const g of box.querySelectorAll("[data-subject]")) {
+        const k = Number(g.getAttribute("data-subject"));
+        const mine = texts.filter((x) => g === x.el || g.contains(x.el));
+        if (!mine.length) continue;
+        const x0 = Math.min(...mine.map((x) => x.x)), y0 = Math.min(...mine.map((x) => x.y));
+        const x1 = Math.max(...mine.map((x) => x.x + x.w)), y1 = Math.max(...mine.map((x) => x.y + x.h));
+        const lab = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+        const own = subs.find((q) => q.k === k);
+        // Gap between the label and its subject, in the box's own px (camera-free).
+        const gap = own ? Math.hypot(Math.max(0, own.r.x - x1, x0 - (own.r.x + own.r.width)), Math.max(0, own.r.y - y1, y0 - (own.r.y + own.r.height))) / s : 1e9;
+        // The most of the label any OTHER subject's box covers (the part not also its own).
+        let over = 0;
+        for (const q of subs) {
+          if (q.k === k) continue;
+          const m = meet(lab, q.r);
+          let a = area(m);
+          if (own) a -= area(meet(m, own.r));
+          over = Math.max(over, a / Math.max(1, area(lab)));
+        }
+        anchors.push({ id: g.id || "g:" + k, k, d: Math.round(gap), o: Math.round(over * 100) / 100 });
+      }
+    }
+    // A table or chart painted over the picture: numbers sitting on the illustration.
+    const pic = box.querySelector("image[data-art]");
+    if (pic && alpha(pic) > 0.15) {
+      const pr = boxOf(pic);
+      onPicture = texts.filter((x) => box.contains(x.el) && /[0-9]/.test(x.el.textContent || "") &&
+        x.x + x.w / 2 > pr.x && x.x + x.w / 2 < pr.x + pr.width && x.y + x.h / 2 > pr.y && x.y + x.h / 2 < pr.y + pr.height).length;
+    }
+  }
+  const svg0 = document.getElementById(sid + "-svg");
+  if (svg0 && !camOff) {
+    // The contract's viewBox is "0 0 W H" with W, H the svg's own size.
+    const vb = (svg0.getAttribute("viewBox") || "").trim().split(/[ ,]+/).map(Number);
+    const w0 = Number(svg0.getAttribute("width")), h0 = Number(svg0.getAttribute("height"));
+    if (vb.length === 4 && w0 > 0 && h0 > 0 && (Math.abs(vb[0]) > 1 || Math.abs(vb[1]) > 1 || Math.abs(vb[2] - w0) > 1 || Math.abs(vb[3] - h0) > 1))
+      camOff = "#" + sid + "-svg viewBox " + vb.join(" ");
+  }
+
+  // What the repair pass needs (bespoke scenes only): every element of the body
+  // addressed as tag:index in document order \u2014 the markup's own order, which
+  // is how a fix finds it again in the fragment \u2014 the labels with the unit a
+  // nudge would move (the text, or the smallest <g> that holds it and its
+  // plate and no other label), what is painted, and each part's opacity.
+  let geo;
+  if (box && wantGeo) {
+    const index = new Map(), order = new Map();
+    const n = {};
+    let k = 0;
+    for (const e of box.querySelectorAll("*")) {
+      // Not the markup's: KaTeX's rendered spans, and the shell's camera wrapper.
+      if (e.closest(".katex") || e.id === sid + "-cam") continue;
+      const t = e.tagName.toLowerCase();
+      n[t] = n[t] || 0;
+      index.set(e, t + ":" + n[t]++);
+      order.set(e, k++);
+    }
+    const ob = box.getBoundingClientRect();
+    const rel = (x, y, w, h) => [x - ob.x, y - ob.y, w, h].map((v) => Math.round(v * 10) / 10);
+    const unitOf = (el) => {
+      let u = el;
+      const tb = el.getBoundingClientRect();
+      const area = Math.max(1, tb.width * tb.height);
+      for (let p = el.parentElement; p && p !== box && p.tagName.toLowerCase() === "g" && box.contains(p); p = p.parentElement) {
+        if (p.querySelectorAll("text").length !== 1) break;
+        const pb = p.getBoundingClientRect();
+        if (pb.width * pb.height > 4 * area) break;
+        u = p;
+      }
+      return u;
+    };
+    const scaleOf = (u) => {
+      const par = u.parentElement;
+      const m = par && par.getScreenCTM ? par.getScreenCTM() : null;
+      return m ? Math.hypot(m.a, m.b) || 1 : 1;
+    };
+    const units = [];
+    const labels = texts.filter((t) => box.contains(t.el)).map((t) => {
+      // The shell's own labels (round 4) are not the scene's to move: obstacles.
+      const movable = t.el.tagName.toLowerCase() === "text" && !t.el.closest(".ds-callouts");
+      const u = movable ? unitOf(t.el) : null;
+      if (u) units.push(u);
+      return { a: index.get(t.el) || "", u: u ? index.get(u) : null, o: order.get(t.el) ?? -1, b: rel(t.x, t.y, t.w, t.h), s: u ? Math.round(scaleOf(u) * 1000) / 1000 : 1, fs: Math.round(t.fs) };
+    });
+    const ownerOf = (el) => { for (const u of units) if (u === el || u.contains(el)) return index.get(u); return null; };
+    const points = geoPoints.filter((p) => box.contains(p.el)).map((p) => [Math.round(p.x - ob.x), Math.round(p.y - ob.y), ownerOf(p.el)]);
+    const boxes = geoBoxes.filter((b) => box.contains(b.el)).map((b) => ({ a: index.get(b.el) || "", u: ownerOf(b.el), o: order.get(b.el) ?? -1, b: rel(b.x, b.y, b.w, b.h) }));
+    // Each visible part's opacity, and the elements above it (itself included)
+    // that dim it: what a relight would have to bring back.
+    const own = (e) => Number(getComputedStyle(e).opacity);
+    const parts = texts.filter((t) => box.contains(t.el)).map((t) => ({ el: t.el, o: t.o }))
+      .concat(leaves.filter((l) => box.contains(l.el)).map((l) => ({ el: l.el, o: l.o })))
+      .map((p) => {
+        const dim = [];
+        if (p.o < 0.95)
+          for (let e = p.el; e && e !== box; e = e.parentElement)
+            if (index.has(e) && own(e) < 0.95) dim.push(index.get(e) + (e.id ? "#" + e.id : ""));
+        return { a: index.get(p.el) || "", al: Math.round(p.o * 100) / 100, dim };
+      });
+    geo = { w: Math.round(ob.width), h: Math.round(ob.height), labels, boxes, points, parts };
+  }
+  return { crossings, occlusions, overlaps, small, off, strays, fill, cells, maxType, groups, revealed, dimmed, camOff, geo, shot, subjects, anchors, onPicture };
+}`;
+
 // src/verify/drift.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
@@ -14295,12 +15212,12 @@ function scanBeatCount(storyboard, prefs) {
 }
 
 // src/render/render.ts
-import { mkdir as mkdir8, readFile as readFile10, rename as rename2, rm as rm7, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname3, join as join12, resolve as resolve5 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile11, rename as rename3, rm as rm7, writeFile as writeFile11 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname3, join as join13, resolve as resolve6 } from "node:path";
 
 // src/render/captions.ts
-import { mkdir as mkdir7, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { mkdir as mkdir8, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 import { pathToFileURL } from "node:url";
 var DECK_FONT_CSS = "assets/fonts/fonts.css";
 function cssString(value) {
@@ -14391,11 +15308,11 @@ async function captionBlocker() {
 }
 async function renderCaptions(cues, style, deck, work2) {
   if (cues.length === 0) throw new Error("renderCaptions was given no cues.");
-  const fontCss = join11(deck, DECK_FONT_CSS);
+  const fontCss = join12(deck, DECK_FONT_CSS);
   const href = await import("node:fs/promises").then((fs) => fs.stat(fontCss).catch(() => null)) ? pathToFileURL(fontCss).href : null;
-  const page = join11(work2, "captions.html");
-  await mkdir7(work2, { recursive: true });
-  await writeFile9(page, captionPage(cues, style, href));
+  const page = join12(work2, "captions.html");
+  await mkdir8(work2, { recursive: true });
+  await writeFile10(page, captionPage(cues, style, href));
   const { default: puppeteer } = await import("puppeteer-core");
   const executablePath = await chromePath(CAPTION_NEED);
   const browser = await launchOwnPage(
@@ -14416,7 +15333,7 @@ async function renderCaptions(cues, style, deck, work2) {
       const name = `cap${String(i).padStart(4, "0")}.png`;
       await tab.evaluate((id2) => document.getElementById(id2)?.classList.add("on"), `c${i}`);
       await tab.screenshot({
-        path: join11(work2, name),
+        path: join12(work2, name),
         type: "png",
         omitBackground: true,
         clip: { x: box.x, y: box.y, width: box.width, height: box.height }
@@ -14457,9 +15374,9 @@ function subtitlePlan(mode) {
 async function render(opts) {
   const log = opts.log ?? (() => {
   });
-  const deck = resolve5(opts.deck);
-  const out = resolve5(opts.out);
-  const work2 = join12(dirname3(out), `.${basename4(out)}.parts`);
+  const deck = resolve6(opts.deck);
+  const out = resolve6(opts.out);
+  const work2 = join13(dirname3(out), `.${basename4(out)}.parts`);
   const timing = await readTiming(deck);
   if (opts.targetSeconds && !opts.allowFastPlayback) {
     const refusal = playbackRefusal(
@@ -14479,9 +15396,9 @@ async function render(opts) {
     if (blocker) throw new Error(`Cannot burn in captions: ${blocker}`);
   }
   const burnable = plan0.burn;
-  await mkdir8(work2, { recursive: true });
+  await mkdir9(work2, { recursive: true });
   try {
-    const raw2 = opts.video ? resolve5(opts.video) : await capture(deck, join12(work2, "raw.mp4"), opts, log);
+    const raw2 = opts.video ? resolve6(opts.video) : await capture(deck, join13(work2, "raw.mp4"), opts, log);
     const shot = await probe(raw2);
     log(
       `render: ${shot.frames} frames, ${shot.width}\xD7${shot.height}, ${shot.fps.toFixed(3)} fps, ${shot.seconds.toFixed(2)}s`
@@ -14494,24 +15411,24 @@ async function render(opts) {
       );
     }
     const retimed = await retime(raw2, plan, work2, log);
-    const srtPath = join12(dirname3(out), SRT_NAME(out));
+    const srtPath = join13(dirname3(out), SRT_NAME(out));
     const playback = opts.targetSeconds ? playbackFactor(plan.frames / shot.fps, opts.targetSeconds) : 1;
     const cues = playback > 1 ? plan.cues.map((c) => scaleCue(c, playback)) : plan.cues;
     const srt = plan0.sidecar ? toSrt(cues) : "";
-    if (srt) await writeFile10(srtPath, srt);
+    if (srt) await writeFile11(srtPath, srt);
     const burn = burnable && srt.length > 0;
     await mux(retimed, timing, plan, deck, out, work2, burn ? plan.cues : void 0, shot.fps, log);
     if (playback > 1) {
       log(`render: speeding playback ${playback}\xD7 to reach ${opts.targetSeconds}s`);
       const warning = playbackWarning(playback, p95CueRate(plan.cues));
       if (warning) log(`render: ${warning}`);
-      const fast = join12(work2, `fast.${basename4(out)}`);
+      const fast = join13(work2, `fast.${basename4(out)}`);
       const muxed = await probe(out);
       await runTool(
         "ffmpeg",
         respeedArgs(out, playback, tempoChain(playback), shot.fps, muxed.hasAudio, fast)
       );
-      await rename2(fast, out);
+      await rename3(fast, out);
     }
     const final = await probe(out);
     if (plan.audio.length > 0 && !final.hasAudio) {
@@ -14535,8 +15452,8 @@ async function render(opts) {
   }
 }
 async function readTiming(deck) {
-  const path2 = join12(deck, TIMING_FILE);
-  const text2 = await readFile10(path2, "utf8").catch(() => {
+  const path2 = join13(deck, TIMING_FILE);
+  const text2 = await readFile11(path2, "utf8").catch(() => {
     throw new Error(
       `${path2} is missing. \`render\` needs the timing manifest \`build\` writes; rebuild the deck.`
     );
@@ -14575,20 +15492,20 @@ async function retime(raw2, plan, work2, log) {
   if (plan.pieces.every((p) => p.freeze === 0)) return raw2;
   const list = [];
   for (const [i, piece] of plan.pieces.entries()) {
-    const file = join12(work2, `p${String(i).padStart(4, "0")}.ts`);
+    const file = join13(work2, `p${String(i).padStart(4, "0")}.ts`);
     await runTool("ffmpeg", pieceArgs(raw2, piece.from, piece.motion, piece.freeze, plan.fps, file));
     list.push(file);
     if ((i + 1) % 10 === 0 || i === plan.pieces.length - 1) {
       log(`render: retimed ${i + 1}/${plan.pieces.length} pieces`);
     }
   }
-  const listFile = join12(work2, "pieces.txt");
-  await writeFile10(
+  const listFile = join13(work2, "pieces.txt");
+  await writeFile11(
     listFile,
     `${list.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n")}
 `
   );
-  const joined = join12(work2, "retimed.mp4");
+  const joined = join13(work2, "retimed.mp4");
   await runTool("ffmpeg", [
     "-y",
     "-hide_banner",
@@ -14610,7 +15527,7 @@ async function retime(raw2, plan, work2, log) {
 }
 async function mux(video, timing, plan, deck, out, work2, burnCues, fps, log) {
   const inputs = plan.audio.map((a) => ({
-    file: join12(deck, timing.audioDir, a.audio),
+    file: join13(deck, timing.audioDir, a.audio),
     delayMs: a.delayMs
   }));
   const args = ["-y", "-hide_banner", "-loglevel", "error", "-i", video];
@@ -14631,8 +15548,8 @@ async function mux(video, timing, plan, deck, out, work2, burnCues, fps, log) {
     graph.push(audioGraph(inputs, plan.frames / fps, 1 + (band?.files.length ?? 0)));
   }
   if (graph.length > 0) {
-    const script = join12(work2, "mux.filter");
-    await writeFile10(script, `${graph.join(";\n")}
+    const script = join13(work2, "mux.filter");
+    await writeFile11(script, `${graph.join(";\n")}
 `);
     args.push("-filter_complex_script", script);
   }
@@ -14647,12 +15564,12 @@ async function mux(video, timing, plan, deck, out, work2, burnCues, fps, log) {
   log(
     `render: muxing ${inputs.length} segment(s)${burnCues ? " and burning in the captions" : ""} \u2192 ${out}`
   );
-  await mkdir8(dirname3(out), { recursive: true });
+  await mkdir9(dirname3(out), { recursive: true });
   await runTool("ffmpeg", args, { cwd: work2 });
 }
 
 // src/pack/pack.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname4, extname as extname3 } from "node:path";
 import { unzipSync, zipSync } from "fflate";
 var MTIME = Date.UTC(1980, 0, 2, 12);
@@ -14692,8 +15609,8 @@ async function writePack(pack3, files, out) {
     entries[path2] = STORED.has(extname3(path2).toLowerCase()) ? [bytes, { level: 0 }] : bytes;
   }
   const zip = zipSync(entries, { mtime: MTIME });
-  await mkdir9(dirname4(out), { recursive: true });
-  await writeFile11(out, zip);
+  await mkdir10(dirname4(out), { recursive: true });
+  await writeFile12(out, zip);
   return zip.length;
 }
 function check2(label, path2 = label) {
@@ -14705,6 +15622,325 @@ function check2(label, path2 = label) {
 var PREF_KEYS = Object.keys(prefsSchema.shape);
 var NARRATION_KEYS = Object.keys(prefsSchema.shape.narration.unwrap().shape);
 var IMAGES_KEYS = Object.keys(prefsSchema.shape.images.unwrap().shape);
+var BESPOKE_KEYS = Object.keys(prefsSchema.shape.bespoke.unwrap().shape);
+
+// src/bespoke/references.ts
+var TOKEN_Y = [110, 240, 370, 500, 630];
+var EXPERT_Y = [30, 206, 382, 558];
+var SCORES = [0.62, 0.21, 0.71, 0.09];
+var route = {
+  name: "route",
+  shows: "a mechanism that RUNS: a queue of tokens streams particles into a router, wires draw out to four experts, scores grow, the two chosen paths light while the rest dim (focus) and particles flow along them, and a big counter lands the consequence",
+  fits: ["pipeline", "stack", "grid", "process", "flow", "cycle", "split-compare"],
+  cues: [
+    { t0: 1, t1: 4.6, text: "Every token arrives at the router." },
+    { t0: 4.6, t1: 9, text: "The router scores all four experts," },
+    { t0: 9, t1: 13.4, text: "and sends each token to its top two." },
+    { t0: 13.4, t1: 17.8, text: "Only those run, so compute drops by half." }
+  ],
+  duration: 19,
+  fragment: {
+    markup: `<svg id="SCENEID-svg" width="1700" height="732" viewBox="0 0 1700 732" style="position:absolute;left:0;top:0;overflow:visible">
+  <g id="SCENEID-tokens" data-cue="1">
+    <text id="SCENEID-tokens-label" x="130" y="34" font-size="52" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">Tokens</text>
+${TOKEN_Y.map((y, i) => `    <circle id="SCENEID-tok${i}" cx="130" cy="${y}" r="40" fill="{{${"abcda"[i]}}}"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-stream" data-cue="1">
+${TOKEN_Y.map((y, i) => `    <circle id="SCENEID-s${i}" cx="130" cy="${y}" r="16" fill="{{${"abcda"[i]}}}"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-wires" data-cue="2">
+${EXPERT_Y.map((y, i) => `    <line id="SCENEID-wire${i}" x1="890" y1="370" x2="1176" y2="${y + 72}" stroke="{{rule}}" stroke-width="7" stroke-linecap="round"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-flow" data-cue="3">
+${[0, 1, 2, 3, 4, 5].map((i) => `    <circle id="SCENEID-p${i}" cx="890" cy="370" r="15" fill="{{accent}}"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-router" data-cue="1">
+    <circle id="SCENEID-disc-fill" cx="700" cy="370" r="190" fill="{{bg}}"/>
+    <circle id="SCENEID-disc" cx="700" cy="370" r="190" fill="{{accent}}" fill-opacity="0.22" stroke="{{accent}}" stroke-width="7"/>
+    <text id="SCENEID-router-label" x="700" y="370" font-size="80" font-weight="700" fill="{{fg}}" text-anchor="middle" dominant-baseline="middle">Router</text>
+  </g>
+${EXPERT_Y.map(
+      (y, i) => `  <g id="SCENEID-expert${i}" data-cue="2">
+    <rect id="SCENEID-box${i}" x="1180" y="${y}" width="480" height="144" rx="22" fill="{{${"abcd"[i]}}}" fill-opacity="0.16" stroke="{{rule}}" stroke-width="5"/>
+    <text id="SCENEID-name${i}" x="1224" y="${y + 56}" font-size="60" font-weight="600" fill="{{fg}}" dominant-baseline="middle">Expert ${i + 1}</text>
+    <rect id="SCENEID-bar${i}" x="1224" y="${y + 100}" width="${Math.round(380 * SCORES[i])}" height="22" rx="11" fill="{{${"abcd"[i]}}}"/>
+  </g>`
+    ).join("\n")}
+  <g id="SCENEID-saving" data-cue="4">
+    <text id="SCENEID-count" x="770" y="660" font-size="120" font-weight="800" fill="{{accent}}" text-anchor="end" dominant-baseline="middle">100</text>
+    <text id="SCENEID-count-unit" x="786" y="668" font-size="60" fill="{{fg}}" dominant-baseline="middle">% compute</text>
+  </g>
+</svg>`,
+    css: "",
+    script: `// Layout (box 1700x732): tokens x 90-170, y 10-670 \xB7 router disc 510-890 x 180-560 \xB7
+// wires 890-1176 \xB7 experts 1180-1660 x 30-702 \xB7 counter 560-1090 x 600-700.
+// Particles are drawn BEFORE the router so they slide under its disc (absorbed).
+var tokens = [], stream = [], ps = [];
+var ys = [110, 240, 370, 500, 630];
+for (var i = 0; i < 5; i++) {
+  tokens.push("#SCENEID-tok" + i);
+  stream.push("#SCENEID-s" + i);
+}
+for (var j = 0; j < 6; j++) ps.push("#SCENEID-p" + j);
+var experts = ["#SCENEID-expert0", "#SCENEID-expert1", "#SCENEID-expert2", "#SCENEID-expert3"];
+var wires = ["#SCENEID-wire0", "#SCENEID-wire1", "#SCENEID-wire2", "#SCENEID-wire3"];
+var bars = ["#SCENEID-bar0", "#SCENEID-bar1", "#SCENEID-bar2", "#SCENEID-bar3"];
+
+// Baselines: every animated thing's start state, set once, before any tween.
+gsap.set(tokens, { scale: 0, transformOrigin: "50% 50%" });
+gsap.set("#SCENEID-tokens-label", { opacity: 0 });
+gsap.set(stream, { opacity: 0, x: 0, y: 0 });
+gsap.set(["#SCENEID-disc", "#SCENEID-disc-fill"], { scale: 0, transformOrigin: "50% 50%" });
+gsap.set("#SCENEID-router-label", { opacity: 0 });
+gsap.set(experts, { opacity: 0, x: 60 });
+gsap.set(wires, { drawSVG: "0% 0%", opacity: 0 });
+gsap.set(bars, { scaleX: 0, transformOrigin: "0% 50%" });
+gsap.set(ps, { opacity: 0, x: 0, y: 0 });
+gsap.set("#SCENEID-saving", { opacity: 0, y: 30 });
+
+// C1 1.0-4.6 "Every token arrives at the router." \u2014 the queue pops in, then streams into the router.
+tl.to("#SCENEID-tokens-label", { opacity: 1, duration: 0.4 }, 1.0);
+tl.to(tokens, { scale: 1, duration: 0.5, ease: "back.out(2)", stagger: 0.08 }, 1.05);
+tl.to(["#SCENEID-disc", "#SCENEID-disc-fill"], { scale: 1, duration: 0.7, ease: "expo.out" }, 1.4);
+tl.to("#SCENEID-router-label", { opacity: 1, duration: 0.4 }, 1.8);
+for (var k = 0; k < 5; k++) {
+  tl.to(stream[k], { opacity: 1, duration: 0.1 }, 2.2 + k * 0.15);
+  tl.to(stream[k], { x: 440, y: 370 - ys[k], duration: 0.9, ease: "power2.in", repeat: 2 }, 2.2 + k * 0.15);
+  tl.to(stream[k], { opacity: 0, duration: 0.1 }, 4.9 + k * 0.15);
+}
+
+// C2 4.6-9.0 "The router scores all four experts," \u2014 experts slide in, wires draw, scores grow.
+tl.to(experts, { opacity: 1, x: 0, duration: 0.6, ease: "power3.out", stagger: 0.15 }, 4.7);
+tl.to(wires, { opacity: 1, duration: 0.01, stagger: 0.2 }, 5.0);
+tl.to(wires, { drawSVG: "0% 100%", duration: 0.7, ease: "power2.inOut", stagger: 0.2 }, 5.0);
+tl.to(bars, { scaleX: 1, duration: 0.9, ease: "power2.out", stagger: 0.3 }, 6.4);
+tl.to("#SCENEID-disc", { scale: 1.05, duration: 0.35, yoyo: true, repeat: 3, ease: "sine.inOut" }, 7.6);
+
+// C3 9.0-13.4 "and sends each token to its top two." \u2014 focus: the two winners light, the rest dim; particles flow.
+tl.to(["#SCENEID-expert1", "#SCENEID-expert3", "#SCENEID-wire1", "#SCENEID-wire3"], { opacity: 0.25, duration: 0.5 }, 9.1);
+tl.to(["#SCENEID-wire0", "#SCENEID-wire2"], { stroke: "{{accent}}", strokeWidth: 12, duration: 0.5 }, 9.1);
+var dest = [[286, -268], [286, 84]];
+for (var n = 0; n < 6; n++) {
+  var d = dest[n % 2];
+  tl.to(ps[n], { opacity: 1, duration: 0.15 }, 9.6 + n * 0.35);
+  tl.to(ps[n], { x: d[0], y: d[1], duration: 0.9, ease: "none", repeat: 2 }, 9.6 + n * 0.35);
+  tl.to(ps[n], { opacity: 0, duration: 0.2 }, 13.1);
+}
+
+// C4 13.4-17.8 "Only those run, so compute drops by half." \u2014 the consequence, as a number that moves.
+tl.to("#SCENEID-saving", { opacity: 1, y: 0, duration: 0.5, ease: "power3.out" }, 13.5);
+tl.to("#SCENEID-count", { textContent: 50, snap: { textContent: 1 }, duration: 1.8, ease: "power2.inOut" }, 13.7);
+tl.to(["#SCENEID-box0", "#SCENEID-box2"], { stroke: "{{accent}}", fillOpacity: 0.32, duration: 0.5 }, 13.7);
+tl.to(["#SCENEID-bar0", "#SCENEID-bar2"], { opacity: 0.55, duration: 0.45, yoyo: true, repeat: 3, ease: "sine.inOut" }, 15.6);
+// The end frame is the summary: everything back at full strength; the winners keep their accent.
+tl.to(["#SCENEID-expert1", "#SCENEID-expert3", "#SCENEID-wire1", "#SCENEID-wire3"], { opacity: 1, duration: 0.5 }, 16.6);`
+  }
+};
+var SLABS = Array.from({ length: 12 }, (_, i) => 70 + i * 132);
+var INSIDE = "translate(634.5 259.5) scale(0.5)";
+var zoom = {
+  name: "zoom",
+  shows: "structure then detail: a staggered build of the whole, a CAMERA zoom (viewBox tween) into one part whose inside is drawn at its own scale, a draw that explains it, and a zoom back out where a pulse runs through every part",
+  fits: ["stack", "grid", "annotated-figure", "claim-figure", "layers", "pipeline"],
+  cues: [
+    { t0: 1, t1: 4.8, text: "The model is a stack of twelve identical blocks." },
+    { t0: 4.8, t1: 9.2, text: "Inside each one, attention" },
+    { t0: 9.2, t1: 13.6, text: "lets every token read from every other." },
+    { t0: 13.6, t1: 18, text: "Then the next block does it again, twelve times over." }
+  ],
+  duration: 19.2,
+  fragment: {
+    markup: `<svg id="SCENEID-svg" width="1700" height="732" viewBox="0 0 1700 732" style="position:absolute;left:0;top:0;overflow:hidden">
+  <g id="SCENEID-stack" data-cue="1">
+${SLABS.map(
+      (x, i) => `    <rect id="SCENEID-slab${i}" x="${x}" y="150" width="104" height="440" rx="18" fill="{{panel}}" stroke="{{${i === 5 ? "accent" : "rule"}}}" stroke-width="5"/>`
+    ).join("\n")}
+  </g>
+  <g id="SCENEID-count" data-cue="1">
+    <text id="SCENEID-times" x="850" y="60" font-size="96" font-weight="700" fill="{{fg}}" text-anchor="middle" dominant-baseline="middle">\xD7 12</text>
+    <text id="SCENEID-in" x="122" y="664" font-size="48" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">input</text>
+    <text id="SCENEID-out" x="1574" y="664" font-size="48" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">output</text>
+  </g>
+  <g id="SCENEID-inside" data-cue="2" transform="${INSIDE}">
+    <text id="SCENEID-att" x="295" y="40" font-size="64" font-weight="700" fill="{{accent}}" text-anchor="middle" dominant-baseline="middle">Attention</text>
+${[0, 1, 2, 3, 4].map((i) => `    <circle id="SCENEID-q${i}" cx="${55 + i * 120}" cy="150" r="34" fill="{{${"abcda"[i]}}}"/>`).join("\n")}
+${[0, 1, 2, 3, 4].map((i) => `    <circle id="SCENEID-k${i}" cx="${55 + i * 120}" cy="400" r="34" fill="{{${"abcda"[i]}}}"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-links" data-cue="3" transform="${INSIDE}">
+${[0, 1, 2, 3, 4].flatMap(
+      (a) => [0, 1, 2, 3, 4].map(
+        (b) => `    <line id="SCENEID-l${a}${b}" x1="${55 + a * 120}" y1="186" x2="${55 + b * 120}" y2="364" stroke="{{accent}}" stroke-width="${a === 2 ? 7 : 4}" stroke-linecap="round"/>`
+      )
+    ).join("\n")}
+  </g>
+  <g id="SCENEID-pulse" data-cue="4">
+${SLABS.map((x, i) => `    <rect id="SCENEID-glow${i}" x="${x}" y="150" width="104" height="440" rx="18" fill="{{accent}}"/>`).join("\n")}
+  </g>
+</svg>`,
+    css: "",
+    script: `// Layout (box 1700x732): "\xD7 12" centre top \xB7 12 slabs x 70-1626, y 150-590 \xB7 input/output
+// under the ends. Block 6 (x 730-834) has an inside drawn in its own units at half scale
+// (x 645-919, y 263-477): only legible with the camera in (viewBox 482 240.8 600 258.4,
+// 2.83x), so it shows only then. overflow:hidden on the svg keeps the zoomed view in its box.
+var slabs = [], glows = [];
+for (var i = 0; i < 12; i++) {
+  slabs.push("#SCENEID-slab" + i);
+  glows.push("#SCENEID-glow" + i);
+}
+var links = root.querySelectorAll("#SCENEID-links line");
+var row3 = ["#SCENEID-l20", "#SCENEID-l21", "#SCENEID-l22", "#SCENEID-l23", "#SCENEID-l24"];
+var labels = ["#SCENEID-times", "#SCENEID-in", "#SCENEID-out"];
+var wide = "0 0 1700 732";
+var close = "482 240.8 600 258.4";
+
+gsap.set("#SCENEID-svg", { attr: { viewBox: wide } });
+gsap.set(slabs, { scaleY: 0, transformOrigin: "50% 100%" });
+gsap.set(labels, { opacity: 0 });
+gsap.set("#SCENEID-inside", { opacity: 0 });
+gsap.set(links, { drawSVG: "0% 0%", opacity: 0 });
+gsap.set(glows, { opacity: 0 });
+
+// C1 1.0-4.8 "a stack of twelve identical blocks." \u2014 a staggered build, then the count lands.
+tl.to(slabs, { scaleY: 1, duration: 0.6, ease: "expo.out", stagger: 0.12 }, 1.0);
+tl.to(["#SCENEID-in", "#SCENEID-out"], { opacity: 1, duration: 0.4 }, 2.4);
+tl.to("#SCENEID-times", { opacity: 1, duration: 0.5 }, 2.9);
+tl.to(slabs, { y: -10, duration: 0.3, yoyo: true, repeat: 1, ease: "sine.inOut", stagger: 0.08 }, 3.4);
+
+// C2 4.8-9.2 "Inside each one, attention" \u2014 the camera flies into block 6; the others become ghosts.
+tl.to(labels, { opacity: 0, duration: 0.3 }, 4.85);
+tl.to("#SCENEID-svg", { attr: { viewBox: close }, duration: 1.4, ease: "power3.inOut" }, 4.9);
+tl.to(slabs, { opacity: 0.15, duration: 0.5 }, 5.9);
+tl.to("#SCENEID-inside", { opacity: 1, duration: 0.5 }, 6.2);
+tl.to("#SCENEID-att", { scale: 1.08, transformOrigin: "50% 50%", duration: 0.4, yoyo: true, repeat: 3, ease: "sine.inOut" }, 7.2);
+
+// C3 9.2-13.6 "lets every token read from every other." \u2014 every link draws; one token's reads are the focus.
+tl.to(links, { opacity: 0.35, duration: 0.01 }, 9.25);
+tl.to(links, { drawSVG: "0% 100%", duration: 0.6, ease: "power2.out", stagger: 0.06 }, 9.3);
+tl.to(row3, { opacity: 1, duration: 0.4 }, 11.4);
+tl.to("#SCENEID-q2", { scale: 1.3, transformOrigin: "50% 50%", duration: 0.4, yoyo: true, repeat: 3 }, 11.6);
+
+// C4 13.6-18.0 "the next block does it again, twelve times over." \u2014 out to the whole; block after block lights.
+tl.to(["#SCENEID-inside", "#SCENEID-links"], { opacity: 0, duration: 0.3 }, 13.65);
+tl.to(slabs, { opacity: 1, duration: 0.4 }, 13.9);
+tl.to("#SCENEID-svg", { attr: { viewBox: wide }, duration: 1.3, ease: "power3.inOut" }, 13.9);
+tl.to(labels, { opacity: 1, duration: 0.4 }, 15.0);
+tl.to(glows, { opacity: 0.5, duration: 0.3, ease: "power2.out", stagger: 0.14 }, 15.3);`
+  }
+};
+var SPREAD = Array.from({ length: 24 }, (_, i) => {
+  const h = (n3) => {
+    const s = Math.sin(n3 * 12.9898) * 43758.5453;
+    return s - Math.floor(s);
+  };
+  return { x: Math.round(160 + h(i + 1) * 1380), y: Math.round(210 + h(i + 31) * 380) };
+});
+var BELL = (() => {
+  const counts = [1, 2, 3, 4, 4, 4, 3, 2, 1];
+  const slots2 = [];
+  counts.forEach((c, b) => {
+    for (let k = 0; k < c; k++) slots2.push([850 + (b - 4) * 150, 596 - k * 68]);
+  });
+  const byX = SPREAD.map((p, i) => ({ i, x: p.x })).sort((a, b) => a.x - b.x);
+  const to = new Array(24);
+  byX.forEach((d, rank) => {
+    to[d.i] = slots2[rank];
+  });
+  return to;
+})();
+var OUTLIERS = [0, 7, 14, 21];
+var gather = {
+  name: "gather",
+  shows: "one set of objects keeps its identity through a change of state: a scatter whose outliers are singled out, then every dot TRAVELS (staggered) into a bell on a shared axis, a band marks one standard deviation and a counter measures the spread shrinking",
+  fits: ["split-compare", "bar-compare", "grid", "claim-figure", "definition", "concept"],
+  cues: [
+    { t0: 1, t1: 4.8, text: "Without normalization, activations spread wide," },
+    { t0: 4.8, t1: 9, text: "and a few outliers dominate every update." },
+    { t0: 9, t1: 13.4, text: "Normalizing reshapes them onto one standard scale," },
+    { t0: 13.4, t1: 17.6, text: "cutting the spread from three point two to one." }
+  ],
+  duration: 18.8,
+  fragment: {
+    markup: `<svg id="SCENEID-svg" width="1700" height="732" viewBox="0 0 1700 732" style="position:absolute;left:0;top:0;overflow:visible">
+  <g id="SCENEID-scale" data-cue="1">
+    <line id="SCENEID-axis" x1="120" y1="652" x2="1580" y2="652" stroke="{{muted}}" stroke-width="5" stroke-linecap="round"/>
+    <text id="SCENEID-lo" x="120" y="702" font-size="48" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">\u22123\u03C3</text>
+    <text id="SCENEID-mid" x="850" y="702" font-size="48" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">0</text>
+    <text id="SCENEID-hi" x="1580" y="702" font-size="48" fill="{{muted}}" text-anchor="middle" dominant-baseline="middle">+3\u03C3</text>
+    <text id="SCENEID-sigma" x="850" y="60" font-size="96" font-weight="700" fill="{{fg}}" text-anchor="end" dominant-baseline="middle">\u03C3 =</text>
+    <text id="SCENEID-sigma-n" x="880" y="60" font-size="96" font-weight="700" fill="{{fg}}" dominant-baseline="middle">3.2</text>
+  </g>
+  <g id="SCENEID-band" data-cue="4">
+    <rect id="SCENEID-band-fill" x="700" y="130" width="300" height="500" rx="16" fill="{{accent}}" fill-opacity="0.16"/>
+  </g>
+  <g id="SCENEID-dots" data-cue="1">
+${SPREAD.map((p, i) => `    <circle id="SCENEID-d${i}" cx="${p.x}" cy="${p.y}" r="${OUTLIERS.includes(i) ? 36 : 26}" fill="{{${OUTLIERS.includes(i) ? "d" : "a"}}}"/>`).join("\n")}
+  </g>
+  <g id="SCENEID-outliers" data-cue="2">
+${OUTLIERS.map((i, k) => `    <circle id="SCENEID-ring${k}" cx="${SPREAD[i]?.x}" cy="${SPREAD[i]?.y}" r="54" fill="none" stroke="{{d}}" stroke-width="6"/>`).join("\n")}
+    <text id="SCENEID-outlier-label" x="1600" y="60" font-size="52" fill="{{d}}" text-anchor="end" dominant-baseline="middle">outliers</text>
+  </g>
+  <g id="SCENEID-norm" data-cue="3">
+    <text id="SCENEID-norm-label" x="200" y="60" font-size="52" fill="{{accent}}" dominant-baseline="middle">normalized</text>
+  </g>
+  <g id="SCENEID-band-tag" data-cue="4">
+    <text id="SCENEID-band-label" x="850" y="176" font-size="64" font-weight="700" fill="{{accent}}" text-anchor="middle" dominant-baseline="middle">\xB11\u03C3</text>
+  </g>
+</svg>`,
+    css: "",
+    script: `// Layout (box 1700x732): \u03C3 readout top centre \xB7 scatter x 150-1550, y 200-600 \xB7 axis at
+// y 652 (x 120-1580) with \u22123\u03C3/0/+3\u03C3 under it. The same 24 dots travel into a bell of
+// 9 bins on that axis (x 250-1450, stacks up from y 600) \u2014 one set changing state,
+// not two pictures \u2014 and a \xB11\u03C3 band (x 700-1000) lands behind them.
+var dots = [], rest = [], rings = [];
+for (var i = 0; i < 24; i++) {
+  dots.push("#SCENEID-d" + i);
+  if (i % 7 !== 0) rest.push("#SCENEID-d" + i);
+}
+for (var k = 0; k < 4; k++) rings.push("#SCENEID-ring" + k);
+var from = ${JSON.stringify(SPREAD.map((p) => [p.x, p.y]))};
+var to = ${JSON.stringify(BELL)};
+
+gsap.set(dots, { scale: 0, transformOrigin: "50% 50%", x: 0, y: 0 });
+gsap.set("#SCENEID-axis", { drawSVG: "50% 50%" });
+gsap.set(["#SCENEID-lo", "#SCENEID-mid", "#SCENEID-hi", "#SCENEID-sigma", "#SCENEID-sigma-n"], { opacity: 0 });
+gsap.set(rings, { drawSVG: "0% 0%", opacity: 0 });
+gsap.set("#SCENEID-outlier-label", { opacity: 0 });
+gsap.set("#SCENEID-norm-label", { opacity: 0, x: -40 });
+gsap.set("#SCENEID-band-fill", { scaleX: 0, transformOrigin: "50% 50%" });
+gsap.set("#SCENEID-band-label", { opacity: 0 });
+
+// C1 1.0-4.8 "activations spread wide," \u2014 the scatter lands, the scale opens under it.
+tl.to(dots, { scale: 1, duration: 0.45, ease: "back.out(2)", stagger: 0.06 }, 1.0);
+tl.to("#SCENEID-axis", { drawSVG: "0% 100%", duration: 1.1, ease: "power3.out" }, 2.4);
+tl.to(["#SCENEID-lo", "#SCENEID-mid", "#SCENEID-hi"], { opacity: 1, duration: 0.4 }, 2.9);
+tl.to(["#SCENEID-sigma", "#SCENEID-sigma-n"], { opacity: 1, duration: 0.4 }, 3.1);
+tl.to(dots, { y: -8, duration: 0.5, yoyo: true, repeat: 1, ease: "sine.inOut", stagger: 0.03 }, 3.6);
+
+// C2 4.8-9.0 "a few outliers dominate every update." \u2014 focus: rings draw on the four, the rest dim.
+tl.to(rings, { opacity: 1, duration: 0.01, stagger: 0.2 }, 4.9);
+tl.to(rings, { drawSVG: "0% 100%", duration: 0.6, ease: "power2.out", stagger: 0.2 }, 4.9);
+tl.to("#SCENEID-outlier-label", { opacity: 1, duration: 0.4 }, 5.6);
+tl.to(rest, { opacity: 0.3, duration: 0.5 }, 6.0);
+tl.to(rings, { scale: 1.15, transformOrigin: "50% 50%", duration: 0.4, yoyo: true, repeat: 3, ease: "sine.inOut" }, 6.8);
+
+// C3 9.0-13.4 "Normalizing reshapes them onto one standard scale," \u2014 every dot travels into the bell.
+tl.to(rings.concat(["#SCENEID-outlier-label"]), { opacity: 0, duration: 0.4 }, 9.05);
+tl.to(rest, { opacity: 1, duration: 0.4 }, 9.1);
+tl.to("#SCENEID-norm-label", { opacity: 1, x: 0, duration: 0.5, ease: "power3.out" }, 9.2);
+for (var n = 0; n < 24; n++) {
+  tl.to(dots[n], { x: to[n][0] - from[n][0], y: to[n][1] - from[n][1], attr: { r: 30 }, fill: "{{accent}}", duration: 1.2, ease: "power3.inOut" }, 9.5 + n * 0.07);
+}
+
+// C4 13.4-17.6 "cutting the spread from three point two to one." \u2014 the band opens, the number follows it.
+tl.to("#SCENEID-band-fill", { scaleX: 1, duration: 0.9, ease: "power3.out" }, 13.5);
+tl.to("#SCENEID-band-label", { opacity: 1, duration: 0.4 }, 14.1);
+tl.to("#SCENEID-sigma-n", { textContent: 1, snap: { textContent: 0.1 }, fill: "{{accent}}", duration: 1.4, ease: "power3.inOut" }, 13.6);
+tl.to(dots, { scale: 1.12, duration: 0.35, yoyo: true, repeat: 3, ease: "sine.inOut", stagger: 0.02 }, 15.3);`
+  }
+};
+
+// src/bespoke/untangle.ts
+import { parse as parse2 } from "acorn";
 
 // src/index.ts
 async function buildDeck(storyboard, source, outDir, opts = {}) {
@@ -14712,8 +15948,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   if (!format) throw new Error("no deck-16x9 format");
   const step = opts.onStep ?? (() => {
   });
-  const out = resolve6(outDir);
-  await mkdir10(out, { recursive: true });
+  const out = resolve7(outDir);
+  await mkdir11(out, { recursive: true });
   const speed = opts.speed ?? 1;
   const design2 = opts.design ?? storyboard.design ?? "classic";
   const theme = pickTheme(storyboard, source, format, {
@@ -14732,12 +15968,13 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
     ...opts.narration ? { narration: opts.narration } : {},
     ...opts.onBeatError ? { onBeatError: opts.onBeatError } : {},
     ...opts.onBeatWarning ? { onBeatWarning: opts.onBeatWarning } : {},
-    ...fontCss ? { fontCss } : {}
+    ...fontCss ? { fontCss } : {},
+    ...opts.bespoke ? { bespoke: opts.bespoke } : {}
   });
   const files = [];
   const write = async (name, text2) => {
-    await writeFile12(join13(out, name), text2);
-    files.push(join13(out, name));
+    await writeFile13(join14(out, name), text2);
+    files.push(join14(out, name));
   };
   await write("index.html", deck.composition);
   await write("hyperframes.json", HYPERFRAMES_JSON);
@@ -14756,7 +15993,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
       beats: deck.cut.kept,
       speed,
       ...opts.narration ? { narration: opts.narration } : {},
-      ...opts.theme ? { theme: opts.theme } : {}
+      ...opts.theme ? { theme: opts.theme } : {},
+      ...opts.bespoke ? { bespoke: opts.bespoke } : {}
     });
     await write(TIMING_FILE, `${JSON.stringify(timing, null, 2)}
 `);
@@ -14768,20 +16006,21 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   }
   if (deck.page) {
     await write(DECK_PAGE, deck.page);
-    await cp2(playerBundle(), join13(out, PLAYER_FILE));
-    files.push(join13(out, PLAYER_FILE));
+    await cp2(playerBundle(), join14(out, PLAYER_FILE));
+    files.push(join14(out, PLAYER_FILE));
   }
   files.push(...await vendorKatex(out));
   files.push(...await vendorScripts(out, deck.composition));
   if (opts.assetsFrom) {
     files.push(...await copyAssets(opts.assetsFrom, out, source.figures, step));
   }
+  if (opts.bespoke) files.push(...await copyArt(Object.values(opts.bespoke), out));
   if (opts.narration && opts.audioFrom) {
     files.push(...await copyAudio(opts.audioFrom, opts.narration, out, step));
   }
   const of = deck.cut.kept.length === storyboard.beats.length ? "" : ` of ${storyboard.beats.length}`;
   step(
-    `build: ${deck.cut.kept.length}${of} beats at ${format.width}\xD7${format.height} \u2192 ${join13(out, "index.html")}`
+    `build: ${deck.cut.kept.length}${of} beats at ${format.width}\xD7${format.height} \u2192 ${join14(out, "index.html")}`
   );
   for (const d of deck.cut.dropped) step(`build:   cut ${d.beat.id} \u2014 ${d.reason}`);
   for (const d of deck.cut.dangling) step(`build:   check the wording \u2014 ${d.reason}`);
@@ -14799,7 +16038,7 @@ var HYPERFRAMES_JSON = `${JSON.stringify(
 async function deckRuntime() {
   const path2 = fileURLToPath2(new URL(`./${"deck-runtime.js"}`, import.meta.url));
   try {
-    return await readFile12(path2, "utf8");
+    return await readFile13(path2, "utf8");
   } catch {
     throw new Error(`Deck runtime missing at ${path2}. Run "npm run build" first.`);
   }
@@ -14807,14 +16046,14 @@ async function deckRuntime() {
 function playerBundle() {
   const require2 = createRequire4(import.meta.url);
   try {
-    return join13(dirname5(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
+    return join14(dirname5(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
   } catch {
     throw new Error('Cannot locate the hyperframes player. Run "npm install".');
   }
 }
 
 // src/server/upload.ts
-import { posix, sep as sep2 } from "node:path";
+import { posix, sep as sep3 } from "node:path";
 import { unzipSync as unzipSync2 } from "fflate";
 var MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
 var ZIP_LIMITS = {
@@ -14852,7 +16091,7 @@ function safeEntryPath(name) {
   return path2;
 }
 function insideRoot2(root2, joined) {
-  return joined === root2 || joined.startsWith(root2.endsWith(sep2) ? root2 : root2 + sep2);
+  return joined === root2 || joined.startsWith(root2.endsWith(sep3) ? root2 : root2 + sep3);
 }
 function readZip(bytes, limits = ZIP_LIMITS) {
   const seen = [];
@@ -15156,8 +16395,8 @@ function int(name, raw2) {
 }
 
 // src/server/pipeline.ts
-import { mkdir as mkdir11, readFile as readFile13, stat as stat3, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname6, isAbsolute, join as join14, relative, resolve as resolve7 } from "node:path";
+import { mkdir as mkdir12, readFile as readFile14, stat as stat4, writeFile as writeFile14 } from "node:fs/promises";
+import { dirname as dirname6, isAbsolute, join as join15, relative, resolve as resolve8 } from "node:path";
 var AUDIO_DIR = "audio";
 var NARRATION_FILE = "narration.json";
 var MAX_REMOTE_FIGURES = 40;
@@ -15180,10 +16419,10 @@ function stagesFor(options) {
 async function runPipeline(job, input) {
   const { options } = input;
   const dirs = {
-    upload: join14(job.dir, "upload"),
-    src: join14(job.dir, "src"),
-    audio: join14(job.dir, AUDIO_DIR),
-    deck: join14(job.dir, "deck")
+    upload: join15(job.dir, "upload"),
+    src: join15(job.dir, "src"),
+    audio: join15(job.dir, AUDIO_DIR),
+    deck: join15(job.dir, "deck")
   };
   const warnings = [...options.warnings];
   const url = (rel) => `/d/${job.id}/${rel}`;
@@ -15207,21 +16446,21 @@ async function runPipeline(job, input) {
     theme: options.stated.theme ? prefs.theme : planned.theme
   };
   assertRefsResolve(storyboard, source, { pending: options.images ? "allow" : "refuse" });
-  await writeJson(join14(job.dir, "storyboard.json"), storyboard);
+  await writeJson(join15(job.dir, "storyboard.json"), storyboard);
   job.done("plan", `${storyboard.beats.length} beats`);
   for (const f of scanBeatCount(storyboard, prefs)) warnings.push(f.message);
   if (options.images) {
     job.begin("illustrate");
     const drawn = await illustrate(storyboard, source, {
       prefs,
-      assetsDir: join14(dirs.src, "assets"),
+      assetsDir: join15(dirs.src, "assets"),
       ...input.imageChain ? { chain: input.imageChain } : {},
       onStep: (line2) => job.log(line2)
     });
     storyboard = drawn.storyboard;
     source = drawn.source;
-    await writeJson(join14(dirs.src, "source.json"), source);
-    await writeJson(join14(job.dir, "storyboard.json"), storyboard);
+    await writeJson(join15(dirs.src, "source.json"), source);
+    await writeJson(join15(job.dir, "storyboard.json"), storyboard);
     for (const p of drawn.illustrated) {
       job.log(
         `illustrate: ${p.beatId} \u2192 assets/${p.src} via ${p.provider}${p.cached ? " (cached)" : ""}`
@@ -15243,7 +16482,7 @@ async function runPipeline(job, input) {
       warnings.push("the plan had nothing to say aloud, so the deck is silent");
     } else {
       job.log(`narrate: ${speaking} of ${storyboard.beats.length} beats speak`);
-      await mkdir11(dirs.audio, { recursive: true });
+      await mkdir12(dirs.audio, { recursive: true });
       const staged = pickTheme(storyboard, source, options.format, {
         stated: options.stated.theme ? prefs.theme : void 0,
         design: prefs.design ?? storyboard.design ?? "classic",
@@ -15254,7 +16493,7 @@ async function runPipeline(job, input) {
         dir: dirs.audio,
         format: options.format
       });
-      await writeJson(join14(dirs.audio, NARRATION_FILE), spoken);
+      await writeJson(join15(dirs.audio, NARRATION_FILE), spoken);
       narration = { ...spoken, dir: AUDIO_DIR };
       const segments2 = Object.values(spoken.beats).flat();
       const seconds = segments2.reduce((sum, s) => sum + s.seconds, 0);
@@ -15312,7 +16551,7 @@ async function runPipeline(job, input) {
       job.log("render: capturing frames \u2014 two minutes for a four-minute video");
       const out = await render({
         deck: dirs.deck,
-        out: join14(dirs.deck, "video.mp4"),
+        out: join15(dirs.deck, "video.mp4"),
         subtitles: "sidecar",
         log: (line2) => job.log(line2),
         // The last of the three length levers, and the only one that acts on a
@@ -15361,8 +16600,8 @@ async function runPipeline(job, input) {
   };
 }
 async function ingest(job, input, dirs, warnings) {
-  await mkdir11(dirs.upload, { recursive: true });
-  const root2 = resolve7(dirs.upload);
+  await mkdir12(dirs.upload, { recursive: true });
+  const root2 = resolve8(dirs.upload);
   let docPath;
   const upload = input.upload;
   const bothOrNeither = new UploadError(
@@ -15372,13 +16611,13 @@ async function ingest(job, input, dirs, warnings) {
   );
   if (input.url !== void 0) {
     if (upload !== void 0) throw bothOrNeither;
-    const harvested = await harvestBounded(input.url, join14(root2, "assets"), {
+    const harvested = await harvestBounded(input.url, join15(root2, "assets"), {
       ...HARVEST_LIMITS,
       ...input.harvest
     });
     warnings.push(...harvested.warnings);
-    docPath = join14(root2, "document.md");
-    await writeFile13(docPath, harvested.markdown);
+    docPath = join15(root2, "document.md");
+    await writeFile14(docPath, harvested.markdown);
     job.log(
       `ingest: harvested ${input.url} \u2014 "${harvested.title}", ${harvested.assets.length} asset(s)`
     );
@@ -15394,13 +16633,13 @@ async function ingest(job, input, dirs, warnings) {
     const { files, warnings: zipWarnings } = readZip(upload.bytes);
     warnings.push(...zipWarnings);
     for (const [rel, bytes] of Object.entries(files)) {
-      const to = resolve7(join14(root2, rel));
+      const to = resolve8(join15(root2, rel));
       if (!insideRoot2(root2, to))
         throw new UploadError(`Refusing to write ${rel}.`, "Re-zip from inside the folder.");
-      await mkdir11(dirname6(to), { recursive: true });
-      await writeFile13(to, bytes);
+      await mkdir12(dirname6(to), { recursive: true });
+      await writeFile14(to, bytes);
     }
-    docPath = join14(root2, pickMarkdown(files));
+    docPath = join15(root2, pickMarkdown(files));
     job.log(
       `ingest: unpacked ${Object.keys(files).length} file(s), reading ${pickMarkdown(files)}`
     );
@@ -15412,10 +16651,10 @@ async function ingest(job, input, dirs, warnings) {
         `DeckSmith reads ${MARKDOWN_EXTS.join(", ")} or a .zip containing one. Export the document to markdown first.`
       );
     }
-    docPath = join14(root2, "document.md");
-    await writeFile13(docPath, upload.bytes);
+    docPath = join15(root2, "document.md");
+    await writeFile14(docPath, upload.bytes);
   }
-  const text2 = await readFile13(docPath, "utf8");
+  const text2 = await readFile14(docPath, "utf8");
   const parsed = parseMarkdown(text2, {
     lang: input.options.stated.lang ? input.options.prefs.lang : void 0
   });
@@ -15435,8 +16674,8 @@ async function ingest(job, input, dirs, warnings) {
     `ingest: ${parsed.sections.length} sections, ${parsed.figures.length} figures, ${parsed.equations.length} equations, ${parsed.tables.length} tables`
   );
   const guarded = await guardFigures(parsed, root2, input.fetchRemoteFigures, warnings);
-  const source = await fetchFigures(guarded, join14(resolve7(dirs.src), "assets"), warnings);
-  await writeJson(join14(dirs.src, "source.json"), source);
+  const source = await fetchFigures(guarded, join15(resolve8(dirs.src), "assets"), warnings);
+  await writeJson(join15(dirs.src, "source.json"), source);
   return source;
 }
 async function harvestBounded(url, dir, opts) {
@@ -15512,12 +16751,12 @@ async function guardFigures(source, root2, allowRemote, warnings) {
       warnings.push(`figure ${figure.id} was left out: "${scheme}:" figures are not read`);
       continue;
     }
-    const abs = isAbsolute(src) ? resolve7(src) : resolve7(join14(root2, src.replace(/^\.?\//, "")));
+    const abs = isAbsolute(src) ? resolve8(src) : resolve8(join15(root2, src.replace(/^\.?\//, "")));
     if (!insideRoot2(root2, abs)) {
       warnings.push(`figure ${figure.id} was left out: "${src}" points outside the upload`);
       continue;
     }
-    if (!(await stat3(abs).catch(() => null))?.isFile()) {
+    if (!(await stat4(abs).catch(() => null))?.isFile()) {
       warnings.push(`figure ${figure.id} was left out: "${src}" is not in the upload`);
       continue;
     }
@@ -15527,19 +16766,19 @@ async function guardFigures(source, root2, allowRemote, warnings) {
 }
 async function pack2(job, ctx) {
   try {
-    const assets = join14(resolve7(ctx.dirs.src), "assets");
+    const assets = join15(resolve8(ctx.dirs.src), "assets");
     const requests = ctx.source.figures.map((f) => ({
       id: f.id,
-      url: join14(assets, f.src),
+      url: join15(assets, f.src),
       prefer: "bake"
     }));
     const plan = await planMedia(requests, async (url) => ({
-      bytes: new Uint8Array(await readFile13(url))
+      bytes: new Uint8Array(await readFile14(url))
     }));
     const files = { ...plan.files };
     if (ctx.narration) {
       for (const name of audioNames2(ctx.narration)) {
-        files[`${AUDIO_DIR}/${name}`] = new Uint8Array(await readFile13(join14(ctx.dirs.audio, name)));
+        files[`${AUDIO_DIR}/${name}`] = new Uint8Array(await readFile14(join15(ctx.dirs.audio, name)));
       }
     }
     const container = {
@@ -15556,10 +16795,10 @@ async function pack2(job, ctx) {
       },
       source: ctx.source,
       storyboard: ctx.storyboard,
-      ...ctx.narration ? { narration: await readJson(join14(ctx.dirs.audio, NARRATION_FILE)) } : {},
+      ...ctx.narration ? { narration: await readJson(join15(ctx.dirs.audio, NARRATION_FILE)) } : {},
       media: plan.media
     };
-    const bytes = await writePack(container, files, join14(ctx.dirs.deck, "deck.deck"));
+    const bytes = await writePack(container, files, join15(ctx.dirs.deck, "deck.deck"));
     job.log(`pack: ${Math.round(bytes / 1024)} KB \u2192 deck.deck`);
     return ctx.url("deck.deck");
   } catch (err) {
@@ -15582,12 +16821,12 @@ function host(src) {
   }
 }
 async function writeJson(path2, value) {
-  await mkdir11(dirname6(path2), { recursive: true });
-  await writeFile13(path2, `${JSON.stringify(value, null, 2)}
+  await mkdir12(dirname6(path2), { recursive: true });
+  await writeFile14(path2, `${JSON.stringify(value, null, 2)}
 `);
 }
 async function readJson(path2) {
-  return JSON.parse(await readFile13(path2, "utf8"));
+  return JSON.parse(await readFile14(path2, "utf8"));
 }
 
 // src/server/errors.ts
@@ -15993,14 +17232,14 @@ var PAGE_BUDGET = {
   refs: "relative"
 };
 async function readPage(url, work2) {
-  await mkdir12(work2, { recursive: true });
-  const dir = await mkdtemp3(join15(work2, "harvest-"));
+  await mkdir13(work2, { recursive: true });
+  const dir = await mkdtemp3(join16(work2, "harvest-"));
   try {
     const page = await harvest(url, dir, PAGE_BUDGET);
     const files = {
       "document.md": new TextEncoder().encode(page.markdown)
     };
-    for (const asset of page.assets) files[basename5(asset)] = await readFile14(asset);
+    for (const asset of page.assets) files[basename5(asset)] = await readFile15(asset);
     const warnings = [...page.warnings];
     if (page.clips.length > 0) {
       warnings.push(
@@ -16034,7 +17273,7 @@ var statusSchema = z5.object({
 var DEFAULT_WAIT = 45;
 function deckTools(opts) {
   const queue = new Queue({ maxQueued: 8 });
-  const root2 = resolve8(opts.root);
+  const root2 = resolve9(opts.root);
   let cached2;
   const found = async () => {
     cached2 ??= await (opts.probe ?? prereqs)();
@@ -16042,8 +17281,8 @@ function deckTools(opts) {
   };
   const insideRoot3 = (p) => {
     if (!isAbsolute2(p)) throw new Error(`document_path must be absolute; got "${p}".`);
-    const full = resolve8(p);
-    if (full !== root2 && !full.startsWith(root2 + sep3)) {
+    const full = resolve9(p);
+    if (full !== root2 && !full.startsWith(root2 + sep4)) {
       throw new Error(
         `document_path is outside the server's root. It may only read files under ${root2}.`
       );
@@ -16120,16 +17359,16 @@ function deckTools(opts) {
         }
       }
       const page = input.document_url === void 0 ? void 0 : await readPage(input.document_url, opts.work);
-      const filename = page ? "page.zip" : input.document_path ? input.document_path.split(sep3).pop() : "document.md";
-      const bytes = page ? page.zip : file ? await readFile14(file) : new TextEncoder().encode(input.document_text);
+      const filename = page ? "page.zip" : input.document_path ? input.document_path.split(sep4).pop() : "document.md";
+      const bytes = page ? page.zip : file ? await readFile15(file) : new TextEncoder().encode(input.document_text);
       if (bytes.byteLength > MAX_UPLOAD_BYTES) {
         throw new Error(
           `Document is ${(bytes.byteLength / 1e6).toFixed(1)} MB, over the ${(MAX_UPLOAD_BYTES / 1e6).toFixed(0)} MB cap.` + (page ? " Harvest fewer figures with a smaller maxAssets, or save the page and edit it." : "")
         );
       }
       const id2 = randomBytes(16).toString("base64url");
-      const dir = join15(opts.work, id2);
-      await mkdir12(dir, { recursive: true });
+      const dir = join16(opts.work, id2);
+      await mkdir13(dir, { recursive: true });
       queue.submit({
         id: id2,
         dir,
@@ -16156,7 +17395,7 @@ function deckTools(opts) {
   };
 }
 function dirOf(work2, id2) {
-  return join15(work2, id2);
+  return join16(work2, id2);
 }
 function waitFor(queue, id2, seconds) {
   const now = queue.view(id2);
@@ -16188,9 +17427,9 @@ function report(view, dir) {
     // (src/server/pipeline.ts). This said `src/storyboard.json` for one run, which
     // is the shape of the CLI's output directory and not the server's, and an
     // agent told to read it would have found nothing there.
-    storyboard_path: join15(dir, "storyboard.json"),
+    storyboard_path: join16(dir, "storyboard.json"),
     ...done && view.result ? {
-      deck_path: join15(dir, "deck"),
+      deck_path: join16(dir, "deck"),
       slides: view.result.slides,
       duration_seconds: view.result.duration,
       warnings: view.result.warnings
@@ -16199,7 +17438,7 @@ function report(view, dir) {
   };
 }
 function defaultWork() {
-  return join15(tmpdir4(), "decksmith-mcp");
+  return join16(tmpdir4(), "decksmith-mcp");
 }
 
 // src/mcp/main.ts