takomi 2.1.45 → 2.5.4

package/assets/.agent/skills/embedded-captions/scripts/fit-fonts.cjs

@@ -1,158 +1,158 @@
-#!/usr/bin/env node
-/*
- * fit-fonts.cjs — shrink any plan.json caption group whose single line would overflow
- * its box, BEFORE render (Cinematic mode). Kills the "font too big → off-frame → shrink
- * → re-render" overflow round. Estimates rendered width from character count × a
- * per-family advance × the group's font-size, compares to the group's box width (its
- * plane width, else the frame), and only ever SHRINKS to fit. Approximate by design —
- * it prevents gross overflow; check-overflow.cjs remains the exact terminal check.
- *
- *   node fit-fonts.cjs <project-dir>
- */
-const path = require("path");
-const fs = require("fs");
-
-// rough per-family advance (em per char, caps-ish). Condensed faces are narrow; pixel
-// faces wide. Default is conservative. (Estimate only — gate confirms.)
-const ADV = {
-  anton: 0.44,
-  oswald: 0.45,
-  teko: 0.4,
-  "saira stencil one": 0.46,
-  "bebas neue": 0.4,
-  "press start 2p": 1.05,
-  vt323: 0.52,
-  monoton: 0.62,
-  "special elite": 0.55,
-  "jetbrains mono": 0.6,
-  "space mono": 0.6,
-  "ibm plex mono": 0.6,
-  "source code pro": 0.6,
-  "archivo black": 0.62,
-  bangers: 0.5,
-  "bodoni moda": 0.5,
-  "playfair display": 0.52,
-  cinzel: 0.62,
-  "cormorant garamond": 0.45,
-  fredoka: 0.55,
-  "baloo 2": 0.55,
-  "permanent marker": 0.55,
-  caveat: 0.4,
-  orbitron: 0.66,
-  sora: 0.54,
-  "space grotesk": 0.54,
-};
-const DEFAULT_ADV = 0.56;
-
-const cssVal = (css, prop) => {
-  const m = String(css || "").match(new RegExp(prop + "\\s*:\\s*([^;}]+)", "i"));
-  return m ? m[1].trim() : null;
-};
-function familyOf(css) {
-  const v = cssVal(css, "font-family");
-  if (!v) return "inter";
-  return v
-    .split(",")[0]
-    .trim()
-    .replace(/^['"]|['"]$/g, "")
-    .toLowerCase();
-}
-function sizePxOf(css, H) {
-  const v = cssVal(css, "font-size");
-  if (!v) return null;
-  let m;
-  if ((m = v.match(/calc\(\s*([\d.]+)\s*\*\s*var\(--h\)\s*\)/i))) return parseFloat(m[1]) * H;
-  if ((m = v.match(/([\d.]+)\s*cqh/i))) return (parseFloat(m[1]) / 100) * H;
-  if ((m = v.match(/([\d.]+)\s*vh/i))) return (parseFloat(m[1]) / 100) * H;
-  if ((m = v.match(/([\d.]+)\s*px/i))) return parseFloat(m[1]);
-  return null;
-}
-function planeWidthPx(plan, plane, W) {
-  const p = plan.planes && plan.planes[plane];
-  const css = p && (typeof p === "string" ? p : p.css);
-  const v = cssVal(css, "width");
-  if (!v) return null;
-  let m;
-  if ((m = v.match(/([\d.]+)\s*%/))) return (parseFloat(m[1]) / 100) * W;
-  if ((m = v.match(/([\d.]+)\s*px/))) return parseFloat(m[1]);
-  return null;
-}
-function setFontSize(css, fracOfH) {
-  const decl = `font-size: calc(${fracOfH.toFixed(3)} * var(--h))`;
-  if (/font-size\s*:/i.test(css || "")) return String(css).replace(/font-size\s*:\s*[^;}]+/i, decl);
-  return (css ? css.replace(/\s*$/, "").replace(/;?\s*$/, "; ") : "") + decl + ";";
-}
-
-function main() {
-  const project = path.resolve(process.argv[2] || "");
-  if (!process.argv[2]) {
-    console.error("usage: fit-fonts.cjs <project-dir>");
-    process.exit(1);
-  }
-  const planPath = path.join(project, "plan.json");
-  let plan;
-  try {
-    plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
-  } catch {
-    console.error("[fit-fonts] no plan.json (Cinematic only) — skipping");
-    process.exit(0);
-  }
-  const W = plan.width || 1920,
-    H = plan.height || 1080;
-  const groups = (plan.groups || []).concat(plan.crown_group ? [plan.crown_group] : []);
-  const MARGIN = 0.92; // leave 8% breathing room inside the box
-  const HERO_MIN_FRAC = 0.18; // a hero below ~0.18·h isn't "big" — keep it punchy, widen its box instead
-
-  let changed = 0;
-  for (const g of groups) {
-    const text = (g.words || []).map((w) => w.text).join(" ");
-    const nChars = text.replace(/\s/g, "").length + (g.words || []).length * 0.5; // glyphs + ~half-space gaps
-    if (nChars < 1) continue;
-    const fam = familyOf(g.css);
-    let adv = ADV[fam] ?? DEFAULT_ADV;
-    if (/text-transform\s*:\s*uppercase/i.test(g.css || "") || text === text.toUpperCase())
-      adv *= 1.05;
-    const sizePx = sizePxOf(g.css, H);
-    if (!sizePx) continue; // no explicit size → template default handles it
-    const boxW = (g.plane ? planeWidthPx(plan, g.plane, W) : null) || W;
-    const usable = boxW * MARGIN;
-    // A WRAPPING group only overflows if a SINGLE word is wider than the box (the rest
-    // wraps). A NOWRAP group must fit its whole line. So don't shrink wrapping narration
-    // down to one line — only force the whole line for nowrap; else just the longest word.
-    const nowrap = /white-space\s*:\s*nowrap/i.test(g.css || "");
-    const longestWord = (g.words || []).reduce(
-      (m, w) => Math.max(m, String(w.text || "").replace(/\s/g, "").length),
-      0,
-    );
-    const constrainChars = nowrap ? nChars : longestWord;
-    if (constrainChars < 1) continue;
-    const estW = constrainChars * adv * sizePx;
-    if (estW > usable) {
-      const newPx = usable / (constrainChars * adv);
-      let frac = Math.max(0.02, newPx / H);
-      const isHero = g.hero === true || /^(hero|crown)$/i.test(g.plane || "");
-      if (isHero && frac < HERO_MIN_FRAC) {
-        // The hero must stay BIG. If it won't fit its box while staying punchy, the BOX is
-        // too narrow (the hero should span the subject) — keep it at the floor + flag it,
-        // rather than silently shrinking the peak into a small word.
-        frac = HERO_MIN_FRAC;
-        g.css = setFontSize(g.css, frac);
-        changed++;
-        console.log(
-          `[fit-fonts] ⚠ ${g.id || "(group)"} HERO "${text.slice(0, 28)}" won't fit box ${Math.round(usable)}px while staying big → KEPT at floor ${frac}·h. WIDEN the hero plane (it should span the subject, centered), not shrink the peak.`,
-        );
-        continue;
-      }
-      g.css = setFontSize(g.css, frac);
-      changed++;
-      console.log(
-        `[fit-fonts] ${g.id || "(group)"}: "${text.slice(0, 28)}" (${nowrap ? "nowrap line" : "longest word"}) est ${Math.round(estW)}px > box ${Math.round(usable)}px → shrink to ${frac.toFixed(3)}·h (${Math.round(newPx)}px)`,
-      );
-    }
-  }
-  if (changed) {
-    fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
-    console.log(`[fit-fonts] shrank ${changed} group(s) to fit; wrote plan.json`);
-  } else console.log("[fit-fonts] all groups fit their box — no change");
-}
-main();
+#!/usr/bin/env node
+/*
+ * fit-fonts.cjs — shrink any plan.json caption group whose single line would overflow
+ * its box, BEFORE render (Cinematic mode). Kills the "font too big → off-frame → shrink
+ * → re-render" overflow round. Estimates rendered width from character count × a
+ * per-family advance × the group's font-size, compares to the group's box width (its
+ * plane width, else the frame), and only ever SHRINKS to fit. Approximate by design —
+ * it prevents gross overflow; check-overflow.cjs remains the exact terminal check.
+ *
+ *   node fit-fonts.cjs <project-dir>
+ */
+const path = require("path");
+const fs = require("fs");
+
+// rough per-family advance (em per char, caps-ish). Condensed faces are narrow; pixel
+// faces wide. Default is conservative. (Estimate only — gate confirms.)
+const ADV = {
+  anton: 0.44,
+  oswald: 0.45,
+  teko: 0.4,
+  "saira stencil one": 0.46,
+  "bebas neue": 0.4,
+  "press start 2p": 1.05,
+  vt323: 0.52,
+  monoton: 0.62,
+  "special elite": 0.55,
+  "jetbrains mono": 0.6,
+  "space mono": 0.6,
+  "ibm plex mono": 0.6,
+  "source code pro": 0.6,
+  "archivo black": 0.62,
+  bangers: 0.5,
+  "bodoni moda": 0.5,
+  "playfair display": 0.52,
+  cinzel: 0.62,
+  "cormorant garamond": 0.45,
+  fredoka: 0.55,
+  "baloo 2": 0.55,
+  "permanent marker": 0.55,
+  caveat: 0.4,
+  orbitron: 0.66,
+  sora: 0.54,
+  "space grotesk": 0.54,
+};
+const DEFAULT_ADV = 0.56;
+
+const cssVal = (css, prop) => {
+  const m = String(css || "").match(new RegExp(prop + "\\s*:\\s*([^;}]+)", "i"));
+  return m ? m[1].trim() : null;
+};
+function familyOf(css) {
+  const v = cssVal(css, "font-family");
+  if (!v) return "inter";
+  return v
+    .split(",")[0]
+    .trim()
+    .replace(/^['"]|['"]$/g, "")
+    .toLowerCase();
+}
+function sizePxOf(css, H) {
+  const v = cssVal(css, "font-size");
+  if (!v) return null;
+  let m;
+  if ((m = v.match(/calc\(\s*([\d.]+)\s*\*\s*var\(--h\)\s*\)/i))) return parseFloat(m[1]) * H;
+  if ((m = v.match(/([\d.]+)\s*cqh/i))) return (parseFloat(m[1]) / 100) * H;
+  if ((m = v.match(/([\d.]+)\s*vh/i))) return (parseFloat(m[1]) / 100) * H;
+  if ((m = v.match(/([\d.]+)\s*px/i))) return parseFloat(m[1]);
+  return null;
+}
+function planeWidthPx(plan, plane, W) {
+  const p = plan.planes && plan.planes[plane];
+  const css = p && (typeof p === "string" ? p : p.css);
+  const v = cssVal(css, "width");
+  if (!v) return null;
+  let m;
+  if ((m = v.match(/([\d.]+)\s*%/))) return (parseFloat(m[1]) / 100) * W;
+  if ((m = v.match(/([\d.]+)\s*px/))) return parseFloat(m[1]);
+  return null;
+}
+function setFontSize(css, fracOfH) {
+  const decl = `font-size: calc(${fracOfH.toFixed(3)} * var(--h))`;
+  if (/font-size\s*:/i.test(css || "")) return String(css).replace(/font-size\s*:\s*[^;}]+/i, decl);
+  return (css ? css.replace(/\s*$/, "").replace(/;?\s*$/, "; ") : "") + decl + ";";
+}
+
+function main() {
+  const project = path.resolve(process.argv[2] || "");
+  if (!process.argv[2]) {
+    console.error("usage: fit-fonts.cjs <project-dir>");
+    process.exit(1);
+  }
+  const planPath = path.join(project, "plan.json");
+  let plan;
+  try {
+    plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
+  } catch {
+    console.error("[fit-fonts] no plan.json (Cinematic only) — skipping");
+    process.exit(0);
+  }
+  const W = plan.width || 1920,
+    H = plan.height || 1080;
+  const groups = (plan.groups || []).concat(plan.crown_group ? [plan.crown_group] : []);
+  const MARGIN = 0.92; // leave 8% breathing room inside the box
+  const HERO_MIN_FRAC = 0.18; // a hero below ~0.18·h isn't "big" — keep it punchy, widen its box instead
+
+  let changed = 0;
+  for (const g of groups) {
+    const text = (g.words || []).map((w) => w.text).join(" ");
+    const nChars = text.replace(/\s/g, "").length + (g.words || []).length * 0.5; // glyphs + ~half-space gaps
+    if (nChars < 1) continue;
+    const fam = familyOf(g.css);
+    let adv = ADV[fam] ?? DEFAULT_ADV;
+    if (/text-transform\s*:\s*uppercase/i.test(g.css || "") || text === text.toUpperCase())
+      adv *= 1.05;
+    const sizePx = sizePxOf(g.css, H);
+    if (!sizePx) continue; // no explicit size → template default handles it
+    const boxW = (g.plane ? planeWidthPx(plan, g.plane, W) : null) || W;
+    const usable = boxW * MARGIN;
+    // A WRAPPING group only overflows if a SINGLE word is wider than the box (the rest
+    // wraps). A NOWRAP group must fit its whole line. So don't shrink wrapping narration
+    // down to one line — only force the whole line for nowrap; else just the longest word.
+    const nowrap = /white-space\s*:\s*nowrap/i.test(g.css || "");
+    const longestWord = (g.words || []).reduce(
+      (m, w) => Math.max(m, String(w.text || "").replace(/\s/g, "").length),
+      0,
+    );
+    const constrainChars = nowrap ? nChars : longestWord;
+    if (constrainChars < 1) continue;
+    const estW = constrainChars * adv * sizePx;
+    if (estW > usable) {
+      const newPx = usable / (constrainChars * adv);
+      let frac = Math.max(0.02, newPx / H);
+      const isHero = g.hero === true || /^(hero|crown)$/i.test(g.plane || "");
+      if (isHero && frac < HERO_MIN_FRAC) {
+        // The hero must stay BIG. If it won't fit its box while staying punchy, the BOX is
+        // too narrow (the hero should span the subject) — keep it at the floor + flag it,
+        // rather than silently shrinking the peak into a small word.
+        frac = HERO_MIN_FRAC;
+        g.css = setFontSize(g.css, frac);
+        changed++;
+        console.log(
+          `[fit-fonts] ⚠ ${g.id || "(group)"} HERO "${text.slice(0, 28)}" won't fit box ${Math.round(usable)}px while staying big → KEPT at floor ${frac}·h. WIDEN the hero plane (it should span the subject, centered), not shrink the peak.`,
+        );
+        continue;
+      }
+      g.css = setFontSize(g.css, frac);
+      changed++;
+      console.log(
+        `[fit-fonts] ${g.id || "(group)"}: "${text.slice(0, 28)}" (${nowrap ? "nowrap line" : "longest word"}) est ${Math.round(estW)}px > box ${Math.round(usable)}px → shrink to ${frac.toFixed(3)}·h (${Math.round(newPx)}px)`,
+      );
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(planPath, JSON.stringify(plan, null, 2));
+    console.log(`[fit-fonts] shrank ${changed} group(s) to fit; wrote plan.json`);
+  } else console.log("[fit-fonts] all groups fit their box — no change");
+}
+main();

package/assets/.agent/skills/embedded-captions/scripts/gen-stroke-path.py

@@ -1,46 +1,46 @@
-#!/usr/bin/env python3
-"""gen-stroke-path.py — generalized draw-on path generator.
-
-Lays out ANY word in a single-line (pen-path) SVG font — Hershey/EMS — and emits
-one continuous-dash-revealable path `d`. The glyph data IS the pen path, so
-stroke-order reveal is exact by construction for any text, no per-word tuning.
-
-Usage: gen-stroke-path.py <font.svg> <text> <target_width_px> <baseline_y> <x0>
-Prints: the path `d` string + layout info on stderr.
-"""
-import re, sys
-
-font_path, text, target_w, baseline_y, x0 = (
-    sys.argv[1], sys.argv[2], float(sys.argv[3]), float(sys.argv[4]), float(sys.argv[5]))
-
-svg = open(font_path).read()
-glyphs = {}
-for m in re.finditer(r'<glyph\s+unicode="(.)"[^>]*?horiz-adv-x="([\d.]+)"(?:[^>]*?d="([^"]*)")?', svg):
-    ch, adv, d = m.group(1), float(m.group(2)), m.group(3) or ""
-    glyphs[ch] = (adv, d)
-# default advance for space
-space_adv = glyphs.get(" ", (300, ""))[0]
-
-# total advance width in font units
-total = 0.0
-for ch in text:
-    total += glyphs.get(ch, (space_adv, ""))[0]
-s = target_w / total                       # scale font-units → px
-
-out = []
-cursor = 0.0
-NUM = re.compile(r"[-\d.]+")
-for ch in text:
-    adv, d = glyphs.get(ch, (space_adv, ""))
-    if d:
-        # polylines only (M/L): transform every coordinate pair
-        toks = re.findall(r"([ML])\s+([-\d.]+)\s+([-\d.]+)", d)
-        for cmd, xs, ys in toks:
-            x = x0 + (cursor + float(xs)) * s
-            y = baseline_y - float(ys) * s          # SVG-font y is UP; flip
-            out.append(f"{cmd} {x:.1f} {y:.1f}")
-    cursor += adv
-
-print(" ".join(out))
-print(f"[gen] chars={len(text)} scale={s:.3f} width={total*s:.0f}px "
-      f"subpaths={sum(1 for o in out if o.startswith('M'))}", file=sys.stderr)
+#!/usr/bin/env python3
+"""gen-stroke-path.py — generalized draw-on path generator.
+
+Lays out ANY word in a single-line (pen-path) SVG font — Hershey/EMS — and emits
+one continuous-dash-revealable path `d`. The glyph data IS the pen path, so
+stroke-order reveal is exact by construction for any text, no per-word tuning.
+
+Usage: gen-stroke-path.py <font.svg> <text> <target_width_px> <baseline_y> <x0>
+Prints: the path `d` string + layout info on stderr.
+"""
+import re, sys
+
+font_path, text, target_w, baseline_y, x0 = (
+    sys.argv[1], sys.argv[2], float(sys.argv[3]), float(sys.argv[4]), float(sys.argv[5]))
+
+svg = open(font_path).read()
+glyphs = {}
+for m in re.finditer(r'<glyph\s+unicode="(.)"[^>]*?horiz-adv-x="([\d.]+)"(?:[^>]*?d="([^"]*)")?', svg):
+    ch, adv, d = m.group(1), float(m.group(2)), m.group(3) or ""
+    glyphs[ch] = (adv, d)
+# default advance for space
+space_adv = glyphs.get(" ", (300, ""))[0]
+
+# total advance width in font units
+total = 0.0
+for ch in text:
+    total += glyphs.get(ch, (space_adv, ""))[0]
+s = target_w / total                       # scale font-units → px
+
+out = []
+cursor = 0.0
+NUM = re.compile(r"[-\d.]+")
+for ch in text:
+    adv, d = glyphs.get(ch, (space_adv, ""))
+    if d:
+        # polylines only (M/L): transform every coordinate pair
+        toks = re.findall(r"([ML])\s+([-\d.]+)\s+([-\d.]+)", d)
+        for cmd, xs, ys in toks:
+            x = x0 + (cursor + float(xs)) * s
+            y = baseline_y - float(ys) * s          # SVG-font y is UP; flip
+            out.append(f"{cmd} {x:.1f} {y:.1f}")
+    cursor += adv
+
+print(" ".join(out))
+print(f"[gen] chars={len(text)} scale={s:.3f} width={total*s:.0f}px "
+      f"subpaths={sum(1 for o in out if o.startswith('M'))}", file=sys.stderr)