@jokerized/decksmith 0.1.0 → 0.1.2

package/dist/mcp.js

@@ -850,27 +850,229 @@ function drawFrom(length) {
 function id(sid, part, i) {
   return i === void 0 ? `${sid}-${part}` : `${sid}-${part}${i}`;
 }
-function charUnits(c) {
-  if (c === " ") return 0.3;
-  const code = c.codePointAt(0) ?? 0;
-  if (code > 11903) return 1.02;
-  if (c >= "0" && c <= "9" || c === "." || c === ",") return 0.6;
-  if ("MW@%".includes(c)) return 0.95;
-  if ("mw".includes(c)) return 0.88;
-  if ("ijltI:;'`|!()[]".includes(c)) return 0.33;
-  if (c >= "A" && c <= "Z") return 0.72;
-  if (code >= 192 && code <= 223) return 0.72;
-  return 0.56;
+var ADVANCE = {
+  /* digits, PROPORTIONAL — see `TABULAR_FIGURE` for a table's */
+  "0": 0.646,
+  "1": 0.413,
+  "2": 0.61,
+  "3": 0.618,
+  "4": 0.648,
+  "5": 0.596,
+  "6": 0.622,
+  "7": 0.566,
+  "8": 0.624,
+  "9": 0.622,
+  ".": 0.32,
+  ",": 0.32,
+  /* capitals */
+  A: 0.715,
+  B: 0.655,
+  C: 0.731,
+  D: 0.722,
+  E: 0.602,
+  F: 0.591,
+  G: 0.747,
+  H: 0.744,
+  I: 0.269,
+  J: 0.571,
+  K: 0.689,
+  L: 0.566,
+  M: 0.904,
+  N: 0.754,
+  O: 0.765,
+  P: 0.639,
+  Q: 0.765,
+  R: 0.644,
+  S: 0.642,
+  T: 0.646,
+  U: 0.745,
+  // biome-ignore lint/suspicious/noApproximativeNumericConstant: X's advance in Inter, measured. It is near 1/sqrt(2) by coincidence and means nothing of the sort.
+  V: 0.715,
+  W: 0.993,
+  X: 0.707,
+  Y: 0.7,
+  Z: 0.636,
+  /* lowercase */
+  a: 0.562,
+  b: 0.613,
+  c: 0.572,
+  d: 0.613,
+  e: 0.584,
+  f: 0.381,
+  g: 0.614,
+  h: 0.596,
+  i: 0.26,
+  j: 0.26,
+  k: 0.555,
+  l: 0.26,
+  m: 0.876,
+  n: 0.596,
+  o: 0.6,
+  p: 0.613,
+  q: 0.613,
+  r: 0.39,
+  s: 0.537,
+  t: 0.351,
+  u: 0.596,
+  v: 0.574,
+  w: 0.819,
+  x: 0.556,
+  y: 0.576,
+  z: 0.553,
+  /* ASCII punctuation */
+  "!": 0.324,
+  '"': 0.528,
+  "#": 0.634,
+  $: 0.642,
+  "%": 0.982,
+  "&": 0.645,
+  "'": 0.325,
+  "(": 0.391,
+  ")": 0.391,
+  "*": 0.649,
+  "+": 0.662,
+  "-": 0.649,
+  "/": 0.372,
+  ":": 0.32,
+  ";": 0.329,
+  "<": 0.662,
+  "=": 0.662,
+  ">": 0.662,
+  "?": 0.536,
+  "@": 0.973,
+  "[": 0.391,
+  "\\": 0.372,
+  "]": 0.391,
+  "^": 0.472,
+  _: 0.457,
+  "`": 0.35,
+  "{": 0.449,
+  "|": 0.356,
+  "}": 0.449,
+  "~": 0.662,
+  " ": 0.282,
+  /* dashes, arrows, marks */
+  "\xB7": 0.32,
+  "\u2014": 1,
+  "\u2013": 0.5,
+  "\u2026": 0.959,
+  "\xD7": 0.662,
+  "\xF7": 0.662,
+  "\xB0": 0.456,
+  "\xB1": 0.662,
+  "\u2248": 0.662,
+  "\u2264": 0.662,
+  "\u2265": 0.662,
+  "\u2192": 0.955,
+  "\u2190": 0.955,
+  "\u2191": 0.867,
+  "\u2193": 0.867,
+  "\u2194": 1.341,
+  "\u27F6": 1.341,
+  "\u201C": 0.517,
+  "\u201D": 0.51,
+  "\u2018": 0.298,
+  "\u2019": 0.298,
+  "\xAB": 0.632,
+  "\xBB": 0.632,
+  "\u20AC": 0.667,
+  "\xA3": 0.612,
+  "\xA5": 0.55,
+  "\xA7": 0.569,
+  "\xB6": 0.603,
+  "\u2020": 0.558,
+  "\u2021": 0.558,
+  "\u2022": 0.563,
+  "\u2030": 1.336,
+  "\u2032": 0.263,
+  "\u2033": 0.524,
+  /* Latin-1 letters — the accent rides above, so ï advances exactly as i does */
+  \u00C0: 0.715,
+  \u00C1: 0.715,
+  \u00C2: 0.715,
+  \u00C3: 0.715,
+  \u00C4: 0.715,
+  \u00C5: 0.715,
+  \u00C6: 0.994,
+  \u00C7: 0.731,
+  \u00C8: 0.602,
+  \u00C9: 0.602,
+  \u00CA: 0.602,
+  \u00CB: 0.602,
+  \u00CC: 0.269,
+  \u00CD: 0.269,
+  \u00CE: 0.269,
+  \u00CF: 0.269,
+  \u00D0: 0.735,
+  \u00D1: 0.754,
+  \u00D2: 0.765,
+  \u00D3: 0.765,
+  \u00D4: 0.765,
+  \u00D5: 0.765,
+  \u00D6: 0.765,
+  \u00D8: 0.765,
+  \u00D9: 0.745,
+  \u00DA: 0.745,
+  \u00DB: 0.745,
+  \u00DC: 0.745,
+  \u00DD: 0.7,
+  \u00DE: 0.641,
+  \u00DF: 0.63,
+  \u00E0: 0.562,
+  \u00E1: 0.562,
+  \u00E2: 0.562,
+  \u00E3: 0.562,
+  \u00E4: 0.562,
+  \u00E5: 0.562,
+  \u00E6: 0.918,
+  \u00E7: 0.572,
+  \u00E8: 0.584,
+  \u00E9: 0.584,
+  \u00EA: 0.584,
+  \u00EB: 0.584,
+  \u00EC: 0.26,
+  \u00ED: 0.26,
+  \u00EE: 0.26,
+  \u00EF: 0.26,
+  \u00F0: 0.583,
+  \u00F1: 0.596,
+  \u00F2: 0.6,
+  \u00F3: 0.6,
+  \u00F4: 0.6,
+  \u00F5: 0.6,
+  \u00F6: 0.6,
+  \u00F8: 0.6,
+  \u00F9: 0.596,
+  \u00FA: 0.596,
+  \u00FB: 0.596,
+  \u00FC: 0.596,
+  \u00FD: 0.576,
+  \u00FE: 0.613,
+  \u00FF: 0.576
+};
+var KERN_SLACK = 1.007;
+var TABULAR_FIGURE = 0.649;
+var TABULAR_SEPARATOR = 0.269;
+function charUnits(c, tabular) {
+  if (tabular) {
+    if (c >= "0" && c <= "9") return TABULAR_FIGURE;
+    if (c === "." || c === ",") return TABULAR_SEPARATOR;
+  }
+  return ADVANCE[c] ?? 1.02;
 }
 function weightFactor(weight) {
-  return weight >= 700 ? 1.07 : weight >= 600 ? 1.04 : 1;
+  return weight >= 700 ? 1.045 : weight >= 600 ? 1.03 : weight >= 500 ? 1.015 : 1;
 }
-function textWidth(text2, fontSize, weight = 400) {
+function textWidth(text2, fontSize, weight = 400, tracking = 0, tabular = false) {
   let units = 0;
-  for (const c of text2) units += charUnits(c);
-  return units * fontSize * weightFactor(weight);
+  let chars = 0;
+  for (const c of text2) {
+    units += charUnits(c, tabular);
+    chars++;
+  }
+  return units * KERN_SLACK * fontSize * weightFactor(weight) + tracking * fontSize * chars;
 }
-function wrap(text2, fontSize, maxWidth, weight = 400) {
+function wrap(text2, fontSize, maxWidth, weight = 400, tracking = 0) {
   if (maxWidth <= 0) return [text2];
   const lines = [];
   let line2 = "";
@@ -880,17 +1082,17 @@ function wrap(text2, fontSize, maxWidth, weight = 400) {
   };
   for (const word of text2.split(/\s+/).filter(Boolean)) {
     const candidate = line2 ? `${line2} ${word}` : word;
-    if (textWidth(candidate, fontSize, weight) <= maxWidth) {
+    if (textWidth(candidate, fontSize, weight, tracking) <= maxWidth) {
       line2 = candidate;
       continue;
     }
     push();
-    if (textWidth(word, fontSize, weight) <= maxWidth) {
+    if (textWidth(word, fontSize, weight, tracking) <= maxWidth) {
       line2 = word;
       continue;
     }
     for (const c of word) {
-      if (line2 && textWidth(line2 + c, fontSize, weight) > maxWidth) push();
+      if (line2 && textWidth(line2 + c, fontSize, weight, tracking) > maxWidth) push();
       line2 += c;
     }
   }
@@ -1161,7 +1363,11 @@ function isPortrait(format) {
 }
 var EYEBROW_SIZE = 42;
 var EYEBROW_LH = 1.2;
-var EYEBROW_H = Math.round(EYEBROW_SIZE * EYEBROW_LH) + 22;
+var EYEBROW_LINE = Math.round(EYEBROW_SIZE * EYEBROW_LH);
+var EYEBROW_GAP = 22;
+var EYEBROW_H = EYEBROW_LINE + EYEBROW_GAP;
+var EYEBROW_TRACKING = 0.14;
+var HEADLINE_TRACKING = -0.015;
 var HEADLINE_SIZE = 76;
 var HEADLINE_LH = 1.15;
 var HEADLINE_H = Math.round(HEADLINE_SIZE * HEADLINE_LH);
@@ -1201,12 +1407,14 @@ function wrapTokens(tokens, size, width, weight) {
   return lines;
 }
 function chromeHeight(eyebrow, headline, width) {
-  const lines = wrap(headline, HEADLINE_SIZE, width, 700).length;
-  return (eyebrow ? EYEBROW_H : 0) + lines * HEADLINE_H;
+  const lines = wrap(headline, HEADLINE_SIZE, width, 700, HEADLINE_TRACKING).length;
+  const brow = eyebrow ? wrap(eyebrow.toUpperCase(), EYEBROW_SIZE, width, 500, EYEBROW_TRACKING).length * EYEBROW_LINE + EYEBROW_GAP : 0;
+  return brow + lines * HEADLINE_H;
 }
-function bodyBudget(format, eyebrow, headline, below = 0, top = 34) {
+var BODY_FLOOR = 320;
+function bodyBudget(format, eyebrow, headline, below = 0, top = 34, floor = BODY_FLOOR) {
   const width = contentW(format);
-  return Math.max(320, contentH(format) - chromeHeight(eyebrow, headline, width) - top - below);
+  return Math.max(floor, contentH(format) - chromeHeight(eyebrow, headline, width) - top - below);
 }
 function fitText(text2, width, maxLines, lo, hi, weight = 700) {
   const units = textWidth(text2, 1, weight);
@@ -1304,8 +1512,6 @@ var title = (beat, ctx) => {
 };
 
 // src/emit/archetypes/annotated-figure.ts
-var HEAD_H = HEADLINE_H;
-var BROW_H = EYEBROW_H;
 var STAGE_GAP = 30;
 var CAP_GAP = 26;
 var CAP_LH = 1.35;
@@ -1331,7 +1537,17 @@ function lineBudget(count, stageH) {
   const lines = Math.floor((room - ASCENT - RULE_LIFT - RULE_W) / (LAB * LAB_LH)) + 1;
   return Math.min(LINE_CEIL, Math.max(1, lines));
 }
-var COLS = [320, 380, 470, 560];
+var STEPS = 6;
+function columns(notes, stageW) {
+  const words = notes.flatMap((n3) => n3.text.split(/\s+/).filter(Boolean));
+  if (words.length === 0) return [stageW / 3];
+  const floor = Math.max(...words.map((w) => textWidth(w, LAB, LAB_WEIGHT)));
+  const ceiling = Math.max(...notes.map((n3) => textWidth(n3.text, LAB, LAB_WEIGHT)));
+  const hi = Math.max(floor, ceiling);
+  if (hi <= floor) return [floor];
+  const ratio = (hi / floor) ** (1 / (STEPS - 1));
+  return Array.from({ length: STEPS }, (_, k) => floor * ratio ** k);
+}
 var MAX_UPSCALE = 1.5;
 var DOT_R = 9;
 var HALO_R = 18;
@@ -1351,13 +1567,19 @@ function measure(content, col, maxLines) {
     clipped
   };
 }
-function attempt(stageW, notes, fig, stageH, want, tall) {
+function wantedSides(notes) {
+  const want = { l: false, r: false };
+  for (const note of notes) want[(note.x ?? 0) < 0.5 ? "l" : "r"] = true;
+  return want.l || want.r ? want : { l: true, r: true };
+}
+function attempt(stageW, notes, fig, stageH, want, tall, sides = { l: true, r: true }) {
   const band = tall ? tracks(stageW, notes.length, COL_GAP) : [];
   const row = tall && (band[0]?.w ?? 0) >= MIN_COL;
   const stacks = row ? 1 : Math.max(1, Math.ceil(notes.length / 2));
   const bandMin = tall ? stacks * (ASCENT + RULE_LIFT + RULE_W) + (stacks - 1) * LAB_GAP + BAND_GAP : 0;
   const asked = Math.min(want, stageW / 3);
-  const plateMax = tall ? stageW - 2 * EDGE : stageW - 2 * (asked + LEAD + EDGE);
+  const margin = (s) => tall || !sides[s] ? EDGE : asked + LEAD + EDGE;
+  const plateMax = tall ? stageW - 2 * EDGE : stageW - margin("l") - margin("r");
   const scale = Math.min(
     (plateMax - 2 * PLATE) / fig.width,
     (stageH - bandMin - 2 * PLATE) / fig.height,
@@ -1366,12 +1588,15 @@ function attempt(stageW, notes, fig, stageH, want, tall) {
   const img = {
     w: fig.width * scale,
     h: fig.height * scale,
-    x: (stageW - fig.width * scale) / 2,
+    // Centred between the MARGINS, not on the stage. With both reserved the two
+    // are the same number; with one, centring on the stage walks the figure into
+    // the margin its own labels are standing in.
+    x: tall ? (stageW - fig.width * scale) / 2 : margin("l") + (plateMax - fig.width * scale) / 2,
     // Portrait pins the figure to the top of the stage — the labels take the
     // band under it, so centring it would open a gap the labels then hang off.
     y: tall ? PLATE : (stageH - fig.height * scale) / 2
   };
-  const col = row ? band[0]?.w ?? stageW : tall ? (stageW - MID_GAP) / 2 : img.x - PLATE - LEAD - EDGE;
+  const col = row ? band[0]?.w ?? stageW : tall ? (stageW - MID_GAP) / 2 : sides.l ? img.x - PLATE - LEAD - EDGE : stageW - (img.x + img.w) - PLATE - LEAD - EDGE;
   const stackTop = tall ? img.y + img.h + PLATE + BAND_GAP : 0;
   const room = stageH - stackTop;
   const innerOf = (side) => tall ? side === "l" ? col : stageW - col : side === "l" ? img.x - PLATE - LEAD : img.x + img.w + PLATE + LEAD;
@@ -1398,7 +1623,8 @@ function attempt(stageW, notes, fig, stageH, want, tall) {
     const cost = (s, h) => used[s] + (used[s] > 0 ? LAB_GAP : 0) + h;
     for (const w of order) {
       const pref = (notes[w.i]?.x ?? 0) < 0.5 ? "l" : "r";
-      const other = pref === "l" ? "r" : "l";
+      const across = pref === "l" ? "r" : "l";
+      const other = sides[across] ? across : pref;
       w.side = cost(pref, w.h) <= room ? pref : cost(other, w.h) <= room ? other : used[pref] <= used[other] ? pref : other;
       used[w.side] = cost(w.side, w.h);
       w.inner = innerOf(w.side);
@@ -1431,7 +1657,12 @@ function attempt(stageW, notes, fig, stageH, want, tall) {
     img: { ...img, y: img.y - top },
     col,
     height: bottom - top,
-    ok: (row ? bottom - stackTop <= room : used.l <= room && used.r <= room) && !work2.some((w) => w.clipped),
+    ok: (row ? bottom - stackTop <= room : used.l <= room && used.r <= room) && // THE COLUMN HOLDS WHAT WAS MEASURED AGAINST IT. `measure` wraps to `col`,
+    // so a label wider than `col` means the column shrank AFTER the wrap — the
+    // one-margin arrangement widening the figure into it. Without this the
+    // search calls that a fit and never falls back, and the label runs off the
+    // stage: measured at 30px of text in 29.1px of column.
+    !work2.some((w) => w.w > col) && !work2.some((w) => w.clipped),
     boxes: work2.map((w) => ({
       side: w.side,
       lines: w.lines,
@@ -1447,19 +1678,24 @@ function attempt(stageW, notes, fig, stageH, want, tall) {
 }
 function planFigure(stageW, notes, fig, stageH, tall = false) {
   if (tall) return attempt(stageW, notes, fig, stageH, 0, true);
-  let plan = attempt(stageW, notes, fig, stageH, COLS[0] ?? 380, false);
-  for (let k = 1; k < COLS.length && !plan.ok; k++) {
-    plan = attempt(stageW, notes, fig, stageH, COLS[k] ?? 560, false);
+  const wanted = wantedSides(notes);
+  const both = { l: true, r: true };
+  const tries = wanted.l && wanted.r ? [both] : [wanted, both];
+  const cols = columns(notes, stageW);
+  let plan;
+  for (const sides of tries) {
+    for (const col of cols) {
+      plan = attempt(stageW, notes, fig, stageH, col, false, sides);
+      if (plan.ok) return plan;
+    }
   }
   return plan;
 }
-function stageBudget(format, eyebrow, caption) {
+var MIN_STAGE = 2 * PLATE + 2 * Math.round(LAB * CAP_LH);
+function stageBudget(format, eyebrow, headline, caption) {
   const lines = Math.min(CAP_LINES, wrap(caption, LAB, contentW(format)).length);
   const capH = lines * LAB * CAP_LH;
-  return Math.max(
-    360,
-    contentH(format) - (eyebrow ? BROW_H : 0) - HEAD_H - STAGE_GAP - CAP_GAP - capH
-  );
+  return contentH(format) - chromeHeight(eyebrow, headline, contentW(format)) - STAGE_GAP - CAP_GAP - capH;
 }
 function offDot(from, to) {
   const d = Math.hypot(to.x - from.x, to.y - from.y);
@@ -1488,13 +1724,13 @@ var annotatedFigure = (beat, ctx) => {
     y: clamp3((no.y - crop.y) / crop.h)
   })) : p.notes;
   const STAGE_W = contentW(ctx.format);
-  const plan = planFigure(
-    STAGE_W,
-    notes,
-    view,
-    stageBudget(ctx.format, p.eyebrow !== void 0, fig.caption),
-    isPortrait(ctx.format)
-  );
+  const budget2 = stageBudget(ctx.format, p.eyebrow, p.headline, fig.caption);
+  if (budget2 < MIN_STAGE) {
+    throw new Error(
+      `annotated-figure ${beat.id}: the headline and caption leave ${Math.round(budget2)}px for the figure, under the ${MIN_STAGE}px floor \u2014 shorten the headline or split the beat`
+    );
+  }
+  const plan = planFigure(STAGE_W, notes, view, budget2, isPortrait(ctx.format));
   const stageH = plan.height;
   const plate = {
     x: plan.img.x - PLATE,
@@ -1721,7 +1957,9 @@ var barCompare = (beat, ctx) => {
   }
   const gutter = tall ? 0 : Math.min(
     gutterMax,
-    Math.max(...lines.flat().map((l) => textWidth(l, labelSize, LABEL_WEIGHT))) + GUTTER_PAD
+    Math.ceil(
+      Math.max(...lines.flat().map((l) => textWidth(l, labelSize, LABEL_WEIGHT))) + GUTTER_PAD
+    )
   );
   const metrics = p.bars.map((b) => {
     const printed = String(b.value);
@@ -1973,7 +2211,19 @@ var callout = (beat, ctx) => {
     return 2 * PANEL_PAD_Y + label + LABEL_GAP + body;
   });
   const stackedH = heights.reduce((a, b) => a + b, 0) + PANEL_GAP * (heights.length - 1);
-  const cap = Math.round(cols === 1 ? stackedH * 1.1 : Math.max(...heights) * 1.22);
+  const need = cols === 1 ? stackedH : Math.max(...heights);
+  const budget2 = bodyBudget(
+    ctx.format,
+    p.eyebrow,
+    p.headline,
+    noteHeight(p.note, noteWidth(ctx.format))
+  );
+  if (need > budget2) {
+    throw new Error(
+      `callout ${beat.id}: ${Math.round(need)}px of panel in a ${Math.round(budget2)}px box \u2014 shorten the lines or split the beat`
+    );
+  }
+  const cap = Math.min(budget2, Math.round(need * (cols === 1 ? 1.1 : 1.22)));
   const note = p.note ? `
 <div class="conote" id="${sid}-note">${esc(p.note)}</div>` : "";
   const html = `${chrome(sid, p.eyebrow, p.headline, box)}
@@ -2032,6 +2282,8 @@ var FULL_WIDTH_ASPECT = 3;
 var CLAIM_SIZE = 50;
 var CLAIM_LH = 1.5;
 var CLAIM_RULE = 6 + 32;
+var BESIDE_COL = 560;
+var MIN_PLATE = 2 * Math.round(BODY_SIZE * BODY_LH);
 var claimFigure = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
@@ -2042,12 +2294,20 @@ var claimFigure = (beat, ctx) => {
     );
   }
   const box = contentW(ctx.format);
-  const tall = isPortrait(ctx.format);
-  const wide = !tall && fig.width / fig.height >= FULL_WIDTH_ASPECT;
-  const claimBand = tall ? wrap(p.claim, CLAIM_SIZE, box - CLAIM_RULE).length * Math.round(CLAIM_SIZE * CLAIM_LH) + 34 : 0;
+  const portrait = isPortrait(ctx.format);
+  const wide = !portrait && fig.width / fig.height >= FULL_WIDTH_ASPECT;
+  const bandFor = (width) => wrap(p.claim, CLAIM_SIZE, width - CLAIM_RULE).length * Math.round(CLAIM_SIZE * CLAIM_LH) + 34;
+  const rowBudget = bodyBudget(ctx.format, p.eyebrow, p.headline, CAP_BAND, 26);
+  const tall = portrait || !wide && bandFor(BESIDE_COL) - 34 > rowBudget;
+  const claimBand = tall ? bandFor(box) : 0;
   const figMax = Math.round(
-    bodyBudget(ctx.format, p.eyebrow, p.headline, CAP_BAND + claimBand, 26) - 32
-  );
+    bodyBudget(ctx.format, p.eyebrow, p.headline, CAP_BAND + claimBand, 26, tall ? 0 : void 0)
+  ) - 32;
+  if (figMax < MIN_PLATE) {
+    throw new Error(
+      `claim-figure ${beat.id}: the claim takes ${claimBand}px and leaves ${figMax}px for the figure, under the ${MIN_PLATE}px floor \u2014 shorten the claim or split the beat`
+    );
+  }
   const claim = `<div class="claim" id="${sid}-c">${esc(p.claim)}</div>`;
   const figure = `<div class="figwrap" id="${sid}-f"><img src="assets/${esc(fig.src)}" alt="${esc(fig.caption)}" /></div>`;
   const caption = `<div class="caption" id="${sid}-cap">${esc(fig.caption)}</div>`;
@@ -2074,7 +2334,7 @@ ${body}`,
       // 560, not 640: the claim was set in a column narrow enough to break a
       // sentence over four lines while the figure beside it was capped short, so
       // both halves were smaller than the slide could carry.
-      ".cf-beside{display:grid;grid-template-columns:560px 1fr;gap:56px;align-items:center;margin-top:34px}",
+      `.cf-beside{display:grid;grid-template-columns:${BESIDE_COL}px 1fr;gap:56px;align-items:center;margin-top:34px}`,
       ".cf-under{display:grid;grid-template-columns:1fr 1fr;gap:56px;align-items:start;margin-top:26px}",
       // PORTRAIT. Two children, not three: the caption is wrapped with the plate
       // it captions. `space-between` across claim/figure/caption separately put
@@ -2105,7 +2365,11 @@ ${body}`,
 // src/emit/archetypes/data-table.ts
 var CELL_PAD = 14;
 var CELL_MAX = 52;
+var TH_TRACKING = 0.04;
 var PAD_Y_MAX = { wide: 40, tall: 68 };
+var PAD_Y_MIN = 12;
+var RULE_HEAD = 2;
+var RULE_ROW = 1;
 var dataTable = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
@@ -2115,15 +2379,31 @@ var dataTable = (beat, ctx) => {
   }
   const box = contentW(ctx.format);
   const units = table.columns.reduce((total, col, i) => {
-    const cells = [col, ...table.rows.map((r) => r[i] ?? "")];
-    return total + Math.max(...cells.map((c) => textWidth(c, 1, 600)));
+    const head2 = textWidth(col, 1, 600, TH_TRACKING, true);
+    const body2 = table.rows.map((r) => textWidth(r[i] ?? "", 1, 600, 0, true));
+    return total + Math.max(head2, ...body2);
   }, 0);
   const channels = 2 * CELL_PAD * table.columns.length;
   const cell = Math.max(MIN_FONT, Math.min(CELL_MAX, Math.floor((box - channels) / units)));
   const rows = table.rows.length + 1;
-  const spare = bodyBudget(ctx.format, p.eyebrow, p.headline, noteHeight(p.note, noteWidth(ctx.format), 26)) - rows * cell * 1.2;
+  const budget2 = bodyBudget(
+    ctx.format,
+    p.eyebrow,
+    p.headline,
+    noteHeight(p.note, noteWidth(ctx.format), 26),
+    34,
+    0
+  );
+  const spare = budget2 - rows * cell * 1.2;
   const roomiest = isPortrait(ctx.format) ? PAD_Y_MAX.tall : PAD_Y_MAX.wide;
-  const padY = Math.round(Math.max(12, Math.min(roomiest, spare / (2 * rows))));
+  const padY = Math.round(Math.max(PAD_Y_MIN, Math.min(roomiest, spare / (2 * rows))));
+  const drawn = rows * (cell * 1.2 + 2 * padY);
+  const canvas = budget2 + PAD_Y;
+  if (drawn > canvas) {
+    throw new Error(
+      `data-table ${beat.id}: table "${table.id}" has ${table.rows.length} rows, which with the header stand ${Math.round(drawn)}px tall at ${cell}px type on ${padY}px of row padding, and this slide has ${Math.round(canvas)}px. Every row of a cited table is drawn and none is set below ${MIN_FONT}px, so the lever is upstream of this beat: a shorter table in the source, or the one column that carries the argument in bar-compare.`
+    );
+  }
   const head = table.columns.map((c) => `<th>${mathy(c)}</th>`).join("");
   const body = table.rows.map(
     (row, i) => `<tr class="trow" id="${sid}-r${i}">${row.map((cell2) => `<td>${mathy(cell2)}</td>`).join("")}</tr>`
@@ -2183,16 +2463,30 @@ var dataTable = (beat, ctx) => {
     css: [
       chromeCss(theme),
       // Never derived *downwards*. Shrinking to fit is the one failure mode
-      // invariant 10 names: a 30px table clears every automated gate and is
+      // invariant 5 names: a 30px table clears every automated gate and is
       // unreadable projected. A table too wide at 40px eats its margin first and
-      // then trips the layout gate at the canvas edge — both of which someone can
-      // see, which small type is not. `cell` is floored at 40 for exactly that.
-      `table{border-collapse:collapse;width:100%;margin-top:34px;font-size:${cell}px}`,
-      `th,td{font-size:inherit;padding:${padY}px ${CELL_PAD}px;text-align:right;font-variant-numeric:tabular-nums;white-space:nowrap}`,
-      `th{color:${theme.dim};font-weight:500;letter-spacing:.04em;border-bottom:2px solid ${theme.rule}}`,
-      "td:first-child,th:first-child{text-align:left}",
-      `tbody tr{border-bottom:1px solid ${theme.rule}}`,
-      `tbody td{color:${theme.muted}}`,
+      // then trips the layout gate at the canvas edge, which someone can see —
+      // small type is not. A table too TALL to draw is refused above instead,
+      // because there the thing that leaves the canvas is the headline rather
+      // than the table. `cell` is floored at 40 for exactly that.
+      // SCOPED TO THIS SCENE, because two of these rules carry numbers this scene
+      // solved for itself. A deck shares one stylesheet, so an unscoped
+      // `td{padding:${padY}px}` is written once per data-table and the last one
+      // wins for all of them: two tables of different heights in one deck then
+      // render at a single padding, and the shorter one is drawn with the
+      // taller one's arithmetic. The height guard above cannot see that, because
+      // it reasons about the value this scene emitted.
+      //
+      // All six are scoped, not only the two that vary. Scoping `th,td` alone
+      // lifts it to an id's specificity and it would then beat
+      // `td:first-child{text-align:left}`, right-aligning the first column of
+      // every table — a fix that quietly breaks the thing next to it.
+      `#${sid} table{border-collapse:collapse;width:100%;margin-top:34px;font-size:${cell}px}`,
+      `#${sid} th,#${sid} td{font-size:inherit;padding:${padY}px ${CELL_PAD}px;text-align:right;font-variant-numeric:tabular-nums;white-space:nowrap}`,
+      `#${sid} th{color:${theme.dim};font-weight:500;letter-spacing:${TH_TRACKING}em;border-bottom:${RULE_HEAD}px solid ${theme.rule}}`,
+      `#${sid} td:first-child,#${sid} th:first-child{text-align:left}`,
+      `#${sid} tbody tr{border-bottom:${RULE_ROW}px solid ${theme.rule}}`,
+      `#${sid} tbody td{color:${theme.muted}}`,
       `.rownote{font-size:${BODY_SIZE}px;line-height:1.45;color:${theme.dim};margin-top:26px}`,
       // A table with nothing emphasised has no focal row, and so no ambient life.
       // `filter` again: the emphasis tween owns this row's colour and weight.
@@ -2439,6 +2733,21 @@ var CELL_MAX2 = 280;
 var MARGIN = 6;
 var MAX_LINES = 2;
 var FIELD_TOP = 52;
+var NOTE_GAP = FIELD_TOP;
+var NOTE_LINES = 4;
+function noteColumn(note, size) {
+  const words = note.split(/\s+/).filter(Boolean);
+  const longest = Math.max(0, ...words.map((w) => textWidth(w, size)));
+  const whole = textWidth(note, size);
+  return { min: longest, want: Math.max(longest, whole / NOTE_LINES) };
+}
+function solveCell(cols, rows, boxW, boxH) {
+  return Math.min(
+    CELL_MAX2,
+    (boxW - 2 * MARGIN) / (cols + GAP * (cols - 1)),
+    (boxH - 2 * MARGIN) / (rows + GAP * (rows - 1))
+  );
+}
 var grid = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
@@ -2450,19 +2759,17 @@ var grid = (beat, ctx) => {
     }
   }
   const W = contentW(ctx.format);
-  const budget2 = bodyBudget(
+  const full = bodyBudget(ctx.format, p.eyebrow, p.headline, 0, FIELD_TOP);
+  const col = p.note ? noteColumn(p.note, BODY_SIZE) : void 0;
+  const stackedBudget = bodyBudget(
     ctx.format,
     p.eyebrow,
     p.headline,
     noteHeight(p.note, noteWidth(ctx.format)),
     FIELD_TOP
   );
-  const solve3 = (boxW) => {
-    const cell = Math.min(
-      CELL_MAX2,
-      (boxW - 2 * MARGIN) / (p.cols + GAP * (p.cols - 1)),
-      (budget2 - 2 * MARGIN) / (p.rows + GAP * (p.rows - 1))
-    );
+  const solve3 = (boxW, budget3) => {
+    const cell = solveCell(p.cols, p.rows, boxW, budget3);
     const gap = cell * GAP;
     return {
       cell,
@@ -2482,18 +2789,26 @@ var grid = (beat, ctx) => {
   };
   const hits = (a, b) => a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
   const crowded = p.regions.map((r, i) => p.regions.some((o, k) => k !== i && hits(r, o)));
-  const bare = solve3(W);
   const widest2 = Math.max(...p.regions.map((r) => textWidth(r.label, LABEL, 600)));
   const oneLine = Math.min(620, widest2 * 1.06);
   const wrapped = Math.min(620, widest2 / MAX_LINES * 1.12);
-  const free = W - bare.w - 2 * MARGIN;
-  const needsGutter = p.regions.some((r, i) => crowded[i] || !fitsInside(bare, r));
-  const lw = needsGutter ? Math.max(wrapped, Math.min(oneLine, free - 90)) : 0;
-  const gutter = needsGutter ? lw + 90 : 0;
-  const f = needsGutter ? solve3(W - gutter) : bare;
-  const inGutter = p.regions.map((r, i) => crowded[i] || !fitsInside(f, r));
-  const lines = (r) => wrap(r.label, LABEL, lw, 600).length;
-  const stackH = p.regions.filter((_, i) => inGutter[i]).reduce((t2, r, i) => t2 + lines(r) * LABEL * LH + (i > 0 ? 14 : 16), 0);
+  const layout2 = (budget3) => {
+    const bare = solve3(W, budget3);
+    const free = W - bare.w - 2 * MARGIN;
+    const needsGutter = p.regions.some((r, i) => crowded[i] || !fitsInside(bare, r));
+    const lw2 = needsGutter ? Math.max(wrapped, Math.min(oneLine, free - 90)) : 0;
+    const gutter2 = needsGutter ? lw2 + 90 : 0;
+    const f2 = needsGutter ? solve3(W - gutter2, budget3) : bare;
+    const inGutter2 = p.regions.map((r, i) => crowded[i] || !fitsInside(f2, r));
+    const lines2 = (r) => wrap(r.label, LABEL, lw2, 600).length;
+    const stackH2 = p.regions.filter((_, i) => inGutter2[i]).reduce((t2, r, i) => t2 + lines2(r) * LABEL * LH + (i > 0 ? 14 : 16), 0);
+    return { bare, f: f2, lw: lw2, gutter: gutter2, inGutter: inGutter2, lines: lines2, stackH: stackH2 };
+  };
+  const roomy = layout2(full);
+  const roomBeside = W - Math.ceil(roomy.f.w + 2 * MARGIN + roomy.gutter) - NOTE_GAP;
+  const beside = !isPortrait(ctx.format) && !!col && roomBeside >= col.min;
+  const budget2 = beside ? full : stackedBudget;
+  const { f, lw, gutter, inGutter, lines, stackH } = beside ? roomy : layout2(budget2);
   const H = Math.min(budget2, Math.max(f.h + 2 * MARGIN, stackH));
   const fx = MARGIN;
   const fy = (H - f.h) / 2;
@@ -2502,7 +2817,7 @@ var grid = (beat, ctx) => {
   const corner = Math.min(10, f.cell * 0.12);
   const cells = rows.flatMap(
     (row) => cols.map(
-      (col) => roundRect({ x: col.x, y: row.x, w: col.w, h: row.w }, corner, { class: "gcell" })
+      (col2) => roundRect({ x: col2.x, y: row.x, w: col2.w, h: row.w }, corner, { class: "gcell" })
     )
   ).join("");
   const stroke = Math.max(3, Math.min(6, f.cell * 0.16));
@@ -2602,7 +2917,11 @@ var grid = (beat, ctx) => {
   );
   const note = p.note ? `
 <div class="gdnote" id="${id(sid, "note")}">${esc(p.note)}</div>` : "";
-  const html = `${chrome(sid, p.eyebrow, p.headline, W)}
+  const fieldW = Math.ceil(f.w + 2 * MARGIN + gutter);
+  const room = W - fieldW - NOTE_GAP;
+  const noteW = col ? Math.round(Math.min(col.want, room)) : 0;
+  const html = beside ? `${chrome(sid, p.eyebrow, p.headline, W)}
+<div class="growbeside"><div class="gwrap" style="width:${fieldW}px;flex:none">${field}</div><div class="gnotecol" style="width:${noteW}px">${note}</div></div>` : `${chrome(sid, p.eyebrow, p.headline, W)}
 <div class="gwrap">${field}</div>${note}`;
   const drawn = 1.6;
   const tl = [
@@ -2678,6 +2997,16 @@ var grid = (beat, ctx) => {
     css: [
       chromeCss(theme),
       ".gwrap{margin-top:52px}",
+      // The note beside the field rather than under it. `align-items:center` sets
+      // it against the middle of the lattice, and the column takes what the field
+      // left — which `beside` already proved is at least `NOTE_COL`. `margin-top`
+      // on the note is zeroed because `noteCss` sets one for the stacked layout,
+      // where it is the gap under the field; here the gap is horizontal.
+      `.growbeside{display:flex;align-items:center;gap:${NOTE_GAP}px}`,
+      // `max-width:none` because `noteCss` caps the stacked note at `NOTE_MAX_W`,
+      // which is a measure for a note running the full content width. Here the
+      // column is already the width the note asked for, and the cap would fight it.
+      ".growbeside .gdnote{margin-top:0;max-width:none}",
       `.gcell{fill:${theme.panel};stroke:${theme.rule};stroke-width:1}`,
       // `fill-opacity` and the dash offset are what the reveal animates; the
       // stylesheet holds the pre-reveal state so a still render is a bare field.
@@ -2736,8 +3065,8 @@ var lineChart = (beat, ctx) => {
   const budget2 = bodyBudget(ctx.format, p.eyebrow, p.headline, below, CHART_TOP);
   const H = Math.round(tall ? Math.min(budget2, width * TALL_ASPECT) : budget2);
   const last = p.points[p.points.length - 1];
-  const valueW = String(last?.y ?? "").length * 40 * 0.58;
-  const labelW = (last?.x ?? "").length * 40 * 0.68;
+  const valueW = textWidth(String(last?.y ?? ""), 40);
+  const labelW = textWidth(last?.x ?? "", 40);
   const padR = Math.max(PAD2.r, Math.ceil(Math.max(valueW, labelW) / 2) + 16);
   const plotW = width - PAD2.l - padR;
   const plotH = H - PAD2.t - PAD2.b;
@@ -2750,7 +3079,31 @@ var lineChart = (beat, ctx) => {
   );
   const grid2 = ticks.map((v) => `<line x1="${PAD2.l}" y1="${n2(y(v))}" x2="${width - padR}" y2="${n2(y(v))}" />`).join("");
   const yLabels = ticks.map((v) => `<text x="${PAD2.l - 22}" y="${n2(y(v) + 13)}">${v.toFixed(scale.decimals)}</text>`).join("");
-  const xLabels = p.points.map((pt, i) => `<text x="${n2(x(i))}" y="${H - PAD2.b + 56}">${esc(pt.x)}</text>`).join("");
+  const fitIndices = (widthAt, firstAnchoredStart) => {
+    const leftEdge = (i) => i === 0 && firstAnchoredStart ? x(i) : x(i) - widthAt(i) / 2;
+    const rightEdge = (i) => i === 0 && firstAnchoredStart ? x(i) + widthAt(i) : x(i) + widthAt(i) / 2;
+    const kept = [];
+    const last2 = p.points.length - 1;
+    for (let i = 0; i <= last2; i++) {
+      const previous = kept[kept.length - 1];
+      if (i === last2) {
+        while (kept.length > 0 && rightEdge(kept[kept.length - 1]) + 8 > leftEdge(i)) {
+          kept.pop();
+        }
+        kept.push(i);
+      } else if (previous === void 0 || leftEdge(i) >= rightEdge(previous) + 8) {
+        kept.push(i);
+      }
+    }
+    return new Set(kept);
+  };
+  const LABEL_SIZE3 = 40;
+  const runW = (s) => textWidth(s, LABEL_SIZE3);
+  const catW = (s) => textWidth(s, LABEL_SIZE3);
+  const shownX = fitIndices((i) => catW(p.points[i]?.x ?? ""), false);
+  const xLabels = p.points.map(
+    (pt, i) => shownX.has(i) ? `<text x="${n2(x(i))}" y="${H - PAD2.b + 56}">${esc(pt.x)}</text>` : ""
+  ).join("");
   const path2 = p.points.map((pt, i) => `${i === 0 ? "M" : "L"}${n2(x(i))},${n2(y(pt.y))}`).join(" ");
   const length = p.points.reduce(
     (total, pt, i) => i === 0 ? 0 : total + Math.hypot(x(i) - x(i - 1), y(pt.y) - y(p.points[i - 1]?.y ?? pt.y)),
@@ -2759,11 +3112,29 @@ var lineChart = (beat, ctx) => {
   const dots = p.points.map(
     (pt, i) => `<circle class="dot" cx="${n2(x(i))}" cy="${n2(y(pt.y))}" r="${i === p.points.length - 1 ? 11 : 9}" fill="${i === p.points.length - 1 ? theme.tones.b : theme.accent}" />`
   ).join("");
-  const values = p.points.map((pt, i) => {
+  const shownValues = fitIndices((i) => runW(String(p.points[i]?.y ?? "")), true);
+  const showsValue = (i) => shownValues.has(i);
+  const values = p.points.map((pt, i) => ({ pt, i })).filter(({ i }) => showsValue(i)).map(({ pt, i }) => {
     const anchor = i === 0 ? ' text-anchor="start"' : "";
     return `<text class="pv"${anchor} x="${n2(x(i))}" y="${n2(Math.max(44, y(pt.y) - 26))}">${esc(String(pt.y))}</text>`;
   }).join("");
-  const deltas = (p.deltas ?? []).slice(0, p.points.length - 1).map((d, i) => {
+  const labelBox = (cx, cy, text2, anchorStart = false) => {
+    const w = runW(text2);
+    return { x: anchorStart ? cx : cx - w / 2, y: cy - LABEL_SIZE3, w, h: LABEL_SIZE3 };
+  };
+  const valueBoxes = p.points.map((pt, i) => ({ pt, i })).filter(({ i }) => showsValue(i)).map(({ pt, i }) => labelBox(x(i), Math.max(44, y(pt.y) - 26), String(pt.y), i === 0));
+  const overlaps = (a, b) => Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x) > 8 && Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y) > 8;
+  const deltaBoxes = (p.deltas ?? []).slice(0, p.points.length - 1).map((d, i) => {
+    const a = p.points[i];
+    const b = p.points[i + 1];
+    if (!a || !b) return null;
+    const mid = (y(a.y) + y(b.y)) / 2;
+    return labelBox((x(i) + x(i + 1)) / 2, tall ? mid + 52 : Math.max(44, mid - 28), d);
+  });
+  const deltasFit = deltaBoxes.every(
+    (d, i) => d !== null && !valueBoxes.some((v) => overlaps(d, v)) && deltaBoxes.slice(i + 1).every((o) => o === null || !overlaps(d, o))
+  );
+  const deltas = (deltasFit ? p.deltas ?? [] : []).slice(0, p.points.length - 1).map((d, i) => {
     const a = p.points[i];
     const b = p.points[i + 1];
     if (!a || !b) return "";
@@ -3490,6 +3861,9 @@ function stackLayout(p, format) {
   const inline = solve2(p, format, true);
   return inline.fits || inline.blockH < stacked.blockH ? inline : stacked;
 }
+function labelWeight(i, count) {
+  return i === count - 1 ? 700 : 600;
+}
 function solve2(p, format, inline) {
   const width = contentW(format);
   const boxH = contentH(format);
@@ -3499,19 +3873,23 @@ function solve2(p, format, inline) {
   const syMax = SY_MAX[k];
   const tMax = T_MAX[k];
   const noteW = (l) => inline && l.note !== void 0 ? textWidth(l.note, MIN_FONT, 400) + 28 : 0;
-  const want = Math.max(...p.layers.map((l) => textWidth(l.label, LABEL_SIZE2, 600) + noteW(l)));
+  const want = Math.max(
+    ...p.layers.map((l, i) => textWidth(l.label, LABEL_SIZE2, labelWeight(i, count)) + noteW(l))
+  );
   const colCap = inline ? width * 0.56 : width * 0.5;
   const colW = clamp(Math.ceil(want) + 12, Math.min(520, width * 0.34), colCap);
   const labelX = width - colW;
   const labelRoom = Math.min(
-    ...p.layers.map((l) => (colW - noteW(l)) / Math.max(1, textWidth(l.label, 1, 600)))
+    ...p.layers.map(
+      (l, i) => (colW - noteW(l)) / Math.max(1, textWidth(l.label, 1, labelWeight(i, count)))
+    )
   );
   const labelSize = Math.max(MIN_FONT, Math.min(LABEL_SIZE2, labelRoom));
-  const lines = p.layers.map((l) => {
+  const lines = p.layers.map((l, i) => {
     const nw = noteW(l);
     const labelMaxW = Math.max(labelSize, colW - nw);
     return {
-      label: wrap(l.label, labelSize, labelMaxW, 600),
+      label: wrap(l.label, labelSize, labelMaxW, labelWeight(i, count)),
       // 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, MIN_FONT, colW, 400),
@@ -3595,7 +3973,7 @@ var stack = (beat, ctx) => {
       { x: L.labelX, y: L.inline ? mid : mid - noteH / 2 },
       {
         size: L.labelSize,
-        weight: top ? 700 : 600,
+        weight: labelWeight(i, count),
         fill: top ? theme.tones.b : theme.fg,
         maxWidth: block.labelMaxW,
         lineHeight: 1.16,
@@ -3886,17 +4264,30 @@ function planCut(storyboard, source, format, opts = {}) {
   const speed = opts.speed ?? 1;
   const floor = storyboard.beats.filter((b) => b.weight >= format.minWeight);
   const seconds = {};
+  const undrawable = /* @__PURE__ */ new Set();
   floor.forEach((beat, i) => {
     const segments = opts.narration?.beats[beat.id];
-    const { scene } = stageScene(
-      emitScene(beat, { source, format, theme, sid: `s${i + 1}` }),
-      speed
-    );
-    const own = beatSeconds(beat.seconds * speed, scene, segments);
-    const tail = floor[i + 1]?.inside?.beat === beat.id ? MOVE_SECONDS + FADE_SECONDS : 0;
-    seconds[beat.id] = rnd(own + tail * speed);
+    let scene;
+    try {
+      ({ scene } = stageScene(emitScene(beat, { source, format, theme, sid: `s${i + 1}` }), 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);
+  });
+  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`);
+  }
+  const drawable = floor.filter((b) => !undrawable.has(b.id));
+  drawable.forEach((beat, i) => {
+    const tail = drawable[i + 1]?.inside?.beat === beat.id ? MOVE_SECONDS + FADE_SECONDS : 0;
+    seconds[beat.id] = rnd((seconds[beat.id] ?? 0) + tail * speed);
   });
-  return selectBeats(storyboard, format, seconds);
+  const board = undrawable.size ? { ...storyboard, beats: storyboard.beats.filter((b) => !undrawable.has(b.id)) } : storyboard;
+  return selectBeats(board, format, seconds);
 }
 function deckLook(storyboard, opts) {
   const base = resolveTheme(opts.theme ?? storyboard.theme);
@@ -3919,22 +4310,7 @@ function layout(storyboard, source, format, opts = {}) {
   const slides = [];
   const spoken = {};
   const entered = enteredParts(beats);
-  const drawable = opts.onBeatError ? beats.filter((beat) => {
-    try {
-      emitScene(beat, { source, format, theme, sid: "trial" });
-      return true;
-    } catch (err) {
-      opts.onBeatError(
-        beat.id,
-        err instanceof Error ? err : new Error(String(err))
-      );
-      return false;
-    }
-  }) : beats;
-  if (drawable.length === 0) {
-    throw new Error(`every one of ${beats.length} beat(s) failed to draw \u2014 there is no deck`);
-  }
-  const cuts = drawable.map((beat, i) => {
+  const cuts = beats.map((beat, i) => {
     const sid = `s${i + 1}`;
     const ctx = { source, format, theme, sid };
     const segments = opts.narration?.beats[beat.id];
@@ -4752,7 +5128,7 @@ var SENTENCES_PER_BEAT = 2;
 var FF_BEAT_SECONDS = 8;
 var MIN_BEAT_SECONDS = 4;
 var SHORT_FORM_CPS = 22;
-var CUE_OVERHEAD = 1.17;
+var CUE_OVERHEAD = 1.28;
 var COMFORTABLE_CPS = 17;
 var MAX_PLAYBACK = 1.25;
 var SPEAKING_STOPS = {
@@ -4795,8 +5171,9 @@ function durationPlan(prefs) {
     );
   }
   if (speedup > 1) {
+    const cue = cps * speedup * CUE_OVERHEAD;
     warnings.push(
-      `narration speaks at ${rate} to fit ${chars} characters a slide into ${speechSeconds.toFixed(1)}s \u2014 ${slow.chars} at normal speed. Subtitles run near ${(cps * speedup).toFixed(0)} characters per second against the ${COMFORTABLE_CPS} cps broadcast practice, which is the cost of the extra words.`
+      `narration speaks at ${rate} to fit ${chars} characters a slide into ${speechSeconds.toFixed(1)}s \u2014 ${slow.chars} at normal speed. Subtitles run near ${cue.toFixed(0)} characters per second against the ${COMFORTABLE_CPS} cps broadcast practice, which is the cost of the extra words.`
     );
   }
   const beatChars = Math.round(speechSeconds * cps * speedup);
@@ -5010,9 +5387,15 @@ DESCRIBING ARCHETYPES \u2014 the fallbacks
   data-table     A table with up to four rows revealed and toned. Use when the
                  cells themselves matter \u2014 mixed units, text values, a matrix the
                  reader must scan. If it is one column of numbers in one unit,
-                 that is bar-compare. params.tableId must name a table, and each
-                 highlight[].row must match one of that table's first-column
-                 values exactly.
+                 that is bar-compare. It draws EVERY row of the table it names and
+                 cannot show a subset. Five to seven rows is what a 16:9 slide
+                 holds \u2014 fewer under a long headline or a two-line note, more in
+                 portrait or where wider columns set the type smaller \u2014 and a
+                 table that does not fit is refused rather than shrunk, which
+                 fails the build. For a longer one, take the column that carries
+                 the argument to bar-compare, or cite it under another archetype.
+                 params.tableId must name a table, and each highlight[].row must
+                 match one of that table's first-column values exactly.
 
   callout        One to three short panels. The last resort, for structure that
                  has no shape at all: a definition, the limitations the source
@@ -5664,7 +6047,11 @@ function stopCount(holds) {
 }
 function stopsFor(beat, source, format, sid = "s1") {
   const ctx = { source, format, theme: ink, sid };
-  return stopCount(emitScene(beat, ctx).holds);
+  try {
+    return stopCount(emitScene(beat, ctx).holds);
+  } catch {
+    return 1;
+  }
 }
 function splitSentences(text2) {
   const parts = [];
@@ -7610,7 +7997,7 @@ function deckTools(opts) {
   const root2 = resolve4(opts.root);
   let cached;
   const found = async () => {
-    cached ??= await prereqs();
+    cached ??= await (opts.probe ?? prereqs)();
     return cached;
   };
   const insideRoot2 = (p) => {
@@ -7659,6 +8046,7 @@ function deckTools(opts) {
       }
       const settings = input.settings ?? {};
       const options = parseOptions(fieldsFor(settings));
+      const file = input.document_path ? insideRoot2(input.document_path) : void 0;
       const missing = missingFor(await found(), options);
       if (missing.length) {
         throw new Error(
@@ -7666,7 +8054,7 @@ function deckTools(opts) {
         );
       }
       const filename = input.document_path ? input.document_path.split(sep2).pop() : "document.md";
-      const bytes = input.document_path ? await readFile10(insideRoot2(input.document_path)) : new TextEncoder().encode(input.document_text);
+      const bytes = file ? await readFile10(file) : new TextEncoder().encode(input.document_text);
       if (bytes.byteLength > MAX_UPLOAD_BYTES) {
         throw new Error(
           `Document is ${(bytes.byteLength / 1e6).toFixed(1)} MB, over the ${(MAX_UPLOAD_BYTES / 1e6).toFixed(0)} MB cap.`
@@ -7728,7 +8116,11 @@ function report(view, dir) {
     steps: view.steps.map((s) => ({ name: s.name, state: s.state })),
     log: view.log.slice(-12),
     ...view.error ? { error: view.error } : {},
-    storyboard_path: join9(dir, "src", "storyboard.json"),
+    // `join(dir, "storyboard.json")` — where `runPipeline` actually writes it
+    // (src/server/pipeline.ts). This said `src/storyboard.json` for one run, which
+    // is the shape of the CLI's output directory and not the server's, and an
+    // agent told to read it would have found nothing there.
+    storyboard_path: join9(dir, "storyboard.json"),
     ...done && view.result ? {
       deck_path: join9(dir, "deck"),
       slides: view.result.slides,