/skills/embedded-captions/scripts/make-cinematic.cjs

#!/usr/bin/env node
/*
 * make-cinematic.cjs — compile cinematic.json → plan.json (then make-composition.cjs).
 * CINEMATIC MODE, raised to BLOCK level. The agent authors thought-BLOCKS — lines of
 * words, which plane each block stacks in, at most one promoted HERO word — and the
 * compiler lowers that into the classic plan.json with everything deterministic
 * generated, so the Cinematic failure modes seen in the wild become impossible:
 *   - READING ORDER by construction: lines stack in declaration order inside a flex
 *     plane (spoken order = visual order; a hero can never sit below later words)
 *   - timings from the transcript BY SEQUENCE (no hand-copied times; duplicates by position)
 *   - accumulate-within-block / page-flip-between-blocks rhythm generated:
 *     lines of a block share the block's out (they accumulate, then clear together
 *     when the next block's first word lands); the NEXT block enters fresh
 *   - hero hand-off: the promoted word is lifted OUT of its line, enters as the hero
 *     (its own plane, BIG) when spoken, holds to the END of its block, exits cleanly
 *   - fg fallback: safe-zones verdict "fg" → caption_layer:"fg" automatically
 *
 *   node make-cinematic.cjs <project-dir>
 *
 * cinematic.json schema:
 * {
 *   "template": "cinematic-cream",
 *   "width": 1920, "height": 1080, "fps": 30,
 *   "planes": {                       // layout REGIONS — place them using safe-zones.json
 *     "narr": "top: 14%; left: 4%; width: 26%;",            // string or {css}
 *     "hero": null                    // null/absent → auto from safe-zones heroAnchor
 *   },
 *   "blocks": [
 *     { "plane": "narr", "lines": [
 *         { "words": ["You","need","to"],        "css": "font-size: calc(0.05*var(--h)); font-weight:600;" },
 *         { "words": ["judge","us","by","the"],  "css": "font-size: calc(0.062*var(--h)); font-weight:700;" },
 *         { "words": ["actions"],                "hero": true,
 *           "text": "ACTIONS", "css": "font-size: calc(0.24*var(--h)); font-weight:900; text-transform:uppercase;" },
 *         { "words": ["that","we","take."],      "css": "font-size: calc(0.05*var(--h));" },
 *         // per-line escape hatch: "layer":"fg" lifts a line ABOVE the subject matte
 *         // (use when the occlusion gate reports a context line eaten by the subject)
 *         { "words": ["over","the","subject"],     "layer": "fg" }
 *       ] },
 *     { "plane": "narr", "lines": [ ... next thought ... ] }
 *   ],
 *   "tones": { "default": "soft", "hero": "present" }       // optional
 * }
 * Rules: words must match the transcript verbatim in spoken order across all blocks.
 * Mark at most ONE line "hero": true per clip (scarcity); its words form the hero
 * (usually a single word; "text" overrides the display form).
 */
const path = require("path");
const fs = require("fs");

const norm = (s) =>
  String(s == null ? "" : s)
    .toLowerCase()
    .replace(/[^a-z0-9']/g, "");
const LOOKAHEAD = 40;

// Authored css WITHOUT a font-size renders at browser-default ~16px (an
// invisible ribbon) and every gate still passes — observed in the cold-start
// E2E. Guarantee the default is present whenever the author omitted it.
function ensureFontSize(css, defaultDecl) {
  if (!css) return defaultDecl;
  return /font-size\s*:/.test(css) ? css : defaultDecl + " " + css;
}

function die(m) {
  console.error(`[make-cinematic] ${m}`);
  process.exit(1);
}

function main() {
  const project = path.resolve(process.argv[2] || "");
  if (!process.argv[2]) die("usage: make-cinematic.cjs <project-dir>");
  const cj = path.join(project, "cinematic.json");
  const tj = path.join(project, "transcript.json");
  if (!fs.existsSync(cj)) die(`missing ${cj} — author it first (schema in this header)`);
  if (!fs.existsSync(tj)) die(`missing ${tj} — run prepare.sh first`);
  const C = JSON.parse(fs.readFileSync(cj, "utf8"));
  const tr = (JSON.parse(fs.readFileSync(tj, "utf8")).words || []).filter(
    (w) => w && "start" in w && "end" in w,
  );
  if (!tr.length) die("transcript has no word timings");

  // safe-zones: fg verdict + heroAnchor default
  let sz = null;
  try {
    sz = JSON.parse(fs.readFileSync(path.join(project, "safe-zones.json"), "utf8"));
  } catch {}
  // author override first (borderline scenes: coverage near the line, agitated subject),
  // else the safe-zones verdict.
  // narration legibility follows the verdict; the HERO is judged separately — it WANTS
  // occlusion (~30–55% is the product). fg for the hero is the LAST resort: only when no
  // height band achieves ≤62% predicted occlusion (safe-zones heroBands). An explicit
  // author caption_layer:"fg" still forces everything front.
  const authorFg = C.caption_layer === "fg";
  const narrFg = authorFg || (sz && sz.recommendation === "fg");
  const hb = sz && sz.heroBands;
  const heroFeasible = authorFg ? false : hb ? hb.feasible : !narrFg;
  const globalFg = narrFg; // narration layer (name kept for the lowering below)

  const W = C.width || 1920,
    H = C.height || 1080,
    FPS = C.fps || 24;
  const blocks = C.blocks || [];
  if (!blocks.length) die("blocks is empty");

  // ── sequence-match every word across blocks/lines ──────────────────────────
  let p = 0;
  const missing = [];
  for (const b of blocks)
    for (const ln of b.lines || []) {
      ln._w = (ln.words || []).map((text) => {
        const t = norm(text);
        let f = -1;
        for (let j = p; j < Math.min(tr.length, p + LOOKAHEAD); j++)
          if (norm(tr[j].text) === t) {
            f = j;
            break;
          }
        if (f < 0) {
          missing.push(text);
          return { text, start: null, end: null };
        }
        p = f + 1;
        return { text, start: tr[f].start, end: tr[f].end, ti: f };
      });
    }
  if (missing.length)
    die(
      `words not in transcript (in order): ${missing.join(" ")} — lines must match the transcript verbatim`,
    );

  // COMPLETENESS GATE — verbatim is a hard rule, so enforce it at compile time: the
  // sequence matcher's lookahead can silently SKIP transcript words the author forgot
  // (a real case shipped missing "in our newly released model."). Every transcript word
  // must be consumed; the only legitimate drops are filler (um/uh/stutters), declared in
  // cinematic.json "drops": ["um", ...].
  {
    const consumed = new Set();
    for (const b of blocks)
      for (const ln of b.lines || []) for (const w of ln._w) if (w.ti != null) consumed.add(w.ti);
    const dropOk = new Set((C.drops || []).map(norm));
    const FILLER = new Set(["um", "uh", "er", "ah", "hmm", "mm"]);
    const skipped = tr
      .map((w, i) => ({ w, i }))
      .filter(
        ({ w, i }) => !consumed.has(i) && !dropOk.has(norm(w.text)) && !FILLER.has(norm(w.text)),
      );
    if (skipped.length)
      die(
        `VERBATIM VIOLATION — ${skipped.length} transcript word(s) never authored (the matcher skipped them): ` +
          `${skipped.map(({ w }) => `"${w.text}"`).join(" ")} — add them to a line, or declare true filler in "drops": []`,
      );
  }

  // text override + multiple words double-renders (override replaces word 1, words
  // 2..n still draw) — caught cold by a clean-room agent; illegal for ANY hero line.
  for (const b of blocks)
    for (const ln of b.lines || []) {
      if (ln.hero && ln.text && (ln.words || []).length > 1)
        die(
          `hero line ["${(ln.words || []).join('" "')}"] has BOTH multiple words and a "text" override — drop "text" (words render verbatim; DNA case applies) or promote a single word.`,
        );
    }

  // ── block windows: in = first word −lead; out = page-flip = next block's first word −0.28 (or +1.2 hold) ──
  const LEAD = 0.18;
  const bw = blocks.map((b) => {
    const ws = (b.lines || []).flatMap((l) => l._w);
    return { first: Math.min(...ws.map((w) => w.start)), last: Math.max(...ws.map((w) => w.end)) };
  });
  let srcDur = null;
  try {
    const cp = require("child_process");
    for (const f of ["source.mp4"].concat(
      fs.readdirSync(project).filter((x) => /\.(mp4|mov|webm)$/i.test(x)),
    )) {
      const fp = path.join(project, f);
      if (!fs.existsSync(fp)) continue;
      const d = parseFloat(
        cp.execFileSync(
          "ffprobe",
          [
            "-v",
            "error",
            "-show_entries",
            "format=duration",
            "-of",
            "default=nokey=1:noprint_wrappers=1",
            fp,
          ],
          { encoding: "utf8" },
        ),
      );
      if (d > 0) {
        srcDur = d;
        break;
      }
    }
  } catch {}
  const DUR = +(srcDur || bw[bw.length - 1].last + 0.6).toFixed(3);
  // ── SLOT layout + paging. Lines get FIXED absolute positions (no flex reflow — the
  // "lower line jumps up when the upper one clears" bug is impossible by construction).
  // Lines accumulate down the plane like a poem; the plane PAGE-FLIPS (all visible lines
  // clear together, the next line restarts at the top) only when (a) the plane is full,
  // (b) a block sets "flip": true, or (c) a block boundary coincides with a real speech
  // pause (≥0.6s). Block windows (bw) are kept only for the hero's hold.
  for (let i = 0; i < bw.length; i++) {
    bw[i].in = Math.max(0, bw[i].first - LEAD);
    bw[i].out = Math.min(DUR - 0.05, Math.min(bw[i].last, DUR - 0.05) + 0.9);
    // a block's hold (incl. a LOCKUP's) yields to the NEXT block's entrance — the same
    // page-flip semantics columns already have; floor: its own words must finish
    if (i + 1 < bw.length)
      bw[i].out = Math.max(
        Math.min(bw[i].last, DUR - 0.05) + 0.15,
        Math.min(bw[i].out, bw[i + 1].first - 0.28),
      );
  }
  const fracOfLine = (css) => {
    const m = (css || "").match(/font-size\s*:\s*calc\(\s*([\d.]+)\s*\*\s*var\(--h\)/);
    return m ? +m[1] : 0.05;
  };
  const planeBudgetPx = (pk) => {
    const css =
      (C.planes &&
        C.planes[pk] &&
        (typeof C.planes[pk] === "string" ? C.planes[pk] : C.planes[pk].css)) ||
      "";
    const m = css.match(/height\s*:\s*([\d.]+)%/);
    return (m ? +m[1] / 100 : 0.3) * H;
  };

  // ── planes: agent's + auto LOCKUP planes (one per hero block) ───────────────
  // The LOCKUP is the layout answer to "the sentence reads broken around the hero":
  // a hero block's lines do NOT scatter into the narration column — kicker, HERO and
  // tail compose as ONE bonded ORBIT (context anchored at the hero's edges, diagonal
  // read). DEPTH: context EMBEDS (bg) with the hero — one shared depth; per-line
  // `layer:"fg"` is the escape hatch when the matte eats a context line (gate tells you).
  const planes = {};
  for (const [k, v] of Object.entries(C.planes || {})) {
    if (v == null) continue;
    let css = typeof v === "string" ? v : v.css || "";
    if (!/text-align\s*:/.test(css)) css += " text-align:center;"; // slot children are absolute; only alignment carries
    planes[k] = { css };
  }
  // multiple heroes allowed — scarcity is per BLOCK (≤1 per thought), not per clip.
  // The LARGEST authored hero is the APEX: it gets the full lockup embed (centered on
  // the subject, matte showcase). Smaller heroes are MINOR peaks: they stay IN their
  // column's flow as oversized emphasis lines (fg, hero motion at reduced amplitude) —
  // not every beat needs the matte showcase; that's what keeps the apex an event.
  const allHeroBlocks = [];
  blocks.forEach((b, bi) => {
    const hs = (b.lines || []).filter((l) => l.hero === true);
    if (hs.length > 1)
      die(
        `block ${bi} has ${hs.length} hero lines — at most ONE hero per block (scarcity = per beat)`,
      );
    if (hs.length === 1)
      allHeroBlocks.push({ b, bi, ln: hs[0], frac: fracOfLine(hs[0].css) || 0.24 });
  });
  const apexFracAll = Math.max(...allHeroBlocks.map((h) => h.frac), 0);
  // placement: "column" keeps even an APEX in its column's flow (the hero bursts the
  // column instead of crossing the subject) — the sanctioned alternative to the
  // subject-anchored lockup. Author it per hero line: { "hero": true, "placement": "column" }.
  const heroBlocks = allHeroBlocks.filter(
    (h) => h.frac >= apexFracAll - 1e-6 && (h.ln.placement || "subject") !== "column",
  );
  const minorHeroBis = new Set(
    allHeroBlocks
      .filter((h) => h.frac < apexFracAll - 1e-6 || (h.ln.placement || "subject") === "column")
      .map((h) => h.bi),
  );
  const columnApexBis = new Set(
    allHeroBlocks
      .filter((h) => h.frac >= apexFracAll - 1e-6 && (h.ln.placement || "subject") === "column")
      .map((h) => h.bi),
  );
  if (minorHeroBis.size)
    console.log(
      `[make-cinematic] ${minorHeroBis.size} minor hero(es) stay in the column flow (apex gets the lockup embed)`,
    );
  const lockupName = (bi) => `lockup-b${bi}`;
  const lockupTemplate =
    C.planes && C.planes.lockup
      ? typeof C.planes.lockup === "string"
        ? C.planes.lockup
        : C.planes.lockup.css
      : null;
  delete planes.lockup; // template only — not a real plane
  for (const hRef of heroBlocks) {
    const a = sz && sz.heroAnchor && sz.heroAnchor.plane;
    // band pick: target ~40% occlusion AND a band the DNA's text can survive on
    // (skip bright bands when luma data exists) — heroAnchor.yPct is the fallback
    let heroTop = a ? a.yPct : 30;
    if (hb && hb.profile && hb.profile.length) {
      const ok = hb.profile.filter(
        (b2) => b2.occPct >= 12 && b2.occPct <= 62 && (b2.bgLuma == null || b2.bgLuma <= 165),
      );
      const pool = ok.length ? ok : hb.profile;
      const best = pool.reduce((x, y) =>
        Math.abs(y.occPct - 40) < Math.abs(x.occPct - 40) ? y : x,
      );
      heroTop = +(best.topPct + 6.5).toFixed(1);
    }
    const heroFrac = (hRef.ln.css || "").match(/calc\(\s*([\d.]+)\s*\*\s*var\(--h\)/);
    // the lockup is taller than the hero alone (context above+below) — anchor so the
    // HERO band (not the plane top) lands on the target, then clamp so the WHOLE
    // lockup (pre + hero + post) stays on frame
    const heroIdx2 = (hRef.b.lines || []).indexOf(hRef.ln);
    const preH = (hRef.b.lines || [])
      .filter((l, i) => l !== hRef.ln && i < heroIdx2)
      .reduce(
        (s, l) =>
          s + (fracOfLine(l.css) * 100 * 1.32 + Math.max(1.6, fracOfLine(l.css) * 100 * 0.38)),
        0,
      );
    const postH = (hRef.b.lines || [])
      .filter((l, i) => l !== hRef.ln && i > heroIdx2)
      .reduce(
        (s, l) =>
          s + (fracOfLine(l.css) * 100 * 1.32 + Math.max(1.6, fracOfLine(l.css) * 100 * 0.38)),
        0,
      );
    const heroHpct = (heroFrac ? +heroFrac[1] : 0.24) * 100 * 1.12;
    const totalH = preH + heroHpct + postH;
    let top = +Math.max(2, Math.min(96 - totalH, heroTop - heroHpct / 2 - preH)).toFixed(1);
    const css = lockupTemplate
      ? lockupTemplate.replace(/top:\s*[\d.]+%/, `top: ${top}%`)
      : a
        ? `top: ${top}%; left: ${a.xPct}%; width: ${a.wPct}%; text-align: center;`
        : `top: ${top}%; left: 6%; width: 88%; text-align: center;`;
    planes[lockupName(hRef.bi)] = { css };
    hRef.plane = lockupName(hRef.bi);
  }
  // legacy alias: an author-defined "hero" plane positions the FIRST lockup
  if (planes.hero) {
    if (heroBlocks.length) {
      planes[lockupName(heroBlocks[0].bi)] = planes.hero;
    }
    delete planes.hero;
  }

  // ── PER-PLANE LEGIBILITY COMPENSATION ────────────────────────────────────
  // The DNA fixes hue + blend; the SCENE decides whether that survives. Match each
  // plane to its best-overlapping measured zone and ladder the treatment:
  //   luma > 150 → opaque (blend:normal) + strong tight scrim — screen/blend washes out
  //   luma 95–150 → keep the DNA blend, strengthen the glyph scrim
  const planeComp = {};
  if (sz && sz.zones) {
    const zlist = Object.entries(sz.zones).filter(([, z]) => z && z.meanLuma != null);
    for (const [pk, pv] of Object.entries(C.planes || {})) {
      const css0 = typeof pv === "string" ? pv : (pv || {}).css || "";
      const lm = css0.match(/left:\s*([\d.]+)%/),
        wm = css0.match(/width:\s*([\d.]+)%/);
      if (!lm || !wm) continue;
      const a0 = +lm[1],
        a1 = a0 + +wm[1];
      let best = null,
        bestOv = 0;
      for (const [, z] of zlist) {
        const ov = Math.min(a1, z.xPct + z.wPct) - Math.max(a0, z.xPct);
        if (ov > bestOv) {
          bestOv = ov;
          best = z;
        }
      }
      if (!best) continue;
      // gate on the time PEAK too — a dark wall swept by a bright moving object
      // (handheld drift, screens) averages "clean" but peaks hot, and text there
      // washes out exactly when the bright thing passes (real cold-start case)
      const pkL = best.peakLuma != null ? best.peakLuma : best.meanLuma;
      if (best.meanLuma > 150 || pkL > 175)
        planeComp[pk] =
          " mix-blend-mode: normal; text-shadow: 0 1px 6px rgba(0,0,0,.65), 0 2px 16px rgba(0,0,0,.4);";
      else if (best.meanLuma > 95 || pkL > 135)
        planeComp[pk] = " text-shadow: 0 1px 5px rgba(0,0,0,.6), 0 2px 14px rgba(0,0,0,.35);";
      if (planeComp[pk])
        console.log(
          `[make-cinematic] plane "${pk}" zone luma ${best.meanLuma} (peak ${pkL}) → legibility compensation (${best.meanLuma > 150 || pkL > 175 ? "opaque+scrim" : "scrim"})`,
        );
    }
  }
  // lockup context shares the hero band's luma
  const bandLuma = sz && sz.heroAnchor && sz.heroAnchor.bandLuma;
  const lockupComp =
    bandLuma != null && bandLuma > 150
      ? " mix-blend-mode: normal; text-shadow: 0 1px 6px rgba(0,0,0,.65), 0 2px 16px rgba(0,0,0,.4);"
      : bandLuma != null && bandLuma > 95
        ? " text-shadow: 0 1px 5px rgba(0,0,0,.6), 0 2px 14px rgba(0,0,0,.35);"
        : "";

  // ── lower to classic plan.json groups (slot layout + per-plane paging) ─────
  const tones = C.tones || {};
  let dnaBodyLayer = null;
  try {
    const dnaLib0 = require("./lib-dna.cjs");
    const dn0 = C.dna || (C.template ? dnaLib0.LEGACY[C.template] : "cream");
    if (dn0) {
      const d0 = dnaLib0.load(dn0);
      dnaBodyLayer = d0.bodyLayer || null;
      // category lock (symmetric): column is every classic DNA's home today,
      // so this only fires if a future DNA declares a different home.
      if (d0.deliveries && d0.deliveries.home && d0.deliveries.home !== "column")
        console.warn(
          `[make-cinematic] WARN: DNA "${dn0}" declares home="${d0.deliveries.home}" — cinematic use is cross-category and unvalidated.`,
        );
    }
  } catch (e) {
    if (e.message && e.message.includes("does not support")) throw e;
  }
  const groups = [];
  const heroRefs = heroBlocks; // [{b, bi, ln, plane}]
  const isHeroBlock = new Set(heroBlocks.map((h) => h.bi));
  const flat = [];
  blocks.forEach((b, bi) => {
    const heroIdx = isHeroBlock.has(bi) ? (b.lines || []).findIndex((l) => l.hero === true) : -1;
    (b.lines || []).forEach((ln, li) => {
      if (ln.hero === true && isHeroBlock.has(bi)) return; // APEX heroes slot into their lockup below
      flat.push({
        b,
        bi,
        ln,
        plane: heroIdx >= 0 ? lockupName(bi) : b.plane,
        lockupPos: heroIdx >= 0 ? (li < heroIdx ? "pre" : "post") : null,
        isMinorHero: ln.hero === true && minorHeroBis.has(bi), // minor peak rides its column
        first: Math.min(...ln._w.map((w) => w.start)),
        lastEnd: Math.min(Math.max(...ln._w.map((w) => w.end)), DUR - 0.05),
        frac: fracOfLine(ln.css),
      });
    });
  });
  // size sanity: narration below 0.05·h is whisper-tier (36px at 720p) — warn loudly
  {
    const tiny = flat.filter((l) => !l.isMinorHero && l.frac > 0 && l.frac < 0.05);
    if (tiny.length)
      console.log(
        `[make-cinematic] ⚠ ${tiny.length} narration line(s) authored below 0.05·h (whisper tier) — body narration wants 0.055–0.07·h: ${tiny
          .slice(0, 3)
          .map((l) => `"${l.ln.words.slice(0, 3).join(" ")}…"`)
          .join(" ")}`,
      );
  }
  // RATIO LOCK — poster lockup typography: context is sized FROM the hero, the way a
  // title system locks its eyebrow/tagline (kicker & tail ≈ 0.26× the hero height,
  // clamped to [0.05, 0.085]·h). Hero dominance is structural (~4× height + weight
  // contrast), so the old mass-rule downscale is gone — whisper-small context was the
  // disease, not the cure. Too MUCH context is a line-count problem, never a size one.
  for (const hRef of heroRefs) {
    const ctx = flat.filter((l) => l.bi === hRef.bi);
    if (!ctx.length) continue;
    const heroFracV = fracOfLine(hRef.ln.css || "") || 0.24;
    const ratioFrac = +Math.min(0.085, Math.max(0.05, heroFracV * 0.26)).toFixed(4);
    if (ctx.length > 3)
      console.log(
        `[make-cinematic] ⚠ lockup-b${hRef.bi} has ${ctx.length} context lines — a lockup wants kicker + hero + tail; move narration to the column (a leading clause can be its own block)`,
      );
    const moved = ctx.filter((l) => Math.abs(l.frac - ratioFrac) > 0.002).length;
    ctx.forEach((l) => {
      l.ln.css = (l.ln.css || "").replace(
        /font-size\s*:\s*[^;]+/,
        `font-size: calc(${ratioFrac} * var(--h))`,
      );
      l.frac = ratioFrac;
    });
    if (moved)
      console.log(
        `[make-cinematic] lockup-b${hRef.bi}: context RATIO-LOCKED to 0.26×hero → ${ratioFrac}·h (${moved} line(s) re-sized)`,
      );
  }
  const byPlane = {};
  flat.forEach((l) => {
    (byPlane[l.plane] = byPlane[l.plane] || []).push(l);
  });
  // make sure a lockup whose block has NO context lines still exists in the loop
  for (const hRef of heroRefs) if (!byPlane[hRef.plane]) byPlane[hRef.plane] = [];
  for (const [pk, ls] of Object.entries(byPlane)) {
    const isLockup = /^lockup-b/.test(pk);
    const budget = isLockup ? H : planeBudgetPx(pk); // a lockup is ONE composition — never paginate inside it
    const hRef = isLockup ? heroRefs.find((h) => h.plane === pk) : null;
    const heroH = hRef ? (fracOfLine(hRef.ln.css || "") || 0.24) * H * 1.12 + 12 : 0;
    // ORBIT estimate: where do the hero's left/right edges land inside the (frame-wide,
    // centered) lockup plane — kicker hangs off the left edge, tail off the right
    let orbit = null;
    if (hRef) {
      const disp = String(hRef.ln.text || (hRef.ln.words || []).join(" "));
      const fpx = (fracOfLine(hRef.ln.css || "") || 0.24) * H;
      const estW = Math.min(
        W * 0.94,
        Math.max(fpx * 1.2, disp.replace(/\s/g, "").length * fpx * 0.6),
      );
      const planeCss0 = (planes[pk] && planes[pk].css) || "";
      const _pl = ((planeCss0.match(/left:\s*([\d.]+)%/) || [0, 0])[1] * W) / 100;
      const pw = ((planeCss0.match(/width:\s*([\d.]+)%/) || [0, 100])[1] * W) / 100;
      const heroLeft = Math.max(0, (pw - estW) / 2);
      // side-aware: anchor context to the CLEANER side of THIS hero's window — the
      // kicker/tail must land on scene, not on a large/moving subject
      let side = (sz && sz.subject && sz.subject.clearerSide) || "left";
      try {
        const hin = Math.min(...hRef.ln._w.map((w) => w.start));
        const win = (sz.windows || []).find((w2) => hin >= w2.in - 0.3 && hin <= w2.out + 0.3);
        if (win && win.clearerSide) side = win.clearerSide;
      } catch {}
      orbit = {
        left: Math.round(heroLeft),
        right: Math.round(Math.max(0, pw - heroLeft - estW)),
        maxW: Math.round(Math.min(estW * 0.75, pw * 0.55)),
        side,
      };
    }
    const pages = [];
    let page = [],
      slot = 0;
    for (const l of ls) {
      // the HERO occupies its slot between pre- and post-context, in spoken order
      if (hRef && hRef.slotPx == null && l.lockupPos === "post") {
        hRef.slotPx = Math.round(slot);
        slot += heroH;
      }
      const lineH = l.frac * H * 1.32 + Math.max(12, Math.round(l.frac * H * 0.38)); // ink overflows the 1.0 line-box (+shadows) — breathe in proportion to the type
      const prev = page[page.length - 1];
      const pauseGap = prev ? l.first - prev.lastEnd : 0;
      const boundary = prev && l.bi !== prev.bi;
      // a block carrying a COLUMN-PLACED apex is one composition — never split it on
      // budget (the oversized hero legitimately exceeds the column's page height)
      const unbreakable = columnApexBis.has(l.bi) && prev && prev.bi === l.bi;
      if (
        page.length &&
        !unbreakable &&
        (slot + lineH > budget || (boundary && l.b.flip === true) || (boundary && pauseGap >= 0.6))
      ) {
        pages.push(page);
        page = [];
        slot = 0;
      }
      l.slotPx = Math.round(slot);
      if (isLockup) l._orbit = orbit;
      slot += lineH;
      page.push(l);
    }
    if (hRef && hRef.slotPx == null) {
      hRef.slotPx = Math.round(slot);
    } // hero is the block's last line
    if (page.length) pages.push(page);
    pages.forEach((pg, pi) => {
      const nextFirst = pi + 1 < pages.length ? pages[pi + 1][0].first : null;
      const maxEnd = Math.max(...pg.map((l) => l.lastEnd));
      let out =
        nextFirst != null
          ? Math.max(maxEnd + 0.01, Math.min(DUR - 0.05, nextFirst - 0.28))
          : Math.min(DUR - 0.05, maxEnd + 1.2);
      // THE LOCKUP OWNS THE FRAME: a sidebar page must not linger into an apex
      // lockup's window (its kicker/tail can land in the same zone → text-on-text)
      if (!isLockup)
        for (const hRef2 of heroRefs) {
          const lkIn = bw[hRef2.bi].first - 0.18;
          if (lkIn > maxEnd - 0.2 && lkIn < out)
            out = Math.max(maxEnd + 0.01, Math.min(out, lkIn - 0.28));
        }
      pg.forEach((l, li) => {
        l.pageIdx = pi;
        if (!isLockup)
          for (const hRef2 of heroRefs) {
            const lkOut = bw[hRef2.bi].out;
            const lkIn2 = bw[hRef2.bi].first - 0.18;
            const enter0 = Math.max(0, l.first - LEAD);
            if (enter0 > lkIn2 && enter0 < lkOut)
              l._delayIn = +Math.min(l.first, Math.max(enter0, lkOut - 0.2)).toFixed(3);
          }
        // a LOCKUP fades as ONE unit: context lines exit with the hero (block window),
        // never linger on page timing after the hero has left
        l.out = l.lockupPos ? +Math.min(out, bw[l.bi].out).toFixed(3) : +out.toFixed(3);
        l.in = l._delayIn != null ? l._delayIn : +Math.max(0, l.first - LEAD).toFixed(3);
        // first line of a NEW page: don't enter before the old page has begun clearing
        if (li === 0 && pi > 0)
          l.in = +Math.min(l.first, Math.max(l.first - LEAD, pages[pi - 1][0].out - 0.02)).toFixed(
            3,
          );
      });
    });
  }
  let gid = 0;
  for (const l of flat) {
    l.gid = l.isMinorHero ? `h-${l.bi}` : `b${l.bi}-l${gid++}`;
    // depth model: lockup CONTEXT embeds (bg) WITH the hero — the orbit anchors it
    // beside the head/shoulder so it reads on the scene, one shared depth; narration
    // columns embed too unless the DNA declares bodyLayer:"fg" (loud's announce-style).
    // Minor heroes ride their column in FRONT. Per-line layer overrides any default.
    // ORBIT depth: lockup context lands BESIDE the subject (kicker/tail at the hero's
    // edges) — so it EMBEDS (bg) like the hero; the whole composition shares one depth.
    // fg remains for: minor heroes (column emphasis), a DNA's bodyLayer (loud announces),
    // scene verdict FG (globalFg), and explicit per-line "layer" overrides.
    const defLayer = l.isMinorHero ? "fg" : dnaBodyLayer || "bg";
    groups.push({
      id: l.gid,
      plane: l.plane,
      layer: globalFg ? "fg" : l.ln.layer || l.b.layer || defLayer,
      ...(l.isMinorHero ? { hero: true, ...(columnApexBis.has(l.bi) ? {} : { minor: true }) } : {}),
      tone: l.isMinorHero ? tones.hero || "present" : l.ln.tone || tones.default || "soft",
      allow_overlap: true,
      // a MINOR hero holds only to the end of ITS thought (+a breath) — lingering with
      // the page through a long pause leaves it co-visible with the next apex
      in: l.in,
      out: l.isMinorHero ? +Math.min(l.out, bw[l.bi].out + 0.3).toFixed(3) : l.out,
      // carry the PLANE's text-align onto each slotted line (absolute children don't
      // reliably inherit through the template's .cap centering — authored "right edge
      // hugs the silhouette" was silently centered)
      css:
        (l.lockupPos && l._orbit
          ? (l.ln.anchor || (l.lockupPos === "pre" ? l._orbit.side : l._orbit.side)) === "left"
            ? `position:absolute;top:${l.slotPx}px;left:${l._orbit.left}px;right:auto;max-width:${l._orbit.maxW}px;text-align:left; `
            : `position:absolute;top:${l.slotPx}px;right:${l._orbit.right}px;left:auto;max-width:${l._orbit.maxW}px;text-align:right; `
          : `position:absolute;left:0;right:0;top:${l.slotPx}px; ` +
            (() => {
              const pc =
                (C.planes &&
                  C.planes[l.plane] &&
                  (typeof C.planes[l.plane] === "string"
                    ? C.planes[l.plane]
                    : C.planes[l.plane].css)) ||
                "";
              const ta = pc.match(/text-align\s*:\s*(left|right|center)/);
              return ta ? `text-align:${ta[1]}; ` : "";
            })()) +
        ensureFontSize(l.ln.css, "font-size: calc(0.05 * var(--h)); font-weight: 600;") +
        (l.lockupPos ? lockupComp : planeComp[l.plane] || ""),
      words: l.ln._w.map((w, wi2) => ({
        // minor/column heroes honor the display-form override too (single-word lines)
        text: l.isMinorHero && l.ln.text && wi2 === 0 && l.ln._w.length === 1 ? l.ln.text : w.text,
        start: w.start,
        end: Math.min(w.end, DUR - 0.05),
        ti: w.ti,
      })),
    });
  }
  for (const hRef of heroRefs) {
    const { bi, ln } = hRef;
    const w0 = ln._w[0];
    groups.push({
      id: `h-${bi}`,
      hero: true,
      plane: hRef.plane,
      layer: ln.layer || (heroFeasible ? "bg" : "fg"),
      tone: tones.hero || "present",
      allow_overlap: true,
      in: +Math.max(0, w0.start - 0.02).toFixed(3),
      out: +bw[bi].out.toFixed(3),
      css:
        `position:absolute;left:0;right:0;top:${hRef.slotPx || 0}px; text-align:center; ` +
        ensureFontSize(
          ln.css,
          "font-size: calc(0.24 * var(--h)); font-weight: 900; white-space: nowrap;",
        ), // case/tracking come from the DNA's hero treatment
      words: ln._w.map((w, i) => ({
        text: i === 0 && ln.text ? ln.text : w.text,
        start: w.start,
        end: Math.min(w.end, DUR - 0.05),
        ti: w.ti,
      })),
    });
    if (!heroFeasible)
      console.log(
        "[make-cinematic] no hero band ≤62% predicted occlusion → hero rendered in FRONT (last resort)",
      );
  }
  // scarcity spacing: heroes must breathe apart (≥ a beat between windows)
  const heroGs = groups.filter((g) => g.hero === true).sort((a, b) => a.in - b.in);
  for (let i = 1; i < heroGs.length; i++) {
    const gap = heroGs[i].in - heroGs[i - 1].out;
    if (gap < 0.6)
      console.log(
        `[make-cinematic] ⚠ heroes "${heroGs[i - 1].words[0].text}" and "${heroGs[i].words[0].text}" are only ${gap.toFixed(2)}s apart — peaks need a beat of air between them (consider demoting one to an emphasis line)`,
      );
  }
  // proximity: narration planes should HUG the silhouette (the embed reads as in-scene
  // only when typography interacts with the subject) — warn on far-parked planes.
  if (sz && sz.subject) {
    for (const [pk2, pv] of Object.entries(C.planes || {})) {
      if (/^lockup/.test(pk2) || pk2 === "hero" || pv == null) continue;
      const css2 = typeof pv === "string" ? pv : pv.css || "";
      const lm = css2.match(/left\s*:\s*([\d.]+)%/),
        wm = css2.match(/width\s*:\s*([\d.]+)%/);
      if (!lm || !wm) continue;
      const pl = +lm[1],
        pr = +lm[1] + +wm[1];
      const gap =
        pr <= sz.subject.colMinPct
          ? sz.subject.colMinPct - pr
          : pl >= sz.subject.colMaxPct
            ? pl - sz.subject.colMaxPct
            : 0;
      if (gap > 12)
        console.log(
          `[make-cinematic] ⚠ plane "${pk2}" sits ${gap.toFixed(0)}% away from the silhouette — embeds read in-scene when text HUGS the subject (use safe-zones zones.hugLeft/hugRight, gap 2–6%)`,
        );
    }
  }
  const plan = {
    mode: "template",
    dna: C.dna || (C.template ? undefined : "cream"), // canonical: name a DNA; default cream
    template: C.template || "cinematic-cream",
    compiled_by: "make-cinematic.cjs",
    width: W,
    height: H,
    fps: FPS,
    duration: DUR,
    ...(globalFg && (!heroRefs.length || !heroFeasible) ? { caption_layer: "fg" } : {}), // mixed narration-fg + hero-bg → per-group layers (hybrid render)
    planes: Object.fromEntries(Object.entries(planes).map(([k, v]) => [k, { css: v.css }])),
    groups,
  };
  fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
  console.log(
    `[make-cinematic] ${blocks.length} block(s) → ${groups.length} group(s)` +
      `${heroRefs.length ? `, ${heroRefs.length} hero(es): ${heroRefs.map((h) => `"${h.ln.text || h.ln.words[0]}"`).join(" · ")} (each holds to its block end, lockup-composed)` : ""}` +
      `${globalFg ? ", caption_layer=fg (safe-zones verdict)" : ""}, canvas ${DUR}s`,
  );
  // straight into the existing template compiler
  const cp2 = require("child_process");
  let r = cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
    stdio: "inherit",
  });
  if ((r.status || 0) !== 0) process.exit(r.status);

  // ── RE-SLOT pass (real measurement). Compile-time slots assume each line renders as
  // ONE visual line; a narrow plane WRAPS long lines and the next slot overlaps the
  // wrapped tail. Measure every page's REAL text heights in Chromium and re-stack.
  {
    const textBoxH = (c) => {
      const ws = (c.words || []).filter((w) => (w.opacity ?? 1) > 0.05 && w.w > 0);
      if (!ws.length) return c.cap_bbox ? c.cap_bbox.h : 0;
      return Math.max(...ws.map((w) => w.y + w.h)) - Math.min(...ws.map((w) => w.y));
    };
    const pagesByKey = {};
    for (const l of flat) {
      const key = l.plane + "|" + (l.pageIdx || 0);
      (pagesByKey[key] = pagesByKey[key] || { t: +(l.out - 0.1).toFixed(2), lines: [] }).lines.push(
        l,
      );
    }
    // the HERO is a real member of its lockup's stack — re-slot must move it (and the
    // post-context below it) from MEASURED heights, or a wrapped pre-line / raised hero
    // font reopens the very overlap this pass exists to prevent
    for (const hRef of heroRefs) {
      const key = hRef.plane + "|0";
      const hg2 = groups.find((g2) => g2.id === `h-${hRef.bi}`);
      if (!hg2) continue;
      (pagesByKey[key] = pagesByKey[key] || {
        t: +(hg2.out - 0.1).toFixed(2),
        lines: [],
      }).lines.push({
        gid: hg2.id,
        slotPx: hRef.slotPx || 0,
        frac: fracOfLine(hg2.css) || 0.24,
        _hero: true,
      });
    }
    const times = [...new Set(Object.values(pagesByKey).map((pg) => pg.t))];
    if (times.length) {
      cp2.spawnSync(
        "node",
        [path.join(__dirname, "measure-layout.cjs"), project, ...times.map(String)],
        { stdio: "ignore", timeout: 120000 },
      );
      let lay = null;
      try {
        lay = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8"));
      } catch {}
      if (lay && lay.samples) {
        let changes = 0;
        for (const pg of Object.values(pagesByKey)) {
          const sample = lay.samples.reduce((a, b) =>
            Math.abs(b.t - pg.t) < Math.abs(a.t - pg.t) ? b : a,
          );
          if (!sample || Math.abs(sample.t - pg.t) > 0.3) continue;
          const ordered = [...pg.lines].sort((a, b) => a.slotPx - b.slotPx);
          let top = 0;
          for (const l of ordered) {
            const cap = (sample.caps || []).find((c) => c.id === l.gid);
            const realH = cap
              ? (cap.cap_bbox && cap.cap_bbox.h) || textBoxH(cap)
              : l.frac * H * 1.25;
            if (Math.abs(top - l.slotPx) > 3) {
              const g = groups.find((g2) => g2.id === l.gid);
              g.css = g.css.replace(/top:\s*-?[\d.]+px/, "top:" + Math.round(top) + "px");
              if (l._hero) {
                const hr = heroRefs.find((h) => `h-${h.bi}` === l.gid);
                if (hr) hr.slotPx = Math.round(top);
              }
              l.slotPx = Math.round(top);
              changes++;
            }
            top +=
              (realH || l.frac * H * 1.25) + Math.max(12, Math.round((l.frac || 0.05) * H * 0.38)); // box is lh1.12 — contains its own ink
          }
        }
        if (changes) {
          console.log(
            `[make-cinematic] re-slot: ${changes} line(s) re-stacked from MEASURED heights (wrapped lines accounted)`,
          );
          fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
          cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
            stdio: "ignore",
          });
          try {
            fs.unlinkSync(path.join(project, "_layout.json"));
          } catch {}
        }
      }
    }
  }

  // ── HERO post-pass (real measurement, up to 2 re-emits) — runs PER HERO ─────
  // (a) SIZE: a timid hero is the #1 quality kill. If the authored font leaves >25%
  //     of the usable width unused, raise it to the width-fit maximum (DNA sizeRange cap).
  // (b) CLEARANCE vs OTHER planes: the hero band must not overlap caps outside its own
  //     lockup (its own context is composed around it by the slot layout). On a hit,
  //     shift the whole LOCKUP plane vertically.
  // (c) LOCKUP RE-STACK: a size change moves the hero's height — restack the lockup's
  //     slots from measured heights so post-context stays bonded BELOW the hero.
  // HERO words never wrap — a mid-word break ("Watermelo|n") is wrong in every case,
  // and author css REPLACES the default (which silently lost white-space:nowrap).
  // Forced here so no authoring path can drop it; centered nowrap text overflows a
  // narrow plane SYMMETRICALLY, which also keeps width-fit honest (it measures the
  // true single-line width instead of a wrapped row).
  // narration lines whipped away by a mid-sentence page-flip are the same disease
  // in mild form — warn (a deliberate quick beat is legal, so no die)
  for (const g of groups)
    if (!g.hero && g.words && g.words.length && g.out - g.in < 0.6) {
      console.log(
        `[make-cinematic] ⚠ line "${g.words
          .map((w) => w.text)
          .join(" ")
          .slice(
            0,
            28,
          )}" visible only ${(g.out - g.in).toFixed(2)}s (page-flip) — merge micro-lines or give the plane more height so the page holds`,
      );
    }
  // MIN DWELL — a peak on screen <0.5s is unreadable ("stars" shipped at 0.47s and
  // the user couldn't read it). Merge the block with the next (one thought), promote
  // a word with room, or demote to an emphasized line. <0.8s gets a loud warning.
  for (const g of groups)
    if (g.hero) {
      const dwell = g.out - g.in;
      if (dwell < 0.5)
        die(
          `hero "${(g.words[0] || {}).text}" is on screen only ${dwell.toFixed(2)}s (<0.5s readability floor) — merge its block with the next, promote a word with more room, or demote it to an emphasized (non-hero) line.`,
        );
      if (dwell < 0.8)
        console.log(
          `[make-cinematic] ⚠ hero "${(g.words[0] || {}).text}" dwell ${dwell.toFixed(2)}s is tight (<0.8s) — consider merging blocks so the peak can breathe`,
        );
    }
  {
    let nwChanged = false;
    for (const g of groups)
      if (g.hero && !/white-space\s*:\s*nowrap/.test(g.css || "")) {
        g.css = (g.css || "") + " white-space: nowrap;";
        nwChanged = true;
      }
    if (nwChanged) {
      fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
      require("child_process").spawnSync(
        "node",
        [path.join(__dirname, "make-composition.cjs"), project],
        { stdio: "ignore" },
      );
    }
  }
  const fracOf = (css) => {
    const m = (css || "").match(/font-size\s*:\s*calc\(\s*([\d.]+)\s*\*\s*var\(--h\)/);
    return m ? +m[1] : null;
  };
  const setFrac = (css, f) =>
    (css || "").replace(
      /font-size\s*:\s*[^;]+/,
      "font-size: calc(" + f.toFixed(3) + " * var(--h))",
    );
  const textBox = (c) => {
    const ws = (c.words || []).filter((w) => (w.opacity ?? 1) > 0.05 && w.w > 0);
    if (!ws.length) return c.cap_bbox;
    const x0 = Math.min(...ws.map((w) => w.x)),
      x1 = Math.max(...ws.map((w) => w.x + w.w));
    const y0 = Math.min(...ws.map((w) => w.y)),
      y1 = Math.max(...ws.map((w) => w.y + w.h));
    return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
  };
  let dnaSizeCap = 0.34,
    dnaHeroCase = "none";
  try {
    const dnaLib2 = require("./lib-dna.cjs");
    const dn = plan.dna || dnaLib2.LEGACY[plan.template];
    if (dn) {
      const dj = dnaLib2.load(dn);
      if (dj.hero && dj.hero.sizeRange) dnaSizeCap = dj.hero.sizeRange[1];
      if (dj.hero) dnaHeroCase = dj.hero.case || "none";
    }
  } catch {}
  // the APEX (largest authored hero) gets the width-fit raise; minor heroes keep their
  // authored size — inter-hero hierarchy is a deliberate choice, not timidity
  const apexFrac = Math.max(
    ...heroRefs.map((h) => fracOf((groups.find((g) => g.id === `h-${h.bi}`) || {}).css) || 0),
    0,
  );
  for (const hRef of heroRefs) {
    const heroG = groups.find((g) => g.id === `h-${hRef.bi}`);
    if (!heroG) continue;
    const isApex = (fracOf(heroG.css) || 0) >= apexFrac - 1e-6;
    const lockupMates = groups.filter((g) => g.plane === hRef.plane && g.id !== heroG.id);
    // hero size changed → context follows the 0.26 poster ratio, and its orbit
    // max-width scales WITH the font (a stale max-width wraps re-locked context
    // into multi-row towers that blow the stack past the frame)
    const relockMates = (hf) => {
      const rf = +Math.min(0.085, Math.max(0.05, hf * 0.26)).toFixed(4);
      for (const m of lockupMates) {
        const mf = fracOf(m.css);
        if (!mf || Math.abs(mf - rf) <= 0.002) continue;
        const scale = rf / mf;
        m.css = setFrac(m.css, rf).replace(
          /max-width:\s*([\d.]+)px/,
          (s2, px) => "max-width:" + Math.round(+px * scale) + "px",
        );
      }
    };
    const measure = () => {
      const midT = ((heroG.in + Math.min(heroG.out, heroG.in + 1.0)) / 2).toFixed(2);
      const endT = Math.max(+midT + 0.05, heroG.out - 0.12).toFixed(2);
      cp2.spawnSync(
        "node",
        [path.join(__dirname, "measure-layout.cjs"), project, String(midT), String(endT)],
        { stdio: "ignore", timeout: 90000 },
      );
      try {
        const ss = JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples;
        const near = (t) =>
          ss.reduce((a, b) => (Math.abs(b.t - t) < Math.abs((a ? a.t : 1e9) - t) ? b : a), null);
        return { caps: (near(+midT) || {}).caps || [], capsEnd: (near(+endT) || {}).caps || [] };
      } catch {
        return null;
      }
    };
    let didRaise = false;
    for (let pass = 0; pass < 5; pass++) {
      const m0 = measure();
      if (!m0) break;
      const caps = m0.caps,
        capsEnd = m0.capsEnd && m0.capsEnd.length ? m0.capsEnd : m0.caps;
      const hc0 = caps.find((c) => c.id === heroG.id);
      if (!hc0 || !hc0.cap_bbox) break;
      const hc = { ...hc0, cap_bbox: textBox(hc0) };
      const mateIds = new Set(lockupMates.map((m) => m.id));
      const others = caps
        .filter(
          (c) =>
            c.id !== heroG.id &&
            !mateIds.has(c.id) &&
            !/-glow$/.test(c.id || "") &&
            c.cap_bbox &&
            c.opacity > 0.05,
        )
        .map((c) => ({ ...c, cap_bbox: textBox(c) }));
      const maxW = W * 0.94;
      const f0 = fracOf(heroG.css);
      let changed = false;
      if (f0 && hc.cap_bbox.w > 0) {
        if (hc.cap_bbox.w > maxW) {
          const nf = Math.max(0.06, (f0 * maxW) / hc.cap_bbox.w);
          console.log(
            `[make-cinematic] hero "${heroG.words[0].text}" too WIDE ${Math.round(hc.cap_bbox.w)}px → ${f0}h→${nf.toFixed(3)}h`,
          );
          heroG.css = setFrac(heroG.css, nf);
          changed = true;
        } else if (hc.cap_bbox.w >= maxW * 0.88) {
          if (pass === 0)
            console.log(
              `[make-cinematic] hero "${heroG.words[0].text}" at width CEILING (${Math.round(hc.cap_bbox.w)}/${Math.round(maxW)}px) — cannot enlarge.`,
            );
        } else if (!didRaise && hc.cap_bbox.w < maxW * 0.88 && isApex) {
          // NO DEAD ZONE: anything under 88% of usable width is raised toward a 93%
          // fill (the old <75% trigger let 75–88%-wide heroes stay merely "decent")
          const fit = (f0 * (maxW * 0.93)) / hc.cap_bbox.w;
          const nf = Math.min(dnaSizeCap, fit);
          if (nf > f0 * 1.05 || fit > dnaSizeCap * 1.02) {
            if (nf > f0 * 1.001)
              console.log(
                `[make-cinematic] hero "${heroG.words[0].text}" TIMID (${Math.round(hc.cap_bbox.w)}px of ${Math.round(maxW)}px usable) → ${f0}h→${nf.toFixed(3)}h (width-fit max)`,
              );
            // SHORT-WORD FILL: height cap bound before the width target → fill with
            // TRACKING (film-title craft — HER, DUNE), ≤0.32em so it stays a word.
            const wAtCap = (hc.cap_bbox.w * nf) / f0;
            const dispT = String(heroG.text || (heroG.words || []).map((w) => w.text).join(" "));
            // never letterspace lowercase (tracked lowercase falls apart — caps only)
            const capsy = dnaHeroCase === "uppercase" || dispT === dispT.toUpperCase();
            if (fit > dnaSizeCap && wAtCap < maxW * 0.85 && capsy) {
              const disp = dispT;
              // letter-spacing adds a gap after EVERY char (N gaps) and the centering
              // text-indent adds one more — budget N+1 gaps or the word leaves the frame
              const gaps = disp.length + 1;
              const tr = +Math.min(0.32, (maxW * 0.88 - wAtCap) / (gaps * nf * H)).toFixed(3);
              if (tr >= 0.04) {
                heroG.css =
                  heroG.css
                    .replace(/letter-spacing\s*:[^;]+;?\s*/g, "")
                    .replace(/text-indent\s*:[^;]+;?\s*/g, "") +
                  (heroG.css.trim().endsWith(";") || !heroG.css.trim() ? "" : ";") +
                  ` letter-spacing:${tr}em; text-indent:${tr}em;`;
                console.log(
                  `[make-cinematic] hero "${disp}" short word at height cap (${Math.round(wAtCap)}px of ${Math.round(maxW)}px) → tracked +${tr}em to fill`,
                );
              }
            }
            heroG.css = setFrac(heroG.css, nf);
            changed = true;
            didRaise = true;
            relockMates(nf);
          }
        }
      }
      const hbx = hc.cap_bbox;
      // colliders OUTSIDE the lockup only — the lockup composes around the hero by design
      const hits = others.filter((o) => {
        const b = o.cap_bbox;
        const ix = Math.min(hbx.x + hbx.w, b.x + b.w) - Math.max(hbx.x, b.x);
        const iy = Math.min(hbx.y + hbx.h, b.y + b.h) - Math.max(hbx.y, b.y);
        return ix > 8 && iy > 8;
      });
      if (hits.length) {
        const maxBottom = Math.max(...hits.map((o) => o.cap_bbox.y + o.cap_bbox.h));
        const minTop = Math.min(...hits.map((o) => o.cap_bbox.y));
        const downTo = ((maxBottom + 14) / H) * 100;
        const upTo = Math.max(2, ((minTop - hbx.h - 14) / H) * 100);
        const planeCss = plan.planes[hRef.plane].css;
        const curTop = +(planeCss.match(/top:\s*([\d.]+)%/) || [0, 30])[1];
        const newTop = downTo + (hbx.h / H) * 100 < 96 ? downTo : upTo;
        plan.planes[hRef.plane].css = planeCss.replace(
          /top:\s*[\d.]+%/,
          "top: " + newTop.toFixed(1) + "%",
        );
        console.log(
          `[make-cinematic] hero "${heroG.words[0].text}" OVERLAPS ${hits.map((o) => o.id).join(",")} — lockup top ${curTop}% → ${newTop.toFixed(1)}%`,
        );
        changed = true;
      }
      // ORBIT REFINE: anchor kicker/tail to the MEASURED hero edges (estimate → real)
      if (lockupMates.length && hc.cap_bbox && hc.cap_bbox.w > 0) {
        const planeCss2 = (plan.planes[hRef.plane] && plan.planes[hRef.plane].css) || "";
        const pl2 = ((planeCss2.match(/left:\s*([\d.]+)%/) || [0, 0])[1] * W) / 100;
        const relL = Math.max(0, Math.round(hc.cap_bbox.x - pl2));
        const pw2 = ((planeCss2.match(/width:\s*([\d.]+)%/) || [0, 100])[1] * W) / 100;
        const relR = Math.max(0, Math.round(pw2 - (hc.cap_bbox.x - pl2) - hc.cap_bbox.w));
        for (const m of lockupMates) {
          if (/left:\s*\d+px;right:auto/.test(m.css)) {
            const nc = m.css.replace(/left:\s*\d+px/, "left:" + relL + "px");
            if (nc !== m.css) {
              m.css = nc;
              changed = true;
            }
          } else if (/right:\s*\d+px;left:auto/.test(m.css)) {
            const nc = m.css.replace(/right:\s*\d+px/, "right:" + relR + "px");
            if (nc !== m.css) {
              m.css = nc;
              changed = true;
            }
          }
        }
      }
      // LOCKUP RE-STACK from measured heights — runs EVERY pass for lockups (orbit
      // max-widths wrap context lines, so the re-slot's estimates can leave the tail
      // displaced or the whole composition off frame)
      if (lockupMates.length) {
        const caps2 = capsEnd; // lockup-END sample: every context line is revealed there
        // TOWER CHECK — a context line wrapped to 3+ rows means its orbit max-width is
        // too narrow for the (re-locked) font; widen toward the plane before stacking,
        // or the tower blows the stack past the frame and the walk-back eats the hero
        for (const m of lockupMates) {
          const cm = caps2.find((x) => x.id === m.id);
          const frm = fracOf(m.css) || 0.05;
          const mwM = m.css.match(/max-width:\s*([\d.]+)px/);
          if (!cm || !cm.cap_bbox || !mwM) continue;
          const rows = Math.round(cm.cap_bbox.h / (frm * H * 1.12));
          if (rows >= 3) {
            const planeCssW2 = (plan.planes[hRef.plane] && plan.planes[hRef.plane].css) || "";
            const pwX = W * (+(planeCssW2.match(/width:\s*([\d.]+)%/) || [0, 92])[1] / 100);
            const nw = Math.round(pwX * 0.62);
            if (nw > +mwM[1] + 10) {
              m.css = m.css.replace(/max-width:\s*[\d.]+px/, "max-width:" + nw + "px");
              console.log(
                `[make-cinematic] context "${((m.words || [])[0] || {}).text}…" wrapped to ${rows} rows — orbit max-width ${Math.round(+mwM[1])}→${nw}px (towers break the stack)`,
              );
              changed = true;
            }
          }
        }
        const entries = [heroG, ...lockupMates]
          .map((g) => {
            const c = caps2.find((x) => x.id === g.id);
            const curTop = +(g.css.match(/top:\s*(-?[\d.]+)px/) || [0, 0])[1];
            const fr = fracOf(g.css) || 0.05;
            // SLOT HEIGHT = the LAYOUT box (cap_bbox), not the glyph box: words reveal
            // over time, so at the hero-mid sample a context line's later words are
            // still opacity-0 — glyph-box measured a wrapped line one row short and the
            // next line slotted INTO its wrap band (real text-on-text shipped).
            const measuredH = c && c.cap_bbox ? c.cap_bbox.h : null;
            const h2 = g.id === heroG.id && didRaise ? fr * H * 1.12 : measuredH || fr * H * 1.25;
            return { g, curTop, h: h2 };
          })
          .sort((a, b) => a.curTop - b.curTop);
        let top = 0;
        for (const e of entries) {
          if (Math.abs(top - e.curTop) > 3) {
            e.g.css = e.g.css.replace(/top:\s*-?[\d.]+px/, "top:" + Math.round(top) + "px");
            changed = true;
          }
          top += e.h + Math.max(12, Math.round((fracOf(e.g.css) || 0.05) * H * 0.38)); // box is lh1.12 — contains its own ink
        }
        // RE-CLAMP the plane after MEASURED growth — keep the whole composition on frame
        const planeCss3 = plan.planes[hRef.plane].css;
        const curTopPct = +(planeCss3.match(/top:\s*([\d.]+)%/) || [0, 30])[1];
        const maxTopPct = Math.max(2, ((H * 0.97 - top) / H) * 100);
        if (curTopPct > maxTopPct + 0.3) {
          plan.planes[hRef.plane].css = planeCss3.replace(
            /top:\s*[\d.]+%/,
            "top: " + maxTopPct.toFixed(1) + "%",
          );
          console.log(
            `[make-cinematic] lockup measured ${Math.round(top)}px tall — plane top ${curTopPct}% → ${maxTopPct.toFixed(1)}% (kept on frame)`,
          );
          changed = true;
        }
        // even at the 2% ceiling the stack can exceed the frame (TIMID raise + ratio
        // context on a tall lockup) — walk the hero back 8% and re-lock until it fits
        if (top > H * 0.95 && maxTopPct <= 2.01) {
          const f0c = fracOf(heroG.css);
          if (f0c && f0c > 0.14) {
            // decisive step: stack height scales ~linearly with the hero (context is
            // ratio-locked to it), so aim straight at a 93% fill instead of nibbling
            const nf2 = +Math.max(0.14, Math.min(f0c * 0.92, (f0c * (H * 0.93)) / top)).toFixed(3);
            console.log(
              `[make-cinematic] lockup stack ${Math.round(top)}px exceeds the frame even at top 2% — hero ${f0c}h → ${nf2}h (fit)`,
            );
            heroG.css = setFrac(heroG.css, nf2);
            relockMates(nf2);
            didRaise = true;
            changed = true;
          }
        }
      }
      if (!changed) break;
      fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
      r = cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
        stdio: "ignore",
      });
      try {
        fs.unlinkSync(path.join(project, "_layout.json"));
      } catch {}
    }
  }
  // MINOR HERO measure pass — minors keep their authored size (hierarchy is a choice)
  // but never ship broken: wider than the frame's usable width shrinks to fit, and a
  // column overflow gets a loud note (centered spill is legal on a clear side only).
  {
    const minors = groups.filter((g) => g.hero && !heroRefs.some((h) => `h-${h.bi}` === g.id));
    let minorChanged = false;
    for (const mg of minors) {
      const midT = ((mg.in + Math.min(mg.out, mg.in + 1.0)) / 2).toFixed(2);
      cp2.spawnSync("node", [path.join(__dirname, "measure-layout.cjs"), project, String(midT)], {
        stdio: "ignore",
        timeout: 60000,
      });
      let mc = null;
      try {
        mc = (
          JSON.parse(fs.readFileSync(path.join(project, "_layout.json"), "utf8")).samples[0].caps ||
          []
        ).find((c) => c.id === mg.id);
      } catch {}
      if (!mc || !mc.cap_bbox) continue;
      const bb = textBox(mc),
        f0 = fracOf(mg.css);
      if (f0 && bb.w > W * 0.94) {
        const nf = Math.max(0.06, +((f0 * (W * 0.94)) / bb.w).toFixed(3));
        console.log(
          `[make-cinematic] minor hero "${(mg.words[0] || {}).text}" too WIDE ${Math.round(bb.w)}px → ${f0}h→${nf.toFixed(3)}h (shrink-to-fit)`,
        );
        mg.css = setFrac(mg.css, nf);
        minorChanged = true;
      } else {
        const planeCssM = (plan.planes[mg.plane] && plan.planes[mg.plane].css) || "";
        const pwPx = W * (+(planeCssM.match(/width:\s*([\d.]+)%/) || [0, 100])[1] / 100);
        if (bb.w > pwPx * 1.05)
          console.log(
            `[make-cinematic] note: minor hero "${(mg.words[0] || {}).text}" (${Math.round(bb.w)}px) spills its ${Math.round(pwPx)}px column — fine on a clear side; reduce size if it crosses the subject`,
          );
      }
      try {
        fs.unlinkSync(path.join(project, "_layout.json"));
      } catch {}
    }
    if (minorChanged) {
      fs.writeFileSync(path.join(project, "plan.json"), JSON.stringify(plan, null, 2));
      cp2.spawnSync("node", [path.join(__dirname, "make-composition.cjs"), project], {
        stdio: "ignore",
      });
    }
  }
  process.exit(0);
}
main();