/skills/embedded-captions/scripts/safe-zones.cjs

#!/usr/bin/env node
/*
 * safe-zones.cjs — PRECOMPUTE where captions can safely go, from the subject matte.
 *
 *   node safe-zones.cjs <project-dir>            → safe-zones.json (global + per-sentence windows) + summary
 *   node safe-zones.cjs <project-dir> <in> <out> → just that time window's zones (ad-hoc query)
 *
 * The inverse of check-occlusion: read the silhouette FIRST and hand the author the
 * clean regions + an embed-vs-fg verdict, so layout is right the first time instead of
 * after N occlusion-failure rounds.
 *
 * Uses the per-pixel ALPHA matte (not a bounding box): a cell counts as subject only
 * where the silhouette actually is, so the empty pocket beside the head / above the
 * shoulders stays FREE (a bbox would wrongly claim it). The subject MOVES, so zones are
 * computed PER TIME WINDOW (the union over just that window's frames), not one global box.
 */
const path = require("path");
const fs = require("fs");
const os = require("os");

const THRESH = 30 / 255; // a cell is "subject" if ≥12% covered at any sampled frame in the window
const SAMPLES = 48; // frames cached across the clip (windows aggregate the cached grids)

const HF_ROOTS = [
  process.env.HYPERFRAMES_ROOT,
  path.resolve(__dirname, "../../.."),
  path.join(os.homedir(), "Downloads", "hyperframes"),
].filter(Boolean);
let sharp = null;
for (const root of HF_ROOTS) {
  const cands = [path.join(root, "node_modules", "sharp")];
  const bunDir = path.join(root, "node_modules", ".bun");
  try {
    if (fs.existsSync(bunDir))
      for (const d of fs.readdirSync(bunDir))
        if (d.startsWith("sharp@")) cands.push(path.join(bunDir, d, "node_modules", "sharp"));
  } catch {}
  for (const c of cands) {
    try {
      if (fs.existsSync(c)) {
        sharp = require(c);
        break;
      }
    } catch {}
  }
  if (sharp) break;
}

// largest all-clear (1) rectangle within [c0,c1)×[r0,r1), in CELL units
function largestRect(safe, GW, c0, c1, r0, r1) {
  const cols = c1 - c0;
  const heights = new Array(cols).fill(0);
  let best = { area: 0, x: 0, y: 0, w: 0, h: 0 };
  for (let r = r0; r < r1; r++) {
    for (let cc = 0; cc < cols; cc++) heights[cc] = safe[r * GW + (c0 + cc)] ? heights[cc] + 1 : 0;
    const st = [];
    for (let cc = 0; cc <= cols; cc++) {
      const h = cc < cols ? heights[cc] : 0;
      let start = cc;
      while (st.length && st[st.length - 1].h >= h) {
        const top = st.pop();
        const area = top.h * (cc - top.i);
        if (area > best.area)
          best = { area, x: c0 + top.i, y: r - top.h + 1, w: cc - top.i, h: top.h };
        start = top.i;
      }
      st.push({ i: start, h });
    }
  }
  return best;
}

// turn a max-coverage grid into {coverage, subject, zones, recommendation}
function analyze(occ, GW, GH, W, H, lum, lumSeries) {
  const occCell = new Uint8Array(GW * GH);
  for (let c = 0; c < GW * GH; c++) occCell[c] = occ[c] >= THRESH ? 1 : 0;
  const safe = new Uint8Array(GW * GH); // 1-cell dilation margin around the silhouette
  for (let y = 0; y < GH; y++)
    for (let x = 0; x < GW; x++) {
      let o = 0;
      for (let dy = -1; dy <= 1 && !o; dy++)
        for (let dx = -1; dx <= 1 && !o; dx++) {
          const nx = x + dx,
            ny = y + dy;
          if (nx >= 0 && nx < GW && ny >= 0 && ny < GH && occCell[ny * GW + nx]) o = 1;
        }
      safe[y * GW + x] = o ? 0 : 1;
    }
  const occupied = occCell.reduce((a, b) => a + b, 0);
  const coverage = occupied / (GW * GH);
  let colMin = GW,
    colMax = -1,
    rowMin = GH,
    rowMax = -1;
  for (let x = 0; x < GW; x++)
    for (let y = 0; y < GH; y++)
      if (occCell[y * GW + x]) {
        if (x < colMin) colMin = x;
        if (x > colMax) colMax = x;
        if (y < rowMin) rowMin = y;
        if (y > rowMax) rowMax = y;
      }
  if (colMax < 0) {
    colMin = 0;
    colMax = -1;
    rowMin = 0;
    rowMax = -1;
  }
  const clearerSide = colMin >= GW - 1 - colMax ? "left" : "right";
  const cellW = W / GW,
    cellH = H / GH;
  // HERO anchor — where the ONE big promoted word should sit: ON the subject (centered,
  // crossing it so the head/torso occludes the middle). The OPPOSITE of the clean zones
  // above (those are for narration). A wide band ≈ centered on the subject, vertically
  // crossing the head/upper torso. Only meaningful when there IS a subject.
  let heroAnchor = null;
  if (colMax >= 0) {
    const subjCx = ((colMin + colMax + 1) / 2 / GW) * 100;
    const subjWpct = ((colMax - colMin + 1) / GW) * 100;
    const yTop = (rowMin / GH) * 100,
      yBot = ((rowMax + 1) / GH) * 100;
    const wPct = Math.round(Math.min(92, Math.max(58, subjWpct + 26)));
    const xPct = Math.round(Math.min(98 - wPct, Math.max(2, subjCx - wPct / 2)));
    const yPct = Math.round(yTop + (yBot - yTop) * 0.12); // band crosses the head / upper torso
    let bandLuma = null;
    if (lum) {
      const y0 = Math.round((yPct / 100) * GH),
        y1 = Math.min(GH, y0 + Math.max(2, Math.round(GH * 0.14)));
      const x0 = Math.round((xPct / 100) * GW),
        x1 = Math.min(GW, Math.round(((xPct + wPct) / 100) * GW));
      // luma of the BACKGROUND cells only — that's where the hero's glyphs are visible
      // (the subject-occluded middle doesn't show text; averaging it in hides washout).
      let s2 = 0,
        n = 0;
      for (let y = y0; y < y1; y++)
        for (let x = x0; x < x1; x++) {
          if (occCell[y * GW + x]) continue;
          s2 += lum[y * GW + x];
          n++;
        }
      bandLuma = n ? Math.round(s2 / n) : null;
    }
    heroAnchor = {
      centerXPct: +subjCx.toFixed(1),
      plane: { xPct, yPct, wPct, align: "center" },
      ...(bandLuma != null ? { bandLuma, washoutRisk: bandLuma > 175 } : {}),
      note:
        "Place the ONE big hero here (centered on the subject); the head/torso occludes its middle (~30-55%) — that is the embed. Do NOT put the hero in a clean zone." +
        (bandLuma != null && bandLuma > 175
          ? " ⚠ BAND IS BRIGHT (luma " +
            bandLuma +
            "): cream/screen text will wash out — lower the hero onto the darker subject body, or use a template/mode with opaque text."
          : ""),
    };
  }
  const zoneLuma = (r) => {
    if (!lum || r.area === 0) return null;
    let s2 = 0,
      n = 0;
    for (let y = r.y; y < r.y + r.h; y++)
      for (let x = r.x; x < r.x + r.w; x++) {
        s2 += lum[y * GW + x];
        n++;
      }
    return n ? Math.round(s2 / n) : null;
  };
  // a TIME-AVERAGED map walks a moving minefield: a dark wall swept by a bright
  // moving object (handheld drift, screens) averages "clean" while peaking hot.
  // peakLuma = p95 of the zone's per-sample mean over the window.
  const zoneLumaPeak = (r) => {
    if (!lumSeries || !lumSeries.length || r.area === 0) return null;
    const means = lumSeries
      .map((Lg) => {
        let s2 = 0,
          n = 0;
        for (let y = r.y; y < r.y + r.h; y++)
          for (let x = r.x; x < r.x + r.w; x++) {
            s2 += Lg[y * GW + x];
            n++;
          }
        return n ? s2 / n : 0;
      })
      .sort((a, b) => a - b);
    return Math.round(means[Math.max(0, Math.ceil(means.length * 0.95) - 1)]);
  };
  const toZone = (r) =>
    r.area === 0
      ? null
      : {
          xPct: +((r.x / GW) * 100).toFixed(1),
          yPct: +((r.y / GH) * 100).toFixed(1),
          wPct: +((r.w / GW) * 100).toFixed(1),
          hPct: +((r.h / GH) * 100).toFixed(1),
          areaPct: +(((r.w * r.h) / (GW * GH)) * 100).toFixed(1),
          px: {
            x: Math.round(r.x * cellW),
            y: Math.round(r.y * cellH),
            w: Math.round(r.w * cellW),
            h: Math.round(r.h * cellH),
          },
          ...(zoneLuma(r) != null
            ? {
                meanLuma: zoneLuma(r),
                bright: zoneLuma(r) > 180,
                ...(zoneLumaPeak(r) != null ? { peakLuma: zoneLumaPeak(r) } : {}),
              }
            : {}),
        };
  const zones = {
    largest: toZone(largestRect(safe, GW, 0, GW, 0, GH)),
    left: toZone(largestRect(safe, GW, 0, Math.round(GW / 2), 0, GH)),
    right: toZone(largestRect(safe, GW, Math.round(GW / 2), GW, 0, GH)),
    top: toZone(largestRect(safe, GW, 0, GW, 0, Math.max(2, Math.round(GH * 0.38)))),
  };
  // HUGGING zones — clean strips that ABUT the silhouette (the embed aesthetic wants
  // text NEAR the subject, not parked in the farthest corner). Grown outward from the
  // subject's edge at upper-body height; prefer these for narration.
  const hug = (side) => {
    if (colMax < 0) return null;
    const pad = Math.max(1, Math.round(GW * 0.02));
    const y0 = rowMin,
      y1 = Math.min(GH, rowMin + Math.max(3, Math.round((rowMax - rowMin + 1) * 0.45)));
    let x0, x1;
    if (side === "right") {
      x0 = Math.min(GW - 1, colMax + 1 + pad);
      x1 = GW - pad;
    } else {
      x1 = Math.max(1, colMin - pad);
      x0 = pad;
    }
    if (x1 - x0 < Math.round(GW * 0.1)) return null;
    // shrink until actually clean (≤8% occupied cells)
    let occN = 0,
      tot = 0;
    for (let y = y0; y < y1; y++)
      for (let x = x0; x < x1; x++) {
        tot++;
        if (occCell[y * GW + x]) occN++;
      }
    if (tot === 0 || occN / tot > 0.08) return null;
    const r = { x: x0, y: y0, w: x1 - x0, h: y1 - y0, area: (x1 - x0) * (y1 - y0) };
    const z2 = toZone(r);
    // GLYPHS must hug, not just the plane: in a wide column, text aligned to the far
    // edge parks the words a third of the frame away from the subject. Align TOWARD
    // the silhouette: right-side column → text-align:left (text starts beside the
    // subject); left-side column → text-align:right.
    if (z2) z2.align = side === "right" ? "left" : "right";
    return z2;
  };
  zones.hugLeft = hug("left");
  zones.hugRight = hug("right");
  // HERO BAND PROFILE — per-height predicted occlusion of a centered hero band. The hero
  // WANTS ~30–55% (occlusion IS the embed); fg is the LAST resort, only when no height
  // achieves ≤62%. Even an 88%-coverage frame usually has a feasible band over the hairline.
  let heroBands = null;
  if (colMax >= 0) {
    const bandH = Math.max(2, Math.round(GH * 0.13));
    const hx0 = Math.round(((heroAnchor ? heroAnchor.plane.xPct : 8) / 100) * GW);
    const hx1 = Math.min(
      GW,
      Math.round(((heroAnchor ? heroAnchor.plane.xPct + heroAnchor.plane.wPct : 92) / 100) * GW),
    );
    const profile = [];
    for (let y0 = 0; y0 + bandH <= GH; y0 += Math.max(1, Math.round(GH * 0.02))) {
      let n = 0,
        occN = 0,
        lsum = 0;
      for (let y = y0; y < y0 + bandH; y++)
        for (let x = hx0; x < hx1; x++) {
          n++;
          if (occCell[y * GW + x]) occN++;
          if (lum) lsum += lum[y * GW + x];
        }
      profile.push({
        topPct: +((y0 / GH) * 100).toFixed(1),
        occPct: +((occN / n) * 100).toFixed(1),
        ...(lum ? { bgLuma: Math.round(lsum / n) } : {}),
      });
    }
    const ok = profile.filter((b) => b.occPct >= 12 && b.occPct <= 62);
    const best = (ok.length ? ok : profile).reduce((a, b) =>
      Math.abs(b.occPct - 40) < Math.abs(a.occPct - 40) ? b : a,
    );
    heroBands = { feasible: ok.length > 0, best, profile };
  }
  const big = zones.largest;
  const embeddable = !!big && big.areaPct >= 8 && big.hPct >= 10 && big.wPct >= 18;
  return {
    coverage: +(coverage * 100).toFixed(1),
    subject: {
      colMinPct: +((colMin / GW) * 100).toFixed(1),
      colMaxPct: +(((colMax + 1) / GW) * 100).toFixed(1),
      clearerSide,
    },
    zones,
    heroAnchor,
    heroBands,
    recommendation: embeddable ? "embed" : "fg",
  };
}

// ── SCENE OPTICS + PALETTE (v2) ──────────────────────────────────────────────
// Deterministic scene measurements that drive the DNA tokens, so "design that fits
// the scene" is a pipeline product, not agent inspiration:
//   palette  — dominant scene colors + a READABLE accent suggestion (sampled, then
//              clamped to usable saturation/lightness) + warm/cool temperature
//   optics   — background vs subject sharpness (Laplacian proxy) → suggested text
//              blur so embed type matches the scene's depth-of-field
//   lighting — bright-side estimate → contact-shadow direction for embed type

function rgb2hsv(r, g, b) {
  r /= 255;
  g /= 255;
  b /= 255;
  const mx = Math.max(r, g, b),
    mn = Math.min(r, g, b),
    d = mx - mn;
  let h = 0;
  if (d > 0) {
    if (mx === r) h = ((g - b) / d) % 6;
    else if (mx === g) h = (b - r) / d + 2;
    else h = (r - g) / d + 4;
    h *= 60;
    if (h < 0) h += 360;
  }
  return { h, s: mx === 0 ? 0 : d / mx, v: mx };
}
function hsv2hex(h, s, v) {
  const c = v * s,
    x = c * (1 - Math.abs(((h / 60) % 2) - 1)),
    m = v - c;
  let [r, g, b] =
    h < 60
      ? [c, x, 0]
      : h < 120
        ? [x, c, 0]
        : h < 180
          ? [0, c, x]
          : h < 240
            ? [0, x, c]
            : h < 300
              ? [x, 0, c]
              : [c, 0, x];
  const f = (n) =>
    Math.round((n + m) * 255)
      .toString(16)
      .padStart(2, "0");
  return `#${f(r)}${f(g)}${f(b)}`;
}

// dominant colors + accent suggestion from the BACKGROUND cells of a mid frame
async function scenePalette(bgPath, occCell, GW, GH) {
  const { data, info } = await sharp(bgPath)
    .resize(GW, GH, { fit: "fill" })
    .removeAlpha()
    .raw()
    .toBuffer({ resolveWithObject: true });
  const ch = info.channels;
  const cells = [];
  for (let c = 0; c < GW * GH; c++) {
    if (occCell && occCell[c]) continue; // background only
    cells.push([data[c * ch], data[c * ch + 1], data[c * ch + 2]]);
  }
  if (!cells.length) return null;
  // dominant: quantize to 3 bits/channel, top buckets by count
  const buckets = new Map();
  for (const [r, g, b] of cells) {
    const k = ((r >> 5) << 6) | ((g >> 5) << 3) | (b >> 5);
    const e = buckets.get(k) || { n: 0, r: 0, g: 0, b: 0 };
    e.n++;
    e.r += r;
    e.g += g;
    e.b += b;
    buckets.set(k, e);
  }
  const hex = (e) =>
    "#" +
    [e.r, e.g, e.b]
      .map((x) =>
        Math.round(x / e.n)
          .toString(16)
          .padStart(2, "0"),
      )
      .join("");
  const dominant = [...buckets.values()]
    .sort((a, b) => b.n - a.n)
    .slice(0, 3)
    .map((e) => ({ hex: hex(e), sharePct: +((e.n / cells.length) * 100).toFixed(1) }));
  // chromatic accent: hue histogram over saturated cells, weighted s·v
  const bins = Array.from({ length: 12 }, () => ({ w: 0, h: 0, s: 0, v: 0, n: 0 }));
  let warmW = 0,
    coolW = 0;
  for (const [r, g, b] of cells) {
    const { h, s, v } = rgb2hsv(r, g, b);
    if (h <= 90 || h >= 330) warmW += s * v;
    else if (h >= 150 && h <= 300) coolW += s * v;
    if (s < 0.18 || v < 0.12 || v > 0.97) continue;
    const bi = Math.floor(h / 30) % 12,
      w = s * v;
    const B = bins[bi];
    B.w += w;
    B.h += h * w;
    B.s += s * w;
    B.v += v * w;
    B.n++;
  }
  const top = bins.reduce((a, b) => (b.w > a.w ? b : a));
  let accent = null;
  if (top.w > 0.5 && top.n >= 3) {
    const h = top.h / top.w,
      s = top.s / top.w,
      v = top.v / top.w;
    // clamp to a readable accent: saturated enough to read as a choice, light enough to sit on video
    accent = hsv2hex(
      h,
      Math.min(0.78, Math.max(0.5, s * 1.2)),
      Math.min(0.8, Math.max(0.55, v * 1.15)),
    );
  }
  const temperature = warmW > coolW * 1.25 ? "warm" : coolW > warmW * 1.25 ? "cool" : "neutral";
  return { dominant, accentSuggestion: accent, temperature };
}

// Laplacian-stdev sharpness proxy of a region crop (full-res)
async function regionSharpness(imgPath, rect, W, H) {
  const x = Math.max(0, Math.min(W - 2, Math.round(rect.x))),
    y = Math.max(0, Math.min(H - 2, Math.round(rect.y)));
  const w = Math.max(2, Math.min(W - x, Math.round(rect.w))),
    h = Math.max(2, Math.min(H - y, Math.round(rect.h)));
  // two passes: crop to a buffer FIRST, then convolve+stats on the crop — sharp's
  // internal pipeline ordering otherwise convolves/stats the full frame and the two
  // regions measure identical.
  const crop = await sharp(imgPath)
    .extract({ left: x, top: y, width: w, height: h })
    .png()
    .toBuffer();
  const st = await sharp(crop)
    .greyscale()
    .convolve({ width: 3, height: 3, kernel: [0, 1, 0, 1, -4, 1, 0, 1, 0], scale: 1, offset: 128 })
    .stats();
  return st.channels[0].stdev;
}

async function sceneOptics(project, bgPath, fgPath, zones, subjectBox, W, H) {
  let bgSharp = null,
    subjSharp = null;
  const bigZone = zones && zones.largest && zones.largest.px;
  try {
    if (bigZone && bigZone.w >= 64 && bigZone.h >= 64)
      bgSharp = await regionSharpness(bgPath, bigZone, W, H);
  } catch {}
  try {
    if (subjectBox && subjectBox.w >= 64)
      subjSharp = await regionSharpness(bgPath, subjectBox, W, H);
  } catch {}
  let suggestedTextBlurPx = 0,
    ratio = null;
  if (bgSharp != null && subjSharp != null && subjSharp > 1) {
    ratio = +(bgSharp / subjSharp).toFixed(3);
    // strong bokeh → text in that depth plane should soften to match
    suggestedTextBlurPx = ratio < 0.35 ? 1.6 : ratio < 0.55 ? 1.0 : ratio < 0.8 ? 0.5 : 0;
  }
  return {
    bgSharpness: bgSharp != null ? +bgSharp.toFixed(2) : null,
    subjSharpness: subjSharp != null ? +subjSharp.toFixed(2) : null,
    sharpnessRatio: ratio,
    suggestedTextBlurPx,
  };
}

// bright-side estimate from the luminance grid → contact-shadow vector (shadow falls AWAY from light)
function sceneLighting(lum, occCell, GW, GH) {
  if (!lum) return null;
  let sw = 0,
    sx = 0,
    sy = 0,
    n = 0,
    mean = 0;
  for (let c = 0; c < GW * GH; c++) {
    if (!occCell[c]) {
      mean += lum[c];
      n++;
    }
  }
  if (!n) return null;
  mean /= n;
  for (let y = 0; y < GH; y++)
    for (let x = 0; x < GW; x++) {
      const c = y * GW + x;
      if (occCell[c]) continue;
      const w = Math.max(0, lum[c] - mean);
      sw += w;
      sx += w * (x / GW - 0.5);
      sy += w * (y / GH - 0.5);
    }
  if (sw < 1) return { lightFrom: "flat", shadow: { dx: 0, dy: 3 } };
  const lx = sx / sw,
    ly = sy / sw; // light centroid offset from center, −0.5..0.5
  const mag = Math.hypot(lx, ly);
  if (mag < 0.04) return { lightFrom: "frontal", shadow: { dx: 0, dy: 3 } };
  // shadow direction = opposite the light, scaled to a subtle px offset
  const s = Math.min(1, mag / 0.25);
  const dx = Math.round((-lx / mag) * 4 * s),
    dy = Math.round(Math.max(1, (-ly / mag) * 4 * s + 2));
  const compass =
    Math.abs(lx) > Math.abs(ly) * 1.8
      ? lx > 0
        ? "right"
        : "left"
      : Math.abs(ly) > Math.abs(lx) * 1.8
        ? ly > 0
          ? "below"
          : "above"
        : `${ly > 0 ? "lower" : "upper"}-${lx > 0 ? "right" : "left"}`;
  return { lightFrom: compass, shadow: { dx, dy } };
}

// split the transcript into sentence windows (punctuation, or a > 0.7s gap)
function sentenceWindows(project) {
  const tp = path.join(project, "transcript.json");
  if (!fs.existsSync(tp)) return [];
  let words;
  try {
    words = (JSON.parse(fs.readFileSync(tp, "utf8")).words || []).filter((w) => w && "start" in w);
  } catch {
    return [];
  }
  const out = [];
  let cur = [];
  for (let i = 0; i < words.length; i++) {
    cur.push(words[i]);
    const w = words[i],
      nx = words[i + 1];
    const ends = /[.!?…]$/.test((w.text || "").trim());
    const gap = nx ? nx.start - w.end > 0.7 : true;
    if (ends || gap || !nx) {
      if (cur.length)
        out.push({
          in: +cur[0].start.toFixed(2),
          out: +cur[cur.length - 1].end.toFixed(2),
          text: cur.map((x) => x.text).join(" "),
        });
      cur = [];
    }
  }
  return out;
}

async function main() {
  const project = path.resolve(process.argv[2] || "");
  if (!process.argv[2]) {
    console.error("usage: safe-zones.cjs <project-dir> [in out]");
    process.exit(1);
  }
  const fgDir = path.join(project, "frames_fg");
  if (!fs.existsSync(fgDir)) {
    console.error(`[safe-zones] no ${fgDir} — run matte.cjs first`);
    process.exit(2);
  }
  if (!sharp) {
    console.error("[safe-zones] sharp unavailable — set HYPERFRAMES_ROOT");
    process.exit(0);
  }

  const frames = fs
    .readdirSync(fgDir)
    .filter((f) => /\.png$/i.test(f))
    .sort();
  if (!frames.length) {
    console.error("[safe-zones] no PNG frames");
    process.exit(2);
  }
  const meta = await sharp(path.join(fgDir, frames[0])).metadata();
  const W = meta.width,
    H = meta.height;
  const CELL = Math.max(W, H) / 48;
  const GW = Math.max(8, Math.round(W / CELL)),
    GH = Math.max(8, Math.round(H / CELL));
  let fps = 24;
  try {
    const f = parseFloat(
      String(fs.readFileSync(path.join(project, "matte.fps"), "utf8")).replace(/[^\d.]/g, ""),
    );
    if (f > 0) fps = f;
  } catch {}

  const bgDir = path.join(project, "frames_bg");
  const hasBg = fs.existsSync(bgDir);
  // cache evenly-sampled frame grids once (each = per-cell avg subject alpha 0..1,
  // plus per-cell mean LUMINANCE from frames_bg — bright zones wash out cream/screen text)
  const sampleIdx = [
    ...new Set(
      Array.from({ length: SAMPLES }, (_, i) =>
        Math.min(frames.length - 1, Math.round((i / (SAMPLES - 1)) * (frames.length - 1))),
      ),
    ),
  ];
  const grids = [];
  for (const i of sampleIdx) {
    const { data, info } = await sharp(path.join(fgDir, frames[i]))
      .resize(GW, GH, { fit: "fill" })
      .raw()
      .toBuffer({ resolveWithObject: true });
    const ch = info.channels,
      g = new Float32Array(GW * GH);
    for (let c = 0; c < GW * GH; c++) g[c] = (ch >= 4 ? data[c * ch + 3] : 255) / 255;
    let lum = null;
    if (hasBg && fs.existsSync(path.join(bgDir, frames[i]))) {
      const { data: bd, info: bi } = await sharp(path.join(bgDir, frames[i]))
        .resize(GW, GH, { fit: "fill" })
        .greyscale()
        .raw()
        .toBuffer({ resolveWithObject: true });
      const bch = bi.channels;
      lum = new Float32Array(GW * GH);
      for (let c = 0; c < GW * GH; c++) lum[c] = bd[c * bch];
    }
    grids.push({ t: i / fps, g, lum });
  }
  const lumWindow = (t0, t1) => {
    const acc = new Float32Array(GW * GH);
    let n = 0;
    let inWin = grids.filter((s2) => s2.t >= t0 - 1e-6 && s2.t <= t1 + 1e-6 && s2.lum);
    if (!inWin.length) inWin = grids.filter((s2) => s2.lum);
    for (const s2 of inWin) {
      for (let c = 0; c < GW * GH; c++) acc[c] += s2.lum[c];
      n++;
    }
    if (!n) return null;
    for (let c = 0; c < GW * GH; c++) acc[c] /= n;
    return acc;
  };
  const lumSeriesWindow = (t0, t1) => {
    let inWin = grids.filter((s2) => s2.t >= t0 - 1e-6 && s2.t <= t1 + 1e-6 && s2.lum);
    if (!inWin.length) inWin = grids.filter((s2) => s2.lum);
    return inWin.map((s2) => s2.lum);
  };
  const occWindow = (t0, t1) => {
    const occ = new Float32Array(GW * GH);
    let inWin = grids.filter((s) => s.t >= t0 - 1e-6 && s.t <= t1 + 1e-6);
    if (!inWin.length) {
      // window between samples → use nearest grid
      const mid = (t0 + t1) / 2;
      inWin = [grids.reduce((a, b) => (Math.abs(b.t - mid) < Math.abs(a.t - mid) ? b : a))];
    }
    for (const s of inWin) for (let c = 0; c < GW * GH; c++) if (s.g[c] > occ[c]) occ[c] = s.g[c];
    return occ;
  };

  // ad-hoc window query
  const qIn = parseFloat(process.argv[3]),
    qOut = parseFloat(process.argv[4]);
  if (Number.isFinite(qIn) && Number.isFinite(qOut)) {
    const a = analyze(
      occWindow(qIn, qOut),
      GW,
      GH,
      W,
      H,
      lumWindow(qIn, qOut),
      lumSeriesWindow(qIn, qOut),
    );
    console.log(
      `[safe-zones] window ${qIn}-${qOut}s: ${a.recommendation.toUpperCase()}  coverage ${a.coverage}%  clearer:${a.subject.clearerSide}`,
    );
    const z = a.zones;
    for (const k of ["largest", "left", "right", "top"])
      if (z[k]) console.log(`   ${k}: ${z[k].wPct}%×${z[k].hPct}% @ (${z[k].xPct}%,${z[k].yPct}%)`);
    console.log(JSON.stringify({ in: qIn, out: qOut, ...a }));
    return;
  }

  const globalOcc = occWindow(-1e9, 1e9);
  const globalLum = lumWindow(-1e9, 1e9);
  const global = analyze(globalOcc, GW, GH, W, H, globalLum, lumSeriesWindow(-1e9, 1e9));
  const windows = sentenceWindows(project).map((s) => {
    const a = analyze(
      occWindow(s.in, s.out),
      GW,
      GH,
      W,
      H,
      lumWindow(s.in, s.out),
      lumSeriesWindow(s.in, s.out),
    );
    return {
      in: s.in,
      out: s.out,
      text: s.text.slice(0, 48),
      coverage: a.coverage,
      recommendation: a.recommendation,
      clearerSide: a.subject.clearerSide,
      zones: a.zones,
    };
  });

  // ── v2: palette / optics / lighting from the mid frame + global grids ───────
  let palette = null,
    optics = null,
    lighting = null;
  try {
    const occCellG = new Uint8Array(GW * GH);
    for (let c = 0; c < GW * GH; c++) occCellG[c] = globalOcc[c] >= THRESH ? 1 : 0;
    const midName = frames[Math.floor(frames.length / 2)];
    const midBg = path.join(bgDir, midName);
    if (hasBg && fs.existsSync(midBg)) {
      palette = await scenePalette(midBg, occCellG, GW, GH);
      // subject bbox in px from the global occupancy grid
      let cx0 = GW,
        cx1 = -1,
        cy0 = GH,
        cy1 = -1;
      for (let y = 0; y < GH; y++)
        for (let x = 0; x < GW; x++)
          if (occCellG[y * GW + x]) {
            if (x < cx0) cx0 = x;
            if (x > cx1) cx1 = x;
            if (y < cy0) cy0 = y;
            if (y > cy1) cy1 = y;
          }
      const subjectBox =
        cx1 >= 0
          ? {
              x: (cx0 / GW) * W,
              y: (cy0 / GH) * H,
              w: ((cx1 - cx0 + 1) / GW) * W,
              h: ((cy1 - cy0 + 1) / GH) * H,
            }
          : null;
      optics = await sceneOptics(
        project,
        midBg,
        path.join(fgDir, midName),
        global.zones,
        subjectBox,
        W,
        H,
      );
      lighting = sceneLighting(globalLum, occCellG, GW, GH);
    }
  } catch (e) {
    console.error(`[safe-zones] scene optics skipped — ${e.message}`);
  }

  const out = {
    width: W,
    height: H,
    fps,
    grid: { cols: GW, rows: GH },
    ...global,
    palette,
    optics,
    lighting,
    windows,
  };
  fs.writeFileSync(path.join(project, "safe-zones.json"), JSON.stringify(out, null, 2));

  const z = (n, zn) =>
    zn
      ? `${n}: ${zn.wPct}%×${zn.hPct}% @ (${zn.xPct}%,${zn.yPct}%) [${zn.areaPct}%${zn.meanLuma != null ? ` · luma ${zn.meanLuma}${zn.bright ? " ⚠BRIGHT" : ""}` : ""}]`
      : `${n}: —`;
  console.log(
    `[safe-zones] ${W}×${H} grid ${GW}×${GH} @ ${fps}fps · GLOBAL coverage ${global.coverage}% · clearer ${global.subject.clearerSide} · verdict ${global.recommendation.toUpperCase()}`,
  );
  console.log(
    `             ${z("largest", global.zones.largest)} | ${z("left", global.zones.left)} | ${z("right", global.zones.right)} | ${z("top", global.zones.top)}`,
  );
  if (global.recommendation === "embed") {
    console.log(
      `[safe-zones] ✅ EMBED — NARRATION planes go in the clean zones (prefer ${global.subject.clearerSide}/top).`,
    );
    if (global.heroAnchor)
      console.log(
        `[safe-zones] 🎯 HERO → centered ON the subject: plane ≈ x${global.heroAnchor.plane.xPct}% y${global.heroAnchor.plane.yPct}% w${global.heroAnchor.plane.wPct}% center · BIG (~0.22–0.34·h) · target ~30–55% occlusion${global.heroAnchor.bandLuma != null ? ` · band luma ${global.heroAnchor.bandLuma}${global.heroAnchor.washoutRisk ? " ⚠WASHOUT RISK — see heroAnchor.note" : ""}` : ""}`,
      );
    if (global.heroBands)
      console.log(
        `[safe-zones] hero bands: best top ${global.heroBands.best.topPct}% (predicted occlusion ${global.heroBands.best.occPct}%) · bg-hero ${global.heroBands.feasible ? "FEASIBLE — keep the hero EMBEDDED (fg is last resort)" : "INFEASIBLE (no band ≤62%) → hero fg"}`,
      );
    if (global.zones.hugLeft || global.zones.hugRight)
      console.log(
        `[safe-zones] hugging zones (narration belongs HERE, abutting the silhouette): L ${global.zones.hugLeft ? global.zones.hugLeft.wPct + "%×" + global.zones.hugLeft.hPct + "%@x" + global.zones.hugLeft.xPct + "%" + (global.zones.hugLeft.bright ? "⚠bright" : "") : "—"} · R ${global.zones.hugRight ? global.zones.hugRight.wPct + "%×" + global.zones.hugRight.hPct + "%@x" + global.zones.hugRight.xPct + "%" + (global.zones.hugRight.bright ? "⚠bright" : "") : "—"}`,
      );
  } else {
    console.log(
      `[safe-zones] ⚠ FG — subject fills the frame; use caption_layer:"fg" (no clean region to embed behind).`,
    );
  }
  if (palette)
    console.log(
      `[safe-zones] 🎨 palette: dominant ${palette.dominant.map((d) => d.hex).join(" ")} · accent suggestion ${palette.accentSuggestion || "— (no chromatic anchor; use the DNA default)"} · ${palette.temperature}`,
    );
  if (optics && optics.sharpnessRatio != null)
    console.log(
      `[safe-zones] 🔭 depth: bg/subject sharpness ${optics.sharpnessRatio} → embed text blur ${optics.suggestedTextBlurPx}px${optics.suggestedTextBlurPx ? " (match the scene's depth-of-field)" : " (scene is uniformly sharp)"}`,
    );
  if (lighting)
    console.log(
      `[safe-zones] 💡 light from ${lighting.lightFrom} → contact shadow offset (${lighting.shadow.dx}px, ${lighting.shadow.dy}px)`,
    );
  if (windows.length) {
    console.log(`[safe-zones] per-sentence windows (place each group using ITS window's zones):`);
    for (const w of windows)
      console.log(
        `   [${w.in}-${w.out}s] ${w.recommendation.toUpperCase()} cov ${w.coverage}% clear:${w.clearerSide}  ${w.zones.largest ? `best ${w.zones.largest.wPct}%×${w.zones.largest.hPct}%@(${w.zones.largest.xPct}%,${w.zones.largest.yPct}%)` : ""}  "${w.text}"`,
      );
  }
  console.log(`[safe-zones] → ${path.join(project, "safe-zones.json")}`);
}
main().catch((e) => {
  console.error(`[safe-zones] (skipped — ${e.message})`);
  process.exit(0);
});