@jokerized/decksmith 0.3.2 → 0.4.1

package/dist/cli.js

@@ -2,9 +2,9 @@
 
 // src/cli.ts
 import { cp, mkdir as mkdir10, mkdtemp as mkdtemp4, readdir as readdir4, readFile as readFile17, rm as rm9, stat as stat2, writeFile as writeFile12 } from "node:fs/promises";
-import { createRequire as createRequire3 } from "node:module";
-import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname4, join as join16, relative as relative2, resolve as resolve5 } from "node:path";
+import { createRequire as createRequire4 } from "node:module";
+import { tmpdir as tmpdir5 } from "node:os";
+import { dirname as dirname5, join as join17, relative as relative2, resolve as resolve6 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -418,15 +418,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(),
@@ -1206,8 +1244,8 @@ async function bundleFont(lang, glyphs2, dir) {
 ${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 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 } }
@@ -1420,6 +1458,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 = [];
@@ -4101,6 +4154,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);
@@ -4131,7 +4190,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);
@@ -4174,11 +4234,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("");
@@ -4214,6 +4278,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)}
@@ -4226,7 +4359,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>
@@ -4234,10 +4367,52 @@ var lineChart = (beat, ctx) => {
   </svg>${readout}
 </div>`;
   const draw2 = 0.8;
-  const step2 = 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 step2 = 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
@@ -4245,37 +4420,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: step2 },
-      draw2
+      settled
     ),
-    tween(`#${sid} .pv`, { opacity: 0 }, { opacity: 1, duration: 0.3, stagger: step2 }, draw2 + 0.2)
-  ];
+    tween(
+      `#${sid} .pv`,
+      { opacity: 0 },
+      { opacity: 1, duration: 0.3, stagger: step2 },
+      settled + 0.2
+    )
+  );
   if (deltas) {
     tl.push(
       tween(
         `#${sid} .dv`,
         { opacity: 0, y: -10 },
         { opacity: 1, y: 0, duration: 0.35, stagger: step2 },
-        draw2 + 0.6
+        settled + 0.6
       )
     );
   }
-  if (p.points.length > 1) {
+  const walk = cmp ? sec(step2 * 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 + step2 * p.points.length + 0.4;
-  const holds = [drawn];
+  const drawn = settled + (cmp ? tailAfter(step2) : step2 * 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
@@ -4284,9 +4465,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),
@@ -4311,6 +4505,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}`,
@@ -5556,7 +5758,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 = {}) {
@@ -5664,7 +5869,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,
@@ -5781,9 +5994,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>
@@ -5792,7 +6007,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>
@@ -6187,8 +6402,8 @@ async function send(url2, target, headers, signal, opts) {
     ...secure && isIP(host) === 0 ? { servername: host } : {}
   };
   try {
-    return await new Promise((resolve6, reject) => {
-      const req = (secure ? httpsRequest : httpRequest)(options, resolve6);
+    return await new Promise((resolve7, reject) => {
+      const req = (secure ? httpsRequest : httpRequest)(options, resolve7);
       req.on("error", reject);
       req.end();
     });
@@ -6274,7 +6489,7 @@ function message(err) {
 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") {
@@ -6282,7 +6497,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)}`);
     }
@@ -6296,15 +6511,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 hit = cached2.find((name) => name.startsWith(`${stem}.`));
   const bytes = hit ? await readFile3(join2(dir, hit)) : await load(figure.src);
   const size3 = imageSize(bytes);
   if (hit) return { ...figure, src: hit, ...size3 };
   const src = `${stem}${assetExt(bytes, figure.src)}`;
   await writeFile2(join2(dir, src), bytes);
-  cached.push(src);
+  cached2.push(src);
   return { ...figure, src, ...size3 };
 }
 function assetStem(id2, src) {
@@ -6853,7 +7068,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",
@@ -6976,6 +7194,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
 
@@ -7760,7 +8001,7 @@ function codexCommand(args) {
 }
 function runCodex(args) {
   const { argv, env } = codexCommand(args);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = spawn("codex", argv, {
       stdio: ["pipe", "ignore", "pipe"],
       ...env === void 0 ? {} : { env }
@@ -7783,7 +8024,7 @@ function runCodex(args) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (code === 0) return resolve6();
+      if (code === 0) return resolve7();
       reject(
         new Error(`codex exec exited ${code}.
 ${stderr.trim().split("\n").slice(-8).join("\n")}`)
@@ -8244,7 +8485,7 @@ async function find2(can) {
   throw new Error(MISSING);
 }
 function runArgv(cmd, args) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -8254,8 +8495,8 @@ function runArgv(cmd, args) {
     child.stderr.on("data", (b) => {
       stderr += b.toString();
     });
-    child.on("error", (e) => resolve6({ code: -1, stderr: String(e), stdout }));
-    child.on("close", (code) => resolve6({ code: code ?? -1, stderr, stdout }));
+    child.on("error", (e) => resolve7({ code: -1, stderr: String(e), stdout }));
+    child.on("close", (code) => resolve7({ code: code ?? -1, stderr, stdout }));
   });
 }
 var edgeTts = {
@@ -8342,8 +8583,8 @@ async function synthesize(text2, opts) {
   const file = `${key}.mp3`;
   const audio = join6(opts.dir, file);
   const sidecar = join6(opts.dir, `${key}.json`);
-  const cached = await readSidecar(sidecar);
-  if (cached) return { audio, file, seconds: cached.seconds, cues: cached.cues };
+  const cached2 = await readSidecar(sidecar);
+  if (cached2) return { audio, file, seconds: cached2.seconds, cues: cached2.cues };
   await mkdir4(opts.dir, { recursive: true });
   const spoken = await provider.speak({ text: text2, voice: opts.voice, rate, pitch, audio });
   const { cues, seconds } = spoken;
@@ -8681,18 +8922,26 @@ import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir2 } from "node:os";
 import { join as join8 } from "node:path";
 import { pathToFileURL } from "node:url";
-async function chromePath(need = "open the deck with") {
-  const explicit = process.env.DECKSMITH_CHROME || process.env.CHROME_PATH;
-  if (explicit) return explicit;
+async function resolveChrome(need = "open the deck with") {
+  const env = process.env.HYPERFRAMES_BROWSER_PATH || process.env.DECKSMITH_CHROME || process.env.CHROME_PATH;
+  if (env) return { path: env, source: "env" };
   const { getInstalledBrowsers } = await import("@puppeteer/browsers");
-  const cacheDir = process.env.PUPPETEER_CACHE_DIR || join8(homedir2(), ".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(join8(homedir2(), ".cache", "hyperframes", "chrome"));
+  if (hf) return { path: hf.executablePath, source: "hyperframes" };
+  const pup = await pick(process.env.PUPPETEER_CACHE_DIR || join8(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.`
   );
 }
+async function chromePath(need = "open the deck with") {
+  return (await resolveChrome(need)).path;
+}
 function runtimePath() {
   return createRequire2(import.meta.url).resolve("hyperframes/dist/hyperframe.runtime.iife.js");
 }
@@ -8709,12 +8958,24 @@ async function openDeck(dir, opts = {}) {
   if (!width || !height) throw new Error("index.html declares no canvas size");
   const timeout = opts.timeoutMs ?? 6e4;
   const { default: puppeteer } = await import("puppeteer-core");
+  const chrome2 = await resolveChrome();
   const browser = await puppeteer.launch({
-    executablePath: await chromePath(),
+    executablePath: chrome2.path,
     headless: true,
-    // A retina host would otherwise hand back a 2x frame, whose clip is not the
-    // renderer's.
-    args: ["--force-device-scale-factor=1", "--hide-scrollbars"]
+    args: [
+      // A retina host would otherwise hand back a 2x frame, whose clip is not the
+      // renderer's.
+      "--force-device-scale-factor=1",
+      "--hide-scrollbars",
+      // WITHOUT THESE A WebGL CANVAS GETS NO CONTEXT AND SCREENSHOTS EMPTY. The
+      // renderer passes its own GL arguments; this path passed none, so it drew
+      // a blank rectangle and reported success. SwiftShader rather than the host
+      // GPU on purpose: it is the one backend available on every machine, and a
+      // gate that quietly follows the host's hardware is measuring the host.
+      "--use-gl=angle",
+      "--use-angle=swiftshader",
+      "--enable-unsafe-swiftshader"
+    ]
   });
   try {
     const page = await browser.newPage();
@@ -8730,6 +8991,18 @@ async function openDeck(dir, opts = {}) {
       { timeout }
     );
     await page.evaluate(() => document.fonts.ready);
+    const canvas = await page.evaluate(() => {
+      const el = document.querySelector("canvas");
+      if (!el) return { present: false, gl: true };
+      const probe2 = document.createElement("canvas");
+      const gl = !!(probe2.getContext("webgl2") ?? probe2.getContext("webgl"));
+      return { present: true, gl };
+    });
+    if (canvas.present && !canvas.gl) {
+      throw new Error(
+        `this deck draws on a <canvas> and ${chrome2.path} cannot create a WebGL context, so the capture would be of an empty rectangle. Chrome came from ${chrome2.source}; the renderer uses hyperframes' own shell. Set HYPERFRAMES_BROWSER_PATH to the binary \`hyperframes render\` uses so the gate and the render are the same browser.`
+      );
+    }
     const cdp = await page.createCDPSession();
     return {
       width,
@@ -9251,7 +9524,7 @@ ${tail3}`);
   }
 }
 function runLive(file, args) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = spawn3(file, args, { stdio: ["ignore", "inherit", "inherit"] });
     child.on("error", (err) => {
       reject(
@@ -9259,7 +9532,7 @@ function runLive(file, args) {
       );
     });
     child.on("close", (code, signal) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else if (signal) {
         reject(
           new Error(
@@ -10083,7 +10356,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 {
@@ -11052,9 +11329,57 @@ function textOf(node) {
   }
 }
 
+// src/tmpdir.ts
+import { realpathSync } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { tmpdir as tmpdir3 } from "node:os";
+import { basename as basename4, dirname as dirname4, join as join12, resolve as resolve5, sep } from "node:path";
+var cached;
+function real(dir) {
+  let at = resolve5(dir);
+  const tail3 = [];
+  for (; ; ) {
+    try {
+      return join12(realpathSync(at), ...tail3);
+    } catch {
+      const up = dirname4(at);
+      if (up === at) return resolve5(dir);
+      tail3.unshift(basename4(at));
+      at = up;
+    }
+  }
+}
+function packageRoot() {
+  cached ??= real(dirname4(createRequire3(import.meta.url).resolve("../package.json")));
+  return cached;
+}
+function insideRoot(dir) {
+  const root = packageRoot();
+  const at = real(dir);
+  return at === root || at.startsWith(root + sep);
+}
+function guardTmpdir() {
+  const before = tmpdir3();
+  if (!insideRoot(before)) return;
+  delete process.env.TMPDIR;
+  const after = tmpdir3();
+  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/verify/index.ts
 import { readdir as readdir3, readFile as readFile16 } from "node:fs/promises";
-import { join as join15, relative, sep } from "node:path";
+import { join as join16, relative, sep as sep2 } from "node:path";
 
 // src/verify/budget.ts
 function readCanvas(html) {
@@ -11162,7 +11487,7 @@ function clock2(seconds) {
 // src/verify/check.ts
 import { execFile as execFile2 } from "node:child_process";
 import { readFile as readFile13 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var run2 = promisify2(execFile2);
 var DEFAULT_TIMEOUT_MS3 = 24e4;
@@ -11192,7 +11517,7 @@ async function check2(dir, opts = {}) {
 async function readComposition(dir) {
   let html;
   try {
-    html = await readFile13(join12(dir, "index.html"), "utf8");
+    html = await readFile13(join13(dir, "index.html"), "utf8");
   } catch {
     return { transit: [], duration: 0 };
   }
@@ -11341,7 +11666,7 @@ function tail(s) {
 
 // src/verify/fidelity.ts
 import { readFile as readFile14 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/verify/typefloor.ts
 var TYPE_FLOOR_PX = 40;
@@ -11788,8 +12113,8 @@ async function fidelity(dir, opts = {}) {
     elapsedMs: Date.now() - started
   });
   const stops = opts.stops ?? readStops(
-    await readFile14(join13(dir, TIMING_FILE), "utf8").catch(() => null),
-    await readFile14(join13(dir, DECK_PAGE), "utf8").catch(() => null)
+    await readFile14(join14(dir, TIMING_FILE), "utf8").catch(() => null),
+    await readFile14(join14(dir, DECK_PAGE), "utf8").catch(() => null)
   );
   if (stops.length === 0) return notMeasured("the deck declares no stops");
   let deck = null;
@@ -11848,8 +12173,8 @@ async function fidelity(dir, opts = {}) {
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
 import { mkdtemp as mkdtemp3, readdir as readdir2, readFile as readFile15, rm as rm8 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join14 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join15 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var run3 = promisify3(execFile3);
 var FLOOR_DB = 40;
@@ -11888,9 +12213,9 @@ function measureMotion(hashes, scenes, seconds) {
 async function drift(dir, opts = {}) {
   const mode = opts.mode ?? "psnr";
   const floorDb = opts.floorDb ?? FLOOR_DB;
-  const work = opts.workDir ?? await mkdtemp3(join14(tmpdir3(), "decksmith-drift-"));
-  const a = join14(work, "a");
-  const b = join14(work, "b");
+  const work = opts.workDir ?? await mkdtemp3(join15(tmpdir4(), "decksmith-drift-"));
+  const a = join15(work, "a");
+  const b = join15(work, "b");
   const report2 = await compare(dir, a, b, mode, floorDb, opts);
   const keep = opts.keep || !report2.passed;
   if (keep) report2.kept = { a, b };
@@ -11945,11 +12270,11 @@ async function compare(dir, a, b, mode, floorDb, opts) {
   const differing = [];
   const ha = [];
   for (const [i, name] of fa.entries()) {
-    const one = await sha(join14(a, name));
+    const one = await sha(join15(a, name));
     ha.push(one);
-    if (one !== await sha(join14(b, name))) differing.push(i + 1);
+    if (one !== await sha(join15(b, name))) differing.push(i + 1);
   }
-  const html = await readFile15(join14(dir, COMPOSITION_PAGE), "utf8").catch(() => "");
+  const html = await readFile15(join15(dir, COMPOSITION_PAGE), "utf8").catch(() => "");
   const motion = measureMotion(ha, readScenes(html), readCanvas(html)?.seconds ?? 0);
   let worst;
   if (differing.length > 0) {
@@ -12097,11 +12422,11 @@ async function psnr(a, b, firstFrame) {
         "-start_number",
         String(seq.start),
         "-i",
-        join14(a, seq.pattern),
+        join15(a, seq.pattern),
         "-start_number",
         String(seq.start),
         "-i",
-        join14(b, seq.pattern),
+        join15(b, seq.pattern),
         "-lavfi",
         "psnr=stats_file=-",
         "-f",
@@ -12176,7 +12501,7 @@ async function verify(dir, opts = {}, storyboard, kept, source) {
   const html = await readCompositions(dir);
   const determinism = html.flatMap(([file, text2]) => scanDeterminism(text2, file));
   const narration = scanNarration(
-    await readFile16(join15(dir, DECK_PAGE), "utf8").catch(() => ""),
+    await readFile16(join16(dir, DECK_PAGE), "utf8").catch(() => ""),
     await listFiles(dir)
   );
   const budget3 = html.flatMap(([, text2]) => scanBudget(text2, storyboard, kept));
@@ -12213,8 +12538,8 @@ async function verify(dir, opts = {}, storyboard, kept, source) {
 }
 async function declaredStops(dir) {
   return readStops(
-    await readFile16(join15(dir, TIMING_FILE), "utf8").catch(() => null),
-    await readFile16(join15(dir, DECK_PAGE), "utf8").catch(() => null)
+    await readFile16(join16(dir, TIMING_FILE), "utf8").catch(() => null),
+    await readFile16(join16(dir, DECK_PAGE), "utf8").catch(() => null)
   );
 }
 var NARRATION_ISLAND = /<script type="application\/decksmith-narration\+json">([\s\S]*?)<\/script>/;
@@ -12254,7 +12579,7 @@ function scanNarration(page, files) {
   ];
 }
 async function readTiming2(dir) {
-  const raw2 = await readFile16(join15(dir, TIMING_FILE), "utf8").catch(() => "");
+  const raw2 = await readFile16(join16(dir, TIMING_FILE), "utf8").catch(() => "");
   if (!raw2) return void 0;
   try {
     const parsed = JSON.parse(raw2);
@@ -12266,7 +12591,7 @@ async function readTiming2(dir) {
 async function listFiles(dir) {
   const entries = await readdir3(dir, { recursive: true, withFileTypes: true }).catch(() => []);
   return new Set(
-    entries.filter((e) => e.isFile()).map((e) => relative(dir, join15(e.parentPath, e.name)).split(sep).join("/"))
+    entries.filter((e) => e.isFile()).map((e) => relative(dir, join16(e.parentPath, e.name)).split(sep2).join("/"))
   );
 }
 var INSTEAD = {
@@ -12525,13 +12850,14 @@ async function readCompositions(dir) {
   const entries = await readdir3(dir, { recursive: true, withFileTypes: true }).catch(() => []);
   const files = entries.filter(
     (e) => e.isFile() && e.name.endsWith(".html") && e.name !== DECK_PAGE && !e.parentPath.includes("node_modules")
-  ).map((e) => join15(e.parentPath, e.name));
+  ).map((e) => join16(e.parentPath, e.name));
   return Promise.all(
     files.map(async (f) => [relative(dir, f), await readFile16(f, "utf8")])
   );
 }
 
 // src/cli.ts
+guardTmpdir();
 var AUDIO_DIR = "audio";
 var NARRATION_FILE = "narration.json";
 var DEFAULTS = prefsSchema.parse({});
@@ -12544,43 +12870,48 @@ async function deckRuntime() {
   }
 }
 function playerBundle() {
-  const require2 = createRequire3(import.meta.url);
+  const require2 = createRequire4(import.meta.url);
   try {
-    return join16(dirname4(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
+    return join17(dirname5(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 = createRequire3(import.meta.url);
-  const dist = join16(dirname4(require2.resolve("katex/package.json")), "dist");
-  const css = await readFile17(join16(dist, "katex.min.css"), "utf8");
-  await mkdir10(join16(out, "katex/fonts"), { recursive: true });
-  for (const file of await readdir4(join16(dist, "fonts"))) {
+  const require2 = createRequire4(import.meta.url);
+  const dist = join17(dirname5(require2.resolve("katex/package.json")), "dist");
+  const css = await readFile17(join17(dist, "katex.min.css"), "utf8");
+  await mkdir10(join17(out, "katex/fonts"), { recursive: true });
+  for (const file of await readdir4(join17(dist, "fonts"))) {
     if (file.endsWith(".woff2"))
-      await cp(join16(dist, "fonts", file), join16(out, "katex/fonts", file));
+      await cp(join17(dist, "fonts", file), join17(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 writeFile12(join16(out, "katex/katex.min.css"), woff2Only);
+  await writeFile12(join17(out, "katex/katex.min.css"), woff2Only);
 }
-async function vendorScripts(out) {
-  const require2 = createRequire3(import.meta.url);
-  await mkdir10(join16(out, "vendor"), { recursive: true });
+async function vendorScripts(out, composition) {
+  const require2 = createRequire4(import.meta.url);
+  await mkdir10(join17(out, "vendor"), { recursive: true });
+  const wanted = (name) => composition.includes(`./vendor/${name}`);
   for (const [pkg, rel, name] of [
     ["gsap/package.json", "dist/gsap.min.js", "gsap.min.js"],
     ["gsap/package.json", "dist/DrawSVGPlugin.min.js", "DrawSVGPlugin.min.js"],
+    ["gsap/package.json", "dist/MorphSVGPlugin.min.js", "MorphSVGPlugin.min.js"],
     ["katex/package.json", "dist/katex.min.js", "katex.min.js"]
   ]) {
-    const from = join16(dirname4(require2.resolve(pkg)), rel);
-    await cp(from, join16(out, "vendor", name));
+    if (!wanted(name)) continue;
+    const from = join17(dirname5(require2.resolve(pkg)), rel);
+    await cp(from, join17(out, "vendor", name));
+  }
+  if (wanted("ds-morph.js")) {
+    await cp(
+      fileURLToPath(new URL("./ds-morph.js", import.meta.url)),
+      join17(out, "vendor", "ds-morph.js")
+    );
   }
-  await cp(
-    fileURLToPath(new URL("./ds-morph.js", import.meta.url)),
-    join16(out, "vendor", "ds-morph.js")
-  );
 }
 var HYPERFRAMES_JSON = `${JSON.stringify(
   {
@@ -12683,13 +13014,13 @@ program.command("ingest").description("Parse a document or a web page into sourc
   "--max-clip-seconds <n>",
   "URL only: seconds of each clip kept, the rest trimmed (maxClipSeconds; default 60)"
 ).option("--no-transcode", "URL only: ship each clip as the page served it, unshrunk").action(async (input, o) => {
-  const assets = join16(dirname4(resolve5(o.out)), "assets");
-  const scratch = url(input) ? await mkdtemp4(join16(tmpdir4(), "decksmith-harvest-")) : void 0;
+  const assets = join17(dirname5(resolve6(o.out)), "assets");
+  const scratch = url(input) ? await mkdtemp4(join17(tmpdir5(), "decksmith-harvest-")) : void 0;
   try {
     let md;
     let clips = [];
     if (scratch === void 0) {
-      md = await readFile17(resolve5(input), "utf8").catch(() => {
+      md = await readFile17(resolve6(input), "utf8").catch(() => {
         throw new Error(`Cannot read ${input}.`);
       });
     } else {
@@ -12710,7 +13041,7 @@ program.command("ingest").description("Parse a document or a web page into sourc
     const dropped = [];
     const source = await fetchFigures(withClips, assets, dropped);
     for (const why3 of dropped) step(`ingest: ${why3}`);
-    const bundle = await bundleFont(source.lang, glyphs(source), join16(assets, "fonts"));
+    const bundle = await bundleFont(source.lang, glyphs(source), join17(assets, "fonts"));
     if (bundle) step(`ingest: bundled ${bundle.family} for ${source.lang}`);
     await writeJson(o.out, source);
     step(`ingest: wrote ${o.out}`);
@@ -12771,7 +13102,7 @@ imageFlags(
   program.command("illustrate").description("Draw the pictures the plan asked for, and point the storyboard at them.").argument("<storyboard>", "storyboard.json carrying illustration briefs").requiredOption("--source <file>", "source.json the storyboard was planned from")
 ).action(async (sbPath, o) => {
   const storyboard = await readValidated(sbPath, storyboardSchema, "storyboard");
-  const sourcePath = resolve5(String(o.source));
+  const sourcePath = resolve6(String(o.source));
   const source = await readValidated(sourcePath, sourceSchema, "source");
   assertRefsResolve(storyboard, source, { pending: "allow" });
   const prefs = await loadPrefs(prefsFromFlags({ ...flags(o), images: true }));
@@ -12785,7 +13116,7 @@ imageFlags(
   );
   const drawn = await illustrate(storyboard, source, {
     prefs,
-    assetsDir: join16(dirname4(sourcePath), "assets"),
+    assetsDir: join17(dirname5(sourcePath), "assets"),
     onStep: step
   });
   for (const p of drawn.illustrated) {
@@ -12795,9 +13126,9 @@ imageFlags(
   }
   await writeJson(sourcePath, drawn.source);
   await writeJson(sbPath, drawn.storyboard);
-  const cached = drawn.illustrated.filter((p) => p.cached).length;
+  const cached2 = drawn.illustrated.filter((p) => p.cached).length;
   step(
-    `illustrate: ${drawn.illustrated.length} picture(s)${cached ? `, ${cached} cached` : ""} \u2192 ${o.source}, ${sbPath}`
+    `illustrate: ${drawn.illustrated.length} picture(s)${cached2 ? `, ${cached2} cached` : ""} \u2192 ${o.source}, ${sbPath}`
   );
 });
 voiceFlags(
@@ -12810,18 +13141,18 @@ voiceFlags(
   const format = pickFormat(String(o.format), o.width, o.height);
   const chosen = await loadPrefs(prefsFromFlags(flags(o)));
   const prefs = stated(chosen, "lang") ? chosen : { ...chosen, lang: storyboard.lang };
-  const dir = resolve5(String(o.out));
+  const dir = resolve6(String(o.out));
   const speaking = storyboard.beats.filter((b) => b.narration?.trim()).length;
   if (speaking === 0) {
     throw new Error(`No beat in ${sbPath} has a "narration" field, so there is nothing to speak.`);
   }
   step(`narrate: ${speaking} of ${storyboard.beats.length} beats have narration`);
   const narration = await narrate(storyboard, source, prefs, { dir, format });
-  await writeJson(join16(dir, NARRATION_FILE), narration);
+  await writeJson(join17(dir, NARRATION_FILE), narration);
   const segments2 = Object.values(narration.beats).flat();
   const seconds = segments2.reduce((sum, s) => sum + s.seconds, 0);
   step(
-    `narrate: ${segments2.length} segments, ${seconds.toFixed(1)}s in ${narration.voice} \u2192 ${join16(dir, NARRATION_FILE)}`
+    `narrate: ${segments2.length} segments, ${seconds.toFixed(1)}s in ${narration.voice} \u2192 ${join17(dir, NARRATION_FILE)}`
   );
 });
 lookFlags(
@@ -12836,7 +13167,7 @@ lookFlags(
     const format = withMinWeight(pickFormat(o.format, o.width, o.height), o.minWeight);
     const prefs = await loadPrefs(prefsFromFlags(flags(o)), process.cwd(), source);
     const theme = stated(prefs, "theme") ?? storyboard.theme;
-    const out = resolve5(o.out);
+    const out = resolve6(o.out);
     await mkdir10(out, { recursive: true });
     const found = await findNarration(sbPath, o.narration);
     const narration = found ? await loadNarration(found) : void 0;
@@ -12861,10 +13192,14 @@ lookFlags(
       // takes eleven good ones with it at the last stage. Printed, not swallowed:
       // a missing slide the terminal never mentioned is the failure this project
       // keeps finding by eye.
-      onBeatError: (id2, err) => step(`build: left out ${id2} \u2014 ${err.message}`)
+      onBeatError: (id2, err) => step(`build: left out ${id2} \u2014 ${err.message}`),
+      // And the slides that ARE here but not as they were planned. A beat drawn
+      // with one of its parts dropped looks finished, so this line is the only
+      // place anyone learns it is not.
+      onBeatWarning: (id2, warning) => step(`build: kept ${id2} \u2014 ${warning}`)
     });
-    await writeFile12(join16(out, "index.html"), deck.composition);
-    await writeFile12(join16(out, "hyperframes.json"), HYPERFRAMES_JSON);
+    await writeFile12(join17(out, "index.html"), deck.composition);
+    await writeFile12(join17(out, "hyperframes.json"), HYPERFRAMES_JSON);
     await writeTiming(out, {
       storyboard,
       source,
@@ -12880,36 +13215,36 @@ lookFlags(
       ...narration ? { narration } : {}
     });
     if (deck.page) {
-      await writeFile12(join16(out, DECK_PAGE), deck.page);
-      await cp(playerBundle(), join16(out, PLAYER_FILE));
+      await writeFile12(join17(out, DECK_PAGE), deck.page);
+      await cp(playerBundle(), join17(out, PLAYER_FILE));
     }
     await vendorKatex(out);
-    await vendorScripts(out);
-    await copyAssets(dirname4(resolve5(o.source)), out, source.figures);
-    if (found && narration) await copyAudio(dirname4(found), narration, out);
+    await vendorScripts(out, deck.composition);
+    await copyAssets(dirname5(resolve6(o.source)), out, source.figures);
+    if (found && narration) await copyAudio(dirname5(found), narration, out);
     const look = [theme, paced.speed === 1 ? "" : `${paced.speed}\xD7 speed`].filter(Boolean).join(", ");
     const { cut } = deck;
     const floor = cut.dropped.filter((d) => d.rule === "below_min_weight").length;
     const of = cut.kept.length === storyboard.beats.length ? "" : ` of ${storyboard.beats.length}`;
     step(
-      `build: ${cut.kept.length}${of} beats at ${format.width}\xD7${format.height} in ${look}${floor > 0 ? ` (${floor} below minWeight ${format.minWeight})` : ""} \u2192 ${join16(out, "index.html")}`
+      `build: ${cut.kept.length}${of} beats at ${format.width}\xD7${format.height} in ${look}${floor > 0 ? ` (${floor} below minWeight ${format.minWeight})` : ""} \u2192 ${join17(out, "index.html")}`
     );
     for (const f of scanPaperArc({ ...storyboard, beats: cut.kept }, prefs))
       step(`build: ${f.message}`);
     reportCut(cut);
-    if (deck.page) step(`build: navigable deck \u2192 ${join16(out, DECK_PAGE)}`);
+    if (deck.page) step(`build: navigable deck \u2192 ${join17(out, DECK_PAGE)}`);
     await gate(out, false, storyboard, cut.kept, o.fidelity !== false, source);
   }
 );
 program.command("verify").description("Re-run the gates on a built deck.").argument("<dir>", "a built deck directory").option("--snapshots", "also write the contrast-pass PNGs to <dir>/snapshots", false).option("--no-fidelity", "skip the frame check \u2014 only for a machine with no browser").action(async (dir, o) => {
-  await gate(resolve5(dir), o.snapshots, void 0, void 0, o.fidelity !== false);
+  await gate(resolve6(dir), o.snapshots, void 0, void 0, o.fidelity !== false);
 });
 program.command("frames").description("Write PNGs of a built deck through the capture path the renderer uses.").argument("<dir>", "a built deck directory").option(
   "--at <seconds...>",
   "absolute times to photograph; defaults to every hold the deck declares"
 ).option("--out <dir>", "where to write the PNGs (default: <dir>/frames)").action(async (dir, o) => {
-  const deck = resolve5(dir);
-  const out = resolve5(o.out ?? join16(deck, "frames"));
+  const deck = resolve6(dir);
+  const out = resolve6(o.out ?? join17(deck, "frames"));
   let times;
   if (o.at?.length) {
     times = o.at.map((raw2) => {
@@ -12919,8 +13254,8 @@ program.command("frames").description("Write PNGs of a built deck through the ca
     });
   } else {
     times = readStops(
-      await readFile17(join16(deck, TIMING_FILE), "utf8").catch(() => null),
-      await readFile17(join16(deck, DECK_PAGE), "utf8").catch(() => null)
+      await readFile17(join17(deck, TIMING_FILE), "utf8").catch(() => null),
+      await readFile17(join17(deck, DECK_PAGE), "utf8").catch(() => null)
     ).map((s) => s.t);
     if (times.length === 0)
       throw new Error(
@@ -12934,7 +13269,7 @@ program.command("frames").description("Write PNGs of a built deck through the ca
 program.command("drift").description("Render a built deck twice and compare, frame by frame. Minutes, not seconds.").argument("<dir>", "a built deck directory").option("--identical", "require every frame byte-identical \u2014 image-free decks only", false).option("--floor <dB>", "per-frame PSNR floor", String(FLOOR_DB)).option("--keep", "keep both frame directories even when they agree").option("--workers <n>", "pin both renders to one worker count (default: 1 vs 3)").action(
   async (dir, o) => {
     step("drift: rendering twice, several minutes a render");
-    const verdict = await drift(resolve5(dir), {
+    const verdict = await drift(resolve6(dir), {
       mode: o.identical ? "identical" : "psnr",
       floorDb: Number(o.floor),
       ...o.keep ? { keep: true } : {},
@@ -12961,8 +13296,8 @@ program.command("render").description("Render a built deck to a finished video:
       throw new Error(`Unknown --subtitles "${o.subtitles}". Use sidecar, burn or none.`);
     }
     const result = await render({
-      deck: resolve5(dir),
-      out: resolve5(o.out),
+      deck: resolve6(dir),
+      out: resolve6(o.out),
       subtitles: o.subtitles,
       protocolTimeoutMs: Number(o.protocolTimeout),
       log: step,
@@ -12990,7 +13325,7 @@ voiceFlags(
   )
 ).action(async (sbPath, o) => {
   const storyboard = await readValidated(sbPath, storyboardSchema, "storyboard");
-  const sourcePath = resolve5(String(o.source));
+  const sourcePath = resolve6(String(o.source));
   const source = await readValidated(sourcePath, sourceSchema, "source");
   assertRefsResolve(storyboard, source);
   if (o.bake && o.link) throw new Error("Choose --bake or --link, not both.");
@@ -13005,7 +13340,7 @@ voiceFlags(
   const prefer = o.link ? "link" : "bake";
   const plan = await planMedia(figureAssets(source, sourcePath, prefer));
   const files = { ...plan.files };
-  if (found && narration) Object.assign(files, await audioFiles(dirname4(found), narration));
+  if (found && narration) Object.assign(files, await audioFiles(dirname5(found), narration));
   const pack2 = {
     version: PACK_VERSION,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13020,7 +13355,7 @@ voiceFlags(
     ...narration ? { narration } : {},
     media: plan.media
   };
-  const out = resolve5(String(o.out));
+  const out = resolve6(String(o.out));
   const bytes = await writePack(pack2, files, out);
   if (plan.demoted.length) {
     step(`pack: kept as links, not bakeable \u2014 ${plan.demoted.join(", ")}`);
@@ -13034,19 +13369,19 @@ voiceFlags(
   step(`pack: ${size2(bytes)} \u2192 ${out}`);
 });
 program.command("unpack").description("Open a .deck back into the files build reads.").argument("<file>", "a .deck archive").requiredOption("-o, --out <dir>", "directory to open it into").action(async (file, o) => {
-  const { pack: pack2, files } = await readPack(resolve5(file));
-  const out = resolve5(o.out);
-  await writeJson(join16(out, "source.json"), pack2.source);
-  await writeJson(join16(out, "storyboard.json"), pack2.storyboard);
-  await writeJson(join16(out, "decksmith.config.json"), pack2.prefs);
-  if (pack2.narration) await writeJson(join16(out, AUDIO_DIR, NARRATION_FILE), pack2.narration);
+  const { pack: pack2, files } = await readPack(resolve6(file));
+  const out = resolve6(o.out);
+  await writeJson(join17(out, "source.json"), pack2.source);
+  await writeJson(join17(out, "storyboard.json"), pack2.storyboard);
+  await writeJson(join17(out, "decksmith.config.json"), pack2.prefs);
+  if (pack2.narration) await writeJson(join17(out, AUDIO_DIR, NARRATION_FILE), pack2.narration);
   const figures = new Map(pack2.source.figures.map((f) => [f.id, f.src]));
   for (const [path2, bytes] of Object.entries(files)) {
     const media = pack2.media.find((m) => m.path === path2);
     const src = media && figures.get(media.id);
-    const to = src ? join16("assets", src) : path2;
-    await mkdir10(dirname4(join16(out, to)), { recursive: true });
-    await writeFile12(join16(out, to), bytes);
+    const to = src ? join17("assets", src) : path2;
+    await mkdir10(dirname5(join17(out, to)), { recursive: true });
+    await writeFile12(join17(out, to), bytes);
   }
   const linked = pack2.media.filter((m) => m.policy !== "bake");
   step(`unpack: "${pack2.title}", ${pack2.storyboard.beats.length} beats \u2192 ${out}`);
@@ -13056,7 +13391,7 @@ program.command("unpack").description("Open a .deck back into the files build re
     );
   }
   step(
-    `unpack: decksmith build ${join16(relative2(process.cwd(), out) || ".", "storyboard.json")} --source ${join16(relative2(process.cwd(), out) || ".", "source.json")} -o deck`
+    `unpack: decksmith build ${join17(relative2(process.cwd(), out) || ".", "storyboard.json")} --source ${join17(relative2(process.cwd(), out) || ".", "source.json")} -o deck`
   );
 });
 program.parseAsync(process.argv).catch((err) => {
@@ -13077,7 +13412,7 @@ async function gate(dir, snapshots = false, storyboard, kept, fidelity2 = true,
   );
   const verdict = await verify(dir, { snapshots, fidelity: fidelity2 }, storyboard, kept, source);
   process.stdout.write(report(verdict));
-  if (snapshots) step(`verify: snapshots in ${join16(dir, "snapshots")}`);
+  if (snapshots) step(`verify: snapshots in ${join17(dir, "snapshots")}`);
   if (!verdict.passed) process.exitCode = 1;
 }
 function report(v) {
@@ -13094,12 +13429,12 @@ function report(v) {
 async function findNarration(sbPath, flag) {
   if (flag === false) return void 0;
   if (typeof flag === "string") {
-    const path2 = resolve5(flag);
+    const path2 = resolve6(flag);
     if (!await stat2(path2).catch(() => null)) throw new Error(`Cannot read narration ${flag}.`);
     return path2;
   }
-  const beside = dirname4(resolve5(sbPath));
-  for (const candidate of [join16(beside, AUDIO_DIR, NARRATION_FILE), join16(beside, NARRATION_FILE)]) {
+  const beside = dirname5(resolve6(sbPath));
+  for (const candidate of [join17(beside, AUDIO_DIR, NARRATION_FILE), join17(beside, NARRATION_FILE)]) {
     if (await stat2(candidate).catch(() => null)) {
       step(`narration: using ${candidate}`);
       return candidate;
@@ -13119,11 +13454,11 @@ function audioNames(narration) {
   ].sort();
 }
 async function copyAudio(from, narration, out) {
-  const dir = join16(out, AUDIO_DIR);
+  const dir = join17(out, AUDIO_DIR);
   await mkdir10(dir, { recursive: true });
   const names = audioNames(narration);
   for (const name of names) {
-    await cp(join16(from, name), join16(dir, name)).catch(() => {
+    await cp(join17(from, name), join17(dir, name)).catch(() => {
       throw new Error(`Narration names ${name}, but it is not in ${from}. Re-run \`narrate\`.`);
     });
   }
@@ -13132,7 +13467,7 @@ async function copyAudio(from, narration, out) {
 async function audioFiles(from, narration) {
   const files = {};
   for (const name of audioNames(narration)) {
-    const bytes = await readFile17(join16(from, name)).catch(() => {
+    const bytes = await readFile17(join17(from, name)).catch(() => {
       throw new Error(`Narration names ${name}, but it is not in ${from}. Re-run \`narrate\`.`);
     });
     files[`${AUDIO_DIR}/${name}`] = new Uint8Array(bytes);
@@ -13154,9 +13489,9 @@ function wrapScript(text2, width) {
 async function writeTiming(out, input) {
   try {
     const timing = planTiming(input);
-    await writeJson(join16(out, TIMING_FILE), timing);
+    await writeJson(join17(out, TIMING_FILE), timing);
     step(
-      `build: timing for ${timing.segments.length} narration segment(s) \u2192 ${join16(out, TIMING_FILE)}`
+      `build: timing for ${timing.segments.length} narration segment(s) \u2192 ${join17(out, TIMING_FILE)}`
     );
   } catch (err) {
     step(
@@ -13165,10 +13500,10 @@ async function writeTiming(out, input) {
   }
 }
 function figureAssets(source, sourcePath, prefer) {
-  const assets = join16(dirname4(sourcePath), "assets");
+  const assets = join17(dirname5(sourcePath), "assets");
   return source.figures.map((f) => ({
     id: f.id,
-    url: /^[a-z][a-z0-9+.-]*:/i.test(f.src) ? f.src : join16(assets, f.src),
+    url: /^[a-z][a-z0-9+.-]*:/i.test(f.src) ? f.src : join17(assets, f.src),
     prefer
   }));
 }
@@ -13197,7 +13532,7 @@ function withMinWeight(format, raw2) {
   return { ...format, minWeight };
 }
 async function copyAssets(sourceDir, out, figures) {
-  const from = join16(sourceDir, "assets");
+  const from = join17(sourceDir, "assets");
   if (!await stat2(from).catch(() => null)) {
     step(`build: no assets/ beside source.json, skipping`);
     return;
@@ -13205,19 +13540,19 @@ async function copyAssets(sourceDir, out, figures) {
   const wanted = new Set(
     figures.flatMap((f) => [f.src, f.poster]).filter((n3) => n3 !== void 0).map((n3) => n3.replace(/^\.?\//, ""))
   );
-  await mkdir10(join16(out, "assets"), { recursive: true });
+  await mkdir10(join17(out, "assets"), { recursive: true });
   let copied = 0;
   for (const name of wanted) {
-    const src = resolve5(join16(from, name));
-    if (!src.startsWith(`${resolve5(from)}/`)) continue;
+    const src = resolve6(join17(from, name));
+    if (!src.startsWith(`${resolve6(from)}/`)) continue;
     if (!await stat2(src).catch(() => null)) continue;
-    await mkdir10(dirname4(join16(out, "assets", name)), { recursive: true });
-    await cp(src, join16(out, "assets", name));
+    await mkdir10(dirname5(join17(out, "assets", name)), { recursive: true });
+    await cp(src, join17(out, "assets", name));
     copied++;
   }
-  const fonts = join16(from, "fonts");
+  const fonts = join17(from, "fonts");
   if (await stat2(fonts).catch(() => null)) {
-    await cp(fonts, join16(out, "assets", "fonts"), { recursive: true });
+    await cp(fonts, join17(out, "assets", "fonts"), { recursive: true });
   }
   step(`build: copied ${copied} referenced figure(s)`);
 }
@@ -13226,7 +13561,7 @@ async function refreshFont(storyboard, source, out) {
     const bundle = await bundleFont(
       storyboard.lang,
       glyphs(source) + glyphs(storyboard),
-      join16(out, "assets", "fonts")
+      join17(out, "assets", "fonts")
     );
     if (bundle) step(`build: font bundle covers ${bundle.family}`);
     return bundle?.css;
@@ -13241,7 +13576,7 @@ function glyphs(value) {
   return JSON.stringify(value);
 }
 async function readValidated(file, schema, label) {
-  const text2 = await readFile17(resolve5(file), "utf8").catch(() => {
+  const text2 = await readFile17(resolve6(file), "utf8").catch(() => {
     throw new Error(`Cannot read ${label} file ${file}.`);
   });
   let json;
@@ -13259,8 +13594,8 @@ ${issues}`);
   return parsed.data;
 }
 async function writeJson(file, value) {
-  const path2 = resolve5(file);
-  await mkdir10(dirname4(path2), { recursive: true });
+  const path2 = resolve6(file);
+  await mkdir10(dirname5(path2), { recursive: true });
   await writeFile12(path2, `${JSON.stringify(value, null, 2)}
 `);
 }