@jokerized/decksmith 0.7.0 → 0.8.0

package/dist/index.js

@@ -864,35 +864,35 @@ function elbow(sid, from, to, o) {
   }
   return path(d, { ...strokeAttrs(o), "marker-end": `url(#${headId(sid, o.stroke)})` });
 }
-function tracks(width, count, gap, x0 = 0) {
-  const w = count > 1 ? (width - gap * (count - 1)) / count : width;
-  return Array.from({ length: count }, (_, i) => ({ x: x0 + i * (w + gap), w }));
+function tracks(width, count2, gap, x0 = 0) {
+  const w = count2 > 1 ? (width - gap * (count2 - 1)) / count2 : width;
+  return Array.from({ length: count2 }, (_, i) => ({ x: x0 + i * (w + gap), w }));
 }
 function fitBoxes(req) {
-  const count = req.labels.length;
+  const count2 = req.labels.length;
   const minGap = req.minGap ?? 24;
   const padEm = req.padEm ?? 0.8;
   const weight = req.weight ?? 600;
   const x0 = req.x0 ?? 0;
   const unit = Math.max(1, ...req.labels.map((l) => textWidth(l, 1, weight) + 2 * padEm));
-  const sizeAt = (gap) => count < 1 ? req.size : (req.width - gap * (count - 1)) / count / unit;
+  const sizeAt = (gap) => count2 < 1 ? req.size : (req.width - gap * (count2 - 1)) / count2 / unit;
   if (sizeAt(req.gap) >= req.size) {
-    return { ok: true, size: req.size, gap: req.gap, boxes: tracks(req.width, count, req.gap, x0) };
+    return { ok: true, size: req.size, gap: req.gap, boxes: tracks(req.width, count2, req.gap, x0) };
   }
-  if (count > 1 && sizeAt(minGap) >= req.size) {
-    const gap = (req.width - count * req.size * unit) / (count - 1);
-    return { ok: true, size: req.size, gap, boxes: tracks(req.width, count, gap, x0) };
+  if (count2 > 1 && sizeAt(minGap) >= req.size) {
+    const gap = (req.width - count2 * req.size * unit) / (count2 - 1);
+    return { ok: true, size: req.size, gap, boxes: tracks(req.width, count2, gap, x0) };
   }
   const size2 = sizeAt(minGap);
   if (size2 >= MIN_FONT) {
-    return { ok: true, size: size2, gap: minGap, boxes: tracks(req.width, count, minGap, x0) };
+    return { ok: true, size: size2, gap: minGap, boxes: tracks(req.width, count2, minGap, x0) };
   }
   return {
     ok: false,
     size: MIN_FONT,
     gap: minGap,
-    boxes: tracks(req.width, count, minGap, x0),
-    needed: count * MIN_FONT * unit + minGap * (count - 1)
+    boxes: tracks(req.width, count2, minGap, x0),
+    needed: count2 * MIN_FONT * unit + minGap * (count2 - 1)
   };
 }
 
@@ -1225,8 +1225,8 @@ var MID_GAP = 56;
 var BAND_GAP = 34;
 var COL_GAP = 28;
 var MIN_COL = 250;
-function lineBudget(count, stageH) {
-  const perSide = Math.max(1, Math.ceil(count / 2));
+function lineBudget(count2, stageH) {
+  const perSide = Math.max(1, Math.ceil(count2 / 2));
   const room = (stageH - (perSide - 1) * LAB_GAP) / perSide;
   const lines = Math.floor((room - ASCENT - RULE_LIFT - RULE_W) / (LAB * LAB_LH)) + 1;
   return Math.min(LINE_CEIL, Math.max(1, lines));
@@ -1637,7 +1637,7 @@ var HEAD_GAP = 14;
 var barCompare = (beat, ctx) => {
   const { sid, theme } = ctx;
   const p = beat.params;
-  const count = p.bars.length;
+  const count2 = p.bars.length;
   const W = contentW(ctx.format);
   const face = faceOf(ctx.theme.fontStack);
   const tall = isPortrait(ctx.format);
@@ -1651,7 +1651,7 @@ var barCompare = (beat, ctx) => {
     0,
     face
   );
-  let bar = Math.min(BAR_MAX, (avail - unitBand - FOOT) / (count + GAP_RATIO * (count - 1)));
+  let bar = Math.min(BAR_MAX, (avail - unitBand - FOOT) / (count2 + GAP_RATIO * (count2 - 1)));
   let pitch = bar * (1 + GAP_RATIO);
   const gutterMax = tall ? 0 : share(GUTTER_MAX, W);
   const gutterInner = tall ? W : gutterMax - GUTTER_PAD;
@@ -1673,7 +1673,7 @@ var barCompare = (beat, ctx) => {
   if (tall) {
     bar = Math.min(
       BAR_MAX,
-      (avail - unitBand - FOOT - count * head) / (count + GAP_RATIO * (count - 1))
+      (avail - unitBand - FOOT - count2 * head) / (count2 + GAP_RATIO * (count2 - 1))
     );
     pitch = head + bar * (1 + GAP_RATIO);
   } else {
@@ -1684,7 +1684,7 @@ var barCompare = (beat, ctx) => {
     }
   }
   const valueSize = Math.max(MIN_FONT, Math.min(VALUE_MAX, bar * 0.9));
-  const barsH = (count - 1) * pitch + head + bar;
+  const barsH = (count2 - 1) * pitch + head + bar;
   const foot = Math.max(
     0,
     Math.ceil(
@@ -1697,7 +1697,7 @@ var barCompare = (beat, ctx) => {
   const H = barsH + unitBand + foot;
   if (H > avail) {
     throw new Error(
-      `bar-compare ${beat.id}: ${count} bars with labels this long need ${Math.ceil(H)}px of the ${Math.floor(avail)}px this slide has. Shorten the labels or split the beat.`
+      `bar-compare ${beat.id}: ${count2} bars with labels this long need ${Math.ceil(H)}px of the ${Math.floor(avail)}px this slide has. Shorten the labels or split the beat.`
     );
   }
   const gutter = tall ? 0 : Math.min(
@@ -1850,7 +1850,7 @@ ${svg(id(sid, "chart"), W, H, body)}
 </div>${note2}`;
   const railsAt = 0.6;
   const barsAt = 0.95;
-  const step = Math.min(0.4, 2.4 / count);
+  const step = Math.min(0.4, 2.4 / count2);
   const grow = 0.85;
   const tl = [
     ...chromeIn(sid, p.eyebrow !== void 0),
@@ -1900,11 +1900,11 @@ ${svg(id(sid, "chart"), W, H, body)}
       );
     }
   }
-  const settled = barsAt + (count - 1) * step + grow + 0.05;
+  const settled = barsAt + (count2 - 1) * step + grow + 0.05;
   const holds = [settled + 0.2];
   const focal = rows.reduce((best, r) => Math.abs(r.value) > Math.abs(best.value) ? r : best);
   const spot = spotlighter(sid, ".bc-bar");
-  if (count > 1) tl.push(...spot.lit(`#${id(sid, "bar", focal.i)}`, settled));
+  if (count2 > 1) tl.push(...spot.lit(`#${id(sid, "bar", focal.i)}`, settled));
   const tailAt = settled + 0.3;
   if (p.unit) {
     tl.push(tween(`#${id(sid, "unit")}`, { opacity: 0 }, { opacity: 1, duration: 0.5 }, tailAt));
@@ -2397,6 +2397,90 @@ var dataTable = (beat, ctx) => {
   };
 };
 
+// src/emit/tex.ts
+import katex from "katex";
+var UNFIT_ATTR = "data-ds-unfit";
+var trust = (c) => c.command === "\\htmlClass";
+function texError(tex, display) {
+  try {
+    katex.renderToString(tex, {
+      displayMode: display,
+      throwOnError: true,
+      strict: false,
+      trust,
+      output: "html"
+    });
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+var LEFT = /\\left(?![a-zA-Z])/g;
+var RIGHT = /\\right(?![a-zA-Z])/g;
+var NO_INK = /\\label\{[^{}]*\}|\\nonumber(?![a-zA-Z])|\\notag(?![a-zA-Z])/g;
+function braceBalance(tex) {
+  let depth = 0;
+  for (let i = 0; i < tex.length; i++) {
+    const c = tex[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") depth--;
+  }
+  return depth;
+}
+var count = (tex, re) => (tex.match(re) ?? []).length;
+function repairTex(input, display) {
+  const repairs = [];
+  let tex = input;
+  let error = texError(tex, display);
+  if (error === null) return { tex, repairs, error };
+  const gone = tex.match(NO_INK) ?? [];
+  if (gone.length) {
+    tex = tex.replace(NO_INK, "").trim();
+    repairs.push(`removed ${gone.join(", ")}, which draw nothing`);
+    error = texError(tex, display);
+  }
+  const lefts = count(tex, LEFT);
+  const rights = count(tex, RIGHT);
+  if (error !== null && lefts !== rights) {
+    const n3 = Math.abs(lefts - rights);
+    tex = lefts > rights ? `${tex} ${"\\right.".repeat(n3)}` : `${"\\left.".repeat(n3)} ${tex}`;
+    repairs.push(
+      `${lefts} \\left against ${rights} \\right: added ${n3} invisible ${lefts > rights ? "\\right." : "\\left."} to balance them`
+    );
+    error = texError(tex, display);
+  }
+  const depth = braceBalance(tex);
+  if (error !== null && depth !== 0) {
+    const n3 = Math.abs(depth);
+    tex = depth > 0 ? `${tex}${"}".repeat(n3)}` : `${"{".repeat(n3)}${tex}`;
+    repairs.push(
+      `${n3} unclosed brace group(s): ${depth > 0 ? "closed at the end" : "opened at the start"}`
+    );
+    error = texError(tex, display);
+  }
+  const undefinedNames = [];
+  for (let round7 = 0; error !== null && round7 < 12; round7++) {
+    const m = /Undefined control sequence: \\([a-zA-Z]+)/.exec(error);
+    if (!m) break;
+    const name = m[1];
+    const next = tex.replace(new RegExp(`\\\\${name}(?![a-zA-Z])`, "g"), `\\operatorname{${name}}`);
+    if (next === tex) break;
+    tex = next;
+    undefinedNames.push(`\\${name}`);
+    error = texError(tex, display);
+  }
+  if (undefinedNames.length) {
+    repairs.push(
+      `${undefinedNames.join(", ")} ${undefinedNames.length === 1 ? "is" : "are"} never defined in the source \u2014 drawn as ${undefinedNames.length === 1 ? "its name" : "their names"} in upright type`
+    );
+  }
+  return { tex, repairs, error };
+}
+
 // src/emit/archetypes/equation-walk.ts
 var TRUST = 'function (c) { return c.command === "\\\\htmlClass"; }';
 var OPTS = `{ displayMode: true, trust: ${TRUST}, strict: false, output: "html" }`;
@@ -2411,6 +2495,9 @@ var SYNONYMS = [
 function normalise(tex) {
   let out = "";
   const map = [];
+  const ends = [];
+  const lead = [];
+  let hint = null;
   for (let i = 0; i < tex.length; ) {
     if (/\s/.test(tex[i])) {
       i++;
@@ -2422,19 +2509,19 @@ function normalise(tex) {
       const m = new RegExp(`^(?:${re.source})`).exec(rest);
       return m ? { len: m[0].length, to } : null;
     }).find(Boolean);
-    if (hit) {
-      for (const ch of hit.to) {
-        out += ch;
-        map.push(i);
-      }
-      i += hit.len;
-      continue;
+    const len = hit ? hit.len : 1;
+    const chars = hit ? hit.to : tex[i];
+    if (chars === "") hint ??= i;
+    for (const ch of chars) {
+      out += ch;
+      map.push(i);
+      ends.push(i + len);
+      lead.push(hint ?? i);
+      hint = null;
     }
-    out += tex[i];
-    map.push(i);
-    i++;
+    i += len;
   }
-  return { text: out, map };
+  return { text: out, map, ends, lead };
 }
 function locate(tex, term) {
   const hay = normalise(tex);
@@ -2442,58 +2529,131 @@ function locate(tex, term) {
   if (needle === "") return null;
   const at = hay.text.indexOf(needle);
   if (at < 0) return null;
-  const start = hay.map[at];
-  const lastNorm = at + needle.length - 1;
-  const lastOrig = hay.map[lastNorm];
-  let end = lastOrig + 1;
-  while (end < tex.length && (hay.map[lastNorm + 1] ?? tex.length) > end && /\s/.test(tex[end])) {
-    end++;
-  }
-  end = Math.max(end, hay.map[lastNorm + 1] ?? lastOrig + 1);
+  const start = hay.lead[at];
+  const end = hay.ends[at + needle.length - 1];
   return { start, end: Math.min(end, tex.length) };
 }
 function wrapTerms(tex, terms, beatId, cls = (t2) => `term t-${t2.tone}`) {
+  const checked = texError(tex, true) === null;
   let parts = [{ text: tex, raw: true }];
   const used = [];
   const missing = [];
+  const broken = [];
+  const joined = (ps) => ps.map((p) => p.text).join("");
   for (const term of terms) {
     let placed = false;
+    let found = false;
     for (let i = 0; i < parts.length && !placed; i++) {
       const part = parts[i];
       if (!part.raw) continue;
       const at = locate(part.text, term.tex);
       if (!at) continue;
-      parts = parts.toSpliced(
-        i,
-        1,
-        { text: part.text.slice(0, at.start), raw: true },
-        {
-          text: `\\htmlClass{${cls(term)}}{${part.text.slice(at.start, at.end)}}`,
-          raw: false
-        },
-        { text: part.text.slice(at.end), raw: true }
-      );
-      used.push(term);
-      placed = true;
+      found = true;
+      const body = `\\htmlClass{${cls(term)}}{${part.text.slice(at.start, at.end)}}`;
+      for (const text2 of [body, `{${body}}`]) {
+        const next = parts.toSpliced(
+          i,
+          1,
+          { text: part.text.slice(0, at.start), raw: true },
+          { text: text2, raw: false },
+          { text: part.text.slice(at.end), raw: true }
+        );
+        if (checked && texError(joined(next), true) !== null) continue;
+        parts = next;
+        used.push(term);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      missing.push(term);
+      if (found) broken.push(term);
     }
-    if (!placed) missing.push(term);
   }
   if (used.length === 0) {
     throw new Error(
-      `equation-walk ${beatId}: none of its ${terms.length} term(s) occur in the equation. Terms: ${terms.map((t2) => JSON.stringify(t2.tex)).join(", ")}. Equation: ${JSON.stringify(tex)}`
+      `equation-walk ${beatId}: none of its ${terms.length} term(s) ${broken.length ? "can be highlighted in" : "occur in"} the equation. Terms: ${terms.map((t2) => JSON.stringify(t2.tex)).join(", ")}. Equation: ${JSON.stringify(tex)}`
+    );
+  }
+  return { tex: joined(parts), used, missing, broken };
+}
+function droppedTerms(eqId, missing, broken) {
+  return missing.map(
+    (t2) => broken.includes(t2) ? `term ${JSON.stringify(t2.tex)} is in ${eqId} but no span around it parses, so it is not highlighted and its legend row ("${t2.label}") is left out` : `term ${JSON.stringify(t2.tex)} does not occur in ${eqId}, so its legend row ("${t2.label}") is left out`
+  );
+}
+function prepareWalk(eq, terms, beatId) {
+  const fixed = repairTex(eq.tex, true);
+  const notes = fixed.repairs.map((r) => `${eq.id} repaired before drawing: ${r}`);
+  const repairedTerms = terms.map((t2) => ({ ...t2, tex: repairTex(t2.tex, false).tex }));
+  if (fixed.error !== null) {
+    notes.push(
+      `${eq.id} does not parse even after repair (${fixed.error}), so it is shown as its TeX source in plain text \u2014 ${JSON.stringify(eq.tex)}`
     );
+    const parts = segment(eq.tex, [...terms]);
+    if (parts.used.length === 0) {
+      throw new Error(
+        `equation-walk ${beatId}: none of its ${terms.length} term(s) occur in the equation. Terms: ${terms.map((t2) => JSON.stringify(t2.tex)).join(", ")}. Equation: ${JSON.stringify(eq.tex)}`
+      );
+    }
+    notes.push(...droppedTerms(eq.id, parts.missing, []));
+    return {
+      raw: eq.tex,
+      plain: { error: fixed.error },
+      used: parts.used,
+      missing: parts.missing,
+      notes
+    };
   }
-  return { tex: parts.map((part) => part.text).join(""), used, missing };
+  const walk = wrapTerms(fixed.tex, repairedTerms, beatId);
+  const back = (ts) => ts.map((t2) => terms[repairedTerms.indexOf(t2)]);
+  const used = back(walk.used);
+  const missing = back(walk.missing);
+  notes.push(...droppedTerms(eq.id, missing, back(walk.broken)));
+  return { tex: walk.tex, raw: fixed.tex, used, missing, notes };
+}
+function segment(tex, terms) {
+  let parts = [{ text: tex }];
+  const used = [];
+  const missing = [];
+  for (const term of terms) {
+    const i = parts.findIndex((p) => !p.term && locate(p.text, term.tex));
+    const part = parts[i];
+    const at = part && locate(part.text, term.tex);
+    if (!part || !at) {
+      missing.push(term);
+      continue;
+    }
+    parts = parts.toSpliced(
+      i,
+      1,
+      { text: part.text.slice(0, at.start) },
+      { text: part.text.slice(at.start, at.end), term },
+      { text: part.text.slice(at.end) }
+    );
+    used.push(term);
+  }
+  return { parts, used, missing };
+}
+function plainHtml(tex, terms) {
+  return segment(tex, terms).parts.map(
+    (p) => p.term ? `<span class="term t-${p.term.tone}">${esc(p.text)}</span>` : esc(p.text)
+  ).join("");
+}
+function chipSetup(sid, term) {
+  const fixed = repairTex(term.tex, false);
+  const el = `document.getElementById("${sid}-chip-${term.tone}")`;
+  return fixed.error === null ? `katex.render('${js(fixed.tex)}', ${el}, ${INLINE_OPTS});` : `${el}.textContent = '${js(term.tex)}';`;
 }
 function equationSize(tex) {
   return tex.length > 120 ? 68 : tex.length > 90 ? 80 : tex.length > 55 ? 92 : 108;
 }
-var NO_INK = /\\(math[a-z]+|text[a-z]*|bm|boldsymbol|displaystyle|textstyle|scriptstyle|left|right|operatorname|limits|nolimits|htmlClass|hspace|phantom|[,;:!])/g;
+var NO_INK2 = /\\(math[a-z]+|text[a-z]*|bm|boldsymbol|displaystyle|textstyle|scriptstyle|left|right|operatorname|limits|nolimits|htmlClass|hspace|phantom|[,;:!])/g;
 var GLYPH_EM = 0.9;
 function texUnits(tex) {
   let ems = 0;
   for (const m of tex.matchAll(/\\qquad|\\quad/g)) ems += m[0] === "\\qquad" ? 2 : 1;
-  const glyphs = tex.replace(/\\q?quad/g, "").replace(NO_INK, "").replace(/[{}\s_^]/g, "");
+  const glyphs = tex.replace(/\\q?quad/g, "").replace(NO_INK2, "").replace(/[{}\s_^]/g, "");
   return ems + glyphs.length * GLYPH_EM;
 }
 function statements(tex, stacked) {
@@ -2501,6 +2661,100 @@ function statements(tex, stacked) {
   const parts = tex.split(/\\qquad|\\quad|\\\\/).map((s) => s.trim()).filter(Boolean);
   return parts.length > 0 ? parts : [tex];
 }
+var PLAIN_FONT = 48;
+function mathFit(sid, targets, shown, raw2, want, floor) {
+  return [
+    `var dsEqFit = (function () {
+                var box = document.getElementById("${sid}-eq");
+                var slide = box && box.parentNode;
+                var bw = box ? box.getBoundingClientRect().width : 0;
+                if (!(bw > 0) || !slide) return "unmeasured";
+                var targets = [${targets.map((id2) => `"${id2}"`).join(", ")}].map(function (id) { return document.getElementById(id); });
+                var TEX = [${shown.map((s) => `'${js(s)}'`).join(", ")}];
+                var spill0 = slide.scrollHeight - slide.clientHeight;
+                function extent(each) {
+                  var w = 0;
+                  targets.forEach(function (t) {
+                    var lo = Infinity, hi = -Infinity;
+                    Array.prototype.forEach.call(t.querySelectorAll(".katex-html > .base"), function (b) {
+                      var r = b.getBoundingClientRect();
+                      if (each) w = Math.max(w, r.width);
+                      else { lo = Math.min(lo, r.left); hi = Math.max(hi, r.right); }
+                    });
+                    if (!each && hi > lo) w = Math.max(w, hi - lo);
+                  });
+                  return w;
+                }
+                function fits(each) {
+                  return extent(each) <= bw + 0.5 && slide.scrollHeight - slide.clientHeight <= Math.max(1, spill0 + 1);
+                }
+                function settle(each, size) {
+                  size = Math.max(${floor}, Math.min(${want}, Math.floor(size)));
+                  box.style.fontSize = size + "px";
+                  while (!fits(each) && size > ${floor}) {
+                    size = Math.max(${floor}, size - 2);
+                    box.style.fontSize = size + "px";
+                  }
+                  return fits(each);
+                }
+                if (fits(false)) return "fits";
+                var size = parseFloat(box.style.fontSize);
+                if (settle(false, (size * bw) / extent(false))) return "scaled";
+                targets.forEach(function (t, i) { katex.render("\\\\displaystyle " + TEX[i], t, ${INLINE_OPTS}); });
+                box.className += " eq-broken";
+                box.style.fontSize = "${want}px";
+                var wb = extent(true);
+                if (settle(true, wb > bw ? (${want} * bw) / wb : ${want})) return "broken";
+                box.setAttribute("${UNFIT_ATTR}", '${js(raw2)}');
+                return "unfit";
+              })()`
+  ];
+}
+function chipFit(sid, terms) {
+  if (terms.length === 0) return [];
+  return [
+    `[${terms.map((t2) => `"${t2.tone}"`).join(", ")}].forEach(function (tone) {
+                var chip = document.getElementById("${sid}-chip-" + tone);
+                var r = chip && chip.getBoundingClientRect();
+                if (!r || !(r.height > 0)) return;
+                var k = chip.offsetHeight / r.height;
+                var top = r.top, bottom = r.bottom;
+                Array.prototype.forEach.call(chip.querySelectorAll("span"), function (el) {
+                  for (var n = el.firstChild; n; n = n.nextSibling) {
+                    if (n.nodeType === 3 && n.nodeValue.trim()) {
+                      var q = el.getBoundingClientRect();
+                      top = Math.min(top, q.top);
+                      bottom = Math.max(bottom, q.bottom);
+                      return;
+                    }
+                  }
+                });
+                var cs = getComputedStyle(chip);
+                if (top < r.top) chip.style.paddingTop = parseFloat(cs.paddingTop) + Math.ceil((r.top - top) * k) + "px";
+                if (bottom > r.bottom) chip.style.paddingBottom = parseFloat(cs.paddingBottom) + Math.ceil((bottom - r.bottom) * k) + "px";
+              })`
+  ];
+}
+var SWELL = 1.16;
+var SWELL_EM = 0.06;
+function swellFit(sid, terms) {
+  return [
+    `var dsSwell = (function () {
+                var out = {};
+                var box = document.getElementById("${sid}-eq");
+                var k = box && box.offsetWidth ? box.getBoundingClientRect().width / box.offsetWidth : 1;
+                var em = box ? parseFloat(getComputedStyle(box).fontSize) : 0;
+                [${terms.map((t2) => `"${t2.tone}"`).join(", ")}].forEach(function (tone) {
+                  var w = 0;
+                  Array.prototype.forEach.call(document.querySelectorAll("#${sid} .t-" + tone), function (el) {
+                    w = Math.max(w, el.getBoundingClientRect().width / k);
+                  });
+                  out[tone] = w > 0 && em > 0 ? Math.min(${SWELL}, Math.round((1 + (2 * ${SWELL_EM} * em) / w) * 1000) / 1000) : ${SWELL};
+                });
+                return out;
+              })()`
+  ];
+}
 function legendRows(sid, terms, theme) {
   return terms.map(
     (t2) => `<div class="leg" id="${sid}-leg-${t2.tone}"><span class="chip" id="${sid}-chip-${t2.tone}" style="color:${theme.tones[t2.tone]}"></span><span>${esc(t2.label)}</span></div>`
@@ -2516,7 +2770,10 @@ function legendCss(theme) {
     `.leg{display:flex;gap:26px;align-items:baseline;max-width:1400px;font-size:48px;color:${theme.muted}}`,
     // A common chip width, so the labels share a spine too — the glyphs inside
     // are one symbol each and their natural widths differ by a few pixels.
-    `.chip{display:inline-block;min-width:72px;text-align:center;background:${theme.panel};border-radius:10px;padding:2px 20px;white-space:nowrap;font-weight:700}`
+    // `flex:none`: beside a long label the chip used to SHRINK below its own
+    // nowrap TeX, which then ran out of the painted box into the label — on a
+    // HypePaper deck, "pixelcoord" 91px past the chip's right edge.
+    `.chip{display:inline-block;flex:none;min-width:72px;text-align:center;background:${theme.panel};border-radius:10px;padding:2px 20px;white-space:nowrap;font-weight:700}`
   ].join("\n");
 }
 var equationWalk = (beat, ctx) => {
@@ -2528,37 +2785,53 @@ var equationWalk = (beat, ctx) => {
       `equation-walk ${beat.id}: no equation "${p.equationId}" in source ${ctx.source.id}`
     );
   }
-  const walk = wrapTerms(eq.tex, p.terms, beat.id);
+  const walk = prepareWalk(eq, p.terms, beat.id);
   const terms = walk.used;
   const legend = legendRows(sid, terms, theme);
-  const stacked = isPortrait(ctx.format);
-  const raw2 = statements(eq.tex, stacked);
-  const shown = statements(walk.tex, stacked);
-  const longest = raw2.reduce((a, b) => b.length > a.length ? b : a);
-  const size2 = Math.max(
-    MIN_FONT,
-    Math.min(
-      equationSize(longest),
-      Math.floor(contentW(ctx.format) / Math.max(...raw2.map(texUnits)))
-    )
-  );
-  const body = shown.length === 1 ? "" : shown.map((_, i) => `<div id="${sid}-eq${i}"></div>`).join("\n    ");
+  const chips = terms.map((t2) => chipSetup(sid, t2));
+  let eqHtml;
+  let setup;
+  let measure4;
+  if (walk.plain) {
+    eqHtml = `<div class="eq eq-plain" id="${sid}-eq" style="font-size:${PLAIN_FONT}px">${plainHtml(eq.tex, terms)}</div>`;
+    setup = chips;
+    measure4 = [...chipFit(sid, terms), ...swellFit(sid, terms)];
+  } else {
+    const wrapped = walk.tex;
+    const split = statements(wrapped, isPortrait(ctx.format));
+    const stacked = split.length > 1 && split.every((s) => texError(s, true) === null);
+    const raw2 = statements(walk.raw, stacked);
+    const shown = stacked ? split : [wrapped];
+    const longest = raw2.reduce((a, b) => b.length > a.length ? b : a);
+    const want = equationSize(longest);
+    const size2 = Math.max(
+      MIN_FONT,
+      Math.min(want, Math.floor(contentW(ctx.format) / Math.max(...raw2.map(texUnits))))
+    );
+    const body = shown.length === 1 ? "" : shown.map((_, i) => `<div id="${sid}-eq${i}"></div>`).join("\n    ");
+    eqHtml = `<div class="eq${shown.length === 1 ? "" : " eqstack"}" id="${sid}-eq" style="font-size:${size2}px">${body}</div>`;
+    const targets = shown.map((_, i) => `${sid}-eq${shown.length === 1 ? "" : i}`);
+    setup = [
+      `var OPTS = ${OPTS};`,
+      ...shown.map(
+        (part, i) => `katex.render('${js(part)}', document.getElementById("${targets[i]}"), OPTS);`
+      ),
+      ...chips
+    ];
+    measure4 = [
+      ...chipFit(sid, terms),
+      ...mathFit(sid, targets, shown, walk.raw, want, MIN_FONT),
+      // Last: it measures each term at the size the fit settled on.
+      ...swellFit(sid, terms)
+    ];
+  }
   const html = `${chrome(sid, p.eyebrow, p.headline, contentW(ctx.format))}
 <div class="eqslide">
-  <div class="eq${shown.length === 1 ? "" : " eqstack"}" id="${sid}-eq" style="font-size:${size2}px">${body}</div>
+  ${eqHtml}
   <div class="legend">
     ${legend}
   </div>
 </div>`;
-  const setup = [
-    `var OPTS = ${OPTS};`,
-    ...shown.map(
-      (part, i) => `katex.render('${js(part)}', document.getElementById("${sid}-eq${shown.length === 1 ? "" : i}"), OPTS);`
-    ),
-    ...terms.map(
-      (t2) => `katex.render('${js(t2.tex)}', document.getElementById("${sid}-chip-${t2.tone}"), ${INLINE_OPTS});`
-    )
-  ];
   const tl = [
     ...chromeIn(sid, p.eyebrow !== void 0),
     tween(`#${sid}-eq`, { opacity: 0, y: 22 }, { opacity: 1, y: 0, duration: 0.7 }, 0.8)
@@ -2570,6 +2843,7 @@ var equationWalk = (beat, ctx) => {
   );
   const holds = [];
   const spot = spotlighter(sid, ".term");
+  const swell = (t2) => raw(`dsSwell.${t2.tone}`);
   terms.forEach((term, i) => {
     const at = first + i * step;
     const colour = theme.tones[term.tone];
@@ -2586,13 +2860,15 @@ var equationWalk = (beat, ctx) => {
       tween(
         `#${sid} .t-${term.tone}`,
         { color: theme.fg, scale: 1 },
-        { color: colour, scale: 1.16, duration: 0.5 },
+        { color: colour, scale: swell(term), duration: 0.5 },
         at
       )
     );
     const prev = terms[i - 1];
     if (prev) {
-      tl.push(tween(`#${sid} .t-${prev.tone}`, { scale: 1.16 }, { scale: 1, duration: 0.4 }, at));
+      tl.push(
+        tween(`#${sid} .t-${prev.tone}`, { scale: swell(prev) }, { scale: 1, duration: 0.4 }, at)
+      );
     }
     holds.push(at + 0.6);
   });
@@ -2600,7 +2876,7 @@ var equationWalk = (beat, ctx) => {
   if (last) {
     const at = first + terms.length * step;
     tl.push(
-      tween(`#${sid} .t-${last.tone}`, { scale: 1.16 }, { scale: 1, duration: 0.4 }, at),
+      tween(`#${sid} .t-${last.tone}`, { scale: swell(last) }, { scale: 1, duration: 0.4 }, at),
       ...spot.restore(at)
     );
   }
@@ -2608,6 +2884,8 @@ var equationWalk = (beat, ctx) => {
     html,
     tl,
     setup,
+    measure: measure4,
+    ...walk.notes.length ? { warnings: walk.notes } : {},
     holds: holdsWithin(holds, beat.seconds),
     css: [
       chromeCss(theme),
@@ -2627,6 +2905,15 @@ var equationWalk = (beat, ctx) => {
       // has its margin zeroed above, so without an explicit gap the two lines
       // would touch and read as one equation broken mid-expression.
       ".eqstack{display:flex;flex-direction:column;gap:32px}",
+      // Set by `mathFit` when one line will not fit at the floor: the display is
+      // re-rendered inline, where KaTeX breaks after a top-level relation or
+      // operator, and the lines it breaks into are centred and spaced as lines.
+      ".eq-broken{line-height:1.5}",
+      // An equation KaTeX refuses, shown as its source. Wraps anywhere, because
+      // TeX source has few spaces and must not run off the slide either. The
+      // deck's own face, not a monospace one: a family the bundle does not
+      // declare falls back silently (invariant 9).
+      ".eq-plain{white-space:pre-wrap;overflow-wrap:anywhere}",
       // Transforms do not apply to inline boxes, and KaTeX spans are inline.
       ".term{display:inline-block}",
       legendCss(theme),
@@ -2641,26 +2928,67 @@ var equationWalk = (beat, ctx) => {
 
 // src/emit/archetypes/equation-morph.ts
 var MORPH_SECONDS = 1.6;
-var equationMorph = (beat, ctx) => {
-  const { sid, theme } = ctx;
+function prepareMorph(beat, source) {
   const p = beat.params;
   const find3 = (id2) => {
-    const eq = ctx.source.equations.find((e) => e.id === id2);
+    const eq = source.equations.find((e) => e.id === id2);
     if (!eq)
-      throw new Error(`equation-morph ${beat.id}: no equation "${id2}" in source ${ctx.source.id}`);
+      throw new Error(`equation-morph ${beat.id}: no equation "${id2}" in source ${source.id}`);
     return eq;
   };
-  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) {
+  const notes = [];
+  const drawable = (eq) => {
+    const fixed = repairTex(eq.tex, true);
+    if (fixed.error !== null) {
+      throw new Error(
+        `equation-morph ${beat.id}: ${eq.id} does not parse even after repair (${fixed.error}), and a morph cannot be drawn from plain text. Formula: ${JSON.stringify(eq.tex)}`
+      );
+    }
+    notes.push(...fixed.repairs.map((r) => `${eq.id} repaired before drawing: ${r}`));
+    return { id: eq.id, tex: fixed.tex };
+  };
+  const a = drawable(find3(p.fromId));
+  const b = drawable(find3(p.toId));
+  const repaired = p.terms.map((t2) => ({ ...t2, tex: repairTex(t2.tex, false).tex }));
+  const original = (t2) => p.terms[repaired.indexOf(t2)];
+  let keyed = repaired.filter((t2) => locate(a.tex, t2.tex) && locate(b.tex, t2.tex));
+  if (keyed.length === 0) {
     throw new Error(
       `equation-morph ${beat.id}: none of its ${p.terms.length} term(s) occur in both equations. Terms: ${p.terms.map((t2) => JSON.stringify(t2.tex)).join(", ")}. From: ${JSON.stringify(a.tex)}. To: ${JSON.stringify(b.tex)}`
     );
   }
+  notes.push(
+    ...repaired.filter((t2) => !keyed.includes(t2)).map(
+      (t2) => `term ${JSON.stringify(original(t2).tex)} does not occur in both ${a.id} and ${b.id}, so it does not travel and its legend row ("${t2.label}") is left out`
+    )
+  );
   const cls = (t2) => `term t-${t2.tone} ds-k-${t2.tone}`;
-  const wa = wrapTerms(a.tex, both, beat.id, cls).tex;
-  const wb = wrapTerms(b.tex, both, beat.id, cls).tex;
+  let wa = wrapTerms(a.tex, keyed, beat.id, cls);
+  let wb = wrapTerms(b.tex, keyed, beat.id, cls);
+  const paired = keyed.filter((t2) => wa.used.includes(t2) && wb.used.includes(t2));
+  if (paired.length < keyed.length) {
+    const unpaired = keyed.filter((t2) => !paired.includes(t2));
+    notes.push(
+      ...unpaired.map(
+        (t2) => `term ${JSON.stringify(original(t2).tex)} cannot be marked on both lines without breaking one, so it does not travel and its legend row ("${t2.label}") is left out`
+      )
+    );
+    if (paired.length === 0) {
+      throw new Error(
+        `equation-morph ${beat.id}: no term can be marked on both lines without breaking one. Terms: ${p.terms.map((t2) => JSON.stringify(t2.tex)).join(", ")}`
+      );
+    }
+    keyed = paired;
+    wa = wrapTerms(a.tex, keyed, beat.id, cls);
+    wb = wrapTerms(b.tex, keyed, beat.id, cls);
+  }
+  const both = keyed.map(original);
+  return { a, b, wa: wa.tex, wb: wb.tex, both, notes };
+}
+var equationMorph = (beat, ctx) => {
+  const { sid, theme } = ctx;
+  const p = beat.params;
+  const { a, b, wa, wb, both, notes } = prepareMorph(beat, ctx.source);
   const size2 = Math.max(
     MIN_FONT,
     Math.min(
@@ -2682,9 +3010,7 @@ var equationMorph = (beat, ctx) => {
     `var OPTS = ${OPTS};`,
     `katex.render('${js(wa)}', document.getElementById("${sid}-eqa"), OPTS);`,
     `katex.render('${js(wb)}', document.getElementById("${sid}-eqb"), OPTS);`,
-    ...both.map(
-      (t2) => `katex.render('${js(t2.tex)}', document.getElementById("${sid}-chip-${t2.tone}"), ${INLINE_OPTS});`
-    )
+    ...both.map((t2) => chipSetup(sid, t2))
   ];
   const first = 1.8;
   const at = Math.round(
@@ -2717,8 +3043,11 @@ var equationMorph = (beat, ctx) => {
     setup,
     // SEAM B: the plan is browser geometry after fonts, so it is built inside
     // the ready gate, and the plugin tween above finds it on the host.
-    measure: [`DSMorph.build(document.getElementById("${sid}-morph"));`],
+    // The chips are fitted before the plan is built: growing one moves the
+    // legend, and nothing the morph measures may move after it has measured.
+    measure: [...chipFit(sid, both), `DSMorph.build(document.getElementById("${sid}-morph"));`],
     plugins: ["dsMorph"],
+    ...notes.length ? { warnings: notes } : {},
     holds: holdsWithin([first, at + MORPH_SECONDS + 0.4], beat.seconds),
     css: [
       chromeCss(theme),
@@ -3299,16 +3628,16 @@ var lineChart = (beat, ctx) => {
   </svg>${readout}
 </div>`;
   const draw2 = 0.8;
-  const count = p.points.length;
-  const idealStep = Math.min(0.45, DRAW_SECONDS / count);
+  const count2 = p.points.length;
+  const idealStep = Math.min(0.45, DRAW_SECONDS / count2);
   const spine = draw2 + SEPARATE + RESHAPE_SECONDS + (p.readout ? 0.8 : 0) + 0.15;
-  const shownDeltas = deltas ? Math.min((p.deltas ?? []).length, count - 1) : 0;
+  const shownDeltas = deltas ? Math.min((p.deltas ?? []).length, count2 - 1) : 0;
   const tailAfter = (s) => Math.max(
-    s * count + 0.4,
+    s * count2 + 0.4,
     // the ring: its walk, then the 0.4s it takes to leave
-    0.3 + s * (count - 1),
+    0.3 + s * (count2 - 1),
     // the dots
-    0.5 + s * (count - 1),
+    0.5 + s * (count2 - 1),
     ...shownDeltas > 0 ? [0.95 + s * (shownDeltas - 1)] : []
   );
   const room = beat.seconds - spine;
@@ -3371,8 +3700,8 @@ var lineChart = (beat, ctx) => {
       )
     );
   }
-  const walk = cmp ? sec(step * count) : DRAW_SECONDS;
-  if (count > 1) {
+  const walk = cmp ? sec(step * count2) : DRAW_SECONDS;
+  if (count2 > 1) {
     const route = p.points.map((pt, i) => ({ x: nv(x(i) - first.x), y: nv(y(pt.y) - first.y) }));
     tl.push(
       tween(`#${sid}-ring`, { opacity: 0 }, { opacity: 1, duration: 0.25 }, settled),
@@ -3387,7 +3716,7 @@ var lineChart = (beat, ctx) => {
       )
     );
   }
-  const drawn = settled + (cmp ? tailAfter(step) : step * count + 0.4);
+  const drawn = settled + (cmp ? tailAfter(step) : step * count2 + 0.4);
   const holds = cmp ? [lift2, drawn] : [drawn];
   if (p.readout) {
     tl.push(
@@ -3403,7 +3732,7 @@ var lineChart = (beat, ctx) => {
     return {
       ...lineChart({ ...beat, params: { ...p, compare: void 0 } }, ctx),
       warnings: [
-        `line-chart ${beat.id}: a comparison against "${cmp.label}" over ${count} points needs ${need}s and the beat is ${beat.seconds}s, so the chart was drawn without it. Lengthen the beat to keep the comparison.`
+        `line-chart ${beat.id}: a comparison against "${cmp.label}" over ${count2} points needs ${need}s and the beat is ${beat.seconds}s, so the chart was drawn without it. Lengthen the beat to keep the comparison.`
       ]
     };
   }
@@ -3483,7 +3812,7 @@ var V_BOX_H = 268;
 var V_LOOP_SIDE = 56;
 var V_LOOP_PAD = 18;
 function columnLayout(stageW, stageH, stages, face, loop) {
-  const count = stages.length;
+  const count2 = stages.length;
   const loopW = loop ? Math.max(240, Math.round(stageW * 0.32)) : 0;
   const boxX = M;
   const boxW = stageW - 2 * M - (loop ? V_LOOP_SIDE + V_LOOP_PAD + loopW : 0);
@@ -3500,11 +3829,11 @@ function columnLayout(stageW, stageH, stages, face, loop) {
       return Math.ceil(2 * PAD_Y2 + label + (note2 > 0 ? NOTE_TOP + note2 * NOTE * NOTE_LH : 0));
     })
   );
-  const room = (stageH - 2 * M - (count - 1) * V_GAP) / count;
+  const room = (stageH - 2 * M - (count2 - 1) * V_GAP) / count2;
   const boxH = Math.max(need, Math.min(room, V_BOX_H));
   return {
     size: size2,
-    boxes: Array.from({ length: count }, (_, i) => ({ x: M + i * (boxH + V_GAP), w: boxH })),
+    boxes: Array.from({ length: count2 }, (_, i) => ({ x: M + i * (boxH + V_GAP), w: boxH })),
     boxH,
     boxX,
     boxW,
@@ -3516,7 +3845,7 @@ function columnLayout(stageW, stageH, stages, face, loop) {
     loopLines: loop ? wrap(loop.label, NOTE, loopW, 500, 0, face) : [],
     loopX: boxX + boxW + V_LOOP_SIDE,
     loopW,
-    svgH: 2 * M + count * boxH + (count - 1) * V_GAP
+    svgH: 2 * M + count2 * boxH + (count2 - 1) * V_GAP
   };
 }
 function balance(label, k, face) {
@@ -4234,8 +4563,8 @@ function stackLayout(p, format, face = "latin") {
   if (inline2.fits) return inline2;
   return inline2.wide && inline2.blockH < stacked.blockH ? inline2 : stacked;
 }
-function labelWeight(i, count) {
-  return i === count - 1 ? 700 : 600;
+function labelWeight(i, count2) {
+  return i === count2 - 1 ? 700 : 600;
 }
 function floorFor(p, format) {
   if (!p.tilt) return MIN_FONT;
@@ -4245,7 +4574,7 @@ function solve2(p, format, inline2, face) {
   const width = contentW(format);
   const boxH = contentH(format);
   const floor = floorFor(p, format);
-  const count = p.layers.length;
+  const count2 = p.layers.length;
   const k = isPortrait(format) ? "tall" : "wide";
   const riseMax = RISE_MAX[k];
   const syMax = SY_MAX[k];
@@ -4253,7 +4582,7 @@ function solve2(p, format, inline2, face) {
   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)
+      (l, i) => textWidth(l.label, LABEL_SIZE2, labelWeight(i, count2), 0, false, face) + noteW(l)
     )
   );
   const colCap = inline2 ? width * 0.56 : width * 0.5;
@@ -4262,7 +4591,7 @@ function solve2(p, format, inline2, face) {
   const labelX = width - colW;
   const labelRoom = Math.min(
     ...p.layers.map(
-      (l, i) => (colW - noteW(l)) / Math.max(1, textWidth(l.label, 1, labelWeight(i, count), 0, false, face))
+      (l, i) => (colW - noteW(l)) / Math.max(1, textWidth(l.label, 1, labelWeight(i, count2), 0, false, face))
     )
   );
   const labelSize = Math.max(floor, Math.min(LABEL_SIZE2, labelRoom));
@@ -4270,7 +4599,7 @@ function solve2(p, format, inline2, face) {
     const nw = noteW(l);
     const labelMaxW = Math.max(labelSize, colW - nw);
     return {
-      label: wrap(l.label, labelSize, labelMaxW, labelWeight(i, count), 0, face),
+      label: wrap(l.label, labelSize, labelMaxW, labelWeight(i, count2), 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 ? [] : inline2 ? [l.note] : wrap(l.note, floor, colW, 400, 0, face),
@@ -4288,13 +4617,13 @@ function solve2(p, format, inline2, face) {
   const noteH = noteHeight(p.note, noteWidth(format), 28, face);
   const free = boxH - chromeH - 20 - noteH;
   const avail = Math.max(300, free);
-  const room = (avail - 2 * pad - syMax - tMax) / Math.max(1, count - 1);
+  const room = (avail - 2 * pad - syMax - tMax) / Math.max(1, count2 - 1);
   const rise = clamp(room, RISE_MIN, riseMax);
   const sy = clamp(rise * 0.62, 46, syMax);
   const t2 = clamp(rise * 0.14, 10, tMax);
   const span = width - NUM_W - GAP3 - colW;
   const sx = clamp(span * 0.2, 110, 220);
-  const height = 2 * pad + (count - 1) * rise + sy + t2;
+  const height = 2 * pad + (count2 - 1) * rise + sy + t2;
   return {
     // A rise shorter than a label block prints the note through the label below.
     // BOTH directions. A layout that fits the height and not the width is not a
@@ -4319,7 +4648,7 @@ function solve2(p, format, inline2, face) {
     labelSize,
     blockH,
     pad,
-    yBase: pad + (count - 1) * rise + sy,
+    yBase: pad + (count2 - 1) * rise + sy,
     lines
   };
 }
@@ -4336,11 +4665,11 @@ var stack = (beat, ctx) => {
   const p = beat.params;
   const face = faceOf(ctx.theme.fontStack);
   const L = stackLayout(p, ctx.format, face);
-  const count = p.layers.length;
-  const last = count - 1;
+  const count2 = p.layers.length;
+  const last = count2 - 1;
   if (!L.fits) {
     throw new Error(
-      `stack ${beat.id}: ${count} layers with ${p.layers.filter((l) => l.note).length} note(s) need ${Math.round(L.blockH)}px of label block against ${Math.round(L.avail)}px of room, at the ${Math.round(L.floor)}px floor and with the notes already moved beside their labels. Nothing here may be set smaller, so the lever is upstream of this beat: drop a layer, or shorten the notes.`
+      `stack ${beat.id}: ${count2} layers with ${p.layers.filter((l) => l.note).length} note(s) need ${Math.round(L.blockH)}px of label block against ${Math.round(L.avail)}px of room, at the ${Math.round(L.floor)}px floor and with the notes already moved beside their labels. Nothing here may be set smaller, so the lever is upstream of this beat: drop a layer, or shorten the notes.`
     );
   }
   const parts = {};
@@ -4368,7 +4697,7 @@ var stack = (beat, ctx) => {
       { x: L.labelX, y: L.inline ? mid : mid - noteH / 2 },
       {
         size: L.labelSize,
-        weight: labelWeight(i, count),
+        weight: labelWeight(i, count2),
         fill: top ? theme.tones.b : theme.fg,
         maxWidth: block.labelMaxW,
         lineHeight: 1.16,
@@ -4422,10 +4751,10 @@ var stack = (beat, ctx) => {
 <div class="stnote" id="${sid}-note">${esc(p.note)}</div>` : "";
   const html = `${chrome(sid, p.eyebrow, p.headline, contentW(ctx.format))}
 <div class="stackwrap">${svg(id(sid, "stack"), L.width, L.height, body + probe2)}</div>${noteHtml}`;
-  const centre2 = (count - 1) / 2;
+  const centre2 = (count2 - 1) / 2;
   const enterFrom = (i) => p.tilt ? (i - centre2) * L.rise : 34;
   const first = 0.9;
-  const step = Math.min(0.8, Math.max(0.4, (beat.seconds - first - 1.5) / count));
+  const step = Math.min(0.8, Math.max(0.4, (beat.seconds - first - 1.5) / count2));
   const tl = [...chromeIn(sid, p.eyebrow !== void 0)];
   const holds = [];
   const spot = spotlighter(sid);
@@ -4457,11 +4786,11 @@ var stack = (beat, ctx) => {
     );
   }
   if (p.note) {
-    const at = first + count * step;
+    const at = first + count2 * step;
     tl.push(tween(`#${sid}-note`, { opacity: 0 }, { opacity: 1, duration: 0.6 }, at));
     holds.push(at + 0.7);
   }
-  if (count > 1) tl.push(...spot.restore(first + count * step));
+  if (count2 > 1) tl.push(...spot.restore(first + count2 * step));
   return {
     html,
     parts,
@@ -5802,8 +6131,8 @@ async function narrate(storyboard, source, prefs, opts) {
     const text2 = beat.narration?.trim();
     if (!text2) continue;
     const segments2 = [];
-    const count = stopsFor(beat, source, format, `s${i + 1}`, theme);
-    const plan = planSegments(text2, Math.min(count, paced.speakingStops));
+    const count2 = stopsFor(beat, source, format, `s${i + 1}`, theme);
+    const plan = planSegments(text2, Math.min(count2, paced.speakingStops));
     for (const [stop, line2] of plan.entries()) {
       if (!line2) continue;
       const speech = await synthesize(line2, {
@@ -5825,7 +6154,7 @@ async function narrate(storyboard, source, prefs, opts) {
     }
     if (segments2.length > 0) {
       beats[beat.id] = segments2;
-      staged[beat.id] = count;
+      staged[beat.id] = count2;
     }
   }
   return {
@@ -6715,11 +7044,11 @@ function stageScene(scene, speed) {
 function speechPlan(open, holds, segments2) {
   const starts = [];
   let at = open;
-  for (const [i, segment] of segments2.entries()) {
-    const hold = holds[Math.min(segment.stop, holds.length - 1)] ?? 0;
+  for (const [i, segment2] of segments2.entries()) {
+    const hold = holds[Math.min(segment2.stop, holds.length - 1)] ?? 0;
     if (i > 0) at = Math.max(at, hold);
     starts.push(at);
-    at += segment.seconds;
+    at += segment2.seconds;
   }
   return { starts, end: at };
 }
@@ -6947,10 +7276,10 @@ function pack(words2, width) {
 function splitCue(cue, max = CUE_MAX_CHARS) {
   if (cue.text.length <= max) return [cue];
   const words2 = cue.text.split(/\s+/).filter(Boolean);
-  const count = pack(words2, max).length;
+  const count2 = pack(words2, max).length;
   let width = max;
-  for (let w = Math.ceil(cue.text.length / count); w < max; w++) {
-    if (pack(words2, w).length <= count) {
+  for (let w = Math.ceil(cue.text.length / count2); w < max; w++) {
+    if (pack(words2, w).length <= count2) {
       width = w;
       break;
     }
@@ -7042,17 +7371,17 @@ function place(scenes, spoken) {
       );
     }
     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);
+    for (const [i, segment2] of segments2.entries()) {
+      const index = Math.min(segment2.stop, scene.holds.length - 1);
       out.push({
-        id: `${scene.id}.${segment.stop}`,
+        id: `${scene.id}.${segment2.stop}`,
         scene: scene.id,
-        stop: segment.stop,
-        audio: segment.audio,
+        stop: segment2.stop,
+        audio: segment2.audio,
         hold: round5(scene.start + scene.holds[index]),
         start: round5(scene.start + starts[i]),
-        duration: segment.seconds,
-        cues: segment.cues.flatMap((c) => splitCue(c, cueMax(c.text)))
+        duration: segment2.seconds,
+        cues: segment2.cues.flatMap((c) => splitCue(c, cueMax(c.text)))
       });
     }
   }
@@ -7129,6 +7458,15 @@ function planTiming(input) {
     // `emitDeck` and `writeTiming` are handed the same `format`, so this cannot
     // disagree with the box the archetypes actually drew into.
     captionReserve: format.captionReserve ?? 0,
+    // An unbudgeted format's limit is Infinity, which JSON writes as `null`.
+    // Left out instead: recorded as a format with no limit, never with a limit
+    // of null or zero.
+    format: {
+      id: format.id,
+      minWeight: format.minWeight,
+      ...Number.isFinite(format.maxSeconds) && { maxSeconds: format.maxSeconds },
+      ...format.warnSeconds !== void 0 && { warnSeconds: format.warnSeconds }
+    },
     scenes,
     segments: segments2
   };
@@ -7155,15 +7493,15 @@ function framePlan(timing, fps) {
       );
     }
     pieces.push({ from: first, motion: last - first, freeze: 0 });
-    for (const segment of segments2) {
-      const at = f(segment.start);
+    for (const segment2 of segments2) {
+      const at = f(segment2.start);
       audio.push({
-        id: segment.id,
-        audio: segment.audio,
+        id: segment2.id,
+        audio: segment2.audio,
         startFrame: at,
         delayMs: Math.round(at / fps * 1e3)
       });
-      for (const cue of segment.cues) {
+      for (const cue of segment2.cues) {
         const start = at / fps + cue.start;
         const end = at / fps + cue.end;
         if (end > start) cues.push({ start, end, text: cue.text });
@@ -7737,6 +8075,22 @@ async function resolveChrome(need = "open the deck with") {
 async function chromePath(need = "open the deck with") {
   return (await resolveChrome(need)).path;
 }
+function sandboxMissing(err) {
+  return /No usable sandbox/.test(err instanceof Error ? err.message : String(err));
+}
+var SANDBOX_FIX = "`sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0`, or give Chrome an AppArmor profile";
+async function launchOwnPage(launch, args, what) {
+  try {
+    return await launch(args);
+  } catch (err) {
+    if (!sandboxMissing(err)) throw err;
+    process.stderr.write(
+      `chrome: this host gives Chrome no sandbox, so ${what} runs without one, as hyperframes' render always does. To keep the sandbox: ${SANDBOX_FIX}.
+`
+    );
+    return launch([...args, "--no-sandbox"]);
+  }
+}
 function runtimePath() {
   return createRequire3(import.meta.url).resolve("hyperframes/dist/hyperframe.runtime.iife.js");
 }
@@ -7754,10 +8108,9 @@ async function openDeck(dir, opts = {}) {
   const timeout = opts.timeoutMs ?? 6e4;
   const { default: puppeteer } = await import("puppeteer-core");
   const chrome2 = await resolveChrome();
-  const browser = await puppeteer.launch({
-    executablePath: chrome2.path,
-    headless: true,
-    args: [
+  const browser = await launchOwnPage(
+    (args) => puppeteer.launch({ executablePath: chrome2.path, headless: true, args }),
+    [
       // A retina host would otherwise hand back a 2x frame, whose clip is not the
       // renderer's.
       "--force-device-scale-factor=1",
@@ -7770,8 +8123,9 @@ async function openDeck(dir, opts = {}) {
       "--use-gl=angle",
       "--use-angle=swiftshader",
       "--enable-unsafe-swiftshader"
-    ]
-  });
+    ],
+    "the gates' page"
+  );
   try {
     const page = await browser.newPage();
     await page.evaluateOnNewDocument("self.__name = self.__name || ((fn) => fn);");
@@ -8792,6 +9146,14 @@ async function readInBrowser(html, timeoutMs) {
       // happens to be that run.
       "--host-resolver-rules=MAP * ~NOTFOUND"
     ]
+    // No `--no-sandbox` fallback here, unlike `launchOwnPage`: this is a page
+    // from the web, and a renderer bug it triggers is exactly what the sandbox
+    // contains. Refused, with the fix, rather than Chrome's raw FATAL.
+  }).catch((err) => {
+    if (!sandboxMissing(err)) throw err;
+    throw new Error(
+      `Chrome has no usable sandbox on this host, and a page from the web is not opened without one. ${SANDBOX_FIX}, then ingest again \u2014 or save the page and ingest the file.`
+    );
   });
   try {
     const page = await browser.newPage();
@@ -10250,8 +10612,13 @@ function renderSource(source) {
     }
   }
   out.push("", "== EQUATIONS ==");
-  for (const e of source.equations)
-    out.push(`[equation ${e.id}] ${e.display ? "display" : "inline"} \u2014 ${e.tex}`);
+  for (const e of source.equations) {
+    const fixed = repairTex(e.tex, true);
+    const note2 = fixed.error === null ? "" : " (KaTeX cannot draw this one: a walk shows it as plain source, a morph cannot use it)";
+    out.push(
+      `[equation ${e.id}] ${e.display ? "display" : "inline"} \u2014 ${fixed.error === null ? fixed.tex : e.tex}${note2}`
+    );
+  }
   if (!source.equations.length)
     out.push("(none \u2014 no equation-walk or equation-morph beat is possible)");
   out.push("", "== TABLES ==");
@@ -10825,10 +11192,10 @@ function drawSvg(req) {
   const seed = createHash7("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);
+  const count2 = 6 + Math.floor(rand() * 5);
   const unit = Math.min(W, H);
   const parts = [`<rect width="${W}" height="${H}" fill="${PAPER}"/>`];
-  for (let i = 0; i < count; i++) {
+  for (let i = 0; i < count2; i++) {
     const kind = Math.floor(rand() * 3);
     const cx = Math.round(W * (0.15 + 0.7 * rand()));
     const cy = Math.round(H * (0.15 + 0.7 * rand()));
@@ -11051,10 +11418,10 @@ function readCanvas(html) {
 function profilesFor(width, height, formats = FORMATS) {
   return Object.values(formats).filter((f) => f.width === width && f.height === height);
 }
-function scanBudget(html, storyboard, kept, formats = FORMATS) {
+function scanBudget(html, storyboard, kept, formats = FORMATS, recorded) {
   const canvas = readCanvas(html);
   if (!canvas) return [];
-  const profiles = profilesFor(canvas.width, canvas.height, formats);
+  const profiles = recorded && recorded.width === canvas.width && recorded.height === canvas.height ? [recorded] : profilesFor(canvas.width, canvas.height, formats);
   if (profiles.length === 0) {
     return [
       {
@@ -11782,6 +12149,20 @@ function captionBottom(sid, selector, fallbackPx) {
   }
   return bottom > 0 ? bottom : fallbackPx;
 }
+function collectUnfit(attr) {
+  return Array.from(document.querySelectorAll(`[${attr}]`)).map((el) => ({
+    sid: el.closest("[data-composition-id]")?.getAttribute("data-composition-id") ?? "?",
+    tex: el.getAttribute(attr) ?? ""
+  }));
+}
+function gradeUnfit(rows) {
+  return rows.map((r) => ({
+    severity: "error",
+    gate: "fidelity",
+    rule: "math_unfit",
+    message: `${r.sid}: the equation does not fit its box even at the ${TYPE_FLOOR_PX}px floor broken across lines \u2014 ${JSON.stringify(r.tex)}. Shorten it in the source, or walk it across two beats.`
+  }));
+}
 async function fidelity(dir, opts = {}) {
   const started = Date.now();
   const floor = opts.floor ?? INK_FLOOR;
@@ -11805,6 +12186,10 @@ async function fidelity(dir, opts = {}) {
   try {
     deck = await openDeck(dir, { timeoutMs: opts.timeoutMs });
     const { page, height } = deck;
+    await page.waitForFunction("window.__hfTimelinesBuilding === false", {
+      timeout: opts.timeoutMs ?? 6e4
+    });
+    const unfit = await page.evaluate(collectUnfit, UNFIT_ATTR);
     const measured = [];
     const collided = [];
     const apparent = [];
@@ -11848,7 +12233,8 @@ async function fidelity(dir, opts = {}) {
         ...gradeFidelity(measured, floor),
         ...gradeReserve(measured),
         ...gradeOverprint(collided),
-        ...gradeApparent(apparent)
+        ...gradeApparent(apparent),
+        ...gradeUnfit(unfit)
       ],
       elapsedMs: Date.now() - started
     };
@@ -12195,9 +12581,13 @@ async function verify(dir, opts = {}, storyboard, kept, source) {
     await readFile14(join13(dir, DECK_PAGE), "utf8").catch(() => ""),
     await listFiles(dir)
   );
-  const budget2 = html.flatMap(([, text2]) => scanBudget(text2, storyboard, kept));
+  const timing = await readTiming(dir);
+  const recorded = typeof timing?.format?.id === "string" ? { ...timing.format, width: timing.width, height: timing.height } : void 0;
+  const budget2 = html.flatMap(
+    ([, text2]) => scanBudget(text2, storyboard, kept, void 0, recorded)
+  );
   const type = html.flatMap(([file, text2]) => scanTypeFloor(text2, file));
-  const lead = kept ? await readTiming(dir).then((t2) => t2 ? scanNarrationLead(kept, t2) : []) : [];
+  const lead = kept && timing ? scanNarrationLead(kept, timing) : [];
   const ours = [...determinism, ...narration, ...budget2, ...type, ...lead];
   const stops = await declaredStops(dir);
   const [verdict, frames2] = await Promise.all([
@@ -12386,6 +12776,31 @@ function scanUnusedFigures(storyboard, source) {
     }
   ];
 }
+function scanMath(storyboard, source) {
+  const out = [];
+  const say = (rule, message2) => {
+    out.push({ severity: "warning", gate: "storyboard", rule, message: message2 });
+  };
+  for (const beat of storyboard.beats) {
+    try {
+      let notes = [];
+      if (beat.archetype === "equation-walk") {
+        const params = beat.params;
+        const eq = source.equations.find((e) => e.id === params.equationId);
+        if (eq) notes = prepareWalk(eq, params.terms, beat.id).notes;
+      } else if (beat.archetype === "equation-morph") {
+        notes = prepareMorph(beat, source).notes;
+      }
+      for (const n3 of notes) say("tex_repaired", `${beat.id}: ${n3}`);
+    } catch (err) {
+      say(
+        "tex_unrenderable",
+        `${beat.id}: ${err instanceof Error ? err.message : String(err)} \u2014 build will leave this beat out`
+      );
+    }
+  }
+  return out;
+}
 function figuresShown2(params) {
   const sides = ["left", "right"].map(
     (side) => params[side]?.figureId
@@ -12467,14 +12882,14 @@ function scanNarrationLead(beats, timing) {
   return findings;
 }
 function firstMention(segments2, label) {
-  for (const segment of segments2) {
-    for (const cue of segment.cues) {
+  for (const segment2 of segments2) {
+    for (const cue of segment2.cues) {
       const words2 = cue.text.split(/\s+/);
       let at = 0;
       for (const word of words2) {
         if (mentions(word, label)) {
           const share2 = cue.text.length > 0 ? at / cue.text.length : 0;
-          return segment.start + cue.start + share2 * (cue.end - cue.start);
+          return segment2.start + cue.start + share2 * (cue.end - cue.start);
         }
         at += word.length + 1;
       }
@@ -12609,7 +13024,7 @@ ${bands}
 </div>
 `;
 }
-function measure3(count) {
+function measure3(count2) {
   const doc = document;
   const probe2 = doc.getElementById("c0");
   if (probe2) {
@@ -12622,7 +13037,7 @@ function measure3(count) {
     probe2.classList.remove("on");
   }
   const rects = [];
-  for (let i = 0; i < count; i++) {
+  for (let i = 0; i < count2; i++) {
     const el = doc.getElementById(`c${i}`);
     if (!el) continue;
     el.classList.add("on");
@@ -12650,11 +13065,12 @@ async function renderCaptions(cues, style, deck, work) {
   await mkdir8(work, { recursive: true });
   await writeFile10(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"]
-  });
+  const executablePath = await chromePath(CAPTION_NEED);
+  const browser = await launchOwnPage(
+    (args) => puppeteer.launch({ executablePath, headless: true, args }),
+    ["--force-device-scale-factor=1", "--hide-scrollbars"],
+    "the caption band"
+  );
   try {
     const tab = await browser.newPage();
     await tab.setViewport({ width: style.width, height: style.height, deviceScaleFactor: 1 });
@@ -13314,6 +13730,7 @@ export {
   sampleTimes,
   scanBeatCount,
   scanHeadlines,
+  scanMath,
   scanNarrationDrift,
   scanNarrationLead,
   scanPaperArc,