chore: import upstream snapshot with attribution

2026-07-13 12:58:35 +08:00
commit 85453da49f
4031 changed files with 710987 additions and 0 deletions
@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/* check-timing.cjs — verify plan.json word timings vs transcript.json (1:1 port of check-timing.py).
+ *   node check-timing.cjs <project-dir> [--strict]
+ */
+const path = require("path");
+const fs = require("fs");
+
+const DRIFT_TOL = 0.08;
+const CREATIVE_SUBS = {
+  "15%": ["fifteen", "percent"],
+  "1/3": ["one", "third"],
+  "2x": ["two", "times"],
+};
+const norm = (s) =>
+  String(s)
+    .replace(/^[ .,?!"']+|[ .,?!"']+$/g, "")
+    .toLowerCase();
+const splitPacked = (t) =>
+  String(t)
+    .split(/<br>|\s+/)
+    .filter(Boolean);
+
+function estimateVerticalBand(css, words, fw, fh) {
+  const top = css.match(/top:\s*(-?[\d.]+)%/);
+  if (!top) return null;
+  const topPct = parseFloat(top[1]);
+  const sizeM = css.match(/font-size:\s*calc\(\s*([\d.]+)\s*\*\s*var\(--h\)\s*\)/);
+  const fontPx = sizeM ? parseFloat(sizeM[1]) * fh : 0.05 * fh;
+  const lhM = css.match(/line-height:\s*([\d.]+)/);
+  const lh = lhM ? parseFloat(lhM[1]) : 1.1;
+  const charW = /uppercase/i.test(css) ? 0.72 : 0.6;
+  let lineCount = 1,
+    cur = 0;
+  const spaceW = fontPx * 0.3;
+  for (const w of words) {
+    const parts = String(w.text).split(/<br>/);
+    parts.forEach((part, i) => {
+      const pw = part.length * fontPx * charW;
+      if (i > 0) {
+        lineCount++;
+        cur = pw;
+      } else {
+        const test = cur + (cur > 0 ? spaceW : 0) + pw;
+        if (test > fw && cur > 0) {
+          lineCount++;
+          cur = pw;
+        } else cur = test;
+      }
+    });
+  }
+  return [topPct, topPct + (100 * (lineCount * fontPx * lh)) / fh];
+}
+
+function check(project, strict) {
+  const plan = JSON.parse(fs.readFileSync(path.join(project, "plan.json"), "utf8"));
+  const t = JSON.parse(fs.readFileSync(path.join(project, "transcript.json"), "utf8"));
+  const seq = (t.words || [])
+    .filter((w) => w.type === "word")
+    .map((w) => [norm(w.text), w.start, w.end]);
+  const issues = [];
+  const fw = plan.width || 720,
+    fh = plan.height || 1290;
+  const groups = plan.groups || [];
+  const bands = groups.map((g) =>
+    g.plane
+      ? [g.id || "?", g.in, g.out, null, true]
+      : [
+          g.id || "?",
+          g.in,
+          g.out,
+          estimateVerticalBand(g.css || "", g.words || [], fw, fh),
+          g.allow_overlap || false,
+        ],
+  );
+  for (let i = 0; i < bands.length; i++) {
+    const [gi, ai, bi, bbi, oki] = bands[i];
+    if (!bbi) continue;
+    for (let j = i + 1; j < bands.length; j++) {
+      const [gj, aj, bj, bbj, okj] = bands[j];
+      if (!bbj || oki || okj) continue;
+      if (Math.min(bi, bj) - Math.max(ai, aj) <= 0.05) continue;
+      if (Math.min(bbi[1], bbj[1]) - Math.max(bbi[0], bbj[0]) > 2.0)
+        issues.push(
+          `[${gi}↔${gj}] groups overlap in time (${Math.max(ai, aj).toFixed(2)}–${Math.min(bi, bj).toFixed(2)}s) AND vertically (band ${Math.max(bbi[0], bbj[0]).toFixed(0)}%–${Math.min(bbi[1], bbj[1]).toFixed(0)}%) — reposition one or add "allow_overlap": true if deliberate.`,
+        );
+    }
+  }
+  let ti = 0;
+  for (const g of groups) {
+    const gid = g.id || "?",
+      gin = g.in,
+      gout = g.out;
+    const ws = (g.words || []).map((w) => w.start),
+      we = (g.words || []).map((w) => w.end);
+    if (ws.length && gin != null) {
+      const e = Math.min(...ws);
+      if (e < gin - 0.01)
+        issues.push(
+          `[${gid}] group.in=${gin.toFixed(2)} but earliest word starts at ${e.toFixed(2)} — word delayed by ${(gin - e >= 0 ? "+" : "") + (gin - e).toFixed(2)}s. Lower group.in.`,
+        );
+    }
+    if (we.length && gout != null) {
+      const l = Math.max(...we);
+      if (l > gout + 0.01)
+        issues.push(
+          `[${gid}] group.out=${gout.toFixed(2)} but latest word ends at ${l.toFixed(2)} — word clipped. Raise group.out.`,
+        );
+    }
+    for (const w of g.words || []) {
+      // Exact pairing: a compiler that KNOWS the transcript index emits `ti` —
+      // duplicate words then pair by POSITION, not text-search (which grabs the
+      // first occurrence and reports a phantom drift). Sanity-check the text; on
+      // mismatch fall back to the text matcher below.
+      if (
+        Number.isInteger(w.ti) &&
+        seq[w.ti] &&
+        seq[w.ti][0] === norm(splitPacked(w.text)[0] || "")
+      ) {
+        const drift = w.start - seq[w.ti][1];
+        if (Math.abs(drift) > DRIFT_TOL)
+          issues.push(
+            `[${gid}] '${norm(w.text)}': plan=${w.start.toFixed(3)} transcript=${seq[w.ti][1].toFixed(3)} drift ${(drift >= 0 ? "+" : "") + drift.toFixed(3)}s`,
+          );
+        ti = w.ti + 1;
+        continue;
+      }
+      const parts = splitPacked(w.text).map(norm);
+      parts.forEach((part, pi) => {
+        if (!part) return;
+        if (part in CREATIVE_SUBS) {
+          for (const sub of CREATIVE_SUBS[part]) {
+            const j = seq.findIndex((s, k) => k >= ti && s[0] === sub);
+            if (j >= 0) ti = j + 1;
+          }
+          return;
+        }
+        let found = seq.findIndex((s, k) => k >= ti && s[0] === part);
+        if (found < 0) found = seq.findIndex((s) => s[0] === part);
+        if (found < 0) {
+          issues.push(`[${gid}] '${part}': NOT IN TRANSCRIPT (plan start=${w.start.toFixed(3)})`);
+          return;
+        }
+        const ts = seq[found][1];
+        ti = found + 1;
+        if (pi === 0) {
+          const drift = w.start - ts;
+          if (Math.abs(drift) > DRIFT_TOL)
+            issues.push(
+              `[${gid}] '${part}': plan=${w.start.toFixed(3)} transcript=${ts.toFixed(3)} drift ${(drift >= 0 ? "+" : "") + drift.toFixed(3)}s`,
+            );
+        } else
+          issues.push(
+            `[${gid}] '${part}' packed with '${parts[0]}': transcript=${ts.toFixed(3)} but entry has no distinct timing — split into separate word entries`,
+          );
+      });
+    }
+  }
+  const name = path.basename(project);
+  if (!issues.length) {
+    console.log(`${name}: timing OK ✓ (${seq.length} transcript words)`);
+    return 0;
+  }
+  console.log(`${name}: ${issues.length} timing issue(s):`);
+  for (const i of issues) console.log(`  ${i}`);
+  return strict ? 1 : 0;
+}
+
+const args = process.argv.slice(2).filter((a) => a !== "--strict");
+if (!args.length) {
+  console.error("usage: check-timing.cjs <project-dir> [--strict]");
+  process.exit(2);
+}
+process.exit(check(path.resolve(args[0]), process.argv.includes("--strict")));