@jokerized/decksmith 0.3.1 → 0.3.2

package/dist/index.js

@@ -1,9 +1,243 @@
 // src/index.ts
-import { cp, mkdir as mkdir9, readdir as readdir3, readFile as readFile16, stat, writeFile as writeFile11 } from "node:fs/promises";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname4, join as join15, resolve as resolve4 } from "node:path";
+import { cp, mkdir as mkdir10, readdir as readdir4, readFile as readFile17, stat as stat2, writeFile as writeFile12 } from "node:fs/promises";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname4, join as join16, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/pack/media.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+var PLAYERS = [
+  "youtube.com",
+  "youtube-nocookie.com",
+  "youtu.be",
+  "vimeo.com",
+  "dailymotion.com",
+  "dai.ly",
+  "twitch.tv",
+  "loom.com",
+  "wistia.com",
+  "wistia.net",
+  "streamable.com",
+  "bilibili.com",
+  "soundcloud.com",
+  "tiktok.com"
+];
+var FILE_EXT = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".mp4",
+  ".webm",
+  ".mov",
+  ".m4v",
+  ".mp3",
+  ".m4a",
+  ".wav",
+  ".ogg",
+  ".opus",
+  ".pdf"
+]);
+function isEmbed(url) {
+  const host = hostOf(url);
+  return host !== null && PLAYERS.some((p) => host === p || host.endsWith(`.${p}`));
+}
+function segments(u) {
+  return u.pathname.split("/").filter(Boolean);
+}
+function token(raw2) {
+  return raw2 && /^[A-Za-z0-9_-]{1,64}$/.test(raw2) ? raw2 : void 0;
+}
+var YOUTUBE_EMBED = "https://www.youtube-nocookie.com";
+var youtube = (id2) => id2 === void 0 ? void 0 : `${YOUTUBE_EMBED}/embed/${id2}`;
+var YOUTUBE = {
+  origin: YOUTUBE_EMBED,
+  embed: (u) => {
+    const seg = segments(u);
+    const path2 = seg[0];
+    return youtube(
+      token(
+        path2 === "watch" ? u.searchParams.get("v") : path2 === "embed" || path2 === "shorts" || path2 === "live" || path2 === "v" ? seg[1] : void 0
+      )
+    );
+  }
+};
+var YOUTU_BE = {
+  origin: YOUTUBE_EMBED,
+  embed: (u) => youtube(token(segments(u)[0]))
+};
+var VIMEO_EMBED = "https://player.vimeo.com";
+var VIMEO = {
+  origin: VIMEO_EMBED,
+  embed: (u) => {
+    const seg = segments(u);
+    const [head, next] = seg[0] === "video" ? [seg[1], seg[2]] : [seg[0], seg[1]];
+    if (head === void 0 || !/^\d+$/.test(head)) return void 0;
+    const hash = token(next ?? u.searchParams.get("h"));
+    return `${VIMEO_EMBED}/video/${head}?${hash ? `h=${hash}&` : ""}dnt=1`;
+  }
+};
+var DAILYMOTION_EMBED = "https://www.dailymotion.com";
+var dailymotion = (id2) => id2 === void 0 ? void 0 : `${DAILYMOTION_EMBED}/embed/video/${id2}`;
+var DAILYMOTION = {
+  origin: DAILYMOTION_EMBED,
+  embed: (u) => {
+    const seg = segments(u);
+    return dailymotion(
+      token(seg[0] === "video" ? seg[1] : seg[0] === "embed" ? seg[2] : void 0)
+    );
+  }
+};
+var DAI_LY = {
+  origin: DAILYMOTION_EMBED,
+  embed: (u) => dailymotion(token(segments(u)[0]))
+};
+var LOOM = {
+  origin: "https://www.loom.com",
+  embed: (u) => {
+    const seg = segments(u);
+    const id2 = token(seg[0] === "share" || seg[0] === "embed" ? seg[1] : void 0);
+    return id2 === void 0 ? void 0 : `https://www.loom.com/embed/${id2}`;
+  }
+};
+var EMBEDS = {
+  "youtube.com": YOUTUBE,
+  "youtube-nocookie.com": YOUTUBE,
+  "youtu.be": YOUTU_BE,
+  "vimeo.com": VIMEO,
+  "dailymotion.com": DAILYMOTION,
+  "dai.ly": DAI_LY,
+  "loom.com": LOOM
+};
+var EMBED_ORIGINS = [
+  ...new Set(Object.values(EMBEDS).map((e) => e.origin))
+];
+function embedUrl(url) {
+  const host = hostOf(url);
+  if (host === null) return void 0;
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return void 0;
+  }
+  if (u.protocol !== "https:" && u.protocol !== "http:") return void 0;
+  const rule = Object.entries(EMBEDS).find(([h]) => host === h || host.endsWith(`.${h}`))?.[1];
+  return rule?.embed(u);
+}
+function policyFor(url, prefer) {
+  if (isEmbed(url)) return "embed";
+  const host = hostOf(url);
+  if (host === null || /^data:/i.test(url)) return "bake";
+  if (prefer === "link") return "link";
+  return FILE_EXT.has(extOf(url)) ? "bake" : "link";
+}
+async function planMedia(assets, fetcher = fetchAsset) {
+  const plan = {
+    media: [],
+    files: {},
+    bakedCount: 0,
+    bakedBytes: 0,
+    demoted: [],
+    promoted: []
+  };
+  for (const asset of assets) {
+    const policy = policyFor(asset.url, asset.prefer);
+    if (policy !== "bake") {
+      if (asset.prefer === "bake") plan.demoted.push(asset.id);
+      plan.media.push({ id: asset.id, policy, url: asset.url, mime: asset.mime });
+      continue;
+    }
+    if (asset.prefer === "link") plan.promoted.push(asset.id);
+    const got = await fetcher(asset.url);
+    const mime = clean(got.mime) ?? asset.mime;
+    if (mime === "text/html") {
+      plan.demoted.push(asset.id);
+      plan.media.push({ id: asset.id, policy: "link", url: asset.url, mime });
+      continue;
+    }
+    const path2 = `media/${bakedName(asset.id, asset.url, mime)}`;
+    plan.files[path2] = got.bytes;
+    plan.bakedCount += 1;
+    plan.bakedBytes += got.bytes.length;
+    plan.media.push({ id: asset.id, policy: "bake", path: path2, mime, bytes: got.bytes.length });
+  }
+  return plan;
+}
+function mediaSummary(plan) {
+  const linked = plan.media.filter((m) => m.policy === "link").length;
+  const embedded = plan.media.filter((m) => m.policy === "embed").length;
+  const parts = [`${plan.bakedCount} baked (${size(plan.bakedBytes)})`];
+  if (linked) parts.push(`${linked} linked`);
+  if (embedded) parts.push(`${embedded} embedded`);
+  if (plan.demoted.length) parts.push(`${plan.demoted.length} not bakeable`);
+  return parts.join(", ");
+}
+function bakedName(id2, url, mime) {
+  const slug = id2.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "asset";
+  const hash = createHash("sha256").update(url).digest("hex").slice(0, 8);
+  return `${slug}-${hash}${extOf(url) || extFor(mime)}`;
+}
+function extOf(url) {
+  const path2 = hostOf(url) === null ? url : new URL(url).pathname;
+  const ext = extname(path2).toLowerCase();
+  return FILE_EXT.has(ext) ? ext : "";
+}
+var MIME_EXT = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/avif": ".avif",
+  "image/svg+xml": ".svg",
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "audio/mpeg": ".mp3",
+  "application/pdf": ".pdf"
+};
+function extFor(mime) {
+  return (mime && MIME_EXT[mime]) ?? ".bin";
+}
+function hostOf(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "file:" || u.protocol === "data:") return null;
+    return u.hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    return null;
+  }
+}
+function clean(mime) {
+  return mime?.split(";")[0]?.trim().toLowerCase() || void 0;
+}
+function size(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let n3 = bytes / 1024;
+  let i = 0;
+  while (n3 >= 1024 && i < units.length - 1) {
+    n3 /= 1024;
+    i += 1;
+  }
+  return `${n3 < 10 ? n3.toFixed(1) : Math.round(n3)} ${units[i]}`;
+}
+async function fetchAsset(url) {
+  if (/^(https?|data):/i.test(url)) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`${url}: HTTP ${res.status}`);
+    return {
+      bytes: new Uint8Array(await res.arrayBuffer()),
+      mime: res.headers.get("content-type") ?? void 0
+    };
+  }
+  return { bytes: new Uint8Array(await readFile(url)) };
+}
+
 // src/types.ts
 import { z } from "zod";
 var refSchema = z.object({
@@ -12,9 +246,34 @@ var refSchema = z.object({
 });
 var figureSchema = z.object({
   id: z.string(),
+  /**
+   * WHAT THE ASSET IS. A CLIP IS A FIGURE.
+   *
+   * A harvested page hands back stills and video in one pass, and the obvious
+   * shape for the video — a fifth `Source` array and a fifth `refSchema` kind —
+   * costs every layer that already knows what a figure is: the inventory
+   * `renderSource` prints, `assertRefsResolve`, the archetypes that take a
+   * `figureId`, and the pack. All of them would need a second word for "the
+   * thing this beat points at", and `refSchema` is a CLOSED enum of four kinds
+   * that a fifth entry would put into every stored plan's schema. A clip is a
+   * rectangle with intrinsic pixels and a caption that a beat points at, which
+   * is what a figure is; what differs is one branch at emit.
+   *
+   * DEFAULTED rather than required, and that is the whole point of the field
+   * being an enum with a default: every `source.json` written before clips
+   * existed parses unchanged and comes back an `image`, which is what it has
+   * always been.
+   */
+  kind: z.enum(["image", "clip"]).default("image"),
   /** Path relative to the deck's asset directory. */
   src: z.string(),
   caption: z.string(),
+  /**
+   * The intrinsic pixel size layout keys off — for a clip, the VIDEO's own
+   * dimensions, not the poster's. Every fit, crop and leader-line fraction
+   * downstream is expressed against this box, so a clip whose poster was
+   * letterboxed to another shape would put every annotation in the wrong place.
+   */
   width: z.int().positive(),
   height: z.int().positive(),
   /**
@@ -32,7 +291,26 @@ var figureSchema = z.object({
    */
   sectionId: z.string().optional(),
   /** The sentence or paragraph that refers to it, verbatim from the document. */
-  mention: z.string().optional()
+  mention: z.string().optional(),
+  // THE THREE FIELDS ONLY A CLIP USES. All optional, for the same reason `kind`
+  // is defaulted: an image carries none of them, and a source written before
+  // clips existed parses into exactly the object it always did.
+  /**
+   * The local still that represents the clip — what the deck shows before
+   * anyone presses play, and what stands in wherever the video cannot run at
+   * all. A clip whose video could not be downloaded is this still and nothing
+   * else, so it is the picture the beat is really planned around.
+   */
+  poster: z.string().optional(),
+  /** How long the clip runs. Seconds, as measured off the file, never guessed. */
+  seconds: z.number().positive().optional(),
+  /**
+   * The page the video lives ON, when the video itself is not a file we can
+   * fetch — a player page, an embed, anything whose terms or DRM make the bytes
+   * unavailable. Then `poster` is all the deck can show, and this is where a
+   * viewer goes to watch the thing. Absent for a clip we hold the file for.
+   */
+  href: z.string().optional()
 });
 var equationSchema = z.object({
   id: z.string(),
@@ -908,8 +1186,8 @@ function clock(seconds) {
 }
 
 // src/source/fonts.ts
-import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 function familyFor(lang) {
   const tag = lang.toLowerCase();
@@ -923,11 +1201,11 @@ async function bundleFont(lang, glyphs, dir) {
   const family = familyFor(lang);
   if (!family) return null;
   const text2 = [...new Set(glyphs)].filter((c) => c > " ").sort().join("");
-  const stamp = `/* decksmith ${createHash("sha256").update(`${family}
+  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 readFile(cssPath, "utf8").catch(() => "");
+  const cached = await readFile2(cssPath, "utf8").catch(() => "");
   if (cached.startsWith(stamp)) return { family, css: cached, files: localNames(cached) };
   const res = await fetch(
     `https://fonts.googleapis.com/css2?family=${family.replaceAll(" ", "+")}:wght@400;500;700&text=${encodeURIComponent(text2)}&display=block`,
@@ -1809,11 +2087,11 @@ function unwidow(text2, width, size2, weight = 700, face = "latin") {
 function wrapTokens(tokens, size2, width, weight, face) {
   const lines = [];
   let line2 = "";
-  for (const token of tokens) {
-    const candidate = line2 ? `${line2} ${token}` : token;
+  for (const token2 of tokens) {
+    const candidate = line2 ? `${line2} ${token2}` : token2;
     if (line2 && textWidth(candidate, size2, weight, 0, false, face) > width) {
       lines.push(line2);
-      line2 = token;
+      line2 = token2;
       continue;
     }
     line2 = candidate;
@@ -2163,6 +2441,11 @@ var annotatedFigure = (beat, ctx) => {
       `annotated-figure ${beat.id}: no figure "${p.figureId}" in source ${ctx.source.id}`
     );
   }
+  if (fig.kind === "clip") {
+    throw new Error(
+      `annotated-figure ${beat.id}: figure "${fig.id}" is a clip, and notes can only be pinned to a still \u2014 use claim-figure, which plays it, or point this beat at the clip's poster as a figure of its own`
+    );
+  }
   const crop = p.crop;
   const view = crop ? { width: fig.width * crop.w, height: fig.height * crop.h } : { width: fig.width, height: fig.height };
   const clamp3 = (v) => Math.min(1, Math.max(0, v));
@@ -2181,7 +2464,7 @@ var annotatedFigure = (beat, ctx) => {
   }
   const plan = planFigure(STAGE_W, notes, view, budget2, isPortrait(ctx.format), face);
   const stageH = plan.height;
-  const plate = {
+  const plate2 = {
     x: plan.img.x - PLATE,
     y: plan.img.y - PLATE,
     w: plan.img.w + 2 * PLATE,
@@ -2335,7 +2618,7 @@ var annotatedFigure = (beat, ctx) => {
       // Per-scene geometry: the overlay is only correct because the image box is
       // stated rather than negotiated with the layout engine.
       `#${sid}-stage{width:${STAGE_W}px;height:${n(stageH)}px;margin-top:${STAGE_GAP}px}`,
-      `#${sid}-plate{left:${n(plate.x)}px;top:${n(plate.y)}px;width:${n(plate.w)}px;height:${n(plate.h)}px}`,
+      `#${sid}-plate{left:${n(plate2.x)}px;top:${n(plate2.y)}px;width:${n(plate2.w)}px;height:${n(plate2.h)}px}`,
       // `overflow:visible` because a dot sitting on the figure's own edge puts its
       // halo outside the viewBox, and a clipped halo reads as a rendering fault.
       `#${sid}-ov{position:absolute;left:0;top:0;overflow:visible}`,
@@ -2791,6 +3074,31 @@ var CLAIM_LH = 1.5;
 var CLAIM_RULE = 6 + 32;
 var BESIDE_COL = 560;
 var MIN_PLATE = 2 * Math.round(BODY_SIZE * BODY_LH);
+function plate(fig, sid, beatId, start) {
+  const img = (src) => ({
+    html: `<img src="assets/${esc(src)}" alt="${esc(fig.caption)}" />`,
+    el: "img"
+  });
+  if (fig.kind !== "clip") return img(fig.src);
+  if (fig.href !== void 0) {
+    if (fig.poster === void 0) {
+      throw new Error(
+        `claim-figure ${beatId}: figure "${fig.id}" is a clip we hold no file for and no still of \u2014 re-ingest it so its poster is measured, or point the beat at a figure this deck has`
+      );
+    }
+    return img(fig.poster);
+  }
+  if (start === void 0) {
+    throw new Error(
+      `claim-figure ${beatId}: figure "${fig.id}" is a clip, and nobody said when this scene starts \u2014 the video is seeked on the deck's absolute clock, so \`EmitContext.start\` has to be passed`
+    );
+  }
+  const poster = fig.poster === void 0 ? "" : ` poster="assets/${esc(fig.poster)}"`;
+  return {
+    html: `<video id="${sid}-v" src="assets/${esc(fig.src)}"${poster} data-start="${start}" preload="auto" playsinline muted></video>`,
+    el: "video"
+  };
+}
 var claimFigure = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
@@ -2830,7 +3138,8 @@ var claimFigure = (beat, ctx) => {
     );
   }
   const claim = `<div class="claim" id="${sid}-c">${words(p.claim)}</div>`;
-  const figure = `<div class="figwrap" id="${sid}-f"><img src="assets/${esc(fig.src)}" alt="${esc(fig.caption)}" /></div>`;
+  const held = plate(fig, sid, beat.id, ctx.start);
+  const figure = `<div class="figwrap" id="${sid}-f">${held.html}</div>`;
   const caption = `<div class="caption" id="${sid}-cap">${esc(fig.caption)}</div>`;
   const body = tall ? `<div class="cf-stack">${claim}
 <div>${figure}
@@ -2898,12 +3207,22 @@ ${body}`,
       // Height-capped rather than width-driven: a square figure in the beside
       // layout would otherwise be ~970px tall and run off the canvas. The cap is
       // the measured remainder, not a constant — see `figMax`.
-      `.figwrap img{max-width:100%;max-height:${figMax}px;width:auto;height:auto;display:block}`,
+      //
+      // NAMED FOR THE TAG THAT IS ACTUALLY THERE rather than written for both.
+      // A rule listing `img, video` would move the bytes of every deck we have
+      // ever built to describe an element almost none of them contain, and a
+      // rule naming only `img` over a clip is a cap that silently does not
+      // apply — the video would render at its natural 1920x1080 and run off the
+      // canvas, which is invariant-5 territory that no gate reads.
+      `.figwrap ${held.el}{max-width:100%;max-height:${figMax}px;width:auto;height:auto;display:block}`,
       `.caption{font-size:${BODY_SIZE}px;line-height:${BODY_LH};color:${theme.dim};margin-top:16px}`,
       // The image, not its wrapper: the wrapper's entrance already writes
       // `transform`. 1.2% of the 550px cap is 3.3px a side, which the wrapper's
-      // 16px padding absorbs — the swell can never reach the canvas edge.
-      ambient(sid, "-f img", DRIFT)
+      // 16px padding absorbs — the swell can never reach the canvas edge. Same
+      // reason as the cap above for naming the tag: a drift rule aimed at `img`
+      // over a `<video>` is one ambient rule that animates nothing, and the
+      // slide reads as dead rather than as held.
+      ambient(sid, `-f ${held.el}`, DRIFT)
     ].join("\n")
   };
 };
@@ -3023,8 +3342,8 @@ var dataTable = (beat, ctx) => {
   p.highlight.forEach((h, i) => {
     const index = shown.findIndex((row) => row[0] === h.row);
     if (index < 0) {
-      const why2 = table.rows.some((row) => row[0] === h.row) ? `no row labelled "${h.row}" is drawn \u2014 table ${table.id} has one, but params.rows left it out` : `no row labelled "${h.row}" in table ${table.id}`;
-      throw new Error(`data-table ${beat.id}: ${why2}`);
+      const why3 = table.rows.some((row) => row[0] === h.row) ? `no row labelled "${h.row}" is drawn \u2014 table ${table.id} has one, but params.rows left it out` : `no row labelled "${h.row}" in table ${table.id}`;
+      throw new Error(`data-table ${beat.id}: ${why3}`);
     }
     const at = settled + 0.3 + i * step;
     tl.push(
@@ -3339,14 +3658,14 @@ var MORPH_SECONDS = 1.6;
 var equationMorph = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
-  const find2 = (id2) => {
+  const find3 = (id2) => {
     const eq = ctx.source.equations.find((e) => e.id === id2);
     if (!eq)
       throw new Error(`equation-morph ${beat.id}: no equation "${id2}" in source ${ctx.source.id}`);
     return eq;
   };
-  const a = find2(p.fromId);
-  const b = find2(p.toId);
+  const a = find3(p.fromId);
+  const b = find3(p.toId);
   const both = p.terms.filter((t2) => locate(a.tex, t2.tex) && locate(b.tex, t2.tex));
   if (both.length === 0) {
     throw new Error(
@@ -3556,10 +3875,10 @@ var grid = (beat, ctx) => {
       h: r.h * y0.w + (r.h - 1) * f.gap + 2 * bleed
     };
   };
-  const boxes = p.regions.map(boxOf);
+  const boxes3 = p.regions.map(boxOf);
   const lx = W - gutter + 40;
   const outside = p.regions.map((r, i) => ({ r, i })).filter(({ i }) => inGutter[i]).map(({ r, i }) => {
-    const b = boxes[i] ?? { x: fx, y: fy, w: f.cell, h: f.cell };
+    const b = boxes3[i] ?? { x: fx, y: fy, w: f.cell, h: f.cell };
     const half = lines(r) * LABEL * LH / 2;
     return { i, half, y: b.y + b.h / 2, from: { x: b.x + b.w, y: b.y + b.h / 2 } };
   }).sort((a, b) => a.y - b.y || a.i - b.i);
@@ -3577,7 +3896,7 @@ var grid = (beat, ctx) => {
   const parts = {};
   p.regions.forEach((r, i) => {
     parts[`rgn${i}`] = r.label;
-    const b = boxes[i] ?? { x: fx, y: fy, w: f.cell, h: f.cell };
+    const b = boxes3[i] ?? { x: fx, y: fy, w: f.cell, h: f.cell };
     const tone2 = theme.tones[r.tone];
     rects.push(
       `<defs><clipPath id="${id(sid, "rgnclip", i)}">${rect({ x: b.x, y: b.y, w: 0, h: b.h }, { id: id(sid, "sweep", i) })}</clipPath></defs>` + roundRect(b, corner, {
@@ -3685,7 +4004,7 @@ var grid = (beat, ctx) => {
   tl.push(...dimCells);
   p.regions.forEach((_, i) => {
     const at = first + i * step;
-    const b = boxes[i] ?? { x: 0, y: 0, w: 0, h: 0 };
+    const b = boxes3[i] ?? { x: 0, y: 0, w: 0, h: 0 };
     tl.push(
       tween(
         `#${id(sid, "rgn", i)}`,
@@ -4085,12 +4404,12 @@ function balance(label, k, face) {
   if (cur.length > 0) lines.push(cur.join(" "));
   return lines;
 }
-function centre(boxes, i) {
-  const b = boxes[i];
+function centre(boxes3, i) {
+  const b = boxes3[i];
   return b ? b.x + b.w / 2 : 0;
 }
-function loopLabelWidth(boxes, from, to, stageW) {
-  const mid = (centre(boxes, from) + centre(boxes, to)) / 2;
+function loopLabelWidth(boxes3, from, to, stageW) {
+  const mid = (centre(boxes3, from) + centre(boxes3, to)) / 2;
   return Math.max(NOTE * 6, Math.min(stageW - 2 * M - 80, 2 * Math.min(mid, stageW - mid) - 40));
 }
 function widest(lines, face) {
@@ -4123,11 +4442,11 @@ function pipeLayout(stageW, stages, loop, face = "latin") {
   let fit = solve(stages, capped, stageW, face);
   if (!fit.ok && capped < width) fit = solve(stages, width, stageW, face);
   const size2 = Math.max(MIN_FONT, Math.floor(fit.size));
-  const boxes = fit.boxes;
-  const innerW = Math.max(size2, (boxes[0]?.w ?? width) - 2 * PAD_X_EM * size2);
+  const boxes3 = fit.boxes;
+  const innerW = Math.max(size2, (boxes3[0]?.w ?? width) - 2 * PAD_X_EM * size2);
   const labelLines = stages.map((s) => wrap(s.label, size2, innerW, 600, 0, face));
   const noteLines = stages.map((s) => s.note ? wrap(s.note, NOTE, innerW, 400, 0, face) : []);
-  const boxW = boxes[0]?.w ?? width;
+  const boxW = boxes3[0]?.w ?? width;
   const need = Math.max(
     MIN_BOX_H,
     Math.min(MAX_BOX_H, boxW * BOX_ASPECT),
@@ -4137,15 +4456,15 @@ function pipeLayout(stageW, stages, loop, face = "latin") {
       return Math.ceil(2 * PAD_Y2 + label + (note2 > 0 ? NOTE_TOP + note2 * NOTE * NOTE_LH : 0));
     })
   );
-  const loopLines = loop ? wrap(loop.label, NOTE, loopLabelWidth(boxes, loop.from, loop.to, stageW), 500, 0, face) : [];
+  const loopLines = loop ? wrap(loop.label, NOTE, loopLabelWidth(boxes3, loop.from, loop.to, stageW), 500, 0, face) : [];
   const below = loop ? LOOP_TOP + LOOP_LABEL_TOP + loopLines.length * NOTE * NOTE_LH + LOOP_BOTTOM : M;
   const boxH = need;
   return {
     size: size2,
-    boxes,
+    boxes: boxes3,
     boxH,
     boxX: M,
-    boxW: boxes[0]?.w ?? width,
+    boxW: boxes3[0]?.w ?? width,
     vertical: false,
     innerW,
     labelLines,
@@ -4473,6 +4792,11 @@ var splitCompare = (beat, ctx) => {
     if (fig.width <= 0 || fig.height <= 0) {
       throw new Error(`split-compare ${beat.id}: figure "${fig.id}" has no usable dimensions`);
     }
+    if (fig.kind === "clip") {
+      throw new Error(
+        `split-compare ${beat.id}: the ${NAME[i]} figure "${fig.id}" is a clip, and a side draws a still <image> \u2014 use claim-figure, which plays it, or point this side at the clip's poster as a figure of its own`
+      );
+    }
     return fig;
   });
   sides.forEach((side, i) => {
@@ -4771,9 +5095,9 @@ var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
 function stackLayout(p, format, face = "latin") {
   const stacked = solve2(p, format, false, face);
   if (stacked.fits || !p.layers.some((l) => l.note)) return stacked;
-  const inline = solve2(p, format, true, face);
-  if (inline.fits) return inline;
-  return inline.wide && inline.blockH < stacked.blockH ? inline : stacked;
+  const inline2 = solve2(p, format, true, face);
+  if (inline2.fits) return inline2;
+  return inline2.wide && inline2.blockH < stacked.blockH ? inline2 : stacked;
 }
 function labelWeight(i, count) {
   return i === count - 1 ? 700 : 600;
@@ -4782,7 +5106,7 @@ function floorFor(p, format) {
   if (!p.tilt) return MIN_FONT;
   return tiltedFloor({ ...DEFAULT_POSE, rotateX: p.tilt }, contentH(format), MIN_FONT);
 }
-function solve2(p, format, inline, face) {
+function solve2(p, format, inline2, face) {
   const width = contentW(format);
   const boxH = contentH(format);
   const floor = floorFor(p, format);
@@ -4791,15 +5115,15 @@ function solve2(p, format, inline, face) {
   const riseMax = RISE_MAX[k];
   const syMax = SY_MAX[k];
   const tMax = T_MAX[k];
-  const noteW = (l) => inline && l.note !== void 0 ? textWidth(l.note, floor, 400, 0, false, face) + 28 : 0;
+  const noteW = (l) => inline2 && l.note !== void 0 ? textWidth(l.note, floor, 400, 0, false, face) + 28 : 0;
   const want = Math.max(
     ...p.layers.map(
       (l, i) => textWidth(l.label, LABEL_SIZE2, labelWeight(i, count), 0, false, face) + noteW(l)
     )
   );
-  const colCap = inline ? width * 0.56 : width * 0.5;
+  const colCap = inline2 ? width * 0.56 : width * 0.5;
   const colW = clamp(Math.ceil(want) + 12, Math.min(520, width * 0.34), colCap);
-  const wide = !inline || Math.ceil(want) + 12 <= colCap;
+  const wide = !inline2 || Math.ceil(want) + 12 <= colCap;
   const labelX = width - colW;
   const labelRoom = Math.min(
     ...p.layers.map(
@@ -4814,14 +5138,14 @@ function solve2(p, format, inline, face) {
       label: wrap(l.label, labelSize, labelMaxW, labelWeight(i, count), 0, face),
       // Inline notes stay on one line by contract — the schema calls a note "one
       // short line" — and wrapping one would put its second line under the label.
-      note: l.note === void 0 ? [] : inline ? [l.note] : wrap(l.note, floor, colW, 400, 0, face),
+      note: l.note === void 0 ? [] : inline2 ? [l.note] : wrap(l.note, floor, colW, 400, 0, face),
       noteW: nw,
       labelMaxW
     };
   });
   const blockH = Math.max(
     ...lines.map(
-      (l) => inline ? Math.max(l.label.length * labelSize, l.note.length * floor) * 1.16 : l.label.length * labelSize * 1.16 + (l.note.length > 0 ? 6 + l.note.length * floor * 1.16 : 0)
+      (l) => inline2 ? Math.max(l.label.length * labelSize, l.note.length * floor) * 1.16 : l.label.length * labelSize * 1.16 + (l.note.length > 0 ? 6 + l.note.length * floor * 1.16 : 0)
     )
   );
   const pad = Math.max(EDGE2, blockH / 2);
@@ -4843,7 +5167,7 @@ function solve2(p, format, inline, face) {
     fits: room >= blockH + 10 && height <= free && wide,
     floor,
     wide,
-    inline,
+    inline: inline2,
     width,
     height,
     avail,
@@ -5247,7 +5571,8 @@ function emitDeck(storyboard, source, format, runtimeJs, opts = {}) {
       format,
       laid.slides,
       runtimeJs,
-      narrationIsland(opts.narration, laid.spoken)
+      narrationIsland(opts.narration, laid.spoken),
+      videoIsland(laid.embeds)
     )
   };
 }
@@ -5258,17 +5583,20 @@ function planCut(storyboard, source, format, opts = {}) {
   const seconds = {};
   const undrawable = /* @__PURE__ */ new Set();
   floor.forEach((beat, i) => {
-    const segments = opts.narration?.beats[beat.id];
+    const segments2 = opts.narration?.beats[beat.id];
     let scene;
     try {
-      ({ scene } = stageScene(emitScene(beat, { source, format, theme, sid: `s${i + 1}` }), speed));
+      ({ scene } = stageScene(
+        emitScene(beat, { source, format, theme, sid: `s${i + 1}`, start: 0 }),
+        speed
+      ));
     } catch (err) {
       if (!opts.onBeatError) throw err;
       opts.onBeatError(beat.id, err instanceof Error ? err : new Error(String(err)));
       undrawable.add(beat.id);
       return;
     }
-    seconds[beat.id] = beatSeconds(beat.seconds * speed, scene, segments);
+    seconds[beat.id] = beatSeconds(beat.seconds * speed, scene, segments2);
   });
   if (floor.length > 0 && undrawable.size === floor.length) {
     throw new Error(`every one of ${floor.length} beat(s) failed to draw \u2014 there is no deck`);
@@ -5301,31 +5629,29 @@ function layout(storyboard, source, format, opts = {}) {
   const scenes = [];
   const slides = [];
   const spoken = {};
+  const embeds = {};
   const entered = enteredParts(beats);
+  let at = 0;
   const cuts = beats.map((beat, i) => {
     const sid = `s${i + 1}`;
-    const ctx = { source, format, theme, sid };
-    const segments = opts.narration?.beats[beat.id];
+    const ctx = { source, format, theme, sid, start: rnd(at) };
+    const segments2 = opts.narration?.beats[beat.id];
     const { scene } = stageScene(emitScene(beat, ctx), speed);
-    const seconds = beatSeconds(beat.seconds * speed, scene, segments);
+    const seconds = beatSeconds(beat.seconds * speed, scene, segments2);
     const inside = entered[i];
     const dive = inside ? { t0: rnd(seconds), dur: rnd(MOVE_SECONDS * speed), fade: rnd(FADE_SECONDS * speed) } : void 0;
-    return {
-      beat,
-      sid,
-      scene,
-      segments,
-      inside,
-      dive,
-      duration: dive ? seconds + diveTail(dive) : seconds
-    };
+    const duration = dive ? seconds + diveTail(dive) : seconds;
+    const start = at;
+    at += duration;
+    return { beat, sid, scene, segments: segments2, inside, dive, duration, start };
   });
-  let start = 0;
   let builds = false;
   const plugins = /* @__PURE__ */ new Set();
   cuts.forEach((cut2, i) => {
-    const { beat, sid, dive, inside, duration } = cut2;
+    const { beat, sid, dive, inside, duration, start } = cut2;
     if (cut2.segments?.length) spoken[sid] = cut2.segments;
+    const embed = playerEmbed(beat, source);
+    if (embed) embeds[sid] = embed;
     const next = cuts[i + 1];
     const over = next ? rnd(Math.min(HANDOFF_SECONDS * speed, next.duration)) : 0;
     let scene = cut2.scene;
@@ -5355,7 +5681,6 @@ function layout(storyboard, source, format, opts = {}) {
       notes: beat.narration ?? beat.intent,
       holds: scene.holds
     });
-    start += duration;
   });
   return {
     family,
@@ -5367,7 +5692,11 @@ function layout(storyboard, source, format, opts = {}) {
     scenes,
     slides,
     spoken,
-    total: start,
+    embeds,
+    // The clock after the last scene: the sum the map above finished with, which
+    // is the number the second pass used to arrive at by re-adding the same
+    // durations in the same order.
+    total: at,
     cut,
     builds,
     plugins
@@ -5418,23 +5747,23 @@ function openSeconds(scene) {
   const first = scene.holds.filter((h) => Number.isFinite(h) && h > 0).sort((a, b) => a - b)[0];
   return rnd(first ?? 0);
 }
-function beatSeconds(authored, scene, segments) {
-  if (!segments?.length) return authored;
+function beatSeconds(authored, scene, segments2) {
+  if (!segments2?.length) return authored;
   const lastHold = scene.holds.reduce((a, b) => Math.max(a, b), 0);
   const usable = [...new Set(scene.holds.filter((h) => Number.isFinite(h) && h > 0))].sort(
     (a, b) => a - b
   );
-  const ends = speechPlan(openSeconds(scene), usable, segments).end;
+  const ends = speechPlan(openSeconds(scene), usable, segments2).end;
   return Math.max(authored, lastHold + SETTLE_SECONDS, ends + SETTLE_SECONDS);
 }
 function stageScene(scene, speed) {
   const paced = pace(scene, speed);
   return { scene: paced, open: openSeconds(paced) };
 }
-function speechPlan(open, holds, segments) {
+function speechPlan(open, holds, segments2) {
   const starts = [];
   let at = open;
-  for (const [i, segment] of segments.entries()) {
+  for (const [i, segment] of segments2.entries()) {
     const hold = holds[Math.min(segment.stop, holds.length - 1)] ?? 0;
     if (i > 0) at = Math.max(at, hold);
     starts.push(at);
@@ -5529,9 +5858,9 @@ function narrationIsland(narration, scenes) {
     voice: narration.voice,
     dir: narration.dir,
     scenes: Object.fromEntries(
-      Object.entries(scenes).map(([sid, segments]) => [
+      Object.entries(scenes).map(([sid, segments2]) => [
         sid,
-        segments.map((s) => ({ stop: s.stop, audio: s.audio, seconds: s.seconds, cues: s.cues }))
+        segments2.map((s) => ({ stop: s.stop, audio: s.audio, seconds: s.seconds, cues: s.cues }))
       ])
     )
   };
@@ -5541,7 +5870,22 @@ function narrationIsland(narration, scenes) {
 ${json}
     </script>`;
 }
-function emitDeckPage(storyboard, format, slides, runtimeJs, narration) {
+function playerEmbed(beat, source) {
+  if (beat.archetype !== "claim-figure") return void 0;
+  const fig = source.figures.find((f) => f.id === beat.params.figureId);
+  if (fig?.kind !== "clip" || fig.href === void 0) return void 0;
+  const url = embedUrl(fig.href);
+  return url === void 0 ? void 0 : { url, title: fig.caption };
+}
+function videoIsland(clips) {
+  if (Object.keys(clips).length === 0) return "";
+  const json = JSON.stringify({ scenes: clips }, null, 2).replace(/</g, "\\u003c");
+  return `
+    <script type="application/decksmith-video+json">
+${json}
+    </script>`;
+}
+function emitDeckPage(storyboard, format, slides, runtimeJs, narration, video) {
   return `<!doctype html>
 <html lang="${esc(storyboard.lang)}">
   <head>
@@ -5560,7 +5904,7 @@ function emitDeckPage(storyboard, format, slides, runtimeJs, narration) {
       width="${format.width}"
       height="${format.height}"
     ></hyperframes-player>
-${emitIsland(slides)}${narration}
+${emitIsland(slides)}${narration}${video}
     <script>
 ${closeSafe(runtimeJs)}
     </script>
@@ -5712,7 +6056,7 @@ function readFragments(html) {
   return out;
 }
 function holdsFor(beat, source, format, theme, sid, speed) {
-  const ctx = { source, format, theme, sid };
+  const ctx = { source, format, theme, sid, start: 0 };
   const { scene, open } = stageScene(emitScene(beat, ctx), speed);
   return {
     holds: [...new Set(scene.holds.filter((h) => Number.isFinite(h) && h > 0))].sort(
@@ -5736,15 +6080,15 @@ function assertHoldsAgree(scenes, fragments) {
 function place(scenes, spoken) {
   const out = [];
   for (const scene of scenes) {
-    const segments = [...spoken[scene.id] ?? []].sort((a, b) => a.stop - b.stop);
-    if (segments.length === 0) continue;
+    const segments2 = [...spoken[scene.id] ?? []].sort((a, b) => a.stop - b.stop);
+    if (segments2.length === 0) continue;
     if (scene.holds.length === 0) {
       throw new Error(
         `${scene.id}: narrated but has no hold to speak at. Re-run \`narrate\` for this format.`
       );
     }
-    const { starts } = speechPlan(scene.open, scene.holds, segments);
-    for (const [i, segment] of segments.entries()) {
+    const { starts } = speechPlan(scene.open, scene.holds, segments2);
+    for (const [i, segment] of segments2.entries()) {
       const index = Math.min(segment.stop, scene.holds.length - 1);
       out.push({
         id: `${scene.id}.${segment.stop}`,
@@ -5760,9 +6104,9 @@ function place(scenes, spoken) {
   }
   return out;
 }
-function assertFits(scenes, segments) {
+function assertFits(scenes, segments2) {
   for (const scene of scenes) {
-    const mine = segments.filter((s) => s.scene === scene.id);
+    const mine = segments2.filter((s) => s.scene === scene.id);
     if (mine.length === 0) continue;
     const spoken = mine.reduce((sum, s) => sum + s.duration, 0);
     const need = scene.open + spoken;
@@ -5806,8 +6150,8 @@ function planTiming(input) {
     const staging = holdsFor(beat, source, format, theme, scene.id, speed);
     scene.holds = staging.holds;
     scene.open = staging.open;
-    const segments2 = narration?.beats[beat.id];
-    if (segments2?.length) spoken[scene.id] = segments2;
+    const segments3 = narration?.beats[beat.id];
+    if (segments3?.length) spoken[scene.id] = segments3;
   });
   const fragments = readFragments(composition);
   if (fragments) {
@@ -5816,18 +6160,18 @@ function planTiming(input) {
       fragments
     );
   }
-  const segments = place(scenes, spoken);
-  assertFits(scenes, segments);
+  const segments2 = place(scenes, spoken);
+  assertFits(scenes, segments2);
   return {
     version: 1,
     width: format.width,
     height: format.height,
     duration: readDuration(composition),
     lang: storyboard.lang,
-    audioDir: segments.length > 0 ? narration?.dir ?? "" : "",
-    voice: segments.length > 0 ? narration?.voice ?? "" : "",
+    audioDir: segments2.length > 0 ? narration?.dir ?? "" : "",
+    voice: segments2.length > 0 ? narration?.voice ?? "" : "",
     scenes,
-    segments
+    segments: segments2
   };
 }
 function framePlan(timing, fps) {
@@ -5839,12 +6183,12 @@ function framePlan(timing, fps) {
   for (const scene of timing.scenes) {
     const first = f(scene.start);
     const last = f(scene.start + scene.duration);
-    const segments = timing.segments.filter((s) => s.scene === scene.id).sort((a, b) => a.hold - b.hold || a.stop - b.stop);
-    if (segments.length === 0) {
+    const segments2 = timing.segments.filter((s) => s.scene === scene.id).sort((a, b) => a.hold - b.hold || a.stop - b.stop);
+    if (segments2.length === 0) {
       pieces.push({ from: first, motion: last - first, freeze: 0 });
       continue;
     }
-    const tail3 = segments[segments.length - 1];
+    const tail3 = segments2[segments2.length - 1];
     const silent = f(tail3.start + tail3.duration);
     if (silent > last) {
       throw new Error(
@@ -5852,7 +6196,7 @@ function framePlan(timing, fps) {
       );
     }
     pieces.push({ from: first, motion: last - first, freeze: 0 });
-    for (const segment of segments) {
+    for (const segment of segments2) {
       const at = f(segment.start);
       audio.push({
         id: segment.id,
@@ -5925,7 +6269,7 @@ function round5(n3) {
 }
 
 // src/source/markdown.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
 import remarkParse from "remark-parse";
@@ -5977,6 +6321,9 @@ function parseMarkdown(md, opts = {}) {
       for (const img of images) {
         const figure = {
           id: `fig${figures.length + 1}`,
+          // Markdown carries no video: an image node is an image. A clip only
+          // ever enters through `harvest`, which sets this itself.
+          kind: "image",
           src: img.url,
           caption: caption ?? img.alt ?? "",
           // 1x1 until assets.ts reads the actual bytes. The schema has no "unknown",
@@ -6012,7 +6359,7 @@ function parseMarkdown(md, opts = {}) {
     if (mention) p.figure.mention = mention;
   }
   return sourceSchema.parse({
-    id: opts.id ?? createHash2("sha256").update(md).digest("hex").slice(0, 12),
+    id: opts.id ?? createHash3("sha256").update(md).digest("hex").slice(0, 12),
     title: title2 || "Untitled",
     lang: opts.lang ?? sniffLang(md),
     sections,
@@ -6021,10 +6368,14 @@ function parseMarkdown(md, opts = {}) {
     tables
   });
 }
+var SCRIPT_SHARE = 0.02;
 function sniffLang(md) {
-  if (/[가-힣]/.test(md)) return "ko";
-  if (/[぀-ヿ]/.test(md)) return "ja";
-  if (/[一-鿿]/.test(md)) return "zh";
+  const total = md.replace(/\s+/g, "").length;
+  if (total === 0) return "en";
+  const share2 = (re) => (md.match(re)?.length ?? 0) / total;
+  if (share2(/[가-힣]/g) >= SCRIPT_SHARE) return "ko";
+  if (share2(/[぀-ヿ]/g) >= SCRIPT_SHARE) return "ja";
+  if (share2(/[一-鿿]/g) >= SCRIPT_SHARE) return "zh";
   return "en";
 }
 function onlyImages(kids) {
@@ -6045,7 +6396,11 @@ function mentionOf(caption, prose, at, opened) {
     const found = before ?? prose.find((p) => p.at > at && name.test(p.text));
     if (found) return found.text;
   }
-  return prose.filter((p) => p.at > opened && p.at < at).at(-1)?.text;
+  const near = prose.filter((p) => p.at > opened && p.at < at).at(-1)?.text;
+  return near !== void 0 && isSentence(near) ? near : void 0;
+}
+function isSentence(text2) {
+  return (text2.match(/[\p{L}\p{N}]+/gu) ?? []).length >= 3;
 }
 function figureName(caption) {
   const match = /^\s*(fig(?:ure)?\.?|그림|図|图)\s*([0-9]+)/i.exec(caption);
@@ -6105,76 +6460,2119 @@ function textOf(node) {
   }
 }
 
-// src/source/assets.ts
-import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { extname, join as join2 } from "node:path";
-async function fetchFigures(source, dir) {
-  await mkdir2(dir, { recursive: true });
-  const figures = [];
-  for (const figure of source.figures) {
-    const name = assetName(figure.id, figure.src);
-    const bytes = await cache(join2(dir, name), figure.src);
-    figures.push({ ...figure, src: name, ...imageSize(bytes) });
-  }
-  return sourceSchema.parse({ ...source, figures });
-}
-function assetName(id2, src) {
-  const ext = extname(new URL(src, "file:///").pathname).toLowerCase().replace(/[^.a-z0-9]/g, "");
-  return `${id2}-${createHash3("sha256").update(src).digest("hex").slice(0, 8)}${ext || ".img"}`;
-}
-async function cache(path2, src) {
-  const hit = await readFile2(path2).catch(() => null);
-  if (hit) return hit;
-  let bytes;
-  if (/^https?:/i.test(src)) {
-    const res = await fetch(src);
-    if (!res.ok) throw new Error(`${src}: HTTP ${res.status}`);
-    bytes = Buffer.from(await res.arrayBuffer());
-  } else {
-    bytes = await readFile2(src);
+// src/source/harvest.ts
+import { createHash as createHash5 } from "node:crypto";
+import { copyFile, mkdir as mkdir4, rm as rm2, stat, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename2, join as join4, resolve } from "node:path";
+
+// src/net/fetch.ts
+import { lookup as resolveHost } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { brotliDecompressSync, gunzipSync } from "node:zlib";
+
+// src/version.ts
+import { createRequire } from "node:module";
+var VERSION = createRequire(import.meta.url)("../package.json").version;
+
+// src/net/fetch.ts
+var BLOCKED_V4 = [
+  // "This network". Already in the original list as /^0\./, which is 0.0.0.0/8.
+  { re: /^0\./, why: "the unspecified network (0.0.0.0/8)" },
+  { re: /^10\./, why: "a private address (10.0.0.0/8)" },
+  // NEW: carrier-grade NAT. A mobile or datacentre network hands these out, and
+  // on a host that has one, the whole /10 is the neighbourhood.
+  {
+    re: /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./,
+    why: "carrier-grade NAT space (100.64.0.0/10)"
+  },
+  { re: /^127\./, why: "loopback (127.0.0.0/8)" },
+  { re: /^169\.254\./, why: "link-local, where the cloud metadata service lives (169.254.0.0/16)" },
+  { re: /^172\.(1[6-9]|2\d|3[01])\./, why: "a private address (172.16.0.0/12)" },
+  // NEW: IETF protocol assignments — 192.0.0.8, the NAT64 well-known prefix and
+  // friends. Not routable on the public internet, so a URL pointing here is
+  // pointing at something local.
+  { re: /^192\.0\.0\./, why: "IETF protocol assignment space (192.0.0.0/24)" },
+  { re: /^192\.168\./, why: "a private address (192.168.0.0/16)" },
+  // NEW: benchmarking. Reserved for test equipment, and some networks route it
+  // internally precisely because it will never collide with anything real.
+  { re: /^198\.1[89]\./, why: "benchmarking space (198.18.0.0/15)" }
+];
+var USER_AGENT = `DeckSmith/${VERSION} (+https://github.com/ca1773130n/DeckSmith)`;
+function isBlockedAddress(ip) {
+  const bare = ip.trim().replace(/^\[|\]$/g, "").toLowerCase();
+  const kind = isIP(bare);
+  if (kind === 0) return `not an IP address (${ip})`;
+  if (kind === 4) {
+    for (const { re, why: why3 } of BLOCKED_V4) if (re.test(bare)) return why3;
+    return null;
   }
-  await writeFile2(path2, bytes);
-  return bytes;
-}
-function imageSize(b) {
-  if (b.length >= 24 && b.readUInt32BE(0) === 2303741511)
-    return { width: b.readUInt32BE(16), height: b.readUInt32BE(20) };
-  if (b.length >= 10 && b.toString("latin1", 0, 4) === "GIF8")
-    return { width: b.readUInt16LE(6), height: b.readUInt16LE(8) };
-  if (b.length >= 4 && b.readUInt16BE(0) === 65496) return jpegSize(b);
-  throw new Error("unrecognised image header (expected PNG, JPEG or GIF)");
+  const groups = expandV6(bare);
+  if (groups === null) return `not an IP address (${ip})`;
+  if (groups.every((n3) => n3 === 0)) return "the unspecified address (::)";
+  if (groups.slice(0, 7).every((n3) => n3 === 0) && groups[7] === 1) return "IPv6 loopback (::1)";
+  const embedded = groups.slice(0, 5).every((n3) => n3 === 0) && (groups[5] === 65535 || groups[5] === 0);
+  if (embedded) {
+    const hi = groups[6] ?? 0;
+    const lo = groups[7] ?? 0;
+    return isBlockedAddress(`${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`);
+  }
+  const top = groups[0] ?? 0;
+  if ((top & 65472) === 65152) return "IPv6 link-local (fe80::/10)";
+  if ((top & 65024) === 64512) return "IPv6 unique-local (fc00::/7)";
+  return null;
 }
-function jpegSize(b) {
-  let i = 2;
-  while (i + 9 < b.length) {
-    if (b[i] !== 255) {
-      i++;
-      continue;
+function expandV6(v6) {
+  let text2 = v6;
+  const quad = /(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(text2);
+  if (quad?.[1]) {
+    const [a = 0, b = 0, c = 0, d = 0] = quad[1].split(".").map(Number);
+    const head = text2.slice(0, text2.length - quad[1].length);
+    text2 = `${head}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`;
+  }
+  const halves = text2.split("::");
+  if (halves.length > 2) return null;
+  const left = halves[0] ? halves[0].split(":") : [];
+  const right = halves.length === 2 ? halves[1] ? halves[1].split(":") : [] : null;
+  const fill = 8 - left.length - (right?.length ?? 0);
+  if (right !== null && fill < 0) return null;
+  const parts = right === null ? left : [...left, ...new Array(fill).fill("0"), ...right];
+  if (parts.length !== 8) return null;
+  const groups = parts.map((p) => Number.parseInt(p, 16));
+  return groups.every((n3) => Number.isInteger(n3) && n3 >= 0 && n3 <= 65535) ? groups : null;
+}
+function isLoopback(ip) {
+  const bare = ip.trim().replace(/^\[|\]$/g, "").toLowerCase();
+  return /^127\./.test(bare) || bare === "::1" || /^::ffff:127\./.test(bare);
+}
+var MAX_REDIRECTS = 5;
+var WEB_PORTS = /* @__PURE__ */ new Set([80, 443]);
+var REDIRECTS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var CREDENTIALS = ["authorization", "cookie"];
+async function fetchGuarded(url, opts) {
+  const signal = AbortSignal.timeout(opts.timeoutMs);
+  let target;
+  try {
+    target = new URL(url);
+  } catch {
+    throw new Error(`refusing ${url}: not a URL. Give an absolute http:// or https:// URL.`);
+  }
+  let headers = lowercased(opts.headers);
+  for (let hop = 0; ; hop++) {
+    if (hop > MAX_REDIRECTS) {
+      throw new Error(
+        `refusing ${url}: more than ${MAX_REDIRECTS} redirects, last to ${target.href}. Link the final URL directly.`
+      );
     }
-    const marker = b[i + 1];
-    if (marker === void 0) break;
-    if (marker === 255) {
-      i++;
+    const res = await send(url, target, headers, signal, opts);
+    const status = res.statusCode ?? 0;
+    if (REDIRECTS.has(status)) {
+      const location = res.headers.location;
+      res.destroy();
+      if (location === void 0) {
+        throw new Error(`refusing ${url}: HTTP ${status} from ${target.href} with no Location.`);
+      }
+      let next;
+      try {
+        next = new URL(location, target);
+      } catch {
+        throw new Error(
+          `refusing ${url}: HTTP ${status} to an unparseable Location (${location}).`
+        );
+      }
+      const sameOrigin = next.protocol === target.protocol && next.hostname === target.hostname && next.port === target.port;
+      if (!sameOrigin) headers = withoutCredentials(headers);
+      target = next;
       continue;
     }
-    if (marker === 1 || marker >= 208 && marker <= 217) {
-      i += 2;
-      continue;
+    if (status < 200 || status >= 300) {
+      res.destroy();
+      throw new Error(`${target.href}: HTTP ${status}`);
     }
-    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204)
-      return { width: b.readUInt16BE(i + 7), height: b.readUInt16BE(i + 5) };
-    i += 2 + b.readUInt16BE(i + 2);
-  }
-  throw new Error("JPEG has no SOF segment");
+    const contentType = (res.headers["content-type"] ?? "").trim();
+    const media = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+    if (opts.accept && media.match(opts.accept) === null) {
+      res.destroy();
+      throw new Error(
+        `refusing ${url}: ${target.href} served ${media || "no Content-Type"}, which does not match ${opts.accept}. Link the file itself, not a page about it.`
+      );
+    }
+    const raw2 = await readCapped(res, opts.maxBytes, url, signal, opts.timeoutMs);
+    const bytes = decode(raw2, res.headers["content-encoding"], opts.maxBytes, url);
+    return { bytes, contentType, url: target.href };
+  }
+}
+async function send(url, target, headers, signal, opts) {
+  const secure = target.protocol === "https:";
+  if (!secure && target.protocol !== "http:") {
+    throw new Error(
+      `refusing ${url}: ${target.protocol}// is not http or https (${target.href}). Only web URLs are followed.`
+    );
+  }
+  const port = Number(target.port || (secure ? 443 : 80));
+  if (!WEB_PORTS.has(port) && opts.allowLoopback !== true) {
+    throw new Error(
+      `refusing ${url}: port ${port} on ${target.hostname} \u2014 only 80 and 443 are fetched. A URL naming another port is naming a service, not a page.`
+    );
+  }
+  const host = target.hostname.replace(/^\[|\]$/g, "");
+  let addresses;
+  try {
+    addresses = await Promise.race([resolveHost(host, { all: true }), rejectsOnAbort(signal)]);
+  } catch {
+    if (signal.aborted) throw timedOut(url, opts.timeoutMs);
+    throw new Error(`refusing ${url}: ${host} does not resolve.`);
+  }
+  const pinned = addresses[0];
+  if (pinned === void 0) throw new Error(`refusing ${url}: ${host} does not resolve.`);
+  for (const { address } of addresses) {
+    const why3 = isBlockedAddress(address);
+    if (why3 !== null && !(opts.allowLoopback === true && isLoopback(address))) {
+      throw new Error(
+        `refusing ${url}: ${host} resolves to ${address}, which is ${why3}. Host the file somewhere this server can reach from the public internet.`
+      );
+    }
+  }
+  const options = {
+    hostname: host,
+    port,
+    path: `${target.pathname}${target.search}`,
+    method: "GET",
+    // IDENTIFY OURSELVES, AND ACCEPT HTML.
+    //
+    // Measured against the first real page this was ever pointed at: Wikipedia
+    // answers a request with no `user-agent` with a bare 403, and so do a great
+    // many sites behind a CDN. A fetcher that will not say who it is looks
+    // exactly like a scraper worth blocking, and the failure arrives as an
+    // HTTP status with nothing in it to explain itself. Both headers are
+    // DEFAULTS rather than overrides — a caller that sets either wins, because
+    // the spread below them is the caller's.
+    headers: {
+      "user-agent": USER_AGENT,
+      accept: "text/html,application/xhtml+xml,image/*;q=0.8,*/*;q=0.5",
+      ...headers,
+      "accept-encoding": "gzip, br"
+    },
+    signal,
+    // THE PIN. Without this line every check above is advisory: `dns.lookup`
+    // would run a second time inside the connect and could answer differently.
+    lookup: pin(pinned.address, pinned.family),
+    // No connection pool. This is a one-shot against a stranger's host, and a
+    // pooled socket outlives the call that validated it — nothing should be able
+    // to inherit a connection this module opened.
+    agent: false,
+    // Say out loud which name the certificate has to match. Node derives this
+    // from `hostname` today, but the pin means the socket is opened to a bare
+    // address, and a future refactor that stops setting `hostname` would turn
+    // verification off silently rather than fail.
+    ...secure && isIP(host) === 0 ? { servername: host } : {}
+  };
+  try {
+    return await new Promise((resolve6, reject) => {
+      const req = (secure ? httpsRequest : httpRequest)(options, resolve6);
+      req.on("error", reject);
+      req.end();
+    });
+  } catch (err) {
+    if (signal.aborted) throw timedOut(url, opts.timeoutMs);
+    throw new Error(`refusing ${url}: ${target.href} could not be reached (${message(err)}).`);
+  }
+}
+function pin(address, family) {
+  return (_hostname, options, callback) => {
+    if (options.all) callback(null, [{ address, family }]);
+    else callback(null, address, family);
+  };
+}
+async function readCapped(res, maxBytes, url, signal, timeoutMs) {
+  const chunks = [];
+  let total = 0;
+  let oversize = false;
+  try {
+    for await (const chunk of res) {
+      total += chunk.length;
+      if (total > maxBytes) {
+        oversize = true;
+        res.destroy();
+        break;
+      }
+      chunks.push(chunk);
+    }
+  } catch (err) {
+    if (signal.aborted) throw timedOut(url, timeoutMs);
+    throw new Error(`refusing ${url}: the body stopped arriving (${message(err)}).`);
+  }
+  if (oversize) {
+    throw new Error(
+      `refusing ${url}: body is larger than ${maxBytes} bytes. Link a smaller file, or raise maxBytes if this one is expected.`
+    );
+  }
+  return Buffer.concat(chunks);
+}
+function decode(raw2, header, maxBytes, url) {
+  const encoding = (header ?? "").trim().toLowerCase();
+  if (encoding === "" || encoding === "identity") return raw2;
+  try {
+    if (encoding === "gzip" || encoding === "x-gzip") {
+      return gunzipSync(raw2, { maxOutputLength: maxBytes });
+    }
+    if (encoding === "br") return brotliDecompressSync(raw2, { maxOutputLength: maxBytes });
+  } catch (err) {
+    throw new Error(
+      `refusing ${url}: ${encoding} body does not decompress within ${maxBytes} bytes (${message(err)}). Serve it uncompressed, or raise maxBytes.`
+    );
+  }
+  throw new Error(
+    `refusing ${url}: Content-Encoding "${encoding}" was never offered \u2014 this request asked for gzip or br. Serve one of those, or no encoding.`
+  );
+}
+function lowercased(headers) {
+  const out = {};
+  for (const [name, value] of Object.entries(headers ?? {})) out[name.toLowerCase()] = value;
+  return out;
+}
+function withoutCredentials(headers) {
+  const out = { ...headers };
+  for (const name of CREDENTIALS) delete out[name];
+  return out;
+}
+function rejectsOnAbort(signal) {
+  return new Promise((_, reject) => {
+    if (signal.aborted) reject(signal.reason);
+    else signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+  });
+}
+function timedOut(url, timeoutMs) {
+  return new Error(
+    `refusing ${url}: nothing completed within ${timeoutMs}ms. Raise timeoutMs, or use a URL that answers faster.`
+  );
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/render/capture.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir } from "node:os";
+import { join as join2 } 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;
+  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;
+  throw new Error(
+    `no Chrome to ${need} \u2014 run \`npx puppeteer browsers install chrome\`, or set DECKSMITH_CHROME to a Chrome binary.`
+  );
+}
+function runtimePath() {
+  return createRequire2(import.meta.url).resolve("hyperframes/dist/hyperframe.runtime.iife.js");
+}
+function renderSeek(t2) {
+  const player = window.__player;
+  player.renderSeek(t2, { suppressEvents: true });
+}
+async function openDeck(dir, opts = {}) {
+  const index = join2(dir, "index.html");
+  const html = await readFile3(index, "utf8").catch(() => null);
+  if (html === null) throw new Error(`no index.html in ${dir}`);
+  const width = Number(/data-width="(\d+)"/.exec(html)?.[1] ?? 0);
+  const height = Number(/data-height="(\d+)"/.exec(html)?.[1] ?? 0);
+  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 browser = await puppeteer.launch({
+    executablePath: await chromePath(),
+    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"]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.evaluateOnNewDocument("self.__name = self.__name || ((fn) => fn);");
+    await page.setViewport({ width, height, deviceScaleFactor: 1 });
+    await page.goto(pathToFileURL(index).href, { waitUntil: "load", timeout });
+    await page.addScriptTag({ path: runtimePath() });
+    await page.waitForFunction(
+      // The composition registers a paused timeline per scene and a spanning
+      // `main` that carries no motion, so seeking `main` directly moves nothing.
+      // Only the runtime knows the per-scene offsets; wait for it.
+      "typeof window.__player?.renderSeek === 'function'",
+      { timeout }
+    );
+    await page.evaluate(() => document.fonts.ready);
+    const cdp = await page.createCDPSession();
+    return {
+      width,
+      height,
+      page,
+      seek: (t2) => page.evaluate(renderSeek, t2),
+      shoot: async () => {
+        const shot = await cdp.send("Page.captureScreenshot", {
+          format: "png",
+          fromSurface: true,
+          captureBeyondViewport: false,
+          clip: { x: 0, y: 0, width, height, scale: 1 }
+        });
+        return Buffer.from(shot.data, "base64");
+      },
+      close: () => browser.close()
+    };
+  } catch (err) {
+    await browser.close().catch(() => {
+    });
+    throw err;
+  }
+}
+
+// src/source/assets.ts
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir3, readdir, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { extname as extname2, join as join3 } from "node:path";
+import { z as z2 } from "zod";
+async function fetchFigures(source, dir, warnings) {
+  const drops = warnings ?? [];
+  await mkdir3(dir, { recursive: true });
+  const cached = await readdir(dir).catch(() => []);
+  const figures = [];
+  for (const figure of source.figures) {
+    if (figure.kind === "clip") {
+      figures.push(figure);
+      continue;
+    }
+    try {
+      figures.push(figureSchema.parse(await localize(figure, dir, cached)));
+    } catch (err) {
+      drops.push(`figure ${figure.id} was left out: ${reason(err)}`);
+    }
+  }
+  if (!warnings) for (const drop of drops) console.warn(`decksmith: ${drop}`);
+  const parsed = sourceSchema.safeParse({ ...source, figures });
+  if (!parsed.success) {
+    throw new Error(
+      `source "${source.id}" no longer parses after localising its figures: ${reason(parsed.error)}. Every figure kept was checked on its own, so the fault is in the document around them, not in an image.`
+    );
+  }
+  return parsed.data;
+}
+async function localize(figure, dir, cached) {
+  const stem = assetStem(figure.id, figure.src);
+  const hit = cached.find((name) => name.startsWith(`${stem}.`));
+  const bytes = hit ? await readFile4(join3(dir, hit)) : await load(figure.src);
+  const size2 = imageSize(bytes);
+  if (hit) return { ...figure, src: hit, ...size2 };
+  const src = `${stem}${assetExt(bytes, figure.src)}`;
+  await writeFile3(join3(dir, src), bytes);
+  cached.push(src);
+  return { ...figure, src, ...size2 };
+}
+function assetStem(id2, src) {
+  const readable = id2.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+/, "") || "figure";
+  return `${readable}-${createHash4("sha256").update(src).digest("hex").slice(0, 8)}`;
+}
+var EXT = {
+  png: ".png",
+  jpeg: ".jpg",
+  gif: ".gif",
+  webp: ".webp",
+  avif: ".avif",
+  svg: ".svg"
+};
+function assetExt(bytes, src) {
+  const format = sniffFormat(bytes);
+  if (format) return EXT[format];
+  const fromUrl = extname2(new URL(src, "file:///").pathname).toLowerCase().replace(/[^.a-z0-9]/g, "");
+  return fromUrl || ".img";
+}
+var FIGURE_MAX_BYTES = 32 * 1024 * 1024;
+var FIGURE_TIMEOUT_MS = 2e4;
+async function load(src) {
+  if (!/^https?:/i.test(src)) return readFile4(src);
+  const got = await fetchGuarded(src, {
+    maxBytes: FIGURE_MAX_BYTES,
+    timeoutMs: FIGURE_TIMEOUT_MS
+  });
+  return got.bytes;
+}
+function reason(err) {
+  if (err instanceof z2.ZodError)
+    return err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+  return err instanceof Error ? err.message : String(err);
+}
+var SVG_WINDOW = 64 * 1024;
+function sniffFormat(b) {
+  if (b.length >= 8 && b.readUInt32BE(0) === 2303741511 && b.readUInt32BE(4) === 218765834)
+    return "png";
+  if (b.length >= 6 && b.toString("latin1", 0, 4) === "GIF8") return "gif";
+  if (b.length >= 2 && b.readUInt16BE(0) === 65496) return "jpeg";
+  if (b.length >= 12 && b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP")
+    return "webp";
+  if (b.length >= 12 && b.toString("latin1", 4, 8) === "ftyp" && isAvifBrand(b)) return "avif";
+  if (isSvg(b)) return "svg";
+  return void 0;
+}
+function isAvifBrand(b) {
+  const declared = b.readUInt32BE(0);
+  const end = Math.min(declared >= 16 ? declared : b.length, b.length);
+  const brand = (at) => b.toString("latin1", at, at + 4);
+  if (brand(8) === "avif" || brand(8) === "avis") return true;
+  for (let i = 16; i + 4 <= end; i += 4)
+    if (brand(i) === "avif" || brand(i) === "avis") return true;
+  return false;
+}
+function isSvg(b) {
+  const text2 = b.toString("utf8", 0, Math.min(b.length, SVG_WINDOW)).replace(/^\uFEFF/, "");
+  let i = 0;
+  for (; ; ) {
+    while (i < text2.length && /\s/.test(text2.charAt(i))) i++;
+    const comment = text2.startsWith("<!--", i);
+    if (text2.startsWith("<?", i) || comment || /^<!doctype\s+svg\b/i.test(text2.slice(i, i + 20))) {
+      const end = comment ? text2.indexOf("-->", i) + 3 : text2.indexOf(">", i) + 1;
+      if (end <= 0) return false;
+      i = end;
+      continue;
+    }
+    return /^<svg[\s/>]/i.test(text2.slice(i, i + 5));
+  }
+}
+function imageSize(b) {
+  const format = sniffFormat(b);
+  const raw2 = measure2(b, format);
+  const width = Math.round(raw2.width);
+  const height = Math.round(raw2.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1)
+    throw new Error(`${format ?? "image"} header claims ${raw2.width}x${raw2.height}, not a size`);
+  return { width, height };
+}
+function measure2(b, format) {
+  switch (format) {
+    case "png":
+      return pngSize(b);
+    case "gif":
+      return gifSize(b);
+    case "jpeg":
+      return jpegSize(b);
+    case "webp":
+      return webpSize(b);
+    case "avif":
+      return avifSize(b);
+    case "svg":
+      return svgFigureSize(b);
+    default:
+      throw new Error(
+        `unrecognised image header (expected PNG, JPEG, GIF, WebP, AVIF or SVG; got ${describe(b)})`
+      );
+  }
+}
+function describe(b) {
+  if (b.length === 0) return "an empty file";
+  if (b.length >= 12 && b.toString("latin1", 4, 8) === "ftyp")
+    return `an ISO-BMFF file branded "${b.toString("latin1", 8, 12)}" \u2014 HEIC and its relatives are not drawn by the renderer`;
+  const head = b.toString("latin1", 0, Math.min(b.length, 64));
+  if (/^\s*<(?:!doctype\s+html|html|head|body)\b/i.test(head))
+    return "an HTML page \u2014 the URL answered with a page, not a picture";
+  if (head.startsWith("%PDF")) return "a PDF";
+  const hex = [...b.subarray(0, 8)].map((x) => x.toString(16).padStart(2, "0")).join(" ");
+  return `${b.length} bytes beginning ${hex}`;
+}
+function pngSize(b) {
+  if (b.length < 24) throw new Error(`PNG is truncated: ${b.length} bytes, IHDR ends at 24`);
+  if (b.toString("latin1", 12, 16) !== "IHDR") throw new Error("PNG does not open with IHDR");
+  return { width: b.readUInt32BE(16), height: b.readUInt32BE(20) };
+}
+function gifSize(b) {
+  if (b.length < 10)
+    throw new Error(`GIF is truncated: ${b.length} bytes, the screen descriptor ends at 10`);
+  return { width: b.readUInt16LE(6), height: b.readUInt16LE(8) };
+}
+function jpegSize(b) {
+  let i = 2;
+  while (i + 9 < b.length) {
+    if (b[i] !== 255) {
+      i++;
+      continue;
+    }
+    const marker = b[i + 1];
+    if (marker === void 0) break;
+    if (marker === 255) {
+      i++;
+      continue;
+    }
+    if (marker === 1 || marker >= 208 && marker <= 217) {
+      i += 2;
+      continue;
+    }
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204)
+      return { width: b.readUInt16BE(i + 7), height: b.readUInt16BE(i + 5) };
+    i += 2 + b.readUInt16BE(i + 2);
+  }
+  throw new Error("JPEG has no SOF segment");
+}
+function webpSize(b) {
+  const chunk = b.length >= 16 ? b.toString("latin1", 12, 16) : "";
+  if (chunk === "VP8 ") {
+    if (b.length < 30) throw new Error(`WebP VP8 chunk is truncated: ${b.length} bytes, needs 30`);
+    if (b[23] !== 157 || b[24] !== 1 || b[25] !== 42)
+      throw new Error("WebP VP8 chunk has no keyframe sync code");
+    return { width: b.readUInt16LE(26) & 16383, height: b.readUInt16LE(28) & 16383 };
+  }
+  if (chunk === "VP8L") {
+    if (b.length < 25) throw new Error(`WebP VP8L chunk is truncated: ${b.length} bytes, needs 25`);
+    if (b[20] !== 47) throw new Error("WebP VP8L chunk has no 0x2f signature");
+    const bits = b.readUInt32LE(21);
+    return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+  }
+  if (chunk === "VP8X") {
+    if (b.length < 30) throw new Error(`WebP VP8X chunk is truncated: ${b.length} bytes, needs 30`);
+    return { width: b.readUIntLE(24, 3) + 1, height: b.readUIntLE(27, 3) + 1 };
+  }
+  throw new Error(`WebP opens with chunk "${chunk}", not one of VP8 , VP8L, VP8X`);
+}
+function avifSize(b) {
+  const meta = find(b, 0, b.length, "meta");
+  if (!meta) throw new Error("AVIF has no meta box (truncated, or not an image item)");
+  const iprp = find(b, meta.start + 4, meta.end, "iprp");
+  const ipco = iprp && find(b, iprp.start, iprp.end, "ipco");
+  if (!ipco) throw new Error("AVIF has no ipco box (no item properties to read a size from)");
+  let best = { width: 0, height: 0 };
+  for (const box of boxes(b, ipco.start, ipco.end)) {
+    if (box.type !== "ispe" || box.end - box.start < 12) continue;
+    const found = { width: b.readUInt32BE(box.start + 4), height: b.readUInt32BE(box.start + 8) };
+    if (found.width * found.height > best.width * best.height) best = found;
+  }
+  if (best.width < 1 || best.height < 1) throw new Error("AVIF has no usable ispe property");
+  return cleanAperture(b, ipco, best) ?? best;
+}
+function cleanAperture(b, ipco, ispe) {
+  for (const box of boxes(b, ipco.start, ipco.end)) {
+    if (box.type !== "clap" || box.end - box.start < 16) continue;
+    const at = (offset) => b.readUInt32BE(box.start + offset);
+    if (at(4) === 0 || at(12) === 0) continue;
+    const width = Math.round(at(0) / at(4));
+    const height = Math.round(at(8) / at(12));
+    if (width > ispe.width || height > ispe.height) continue;
+    if (width * 2 < ispe.width || height * 2 < ispe.height) continue;
+    return { width, height };
+  }
+  return void 0;
+}
+function find(b, from, to, type) {
+  for (const box of boxes(b, from, to)) if (box.type === type) return box;
+  return void 0;
+}
+function* boxes(b, from, to) {
+  let i = from;
+  while (i + 8 <= to) {
+    let size2 = b.readUInt32BE(i);
+    const type = b.toString("latin1", i + 4, i + 8);
+    let start = i + 8;
+    if (size2 === 1) {
+      if (i + 16 > to) return;
+      const large = b.readBigUInt64BE(i + 8);
+      if (large > BigInt(Number.MAX_SAFE_INTEGER)) return;
+      size2 = Number(large);
+      start = i + 16;
+    } else if (size2 === 0) {
+      size2 = to - i;
+    }
+    if (size2 < start - i || i + size2 > to) return;
+    yield { type, start, end: i + size2 };
+    i += size2;
+  }
+}
+function svgFigureSize(b) {
+  const moving = /<(?:animate|animateTransform|animateMotion|set|script)\b|@keyframes\b/i.exec(
+    b.toString("utf8")
+  );
+  if (moving)
+    throw new Error(
+      `SVG carries "${moving[0]}": animation is drawn against the capture clock, so the render would differ every run. Convert the figure to PNG and point at that.`
+    );
+  return svgSize(b);
+}
+function svgSize(bytes) {
+  const text2 = bytes.toString("utf8", 0, Math.min(bytes.length, SVG_WINDOW));
+  const tag = /<svg\b[^>]*>/i.exec(text2)?.[0];
+  if (!tag) throw new Error(`SVG root element is not closed within ${SVG_WINDOW} bytes`);
+  const width = cssPixels(attrOf(tag, "width"));
+  const height = cssPixels(attrOf(tag, "height"));
+  if (width !== void 0 && height !== void 0) return { width, height };
+  const box = attrOf(tag, "viewBox")?.trim().split(/[\s,]+/).map(Number);
+  const w = box?.[2];
+  const h = box?.[3];
+  if (box?.length === 4 && w !== void 0 && h !== void 0 && w > 0 && h > 0)
+    return { width: w, height: h };
+  throw new Error("SVG declares no absolute width and height, and no usable viewBox");
+}
+function attrOf(tag, name) {
+  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, "i").exec(tag);
+  return m?.[1] ?? m?.[2];
+}
+var UNIT = {
+  "": 1,
+  px: 1,
+  pt: 96 / 72,
+  pc: 16,
+  in: 96,
+  cm: 96 / 2.54,
+  mm: 96 / 25.4,
+  q: 96 / 101.6,
+  em: 16,
+  rem: 16
+};
+function cssPixels(value) {
+  if (value === void 0) return void 0;
+  const m = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*([a-z%]*)\s*$/i.exec(value);
+  if (!m?.[1]) return void 0;
+  const scale = UNIT[(m[2] ?? "").toLowerCase()];
+  if (scale === void 0) return void 0;
+  const px = Number(m[1]) * scale;
+  return px > 0 ? px : void 0;
+}
+
+// src/source/readability.ts
+var CONTENT_MARKER = "data-ds-content";
+function readContentRegion() {
+  const MARKER = "data-ds-content";
+  const MIN_TEXT = 250;
+  const MAX_ANCESTORS = 5;
+  const SIBLING_FRACTION = 0.2;
+  const MIN_SIBLING_SCORE = 10;
+  const MIN_PARAGRAPH = 25;
+  const UNLIKELY = /-ad-|ai2html|banner|breadcrumb|combx|comment|community|consent|cookie|disqus|extra|footer|gdpr|legends|masthead|menu|modal|newsletter|paywall|popup|promo|related|remark|replies|rss|share|shoutbox|sidebar|skyscraper|social|sponsor|subscribe|supplemental|pagination|pager|toolbar|yom-remote/i;
+  const MAYBE = /and|article|body|column|content|main|shadow|story/i;
+  const POSITIVE = /article|body|content|entry|hentry|h-entry|main|page|post|story|text|blog/i;
+  const NEGATIVE = /-ad-|banner|combx|comment|com-|contact|foot|footer|footnote|gdpr|masthead|media|meta|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|widget/i;
+  const CHROME_ROLES = /* @__PURE__ */ new Set([
+    "alert",
+    "alertdialog",
+    "banner",
+    "complementary",
+    "contentinfo",
+    "dialog",
+    "menu",
+    "menubar",
+    "navigation",
+    "search",
+    "toolbar",
+    "tooltip"
+  ]);
+  const CHROME_TAGS = /* @__PURE__ */ new Set([
+    "nav",
+    "aside",
+    "footer",
+    "script",
+    "style",
+    "noscript",
+    "form",
+    "svg",
+    "canvas",
+    "template",
+    "button",
+    "select",
+    "textarea"
+  ]);
+  const SCORED = "p, td, pre, section, h2, h3, h4, h5, h6";
+  function textOf2(node) {
+    return (node?.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  function labelOf(el) {
+    return `${el.getAttribute("class") ?? ""} ${el.getAttribute("id") ?? ""}`;
+  }
+  function nameOf(el) {
+    const id2 = el.getAttribute("id");
+    const cls = (el.getAttribute("class") ?? "").trim().split(/\s+/)[0];
+    return el.tagName.toLowerCase() + (id2 ? `#${id2}` : "") + (cls ? `.${cls}` : "");
+  }
+  function pathOf(el) {
+    const parts = [];
+    let node = el;
+    while (node && parts.length < 3) {
+      parts.unshift(nameOf(node));
+      node = node.parentElement;
+    }
+    return parts.join(" > ");
+  }
+  function round7(n3) {
+    return Math.round(n3 * 1e3) / 1e3;
+  }
+  function linkDensity(el) {
+    const total = textOf2(el).length;
+    if (total === 0) return 0;
+    let inLinks = 0;
+    for (const a of el.querySelectorAll("a")) {
+      const href = a.getAttribute("href") ?? "";
+      inLinks += textOf2(a).length * (href.startsWith("#") ? 0.3 : 1);
+    }
+    return inLinks / total;
+  }
+  function classWeight(el) {
+    let weight = 0;
+    for (const label of [el.getAttribute("class") ?? "", el.getAttribute("id") ?? ""]) {
+      if (label === "") continue;
+      if (NEGATIVE.test(label)) weight -= 25;
+      if (POSITIVE.test(label)) weight += 25;
+    }
+    return weight;
+  }
+  function tagBonus(tag) {
+    if (tag === "div") return 5;
+    if (tag === "pre" || tag === "td" || tag === "blockquote") return 3;
+    if (tag === "th" || /^h[1-6]$/.test(tag)) return -5;
+    if (/^(address|ol|ul|dl|dd|dt|li|form)$/.test(tag)) return -3;
+    return 0;
+  }
+  const scores = /* @__PURE__ */ new Map();
+  function scoreOf(el) {
+    const at = scores.get(el);
+    if (at !== void 0) return at;
+    const start = tagBonus(el.tagName.toLowerCase()) + classWeight(el);
+    scores.set(el, start);
+    return start;
+  }
+  const removed = [];
+  function strip(el) {
+    const parent = el.parentElement;
+    if (!parent) return;
+    removed.push({ node: el, parent, next: el.nextSibling });
+    el.remove();
+  }
+  function restore() {
+    for (let i = removed.length - 1; i >= 0; i--) {
+      const at = removed[i];
+      if (at) at.parent.insertBefore(at.node, at.next);
+    }
+    removed.length = 0;
+  }
+  function declined(reason3, candidates2) {
+    restore();
+    return {
+      marked: false,
+      reason: reason3,
+      candidates: candidates2,
+      merged: 0,
+      stripped: 0,
+      text: 0,
+      mediaDropped: 0
+    };
+  }
+  try {
+    if (!document.body) {
+      return declined("the document has no <body>, so there is no region to choose", []);
+    }
+    const mediaBefore = document.querySelectorAll("video, iframe").length;
+    for (const el of [...document.body.querySelectorAll("*")]) {
+      if (!el.isConnected) continue;
+      const tag = el.tagName.toLowerCase();
+      if (CHROME_TAGS.has(tag)) {
+        strip(el);
+        continue;
+      }
+      if (tag === "header" && el.parentElement?.closest("article, main, section") == null) {
+        strip(el);
+        continue;
+      }
+      if (el.hasAttribute("hidden") || el.getAttribute("aria-hidden") === "true") {
+        strip(el);
+        continue;
+      }
+      if (CHROME_ROLES.has((el.getAttribute("role") ?? "").toLowerCase())) {
+        strip(el);
+        continue;
+      }
+      const label = labelOf(el);
+      if (UNLIKELY.test(label) && !MAYBE.test(label) && !el.querySelector("main, article")) {
+        strip(el);
+      }
+    }
+    for (const el of document.body.querySelectorAll(SCORED)) {
+      const text3 = textOf2(el);
+      if (text3.length < MIN_PARAGRAPH) continue;
+      const base = 1 + (text3.split(",").length - 1) + Math.min(Math.floor(text3.length / 100), 3);
+      let node = el.parentElement;
+      let level = 0;
+      while (node && node !== document.documentElement && level < MAX_ANCESTORS) {
+        const divider = level === 0 ? 1 : level === 1 ? 2 : level * 3;
+        scores.set(node, scoreOf(node) + base / divider);
+        node = node.parentElement;
+        level++;
+      }
+    }
+    const ranked = [];
+    for (const [el, content] of scores) {
+      const density = linkDensity(el);
+      ranked.push({
+        el,
+        report: {
+          path: pathOf(el),
+          content: round7(content),
+          linkDensity: round7(density),
+          // THE WHOLE POINT OF THE PASS. A rail of related headlines and an
+          // article of the same length hold the same number of characters; only
+          // this term separates them, and it is why the discount is a
+          // multiplier rather than a subtraction — a candidate that is entirely
+          // links scores zero however long it is.
+          score: round7(content * (1 - density)),
+          text: textOf2(el).length
+        }
+      });
+    }
+    ranked.sort((a, b) => b.report.score - a.report.score);
+    const report = ranked.slice(0, 5).map((r) => r.report);
+    let top = ranked[0];
+    if (!top) {
+      return declined(
+        `nothing scored: the page has no paragraph of ${MIN_PARAGRAPH} characters or more outside its chrome. Save the page and ingest the file if a script builds its body.`,
+        report
+      );
+    }
+    const byElement = new Map(ranked.map((r) => [r.el, r]));
+    const floor = top.report.score / 3;
+    let last = top.report.score;
+    let up = top.el.parentElement;
+    while (up && up !== document.body && up !== document.documentElement) {
+      const here = byElement.get(up);
+      if (here) {
+        if (here.report.score < floor) break;
+        if (here.report.score > last) {
+          top = here;
+          break;
+        }
+        last = here.report.score;
+      }
+      up = up.parentElement;
+    }
+    if (top.el === document.body) {
+      const text3 = textOf2(document.body).length;
+      if (text3 < MIN_TEXT) {
+        return declined(
+          `the page holds ${text3} characters of text outside its chrome, under the ${MIN_TEXT} this pass needs to be sure of a region; left it for the simpler heuristic`,
+          report
+        );
+      }
+      document.body.setAttribute(MARKER, "");
+      return {
+        marked: true,
+        reason: `chose <body>: nothing narrower than the page itself scored, ${text3} characters`,
+        candidates: report,
+        merged: 0,
+        stripped: removed.length,
+        text: text3,
+        mediaDropped: mediaBefore - document.body.querySelectorAll("video, iframe").length
+      };
+    }
+    const parent = top.el.parentElement;
+    if (!parent) {
+      return declined("the winning candidate is not in the document any more", report);
+    }
+    const threshold = Math.max(MIN_SIBLING_SCORE, top.report.score * SIBLING_FRACTION);
+    const topClass = top.el.getAttribute("class") ?? "";
+    const keep = [];
+    for (const sib of [...parent.children]) {
+      if (sib === top.el) {
+        keep.push(sib);
+        continue;
+      }
+      const twin = topClass !== "" && sib.getAttribute("class") === topClass;
+      const bonus = twin ? top.report.score * SIBLING_FRACTION : 0;
+      const here = byElement.get(sib);
+      if (here && here.report.score + bonus >= threshold) {
+        keep.push(sib);
+        continue;
+      }
+      if (sib.tagName.toLowerCase() === "p") {
+        const text3 = textOf2(sib);
+        const density = linkDensity(sib);
+        const long = text3.length > 80 && density < 0.25;
+        const sentence = text3.length > 0 && text3.length <= 80 && density === 0 && /\.( |$)/.test(text3);
+        if (long || sentence) keep.push(sib);
+      }
+    }
+    const text2 = keep.reduce((n3, el) => n3 + textOf2(el).length, 0);
+    if (text2 < MIN_TEXT) {
+      return declined(
+        `the best region (${top.report.path}) holds ${text2} characters, under the ${MIN_TEXT} this pass needs to be sure of it; left the page for the simpler heuristic`,
+        report
+      );
+    }
+    let region;
+    if (keep.length === 1 && keep[0]) {
+      region = keep[0];
+    } else {
+      const box = document.createElement("div");
+      for (const el of keep) box.appendChild(el);
+      document.body.appendChild(box);
+      region = box;
+    }
+    region.setAttribute(MARKER, "");
+    return {
+      marked: true,
+      reason: `chose ${top.report.path} \u2014 score ${top.report.score}, link density ${top.report.linkDensity}, ${textOf2(region).length} characters` + (keep.length > 1 ? `, with ${keep.length - 1} sibling(s) merged in` : ""),
+      candidates: report,
+      merged: keep.length - 1,
+      stripped: removed.length,
+      text: textOf2(region).length,
+      mediaDropped: mediaBefore - region.querySelectorAll("video, iframe").length
+    };
+  } catch (e) {
+    return declined(
+      `the readability pass failed inside the page (${e instanceof Error ? e.message : String(e)}); the page was left as it was found and the simpler heuristic still applies`,
+      []
+    );
+  }
+}
+
+// src/source/transcode.ts
+import { readFile as readFile5, rm } from "node:fs/promises";
+import { basename } from "node:path";
+
+// src/render/ffmpeg.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var DEFAULT_TIMEOUT_MS = 36e5;
+async function runTool(file, args, opts = {}) {
+  try {
+    return await run(file, args, {
+      cwd: opts.cwd,
+      timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      maxBuffer: 64 << 20
+    });
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      throw new Error(`${file} is not installed, or not on PATH. \`render\` needs it.`);
+    }
+    const tail3 = (e.stderr ?? e.stdout ?? e.message).trim().split("\n").slice(-8).join("\n");
+    throw new Error(`${file} failed:
+${tail3}`);
+  }
+}
+function runLive(file, args) {
+  return new Promise((resolve6, reject) => {
+    const child = spawn(file, args, { stdio: ["ignore", "inherit", "inherit"] });
+    child.on("error", (err) => {
+      reject(
+        err.code === "ENOENT" ? new Error(`${file} is not installed, or not on PATH. \`render\` needs it.`) : err
+      );
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) resolve6();
+      else if (signal) {
+        reject(
+          new Error(
+            `${file} was killed by ${signal}. On a machine under memory pressure this is the OS reclaiming the browser; free memory, or lower --workers, and run again.`
+          )
+        );
+      } else reject(new Error(`${file} exited ${code}.`));
+    });
+  });
+}
+async function probe(path2) {
+  const { stdout } = await runTool("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "stream=codec_type,width,height,r_frame_rate,nb_frames:format=duration",
+    "-of",
+    "json",
+    path2
+  ]);
+  const json = JSON.parse(stdout);
+  const streams = json.streams ?? [];
+  const video = streams.find((s) => s.codec_type === "video");
+  if (!video) throw new Error(`${path2} has no video stream.`);
+  const [num, den] = (video.r_frame_rate ?? "30/1").split("/");
+  const fps = Number(num) / (Number(den) || 1);
+  const seconds = Number(json.format?.duration ?? 0);
+  const frames2 = Number(video.nb_frames ?? 0) || Math.round(seconds * fps);
+  return {
+    width: video.width ?? 0,
+    height: video.height ?? 0,
+    fps,
+    frames: frames2,
+    seconds,
+    hasAudio: streams.some((s) => s.codec_type === "audio")
+  };
+}
+function encoderArgs(fps) {
+  return [
+    "-c:v",
+    "libx264",
+    "-preset",
+    "veryfast",
+    "-crf",
+    "16",
+    "-pix_fmt",
+    "yuv420p",
+    "-g",
+    "12",
+    "-r",
+    String(fps),
+    "-fps_mode",
+    "cfr"
+  ];
+}
+function pieceFilter(motion, freeze) {
+  const chain = [`trim=end_frame=${motion}`, "setpts=N/FRAME_RATE/TB"];
+  if (freeze > 0) chain.push(`tpad=stop_mode=clone:stop=${freeze}`);
+  return chain.join(",");
+}
+function pieceArgs(source, fromFrame, motion, freeze, fps, out) {
+  return [
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    // Half a frame in, so a time that is exactly on a boundary cannot round to
+    // the frame before it.
+    "-ss",
+    ((fromFrame + 0.5) / fps).toFixed(6),
+    "-i",
+    source,
+    "-an",
+    "-vf",
+    pieceFilter(motion, freeze),
+    "-frames:v",
+    String(motion + freeze),
+    ...encoderArgs(fps),
+    "-f",
+    "mpegts",
+    out
+  ];
+}
+var LOUDNESS = "loudnorm=I=-16:TP=-1.5:LRA=11,aresample=48000";
+function audioGraph(inputs, seconds, first = 1) {
+  const lines = inputs.map(
+    (input, i) => `[${first + i}:a]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo,adelay=${input.delayMs}:all=1[d${i}]`
+  );
+  const labels = inputs.map((_, i) => `[d${i}]`).join("");
+  lines.push(
+    `${labels}amix=inputs=${inputs.length}:normalize=0:dropout_transition=0:duration=longest,${LOUDNESS},apad=whole_dur=${seconds.toFixed(3)}[aout]`
+  );
+  return lines.join(";\n");
+}
+function respeedArgs(source, factor, chain, fps, hasAudio, out) {
+  const video = `[0:v]setpts=PTS/${factor}[v]`;
+  const audio = hasAudio ? `;[0:a]${chain.map((t2) => `atempo=${t2}`).join(",")}[a]` : "";
+  return [
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    source,
+    "-filter_complex",
+    `${video}${audio}`,
+    "-map",
+    "[v]",
+    ...hasAudio ? ["-map", "[a]", "-c:a", "aac", "-b:a", "160k"] : ["-an"],
+    ...encoderArgs(fps),
+    out
+  ];
+}
+function burnStyle(width, height, font = "Arial") {
+  return {
+    width,
+    height,
+    font,
+    // MEASURED, not guessed. `splitCue` caps a cue at 84 characters and `wrap`
+    // breaks it near the middle, so the longer of the two lines runs to about
+    // 46 characters in real caption prose. Bold Arial advances 0.485em per
+    // character on that prose (measured in a browser over the demo's own
+    // narration), so 46 characters at F px is 22.3F wide, and the usable width
+    // here is 978px. F = 40 leaves 9% of headroom; F = 45 — which is what
+    // "4% of the width" looked like on paper — overflows to a THIRD line, and a
+    // three-line band covers the bottom of the slide.
+    fontSize: Math.round(width * 0.037),
+    // Clear of the play button, the progress bar and the handle every vertical
+    // player draws across the bottom eighth of the frame.
+    marginV: Math.round(height * 0.09),
+    marginX: Math.round(width * 0.04)
+  };
+}
+
+// src/source/transcode.ts
+var CLIP_EDGE_PX = 1280;
+var MAX_CLIP_SECONDS = 60;
+var TIMEOUT_MS = 6e5;
+function fitBox(width, height, maxEdgePx) {
+  const scale = Math.min(1, maxEdgePx / width, maxEdgePx / height);
+  return { width: even(width * scale), height: even(height * scale) };
+}
+function even(n3) {
+  return Math.max(2, Math.floor(Math.round(n3) / 2) * 2);
+}
+function transcodeArgs(input, out, plan) {
+  return [
+    "-y",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    input,
+    ...plan.seconds === void 0 ? [] : ["-t", plan.seconds.toFixed(3)],
+    "-an",
+    "-map_metadata",
+    "-1",
+    "-vf",
+    `scale=${plan.width}:${plan.height}`,
+    "-c:v",
+    "libvpx-vp9",
+    "-crf",
+    "32",
+    "-b:v",
+    "0",
+    "-deadline",
+    "good",
+    "-cpu-used",
+    "4",
+    "-row-mt",
+    "1",
+    "-pix_fmt",
+    "yuv420p",
+    "-fflags",
+    "+bitexact",
+    "-flags:v",
+    "+bitexact",
+    out
+  ];
+}
+var probed = /* @__PURE__ */ new Map();
+function installed(file) {
+  const asked = probed.get(file);
+  if (asked !== void 0) return asked;
+  const answer = runTool(file, ["-version"], { timeoutMs: 5e3 }).then(
+    () => true,
+    () => false
+  );
+  probed.set(file, answer);
+  return answer;
+}
+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 source = videoSize(await readFile5(input));
+  const box = fitBox(source.width, source.height, opts.maxEdgePx ?? CLIP_EDGE_PX);
+  const kept = (why3) => ({
+    path: input,
+    width: source.width,
+    height: source.height,
+    seconds: source.seconds,
+    transcoded: false,
+    warnings: [`${name} was shipped as the page served it: ${why3}`]
+  });
+  if (!await installed(file)) {
+    return kept(
+      `${file} is not installed, or not on PATH, so it could not be shrunk to ${box.width}x${box.height} VP9 \u2014 \`brew install ffmpeg\` / \`apt install ffmpeg\` and re-ingest to spend fewer bytes and a shorter render on it.`
+    );
+  }
+  const trim = source.seconds === void 0 || source.seconds > maxSeconds;
+  const started = Date.now();
+  try {
+    await runTool(
+      file,
+      transcodeArgs(input, out, { ...box, ...trim ? { seconds: maxSeconds } : {} }),
+      { timeoutMs }
+    );
+  } catch (err) {
+    await rm(out, { force: true });
+    const over = Date.now() - started >= timeoutMs;
+    return kept(
+      over ? `${file} ran past its ${(timeoutMs / 1e3).toFixed(0)}s budget and was stopped (raise timeoutMs, or cap the clip harder with maxSeconds).` : `${file} failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let measured;
+  try {
+    measured = videoSize(await readFile5(out));
+  } catch (err) {
+    await rm(out, { force: true });
+    return kept(
+      `the webm ${file} wrote could not be measured \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const warnings = [];
+  if (trim && measured.seconds !== void 0 && measured.seconds >= maxSeconds - 0.05) {
+    warnings.push(
+      `${name} was trimmed to the ${maxSeconds}s cap (maxSeconds) from ${source.seconds === void 0 ? "an unstated length" : `${source.seconds.toFixed(1)}s`}: a clip is pre-decoded to one still per output frame, so everything past the cap is bytes and decode that no beat is long enough to reach.`
+    );
+  }
+  return {
+    path: out,
+    width: measured.width,
+    height: measured.height,
+    seconds: measured.seconds,
+    transcoded: true,
+    warnings
+  };
+}
+
+// src/source/harvest.ts
+var HTML_MAX_BYTES = 8 * 1024 * 1024;
+var ASSET_MAX_BYTES = 32 * 1024 * 1024;
+var TIMEOUT_MS2 = 2e4;
+var MAX_ASSETS = 40;
+var MAX_CLIPS = 4;
+var MAX_TOTAL_BYTES = 96 * 1024 * 1024;
+var MAX_WALL_MS = 18e4;
+var MIN_FIGURE_PX = 64;
+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);
+  await mkdir4(assets, { recursive: true });
+  const page = await fetchGuarded(url, {
+    maxBytes: opts.maxBytes ?? HTML_MAX_BYTES,
+    timeoutMs,
+    accept: HTML_TYPES,
+    ...opts.allowLoopback === true ? { allowLoopback: true } : {}
+  });
+  const html = decodeHtml(page.bytes, page.contentType, url, warnings);
+  const { seen, pick } = await readInBrowser(html, timeoutMs);
+  if (!pick.marked) {
+    warnings.push(
+      `the article could not be scored out of this page \u2014 ${pick.reason}. The densest container was taken instead: read the section count below, and if it is the whole page rather than the piece, save the article and ingest the file.`
+    );
+  } else if (pick.mediaDropped > 0) {
+    warnings.push(
+      `${pick.mediaDropped} video or embed(s) sat outside the article region and were dropped with the page's chrome. If one of them was the video the piece is about, ingest the saved page instead, where the region is the whole document.`
+    );
+  }
+  const base = absolute(seen.base, page.url) ?? page.url;
+  const local = await localise(seen, base, assets, opts, timeoutMs, warnings);
+  return {
+    markdown: toMarkdown(titled(seen.title, local.blocks)),
+    assets: local.assets,
+    clips: local.clips,
+    warnings,
+    title: seen.title
+  };
+}
+function titled(title2, blocks) {
+  const first = blocks[0];
+  const already = first?.kind === "heading" && first.depth === 1 && first.text.trim() === title2.trim();
+  return title2 && !already ? [{ kind: "heading", depth: 1, text: title2 }, ...blocks] : [...blocks];
+}
+function decodeHtml(bytes, contentType, url, warnings) {
+  const declared = /charset\s*=\s*["']?([\w.:-]+)/i.exec(contentType)?.[1];
+  const head = bytes.toString("latin1", 0, Math.min(bytes.length, 4096));
+  const meta = /<meta[^>]+charset\s*=\s*["']?([\w.:-]+)/i.exec(head)?.[1];
+  const label = declared ?? meta;
+  if (label === void 0) return bytes.toString("utf8");
+  try {
+    return new TextDecoder(label).decode(bytes);
+  } catch {
+    warnings.push(
+      `${url} declares charset "${label}", which this Node cannot decode; read as UTF-8 instead. Non-ASCII text may be wrong \u2014 serve the page as UTF-8, or save it and ingest the file.`
+    );
+    return bytes.toString("utf8");
+  }
+}
+async function readInBrowser(html, timeoutMs) {
+  const { default: puppeteer } = await import("puppeteer-core");
+  const browser = await puppeteer.launch({
+    executablePath: await chromePath("read the page with"),
+    headless: true,
+    // Chrome's own background traffic — variations, safe browsing, first-run
+    // pings — never goes through page interception, so it is switched off here
+    // rather than assumed absent. It is not an SSRF path, but "the browser makes
+    // no requests" should be true of the whole process, not just of the tab.
+    args: [
+      "--disable-background-networking",
+      "--disable-extensions",
+      "--no-default-browser-check",
+      "--no-first-run"
+    ]
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setRequestInterception(true);
+    page.on("request", (request) => {
+      request.abort().catch(() => {
+      });
+    });
+    await page.setContent(html, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+    const pick = await page.evaluate(readContentRegion);
+    return { seen: await page.evaluate(readDom, CONTENT_MARKER), pick };
+  } finally {
+    await browser.close().catch(() => {
+    });
+  }
+}
+function readDom(marker) {
+  const SKIP = /* @__PURE__ */ new Set([
+    "nav",
+    "aside",
+    "footer",
+    "script",
+    "style",
+    "noscript",
+    "form",
+    "svg",
+    "canvas",
+    "template",
+    "button",
+    "select",
+    "textarea"
+  ]);
+  const BLOCKY = /* @__PURE__ */ new Set([
+    "p",
+    "div",
+    "section",
+    "article",
+    "main",
+    "ul",
+    "ol",
+    "table",
+    "figure",
+    "blockquote",
+    "pre",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6"
+  ]);
+  const PLAYER = /(?:youtube\.com\/(?:watch|embed|shorts)|youtu\.be\/|(?:player\.)?vimeo\.com\/|dailymotion\.com\/video\/|\.(?:mp4|webm|m4v|mov)(?:[?#]|$))/i;
+  function words2(node) {
+    return (node?.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  function skipped(el) {
+    return SKIP.has(el.tagName.toLowerCase()) || el.hasAttribute("hidden") || el.getAttribute("aria-hidden") === "true";
+  }
+  function pickSrc(el) {
+    const candidates2 = (el.getAttribute("srcset") ?? "").split(",").map((part) => part.trim().split(/\s+/)).filter((bits) => (bits[0] ?? "") !== "").map((bits) => ({ url: bits[0] ?? "", w: Number.parseInt(bits[1] ?? "", 10) || 0 }));
+    let widest2 = candidates2[0];
+    for (const candidate of candidates2) if (candidate.w >= (widest2?.w ?? -1)) widest2 = candidate;
+    return widest2?.url ?? el.getAttribute("src") ?? el.getAttribute("data-src") ?? "";
+  }
+  function imageOf(el, caption) {
+    const src = pickSrc(el);
+    if (!src) return void 0;
+    return { kind: "image", src, alt: words2(el.getAttributeNode("alt")), caption };
+  }
+  function videoOf(el, caption) {
+    const source = el.querySelector("source");
+    return {
+      kind: "video",
+      src: el.getAttribute("src") ?? source?.getAttribute("src") ?? "",
+      poster: el.getAttribute("poster") ?? "",
+      href: "",
+      caption
+    };
+  }
+  function figureOf(el, out) {
+    const caption = words2(el.querySelector("figcaption"));
+    const video = el.querySelector("video");
+    if (video) {
+      out.push(videoOf(video, caption));
+      return;
+    }
+    const image2 = el.querySelector("img");
+    const block2 = image2 ? imageOf(image2, caption) : void 0;
+    if (block2) {
+      out.push(block2);
+      return;
+    }
+    const text2 = words2(el);
+    if (text2) out.push({ kind: "paragraph", text: text2 });
+  }
+  function paragraphOf(el, out) {
+    const solid = [...el.childNodes].filter(
+      (n3) => n3.nodeType !== Node.TEXT_NODE || (n3.textContent ?? "").trim() !== ""
+    );
+    const only = solid.length === 1 ? solid[0] : void 0;
+    if (only instanceof HTMLAnchorElement && PLAYER.test(only.getAttribute("href") ?? "")) {
+      const href = only.getAttribute("href") ?? "";
+      out.push({ kind: "video", src: "", poster: "", href, caption: words2(only) });
+      return;
+    }
+    let buffer = "";
+    const flush = () => {
+      const text2 = buffer.replace(/\s+/g, " ").trim();
+      if (text2) out.push({ kind: "paragraph", text: text2 });
+      buffer = "";
+    };
+    const scan = (node) => {
+      if (node.nodeType === Node.TEXT_NODE) {
+        buffer += node.textContent ?? "";
+        return;
+      }
+      if (!(node instanceof Element)) return;
+      if (skipped(node)) return;
+      const tag = node.tagName.toLowerCase();
+      if (tag === "br") {
+        buffer += " ";
+        return;
+      }
+      if (tag === "img" || tag === "video" || BLOCKY.has(tag)) {
+        flush();
+        block(node, out);
+        return;
+      }
+      for (const kid of node.childNodes) scan(kid);
+    };
+    for (const kid of el.childNodes) scan(kid);
+    flush();
+  }
+  function listOf(el) {
+    return {
+      kind: "list",
+      ordered: el.tagName === "OL",
+      // A nested list flattens into its parent item, exactly as `blockText` in
+      // src/source/markdown.ts already flattens one on the way back out.
+      items: [...el.children].filter((li) => li.tagName === "LI").map(words2).filter((text2) => text2 !== "")
+    };
+  }
+  function tableOf(el) {
+    const rows = [...el.querySelectorAll("tr")].map(
+      (tr) => [...tr.children].filter((c) => c.tagName === "TD" || c.tagName === "TH").map(words2)
+    );
+    const [head, ...body] = rows;
+    return head ? { kind: "table", columns: head, rows: body } : void 0;
+  }
+  function block(el, out) {
+    if (skipped(el)) return;
+    const tag = el.tagName.toLowerCase();
+    if (/^h[1-6]$/.test(tag)) {
+      const text2 = words2(el);
+      if (text2) out.push({ kind: "heading", depth: Number(tag[1]), text: text2 });
+      return;
+    }
+    if (tag === "p" || tag === "blockquote") {
+      paragraphOf(el, out);
+      return;
+    }
+    if (tag === "ul" || tag === "ol") {
+      const list = listOf(el);
+      if (list.kind === "list" && list.items.length > 0) out.push(list);
+      return;
+    }
+    if (tag === "table") {
+      const table = tableOf(el);
+      if (table) out.push(table);
+      return;
+    }
+    if (tag === "figure") {
+      figureOf(el, out);
+      return;
+    }
+    if (tag === "img") {
+      const image2 = imageOf(el, "");
+      if (image2) out.push(image2);
+      return;
+    }
+    if (tag === "video") {
+      out.push(videoOf(el, ""));
+      return;
+    }
+    if (tag === "iframe") {
+      const href = el.getAttribute("src") ?? "";
+      if (PLAYER.test(href)) {
+        out.push({
+          kind: "video",
+          src: "",
+          poster: "",
+          href,
+          caption: words2(el.getAttributeNode("title"))
+        });
+      }
+      return;
+    }
+    if (tag === "pre") {
+      const text2 = (el.textContent ?? "").replace(/\s+$/, "");
+      if (text2) out.push({ kind: "code", text: text2 });
+      return;
+    }
+    const direct = [...el.childNodes].some(
+      (n3) => n3.nodeType === Node.TEXT_NODE && (n3.textContent ?? "").trim() !== ""
+    );
+    if (direct) {
+      paragraphOf(el, out);
+      return;
+    }
+    walk(el, out);
+  }
+  function walk(el, out) {
+    for (const kid of el.children) block(kid, out);
+  }
+  function score(el) {
+    let text2 = 0;
+    for (const p of el.querySelectorAll("p, li, td, h1, h2, h3, h4, h5, h6")) {
+      text2 += (p.textContent ?? "").trim().length;
+    }
+    let links = 0;
+    for (const a of el.querySelectorAll("a")) links += (a.textContent ?? "").trim().length;
+    return text2 - links;
+  }
+  function pickRoot() {
+    const marked = document.querySelector(`[${marker}]`);
+    if (marked) return marked;
+    const main = document.querySelector("main");
+    if (main && score(main) > 0) return main;
+    const article = document.querySelector("article");
+    if (article && score(article) > 0) return article;
+    let best = document.body;
+    let top = score(document.body);
+    for (const el of document.body.querySelectorAll("div, section, td")) {
+      const here = score(el);
+      if (here >= top) {
+        top = here;
+        best = el;
+      }
+    }
+    return best;
+  }
+  const root = pickRoot();
+  const blocks = [];
+  walk(root, blocks);
+  const heading = words2(root.querySelector("h1")) || words2(document.querySelector("h1"));
+  const og = document.querySelector('meta[property="og:image"], meta[name="og:image"]') ?? document.querySelector('meta[property="og:image:url"], meta[name="twitter:image"]');
+  return {
+    title: heading || (document.title ?? "").replace(/\s+/g, " ").trim(),
+    base: document.querySelector("base[href]")?.getAttribute("href") ?? "",
+    ogImage: og?.getAttribute("content") ?? "",
+    blocks
+  };
+}
+async function localise(seen, base, dir, opts, timeoutMs, warnings) {
+  const maxAssets = opts.maxAssets ?? MAX_ASSETS;
+  const maxClips = opts.maxClips ?? MAX_CLIPS;
+  const maxBytes = opts.maxTotalBytes ?? MAX_TOTAL_BYTES;
+  const wallMs = opts.maxWallMs ?? MAX_WALL_MS;
+  const deadline = Date.now() + wallMs;
+  const out = [];
+  const assets = [];
+  const clips = [];
+  let spent = 0;
+  const done = /* @__PURE__ */ new Map();
+  const ref = (got) => opts.refs === "relative" ? basename2(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`;
+    }
+    if (spent >= maxBytes) {
+      return `the harvest has downloaded ${mb(spent)} of its ${mb(maxBytes)} \u2014 raise maxTotalBytes`;
+    }
+    return null;
+  };
+  const bytesOf = async (url) => {
+    const got = await fetchGuarded(url, {
+      maxBytes: opts.maxAssetBytes ?? ASSET_MAX_BYTES,
+      timeoutMs,
+      ...opts.allowLoopback === true ? { allowLoopback: true } : {}
+    });
+    spent += got.bytes.length;
+    return got.bytes;
+  };
+  const grab = async (raw2, what) => {
+    const url = absolute(raw2, base);
+    if (url === null) {
+      warnings.push(
+        `${what} was left out: "${raw2.slice(0, 120)}" is not an http(s) URL. Only web URLs are fetched; a data: or blob: source has to be saved by hand.`
+      );
+      return null;
+    }
+    const already = done.get(url);
+    if (already !== void 0) return already;
+    if (assets.length >= maxAssets) {
+      done.set(url, null);
+      warnings.push(
+        `${what} was left out: ${url} \u2014 already at ${maxAssets} assets. Raise maxAssets if the page really has that many figures.`
+      );
+      return null;
+    }
+    const capped = overdrawn();
+    if (capped !== null) {
+      done.set(url, null);
+      warnings.push(`${what} was left out: ${url} \u2014 ${capped} if the page is worth the wait.`);
+      return null;
+    }
+    let got = null;
+    try {
+      const bytes = await bytesOf(url);
+      const size2 = imageSize(bytes);
+      if (size2.width < MIN_FIGURE_PX || size2.height < MIN_FIGURE_PX) {
+        throw new Error(
+          `it is ${size2.width}x${size2.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))));
+      await writeFile4(path2, bytes);
+      assets.push(path2);
+      got = { path: path2, width: size2.width, height: size2.height };
+    } catch (err) {
+      got = null;
+      warnings.push(`${what} was left out: ${url} \u2014 ${why(err)}`);
+    }
+    done.set(url, got);
+    return got;
+  };
+  const shrink = async (url, path2, measured, what) => {
+    if (opts.transcode === false) return { path: path2, ...measured };
+    const out2 = join4(dir, assetName(url, ".vp9.webm"));
+    let small;
+    try {
+      small = await transcode(path2, out2, {
+        ...opts.maxClipSeconds === void 0 ? {} : { maxSeconds: opts.maxClipSeconds }
+      });
+    } catch (err) {
+      warnings.push(`${what} was shipped as the page served it: ${why(err)}`);
+      return { path: path2, ...measured };
+    }
+    for (const w of small.warnings) warnings.push(`${what} \u2014 ${w}`);
+    if (small.transcoded) {
+      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.`
+        );
+      }
+      await rm2(path2, { force: true });
+    }
+    return {
+      path: small.path,
+      width: small.width,
+      height: small.height,
+      ...small.seconds === void 0 ? {} : { seconds: small.seconds }
+    };
+  };
+  const grabVideo = async (url, what) => {
+    if (clips.length >= maxClips) {
+      warnings.push(
+        maxClips === 0 ? `${what} is a link only: this harvest downloads no videos at all (maxClips is 0).` : `${what} is a link only: already holding ${maxClips} clips. Raise maxClips if the page really is that many videos.`
+      );
+      return null;
+    }
+    const capped = overdrawn();
+    if (capped !== null) {
+      warnings.push(`${what} is a link only: ${capped} if the video is worth the wait.`);
+      return null;
+    }
+    try {
+      const bytes = await bytesOf(url);
+      const measured = videoSize(bytes);
+      const path2 = join4(dir, assetName(url, `.${measured.container}`));
+      await writeFile4(path2, bytes);
+      return await shrink(url, path2, measured, what);
+    } catch (err) {
+      warnings.push(`${what} was not downloaded: ${url} \u2014 ${why(err)}`);
+      return null;
+    }
+  };
+  let ogSpent = false;
+  const stillFor = async (poster, named, needed) => {
+    if (poster) return grab(poster, `the poster of ${named}`);
+    if (needed && seen.ogImage && !ogSpent) {
+      ogSpent = true;
+      return grab(seen.ogImage, `the page's og:image, taken as the still of ${named}`);
+    }
+    return null;
+  };
+  for (const item of seen.blocks) {
+    if (item.kind === "image") {
+      const named = item.caption || item.alt;
+      const got = await grab(item.src, named ? `the image "${named}"` : "an image");
+      if (got) out.push({ ...item, src: ref(got) });
+      continue;
+    }
+    if (item.kind === "video") {
+      const named = item.caption ? `the video "${item.caption}"` : "a video";
+      const file = absolute(item.src, base);
+      const page = absolute(item.href, base);
+      const subject = file ?? page;
+      const watch = page ?? file;
+      const policy = subject === null ? null : policyFor(subject, "bake");
+      const held = policy === "bake" && subject !== null ? await grabVideo(subject, named) : null;
+      const still = await stillFor(item.poster, named, held === null);
+      if (held !== null) {
+        clips.push({
+          file: held.path,
+          poster: still?.path ?? "",
+          href: "",
+          width: held.width,
+          height: held.height,
+          ...held.seconds === void 0 ? {} : { seconds: held.seconds },
+          caption: item.caption
+        });
+        out.push({ ...item, src: "", poster: still ? ref(still) : "", href: "" });
+        continue;
+      }
+      if (still !== null && watch !== null) {
+        clips.push({
+          file: "",
+          poster: still.path,
+          href: watch,
+          width: still.width,
+          height: still.height,
+          caption: item.caption
+        });
+        warnings.push(
+          `${named} is a link only: ${unheld(policy)}. The still is what the deck shows, and a viewer goes to ${watch}.`
+        );
+        out.push({ ...item, src: "", poster: ref(still), href: watch });
+        continue;
+      }
+      if (still !== null) {
+        warnings.push(
+          `${named} is a still only: the page names no source for it, so there is nothing to play.`
+        );
+        out.push({ ...item, src: "", poster: ref(still), href: "" });
+        continue;
+      }
+      if (watch === null) {
+        warnings.push(`${named} was left out: it names neither a poster image nor a URL.`);
+        continue;
+      }
+      warnings.push(
+        `${named} is a link only and the page gave it no still: no poster attribute, no og:image left to spend. Save a frame by hand and add it to source.json as a clip figure.`
+      );
+      out.push({ ...item, src: "", poster: "", href: watch });
+      continue;
+    }
+    out.push(item);
+  }
+  return { blocks: out, assets, clips };
+}
+function unheld(policy) {
+  if (policy === "embed") return "it is a player page, which is never downloaded";
+  if (policy === "link") {
+    return "its URL does not end in a video extension, so what came back could as easily be a page";
+  }
+  return "the file could not be held";
+}
+async function sizeOf(path2) {
+  return await stat(path2).then(
+    (s) => s.size,
+    () => 0
+  );
+}
+function mb(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function absolute(raw2, base) {
+  const trimmed = raw2.trim();
+  if (!trimmed) return null;
+  try {
+    const url = new URL(trimmed, base);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function assetName(url, ext) {
+  const last = new URL(url).pathname.split("/").pop() ?? "";
+  const stem = last.replace(/\.[^.]*$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "figure";
+  const hash = createHash5("sha256").update(url).digest("hex").slice(0, 8);
+  return `${stem}-${hash}${ext}`;
+}
+function extFor2(format) {
+  if (format === void 0) return ".img";
+  return format === "jpeg" ? ".jpg" : `.${format}`;
+}
+function why(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sniffVideo(b) {
+  if (b.length >= 12 && b.toString("latin1", 4, 8) === "ftyp") return "mp4";
+  if (b.length >= 4 && b.readUInt32BE(0) === 440786851) return "webm";
+  return void 0;
+}
+function videoSize(b) {
+  const container = sniffVideo(b);
+  if (container === void 0) {
+    throw new Error(
+      "its first bytes are neither an ISO base media (mp4) header nor an EBML (webm) one, so it is not a video this can measure \u2014 which is what an interstitial or a login page looks like"
+    );
+  }
+  const measured = container === "mp4" ? mp4Size(b) : webmSize(b);
+  if (measured.width < MIN_FIGURE_PX || measured.height < MIN_FIGURE_PX) {
+    throw new Error(
+      `it measures ${measured.width}x${measured.height}, under ${MIN_FIGURE_PX}px \u2014 a slide cannot use one`
+    );
+  }
+  return { ...measured, container };
+}
+function boxes2(b, from, to) {
+  const out = [];
+  let at = from;
+  while (at + 8 <= to) {
+    let size2 = b.readUInt32BE(at);
+    const type = b.toString("latin1", at + 4, at + 8);
+    let body = at + 8;
+    if (size2 === 1) {
+      if (body + 8 > to) return out;
+      size2 = Number(b.readBigUInt64BE(body));
+      body += 8;
+    } else if (size2 === 0) {
+      size2 = to - at;
+    }
+    const end = at + size2;
+    if (size2 < body - at || end > to) return out;
+    out.push({ type, body, end });
+    at = end;
+  }
+  return out;
+}
+function mp4Size(b) {
+  const moov = boxes2(b, 0, b.length).find((box) => box.type === "moov");
+  if (moov === void 0) {
+    throw new Error(
+      "it has no moov box \u2014 the file is truncated, or it is a fragmented stream whose header never arrived"
+    );
+  }
+  let seconds;
+  let size2;
+  for (const box of boxes2(b, moov.body, moov.end)) {
+    if (box.type === "mvhd") seconds = mvhdSeconds(b, box.body);
+    if (box.type !== "trak") continue;
+    for (const inner of boxes2(b, box.body, box.end)) {
+      if (inner.type === "tkhd" && size2 === void 0) size2 = tkhdSize(b, inner.body);
+    }
+  }
+  if (size2 === void 0) {
+    throw new Error(
+      "no track in it declares a width and a height, so there is no picture to place"
+    );
+  }
+  return { ...size2, ...seconds === void 0 ? {} : { seconds } };
+}
+function tkhdSize(b, body) {
+  const matrix = body + (b[body] === 1 ? 52 : 40);
+  const at = matrix + 36;
+  if (at + 8 > b.length) return void 0;
+  const width = Math.round(b.readUInt32BE(at) / 65536);
+  const height = Math.round(b.readUInt32BE(at + 4) / 65536);
+  if (width <= 0 || height <= 0) return void 0;
+  const quarterTurn = b.readInt32BE(matrix) === 0 && b.readInt32BE(matrix + 16) === 0;
+  return quarterTurn ? { width: height, height: width } : { width, height };
+}
+function mvhdSeconds(b, body) {
+  const long = b[body] === 1;
+  const at = body + (long ? 20 : 12);
+  if (at + (long ? 12 : 8) > b.length) return void 0;
+  const timescale = b.readUInt32BE(at);
+  const ticks = long ? Number(b.readBigUInt64BE(at + 4)) : b.readUInt32BE(at + 4);
+  if (timescale <= 0 || ticks <= 0 || ticks === 4294967295) return void 0;
+  return sane(ticks / timescale);
+}
+var EBML_SEGMENT = 408125543;
+var EBML_INFO = 357149030;
+var EBML_TRACKS = 374648427;
+var EBML_TRACK_ENTRY = 174;
+var EBML_VIDEO = 224;
+var EBML_PIXEL_WIDTH = 176;
+var EBML_PIXEL_HEIGHT = 186;
+var EBML_DISPLAY_WIDTH = 21680;
+var EBML_DISPLAY_HEIGHT = 21690;
+var EBML_TIMECODE_SCALE = 2807729;
+var EBML_DURATION = 17545;
+function webmSize(b) {
+  let pixel = { width: 0, height: 0 };
+  let display = { width: 0, height: 0 };
+  let scale = 1e6;
+  let ticks;
+  const masters = /* @__PURE__ */ new Set([EBML_SEGMENT, EBML_INFO, EBML_TRACKS, EBML_TRACK_ENTRY, EBML_VIDEO]);
+  const scan = (from, to, depth) => {
+    let at = from;
+    while (at < to) {
+      const el = ebml(b, at, to);
+      if (el === void 0 || el.end <= at) return;
+      if (masters.has(el.id)) {
+        if (depth < 6) scan(el.body, el.end, depth + 1);
+      } else if (el.id === EBML_PIXEL_WIDTH && pixel.width === 0) {
+        pixel = { ...pixel, width: uint(b, el) };
+      } else if (el.id === EBML_PIXEL_HEIGHT && pixel.height === 0) {
+        pixel = { ...pixel, height: uint(b, el) };
+      } else if (el.id === EBML_DISPLAY_WIDTH && display.width === 0) {
+        display = { ...display, width: uint(b, el) };
+      } else if (el.id === EBML_DISPLAY_HEIGHT && display.height === 0) {
+        display = { ...display, height: uint(b, el) };
+      } else if (el.id === EBML_TIMECODE_SCALE) {
+        scale = uint(b, el) || scale;
+      } else if (el.id === EBML_DURATION) {
+        ticks = float(b, el);
+      }
+      at = el.end;
+    }
+  };
+  scan(0, b.length, 0);
+  const width = display.width || pixel.width;
+  const height = display.height || pixel.height;
+  if (width <= 0 || height <= 0) {
+    throw new Error(
+      "no track in it declares PixelWidth and PixelHeight, so there is no picture to place"
+    );
+  }
+  const seconds = ticks === void 0 ? void 0 : sane(ticks * scale / 1e9);
+  return { width, height, ...seconds === void 0 ? {} : { seconds } };
+}
+function ebml(b, at, to) {
+  const idLen = vintLen(b[at]);
+  if (idLen === 0 || at + idLen > to) return void 0;
+  let id2 = 0;
+  for (let i = 0; i < idLen; i += 1) id2 = id2 * 256 + (b[at + i] ?? 0);
+  let p = at + idLen;
+  const sizeLen = vintLen(b[p]);
+  if (sizeLen === 0 || p + sizeLen > to) return void 0;
+  const first = b[p] ?? 0;
+  const mask = 255 >> sizeLen;
+  let size2 = first & mask;
+  let unknown = size2 === mask;
+  for (let i = 1; i < sizeLen; i += 1) {
+    const byte = b[p + i] ?? 0;
+    size2 = size2 * 256 + byte;
+    unknown = unknown && byte === 255;
+  }
+  p += sizeLen;
+  return { id: id2, body: p, end: unknown ? to : Math.min(p + size2, to) };
+}
+function vintLen(first) {
+  if (first === void 0 || first === 0) return 0;
+  let len = 1;
+  for (let mask = 128; (first & mask) === 0; mask >>= 1) len += 1;
+  return len;
+}
+function uint(b, el) {
+  let value = 0;
+  for (let at = el.body; at < el.end && at - el.body < 8; at += 1)
+    value = value * 256 + (b[at] ?? 0);
+  return value;
+}
+function float(b, el) {
+  const width = el.end - el.body;
+  if (width === 4) return b.readFloatBE(el.body);
+  if (width === 8) return b.readDoubleBE(el.body);
+  return void 0;
+}
+function sane(seconds) {
+  return Number.isFinite(seconds) && seconds > 0 && seconds < 86400 ? seconds : void 0;
+}
+async function attachClips(source, clips, dir) {
+  if (clips.length === 0) return source;
+  const assets = resolve(dir);
+  await mkdir4(assets, { recursive: true });
+  const figures = [...source.figures];
+  for (const clip3 of clips) {
+    const src = clip3.file ? await adopt(clip3.file, assets) : void 0;
+    const poster = clip3.poster ? await adopt(clip3.poster, assets) : void 0;
+    if (src === void 0 && poster === void 0) continue;
+    const at = clip3.poster === "" ? -1 : figures.findIndex((f) => f.src === clip3.poster || f.src === basename2(clip3.poster));
+    const kept = at === -1 ? void 0 : figures[at];
+    const figure = figureSchema.parse({
+      id: kept?.id ?? freeId(figures),
+      kind: "clip",
+      // The file when we hold it, and the still when we do not: `claim-figure`
+      // draws `poster` for a clip that carries an `href` and plays `src` for one
+      // that does not, and `src` is required either way.
+      src: src ?? poster,
+      caption: kept?.caption || clip3.caption,
+      width: clip3.width,
+      height: clip3.height,
+      ...kept?.sectionId === void 0 ? {} : { sectionId: kept.sectionId },
+      ...kept?.mention === void 0 ? {} : { mention: kept.mention },
+      ...poster === void 0 ? {} : { poster },
+      ...clip3.seconds === void 0 ? {} : { seconds: clip3.seconds },
+      ...clip3.href === "" ? {} : { href: clip3.href }
+    });
+    if (at === -1) figures.push(figure);
+    else figures[at] = figure;
+  }
+  return { ...source, figures };
+}
+async function adopt(file, dir) {
+  const name = basename2(file);
+  await copyFile(file, join4(dir, name));
+  return name;
+}
+function freeId(figures) {
+  const taken = new Set(figures.map((f) => f.id));
+  let n3 = figures.length + 1;
+  while (taken.has(`fig${n3}`)) n3 += 1;
+  return `fig${n3}`;
+}
+function toMarkdown(blocks) {
+  const out = [];
+  for (const item of blocks) {
+    switch (item.kind) {
+      case "heading":
+        out.push(`${"#".repeat(Math.min(Math.max(item.depth, 1), 6))} ${inline(item.text)}`);
+        break;
+      case "paragraph":
+        out.push(inline(item.text));
+        break;
+      case "code":
+        out.push(fenced(item.text));
+        break;
+      case "list":
+        out.push(
+          item.items.map((li, n3) => `${item.ordered ? `${n3 + 1}.` : "-"} ${inline(li)}`).join("\n")
+        );
+        break;
+      case "table":
+        out.push(pipes(item.columns, item.rows));
+        break;
+      case "image":
+        out.push(`![${inline(item.alt)}](${destination(item.src)})`);
+        if (item.caption || item.alt) out.push(`*${inline(item.caption || item.alt)}*`);
+        break;
+      case "video": {
+        if (item.poster) {
+          out.push(`![${inline(item.caption)}](${destination(item.poster)})`);
+          if (item.caption) out.push(`*${inline(item.caption)}*`);
+        } else if (item.caption) {
+          out.push(inline(item.caption));
+        }
+        const link = item.href || item.src;
+        if (/^https?:/i.test(link)) out.push(`Video: <${link}>`);
+        break;
+      }
+    }
+  }
+  return `${out.filter((block) => block !== "").join("\n\n")}
+`;
+}
+function inline(text2) {
+  return text2.replace(/\s+/g, " ").trim().replace(/([\\`*_[\]<>])/g, "\\$1").replace(/^(#{1,6}\s|[-+]\s)/, "\\$&").replace(/^(\d{1,9})([.)]\s)/, "$1\\$2");
+}
+function destination(path2) {
+  if (/[<>]/.test(path2)) {
+    throw new Error(
+      `cannot reference ${path2} from markdown: a path containing < or > has no spelling as a link destination. Harvest into a directory without them.`
+    );
+  }
+  return /[\s()]/.test(path2) ? `<${path2}>` : path2;
+}
+function pipes(columns2, rows) {
+  const width = Math.max(columns2.length, ...rows.map((r) => r.length), 1);
+  const cells = (row) => `| ${Array.from({ length: width }, (_, i) => inline(row[i] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`;
+  const rule = `| ${Array.from({ length: width }, () => "---").join(" | ")} |`;
+  return [cells(columns2), rule, ...rows.map(cells)].join("\n");
+}
+function fenced(code) {
+  const runs = [...code.matchAll(/`+/g)].map((m) => m[0].length + 1);
+  const fence = "`".repeat(Math.max(3, ...runs));
+  return `${fence}
+${code}
+${fence}`;
 }
 
 // src/plan/codex.ts
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile as readFile3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { spawn as spawn2 } from "node:child_process";
+import { mkdtemp, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
-import { z as z2 } from "zod";
+import { join as join5 } from "node:path";
+import { z as z3 } from "zod";
 
 // src/plan/arc.ts
 var ARC_ROLES = ["intro", "background", "limitations", "conclusion"];
@@ -6987,9 +9385,28 @@ function renderSource(source) {
   } else {
     const n3 = source.figures.length;
     out.push(`${n3 === 1 ? "1 figure" : `${n3} figures`} in this document.`);
+    if (source.figures.some((f) => f.kind === "clip")) {
+      out.push(
+        "",
+        "A CLIP is a figure whose asset is video. Cite it exactly as you cite any other",
+        "figure \u2014 `figureId` on the beat, `[figure id]` in evidence \u2014 and pick it for the",
+        "same reason: it is the picture that carries the point.",
+        "WHAT IT COSTS, and it decides whether a beat is worth spending on one: the deck",
+        "holds a clip PAUSED AND MUTED, so a viewer clicking through sees one frame until",
+        "they press play, and the rendered video shows that same frame unless the clip is",
+        "a file this deck actually holds. A clip listed as watchable only at a link is a",
+        "page whose video we could not download, and its still is all any format will ever",
+        "show. So write the beat for the FRAME: claim what the picture states, and never",
+        "narrate a motion the still does not."
+      );
+    }
     const headings = new Map(source.sections.map((s) => [s.id, s.heading]));
     for (const f of source.figures) {
-      out.push("", `[figure ${f.id}] ${f.width}x${f.height} \u2014 ${f.caption}`);
+      const size2 = f.kind === "clip" ? `CLIP ${f.width}x${f.height}${f.seconds === void 0 ? "" : `, ${Math.round(f.seconds * 10) / 10}s`}` : `${f.width}x${f.height}`;
+      out.push("", `[figure ${f.id}] ${size2} \u2014 ${f.caption}`);
+      if (f.kind === "clip" && f.href) {
+        out.push(`  watchable only at ${f.href} \u2014 the deck shows its still, never the video`);
+      }
       const heading = f.sectionId === void 0 ? void 0 : headings.get(f.sectionId);
       if (f.sectionId !== void 0) {
         out.push(`  under: [section ${f.sectionId}]${heading ? ` ${heading}` : ""}`);
@@ -7137,7 +9554,7 @@ function assertInsideResolves(storyboard, source) {
     let parts;
     try {
       const sid = `s${i}`;
-      const scene = emitScene(previous, { source, format, theme: ink, sid });
+      const scene = emitScene(previous, { source, format, theme: ink, sid, start: 0 });
       drawn = enterableIds(sid, scene.html).map((id2) => id2.replace(`${sid}-`, ""));
       parts = scene.parts;
     } catch {
@@ -7165,7 +9582,7 @@ function assertInsideResolves(storyboard, source) {
 }
 
 // src/plan/codex.ts
-var DEFAULT_TIMEOUT_MS = 10 * 6e4;
+var DEFAULT_TIMEOUT_MS2 = 10 * 6e4;
 var UNSUPPORTED = /* @__PURE__ */ new Set([
   "$schema",
   "default",
@@ -7240,26 +9657,26 @@ function hideFromPlanner(node, hidden) {
 }
 function schemaFor(prefs) {
   return hideFromPlanner(
-    forStructuredOutput(z2.toJSONSchema(storyboardSchema, { io: "input" })),
+    forStructuredOutput(z3.toJSONSchema(storyboardSchema, { io: "input" })),
     plannerInvisible(prefs)
   );
 }
 var SCHEMA = schemaFor({ genre: "general" });
 async function codexPlanner(source, opts = {}) {
   const prefs = opts.prefs ?? prefsSchema.parse({});
-  const dir = await mkdtemp(join3(tmpdir(), "decksmith-plan-"));
+  const dir = await mkdtemp(join5(tmpdir(), "decksmith-plan-"));
   try {
-    const schemaPath = join3(dir, "storyboard.schema.json");
-    const outPath = join3(dir, "storyboard.json");
-    await writeFile3(schemaPath, JSON.stringify(schemaFor(prefs)));
+    const schemaPath = join5(dir, "storyboard.schema.json");
+    const outPath = join5(dir, "storyboard.json");
+    await writeFile5(schemaPath, JSON.stringify(schemaFor(prefs)));
     await (opts.run ?? runCodex)({
       prompt: buildPrompt(source, prefs),
       schemaPath,
       outPath,
       ...opts.model === void 0 ? {} : { model: opts.model },
-      timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
     });
-    const raw2 = await readFile3(outPath, "utf8").catch(() => "");
+    const raw2 = await readFile6(outPath, "utf8").catch(() => "");
     if (raw2.trim() === "") {
       throw new Error("Codex produced no final message. Re-run, or try a shorter source.");
     }
@@ -7290,7 +9707,7 @@ ${issues}`);
     assertRefsResolve(result.data, source, { pending: prefs.images.enabled ? "allow" : "refuse" });
     return result.data;
   } finally {
-    await rm(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
   }
 }
 function buildPrompt(source, prefs) {
@@ -7332,8 +9749,8 @@ function codexCommand(args) {
 }
 function runCodex(args) {
   const { argv, env } = codexCommand(args);
-  return new Promise((resolve5, reject) => {
-    const child = spawn("codex", argv, {
+  return new Promise((resolve6, reject) => {
+    const child = spawn2("codex", argv, {
       stdio: ["pipe", "ignore", "pipe"],
       ...env === void 0 ? {} : { env }
     });
@@ -7355,7 +9772,7 @@ function runCodex(args) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (code === 0) return resolve5();
+      if (code === 0) return resolve6();
       reject(
         new Error(`codex exec exited ${code}.
 ${stderr.trim().split("\n").slice(-8).join("\n")}`)
@@ -7366,16 +9783,16 @@ ${stderr.trim().split("\n").slice(-8).join("\n")}`)
 }
 
 // src/images/illustrate.ts
-import { createHash as createHash5 } from "node:crypto";
-import { mkdir as mkdir3, readFile as readFile5, rename, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { mkdir as mkdir5, readFile as readFile8, rename, rm as rm5, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 
 // src/images/providers.ts
-import { createHash as createHash4 } from "node:crypto";
-import { mkdtemp as mkdtemp2, readFile as readFile4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { createHash as createHash6 } from "node:crypto";
+import { mkdtemp as mkdtemp2, readFile as readFile7, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join4, resolve } from "node:path";
-import { z as z3 } from "zod";
+import { join as join6, resolve as resolve2 } from "node:path";
+import { z as z4 } from "zod";
 var SIZE = {
   landscape: { width: 1536, height: 1024 },
   square: { width: 1024, height: 1024 },
@@ -7398,11 +9815,11 @@ var DEFAULT_BASE_URL = "https://api.openai.com/v1";
 var DEFAULT_MODEL = "gpt-image-2";
 var REQUEST_TIMEOUT_MS = 12e4;
 var MAX_BYTES = 16 * 1024 * 1024;
-var generatedSchema = z3.object({
-  data: z3.array(z3.object({ b64_json: z3.string().optional(), url: z3.string().optional() })).optional()
+var generatedSchema = z4.object({
+  data: z4.array(z4.object({ b64_json: z4.string().optional(), url: z4.string().optional() })).optional()
 });
-var failedSchema = z3.object({
-  error: z3.object({ code: z3.string().nullish(), type: z3.string().nullish() }).nullish()
+var failedSchema = z4.object({
+  error: z4.object({ code: z4.string().nullish(), type: z4.string().nullish() }).nullish()
 });
 function openaiImages(opts) {
   const base = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -7427,8 +9844,8 @@ function openaiImages(opts) {
         }),
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
-      const body = await readCapped(res);
-      if (!res.ok) throw new Error(`openai images: HTTP ${res.status}${reason(body)}`);
+      const body = await readCapped2(res);
+      if (!res.ok) throw new Error(`openai images: HTTP ${res.status}${reason2(body)}`);
       const first = generatedSchema.safeParse(parseJson(body)).data?.data?.[0];
       if (first?.b64_json) return raster(Buffer.from(first.b64_json, "base64"), "openai images");
       if (!first?.url) throw new Error("openai images: answer carried neither b64_json nor url");
@@ -7441,14 +9858,14 @@ function openaiImages(opts) {
         redirect: "error",
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
-      const bytes = await readCapped(picture);
+      const bytes = await readCapped2(picture);
       if (!picture.ok)
         throw new Error(`openai images: HTTP ${picture.status} fetching the picture`);
       return raster(bytes, "openai images");
     }
   };
 }
-function reason(body) {
+function reason2(body) {
   const error = failedSchema.safeParse(parseJson(body)).data?.error;
   const code = error?.code ?? error?.type;
   return code ? ` (${code})` : "";
@@ -7460,7 +9877,7 @@ function parseJson(body) {
     return void 0;
   }
 }
-async function readCapped(res) {
+async function readCapped2(res) {
   const over = `openai images: answer is over ${MAX_BYTES >> 20} MB`;
   if (Number(res.headers.get("content-length")) > MAX_BYTES) throw new Error(over);
   const reader = res.body?.getReader();
@@ -7490,10 +9907,10 @@ var ANSWER_SCHEMA = {
   required: ["ok", "file", "reason"],
   additionalProperties: false
 };
-var answerSchema = z3.object({
-  ok: z3.boolean(),
-  file: z3.string().nullish(),
-  reason: z3.string().nullish()
+var answerSchema = z4.object({
+  ok: z4.boolean(),
+  file: z4.string().nullish(),
+  reason: z4.string().nullish()
 });
 function codexImages(opts = {}) {
   const run4 = opts.run ?? runCodex;
@@ -7506,11 +9923,11 @@ function codexImages(opts = {}) {
     async check() {
     },
     async generate(req) {
-      const dir = await mkdtemp2(join4(tmpdir2(), "decksmith-image-"));
+      const dir = await mkdtemp2(join6(tmpdir2(), "decksmith-image-"));
       try {
-        const schemaPath = join4(dir, "answer.schema.json");
-        const outPath = join4(dir, "answer.json");
-        await writeFile4(schemaPath, JSON.stringify(ANSWER_SCHEMA));
+        const schemaPath = join6(dir, "answer.schema.json");
+        const outPath = join6(dir, "answer.json");
+        await writeFile6(schemaPath, JSON.stringify(ANSWER_SCHEMA));
         await run4({
           prompt: codexPrompt(req),
           schemaPath,
@@ -7519,7 +9936,7 @@ function codexImages(opts = {}) {
           cwd: dir,
           sandbox: "workspace-write"
         });
-        const raw2 = await readFile4(outPath, "utf8").catch(() => "");
+        const raw2 = await readFile7(outPath, "utf8").catch(() => "");
         const answer = answerSchema.safeParse(parseJson(Buffer.from(raw2)));
         if (!answer.success) throw new Error("codex could not generate a picture: no final answer");
         if (!answer.data.ok) {
@@ -7527,15 +9944,15 @@ function codexImages(opts = {}) {
             `codex could not generate a picture: ${answer.data.reason ?? "no reason given"}`
           );
         }
-        const candidates2 = [join4(dir, "picture.png")];
-        if (answer.data.file) candidates2.push(resolve(dir, answer.data.file));
+        const candidates2 = [join6(dir, "picture.png")];
+        if (answer.data.file) candidates2.push(resolve2(dir, answer.data.file));
         for (const path2 of candidates2) {
-          const bytes = await readFile4(path2).catch(() => null);
+          const bytes = await readFile7(path2).catch(() => null);
           if (bytes) return raster(bytes, "codex");
         }
         throw new Error("codex said ok but wrote no picture.png");
       } finally {
-        await rm2(dir, { recursive: true, force: true });
+        await rm4(dir, { recursive: true, force: true });
       }
     }
   };
@@ -7570,7 +9987,7 @@ function mulberry32(seed) {
 }
 function drawSvg(req) {
   const { width: W, height: H } = SIZE[req.aspect];
-  const seed = createHash4("sha256").update([req.prompt, req.style, req.aspect].join("|")).digest();
+  const seed = createHash6("sha256").update([req.prompt, req.style, req.aspect].join("|")).digest();
   const rand = mulberry32(seed.readUInt32BE(0));
   const accent = ACCENTS[Math.floor(rand() * ACCENTS.length)];
   const count = 6 + Math.floor(rand() * 5);
@@ -7601,11 +10018,6 @@ function drawSvg(req) {
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${W} ${H}" width="${W}" height="${H}">${parts.join("")}</svg>
 `;
 }
-function svgSize(bytes) {
-  const m = /viewBox="0 0 (\d+) (\d+)"/.exec(bytes.toString("utf8", 0, 200));
-  if (!m) throw new Error("svg has no viewBox");
-  return { width: Number(m[1]), height: Number(m[2]) };
-}
 function toolSvg() {
   return {
     id: "svg",
@@ -7649,7 +10061,7 @@ function imageChain(images, backend) {
 }
 
 // src/images/illustrate.ts
-var EXT = {
+var EXT2 = {
   "image/png": ".png",
   "image/jpeg": ".jpg",
   "image/svg+xml": ".svg"
@@ -7667,7 +10079,7 @@ async function illustrate(storyboard, source, opts) {
   const tool = last?.id === "svg" ? last : toolSvg();
   if (tool !== last) chain.push(tool);
   const dropped = /* @__PURE__ */ new Set();
-  if (pending.length > 0) await mkdir3(opts.assetsDir, { recursive: true });
+  if (pending.length > 0) await mkdir5(opts.assetsDir, { recursive: true });
   for (const [i, slot] of pending.entries()) {
     let rungs = chain;
     if (i >= images.max) {
@@ -7687,6 +10099,9 @@ async function illustrate(storyboard, source, opts) {
         const picture = await draw(provider, req, name, opts.assetsDir);
         const figure = {
           id: slot.figureId,
+          // An illustration is always a still: every provider draws a picture,
+          // and there is no rung that returns a video.
+          kind: "image",
           src: picture.src,
           caption: slot.brief.caption,
           width: picture.width,
@@ -7705,8 +10120,8 @@ async function illustrate(storyboard, source, opts) {
       } catch (err) {
         const after = live[j + 1];
         if (!after) throw err;
-        const why2 = err instanceof Error ? err.message : String(err);
-        step(`illustrate: ${slot.label} via ${provider.id} failed (${why2}); trying ${after.id}`);
+        const why3 = err instanceof Error ? err.message : String(err);
+        step(`illustrate: ${slot.label} via ${provider.id} failed (${why3}); trying ${after.id}`);
         dropped.add(provider.id);
       }
     }
@@ -7756,36 +10171,36 @@ function slots(storyboard, known) {
   return out;
 }
 function cacheKey(providerId, req) {
-  return createHash5("sha256").update(["v1", providerId, req.model ?? "", req.aspect, req.style, req.prompt].join("\n")).digest("hex");
+  return createHash7("sha256").update(["v1", providerId, req.model ?? "", req.aspect, req.style, req.prompt].join("\n")).digest("hex");
 }
 async function draw(provider, req, name, dir) {
-  for (const ext of Object.values(EXT)) {
+  for (const ext of Object.values(EXT2)) {
     const src2 = `${name}${ext}`;
-    const bytes = await readFile5(join5(dir, src2)).catch(() => null);
-    if (bytes) return { src: src2, ...sizeOf(bytes, ext), cached: true };
+    const bytes = await readFile8(join7(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}${EXT[img.mime]}`;
-  const tmp = join5(dir, `.${name}.tmp`);
+  const src = `${name}${EXT2[img.mime]}`;
+  const tmp = join7(dir, `.${name}.tmp`);
   try {
-    await writeFile5(tmp, img.bytes);
-    await rename(tmp, join5(dir, src));
+    await writeFile7(tmp, img.bytes);
+    await rename(tmp, join7(dir, src));
   } finally {
-    await rm3(tmp, { force: true });
+    await rm5(tmp, { force: true });
   }
   return { src, width: img.width, height: img.height, cached: false };
 }
-function sizeOf(bytes, ext) {
+function sizeOf2(bytes, ext) {
   return ext === ".svg" ? svgSize(bytes) : imageSize(bytes);
 }
 
 // src/narrate/tts.ts
-import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import { mkdir as mkdir4, readFile as readFile6, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join as join6 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { createHash as createHash8 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile9, rm as rm6, writeFile as writeFile8 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join8 } from "node:path";
 var MISSING = [
   "edge-tts is not installed, so narration cannot be synthesised.",
   "",
@@ -7796,14 +10211,14 @@ var MISSING = [
 ].join("\n");
 function candidates() {
   const env = process.env.DECKSMITH_EDGE_TTS?.trim();
-  const home = homedir();
+  const home = homedir2();
   return [
     ...env ? [[env]] : [],
     ["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.
-    [join6(home, "Library", "Python", "3.9", "bin", "edge-tts")],
-    [join6(home, ".local", "bin", "edge-tts")],
+    [join8(home, "Library", "Python", "3.9", "bin", "edge-tts")],
+    [join8(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"]
@@ -7817,19 +10232,19 @@ async function answersHelp(argv) {
 }
 var resolved = null;
 function resolveEdgeTts(can = answersHelp) {
-  if (can !== answersHelp) return find(can);
-  resolved ??= find(can);
+  if (can !== answersHelp) return find2(can);
+  resolved ??= find2(can);
   return resolved;
 }
-async function find(can) {
+async function find2(can) {
   for (const argv of candidates()) {
     if (await can(argv)) return argv;
   }
   throw new Error(MISSING);
 }
 function runArgv(cmd, args) {
-  return new Promise((resolve5) => {
-    const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+  return new Promise((resolve6) => {
+    const child = spawn3(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (b) => {
@@ -7838,8 +10253,8 @@ function runArgv(cmd, args) {
     child.stderr.on("data", (b) => {
       stderr += b.toString();
     });
-    child.on("error", (e) => resolve5({ code: -1, stderr: String(e), stdout }));
-    child.on("close", (code) => resolve5({ code: code ?? -1, stderr, stdout }));
+    child.on("error", (e) => resolve6({ code: -1, stderr: String(e), stdout }));
+    child.on("close", (code) => resolve6({ code: code ?? -1, stderr, stdout }));
   });
 }
 var edgeTts = {
@@ -7906,8 +10321,8 @@ function edgeProvider(runner = edgeTts) {
     async speak(req) {
       const subs = `${req.audio.replace(/\.mp3$/, "")}.srt`;
       await runner.speak({ ...req, subs });
-      const raw2 = await readFile6(subs, "utf8").catch(() => "");
-      await rm4(subs, { force: true });
+      const raw2 = await readFile9(subs, "utf8").catch(() => "");
+      await rm6(subs, { force: true });
       const cues = parseCues(raw2);
       const measured = await runner.measure(req.audio);
       const lastCue = cues.length > 0 ? cues[cues.length - 1].end : 0;
@@ -7928,7 +10343,7 @@ function resolveProvider(name = process.env.DECKSMITH_TTS ?? "edge-tts") {
   return make();
 }
 function cacheKey2(text2, voice, rate, pitch) {
-  return createHash6("sha256").update([text2, voice, rate, pitch].join("\0")).digest("hex").slice(0, 16);
+  return createHash8("sha256").update([text2, voice, rate, pitch].join("\0")).digest("hex").slice(0, 16);
 }
 async function synthesize(text2, opts) {
   const rate = opts.rate ?? "+0%";
@@ -7936,11 +10351,11 @@ 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 = join6(opts.dir, file);
-  const sidecar = join6(opts.dir, `${key}.json`);
+  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 };
-  await mkdir4(opts.dir, { recursive: true });
+  await mkdir6(opts.dir, { recursive: true });
   const spoken = await provider.speak({ text: text2, voice: opts.voice, rate, pitch, audio });
   const { cues, seconds } = spoken;
   const clamped = cues.map((c) => ({
@@ -7949,13 +10364,13 @@ async function synthesize(text2, opts) {
     text: c.text
   }));
   const body = { seconds, cues: clamped, text: text2, voice: opts.voice };
-  await writeFile6(sidecar, `${JSON.stringify(body, null, 2)}
+  await writeFile8(sidecar, `${JSON.stringify(body, null, 2)}
 `);
   return { audio, file, seconds, cues: clamped };
 }
 async function readSidecar(path2) {
   try {
-    const parsed = JSON.parse(await readFile6(path2, "utf8"));
+    const parsed = JSON.parse(await readFile9(path2, "utf8"));
     const s = parsed;
     return typeof s?.seconds === "number" && s.seconds > 0 && Array.isArray(s.cues) ? s : null;
   } catch {
@@ -8011,7 +10426,7 @@ function stopCount(holds) {
   return Math.max(1, usable.size);
 }
 function stopsFor(beat, source, format, sid = "s1") {
-  const ctx = { source, format, theme: ink, sid };
+  const ctx = { source, format, theme: ink, sid, start: 0 };
   try {
     return stopCount(emitScene(beat, ctx).holds);
   } catch {
@@ -8050,7 +10465,7 @@ async function narrate(storyboard, source, prefs, opts) {
   for (const [i, beat] of storyboard.beats.entries()) {
     const text2 = beat.narration?.trim();
     if (!text2) continue;
-    const segments = [];
+    const segments2 = [];
     const stops = Math.min(stopsFor(beat, source, format, `s${i + 1}`), paced.speakingStops);
     const plan = planSegments(text2, stops);
     for (const [stop, line2] of plan.entries()) {
@@ -8062,7 +10477,7 @@ async function narrate(storyboard, source, prefs, opts) {
         dir: opts.dir,
         runner: opts.runner
       });
-      segments.push({
+      segments2.push({
         stop,
         text: line2,
         // Content-addressed and flat, so the path is the filename and the deck
@@ -8072,14 +10487,14 @@ async function narrate(storyboard, source, prefs, opts) {
         cues: speech.cues
       });
     }
-    if (segments.length > 0) beats[beat.id] = segments;
+    if (segments2.length > 0) beats[beat.id] = segments2;
   }
   return { voice, beats };
 }
 
 // src/verify/index.ts
-import { readdir as readdir2, readFile as readFile11 } from "node:fs/promises";
-import { join as join11, relative, sep } from "node:path";
+import { readdir as readdir3, readFile as readFile13 } from "node:fs/promises";
+import { join as join12, relative, sep } from "node:path";
 
 // src/verify/budget.ts
 function readCanvas(html) {
@@ -8185,24 +10600,24 @@ function clock2(seconds) {
 }
 
 // src/verify/check.ts
-import { execFile } from "node:child_process";
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import { promisify } from "node:util";
-var run = promisify(execFile);
-var DEFAULT_TIMEOUT_MS2 = 24e4;
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile10 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var run2 = promisify2(execFile2);
+var DEFAULT_TIMEOUT_MS3 = 24e4;
 var DEFAULT_SAMPLES = 9;
 var GATES = ["lint", "runtime", "layout", "motion", "contrast"];
 var SEVERITIES = /* @__PURE__ */ new Set(["error", "warning", "info"]);
 async function check(dir, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const args = ["hyperframes", "check", "--json", dir];
   if (opts.snapshots) args.push("--snapshots");
   const started = Date.now();
   const { transit, duration } = await readComposition(dir);
   if (opts.at?.length) args.push(`--at=${sampleTimes(opts.at, duration).join(",")}`);
   try {
-    const { stdout, stderr } = await run("npx", args, { timeout: timeoutMs, maxBuffer: 32 << 20 });
+    const { stdout, stderr } = await run2("npx", args, { timeout: timeoutMs, maxBuffer: 32 << 20 });
     return interpret(stdout, stderr, { timeoutMs, elapsed: Date.now() - started, transit });
   } catch (err) {
     const e = err;
@@ -8217,7 +10632,7 @@ async function check(dir, opts = {}) {
 async function readComposition(dir) {
   let html;
   try {
-    html = await readFile7(join7(dir, "index.html"), "utf8");
+    html = await readFile10(join9(dir, "index.html"), "utf8");
   } catch {
     return { transit: [], duration: 0 };
   }
@@ -8301,11 +10716,11 @@ function regrade({ f, time, selector }, transit = []) {
       (w) => time > w.t0 && time < w.t1 && (named === void 0 || named === w.sid)
     );
     if (hit) {
-      const why2 = named === hit.sid ? `no stop of ${hit.sid} is inside this window` : "the element names no scene, so this is excused on time alone";
+      const why3 = named === hit.sid ? `no stop of ${hit.sid} is inside this window` : "the element names no scene, so this is excused on time alone";
       return {
         ...f,
         severity: "info",
-        message: `${f.message} \u2014 accepted: mid-camera-move, ${why2}.`
+        message: `${f.message} \u2014 accepted: mid-camera-move, ${why3}.`
       };
     }
     return { ...f, severity: "error" };
@@ -8318,7 +10733,7 @@ function regrade({ f, time, selector }, transit = []) {
 var OFF_CANVAS = /* @__PURE__ */ new Set(["canvas_overflow", "panel_out_of_canvas", "text_occluded"]);
 function toFinding(gate, f) {
   const severity = typeof f.severity === "string" && SEVERITIES.has(f.severity) ? f.severity : "warning";
-  const message = str(f.message) ?? "(no message)";
+  const message2 = str(f.message) ?? "(no message)";
   const time = typeof f.time === "number" && f.time > 0 ? f.time : void 0;
   const at = time !== void 0 ? `t=${time}s` : void 0;
   const where2 = [str(f.selector) ?? str(f.containerSelector), at].filter(Boolean).join(" ");
@@ -8329,7 +10744,7 @@ function toFinding(gate, f) {
       rule: str(f.code) ?? "unknown",
       // "Text extends outside the composition canvas." is unactionable without the
       // element it happened to, and Finding has nowhere else to put it.
-      message: where2 ? `${message} [${where2}]` : message
+      message: where2 ? `${message2} [${where2}]` : message2
     },
     time,
     selector: str(f.selector) ?? str(f.containerSelector)
@@ -8343,8 +10758,8 @@ function staticGuardFindings(stderr) {
     message: line2.slice("[StaticGuard]".length).trim()
   }));
 }
-function tooling(rule, message) {
-  return { severity: "error", gate: "check", rule, message };
+function tooling(rule, message2) {
+  return { severity: "error", gate: "check", rule, message: message2 };
 }
 function readJson(stdout) {
   const first = stdout.indexOf("{");
@@ -8368,87 +10783,8 @@ function tail(s) {
 }
 
 // src/verify/fidelity.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-
-// src/render/capture.ts
-import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
-import { createRequire } 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;
-  const { getInstalledBrowsers } = await import("@puppeteer/browsers");
-  const cacheDir = process.env.PUPPETEER_CACHE_DIR || join8(homedir2(), ".cache", "puppeteer");
-  const installed = await getInstalledBrowsers({ cacheDir }).catch(() => []);
-  const found = installed.find((b) => b.browser === "chrome-headless-shell") ?? installed.find((b) => b.browser === "chrome");
-  if (found) return found.executablePath;
-  throw new Error(
-    `no Chrome to ${need} \u2014 run \`npx puppeteer browsers install chrome\`, or set DECKSMITH_CHROME to a Chrome binary.`
-  );
-}
-function runtimePath() {
-  return createRequire(import.meta.url).resolve("hyperframes/dist/hyperframe.runtime.iife.js");
-}
-function renderSeek(t2) {
-  const player = window.__player;
-  player.renderSeek(t2, { suppressEvents: true });
-}
-async function openDeck(dir, opts = {}) {
-  const index = join8(dir, "index.html");
-  const html = await readFile8(index, "utf8").catch(() => null);
-  if (html === null) throw new Error(`no index.html in ${dir}`);
-  const width = Number(/data-width="(\d+)"/.exec(html)?.[1] ?? 0);
-  const height = Number(/data-height="(\d+)"/.exec(html)?.[1] ?? 0);
-  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 browser = await puppeteer.launch({
-    executablePath: await chromePath(),
-    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"]
-  });
-  try {
-    const page = await browser.newPage();
-    await page.evaluateOnNewDocument("self.__name = self.__name || ((fn) => fn);");
-    await page.setViewport({ width, height, deviceScaleFactor: 1 });
-    await page.goto(pathToFileURL(index).href, { waitUntil: "load", timeout });
-    await page.addScriptTag({ path: runtimePath() });
-    await page.waitForFunction(
-      // The composition registers a paused timeline per scene and a spanning
-      // `main` that carries no motion, so seeking `main` directly moves nothing.
-      // Only the runtime knows the per-scene offsets; wait for it.
-      "typeof window.__player?.renderSeek === 'function'",
-      { timeout }
-    );
-    await page.evaluate(() => document.fonts.ready);
-    const cdp = await page.createCDPSession();
-    return {
-      width,
-      height,
-      page,
-      seek: (t2) => page.evaluate(renderSeek, t2),
-      shoot: async () => {
-        const shot = await cdp.send("Page.captureScreenshot", {
-          format: "png",
-          fromSurface: true,
-          captureBeyondViewport: false,
-          clip: { x: 0, y: 0, width, height, scale: 1 }
-        });
-        return Buffer.from(shot.data, "base64");
-      },
-      close: () => browser.close()
-    };
-  } catch (err) {
-    await browser.close().catch(() => {
-    });
-    throw err;
-  }
-}
+import { readFile as readFile11 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // src/verify/typefloor.ts
 var TYPE_FLOOR_PX = 40;
@@ -8502,7 +10838,7 @@ function svgZones(html) {
   return zones;
 }
 function userUnit(zones, at) {
-  return zones.filter((z4) => at >= z4.start && at < z4.end).reduce((unit, z4) => unit * z4.unit, 1);
+  return zones.filter((z5) => at >= z5.start && at < z5.end).reduce((unit, z5) => unit * z5.unit, 1);
 }
 function where(html, at) {
   const open = html.lastIndexOf("<", at);
@@ -8882,21 +11218,21 @@ function captionBottom(sid, selector, fallbackPx) {
 async function fidelity(dir, opts = {}) {
   const started = Date.now();
   const floor = opts.floor ?? INK_FLOOR;
-  const notMeasured = (why2) => ({
+  const notMeasured = (why3) => ({
     stops: [],
     findings: [
       {
         severity: "warning",
         gate: "fidelity",
         rule: "not_measured",
-        message: `did not check whether each stop draws anything: ${why2}`
+        message: `did not check whether each stop draws anything: ${why3}`
       }
     ],
     elapsedMs: Date.now() - started
   });
   const stops = opts.stops ?? readStops(
-    await readFile9(join9(dir, TIMING_FILE), "utf8").catch(() => null),
-    await readFile9(join9(dir, DECK_PAGE), "utf8").catch(() => null)
+    await readFile11(join10(dir, TIMING_FILE), "utf8").catch(() => null),
+    await readFile11(join10(dir, DECK_PAGE), "utf8").catch(() => null)
   );
   if (stops.length === 0) return notMeasured("the deck declares no stops");
   let deck = null;
@@ -8952,13 +11288,13 @@ async function fidelity(dir, opts = {}) {
 }
 
 // src/verify/drift.ts
-import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
-import { mkdtemp as mkdtemp3, readdir, readFile as readFile10, rm as rm5 } from "node:fs/promises";
+import { execFile as execFile3 } from "node:child_process";
+import { createHash as createHash9 } from "node:crypto";
+import { mkdtemp as mkdtemp3, readdir as readdir2, readFile as readFile12, rm as rm7 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var run2 = promisify2(execFile2);
+import { join as join11 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
 var FLOOR_DB = 40;
 var COMPOSITION_PAGE = "index.html";
 var DEFAULT_RENDER_TIMEOUT_MS = 18e5;
@@ -8995,13 +11331,13 @@ 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(join10(tmpdir3(), "decksmith-drift-"));
-  const a = join10(work, "a");
-  const b = join10(work, "b");
+  const work = opts.workDir ?? await mkdtemp3(join11(tmpdir3(), "decksmith-drift-"));
+  const a = join11(work, "a");
+  const b = join11(work, "b");
   const report = await compare(dir, a, b, mode, floorDb, opts);
   const keep = opts.keep || !report.passed;
   if (keep) report.kept = { a, b };
-  else if (!opts.workDir) await rm5(work, { recursive: true, force: true });
+  else if (!opts.workDir) await rm7(work, { recursive: true, force: true });
   return report;
 }
 async function compare(dir, a, b, mode, floorDb, opts) {
@@ -9016,11 +11352,11 @@ async function compare(dir, a, b, mode, floorDb, opts) {
     [a, "first"],
     [b, "second"]
   ].entries()) {
-    const why2 = await render(dir, out, { ...opts, workers: counts[i] });
-    if (why2)
+    const why3 = await render(dir, out, { ...opts, workers: counts[i] });
+    if (why3)
       return {
         passed: false,
-        findings: [finding("render_failed", `The ${label} render of ${dir} failed: ${why2}`)],
+        findings: [finding("render_failed", `The ${label} render of ${dir} failed: ${why3}`)],
         ...empty
       };
   }
@@ -9052,11 +11388,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(join10(a, name));
+    const one = await sha(join11(a, name));
     ha.push(one);
-    if (one !== await sha(join10(b, name))) differing.push(i + 1);
+    if (one !== await sha(join11(b, name))) differing.push(i + 1);
   }
-  const html = await readFile10(join10(dir, COMPOSITION_PAGE), "utf8").catch(() => "");
+  const html = await readFile12(join11(dir, COMPOSITION_PAGE), "utf8").catch(() => "");
   const motion = measureMotion(ha, readScenes(html), readCanvas(html)?.seconds ?? 0);
   let worst;
   if (differing.length > 0) {
@@ -9156,7 +11492,7 @@ async function render(dir, out, opts) {
   ];
   if (opts.workers !== void 0) args.push("-w", String(opts.workers));
   try {
-    await run2("npx", args, {
+    await run3("npx", args, {
       timeout: opts.timeoutMs ?? DEFAULT_RENDER_TIMEOUT_MS,
       maxBuffer: 32 << 20
     });
@@ -9167,11 +11503,11 @@ async function render(dir, out, opts) {
   }
 }
 async function frames(dir) {
-  const names = await readdir(dir).catch(() => []);
+  const names = await readdir2(dir).catch(() => []);
   return names.filter((n3) => n3.endsWith(".png")).sort();
 }
 async function sha(file) {
-  return createHash7("sha256").update(await readFile10(file)).digest("hex");
+  return createHash9("sha256").update(await readFile12(file)).digest("hex");
 }
 var STAT = /^n:(\d+)\b.*\bpsnr_avg:(inf|-?[\d.]+)/;
 function framePattern(name) {
@@ -9195,7 +11531,7 @@ async function psnr(a, b, firstFrame) {
   if (!seq) return { error: `Cannot read a frame-number pattern out of "${firstFrame}".` };
   let stdout;
   try {
-    ({ stdout } = await run2(
+    ({ stdout } = await run3(
       "ffmpeg",
       [
         "-hide_banner",
@@ -9204,11 +11540,11 @@ async function psnr(a, b, firstFrame) {
         "-start_number",
         String(seq.start),
         "-i",
-        join10(a, seq.pattern),
+        join11(a, seq.pattern),
         "-start_number",
         String(seq.start),
         "-i",
-        join10(b, seq.pattern),
+        join11(b, seq.pattern),
         "-lavfi",
         "psnr=stats_file=-",
         "-f",
@@ -9250,11 +11586,11 @@ function moved(motion) {
   const rest = motion.unmeasured.length > 0 ? ` ${motion.unmeasured.length} scene(s) had too few frames of their own to judge: ${motion.unmeasured.join(", ")}.` : "";
   return ` All ${measured} measurable scene(s) moved within their own window.${rest}`;
 }
-function finding(rule, message) {
-  return { severity: "error", gate: "drift", rule, message };
+function finding(rule, message2) {
+  return { severity: "error", gate: "drift", rule, message: message2 };
 }
-function note(message) {
-  return { severity: "info", gate: "drift", rule: "stable", message };
+function note(message2) {
+  return { severity: "info", gate: "drift", rule: "stable", message: message2 };
 }
 function tail2(s) {
   return s.trim().split("\n").slice(-3).join(" / ").slice(0, 400);
@@ -9262,18 +11598,28 @@ function tail2(s) {
 
 // src/verify/index.ts
 var NONDETERMINISM = [
-  [/\bMath\.random\s*\(/, "math_random"],
-  [/\bDate\.now\s*\(/, "date_now"],
-  [/\bnew\s+Date\s*\(\s*\)/, "date_now"],
-  [/\bperformance\.now\s*\(/, "performance_now"],
-  [/\bfetch\s*\(/, "runtime_fetch"],
-  [/\bXMLHttpRequest\b/, "runtime_fetch"]
+  [/\bMath\.random\s*\(/, "math_random", "calls"],
+  [/\bDate\.now\s*\(/, "date_now", "calls"],
+  [/\bnew\s+Date\s*\(\s*\)/, "date_now", "calls"],
+  [/\bperformance\.now\s*\(/, "performance_now", "calls"],
+  [/\bfetch\s*\(/, "runtime_fetch", "calls"],
+  [/\bXMLHttpRequest\b/, "runtime_fetch", "calls"],
+  // The TAG, matched with a word boundary so `<iframes>` and the word "iframe"
+  // in a comment or a `createElement("iframe")` in the wrapper's own runtime are
+  // not it. `deck.html` is never scanned at all (`readCompositions`), which is
+  // what keeps the player's own frame out of this.
+  [
+    /<iframe\b/i,
+    "third_party_iframe",
+    "embeds",
+    "Bake what the frame was showing into the deck instead: a still as a figure, or a clip claim-figure can play."
+  ]
 ];
 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 readFile11(join11(dir, DECK_PAGE), "utf8").catch(() => ""),
+    await readFile13(join12(dir, DECK_PAGE), "utf8").catch(() => ""),
     await listFiles(dir)
   );
   const budget2 = html.flatMap(([, text2]) => scanBudget(text2, storyboard, kept));
@@ -9310,8 +11656,8 @@ async function verify(dir, opts = {}, storyboard, kept, source) {
 }
 async function declaredStops(dir) {
   return readStops(
-    await readFile11(join11(dir, TIMING_FILE), "utf8").catch(() => null),
-    await readFile11(join11(dir, DECK_PAGE), "utf8").catch(() => null)
+    await readFile13(join12(dir, TIMING_FILE), "utf8").catch(() => null),
+    await readFile13(join12(dir, DECK_PAGE), "utf8").catch(() => null)
   );
 }
 var NARRATION_ISLAND = /<script type="application\/decksmith-narration\+json">([\s\S]*?)<\/script>/;
@@ -9334,8 +11680,8 @@ function scanNarration(page, files) {
   const dir = typeof parsed.dir === "string" && parsed.dir ? `${parsed.dir}/` : "";
   const scenes = parsed.scenes ?? {};
   const missing = /* @__PURE__ */ new Set();
-  for (const segments of Object.values(scenes)) {
-    for (const s of segments ?? []) {
+  for (const segments2 of Object.values(scenes)) {
+    for (const s of segments2 ?? []) {
       if (typeof s?.audio !== "string" || /^[a-z][a-z0-9+.-]*:|^\//i.test(s.audio)) continue;
       if (!files.has(`${dir}${s.audio}`)) missing.add(s.audio);
     }
@@ -9351,7 +11697,7 @@ function scanNarration(page, files) {
   ];
 }
 async function readTiming(dir) {
-  const raw2 = await readFile11(join11(dir, TIMING_FILE), "utf8").catch(() => "");
+  const raw2 = await readFile13(join12(dir, TIMING_FILE), "utf8").catch(() => "");
   if (!raw2) return void 0;
   try {
     const parsed = JSON.parse(raw2);
@@ -9361,9 +11707,9 @@ async function readTiming(dir) {
   }
 }
 async function listFiles(dir) {
-  const entries = await readdir2(dir, { recursive: true, withFileTypes: true }).catch(() => []);
+  const entries = await readdir3(dir, { recursive: true, withFileTypes: true }).catch(() => []);
   return new Set(
-    entries.filter((e) => e.isFile()).map((e) => relative(dir, join11(e.parentPath, e.name)).split(sep).join("/"))
+    entries.filter((e) => e.isFile()).map((e) => relative(dir, join12(e.parentPath, e.name)).split(sep).join("/"))
   );
 }
 var INSTEAD = {
@@ -9489,20 +11835,20 @@ function scanBeatCount(storyboard, prefs) {
   ];
 }
 function scanPaperArc(storyboard, prefs) {
-  return arcProblems(storyboard, prefs).map((message) => ({
+  return arcProblems(storyboard, prefs).map((message2) => ({
     severity: "warning",
     gate: "storyboard",
     rule: "paper_arc",
-    message
+    message: message2
   }));
 }
 function scanNarrationDrift(storyboard, narration) {
   const flat = (s) => (s ?? "").replace(/\s+/g, " ").trim();
   const stale = [];
   for (const beat of storyboard.beats) {
-    const segments = narration.beats[beat.id];
-    if (!segments?.length || !flat(beat.narration)) continue;
-    if (flat(segments.map((s) => s.text).join(" ")) !== flat(beat.narration)) stale.push(beat.id);
+    const segments2 = narration.beats[beat.id];
+    if (!segments2?.length || !flat(beat.narration)) continue;
+    if (flat(segments2.map((s) => s.text).join(" ")) !== flat(beat.narration)) stale.push(beat.id);
   }
   if (!stale.length) return [];
   return [
@@ -9547,8 +11893,8 @@ function scanNarrationLead(beats, timing) {
   }
   return findings;
 }
-function firstMention(segments, label) {
-  for (const segment of segments) {
+function firstMention(segments2, label) {
+  for (const segment of segments2) {
     for (const cue of segment.cues) {
       const words2 = cue.text.split(/\s+/);
       let at = 0;
@@ -9606,35 +11952,35 @@ var STOP = /* @__PURE__ */ new Set([
 function scanDeterminism(html, file) {
   const findings = [];
   const lines = html.split("\n");
-  for (const [pattern, rule] of NONDETERMINISM) {
+  for (const [pattern, rule, verb, remedy2] of NONDETERMINISM) {
     const i = lines.findIndex((line2) => pattern.test(line2));
     if (i < 0) continue;
     findings.push({
       severity: "error",
       gate: "determinism",
       rule,
-      message: `${file}:${i + 1} calls \`${lines[i]?.match(pattern)?.[0]}\` at render time, so two renders of this deck will not be identical.`
+      message: `${file}:${i + 1} ${verb} \`${lines[i]?.match(pattern)?.[0]}\` at render time, so two renders of this deck will not be identical.` + (remedy2 ? ` ${remedy2}` : "")
     });
   }
   return findings;
 }
 async function readCompositions(dir) {
-  const entries = await readdir2(dir, { recursive: true, withFileTypes: true }).catch(() => []);
+  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) => join11(e.parentPath, e.name));
+  ).map((e) => join12(e.parentPath, e.name));
   return Promise.all(
-    files.map(async (f) => [relative(dir, f), await readFile11(f, "utf8")])
+    files.map(async (f) => [relative(dir, f), await readFile13(f, "utf8")])
   );
 }
 
 // src/render/render.ts
-import { mkdir as mkdir7, readFile as readFile12, rename as rename2, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
-import { basename, dirname, join as join13, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile14, rename as rename2, rm as rm8, writeFile as writeFile10 } from "node:fs/promises";
+import { basename as basename3, dirname, join as join14, resolve as resolve3 } from "node:path";
 
 // src/render/captions.ts
-import { mkdir as mkdir6, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { mkdir as mkdir7, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var DECK_FONT_CSS = "assets/fonts/fonts.css";
 function cssString(value) {
@@ -9690,7 +12036,7 @@ ${bands}
 </div>
 `;
 }
-function measure2(count) {
+function measure3(count) {
   const doc = document;
   const probe2 = doc.getElementById("c0");
   if (probe2) {
@@ -9710,255 +12056,89 @@ function measure2(count) {
     const r = el.querySelector("span").getBoundingClientRect();
     el.classList.remove("on");
     rects.push({ x: r.x, y: r.y, w: r.width, h: r.height });
-  }
-  return rects;
-}
-var CAPTION_NEED = "draw the captions with (`render` needs one for the capture too)";
-async function captionBlocker() {
-  try {
-    await import("puppeteer-core");
-    await chromePath(CAPTION_NEED);
-    return null;
-  } catch (err) {
-    return err instanceof Error ? err.message : String(err);
-  }
-}
-async function renderCaptions(cues, style, deck, work) {
-  if (cues.length === 0) throw new Error("renderCaptions was given no cues.");
-  const fontCss = join12(deck, DECK_FONT_CSS);
-  const href = await import("node:fs/promises").then((fs) => fs.stat(fontCss).catch(() => null)) ? pathToFileURL2(fontCss).href : null;
-  const page = join12(work, "captions.html");
-  await mkdir6(work, { recursive: true });
-  await writeFile8(page, captionPage(cues, style, href));
-  const { default: puppeteer } = await import("puppeteer-core");
-  const browser = await puppeteer.launch({
-    executablePath: await chromePath(CAPTION_NEED),
-    headless: true,
-    args: ["--force-device-scale-factor=1", "--hide-scrollbars"]
-  });
-  try {
-    const tab = await browser.newPage();
-    await tab.setViewport({ width: style.width, height: style.height, deviceScaleFactor: 1 });
-    await tab.goto(pathToFileURL2(page).href, { waitUntil: "load" });
-    await tab.evaluate(() => document.fonts.ready);
-    const rects = await tab.evaluate(measure2, cues.length);
-    const box = union(rects);
-    const files = [];
-    for (const [i, cue] of cues.entries()) {
-      void cue;
-      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: join12(work, name),
-        type: "png",
-        omitBackground: true,
-        clip: { x: box.x, y: box.y, width: box.width, height: box.height }
-      });
-      await tab.evaluate((id2) => document.getElementById(id2)?.classList.remove("on"), `c${i}`);
-      files.push(name);
-    }
-    return { files, ...box };
-  } finally {
-    await browser.close();
-  }
-}
-function union(rects) {
-  const left = Math.floor(Math.min(...rects.map((r) => r.x)));
-  const top = Math.floor(Math.min(...rects.map((r) => r.y)));
-  const right = Math.ceil(Math.max(...rects.map((r) => r.x + r.w)));
-  const bottom = Math.ceil(Math.max(...rects.map((r) => r.y + r.h)));
-  return { x: left, y: top, width: right - left, height: bottom - top };
-}
-var t3 = (seconds) => seconds.toFixed(3);
-function overlayGraph(cues, band, input = "0:v", output = "vout") {
-  return cues.map((cue, i) => {
-    const from = i === 0 ? `[${input}]` : `[v${i}]`;
-    const to = i === cues.length - 1 ? `[${output}]` : `[v${i + 1}]`;
-    const enable = `enable='gte(t,${t3(cue.start)})*lt(t,${t3(cue.end)})'`;
-    return `${from}[${i + 1}:v]overlay=x=${band.x}:y=${band.y}:format=yuv444:${enable}${to}`;
-  }).join(";\n");
-}
-function overlayInputs(band) {
-  return band.files.flatMap((file) => ["-i", file]);
-}
-
-// src/render/ffmpeg.ts
-import { execFile as execFile3, spawn as spawn3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
-var run3 = promisify3(execFile3);
-var DEFAULT_TIMEOUT_MS3 = 36e5;
-async function runTool(file, args, opts = {}) {
-  try {
-    return await run3(file, args, {
-      cwd: opts.cwd,
-      timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3,
-      maxBuffer: 64 << 20
-    });
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT") {
-      throw new Error(`${file} is not installed, or not on PATH. \`render\` needs it.`);
-    }
-    const tail3 = (e.stderr ?? e.stdout ?? e.message).trim().split("\n").slice(-8).join("\n");
-    throw new Error(`${file} failed:
-${tail3}`);
-  }
-}
-function runLive(file, args) {
-  return new Promise((resolve5, reject) => {
-    const child = spawn3(file, args, { stdio: ["ignore", "inherit", "inherit"] });
-    child.on("error", (err) => {
-      reject(
-        err.code === "ENOENT" ? new Error(`${file} is not installed, or not on PATH. \`render\` needs it.`) : err
-      );
-    });
-    child.on("close", (code, signal) => {
-      if (code === 0) resolve5();
-      else if (signal) {
-        reject(
-          new Error(
-            `${file} was killed by ${signal}. On a machine under memory pressure this is the OS reclaiming the browser; free memory, or lower --workers, and run again.`
-          )
-        );
-      } else reject(new Error(`${file} exited ${code}.`));
-    });
-  });
-}
-async function probe(path2) {
-  const { stdout } = await runTool("ffprobe", [
-    "-v",
-    "error",
-    "-show_entries",
-    "stream=codec_type,width,height,r_frame_rate,nb_frames:format=duration",
-    "-of",
-    "json",
-    path2
-  ]);
-  const json = JSON.parse(stdout);
-  const streams = json.streams ?? [];
-  const video = streams.find((s) => s.codec_type === "video");
-  if (!video) throw new Error(`${path2} has no video stream.`);
-  const [num, den] = (video.r_frame_rate ?? "30/1").split("/");
-  const fps = Number(num) / (Number(den) || 1);
-  const seconds = Number(json.format?.duration ?? 0);
-  const frames2 = Number(video.nb_frames ?? 0) || Math.round(seconds * fps);
-  return {
-    width: video.width ?? 0,
-    height: video.height ?? 0,
-    fps,
-    frames: frames2,
-    seconds,
-    hasAudio: streams.some((s) => s.codec_type === "audio")
-  };
-}
-function encoderArgs(fps) {
-  return [
-    "-c:v",
-    "libx264",
-    "-preset",
-    "veryfast",
-    "-crf",
-    "16",
-    "-pix_fmt",
-    "yuv420p",
-    "-g",
-    "12",
-    "-r",
-    String(fps),
-    "-fps_mode",
-    "cfr"
-  ];
-}
-function pieceFilter(motion, freeze) {
-  const chain = [`trim=end_frame=${motion}`, "setpts=N/FRAME_RATE/TB"];
-  if (freeze > 0) chain.push(`tpad=stop_mode=clone:stop=${freeze}`);
-  return chain.join(",");
-}
-function pieceArgs(source, fromFrame, motion, freeze, fps, out) {
-  return [
-    "-y",
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    // Half a frame in, so a time that is exactly on a boundary cannot round to
-    // the frame before it.
-    "-ss",
-    ((fromFrame + 0.5) / fps).toFixed(6),
-    "-i",
-    source,
-    "-an",
-    "-vf",
-    pieceFilter(motion, freeze),
-    "-frames:v",
-    String(motion + freeze),
-    ...encoderArgs(fps),
-    "-f",
-    "mpegts",
-    out
-  ];
+  }
+  return rects;
 }
-var LOUDNESS = "loudnorm=I=-16:TP=-1.5:LRA=11,aresample=48000";
-function audioGraph(inputs, seconds, first = 1) {
-  const lines = inputs.map(
-    (input, i) => `[${first + i}:a]aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo,adelay=${input.delayMs}:all=1[d${i}]`
-  );
-  const labels = inputs.map((_, i) => `[d${i}]`).join("");
-  lines.push(
-    `${labels}amix=inputs=${inputs.length}:normalize=0:dropout_transition=0:duration=longest,${LOUDNESS},apad=whole_dur=${seconds.toFixed(3)}[aout]`
-  );
-  return lines.join(";\n");
+var CAPTION_NEED = "draw the captions with (`render` needs one for the capture too)";
+async function captionBlocker() {
+  try {
+    await import("puppeteer-core");
+    await chromePath(CAPTION_NEED);
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
 }
-function respeedArgs(source, factor, chain, fps, hasAudio, out) {
-  const video = `[0:v]setpts=PTS/${factor}[v]`;
-  const audio = hasAudio ? `;[0:a]${chain.map((t2) => `atempo=${t2}`).join(",")}[a]` : "";
-  return [
-    "-y",
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-i",
-    source,
-    "-filter_complex",
-    `${video}${audio}`,
-    "-map",
-    "[v]",
-    ...hasAudio ? ["-map", "[a]", "-c:a", "aac", "-b:a", "160k"] : ["-an"],
-    ...encoderArgs(fps),
-    out
-  ];
+async function renderCaptions(cues, style, deck, work) {
+  if (cues.length === 0) throw new Error("renderCaptions was given no cues.");
+  const fontCss = join13(deck, DECK_FONT_CSS);
+  const href = await import("node:fs/promises").then((fs) => fs.stat(fontCss).catch(() => null)) ? pathToFileURL2(fontCss).href : null;
+  const page = join13(work, "captions.html");
+  await mkdir7(work, { recursive: true });
+  await writeFile9(page, captionPage(cues, style, href));
+  const { default: puppeteer } = await import("puppeteer-core");
+  const browser = await puppeteer.launch({
+    executablePath: await chromePath(CAPTION_NEED),
+    headless: true,
+    args: ["--force-device-scale-factor=1", "--hide-scrollbars"]
+  });
+  try {
+    const tab = await browser.newPage();
+    await tab.setViewport({ width: style.width, height: style.height, deviceScaleFactor: 1 });
+    await tab.goto(pathToFileURL2(page).href, { waitUntil: "load" });
+    await tab.evaluate(() => document.fonts.ready);
+    const rects = await tab.evaluate(measure3, cues.length);
+    const box = union(rects);
+    const files = [];
+    for (const [i, cue] of cues.entries()) {
+      void cue;
+      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: join13(work, name),
+        type: "png",
+        omitBackground: true,
+        clip: { x: box.x, y: box.y, width: box.width, height: box.height }
+      });
+      await tab.evaluate((id2) => document.getElementById(id2)?.classList.remove("on"), `c${i}`);
+      files.push(name);
+    }
+    return { files, ...box };
+  } finally {
+    await browser.close();
+  }
 }
-function burnStyle(width, height, font = "Arial") {
-  return {
-    width,
-    height,
-    font,
-    // MEASURED, not guessed. `splitCue` caps a cue at 84 characters and `wrap`
-    // breaks it near the middle, so the longer of the two lines runs to about
-    // 46 characters in real caption prose. Bold Arial advances 0.485em per
-    // character on that prose (measured in a browser over the demo's own
-    // narration), so 46 characters at F px is 22.3F wide, and the usable width
-    // here is 978px. F = 40 leaves 9% of headroom; F = 45 — which is what
-    // "4% of the width" looked like on paper — overflows to a THIRD line, and a
-    // three-line band covers the bottom of the slide.
-    fontSize: Math.round(width * 0.037),
-    // Clear of the play button, the progress bar and the handle every vertical
-    // player draws across the bottom eighth of the frame.
-    marginV: Math.round(height * 0.09),
-    marginX: Math.round(width * 0.04)
-  };
+function union(rects) {
+  const left = Math.floor(Math.min(...rects.map((r) => r.x)));
+  const top = Math.floor(Math.min(...rects.map((r) => r.y)));
+  const right = Math.ceil(Math.max(...rects.map((r) => r.x + r.w)));
+  const bottom = Math.ceil(Math.max(...rects.map((r) => r.y + r.h)));
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+var t3 = (seconds) => seconds.toFixed(3);
+function overlayGraph(cues, band, input = "0:v", output = "vout") {
+  return cues.map((cue, i) => {
+    const from = i === 0 ? `[${input}]` : `[v${i}]`;
+    const to = i === cues.length - 1 ? `[${output}]` : `[v${i + 1}]`;
+    const enable = `enable='gte(t,${t3(cue.start)})*lt(t,${t3(cue.end)})'`;
+    return `${from}[${i + 1}:v]overlay=x=${band.x}:y=${band.y}:format=yuv444:${enable}${to}`;
+  }).join(";\n");
+}
+function overlayInputs(band) {
+  return band.files.flatMap((file) => ["-i", file]);
 }
 
 // src/render/render.ts
-var SRT_NAME = (out) => `${basename(out).replace(/\.[^.]+$/, "")}.srt`;
+var SRT_NAME = (out) => `${basename3(out).replace(/\.[^.]+$/, "")}.srt`;
 function subtitlePlan(mode) {
   return { sidecar: mode !== "none", burn: mode === "burn" };
 }
 async function render2(opts) {
   const log = opts.log ?? (() => {
   });
-  const deck = resolve2(opts.deck);
-  const out = resolve2(opts.out);
-  const work = join13(dirname(out), `.${basename(out)}.parts`);
+  const deck = resolve3(opts.deck);
+  const out = resolve3(opts.out);
+  const work = join14(dirname(out), `.${basename3(out)}.parts`);
   const timing = await readTiming2(deck);
   if (opts.targetSeconds && !opts.allowFastPlayback) {
     const refusal = playbackRefusal(
@@ -9974,9 +12154,9 @@ async function render2(opts) {
     if (blocker) throw new Error(`Cannot burn in captions: ${blocker}`);
   }
   const burnable = plan0.burn;
-  await mkdir7(work, { recursive: true });
+  await mkdir8(work, { recursive: true });
   try {
-    const raw2 = opts.video ? resolve2(opts.video) : await capture(deck, join13(work, "raw.mp4"), opts, log);
+    const raw2 = opts.video ? resolve3(opts.video) : await capture(deck, join14(work, "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`
@@ -9989,18 +12169,18 @@ async function render2(opts) {
       );
     }
     const retimed = await retime(raw2, plan, work, log);
-    const srtPath = join13(dirname(out), SRT_NAME(out));
+    const srtPath = join14(dirname(out), SRT_NAME(out));
     const playback = opts.targetSeconds ? playbackFactor(plan.frames / shot.fps, opts.targetSeconds) : 1;
     const cues = playback > 1 ? plan.cues.map((c) => scaleCue(c, playback)) : plan.cues;
     const srt = plan0.sidecar ? toSrt(cues) : "";
-    if (srt) await writeFile9(srtPath, srt);
+    if (srt) await writeFile10(srtPath, srt);
     const burn = burnable && srt.length > 0;
     await mux(retimed, timing, plan, deck, out, work, burn ? plan.cues : void 0, shot.fps, log);
     if (playback > 1) {
       log(`render: speeding playback ${playback}\xD7 to reach ${opts.targetSeconds}s`);
       const warning = playbackWarning(playback, p95CueRate(plan.cues));
       if (warning) log(`render: ${warning}`);
-      const fast = join13(work, `fast.${basename(out)}`);
+      const fast = join14(work, `fast.${basename3(out)}`);
       const muxed = await probe(out);
       await runTool(
         "ffmpeg",
@@ -10026,12 +12206,12 @@ async function render2(opts) {
       captionCps: p95CueRate(cues)
     };
   } finally {
-    if (!opts.keep) await rm6(work, { recursive: true, force: true });
+    if (!opts.keep) await rm8(work, { recursive: true, force: true });
   }
 }
 async function readTiming2(deck) {
-  const path2 = join13(deck, TIMING_FILE);
-  const text2 = await readFile12(path2, "utf8").catch(() => {
+  const path2 = join14(deck, TIMING_FILE);
+  const text2 = await readFile14(path2, "utf8").catch(() => {
     throw new Error(
       `${path2} is missing. \`render\` needs the timing manifest \`build\` writes; rebuild the deck.`
     );
@@ -10070,20 +12250,20 @@ async function retime(raw2, plan, work, log) {
   if (plan.pieces.every((p) => p.freeze === 0)) return raw2;
   const list = [];
   for (const [i, piece] of plan.pieces.entries()) {
-    const file = join13(work, `p${String(i).padStart(4, "0")}.ts`);
+    const file = join14(work, `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 = join13(work, "pieces.txt");
-  await writeFile9(
+  const listFile = join14(work, "pieces.txt");
+  await writeFile10(
     listFile,
     `${list.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n")}
 `
   );
-  const joined = join13(work, "retimed.mp4");
+  const joined = join14(work, "retimed.mp4");
   await runTool("ffmpeg", [
     "-y",
     "-hide_banner",
@@ -10105,7 +12285,7 @@ async function retime(raw2, plan, work, log) {
 }
 async function mux(video, timing, plan, deck, out, work, burnCues, fps, log) {
   const inputs = plan.audio.map((a) => ({
-    file: join13(deck, timing.audioDir, a.audio),
+    file: join14(deck, timing.audioDir, a.audio),
     delayMs: a.delayMs
   }));
   const args = ["-y", "-hide_banner", "-loglevel", "error", "-i", video];
@@ -10126,8 +12306,8 @@ async function mux(video, timing, plan, deck, out, work, burnCues, fps, log) {
     graph.push(audioGraph(inputs, plan.frames / fps, 1 + (band?.files.length ?? 0)));
   }
   if (graph.length > 0) {
-    const script = join13(work, "mux.filter");
-    await writeFile9(script, `${graph.join(";\n")}
+    const script = join14(work, "mux.filter");
+    await writeFile10(script, `${graph.join(";\n")}
 `);
     args.push("-filter_complex_script", script);
   }
@@ -10142,13 +12322,13 @@ async function mux(video, timing, plan, deck, out, work, 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 mkdir8(dirname(out), { recursive: true });
   await runTool("ffmpeg", args, { cwd: work });
 }
 
 // src/pack/pack.ts
-import { mkdir as mkdir8, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname2, extname as extname2 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile15, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname2, extname as extname3 } from "node:path";
 import { unzipSync, zipSync } from "fflate";
 var MTIME = Date.UTC(1980, 0, 2, 12);
 var STORED = /* @__PURE__ */ new Set([
@@ -10184,15 +12364,15 @@ async function writePack(pack2, files, out) {
     if (!bytes) continue;
     if (path2 === "deck.json") throw new Error("deck.json is written from the manifest, not passed");
     check2(path2);
-    entries[path2] = STORED.has(extname2(path2).toLowerCase()) ? [bytes, { level: 0 }] : bytes;
+    entries[path2] = STORED.has(extname3(path2).toLowerCase()) ? [bytes, { level: 0 }] : bytes;
   }
   const zip = zipSync(entries, { mtime: MTIME });
-  await mkdir8(dirname2(out), { recursive: true });
-  await writeFile10(out, zip);
+  await mkdir9(dirname2(out), { recursive: true });
+  await writeFile11(out, zip);
   return zip.length;
 }
 async function readPack(path2) {
-  return openPack(new Uint8Array(await readFile13(path2)), path2);
+  return openPack(new Uint8Array(await readFile15(path2)), path2);
 }
 function openPack(bytes, label = "pack") {
   if (bytes.length < 4 || bytes[0] !== 80 || bytes[1] !== 75)
@@ -10218,7 +12398,7 @@ function openPack(bytes, label = "pack") {
     );
   const parsed = packSchema.safeParse(json);
   if (!parsed.success)
-    throw new Error(`${label}: deck.json is not a valid pack \u2014 ${why(parsed.error)}`);
+    throw new Error(`${label}: deck.json is not a valid pack \u2014 ${why2(parsed.error)}`);
   const files = {};
   for (const [name, content] of Object.entries(raw2)) {
     if (name === "deck.json" || name.endsWith("/")) continue;
@@ -10231,164 +12411,13 @@ function check2(label, path2 = label) {
   if (path2.startsWith("/") || /^[a-z]:/i.test(path2) || path2.split("/").includes(".."))
     throw new Error(`${label}: unsafe path in pack`);
 }
-function why(error) {
+function why2(error) {
   return error.issues.slice(0, 3).map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
 }
 
-// src/pack/media.ts
-import { createHash as createHash8 } from "node:crypto";
-import { readFile as readFile14 } from "node:fs/promises";
-import { extname as extname3 } from "node:path";
-var PLAYERS = [
-  "youtube.com",
-  "youtube-nocookie.com",
-  "youtu.be",
-  "vimeo.com",
-  "dailymotion.com",
-  "dai.ly",
-  "twitch.tv",
-  "loom.com",
-  "wistia.com",
-  "wistia.net",
-  "streamable.com",
-  "bilibili.com",
-  "soundcloud.com",
-  "tiktok.com"
-];
-var FILE_EXT = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".avif",
-  ".svg",
-  ".mp4",
-  ".webm",
-  ".mov",
-  ".m4v",
-  ".mp3",
-  ".m4a",
-  ".wav",
-  ".ogg",
-  ".opus",
-  ".pdf"
-]);
-function isEmbed(url) {
-  const host = hostOf(url);
-  return host !== null && PLAYERS.some((p) => host === p || host.endsWith(`.${p}`));
-}
-function policyFor(url, prefer) {
-  if (isEmbed(url)) return "embed";
-  const host = hostOf(url);
-  if (host === null || /^data:/i.test(url)) return "bake";
-  if (prefer === "link") return "link";
-  return FILE_EXT.has(extOf(url)) ? "bake" : "link";
-}
-async function planMedia(assets, fetcher = fetchAsset) {
-  const plan = {
-    media: [],
-    files: {},
-    bakedCount: 0,
-    bakedBytes: 0,
-    demoted: [],
-    promoted: []
-  };
-  for (const asset of assets) {
-    const policy = policyFor(asset.url, asset.prefer);
-    if (policy !== "bake") {
-      if (asset.prefer === "bake") plan.demoted.push(asset.id);
-      plan.media.push({ id: asset.id, policy, url: asset.url, mime: asset.mime });
-      continue;
-    }
-    if (asset.prefer === "link") plan.promoted.push(asset.id);
-    const got = await fetcher(asset.url);
-    const mime = clean(got.mime) ?? asset.mime;
-    if (mime === "text/html") {
-      plan.demoted.push(asset.id);
-      plan.media.push({ id: asset.id, policy: "link", url: asset.url, mime });
-      continue;
-    }
-    const path2 = `media/${bakedName(asset.id, asset.url, mime)}`;
-    plan.files[path2] = got.bytes;
-    plan.bakedCount += 1;
-    plan.bakedBytes += got.bytes.length;
-    plan.media.push({ id: asset.id, policy: "bake", path: path2, mime, bytes: got.bytes.length });
-  }
-  return plan;
-}
-function mediaSummary(plan) {
-  const linked = plan.media.filter((m) => m.policy === "link").length;
-  const embedded = plan.media.filter((m) => m.policy === "embed").length;
-  const parts = [`${plan.bakedCount} baked (${size(plan.bakedBytes)})`];
-  if (linked) parts.push(`${linked} linked`);
-  if (embedded) parts.push(`${embedded} embedded`);
-  if (plan.demoted.length) parts.push(`${plan.demoted.length} not bakeable`);
-  return parts.join(", ");
-}
-function bakedName(id2, url, mime) {
-  const slug = id2.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "asset";
-  const hash = createHash8("sha256").update(url).digest("hex").slice(0, 8);
-  return `${slug}-${hash}${extOf(url) || extFor(mime)}`;
-}
-function extOf(url) {
-  const path2 = hostOf(url) === null ? url : new URL(url).pathname;
-  const ext = extname3(path2).toLowerCase();
-  return FILE_EXT.has(ext) ? ext : "";
-}
-var MIME_EXT = {
-  "image/png": ".png",
-  "image/jpeg": ".jpg",
-  "image/gif": ".gif",
-  "image/webp": ".webp",
-  "image/avif": ".avif",
-  "image/svg+xml": ".svg",
-  "video/mp4": ".mp4",
-  "video/webm": ".webm",
-  "audio/mpeg": ".mp3",
-  "application/pdf": ".pdf"
-};
-function extFor(mime) {
-  return (mime && MIME_EXT[mime]) ?? ".bin";
-}
-function hostOf(url) {
-  try {
-    const u = new URL(url);
-    if (u.protocol === "file:" || u.protocol === "data:") return null;
-    return u.hostname.toLowerCase().replace(/^www\./, "");
-  } catch {
-    return null;
-  }
-}
-function clean(mime) {
-  return mime?.split(";")[0]?.trim().toLowerCase() || void 0;
-}
-function size(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  const units = ["KB", "MB", "GB"];
-  let n3 = bytes / 1024;
-  let i = 0;
-  while (n3 >= 1024 && i < units.length - 1) {
-    n3 /= 1024;
-    i += 1;
-  }
-  return `${n3 < 10 ? n3.toFixed(1) : Math.round(n3)} ${units[i]}`;
-}
-async function fetchAsset(url) {
-  if (/^(https?|data):/i.test(url)) {
-    const res = await fetch(url);
-    if (!res.ok) throw new Error(`${url}: HTTP ${res.status}`);
-    return {
-      bytes: new Uint8Array(await res.arrayBuffer()),
-      mime: res.headers.get("content-type") ?? void 0
-    };
-  }
-  return { bytes: new Uint8Array(await readFile14(url)) };
-}
-
 // src/prefs.ts
-import { readFile as readFile15 } from "node:fs/promises";
-import { dirname as dirname3, join as join14, resolve as resolve3 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { dirname as dirname3, join as join15, resolve as resolve4 } from "node:path";
 var CONFIG_FILE = "decksmith.config.json";
 var PREF_KEYS = Object.keys(prefsSchema.shape);
 var NARRATION_KEYS = Object.keys(prefsSchema.shape.narration.unwrap().shape);
@@ -10405,10 +12434,10 @@ async function loadPrefs(overrides = {}, cwd = process.cwd(), source) {
   return parsed;
 }
 async function findConfig(from) {
-  let dir = resolve3(from);
+  let dir = resolve4(from);
   for (; ; ) {
-    const path2 = join14(dir, CONFIG_FILE);
-    const text2 = await readFile15(path2, "utf8").catch(() => void 0);
+    const path2 = join15(dir, CONFIG_FILE);
+    const text2 = await readFile16(path2, "utf8").catch(() => void 0);
     if (text2 !== void 0) {
       try {
         return { path: path2, value: JSON.parse(text2) };
@@ -10466,8 +12495,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   if (!format) throw new Error("no deck-16x9 format");
   const step = opts.onStep ?? (() => {
   });
-  const out = resolve4(outDir);
-  await mkdir9(out, { recursive: true });
+  const out = resolve5(outDir);
+  await mkdir10(out, { recursive: true });
   const speed = opts.speed ?? 1;
   const fontCss = await refreshFont(storyboard, source, out, step);
   const deck = emitDeck(storyboard, source, format, await deckRuntime(), {
@@ -10479,8 +12508,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   });
   const files = [];
   const write = async (name, text2) => {
-    await writeFile11(join15(out, name), text2);
-    files.push(join15(out, name));
+    await writeFile12(join16(out, name), text2);
+    files.push(join16(out, name));
   };
   await write("index.html", deck.composition);
   await write("hyperframes.json", HYPERFRAMES_JSON);
@@ -10509,8 +12538,8 @@ async function buildDeck(storyboard, source, outDir, opts = {}) {
   }
   if (deck.page) {
     await write(DECK_PAGE, deck.page);
-    await cp(playerBundle(), join15(out, PLAYER_FILE));
-    files.push(join15(out, PLAYER_FILE));
+    await cp(playerBundle(), join16(out, PLAYER_FILE));
+    files.push(join16(out, PLAYER_FILE));
   }
   files.push(...await vendorKatex(out));
   if (opts.assetsFrom) files.push(...await copyAssets(opts.assetsFrom, out));
@@ -10519,7 +12548,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 ${join15(out, "index.html")}`
+    `build: ${deck.cut.kept.length}${of} beats at ${format.width}\xD7${format.height} \u2192 ${join16(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}`);
@@ -10537,65 +12566,65 @@ var HYPERFRAMES_JSON = `${JSON.stringify(
 async function deckRuntime() {
   const path2 = fileURLToPath(new URL(`./${"deck-runtime.js"}`, import.meta.url));
   try {
-    return await readFile16(path2, "utf8");
+    return await readFile17(path2, "utf8");
   } catch {
     throw new Error(`Deck runtime missing at ${path2}. Run "npm run build" first.`);
   }
 }
 function playerBundle() {
-  const require2 = createRequire2(import.meta.url);
+  const require2 = createRequire3(import.meta.url);
   try {
-    return join15(dirname4(require2.resolve("hyperframes/package.json")), "dist", PLAYER_FILE);
+    return join16(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 = join15(dirname4(require2.resolve("katex/package.json")), "dist");
-  const css = await readFile16(join15(dist, "katex.min.css"), "utf8");
+  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");
   const written = [];
-  await mkdir9(join15(out, "katex/fonts"), { recursive: true });
-  for (const file of await readdir3(join15(dist, "fonts"))) {
+  await mkdir10(join16(out, "katex/fonts"), { recursive: true });
+  for (const file of await readdir4(join16(dist, "fonts"))) {
     if (!file.endsWith(".woff2")) continue;
-    await cp(join15(dist, "fonts", file), join15(out, "katex/fonts", file));
-    written.push(join15(out, "katex/fonts", file));
+    await cp(join16(dist, "fonts", file), join16(out, "katex/fonts", file));
+    written.push(join16(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(join15(out, "katex/katex.min.css"), woff2Only);
-  written.push(join15(out, "katex/katex.min.css"));
+  await writeFile12(join16(out, "katex/katex.min.css"), woff2Only);
+  written.push(join16(out, "katex/katex.min.css"));
   return written;
 }
 async function copyAssets(sourceDir, out) {
-  const from = join15(resolve4(sourceDir), "assets");
-  if (!await stat(from).catch(() => null)) return [];
-  await cp(from, join15(out, "assets"), { recursive: true });
-  return [join15(out, "assets")];
+  const from = join16(resolve5(sourceDir), "assets");
+  if (!await stat2(from).catch(() => null)) return [];
+  await cp(from, join16(out, "assets"), { recursive: true });
+  return [join16(out, "assets")];
 }
 async function copyAudio(from, narration, out) {
-  const dir = join15(out, narration.dir);
-  await mkdir9(dir, { recursive: true });
+  const dir = join16(out, narration.dir);
+  await mkdir10(dir, { recursive: true });
   const names = [
     ...new Set(
       Object.values(narration.beats).flat().map((s) => s.audio)
     )
   ].sort();
   for (const name of names) {
-    await cp(join15(resolve4(from), name), join15(dir, name)).catch(() => {
+    await cp(join16(resolve5(from), name), join16(dir, name)).catch(() => {
       throw new Error(`Narration names ${name}, but it is not in ${from}. Re-run \`narrate\`.`);
     });
   }
-  return names.map((n3) => join15(dir, n3));
+  return names.map((n3) => join16(dir, n3));
 }
 async function refreshFont(storyboard, source, out, step) {
   try {
     const bundle = await bundleFont(
       storyboard.lang,
       JSON.stringify(source) + JSON.stringify(storyboard),
-      join15(out, "assets", "fonts")
+      join16(out, "assets", "fonts")
     );
     if (bundle) step(`build: font bundle covers ${bundle.family}`);
     return bundle?.css;
@@ -10636,6 +12665,7 @@ export {
   annotatedFigureParamsSchema,
   assertInsideResolves,
   assertRefsResolve,
+  attachClips,
   barCompareParamsSchema,
   beatRoleSchema,
   beatSchema,
@@ -10659,15 +12689,18 @@ export {
   equationSchema,
   equationWalkParamsSchema,
   fetchFigures,
+  fetchGuarded,
   figureSchema,
   framePlan,
   gradeOverprint,
   gridParamsSchema,
+  harvest,
   hasIllustrations,
   illustrate,
   illustrationSchema,
   imageChain,
   insideSchema,
+  isBlockedAddress,
   isCustom,
   lineChartParamsSchema,
   loadPrefs,
@@ -10724,6 +12757,7 @@ export {
   tempoChain,
   termSchema,
   titleParamsSchema,
+  toMarkdown,
   toSrt,
   verify,
   warnSecondsFor,