@jokerized/decksmith 0.3.2 → 0.4.1

package/dist/mcp.js

@@ -7,22 +7,70 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z as z6 } from "zod";
 
-// src/version.ts
+// src/tmpdir.ts
+import { realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-var VERSION = createRequire(import.meta.url)("../package.json").version;
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+var cached;
+function real(dir) {
+  let at = resolve(dir);
+  const tail = [];
+  for (; ; ) {
+    try {
+      return join(realpathSync(at), ...tail);
+    } catch {
+      const up = dirname(at);
+      if (up === at) return resolve(dir);
+      tail.unshift(basename(at));
+      at = up;
+    }
+  }
+}
+function packageRoot() {
+  cached ??= real(dirname(createRequire(import.meta.url).resolve("../package.json")));
+  return cached;
+}
+function insideRoot(dir) {
+  const root2 = packageRoot();
+  const at = real(dir);
+  return at === root2 || at.startsWith(root2 + sep);
+}
+function guardTmpdir() {
+  const before = tmpdir();
+  if (!insideRoot(before)) return;
+  delete process.env.TMPDIR;
+  const after = tmpdir();
+  if (insideRoot(after)) {
+    throw new Error(
+      `tmpdir: ${after} is still inside ${packageRoot()}. Set TMPDIR to a real temp directory.`
+    );
+  }
+  const worker = process.env.VITEST_WORKER_ID;
+  if (worker === void 0 || worker === "1") {
+    process.stderr.write(
+      `tmpdir: TMPDIR pointed at ${before}, inside the source tree, so every mkdtemp would land in the repo. Using ${after}. Fix the environment \u2014 this only stops the mess.
+`
+    );
+  }
+}
+
+// src/version.ts
+import { createRequire as createRequire2 } from "node:module";
+var VERSION = createRequire2(import.meta.url)("../package.json").version;
 
 // src/mcp/tools.ts
 import { randomBytes } from "node:crypto";
 import { mkdir as mkdir11, mkdtemp as mkdtemp3, readFile as readFile13, rm as rm8 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join13, resolve as resolve6, sep as sep2 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { basename as basename5, isAbsolute as isAbsolute2, join as join14, resolve as resolve7, sep as sep3 } from "node:path";
 import { zipSync as zipSync2 } from "fflate";
 import { z as z5 } from "zod";
 
 // src/index.ts
 import { cp, mkdir as mkdir9, readdir as readdir2, readFile as readFile11, stat as stat2, writeFile as writeFile11 } from "node:fs/promises";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname3, join as join11, resolve as resolve4 } from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname4, join as join12, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/pack/media.ts
@@ -415,15 +463,53 @@ var dataTableParamsSchema = z.object({
   path: ["highlight"],
   message: "every highlight must name a row that params.rows draws"
 });
+var chartPointSchema = z.object({ x: z.string(), y: z.number() });
 var lineChartParamsSchema = z.object({
   eyebrow: z.string().optional(),
   headline: z.string(),
   xLabel: z.string(),
   yLabel: z.string(),
-  points: z.array(z.object({ x: z.string(), y: z.number() })).min(2),
+  points: z.array(chartPointSchema).min(2),
   /** Inter-point annotations, e.g. per-step deltas. One fewer than `points`. */
   deltas: z.array(z.string()).optional(),
-  readout: z.string().optional()
+  readout: z.string().optional(),
+  /**
+   * THE SAME MEASUREMENT UNDER A SECOND CONDITION — a baseline the main series
+   * is to be read against, where the point is the change in the SHAPE of the
+   * curve rather than two numbers.
+   *
+   * Drawn first and alone; then the curve lifts off it and reshapes into
+   * `points`, leaving this one behind as a ghost. `label` names the ghost and
+   * is drawn wherever the chart has room for it.
+   *
+   * KEEP IT SHORT — two or three words. A label wider than the plot is refused
+   * outright, and that refusal reaches `onBeatError` and costs the whole beat.
+   * One that fits but cannot be placed clear of the axis names, the tick and
+   * category labels, the values, the deltas and both curves is DROPPED
+   * instead, silently: an unnamed ghost is still legibly the fainter, earlier
+   * curve, where a name printed through a number is a defect in both of them.
+   * Nothing warns about that one — see the placement note in
+   * `src/emit/archetypes/line-chart.ts`.
+   */
+  compare: z.object({ label: z.string(), points: z.array(chartPointSchema).min(2) }).optional()
+}).superRefine((p, ctx) => {
+  if (!p.compare) return;
+  if (p.compare.points.length !== p.points.length) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["compare", "points"],
+      message: `compare has ${p.compare.points.length} points against ${p.points.length}; a comparison is over the same x values`
+    });
+    return;
+  }
+  const off = p.compare.points.findIndex((c, i) => c.x !== p.points[i]?.x);
+  if (off >= 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["compare", "points", off, "x"],
+      message: `compare point ${off} is "${p.compare.points[off]?.x}" where points has "${p.points[off]?.x}"`
+    });
+  }
 });
 var calloutParamsSchema = z.object({
   eyebrow: z.string().optional(),
@@ -1171,7 +1257,7 @@ function clock(seconds) {
 // src/source/fonts.ts
 import { createHash as createHash2 } from "node:crypto";
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 function familyFor(lang) {
   const tag = lang.toLowerCase();
   if (tag.startsWith("ko")) return "Noto Sans KR";
@@ -1187,9 +1273,9 @@ async function bundleFont(lang, glyphs, dir) {
   const stamp = `/* decksmith ${createHash2("sha256").update(`${family}
 ${text2}`).digest("hex").slice(0, 16)} */`;
   await mkdir(dir, { recursive: true });
-  const cssPath = join(dir, "fonts.css");
-  const cached = await readFile2(cssPath, "utf8").catch(() => "");
-  if (cached.startsWith(stamp)) return { family, css: cached, files: localNames(cached) };
+  const cssPath = join2(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?family=${family.replaceAll(" ", "+")}:wght@400;500;700&text=${encodeURIComponent(text2)}&display=block`,
     { headers: { "User-Agent": UA } }
@@ -1203,7 +1289,7 @@ ${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(join(dir, name), Buffer.from(await font.arrayBuffer()));
+    await writeFile(join2(dir, name), Buffer.from(await font.arrayBuffer()));
     css = css.replaceAll(url, name);
     files.push(name);
   }
@@ -1402,6 +1488,21 @@ function nv(v) {
 }
 var DRAW_FROM = { drawSVG: "0%" };
 var DRAW_TO = { drawSVG: "100%" };
+var SHAPE_INDEX = 0;
+function reshape(target, to, at, seconds, first) {
+  if (!(seconds > 0)) throw new Error(`reshape ${target}: ${seconds}s is no time to reshape in`);
+  return fromTo(
+    target,
+    { morphSVG: { shape: target, shapeIndex: SHAPE_INDEX } },
+    {
+      morphSVG: { shape: to, shapeIndex: SHAPE_INDEX },
+      duration: sec(seconds),
+      ease: "power2.inOut",
+      ...first ? {} : { immediateRender: false }
+    },
+    sec(at)
+  );
+}
 function travel(target, route, at, seconds) {
   if (!(seconds > 0)) throw new Error(`travel ${target}: ${seconds}s is no time to travel in`);
   const legs = [];
@@ -4083,6 +4184,12 @@ var CHART_GAP = 60;
 var READOUT_W = 460;
 var READOUT_LH = 1.35;
 var TALL_ASPECT = 1.15;
+var RESHAPE_SECONDS = 1.2;
+var GHOST_OPACITY = 0.28;
+var DRAW_SECONDS = 1.8;
+var DRAW_FLOOR = 1;
+var SEPARATE = 0.5;
+var STEP_FLOOR = 0.15;
 function chartScale(values) {
   const lo = Math.min(...values);
   const hi = Math.max(...values);
@@ -4113,7 +4220,8 @@ var lineChart = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
   const face = faceOf(theme.fontStack);
-  const scale = chartScale(p.points.map((pt) => pt.y));
+  const cmp = p.compare;
+  const scale = chartScale([...p.points, ...cmp?.points ?? []].map((pt) => pt.y));
   const box = contentW(ctx.format);
   const tall = isPortrait(ctx.format);
   const width = tall ? box : box - (p.readout ? CHART_GAP + READOUT_W : 0);
@@ -4156,11 +4264,15 @@ var lineChart = (beat, ctx) => {
   const LABEL_SIZE3 = 40;
   const runW = (s) => textWidth(s, LABEL_SIZE3, 400, 0, false, face);
   const catW = (s) => textWidth(s, LABEL_SIZE3, 400, 0, false, face);
+  const nameW = (s) => textWidth(s, LABEL_SIZE3, 500, 0, false, face);
+  const ghostW = (s) => textWidth(s, LABEL_SIZE3, 600, 0, false, face);
   const shownX = fitIndices((i) => catW(p.points[i]?.x ?? ""), false);
   const xLabels = p.points.map(
     (pt, i) => shownX.has(i) ? `<text x="${n2(x(i))}" y="${H - PAD2.b + 56}">${esc(pt.x)}</text>` : ""
   ).join("");
-  const path2 = p.points.map((pt, i) => `${i === 0 ? "M" : "L"}${n2(x(i))},${n2(y(pt.y))}`).join(" ");
+  const pathOf = (pts) => pts.map((pt, i) => `${i === 0 ? "M" : "L"}${n2(x(i))},${n2(y(pt.y))}`).join(" ");
+  const path2 = pathOf(p.points);
+  const basePath = cmp ? pathOf(cmp.points) : "";
   const dots = p.points.map(
     (pt, i) => `<circle class="dot" cx="${n2(x(i))}" cy="${n2(y(pt.y))}" r="${i === p.points.length - 1 ? 11 : 9}" fill="${i === p.points.length - 1 ? theme.tones.b : theme.accent}" />`
   ).join("");
@@ -4196,6 +4308,75 @@ var lineChart = (beat, ctx) => {
   }).join("");
   const first = { x: x(0), y: y(p.points[0]?.y ?? 0) };
   const ring = p.points.length > 1 ? `<circle id="${sid}-ring" cx="${n2(first.x)}" cy="${n2(first.y)}" r="20" fill="none" stroke="${theme.tones.b}" stroke-width="5" opacity="0" />` : "";
+  const lineTag = (part, d, extra = "") => `<path class="chartline" id="${sid}-${part}" d="${d}" fill="none" stroke="${theme.accent}"${extra} />`;
+  const chartlines = cmp ? [
+    lineTag("base", basePath),
+    lineTag("line", basePath, ' opacity="0"'),
+    `<path id="${sid}-target" d="${path2}" fill="none" stroke="none" />`
+  ].join("\n    ") : lineTag("line", path2);
+  const curveBand = (pts, x0, x1) => {
+    const ys = [];
+    const py = (i) => y(pts[i]?.y ?? 0);
+    for (let i = 0; i < pts.length; i++) {
+      if (x(i) >= x0 && x(i) <= x1) ys.push(py(i));
+    }
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const [ax, bx] = [x(i), x(i + 1)];
+      for (const edge of [x0, x1]) {
+        if (edge > Math.min(ax, bx) && edge < Math.max(ax, bx)) {
+          ys.push(py(i) + (py(i + 1) - py(i)) * (edge - ax) / (bx - ax));
+        }
+      }
+    }
+    return ys.length > 0 ? [Math.min(...ys), Math.max(...ys)] : [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  };
+  const fixedBoxes = [
+    // `.axname` is the one run here set at weight 500 rather than 400, and
+    // under-charging a width is the unrecoverable direction (see `padR`).
+    // No `text-anchor` on the y half, so it runs rightwards from x=0.
+    { x: 0, y: 42 - LABEL_SIZE3, w: nameW(p.yLabel), h: LABEL_SIZE3 },
+    {
+      x: PAD2.l + plotW / 2 - nameW(p.xLabel) / 2,
+      y: H - 16 - LABEL_SIZE3,
+      w: nameW(p.xLabel),
+      h: LABEL_SIZE3
+    },
+    ...ticks.map((v) => {
+      const w = runW(v.toFixed(scale.decimals));
+      return { x: PAD2.l - 22 - w, y: y(v) + 13 - LABEL_SIZE3, w, h: LABEL_SIZE3 };
+    }),
+    ...p.points.map((pt, i) => ({ pt, i })).filter(({ i }) => shownX.has(i)).map(({ pt, i }) => labelBox(x(i), H - PAD2.b + 56, pt.x))
+  ];
+  const lastI = p.points.length - 1;
+  const ghost = (() => {
+    if (!cmp) return void 0;
+    const w = ghostW(cmp.label);
+    if (w > plotW) {
+      throw new Error(
+        `line-chart ${beat.id}: the compare label "${cmp.label}" is ${Math.ceil(w)}px against the ${Math.floor(plotW)}px of plot it is set in. Shorten it.`
+      );
+    }
+    const atEnd = (i, start) => {
+      const cy = y(cmp.points[i]?.y ?? 0);
+      const away = Math.max(44, cy - 26);
+      const toward = Math.min(cy + 52, H - PAD2.b + 4);
+      const sides = cy < y(p.points[i]?.y ?? 0) ? [away, toward] : [toward, away];
+      return sides.map((by) => ({ i, start, by }));
+    };
+    const drawnDeltas = deltasFit ? deltaBoxes : [];
+    return [...atEnd(lastI, false), ...atEnd(0, true)].find((c) => {
+      const box2 = { x: c.start ? x(c.i) : x(c.i) - w, y: c.by - LABEL_SIZE3, w, h: LABEL_SIZE3 };
+      if (fixedBoxes.some((f) => overlaps(box2, f))) return false;
+      if (valueBoxes.some((v) => overlaps(box2, v))) return false;
+      if (drawnDeltas.some((d) => d !== null && overlaps(box2, d))) return false;
+      return ![p.points, cmp.points].some((series) => {
+        const [top, bottom] = curveBand(series, box2.x, box2.x + box2.w);
+        return Math.min(box2.y + box2.h, bottom) - Math.max(box2.y, top) > 8;
+      });
+    });
+  })();
+  const ghostLabel = cmp && ghost ? `
+    <text class="ghostlab" id="${sid}-ghostlab" text-anchor="${ghost.start ? "start" : "end"}" x="${n2(x(ghost.i))}" y="${n2(ghost.by)}">${esc(cmp.label)}</text>` : "";
   const readout = p.readout ? `
   <div class="readout" id="${sid}-read">${esc(p.readout)}</div>` : "";
   const html = `${chrome(sid, p.eyebrow, p.headline, box, face)}
@@ -4208,7 +4389,7 @@ var lineChart = (beat, ctx) => {
          the svg and the layout gate reports container_overflow. -->
     <text class="axname" x="0" y="42">${esc(p.yLabel)}</text>
     <text class="axname" x="${n2(PAD2.l + plotW / 2)}" y="${H - 16}" text-anchor="middle">${esc(p.xLabel)}</text>
-    <path class="chartline" id="${sid}-line" d="${path2}" fill="none" stroke="${theme.accent}" />
+    ${chartlines}${ghostLabel}
     <g>${dots}</g>
     ${ring}
     <g class="ptlab" text-anchor="middle">${values}</g>
@@ -4216,10 +4397,52 @@ var lineChart = (beat, ctx) => {
   </svg>${readout}
 </div>`;
   const draw2 = 0.8;
-  const step = Math.min(0.45, 1.8 / p.points.length);
+  const count = p.points.length;
+  const idealStep = Math.min(0.45, DRAW_SECONDS / count);
+  const spine = draw2 + SEPARATE + RESHAPE_SECONDS + (p.readout ? 0.8 : 0) + 0.15;
+  const shownDeltas = deltas ? Math.min((p.deltas ?? []).length, count - 1) : 0;
+  const tailAfter = (s) => Math.max(
+    s * count + 0.4,
+    // the ring: its walk, then the 0.4s it takes to leave
+    0.3 + s * (count - 1),
+    // the dots
+    0.5 + s * (count - 1),
+    ...shownDeltas > 0 ? [0.95 + s * (shownDeltas - 1)] : []
+  );
+  const room = beat.seconds - spine;
+  let drawCents = Math.round(DRAW_SECONDS * 100);
+  let stepCents = Math.floor(idealStep * 100);
+  if (cmp) {
+    while (drawCents / 100 + tailAfter(stepCents / 100) > room) {
+      if (drawCents > Math.round(DRAW_FLOOR * 100)) drawCents--;
+      else if (stepCents > Math.round(STEP_FLOOR * 100)) stepCents--;
+      else break;
+    }
+  }
+  const drawFor = cmp ? drawCents / 100 : DRAW_SECONDS;
+  const step = cmp ? stepCents / 100 : idealStep;
+  const lift2 = sec(draw2 + drawFor);
+  const settled = cmp ? sec(lift2 + SEPARATE + RESHAPE_SECONDS) : draw2;
   const tl = [
     ...chromeIn(sid, p.eyebrow !== void 0),
-    tween(`#${sid}-line`, DRAW_FROM, { ...DRAW_TO, duration: 1.8, ease: "none" }, draw2),
+    tween(
+      `#${sid}-${cmp ? "base" : "line"}`,
+      DRAW_FROM,
+      { ...DRAW_TO, duration: drawFor, ease: "none" },
+      draw2
+    )
+  ];
+  if (cmp) {
+    tl.push(
+      ...ghost ? [tween(`#${sid}-ghostlab`, { opacity: 0 }, { opacity: 1, duration: 0.5 }, draw2 + 0.4)] : [],
+      // The copy lifts off — same geometry, so the half-second reads as one line
+      // separating from itself rather than as a second line arriving.
+      tween(`#${sid}-line`, { opacity: 0 }, { opacity: 1, duration: SEPARATE }, lift2),
+      tween(`#${sid}-base`, { opacity: 1 }, { opacity: GHOST_OPACITY, duration: SEPARATE }, lift2),
+      reshape(`#${sid}-line`, `#${sid}-target`, lift2 + SEPARATE, RESHAPE_SECONDS, true)
+    );
+  }
+  tl.push(
     tween(
       `#${sid} .dot`,
       // Origin in both halves, or GSAP's smoothOrigin compensates the change with
@@ -4227,37 +4450,43 @@ var lineChart = (beat, ctx) => {
       // polyline they mark, inside the frame and so invisible to every gate.
       { opacity: 0, scale: 0, transformOrigin: "center" },
       { opacity: 1, scale: 1, transformOrigin: "center", duration: 0.3, stagger: step },
-      draw2
+      settled
     ),
-    tween(`#${sid} .pv`, { opacity: 0 }, { opacity: 1, duration: 0.3, stagger: step }, draw2 + 0.2)
-  ];
+    tween(
+      `#${sid} .pv`,
+      { opacity: 0 },
+      { opacity: 1, duration: 0.3, stagger: step },
+      settled + 0.2
+    )
+  );
   if (deltas) {
     tl.push(
       tween(
         `#${sid} .dv`,
         { opacity: 0, y: -10 },
         { opacity: 1, y: 0, duration: 0.35, stagger: step },
-        draw2 + 0.6
+        settled + 0.6
       )
     );
   }
-  if (p.points.length > 1) {
+  const walk = cmp ? sec(step * count) : DRAW_SECONDS;
+  if (count > 1) {
     const route = 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 }, draw2),
-      ...travel(`#${sid}-ring`, route, draw2, 1.8),
+      tween(`#${sid}-ring`, { opacity: 0 }, { opacity: 1, duration: 0.25 }, settled),
+      ...travel(`#${sid}-ring`, route, 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(
         `#${sid}-ring`,
         { opacity: 1 },
         { opacity: 0, duration: 0.4, immediateRender: false },
-        draw2 + 1.8
+        settled + walk
       )
     );
   }
-  const drawn = draw2 + step * p.points.length + 0.4;
-  const holds = [drawn];
+  const drawn = settled + (cmp ? tailAfter(step) : step * count + 0.4);
+  const holds = cmp ? [lift2, drawn] : [drawn];
   if (p.readout) {
     tl.push(
       // It enters from wherever it sits: from the right when it is beside the
@@ -4266,9 +4495,22 @@ var lineChart = (beat, ctx) => {
     );
     holds.push(drawn + 0.8);
   }
+  const end = holds[holds.length - 1] ?? 0;
+  const need = sec(end + 0.15);
+  if (cmp && need > beat.seconds + 1e-9) {
+    return {
+      ...lineChart({ ...beat, params: { ...p, compare: void 0 } }, ctx),
+      warnings: [
+        `line-chart ${beat.id}: a comparison against "${cmp.label}" over ${count} points needs ${need}s and the beat is ${beat.seconds}s, so the chart was drawn without it. Lengthen the beat to keep the comparison.`
+      ]
+    };
+  }
   return {
     html,
     tl,
+    // Named only when a beat actually reshapes, which is what keeps MorphSVG's
+    // 21,195 bytes off every deck that does not. See `PLUGINS` in composition.ts.
+    ...cmp ? { plugins: ["morphSVG"] } : {},
     holds: holdsWithin(holds, beat.seconds),
     css: [
       chromeCss(theme),
@@ -4293,6 +4535,14 @@ var lineChart = (beat, ctx) => {
       `.axname{font-size:40px;fill:${theme.muted};font-weight:500}`,
       `.ptlab{font-size:40px;fill:${theme.fg};font-weight:600}`,
       `.delta{font-size:40px;fill:${theme.tones.b};font-weight:600}`,
+      // Only when a ghost was actually named — not merely when there is a ghost,
+      // since the label is dropped where neither side of the baseline is clear.
+      // An unconditional rule would move the stylesheet bytes of every line chart
+      // ever built for a part they do not draw, which is the whole thing
+      // `Scene.plugins` is careful about one level up. `muted`, not `dim`: it
+      // names a series, so it is read, and the curve it names is the thing that
+      // has been faded, not its label.
+      ...ghost ? [`.ghostlab{font-size:40px;fill:${theme.muted};font-weight:600}`] : [],
       // 1.7 set the two lines of a wrapped readout 68px apart, which reads as two
       // unrelated fragments rather than one sentence. 1.35 keeps it a paragraph.
       `.readout{font-size:${BODY_SIZE}px;line-height:${READOUT_LH};color:${theme.muted};max-width:${READOUT_W}px}`,
@@ -5538,7 +5788,10 @@ function round4(n3) {
 // src/emit/composition.ts
 var GSAP_SRC = "./vendor/gsap.min.js";
 var DRAWSVG_SRC = "./vendor/DrawSVGPlugin.min.js";
-var MORPH_SRC = "./vendor/ds-morph.js";
+var PLUGINS = {
+  dsMorph: { src: "./vendor/ds-morph.js", global: "DSMorphPlugin" },
+  morphSVG: { src: "./vendor/MorphSVGPlugin.min.js", global: "MorphSVGPlugin" }
+};
 var KATEX_JS = "./vendor/katex.min.js";
 var KATEX_CSS = "./katex/katex.min.css";
 function emitDeck(storyboard, source, format, runtimeJs, opts = {}) {
@@ -5646,7 +5899,15 @@ function layout(storyboard, source, format, opts = {}) {
     }
     if (scene.css) archetypeCss.add(scene.css.trim());
     if (scene.measure?.length) builds = true;
-    for (const p of scene.plugins ?? []) plugins.add(p);
+    for (const w of cut2.scene.warnings ?? []) opts.onBeatWarning?.(beat.id, w);
+    for (const p of scene.plugins ?? []) {
+      if (!Object.hasOwn(PLUGINS, p)) {
+        throw new Error(
+          `${beat.archetype} ${beat.id}: no vendored plugin named "${p}" \u2014 Scene.plugins takes ${Object.keys(PLUGINS).join(" or ")}`
+        );
+      }
+      plugins.add(p);
+    }
     scenes.push(
       sceneHtml(
         sid,
@@ -5763,9 +6024,11 @@ function renderComposition(storyboard, format, laid) {
     <link rel="stylesheet" href="${FONT_BUNDLE_HREF}" />` : "";
   const island = format.navigable ? `
 ${emitIsland(slides)}` : "";
-  const morph = laid.plugins.has("dsMorph") ? `
-    <script src="${MORPH_SRC}"></script>
-    <script>gsap.registerPlugin(DSMorphPlugin);</script>` : "";
+  const plugins = Object.entries(PLUGINS).filter(([name]) => laid.plugins.has(name)).map(
+    ([, p]) => `
+    <script src="${p.src}"></script>
+    <script>gsap.registerPlugin(${p.global});</script>`
+  ).join("");
   return `<!doctype html>
 <html lang="${esc(storyboard.lang)}" data-resolution="${orientation}">
   <head>
@@ -5774,7 +6037,7 @@ ${emitIsland(slides)}` : "";
     <meta name="viewport" content="width=${format.width}, height=${format.height}" />
     <script src="${GSAP_SRC}"></script>
     <script src="${DRAWSVG_SRC}"></script>
-    <script>gsap.registerPlugin(DrawSVGPlugin);</script>${morph}
+    <script>gsap.registerPlugin(DrawSVGPlugin);</script>${plugins}
     <link rel="stylesheet" href="${KATEX_CSS}" />
     <script src="${KATEX_JS}"></script>${fontLink}${fontFace}
     <style>
@@ -6443,7 +6706,7 @@ function textOf(node) {
 // src/source/harvest.ts
 import { createHash as createHash5 } from "node:crypto";
 import { copyFile, mkdir as mkdir3, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename2, join as join4, resolve } from "node:path";
+import { basename as basename3, join as join5, resolve as resolve2 } from "node:path";
 
 // src/net/fetch.ts
 import { lookup as resolveHost } from "node:dns/promises";
@@ -6643,8 +6906,8 @@ async function send(url, target, headers, signal, opts) {
     ...secure && isIP(host2) === 0 ? { servername: host2 } : {}
   };
   try {
-    return await new Promise((resolve7, reject) => {
-      const req = (secure ? httpsRequest : httpRequest)(options, resolve7);
+    return await new Promise((resolve8, reject) => {
+      const req = (secure ? httpsRequest : httpRequest)(options, resolve8);
       req.on("error", reject);
       req.end();
     });
@@ -6728,29 +6991,37 @@ function message(err) {
 
 // src/render/capture.ts
 import { homedir } from "node:os";
-import { join as join2 } from "node:path";
-async function chromePath(need = "open the deck with") {
-  const explicit = process.env.DECKSMITH_CHROME || process.env.CHROME_PATH;
-  if (explicit) return explicit;
+import { join as join3 } 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" };
   const { getInstalledBrowsers } = await import("@puppeteer/browsers");
-  const cacheDir = process.env.PUPPETEER_CACHE_DIR || join2(homedir(), ".cache", "puppeteer");
-  const installed2 = await getInstalledBrowsers({ cacheDir }).catch(() => []);
-  const found = installed2.find((b) => b.browser === "chrome-headless-shell") ?? installed2.find((b) => b.browser === "chrome");
-  if (found) return found.executablePath;
+  const pick = async (cacheDir) => {
+    const installed2 = await getInstalledBrowsers({ cacheDir }).catch(() => []);
+    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(join3(homedir(), ".cache", "hyperframes", "chrome"));
+  if (hf) return { path: hf.executablePath, source: "hyperframes" };
+  const pup = await pick(process.env.PUPPETEER_CACHE_DIR || join3(homedir(), ".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.`
   );
 }
+async function chromePath(need = "open the deck with") {
+  return (await resolveChrome(need)).path;
+}
 
 // src/source/assets.ts
 import { createHash as createHash4 } from "node:crypto";
 import { mkdir as mkdir2, readdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { extname as extname2, join as join3 } from "node:path";
+import { extname as extname2, join as join4 } from "node:path";
 import { z as z2 } from "zod";
 async function fetchFigures(source, dir, warnings) {
   const drops = warnings ?? [];
   await mkdir2(dir, { recursive: true });
-  const cached = await readdir(dir).catch(() => []);
+  const cached2 = await readdir(dir).catch(() => []);
   const figures = [];
   for (const figure of source.figures) {
     if (figure.kind === "clip") {
@@ -6758,7 +7029,7 @@ async function fetchFigures(source, dir, warnings) {
       continue;
     }
     try {
-      figures.push(figureSchema.parse(await localize(figure, dir, cached)));
+      figures.push(figureSchema.parse(await localize(figure, dir, cached2)));
     } catch (err) {
       drops.push(`figure ${figure.id} was left out: ${reason(err)}`);
     }
@@ -6772,15 +7043,15 @@ async function fetchFigures(source, dir, warnings) {
   }
   return parsed.data;
 }
-async function localize(figure, dir, cached) {
+async function localize(figure, dir, cached2) {
   const stem = assetStem(figure.id, figure.src);
-  const hit = cached.find((name) => name.startsWith(`${stem}.`));
-  const bytes = hit ? await readFile3(join3(dir, hit)) : await load(figure.src);
+  const hit = cached2.find((name) => name.startsWith(`${stem}.`));
+  const bytes = hit ? await readFile3(join4(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 writeFile2(join3(dir, src), bytes);
-  cached.push(src);
+  await writeFile2(join4(dir, src), bytes);
+  cached2.push(src);
   return { ...figure, src, ...size };
 }
 function assetStem(id2, src) {
@@ -7341,7 +7612,7 @@ function readContentRegion() {
 
 // src/source/transcode.ts
 import { readFile as readFile4, rm } from "node:fs/promises";
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 
 // src/render/ffmpeg.ts
 import { execFile, spawn } from "node:child_process";
@@ -7366,7 +7637,7 @@ ${tail}`);
   }
 }
 function runLive(file, args) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn(file, args, { stdio: ["ignore", "inherit", "inherit"] });
     child.on("error", (err) => {
       reject(
@@ -7374,7 +7645,7 @@ function runLive(file, args) {
       );
     });
     child.on("close", (code, signal) => {
-      if (code === 0) resolve7();
+      if (code === 0) resolve8();
       else if (signal) {
         reject(
           new Error(
@@ -7570,7 +7841,7 @@ async function transcode(input, out, opts = {}) {
   const file = opts.ffmpeg ?? "ffmpeg";
   const maxSeconds = opts.maxSeconds ?? MAX_CLIP_SECONDS;
   const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
-  const name = basename(input);
+  const name = basename2(input);
   const source = videoSize(await readFile4(input));
   const box = fitBox(source.width, source.height, opts.maxEdgePx ?? CLIP_EDGE_PX);
   const kept = (why2) => ({
@@ -7639,7 +7910,7 @@ var HTML_TYPES = /^text\/html$|^application\/xhtml\+xml$/;
 async function harvest(url, dir, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS2;
   const warnings = [];
-  const assets = resolve(dir);
+  const assets = resolve2(dir);
   await mkdir3(assets, { recursive: true });
   const page = await fetchGuarded(url, {
     maxBytes: opts.maxBytes ?? HTML_MAX_BYTES,
@@ -7701,7 +7972,11 @@ async function readInBrowser(html, timeoutMs) {
       "--disable-background-networking",
       "--disable-extensions",
       "--no-default-browser-check",
-      "--no-first-run"
+      "--no-first-run",
+      // The floor under interception — see the note above. Not a hardening
+      // nicety: without it the open-proxy property holds only as fast as CDP
+      // happens to be that run.
+      "--host-resolver-rules=MAP * ~NOTFOUND"
     ]
   });
   try {
@@ -7967,7 +8242,7 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
   const clips = [];
   let spent = 0;
   const done = /* @__PURE__ */ new Map();
-  const ref = (got) => opts.refs === "relative" ? basename2(got.path) : got.path;
+  const ref = (got) => opts.refs === "relative" ? basename3(got.path) : got.path;
   const overdrawn = () => {
     if (Date.now() >= deadline) {
       return `the harvest has used its ${Math.round(wallMs / 1e3)}s budget \u2014 raise maxWallMs`;
@@ -8018,7 +8293,7 @@ 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 = join4(dir, assetName(url, extFor2(sniffFormat(bytes))));
+      const path2 = join5(dir, assetName(url, extFor2(sniffFormat(bytes))));
       await writeFile3(path2, bytes);
       assets.push(path2);
       got = { path: path2, width: size.width, height: size.height };
@@ -8031,7 +8306,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 = join4(dir, assetName(url, ".vp9.webm"));
+    const out2 = join5(dir, assetName(url, ".vp9.webm"));
     let small;
     try {
       small = await transcode(path2, out2, {
@@ -8046,7 +8321,7 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
       const [before, after] = await Promise.all([sizeOf(path2), sizeOf(small.path)]);
       if (before > 0 && after > before) {
         warnings.push(
-          `${what} \u2014 ${basename2(small.path)} came back LARGER than the page's own file (${mb(before)} \u2192 ${mb(after)}) at ${small.width}x${small.height}. The encode is sized for the render, which pre-decodes every clip to one still per output frame, so it still costs less to render; pass --no-transcode if the deck's size is what matters here.`
+          `${what} \u2014 ${basename3(small.path)} came back LARGER than the page's own file (${mb(before)} \u2192 ${mb(after)}) at ${small.width}x${small.height}. The encode is sized for the render, which pre-decodes every clip to one still per output frame, so it still costs less to render; pass --no-transcode if the deck's size is what matters here.`
         );
       }
       await rm2(path2, { force: true });
@@ -8073,7 +8348,7 @@ async function localise(seen, base, dir, opts, timeoutMs, warnings) {
     try {
       const bytes = await bytesOf(url);
       const measured = videoSize(bytes);
-      const path2 = join4(dir, assetName(url, `.${measured.container}`));
+      const path2 = join5(dir, assetName(url, `.${measured.container}`));
       await writeFile3(path2, bytes);
       return await shrink(url, path2, measured, what);
     } catch (err) {
@@ -8438,8 +8713,8 @@ ${fence}`;
 // src/plan/codex.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdtemp, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join6 } from "node:path";
 import { z as z3 } from "zod";
 
 // src/plan/arc.ts
@@ -8651,7 +8926,10 @@ var REVEALS = {
   "equation-walk": "one per term",
   "equation-morph": "2",
   "data-table": "one per highlighted row, plus 1",
-  "line-chart": "1",
+  // "long enough" is not a hedge: below the emitter's own floor the comparison
+  // is dropped and the chart stops twice becoming a chart that stops once. See
+  // the line-chart entry under THE THIRTEEN ARCHETYPES for what that costs.
+  "line-chart": "1, or 2 when compare is given and the beat is long enough for it",
   callout: "one per panel",
   pipeline: "one per stage",
   "annotated-figure": "one per note, plus 1",
@@ -8774,6 +9052,29 @@ DRAWING ARCHETYPES \u2014 reach here first
                  scale, over training. Points come from the source's numbers;
                  deltas, if given, are the steps between consecutive points, so
                  there is always one fewer.
+                 \`compare\` adds a SECOND CONDITION over the same axis \u2014 the tell
+                 there is THE SAME QUANTITY MEASURED TWO WAYS, a baseline and the
+                 result, where what the source is claiming is the change in the
+                 SHAPE of the curve and not two numbers. Its \`label\` names the
+                 baseline ("without pretraining", "FP32") and is drawn on the
+                 slide where the chart has room for it. Keep it SHORT \u2014 two or
+                 three words. A label wider than the plot is refused and the
+                 whole slide goes with it, and one that cannot be placed clear of
+                 the axis names, the values and both curves is dropped without a
+                 word, leaving the baseline unnamed. A \`readout\` takes the plot
+                 down to about two thirds of its width, so a beat that has one
+                 has room for a shorter label still.
+                 \`compare.points\` must carry the SAME x values, in the
+                 same order, as \`points\`; the baseline is drawn first, then the
+                 curve reshapes into \`points\` and leaves the baseline behind. Do
+                 not use it for two unrelated series that happen to share an
+                 axis \u2014 nothing reshapes into something it is not a version of.
+                 A compare beat also costs TIME \u2014 the baseline draws, is held,
+                 then reshapes \u2014 so give it \`seconds\` of 7, or 8 with a
+                 \`readout\`. Give it too few and the emitter draws the chart
+                 without the comparison rather than stopping on a half-drawn one:
+                 the slide is still there, but the point about the baseline is
+                 gone.
 
 DESCRIBING ARCHETYPES \u2014 the fallbacks
 
@@ -9431,10 +9732,10 @@ function schemaFor(prefs) {
 var SCHEMA = schemaFor({ genre: "general" });
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
-  const dir = await mkdtemp(join5(tmpdir(), "decksmith-plan-"));
+  const dir = await mkdtemp(join6(tmpdir2(), "decksmith-plan-"));
   try {
-    const schemaPath = join5(dir, "storyboard.schema.json");
-    const outPath = join5(dir, "storyboard.json");
+    const schemaPath = join6(dir, "storyboard.schema.json");
+    const outPath = join6(dir, "storyboard.json");
     await writeFile4(schemaPath, JSON.stringify(schemaFor(prefs)));
     await (opts.run ?? runCodex)({
       prompt: buildPrompt(source, prefs),
@@ -9516,7 +9817,7 @@ function codexCommand(args) {
 }
 function runCodex(args) {
   const { argv, env: env2 } = codexCommand(args);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn2("codex", argv, {
       stdio: ["pipe", "ignore", "pipe"],
       ...env2 === void 0 ? {} : { env: env2 }
@@ -9539,7 +9840,7 @@ function runCodex(args) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (code === 0) return resolve7();
+      if (code === 0) return resolve8();
       reject(
         new Error(`codex exec exited ${code}.
 ${stderr.trim().split("\n").slice(-8).join("\n")}`)
@@ -9552,13 +9853,13 @@ ${stderr.trim().split("\n").slice(-8).join("\n")}`)
 // src/images/illustrate.ts
 import { createHash as createHash7 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile7, rename, rm as rm5, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/images/providers.ts
 import { createHash as createHash6 } from "node:crypto";
 import { mkdtemp as mkdtemp2, readFile as readFile6, rm as rm4, writeFile as writeFile5 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join7, resolve as resolve3 } from "node:path";
 import { z as z4 } from "zod";
 var SIZE = {
   landscape: { width: 1536, height: 1024 },
@@ -9690,10 +9991,10 @@ function codexImages(opts = {}) {
     async check() {
     },
     async generate(req) {
-      const dir = await mkdtemp2(join6(tmpdir2(), "decksmith-image-"));
+      const dir = await mkdtemp2(join7(tmpdir3(), "decksmith-image-"));
       try {
-        const schemaPath = join6(dir, "answer.schema.json");
-        const outPath = join6(dir, "answer.json");
+        const schemaPath = join7(dir, "answer.schema.json");
+        const outPath = join7(dir, "answer.json");
         await writeFile5(schemaPath, JSON.stringify(ANSWER_SCHEMA));
         await run5({
           prompt: codexPrompt(req),
@@ -9711,8 +10012,8 @@ function codexImages(opts = {}) {
             `codex could not generate a picture: ${answer.data.reason ?? "no reason given"}`
           );
         }
-        const candidates2 = [join6(dir, "picture.png")];
-        if (answer.data.file) candidates2.push(resolve2(dir, answer.data.file));
+        const candidates2 = [join7(dir, "picture.png")];
+        if (answer.data.file) candidates2.push(resolve3(dir, answer.data.file));
         for (const path2 of candidates2) {
           const bytes = await readFile6(path2).catch(() => null);
           if (bytes) return raster(bytes, "codex");
@@ -9943,16 +10244,16 @@ function cacheKey(providerId, req) {
 async function draw(provider, req, name, dir) {
   for (const ext of Object.values(EXT2)) {
     const src2 = `${name}${ext}`;
-    const bytes = await readFile7(join7(dir, src2)).catch(() => null);
+    const bytes = await readFile7(join8(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 = join7(dir, `.${name}.tmp`);
+  const tmp = join8(dir, `.${name}.tmp`);
   try {
     await writeFile6(tmp, img.bytes);
-    await rename(tmp, join7(dir, src));
+    await rename(tmp, join8(dir, src));
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -9967,7 +10268,7 @@ import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { mkdir as mkdir5, readFile as readFile8, rm as rm6, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var MISSING = [
   "edge-tts is not installed, so narration cannot be synthesised.",
   "",
@@ -9984,8 +10285,8 @@ function candidates() {
     ["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.
-    [join8(home, "Library", "Python", "3.9", "bin", "edge-tts")],
-    [join8(home, ".local", "bin", "edge-tts")],
+    [join9(home, "Library", "Python", "3.9", "bin", "edge-tts")],
+    [join9(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"]
@@ -10010,7 +10311,7 @@ async function find2(can) {
   throw new Error(MISSING);
 }
 function runArgv(cmd, args) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn3(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -10020,8 +10321,8 @@ function runArgv(cmd, args) {
     child.stderr.on("data", (b) => {
       stderr += b.toString();
     });
-    child.on("error", (e) => resolve7({ code: -1, stderr: String(e), stdout }));
-    child.on("close", (code) => resolve7({ code: code ?? -1, stderr, stdout }));
+    child.on("error", (e) => resolve8({ code: -1, stderr: String(e), stdout }));
+    child.on("close", (code) => resolve8({ code: code ?? -1, stderr, stdout }));
   });
 }
 var edgeTts = {
@@ -10106,10 +10407,10 @@ async function synthesize(text2, opts) {
   const provider = opts.provider ?? edgeProvider(opts.runner ?? edgeTts);
   const key = cacheKey2(text2, opts.voice, rate, pitch);
   const file = `${key}.mp3`;
-  const audio = join8(opts.dir, file);
-  const sidecar = join8(opts.dir, `${key}.json`);
-  const cached = await readSidecar(sidecar);
-  if (cached) return { audio, file, seconds: cached.seconds, cues: cached.cues };
+  const audio = join9(opts.dir, file);
+  const sidecar = join9(opts.dir, `${key}.json`);
+  const cached2 = await readSidecar(sidecar);
+  if (cached2) return { audio, file, seconds: cached2.seconds, cues: cached2.cues };
   await mkdir5(opts.dir, { recursive: true });
   const spoken = await provider.speak({ text: text2, voice: opts.voice, rate, pitch, audio });
   const { cues, seconds } = spoken;
@@ -10273,11 +10574,11 @@ function scanBeatCount(storyboard, prefs) {
 
 // src/render/render.ts
 import { mkdir as mkdir7, readFile as readFile9, rename as rename2, rm as rm7, writeFile as writeFile9 } from "node:fs/promises";
-import { basename as basename3, dirname, join as join10, resolve as resolve3 } from "node:path";
+import { basename as basename4, dirname as dirname2, join as join11, resolve as resolve4 } from "node:path";
 
 // src/render/captions.ts
 import { mkdir as mkdir6, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { pathToFileURL } from "node:url";
 var DECK_FONT_CSS = "assets/fonts/fonts.css";
 function cssString(value) {
@@ -10368,9 +10669,9 @@ async function captionBlocker() {
 }
 async function renderCaptions(cues, style, deck, work2) {
   if (cues.length === 0) throw new Error("renderCaptions was given no cues.");
-  const fontCss = join9(deck, DECK_FONT_CSS);
+  const fontCss = join10(deck, DECK_FONT_CSS);
   const href = await import("node:fs/promises").then((fs) => fs.stat(fontCss).catch(() => null)) ? pathToFileURL(fontCss).href : null;
-  const page = join9(work2, "captions.html");
+  const page = join10(work2, "captions.html");
   await mkdir6(work2, { recursive: true });
   await writeFile8(page, captionPage(cues, style, href));
   const { default: puppeteer } = await import("puppeteer-core");
@@ -10392,7 +10693,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: join9(work2, name),
+        path: join10(work2, name),
         type: "png",
         omitBackground: true,
         clip: { x: box.x, y: box.y, width: box.width, height: box.height }
@@ -10426,16 +10727,16 @@ function overlayInputs(band) {
 }
 
 // src/render/render.ts
-var SRT_NAME = (out) => `${basename3(out).replace(/\.[^.]+$/, "")}.srt`;
+var SRT_NAME = (out) => `${basename4(out).replace(/\.[^.]+$/, "")}.srt`;
 function subtitlePlan(mode) {
   return { sidecar: mode !== "none", burn: mode === "burn" };
 }
 async function render(opts) {
   const log = opts.log ?? (() => {
   });
-  const deck = resolve3(opts.deck);
-  const out = resolve3(opts.out);
-  const work2 = join10(dirname(out), `.${basename3(out)}.parts`);
+  const deck = resolve4(opts.deck);
+  const out = resolve4(opts.out);
+  const work2 = join11(dirname2(out), `.${basename4(out)}.parts`);
   const timing = await readTiming(deck);
   if (opts.targetSeconds && !opts.allowFastPlayback) {
     const refusal = playbackRefusal(
@@ -10453,7 +10754,7 @@ async function render(opts) {
   const burnable = plan0.burn;
   await mkdir7(work2, { recursive: true });
   try {
-    const raw2 = opts.video ? resolve3(opts.video) : await capture(deck, join10(work2, "raw.mp4"), opts, log);
+    const raw2 = opts.video ? resolve4(opts.video) : await capture(deck, join11(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`
@@ -10466,7 +10767,7 @@ async function render(opts) {
       );
     }
     const retimed = await retime(raw2, plan, work2, log);
-    const srtPath = join10(dirname(out), SRT_NAME(out));
+    const srtPath = join11(dirname2(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) : "";
@@ -10477,7 +10778,7 @@ async function render(opts) {
       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 = join10(work2, `fast.${basename3(out)}`);
+      const fast = join11(work2, `fast.${basename4(out)}`);
       const muxed = await probe(out);
       await runTool(
         "ffmpeg",
@@ -10507,7 +10808,7 @@ async function render(opts) {
   }
 }
 async function readTiming(deck) {
-  const path2 = join10(deck, TIMING_FILE);
+  const path2 = join11(deck, TIMING_FILE);
   const text2 = await readFile9(path2, "utf8").catch(() => {
     throw new Error(
       `${path2} is missing. \`render\` needs the timing manifest \`build\` writes; rebuild the deck.`
@@ -10547,20 +10848,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 = join10(work2, `p${String(i).padStart(4, "0")}.ts`);
+    const file = join11(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 = join10(work2, "pieces.txt");
+  const listFile = join11(work2, "pieces.txt");
   await writeFile9(
     listFile,
     `${list.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n")}
 `
   );
-  const joined = join10(work2, "retimed.mp4");
+  const joined = join11(work2, "retimed.mp4");
   await runTool("ffmpeg", [
     "-y",
     "-hide_banner",
@@ -10582,7 +10883,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: join10(deck, timing.audioDir, a.audio),
+    file: join11(deck, timing.audioDir, a.audio),
     delayMs: a.delayMs
   }));
   const args = ["-y", "-hide_banner", "-loglevel", "error", "-i", video];
@@ -10603,7 +10904,7 @@ 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 = join10(work2, "mux.filter");
+    const script = join11(work2, "mux.filter");
     await writeFile9(script, `${graph.join(";\n")}
 `);
     args.push("-filter_complex_script", script);
@@ -10619,13 +10920,13 @@ 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 mkdir7(dirname(out), { recursive: true });
+  await mkdir7(dirname2(out), { recursive: true });
   await runTool("ffmpeg", args, { cwd: work2 });
 }
 
 // src/pack/pack.ts
 import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname2, extname as extname3 } from "node:path";
+import { dirname as dirname3, extname as extname3 } from "node:path";
 import { unzipSync, zipSync } from "fflate";
 var MTIME = Date.UTC(1980, 0, 2, 12);
 var STORED = /* @__PURE__ */ new Set([
@@ -10664,7 +10965,7 @@ async function writePack(pack3, files, out) {
     entries[path2] = STORED.has(extname3(path2).toLowerCase()) ? [bytes, { level: 0 }] : bytes;
   }
   const zip = zipSync(entries, { mtime: MTIME });
-  await mkdir8(dirname2(out), { recursive: true });
+  await mkdir8(dirname3(out), { recursive: true });
   await writeFile10(out, zip);
   return zip.length;
 }
@@ -10684,7 +10985,7 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   if (!format) throw new Error("no deck-16x9 format");
   const step = opts.onStep ?? (() => {
   });
-  const out = resolve4(outDir);
+  const out = resolve5(outDir);
   await mkdir9(out, { recursive: true });
   const speed = opts.speed ?? 1;
   const fontCss = await refreshFont(storyboard, source, out, step);
@@ -10693,12 +10994,13 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
     ...opts.theme ? { theme: opts.theme } : {},
     ...opts.narration ? { narration: opts.narration } : {},
     ...opts.onBeatError ? { onBeatError: opts.onBeatError } : {},
+    ...opts.onBeatWarning ? { onBeatWarning: opts.onBeatWarning } : {},
     ...fontCss ? { fontCss } : {}
   });
   const files = [];
   const write = async (name, text2) => {
-    await writeFile11(join11(out, name), text2);
-    files.push(join11(out, name));
+    await writeFile11(join12(out, name), text2);
+    files.push(join12(out, name));
   };
   await write("index.html", deck.composition);
   await write("hyperframes.json", HYPERFRAMES_JSON);
@@ -10727,8 +11029,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   }
   if (deck.page) {
     await write(DECK_PAGE, deck.page);
-    await cp(playerBundle(), join11(out, PLAYER_FILE));
-    files.push(join11(out, PLAYER_FILE));
+    await cp(playerBundle(), join12(out, PLAYER_FILE));
+    files.push(join12(out, PLAYER_FILE));
   }
   files.push(...await vendorKatex(out));
   if (opts.assetsFrom) files.push(...await copyAssets(opts.assetsFrom, out));
@@ -10737,7 +11039,7 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   }
   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 ${join11(out, "index.html")}`
+    `build: ${deck.cut.kept.length}${of} beats at ${format.width}\xD7${format.height} \u2192 ${join12(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}`);
@@ -10761,40 +11063,40 @@ async function deckRuntime() {
   }
 }
 function playerBundle() {
-  const require2 = createRequire2(import.meta.url);
+  const require2 = createRequire3(import.meta.url);
   try {
-    return join11(dirname3(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
+    return join12(dirname4(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
   } catch {
     throw new Error('Cannot locate the hyperframes player. Run "npm install".');
   }
 }
 async function vendorKatex(out) {
-  const require2 = createRequire2(import.meta.url);
-  const dist = join11(dirname3(require2.resolve("katex/package.json")), "dist");
-  const css = await readFile11(join11(dist, "katex.min.css"), "utf8");
+  const require2 = createRequire3(import.meta.url);
+  const dist = join12(dirname4(require2.resolve("katex/package.json")), "dist");
+  const css = await readFile11(join12(dist, "katex.min.css"), "utf8");
   const written = [];
-  await mkdir9(join11(out, "katex/fonts"), { recursive: true });
-  for (const file of await readdir2(join11(dist, "fonts"))) {
+  await mkdir9(join12(out, "katex/fonts"), { recursive: true });
+  for (const file of await readdir2(join12(dist, "fonts"))) {
     if (!file.endsWith(".woff2")) continue;
-    await cp(join11(dist, "fonts", file), join11(out, "katex/fonts", file));
-    written.push(join11(out, "katex/fonts", file));
+    await cp(join12(dist, "fonts", file), join12(out, "katex/fonts", file));
+    written.push(join12(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 writeFile11(join11(out, "katex/katex.min.css"), woff2Only);
-  written.push(join11(out, "katex/katex.min.css"));
+  await writeFile11(join12(out, "katex/katex.min.css"), woff2Only);
+  written.push(join12(out, "katex/katex.min.css"));
   return written;
 }
 async function copyAssets(sourceDir, out) {
-  const from = join11(resolve4(sourceDir), "assets");
+  const from = join12(resolve5(sourceDir), "assets");
   if (!await stat2(from).catch(() => null)) return [];
-  await cp(from, join11(out, "assets"), { recursive: true });
-  return [join11(out, "assets")];
+  await cp(from, join12(out, "assets"), { recursive: true });
+  return [join12(out, "assets")];
 }
 async function copyAudio(from, narration, out) {
-  const dir = join11(out, narration.dir);
+  const dir = join12(out, narration.dir);
   await mkdir9(dir, { recursive: true });
   const names = [
     ...new Set(
@@ -10802,18 +11104,18 @@ async function copyAudio(from, narration, out) {
     )
   ].sort();
   for (const name of names) {
-    await cp(join11(resolve4(from), name), join11(dir, name)).catch(() => {
+    await cp(join12(resolve5(from), name), join12(dir, name)).catch(() => {
       throw new Error(`Narration names ${name}, but it is not in ${from}. Re-run \`narrate\`.`);
     });
   }
-  return names.map((n3) => join11(dir, n3));
+  return names.map((n3) => join12(dir, n3));
 }
 async function refreshFont(storyboard, source, out, step) {
   try {
     const bundle = await bundleFont(
       storyboard.lang,
       JSON.stringify(source) + JSON.stringify(storyboard),
-      join11(out, "assets", "fonts")
+      join12(out, "assets", "fonts")
     );
     if (bundle) step(`build: font bundle covers ${bundle.family}`);
     return bundle?.css;
@@ -10826,7 +11128,7 @@ async function refreshFont(storyboard, source, out, step) {
 }
 
 // src/server/upload.ts
-import { posix, sep } from "node:path";
+import { posix, sep as sep2 } from "node:path";
 import { unzipSync as unzipSync2 } from "fflate";
 var MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
 var ZIP_LIMITS = {
@@ -10863,8 +11165,8 @@ function safeEntryPath(name) {
   if (path2.length > 512 || kept.some((s) => s.length > 200)) return null;
   return path2;
 }
-function insideRoot(root2, joined) {
-  return joined === root2 || joined.startsWith(root2.endsWith(sep) ? root2 : root2 + sep);
+function insideRoot2(root2, joined) {
+  return joined === root2 || joined.startsWith(root2.endsWith(sep2) ? root2 : root2 + sep2);
 }
 function readZip(bytes, limits = ZIP_LIMITS) {
   const seen = [];
@@ -11169,7 +11471,7 @@ function int(name, raw2) {
 
 // src/server/pipeline.ts
 import { mkdir as mkdir10, readFile as readFile12, stat as stat3, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname4, isAbsolute, join as join12, relative, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, isAbsolute, join as join13, relative, resolve as resolve6 } from "node:path";
 var AUDIO_DIR = "audio";
 var NARRATION_FILE = "narration.json";
 var MAX_REMOTE_FIGURES = 40;
@@ -11192,10 +11494,10 @@ function stagesFor(options) {
 async function runPipeline(job, input) {
   const { options } = input;
   const dirs = {
-    upload: join12(job.dir, "upload"),
-    src: join12(job.dir, "src"),
-    audio: join12(job.dir, AUDIO_DIR),
-    deck: join12(job.dir, "deck")
+    upload: join13(job.dir, "upload"),
+    src: join13(job.dir, "src"),
+    audio: join13(job.dir, AUDIO_DIR),
+    deck: join13(job.dir, "deck")
   };
   const warnings = [...options.warnings];
   const url = (rel) => `/d/${job.id}/${rel}`;
@@ -11219,21 +11521,21 @@ async function runPipeline(job, input) {
     theme: options.stated.theme ? prefs.theme : planned.theme
   };
   assertRefsResolve(storyboard, source, { pending: options.images ? "allow" : "refuse" });
-  await writeJson(join12(job.dir, "storyboard.json"), storyboard);
+  await writeJson(join13(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: join12(dirs.src, "assets"),
+      assetsDir: join13(dirs.src, "assets"),
       ...input.imageChain ? { chain: input.imageChain } : {},
       onStep: (line2) => job.log(line2)
     });
     storyboard = drawn.storyboard;
     source = drawn.source;
-    await writeJson(join12(dirs.src, "source.json"), source);
-    await writeJson(join12(job.dir, "storyboard.json"), storyboard);
+    await writeJson(join13(dirs.src, "source.json"), source);
+    await writeJson(join13(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)" : ""}`
@@ -11260,7 +11562,7 @@ async function runPipeline(job, input) {
         dir: dirs.audio,
         format: options.format
       });
-      await writeJson(join12(dirs.audio, NARRATION_FILE), spoken);
+      await writeJson(join13(dirs.audio, NARRATION_FILE), spoken);
       narration = { voice: spoken.voice, dir: AUDIO_DIR, beats: spoken.beats };
       const segments2 = Object.values(spoken.beats).flat();
       const seconds = segments2.reduce((sum, s) => sum + s.seconds, 0);
@@ -11286,6 +11588,13 @@ async function runPipeline(job, input) {
     onBeatError: (id2, err) => {
       warnings.push(`slide ${id2} was left out: ${err.message}`);
       job.log(`build: dropped ${id2} \u2014 ${err.message}`);
+    },
+    // A beat that IS in the deck, drawn with one of its parts dropped so it
+    // would fit. The slide looks finished, so the job's warnings are the only
+    // place the person who asked for it finds out otherwise.
+    onBeatWarning: (id2, warning) => {
+      warnings.push(`slide ${id2} was drawn short: ${warning}`);
+      job.log(`build: kept ${id2} \u2014 ${warning}`);
     }
   });
   for (const d of built.cut.dropped) warnings.push(`cut ${d.beat.id} \u2014 ${d.reason}`);
@@ -11307,7 +11616,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: join12(dirs.deck, "video.mp4"),
+        out: join13(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
@@ -11357,7 +11666,7 @@ async function runPipeline(job, input) {
 }
 async function ingest(job, input, dirs, warnings) {
   await mkdir10(dirs.upload, { recursive: true });
-  const root2 = resolve5(dirs.upload);
+  const root2 = resolve6(dirs.upload);
   let docPath;
   const upload = input.upload;
   const bothOrNeither = new UploadError(
@@ -11367,12 +11676,12 @@ async function ingest(job, input, dirs, warnings) {
   );
   if (input.url !== void 0) {
     if (upload !== void 0) throw bothOrNeither;
-    const harvested = await harvestBounded(input.url, join12(root2, "assets"), {
+    const harvested = await harvestBounded(input.url, join13(root2, "assets"), {
       ...HARVEST_LIMITS,
       ...input.harvest
     });
     warnings.push(...harvested.warnings);
-    docPath = join12(root2, "document.md");
+    docPath = join13(root2, "document.md");
     await writeFile12(docPath, harvested.markdown);
     job.log(
       `ingest: harvested ${input.url} \u2014 "${harvested.title}", ${harvested.assets.length} asset(s)`
@@ -11389,13 +11698,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 = resolve5(join12(root2, rel));
-      if (!insideRoot(root2, to))
+      const to = resolve6(join13(root2, rel));
+      if (!insideRoot2(root2, to))
         throw new UploadError(`Refusing to write ${rel}.`, "Re-zip from inside the folder.");
-      await mkdir10(dirname4(to), { recursive: true });
+      await mkdir10(dirname5(to), { recursive: true });
       await writeFile12(to, bytes);
     }
-    docPath = join12(root2, pickMarkdown(files));
+    docPath = join13(root2, pickMarkdown(files));
     job.log(
       `ingest: unpacked ${Object.keys(files).length} file(s), reading ${pickMarkdown(files)}`
     );
@@ -11407,7 +11716,7 @@ async function ingest(job, input, dirs, warnings) {
         `DeckSmith reads ${MARKDOWN_EXTS.join(", ")} or a .zip containing one. Export the document to markdown first.`
       );
     }
-    docPath = join12(root2, "document.md");
+    docPath = join13(root2, "document.md");
     await writeFile12(docPath, upload.bytes);
   }
   const text2 = await readFile12(docPath, "utf8");
@@ -11430,8 +11739,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, join12(resolve5(dirs.src), "assets"), warnings);
-  await writeJson(join12(dirs.src, "source.json"), source);
+  const source = await fetchFigures(guarded, join13(resolve6(dirs.src), "assets"), warnings);
+  await writeJson(join13(dirs.src, "source.json"), source);
   return source;
 }
 async function harvestBounded(url, dir, opts) {
@@ -11507,8 +11816,8 @@ 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) ? resolve5(src) : resolve5(join12(root2, src.replace(/^\.?\//, "")));
-    if (!insideRoot(root2, abs)) {
+    const abs = isAbsolute(src) ? resolve6(src) : resolve6(join13(root2, src.replace(/^\.?\//, "")));
+    if (!insideRoot2(root2, abs)) {
       warnings.push(`figure ${figure.id} was left out: "${src}" points outside the upload`);
       continue;
     }
@@ -11522,10 +11831,10 @@ async function guardFigures(source, root2, allowRemote, warnings) {
 }
 async function pack2(job, ctx) {
   try {
-    const assets = join12(resolve5(ctx.dirs.src), "assets");
+    const assets = join13(resolve6(ctx.dirs.src), "assets");
     const requests = ctx.source.figures.map((f) => ({
       id: f.id,
-      url: join12(assets, f.src),
+      url: join13(assets, f.src),
       prefer: "bake"
     }));
     const plan = await planMedia(requests, async (url) => ({
@@ -11534,7 +11843,7 @@ async function pack2(job, ctx) {
     const files = { ...plan.files };
     if (ctx.narration) {
       for (const name of audioNames(ctx.narration)) {
-        files[`${AUDIO_DIR}/${name}`] = new Uint8Array(await readFile12(join12(ctx.dirs.audio, name)));
+        files[`${AUDIO_DIR}/${name}`] = new Uint8Array(await readFile12(join13(ctx.dirs.audio, name)));
       }
     }
     const container = {
@@ -11551,10 +11860,10 @@ async function pack2(job, ctx) {
       },
       source: ctx.source,
       storyboard: ctx.storyboard,
-      ...ctx.narration ? { narration: await readJson(join12(ctx.dirs.audio, NARRATION_FILE)) } : {},
+      ...ctx.narration ? { narration: await readJson(join13(ctx.dirs.audio, NARRATION_FILE)) } : {},
       media: plan.media
     };
-    const bytes = await writePack(container, files, join12(ctx.dirs.deck, "deck.deck"));
+    const bytes = await writePack(container, files, join13(ctx.dirs.deck, "deck.deck"));
     job.log(`pack: ${Math.round(bytes / 1024)} KB \u2192 deck.deck`);
     return ctx.url("deck.deck");
   } catch (err) {
@@ -11577,7 +11886,7 @@ function host(src) {
   }
 }
 async function writeJson(path2, value) {
-  await mkdir10(dirname4(path2), { recursive: true });
+  await mkdir10(dirname5(path2), { recursive: true });
   await writeFile12(path2, `${JSON.stringify(value, null, 2)}
 `);
 }
@@ -11989,13 +12298,13 @@ var PAGE_BUDGET = {
 };
 async function readPage(url, work2) {
   await mkdir11(work2, { recursive: true });
-  const dir = await mkdtemp3(join13(work2, "harvest-"));
+  const dir = await mkdtemp3(join14(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[basename4(asset)] = await readFile13(asset);
+    for (const asset of page.assets) files[basename5(asset)] = await readFile13(asset);
     const warnings = [...page.warnings];
     if (page.clips.length > 0) {
       warnings.push(
@@ -12029,16 +12338,16 @@ var statusSchema = z5.object({
 var DEFAULT_WAIT = 45;
 function deckTools(opts) {
   const queue = new Queue({ maxQueued: 8 });
-  const root2 = resolve6(opts.root);
-  let cached;
+  const root2 = resolve7(opts.root);
+  let cached2;
   const found = async () => {
-    cached ??= await (opts.probe ?? prereqs)();
-    return cached;
+    cached2 ??= await (opts.probe ?? prereqs)();
+    return cached2;
   };
-  const insideRoot2 = (p) => {
+  const insideRoot3 = (p) => {
     if (!isAbsolute2(p)) throw new Error(`document_path must be absolute; got "${p}".`);
-    const full = resolve6(p);
-    if (full !== root2 && !full.startsWith(root2 + sep2)) {
+    const full = resolve7(p);
+    if (full !== root2 && !full.startsWith(root2 + sep3)) {
       throw new Error(
         `document_path is outside the server's root. It may only read files under ${root2}.`
       );
@@ -12099,7 +12408,7 @@ function deckTools(opts) {
       }
       const settings = input.settings ?? {};
       const options = parseOptions(fieldsFor(settings));
-      const file = input.document_path ? insideRoot2(input.document_path) : void 0;
+      const file = input.document_path ? insideRoot3(input.document_path) : void 0;
       const missing = missingFor(await found(), options);
       if (missing.length) {
         throw new Error(
@@ -12115,7 +12424,7 @@ 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(sep2).pop() : "document.md";
+      const filename = page ? "page.zip" : input.document_path ? input.document_path.split(sep3).pop() : "document.md";
       const bytes = page ? page.zip : file ? await readFile13(file) : new TextEncoder().encode(input.document_text);
       if (bytes.byteLength > MAX_UPLOAD_BYTES) {
         throw new Error(
@@ -12123,7 +12432,7 @@ function deckTools(opts) {
         );
       }
       const id2 = randomBytes(16).toString("base64url");
-      const dir = join13(opts.work, id2);
+      const dir = join14(opts.work, id2);
       await mkdir11(dir, { recursive: true });
       queue.submit({
         id: id2,
@@ -12151,7 +12460,7 @@ function deckTools(opts) {
   };
 }
 function dirOf(work2, id2) {
-  return join13(work2, id2);
+  return join14(work2, id2);
 }
 function waitFor(queue, id2, seconds) {
   const now = queue.view(id2);
@@ -12183,9 +12492,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: join13(dir, "storyboard.json"),
+    storyboard_path: join14(dir, "storyboard.json"),
     ...done && view.result ? {
-      deck_path: join13(dir, "deck"),
+      deck_path: join14(dir, "deck"),
       slides: view.result.slides,
       duration_seconds: view.result.duration,
       warnings: view.result.warnings
@@ -12194,7 +12503,7 @@ function report(view, dir) {
   };
 }
 function defaultWork() {
-  return join13(tmpdir3(), "decksmith-mcp");
+  return join14(tmpdir4(), "decksmith-mcp");
 }
 
 // src/mcp/main.ts
@@ -12204,6 +12513,7 @@ for (const level of ["log", "info", "debug", "warn", "trace"]) {
 `);
   };
 }
+guardTmpdir();
 var env = process.env;
 var root = env.DECKSMITH_MCP_ROOT ?? homedir3();
 var work = env.DECKSMITH_MCP_WORK ?? defaultWork();