video-editing 1.3.1 → 3.0.0

package/dist/chunk-63HIQBDT.js

@@ -1,4321 +0,0 @@
-#!/usr/bin/env node
-import {
-  displayedDimensions,
-  ffprobe,
-  isoNow,
-  mediaDuration,
-  pyFixed,
-  pyFixedPad,
-  pyRound,
-  pySpacePad,
-  run,
-  transcriptPath,
-  videoStream
-} from "./chunk-CU3NBKB4.js";
-
-// src/config.ts
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function configDir() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg && xdg.trim() ? xdg : join(homedir(), ".config");
-  return join(base, "video-editing");
-}
-function configEnvPath() {
-  return join(configDir(), ".env");
-}
-function parseEnvFileForKey(path, key) {
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    return void 0;
-  }
-  for (const raw of text.split(/\r?\n/)) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || !line.includes("=")) continue;
-    const eq = line.indexOf("=");
-    const k = line.slice(0, eq).trim();
-    if (k === key) {
-      let v = line.slice(eq + 1).trim();
-      v = v.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
-      return v.trim();
-    }
-  }
-  return void 0;
-}
-function loadApiKey(opts = {}) {
-  const fromEnv = process.env.ELEVENLABS_API_KEY;
-  if (fromEnv && fromEnv.trim()) return fromEnv.trim();
-  if (opts.apiKey && opts.apiKey.trim()) return opts.apiKey.trim();
-  const candidates = [];
-  if (opts.envPath) candidates.push(opts.envPath);
-  candidates.push(configEnvPath());
-  for (const path of candidates) {
-    if (existsSync(path)) {
-      const v = parseEnvFileForKey(path, "ELEVENLABS_API_KEY");
-      if (v) return v;
-    }
-  }
-  throw new Error(
-    `ELEVENLABS_API_KEY not found. Set the env var, pass --api-key, or add it to ${configEnvPath()}`
-  );
-}
-
-// src/master.ts
-import { writeFileSync } from "fs";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-var X264_BAKE = [
-  "-c:v",
-  "libx264",
-  "-preset",
-  "medium",
-  "-crf",
-  "18",
-  "-pix_fmt",
-  "yuv420p",
-  "-c:a",
-  "aac",
-  "-b:a",
-  "192k",
-  "-movflags",
-  "+faststart"
-];
-async function ensureVerticalMaster(jobDir, source, opts = {}) {
-  const out = join2(jobDir, "vertical_src.mp4");
-  if (existsSync2(out) && !opts.force) return out;
-  const probe = await ffprobe(source);
-  const stream = videoStream(probe);
-  const [displayW, displayH, rotation] = displayedDimensions(stream);
-  const longEdge = Math.max(displayW, displayH);
-  let vf = displayH >= displayW && longEdge > 1920 ? "scale=-2:1920" : null;
-  if (displayW > displayH && longEdge > 1920) vf = "scale=1920:-2";
-  const cmd = ["ffmpeg", "-y", "-i", source];
-  if (vf) cmd.push("-vf", vf);
-  cmd.push(...X264_BAKE, out);
-  await run(cmd);
-  const outProbe = await ffprobe(out);
-  const outStream = videoStream(outProbe);
-  const outW = Math.trunc(Number(outStream.width ?? 0)) || 0;
-  const outH = Math.trunc(Number(outStream.height ?? 0)) || 0;
-  let retriedWith = null;
-  if (displayH > displayW && outW > outH) {
-    retriedWith = vf ? `transpose=1,${vf}` : "transpose=1";
-    await run(["ffmpeg", "-y", "-i", source, "-vf", retriedWith, ...X264_BAKE, out]);
-  }
-  writeFileSync(
-    join2(jobDir, "master.json"),
-    JSON.stringify(
-      {
-        source,
-        master: out,
-        display_width: displayW,
-        display_height: displayH,
-        rotation,
-        scale_filter: vf,
-        retry_filter: retriedWith,
-        created: isoNow()
-      },
-      null,
-      2
-    ) + "\n",
-    "utf8"
-  );
-  return out;
-}
-
-// src/transcribe.ts
-import { existsSync as existsSync3, mkdtempSync, mkdirSync, rmSync, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename, extname, join as join3 } from "path";
-var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
-function stemOf(p) {
-  return basename(p, extname(p));
-}
-async function extractAudio(videoPath, dest) {
-  await run(
-    [
-      "ffmpeg",
-      "-y",
-      "-i",
-      videoPath,
-      "-vn",
-      "-ac",
-      "1",
-      "-ar",
-      "16000",
-      "-c:a",
-      "pcm_s16le",
-      dest
-    ],
-    { capture: true, echo: false }
-  );
-}
-async function extractAudioWindow(video, start, end, dest) {
-  await run(
-    [
-      "ffmpeg",
-      "-y",
-      "-ss",
-      start.toFixed(3),
-      "-i",
-      video,
-      "-t",
-      Math.max(0.05, end - start).toFixed(3),
-      "-vn",
-      "-ac",
-      "1",
-      "-ar",
-      "16000",
-      "-c:a",
-      "pcm_s16le",
-      dest
-    ],
-    { capture: true, echo: false }
-  );
-}
-async function callScribe(audioPath, apiKey, language, numSpeakers) {
-  const form = new FormData();
-  form.append("model_id", "scribe_v1");
-  form.append("diarize", "true");
-  form.append("tag_audio_events", "true");
-  form.append("timestamps_granularity", "word");
-  if (language) form.append("language_code", language);
-  if (numSpeakers) form.append("num_speakers", String(numSpeakers));
-  const { readFileSync: readFileSync11 } = await import("fs");
-  const buf = readFileSync11(audioPath);
-  const blob = new Blob([buf], { type: "audio/wav" });
-  form.append("file", blob, basename(audioPath));
-  const resp = await fetch(SCRIBE_URL, {
-    method: "POST",
-    headers: { "xi-api-key": apiKey },
-    body: form,
-    signal: AbortSignal.timeout(18e5)
-  });
-  if (resp.status !== 200) {
-    const body = await resp.text();
-    throw new Error(`Scribe returned ${resp.status}: ${body.slice(0, 500)}`);
-  }
-  return await resp.json();
-}
-var LONG_TOKEN_S = 1.2;
-function wordDur(w) {
-  const s = w.start;
-  const e = w.end;
-  return s !== null && s !== void 0 && e !== null && e !== void 0 ? e - s : 0;
-}
-function realTokens(words) {
-  return words.filter(
-    (w) => (w.type === "word" || w.type === "audio_event") && w.start !== null && w.start !== void 0 && w.end !== null && w.end !== void 0
-  );
-}
-function attemptKey(lo, hi) {
-  return `${pyRound(lo, 2)},${pyRound(hi, 2)}`;
-}
-function nextRepair(words, duration, maxTokenS = LONG_TOKEN_S, gapS = 2.5, attempted = /* @__PURE__ */ new Set()) {
-  for (const w of words) {
-    if (w.type === "word" && wordDur(w) > maxTokenS) {
-      const lo = Number(w.start);
-      const hi = Number(w.end);
-      if (!attempted.has(attemptKey(lo, hi))) return { kind: "collapse", lo, hi };
-    }
-  }
-  const toks = realTokens(words);
-  if (toks.length === 0) return null;
-  for (let k = 1; k < toks.length; k++) {
-    const lo = Number(toks[k - 1].end);
-    const hi = Number(toks[k].start);
-    if (hi - lo > gapS && !attempted.has(attemptKey(lo, hi))) return { kind: "drop", lo, hi };
-  }
-  if (duration !== null && duration !== void 0 && duration - Number(toks[toks.length - 1].end) > gapS) {
-    const lo = Number(toks[toks.length - 1].end);
-    const hi = duration;
-    if (!attempted.has(attemptKey(lo, hi))) return { kind: "trailing", lo, hi };
-  }
-  return null;
-}
-function anchorNorm(text) {
-  return (text ?? "").toLowerCase().replace(/[^\p{L}\p{N}_֐-׿]/gu, "");
-}
-function goodAnchor(w) {
-  return w.type === "word" && w.start !== null && w.start !== void 0 && anchorNorm(w.text).length >= 2;
-}
-function findAnchors(words, lo, hi) {
-  let fa = null;
-  for (const w of words) {
-    if (goodAnchor(w) && w.end !== null && w.end !== void 0 && Number(w.end) <= lo + 1e-6) {
-      fa = w;
-    }
-  }
-  let ba = null;
-  for (const w of words) {
-    if (goodAnchor(w) && Number(w.start) >= hi - 1e-6) {
-      ba = w;
-      break;
-    }
-  }
-  return { fa, ba };
-}
-function anchorSplice(words, lo, hi, recovered, fa, ba) {
-  const locate = (anchor) => {
-    if (anchor === null) return null;
-    const target = anchorNorm(anchor.text);
-    let best = null;
-    let bestd = 1.2;
-    for (let idx = 0; idx < recovered.length; idx++) {
-      const rw = recovered[idx];
-      if (rw.type !== "word" || rw.start === null || rw.start === void 0) continue;
-      if (anchorNorm(rw.text) === target) {
-        const d = Math.abs(Number(rw.start) - Number(anchor.start));
-        if (d < bestd) {
-          best = idx;
-          bestd = d;
-        }
-      }
-    }
-    if (best !== null) return best;
-    best = null;
-    bestd = 0.5;
-    for (let idx = 0; idx < recovered.length; idx++) {
-      const rw = recovered[idx];
-      if (rw.type !== "word" || rw.start === null || rw.start === void 0) continue;
-      const d = Math.abs(Number(rw.start) - Number(anchor.start));
-      if (d < bestd) {
-        best = idx;
-        bestd = d;
-      }
-    }
-    return best;
-  };
-  const fi = locate(fa);
-  const bi = locate(ba);
-  const startI = fi !== null ? fi + 1 : 0;
-  let endI = bi !== null ? bi : recovered.length;
-  if (endI < startI) endI = startI;
-  const middle = recovered.slice(startI, endI).map((x) => ({ ...x }));
-  while (middle.length && middle[0].type === "spacing") middle.shift();
-  while (middle.length && middle[middle.length - 1].type === "spacing") middle.pop();
-  const low = fa !== null ? Number(fa.start) : -Infinity;
-  const high = ba !== null ? Number(ba.start) : Infinity;
-  const kept = words.filter(
-    (w) => w.start === null || w.start === void 0 || Number(w.start) <= low + 1e-6 || Number(w.start) >= high - 1e-6
-  );
-  const merged = [...kept, ...middle];
-  merged.sort((a, b) => {
-    const sa = a.start !== null && a.start !== void 0 ? Number(a.start) : 1e18;
-    const sb = b.start !== null && b.start !== void 0 ? Number(b.start) : 1e18;
-    return sa - sb;
-  });
-  return { merged, nMid: middle.length };
-}
-async function healCollapsedTokens(payload, video, apiKey, opts = {}) {
-  const {
-    language,
-    verbose = true,
-    maxTokenS = LONG_TOKEN_S,
-    gapS = 2.5,
-    pad = 0.25,
-    maxIters = 12
-  } = opts;
-  let words = payload.words ?? [];
-  if (!words.length) return payload;
-  let duration = null;
-  try {
-    duration = await mediaDuration(video);
-  } catch {
-    duration = null;
-  }
-  const attempted = /* @__PURE__ */ new Set();
-  let healed = false;
-  for (let i = 0; i < maxIters; i++) {
-    const region = nextRepair(words, duration, maxTokenS, gapS, attempted);
-    if (region === null) break;
-    const { lo, hi } = region;
-    attempted.add(attemptKey(lo, hi));
-    if (verbose) {
-      console.error(
-        `  heal: suspicious span ${lo.toFixed(2)}-${hi.toFixed(2)} (${(hi - lo).toFixed(1)}s) \u2014 re-transcribing in isolation`
-      );
-    }
-    const { fa, ba } = findAnchors(words, lo, hi);
-    const winLo = (fa !== null ? Number(fa.start) : lo) - pad;
-    const winHi = (ba !== null ? Number(ba.end) : hi) + pad;
-    let win;
-    let ws;
-    const tmp = mkdtempSync(join3(tmpdir(), "scribe-heal-"));
-    try {
-      const wav = join3(tmp, "window.wav");
-      ws = Math.max(0, winLo);
-      const we = duration === null ? winHi : Math.min(duration, winHi);
-      await extractAudioWindow(video, ws, we, wav);
-      win = await callScribe(wav, apiKey, language, void 0);
-    } catch (e) {
-      if (verbose) console.error(`        window re-transcribe failed (${String(e)}); leaving as-is`);
-      continue;
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-    const recovered = [];
-    for (const orig of win.words ?? []) {
-      const rw = { ...orig };
-      if (rw.start !== null && rw.start !== void 0) rw.start = rw.start + ws;
-      if (rw.end !== null && rw.end !== void 0) rw.end = rw.end + ws;
-      recovered.push(rw);
-    }
-    const beforeWords = words.filter((t) => t.type === "word").length;
-    const { merged, nMid } = anchorSplice(words, lo, hi, recovered, fa, ba);
-    if (nMid === 0) {
-      if (verbose) console.error("        (nothing recovered \u2014 treating as real silence)");
-      continue;
-    }
-    words = merged;
-    healed = true;
-    if (verbose) {
-      const net = words.filter((t) => t.type === "word").length - beforeWords;
-      const sign = net >= 0 ? `+${net}` : `${net}`;
-      console.error(`        spliced ${nMid} token(s) (net ${sign} words)`);
-    }
-  }
-  payload.words = words;
-  if (healed && typeof payload.text === "string") {
-    const rebuilt = words.map((w) => w.text ?? (w.type === "spacing" ? " " : "")).join("").trim();
-    payload.text = rebuilt || payload.text;
-  }
-  return payload;
-}
-async function transcribeOne(video, opts) {
-  const { editDir, language, numSpeakers, noHeal = false, force = false, verbose = true } = opts;
-  const apiKey = loadApiKey({ apiKey: opts.apiKey });
-  const heal = !noHeal;
-  const transcriptsDir = join3(editDir, "transcripts");
-  mkdirSync(transcriptsDir, { recursive: true });
-  const stem = stemOf(video);
-  const outPath = join3(transcriptsDir, `${stem}.json`);
-  if (existsSync3(outPath) && !force) {
-    if (verbose) console.error(`cached: ${basename(outPath)}`);
-    return outPath;
-  }
-  if (verbose) console.error(`  extracting audio from ${basename(video)}`);
-  const t0 = Date.now();
-  const tmp = mkdtempSync(join3(tmpdir(), "scribe-"));
-  let payload;
-  try {
-    const audio = join3(tmp, `${stem}.wav`);
-    await extractAudio(video, audio);
-    const audioS = await mediaDuration(audio);
-    const videoS = await mediaDuration(video);
-    if (Number.isFinite(audioS) && Number.isFinite(videoS) && Math.abs(audioS - videoS) > 0.15) {
-      throw new Error(
-        `source A/V clocks diverge: decoded audio is ${audioS.toFixed(3)}s but video is ${videoS.toFixed(3)}s (\u0394 ${(audioS - videoS).toFixed(3)}s). Word timestamps would drift against the picture by up to that much. Re-export the source with a clean muxer (e.g. \`ffmpeg -i in -c:v copy -af aresample=async=1 out.mp4\`) and retry.`
-      );
-    }
-    const sizeMb = statSync(audio).size / (1024 * 1024);
-    if (verbose) console.error(`  uploading ${stem}.wav (${sizeMb.toFixed(1)} MB)`);
-    payload = await callScribe(audio, apiKey, language, numSpeakers);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-  if (heal) {
-    payload = await healCollapsedTokens(payload, video, apiKey, { language, verbose });
-  }
-  writeFileSync2(outPath, JSON.stringify(payload, null, 2));
-  const dt = (Date.now() - t0) / 1e3;
-  if (verbose) {
-    const kb = statSync(outPath).size / 1024;
-    console.error(`  saved: ${basename(outPath)} (${kb.toFixed(1)} KB) in ${dt.toFixed(1)}s`);
-    if (payload && typeof payload === "object" && "words" in payload) {
-      console.error(`    words: ${payload.words.length}`);
-    }
-  }
-  return outPath;
-}
-
-// src/flag-takes.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { basename as basename2 } from "path";
-var LONG_TOKEN_S2 = 1.2;
-var BIG_GAP_S = 1;
-var REPEAT_WINDOW = 15;
-function norm(t) {
-  return (t ?? "").toLowerCase().replace(/[^\p{L}\p{N}_֐-׿]/gu, "");
-}
-function dur(w) {
-  const s = w.start;
-  const e = w.end;
-  return s !== null && s !== void 0 && e !== null && e !== void 0 ? e - s : 0;
-}
-function fmtG(x) {
-  return String(x);
-}
-function screenTakes(transcriptPath2, opts) {
-  const offset = opts?.offset ?? 0;
-  const longTokenS = opts?.longToken ?? LONG_TOKEN_S2;
-  const gapS = opts?.gap ?? BIG_GAP_S;
-  const parsed = JSON.parse(readFileSync2(transcriptPath2, "utf-8"));
-  const words = parsed.words ?? [];
-  const real = words.filter(
-    (w) => (w.type === "word" || w.type === "audio_event") && w.start !== null && w.start !== void 0
-  );
-  const out = [];
-  const print = (line = "") => {
-    out.push(line + "\n");
-  };
-  print(`## ${basename2(transcriptPath2)}  (${real.length} tokens, offset +${fmtG(offset)})`);
-  const longs = real.filter((w) => w.type === "word" && dur(w) > longTokenS);
-  print("\n[A] OVER-LONG TOKENS (likely a collapsed retake \u2014 re-transcribe this window):");
-  if (longs.length > 0) {
-    for (const w of longs) {
-      const start = w.start + offset;
-      const end = w.end + offset;
-      print(
-        `    ${pySpacePad(start, 7, 2)}-${pySpacePad(end, 7, 2)}  (${pySpacePad(dur(w), 4, 1)}s)  '${(w.text ?? "").trim()}'`
-      );
-    }
-  } else {
-    print("    (none)");
-  }
-  const toks = [];
-  for (const w of real) {
-    if (w.type === "word") {
-      const n = norm(w.text);
-      if (n) toks.push([n, w.start + offset]);
-    }
-  }
-  print("\n[B] REPEATED PHRASES (retake fingerprint \u2014 judge vs intentional repeats):");
-  let coveredUntil = -1;
-  let anyB = false;
-  for (let i = 0; i < toks.length; i++) {
-    if (i <= coveredUntil) continue;
-    const iTime = toks[i][1];
-    let best = null;
-    for (const k of [4, 3, 2]) {
-      const gram = toks.slice(i, i + k).map((t) => t[0]);
-      if (gram.length < k) continue;
-      const jEnd = Math.min(i + k + REPEAT_WINDOW, toks.length - k + 1);
-      for (let j = i + k; j < jEnd; j++) {
-        const cand = toks.slice(j, j + k).map((t) => t[0]);
-        if (cand.length === gram.length && cand.every((v, idx) => v === gram[idx])) {
-          best = [k, toks[j][1], gram];
-          break;
-        }
-      }
-      if (best) break;
-    }
-    if (best) {
-      const [k, jTime, gram] = best;
-      anyB = true;
-      coveredUntil = i + k - 1;
-      print(`    ${pySpacePad(iTime, 7, 2)}s & ${pySpacePad(jTime, 7, 2)}s : "${gram.join(" ")}"`);
-    }
-  }
-  if (!anyB) print("    (none)");
-  print("\n[C] AUDIO EVENTS / BIG GAPS:");
-  let anyC = false;
-  for (const w of real) {
-    if (w.type === "audio_event") {
-      anyC = true;
-      const start = w.start + offset;
-      print(`    ${pySpacePad(start, 7, 2)}s  audio-event '${(w.text ?? "").trim()}'`);
-    }
-  }
-  let prevEnd = null;
-  for (const w of real) {
-    const start = w.start;
-    if (prevEnd !== null && start - prevEnd > gapS) {
-      anyC = true;
-      print(
-        `    ${pySpacePad(prevEnd + offset, 7, 2)}->${pySpacePad(start + offset, 7, 2)}  GAP ${pySpacePad(start - prevEnd, 4, 1)}s (untokenized)`
-      );
-    }
-    prevEnd = "end" in w && w.end !== void 0 ? w.end : start;
-  }
-  if (!anyC) print("    (none)");
-  print();
-  return out.join("");
-}
-
-// src/pack-transcripts.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync } from "fs";
-import { join as join4, basename as basename3, extname as extname2 } from "path";
-function formatTime(seconds) {
-  return pyFixedPad(seconds, 6, 2);
-}
-function formatDuration(seconds) {
-  if (seconds < 60) {
-    return `${pyFixed(seconds, 1)}s`;
-  }
-  const m = Math.floor(seconds / 60);
-  const s = seconds - m * 60;
-  return `${m}m ${pyFixedPad(s, 4, 1)}s`;
-}
-function groupIntoPhrases(words, silenceThreshold = 0.5) {
-  const phrases = [];
-  let currentWords = [];
-  let currentStart = null;
-  let currentSpeaker = null;
-  function flush() {
-    if (currentWords.length === 0) {
-      return;
-    }
-    const textParts = [];
-    for (const w of currentWords) {
-      const t = w.type ?? "word";
-      let raw = (w.text ?? "").trim();
-      if (!raw) {
-        continue;
-      }
-      if (t === "audio_event") {
-        if (!raw.startsWith("(")) {
-          raw = `(${raw})`;
-        }
-      }
-      textParts.push(raw);
-    }
-    if (textParts.length === 0) {
-      currentWords = [];
-      currentStart = null;
-      currentSpeaker = null;
-      return;
-    }
-    let text = textParts.join(" ");
-    text = text.replaceAll(" ,", ",").replaceAll(" .", ".").replaceAll(" ?", "?").replaceAll(" !", "!");
-    const last = currentWords[currentWords.length - 1];
-    const endTime = "end" in last && last.end !== void 0 ? last.end : "start" in last && last.start !== void 0 ? last.start : currentStart ?? 0;
-    phrases.push({
-      start: currentStart,
-      end: endTime,
-      text,
-      speaker_id: currentSpeaker
-    });
-    currentWords = [];
-    currentStart = null;
-    currentSpeaker = null;
-  }
-  let prevEnd = null;
-  for (const w of words) {
-    const t = w.type ?? "word";
-    if (t === "spacing") {
-      const start2 = w.start;
-      const end = w.end;
-      if (start2 !== null && start2 !== void 0 && end !== null && end !== void 0) {
-        const gap = end - start2;
-        if (gap >= silenceThreshold) {
-          flush();
-        }
-      }
-      continue;
-    }
-    const start = w.start;
-    if (start === null || start === void 0) {
-      continue;
-    }
-    const speaker = w.speaker_id;
-    if (currentSpeaker !== null && currentSpeaker !== void 0 && speaker !== null && speaker !== void 0 && speaker !== currentSpeaker) {
-      flush();
-    }
-    if (prevEnd !== null && start - prevEnd >= silenceThreshold) {
-      flush();
-    }
-    if (currentStart === null) {
-      currentStart = start;
-      currentSpeaker = speaker;
-    }
-    currentWords.push(w);
-    prevEnd = "end" in w && w.end !== void 0 && w.end !== null ? w.end : start;
-  }
-  flush();
-  return phrases;
-}
-function packOneFile(jsonPath, silenceThreshold) {
-  const data = JSON.parse(readFileSync3(jsonPath, "utf-8"));
-  const words = data.words ?? [];
-  const phrases = groupIntoPhrases(words, silenceThreshold);
-  let duration;
-  if (phrases.length > 0) {
-    duration = (phrases[phrases.length - 1].end ?? 0) - (phrases[0].start ?? 0);
-  } else {
-    duration = 0;
-  }
-  const stem = basename3(jsonPath, extname2(jsonPath));
-  return { name: stem, duration, phrases };
-}
-function renderMarkdown(entries, silenceThreshold) {
-  const lines = [];
-  lines.push("# Packed transcripts");
-  lines.push("");
-  lines.push(`Phrase-level, grouped on silences \u2265 ${pyFixed(silenceThreshold, 1)}s or speaker change.`);
-  lines.push("Use `[start-end]` ranges to address cuts in the EDL.");
-  lines.push("");
-  for (const { name, duration, phrases } of entries) {
-    lines.push(`## ${name}  (duration: ${formatDuration(duration)}, ${phrases.length} phrases)`);
-    if (phrases.length === 0) {
-      lines.push("  _no speech detected_");
-      lines.push("");
-      continue;
-    }
-    for (const p of phrases) {
-      const spk = p.speaker_id;
-      let spkTag;
-      if (spk !== null && spk !== void 0) {
-        let spkStr = String(spk);
-        if (spkStr.startsWith("speaker_")) {
-          spkStr = spkStr.slice("speaker_".length);
-        }
-        spkTag = ` S${spkStr}`;
-      } else {
-        spkTag = "";
-      }
-      lines.push(`  [${formatTime(p.start ?? 0)}-${formatTime(p.end ?? 0)}]${spkTag} ${p.text}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function packTranscripts(editDir, opts = {}) {
-  const silenceThreshold = opts.silenceThreshold ?? 0.5;
-  const transcriptsDir = join4(editDir, "transcripts");
-  let entries;
-  try {
-    entries = readdirSync(transcriptsDir);
-  } catch {
-    throw new Error(`no transcripts directory at ${transcriptsDir}`);
-  }
-  const jsonFiles = entries.filter((f) => f.endsWith(".json")).map((f) => join4(transcriptsDir, f)).sort();
-  if (jsonFiles.length === 0) {
-    throw new Error(`no .json files in ${transcriptsDir}`);
-  }
-  const packed = jsonFiles.map((p) => packOneFile(p, silenceThreshold));
-  const markdown = renderMarkdown(packed, silenceThreshold);
-  const outPath = opts.output ?? join4(editDir, "takes_packed.md");
-  writeFileSync3(outPath, markdown, { encoding: "utf-8" });
-  return { path: outPath, content: markdown };
-}
-
-// src/grade.ts
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync4, rmSync as rmSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
-var PRESETS = {
-  // Subtle baseline — barely perceptible cleanup. No color shift.
-  // Use when auto-analysis isn't available or when you want a safe floor.
-  subtle: "eq=contrast=1.03:saturation=0.98",
-  // Minimal corrective grade: light contrast + subtle S-curve, no color shifts.
-  neutral_punch: "eq=contrast=1.06:brightness=0.0:saturation=1.0,curves=master='0/0 0.25/0.23 0.75/0.77 1/1'",
-  // OPT-IN creative preset for retro/cinematic looks ONLY. Not a default.
-  // +12% contrast, crushed blacks, -12% sat, warm shadows + cool highs, filmic curve.
-  // Originally from HEURISTICS §6 — too aggressive for standard launch content.
-  warm_cinematic: "eq=contrast=1.12:brightness=-0.02:saturation=0.88,colorbalance=rs=0.02:gs=0.0:bs=-0.03:rm=0.04:gm=0.01:bm=-0.02:rh=0.08:gh=0.02:bh=-0.05,curves=master='0/0 0.25/0.22 0.75/0.78 1/1'",
-  // Flat — no grade. Useful as a sentinel for "skip grading this source".
-  none: ""
-};
-function getPreset(name) {
-  if (!(name in PRESETS)) {
-    const available = Object.keys(PRESETS).sort().join(", ");
-    throw new Error(`unknown preset '${name}'. Available: ${available}`);
-  }
-  return PRESETS[name];
-}
-function decideGradeFilter(stats) {
-  const { y_mean, y_range, sat_mean } = stats;
-  let contrast_adj = 1;
-  if (y_range < 0.65) {
-    const t = Math.max(0, Math.min(1, (y_range - 0.5) / 0.15));
-    contrast_adj = 1.08 - 0.05 * t;
-  } else {
-    contrast_adj = 1.03;
-  }
-  let gamma_adj = 1;
-  if (y_mean < 0.42) {
-    const t = Math.max(0, Math.min(1, (y_mean - 0.3) / 0.12));
-    gamma_adj = 1.1 - 0.08 * t;
-  } else if (y_mean > 0.6) {
-    gamma_adj = 0.97;
-  }
-  let sat_adj = 0.98;
-  if (sat_mean < 0.18) {
-    sat_adj = 1.04;
-  } else if (sat_mean > 0.38) {
-    sat_adj = 0.96;
-  }
-  contrast_adj = Math.max(0.94, Math.min(1.08, contrast_adj));
-  gamma_adj = Math.max(0.94, Math.min(1.1, gamma_adj));
-  sat_adj = Math.max(0.94, Math.min(1.06, sat_adj));
-  const eq_parts = [];
-  if (Math.abs(contrast_adj - 1) > 5e-3) {
-    eq_parts.push(`contrast=${pyFixed(contrast_adj, 3)}`);
-  }
-  if (Math.abs(gamma_adj - 1) > 5e-3) {
-    eq_parts.push(`gamma=${pyFixed(gamma_adj, 3)}`);
-  }
-  if (Math.abs(sat_adj - 1) > 5e-3) {
-    eq_parts.push(`saturation=${pyFixed(sat_adj, 3)}`);
-  }
-  if (eq_parts.length === 0) return "";
-  return "eq=" + eq_parts.join(":");
-}
-function parseValue(line) {
-  const idx = line.lastIndexOf("=");
-  if (idx === -1) return null;
-  const raw = line.slice(idx + 1);
-  const v = Number.parseFloat(raw);
-  if (Number.isNaN(v)) return null;
-  return v;
-}
-async function sampleFrameStats(video, start, duration, nSamples = 10) {
-  const fps = Math.max(0.5, Math.min(nSamples / Math.max(duration, 0.1), 10));
-  const dir = mkdtempSync2(join5(tmpdir2(), "grade-"));
-  const metadataPath = join5(dir, "signalstats.txt");
-  try {
-    const cmd = [
-      "ffmpeg",
-      "-y",
-      "-hide_banner",
-      "-nostats",
-      "-ss",
-      pyFixed(start, 3),
-      "-i",
-      video,
-      "-t",
-      pyFixed(duration, 3),
-      "-vf",
-      `fps=${fps.toFixed(2)},signalstats,metadata=print:file=${metadataPath}`,
-      "-f",
-      "null",
-      "-"
-    ];
-    await run(cmd, { capture: true, check: true, echo: false });
-    const y_avgs = [];
-    const y_mins = [];
-    const y_maxs = [];
-    const sat_avgs = [];
-    let bit_depth = 8;
-    let text = "";
-    try {
-      text = readFileSync4(metadataPath, "utf8");
-    } catch {
-      text = "";
-    }
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim();
-      if (line.includes("lavfi.signalstats.YBITDEPTH")) {
-        const v = parseValue(line);
-        if (v !== null) bit_depth = Math.trunc(v);
-      } else if (line.includes("lavfi.signalstats.YAVG")) {
-        const v = parseValue(line);
-        if (v !== null) y_avgs.push(v);
-      } else if (line.includes("lavfi.signalstats.YMIN")) {
-        const v = parseValue(line);
-        if (v !== null) y_mins.push(v);
-      } else if (line.includes("lavfi.signalstats.YMAX")) {
-        const v = parseValue(line);
-        if (v !== null) y_maxs.push(v);
-      } else if (line.includes("lavfi.signalstats.SATAVG")) {
-        const v = parseValue(line);
-        if (v !== null) sat_avgs.push(v);
-      }
-    }
-    if (y_avgs.length === 0) {
-      return { y_mean: 0.5, y_range: 0.72, sat_mean: 0.25 };
-    }
-    const max_val = Math.pow(2, bit_depth) - 1;
-    const mean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
-    const y_mean = mean(y_avgs) / max_val;
-    const y_range = y_maxs.length > 0 && y_mins.length > 0 ? (mean(y_maxs) - mean(y_mins)) / max_val : 0.7;
-    const sat_mean = sat_avgs.length > 0 ? mean(sat_avgs) / max_val : 0.25;
-    return { y_mean, y_range, sat_mean };
-  } finally {
-    rmSync2(dir, { recursive: true, force: true });
-  }
-}
-async function autoGradeForClip(input) {
-  let duration = 10;
-  try {
-    const res = await run(
-      [
-        "ffprobe",
-        "-v",
-        "error",
-        "-show_entries",
-        "format=duration",
-        "-of",
-        "default=noprint_wrappers=1:nokey=1",
-        input
-      ],
-      { capture: true, check: true, echo: false }
-    );
-    const parsed = Number.parseFloat(res.stdout.trim());
-    if (!Number.isNaN(parsed)) duration = parsed;
-  } catch {
-    duration = 10;
-  }
-  const stats = await sampleFrameStats(input, 0, duration);
-  return decideGradeFilter(stats);
-}
-
-// src/render.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname, isAbsolute, resolve } from "path";
-var SUB_FORCE_STYLE = "FontName=Helvetica,FontSize=18,Bold=1,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,BackColour=&H00000000,BorderStyle=1,Outline=2,Shadow=0,Alignment=2,MarginV=90";
-var HDR_TRANSFERS = /* @__PURE__ */ new Set(["smpte2084", "arib-std-b67"]);
-var TONEMAP_CHAIN = "zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p";
-var LOUDNORM_I_STR = "-14.0";
-var LOUDNORM_TP_STR = "-1.0";
-var LOUDNORM_LRA_STR = "11.0";
-var PUNCT_BREAK = /* @__PURE__ */ new Set([".", ",", "!", "?", ";", ":"]);
-function f6floor(x) {
-  return (Math.floor(x * 1e6 + 1e-3) / 1e6).toFixed(6);
-}
-function f3(x) {
-  return pyFixed(x, 3);
-}
-function pyFloatStr(x) {
-  if (Number.isInteger(x)) return `${x}.0`;
-  return String(x);
-}
-function resolvePath(maybePath, base) {
-  if (isAbsolute(maybePath)) return maybePath;
-  return resolve(base, maybePath);
-}
-function resolveGradeFilter(gradeField) {
-  if (!gradeField) return "";
-  if (gradeField === "auto") return "__AUTO__";
-  if (/^[a-zA-Z0-9_-]+$/.test(gradeField)) {
-    try {
-      return getPreset(gradeField);
-    } catch {
-      process.stderr.write(`warning: unknown preset '${gradeField}', using as raw filter
-`);
-      return gradeField;
-    }
-  }
-  return gradeField;
-}
-function afadeFilter(durationS) {
-  const fadeOutStart = Math.max(0, durationS - 0.03);
-  return `afade=t=in:st=0:d=0.03,afade=t=out:st=${f3(fadeOutStart)}:d=0.03`;
-}
-function modePresetCrf(opts) {
-  if (opts.draft) return { preset: "ultrafast", crf: "28" };
-  if (opts.preview) return { preset: "medium", crf: "22" };
-  return { preset: "fast", crf: "20" };
-}
-function scaleFilter(opts) {
-  if (opts.draft) {
-    return opts.portrait ? "scale=-2:1280" : "scale=1280:-2";
-  }
-  return opts.portrait ? "scale=-2:1920" : "scale=1920:-2";
-}
-function segmentVf(gradeFilter, opts) {
-  const parts = [];
-  if (opts.hdr) parts.push(TONEMAP_CHAIN);
-  parts.push(scaleFilter(opts));
-  if (gradeFilter) parts.push(gradeFilter);
-  return parts.join(",");
-}
-function segmentExtractArgs(source, segStart, duration, gradeFilter, outPath, opts = {}) {
-  const vf = segmentVf(gradeFilter, opts);
-  const af = afadeFilter(duration);
-  const { preset, crf } = modePresetCrf(opts);
-  return [
-    "ffmpeg",
-    "-y",
-    "-ss",
-    f3(segStart),
-    "-i",
-    source,
-    // -t is truncated, never rounded: a frame-grid duration like 20/30 rounds
-    // to "0.667", which lies past frame 20's timestamp, so a rounded -t leaks
-    // one extra video frame while audio stops at -t exactly — and that
-    // one-frame surplus compounds across segments into audible A/V drift.
-    // (Capping video with -frames:v instead is worse: once the video stream
-    // completes, ffmpeg stops consuming input and truncates the audio at the
-    // demuxer's interleave point, 5-20ms short.)
-    "-t",
-    f6floor(duration),
-    "-vf",
-    vf,
-    "-af",
-    af,
-    "-c:v",
-    "libx264",
-    "-preset",
-    preset,
-    "-crf",
-    crf,
-    "-pix_fmt",
-    "yuv420p",
-    "-r",
-    opts.fps ?? "24",
-    // PCM audio in the intermediates (segments are .mov): sample-exact -t cuts
-    // with no AAC frame quantization, priming, or flush loss — per-segment AAC
-    // encoding leaves each segment's audio up to one AAC frame (21ms) short,
-    // which the -c copy concat compounds into audible A/V drift. The loudnorm
-    // stage performs the single AAC encode for the whole timeline.
-    "-c:a",
-    "pcm_s16le",
-    "-ar",
-    "48000",
-    "-movflags",
-    "+faststart",
-    outPath
-  ];
-}
-function concatListContent(segmentPaths) {
-  return segmentPaths.map((p) => `file '${p}'
-`).join("");
-}
-function concatArgs(concatListPath, outPath) {
-  return [
-    "ffmpeg",
-    "-y",
-    "-f",
-    "concat",
-    "-safe",
-    "0",
-    "-i",
-    concatListPath,
-    "-c",
-    "copy",
-    "-movflags",
-    "+faststart",
-    outPath
-  ];
-}
-function loudnormPass1Args(inputPath) {
-  const filterStr = `loudnorm=I=${LOUDNORM_I_STR}:TP=${LOUDNORM_TP_STR}:LRA=${LOUDNORM_LRA_STR}:print_format=json`;
-  return [
-    "ffmpeg",
-    "-y",
-    "-hide_banner",
-    "-nostats",
-    "-i",
-    inputPath,
-    "-af",
-    filterStr,
-    "-vn",
-    "-f",
-    "null",
-    "-"
-  ];
-}
-function loudnormPass2Filter(measured) {
-  return `loudnorm=I=${LOUDNORM_I_STR}:TP=${LOUDNORM_TP_STR}:LRA=${LOUDNORM_LRA_STR}:measured_I=${measured.input_i}:measured_TP=${measured.input_tp}:measured_LRA=${measured.input_lra}:measured_thresh=${measured.input_thresh}:offset=${measured.target_offset}:linear=true`;
-}
-function loudnormOnePassFilter() {
-  return `loudnorm=I=${LOUDNORM_I_STR}:TP=${LOUDNORM_TP_STR}:LRA=${LOUDNORM_LRA_STR}`;
-}
-function loudnormApplyArgs(inputPath, outputPath, filterStr) {
-  return [
-    "ffmpeg",
-    "-y",
-    "-hide_banner",
-    "-nostats",
-    "-i",
-    inputPath,
-    "-c:v",
-    "copy",
-    "-af",
-    filterStr,
-    "-c:a",
-    "aac",
-    "-b:a",
-    "192k",
-    "-ar",
-    "48000",
-    "-movflags",
-    "+faststart",
-    outputPath
-  ];
-}
-function parseLoudnessJson(stderr) {
-  const start = stderr.lastIndexOf("{");
-  const end = stderr.lastIndexOf("}");
-  if (start === -1 || end === -1 || end <= start) return null;
-  let data;
-  try {
-    data = JSON.parse(stderr.slice(start, end + 1));
-  } catch {
-    return null;
-  }
-  const needed = ["input_i", "input_tp", "input_lra", "input_thresh", "target_offset"];
-  for (const k of needed) {
-    if (!(k in data)) return null;
-  }
-  return data;
-}
-function subtitleFilter(srtPath) {
-  const subsAbs = srtPath.replace(/:/g, "\\:").replace(/'/g, "\\'");
-  return `subtitles='${subsAbs}':force_style='${SUB_FORCE_STYLE}'`;
-}
-function srtTimestamp(seconds) {
-  const totalMs = pyRound(seconds * 1e3, 0);
-  let rem = totalMs;
-  const h = Math.floor(rem / 36e5);
-  rem = rem % 36e5;
-  const m = Math.floor(rem / 6e4);
-  rem = rem % 6e4;
-  const s = Math.floor(rem / 1e3);
-  const ms = rem % 1e3;
-  const pad = (n, w) => String(n).padStart(w, "0");
-  return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)},${pad(ms, 3)}`;
-}
-function wordsInRange(transcript, tStart, tEnd) {
-  const out = [];
-  for (const w of transcript.words ?? []) {
-    if (w.type !== "word") continue;
-    const ws = w.start;
-    const we = w.end;
-    if (ws === null || ws === void 0 || we === null || we === void 0) continue;
-    if (we <= tStart || ws >= tEnd) continue;
-    out.push(w);
-  }
-  return out;
-}
-function buildSrt(ranges, transcripts) {
-  const entries = [];
-  let segOffset = 0;
-  for (const r of ranges) {
-    const srcName = r.source;
-    const segStart = Number(r.start);
-    const segEnd = Number(r.end);
-    const segDuration = segEnd - segStart;
-    const transcript = transcripts[srcName];
-    if (!transcript) {
-      segOffset += segDuration;
-      continue;
-    }
-    const wordsInSeg = wordsInRange(transcript, segStart, segEnd);
-    const chunks = [];
-    let current = [];
-    for (const w of wordsInSeg) {
-      const text = (w.text ?? "").trim();
-      if (!text) continue;
-      current.push(w);
-      const endsInPunct = text.length > 0 && PUNCT_BREAK.has(text[text.length - 1]);
-      if (current.length >= 2 || endsInPunct) {
-        chunks.push(current);
-        current = [];
-      }
-    }
-    if (current.length > 0) chunks.push(current);
-    for (const chunk of chunks) {
-      const first = chunk[0];
-      const last = chunk[chunk.length - 1];
-      const firstStart = first.start ?? segStart;
-      const lastEnd = last.end ?? segEnd;
-      const localStart = Math.max(segStart, firstStart);
-      const localEnd = Math.min(segEnd, lastEnd);
-      const outStart = Math.max(0, localStart - segStart) + segOffset;
-      let outEnd = Math.max(0, localEnd - segStart) + segOffset;
-      if (outEnd <= outStart) outEnd = outStart + 0.4;
-      let text = chunk.map((w) => (w.text ?? "").trim()).join(" ");
-      text = text.replace(/\s+/g, " ").trim();
-      text = text.replace(/[,;:]+$/, "");
-      text = text.toUpperCase();
-      entries.push([outStart, outEnd, text]);
-    }
-    segOffset += segDuration;
-  }
-  const indexed = entries.map((e, i) => ({ e, i }));
-  indexed.sort((a, b) => a.e[0] - b.e[0] || a.i - b.i);
-  const sorted = indexed.map((x) => x.e);
-  const lines = [];
-  let n = 0;
-  for (const [a, b, t] of sorted) {
-    n += 1;
-    lines.push(String(n));
-    lines.push(`${srtTimestamp(a)} --> ${srtTimestamp(b)}`);
-    lines.push(t);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function compositeFilterComplex(overlays, subtitlesPath) {
-  const hasOverlays = overlays.length > 0;
-  const hasSubs = subtitlesPath !== null;
-  const filterParts = [];
-  for (let i = 0; i < overlays.length; i++) {
-    const idx = i + 1;
-    const t = Number(overlays[i].start_in_output);
-    filterParts.push(`[${idx}:v]setpts=PTS-STARTPTS+${pyFloatStr(t)}/TB[a${idx}]`);
-  }
-  let current = "[0:v]";
-  for (let i = 0; i < overlays.length; i++) {
-    const idx = i + 1;
-    const t = Number(overlays[i].start_in_output);
-    const dur2 = Number(overlays[i].duration);
-    const end = t + dur2;
-    const nextLabel = `[v${idx}]`;
-    filterParts.push(`${current}[a${idx}]overlay=enable='between(t,${f3(t)},${f3(end)})'${nextLabel}`);
-    current = nextLabel;
-  }
-  let outLabel;
-  if (hasSubs) {
-    filterParts.push(`${current}${subtitleFilter(subtitlesPath)}[outv]`);
-    outLabel = "[outv]";
-  } else if (hasOverlays) {
-    filterParts.push(`${current}null[outv]`);
-    outLabel = "[outv]";
-  } else {
-    outLabel = "[0:v]";
-  }
-  return {
-    filterComplex: filterParts.join(";"),
-    outLabel,
-    hasOverlays,
-    hasSubs
-  };
-}
-function compositeArgs(basePath, overlayPaths, filterComplex, outLabel, outPath) {
-  const inputs = ["-i", basePath];
-  for (const p of overlayPaths) inputs.push("-i", p);
-  return [
-    "ffmpeg",
-    "-y",
-    ...inputs,
-    "-filter_complex",
-    filterComplex,
-    "-map",
-    outLabel,
-    "-map",
-    "0:a",
-    "-c:v",
-    "libx264",
-    "-preset",
-    "fast",
-    "-crf",
-    "18",
-    "-pix_fmt",
-    "yuv420p",
-    "-c:a",
-    "copy",
-    "-movflags",
-    "+faststart",
-    outPath
-  ];
-}
-async function isHdrSource(video) {
-  try {
-    const res = await run(
-      [
-        "ffprobe",
-        "-v",
-        "error",
-        "-select_streams",
-        "v:0",
-        "-show_entries",
-        "stream=color_transfer",
-        "-of",
-        "default=noprint_wrappers=1:nokey=1",
-        video
-      ],
-      { capture: true, check: true, echo: false }
-    );
-    return HDR_TRANSFERS.has(res.stdout.trim());
-  } catch {
-    return false;
-  }
-}
-async function isPortraitSource(video) {
-  try {
-    const res = await run(
-      [
-        "ffprobe",
-        "-v",
-        "error",
-        "-select_streams",
-        "v:0",
-        "-show_entries",
-        "stream=width,height",
-        "-of",
-        "csv=p=0",
-        video
-      ],
-      { capture: true, check: true, echo: false }
-    );
-    const parts = res.stdout.trim().split(",");
-    const w = parseInt(parts[0] ?? "", 10);
-    const h = parseInt(parts[1] ?? "", 10);
-    if (!Number.isFinite(w) || !Number.isFinite(h)) return false;
-    return h > w;
-  } catch {
-    return false;
-  }
-}
-function parseFrameRate(rate) {
-  const m = rate.match(/^(\d+)\/(\d+)$/);
-  if (m) {
-    const num2 = Number(m[1]);
-    const den = Number(m[2]);
-    return num2 > 0 && den > 0 ? num2 / den : null;
-  }
-  const v = Number(rate);
-  return Number.isFinite(v) && v > 0 ? v : null;
-}
-async function sourceFrameRate(video) {
-  try {
-    const res = await run(
-      [
-        "ffprobe",
-        "-v",
-        "error",
-        "-select_streams",
-        "v:0",
-        "-show_entries",
-        "stream=r_frame_rate",
-        "-of",
-        "default=noprint_wrappers=1:nokey=1",
-        video
-      ],
-      { capture: true, check: true, echo: false }
-    );
-    const rate = res.stdout.trim().split("\n")[0]?.trim() ?? "";
-    return parseFrameRate(rate) !== null ? rate : null;
-  } catch {
-    return null;
-  }
-}
-async function extractSegment(source, segStart, duration, gradeFilter, outPath, preview, draft, fps) {
-  mkdirSync2(dirname(outPath), { recursive: true });
-  const portrait = await isPortraitSource(source);
-  const hdr = await isHdrSource(source);
-  const args = segmentExtractArgs(source, segStart, duration, gradeFilter, outPath, {
-    preview,
-    draft,
-    portrait,
-    hdr,
-    fps: fps ?? void 0
-  });
-  await run(args, { capture: true });
-}
-async function extractAllSegments(edl, editDir, preview, draft) {
-  const resolved = resolveGradeFilter(edl.grade);
-  const isAuto = resolved === "__AUTO__";
-  const clipsName = draft ? "clips_draft" : preview ? "clips_preview" : "clips_graded";
-  const clipsDir = resolve(editDir, clipsName);
-  mkdirSync2(clipsDir, { recursive: true });
-  const ranges = edl.ranges;
-  const sources = edl.sources;
-  const segPaths = [];
-  const fpsBySource = {};
-  process.stderr.write(`extracting ${ranges.length} segment(s) -> ${clipsName}/
-`);
-  for (let i = 0; i < ranges.length; i++) {
-    const r = ranges[i];
-    const srcName = r.source;
-    const srcPath = resolvePath(sources[srcName], editDir);
-    if (!(srcName in fpsBySource)) fpsBySource[srcName] = await sourceFrameRate(srcPath);
-    const fpsRate = fpsBySource[srcName];
-    const fps = fpsRate !== null ? parseFrameRate(fpsRate) : null;
-    let start = Number(r.start);
-    let end = Number(r.end);
-    if (fps !== null) {
-      start = Math.round(start * fps) / fps;
-      end = Math.max(start + 1 / fps, Math.round(end * fps) / fps);
-    }
-    const duration = end - start;
-    const ii = String(i).padStart(2, "0");
-    const outPath = resolve(clipsDir, `seg_${ii}_${srcName}.mov`);
-    let segFilter;
-    if (isAuto) {
-      segFilter = await autoGradeForClip(srcPath);
-    } else {
-      segFilter = resolved;
-    }
-    await extractSegment(srcPath, start, duration, segFilter, outPath, preview, draft, fpsRate);
-    segPaths.push(outPath);
-  }
-  return segPaths;
-}
-async function concatSegments(segmentPaths, outPath, editDir) {
-  mkdirSync2(dirname(outPath), { recursive: true });
-  const concatList = resolve(editDir, "_concat.txt");
-  writeFileSync4(concatList, concatListContent(segmentPaths.map((p) => resolve(p))));
-  await run(concatArgs(concatList, outPath), { capture: true });
-  rmSync3(concatList, { force: true });
-  await warnOnAvDrift(outPath);
-}
-async function warnOnAvDrift(path) {
-  try {
-    const res = await run(
-      [
-        "ffprobe",
-        "-v",
-        "error",
-        "-show_entries",
-        "stream=codec_type,duration",
-        "-of",
-        "json",
-        path
-      ],
-      { capture: true, check: true, echo: false }
-    );
-    const streams = JSON.parse(res.stdout).streams ?? [];
-    const v = Number(streams.find((s) => s.codec_type === "video")?.duration);
-    const a = Number(streams.find((s) => s.codec_type === "audio")?.duration);
-    if (!Number.isFinite(v) || !Number.isFinite(a)) return;
-    const driftMs = Math.round((v - a) * 1e3);
-    if (Math.abs(driftMs) > 100) {
-      process.stderr.write(
-        `  WARNING: A/V stream durations differ by ${driftMs}ms after concat (video ${v.toFixed(3)}s, audio ${a.toFixed(3)}s) \u2014 likely audible desync
-`
-      );
-    }
-  } catch {
-  }
-}
-function loadTranscripts(edl, editDir) {
-  const transcriptsDir = resolve(editDir, "transcripts");
-  const out = {};
-  for (const r of edl.ranges) {
-    const srcName = r.source;
-    if (srcName in out) continue;
-    const trPath = resolve(transcriptsDir, `${srcName}.json`);
-    if (!existsSync4(trPath)) {
-      out[srcName] = void 0;
-      continue;
-    }
-    try {
-      out[srcName] = JSON.parse(readFileSync5(trPath, "utf-8"));
-    } catch {
-      out[srcName] = void 0;
-    }
-  }
-  return out;
-}
-async function buildFinalComposite(basePath, overlays, subtitlesPath, outPath, editDir) {
-  const hasOverlays = overlays.length > 0;
-  const hasSubs = subtitlesPath !== null && existsSync4(subtitlesPath);
-  if (!hasOverlays && !hasSubs) {
-    await run(["ffmpeg", "-y", "-i", basePath, "-c", "copy", outPath], { echo: false, capture: true });
-    return;
-  }
-  const overlayPaths = overlays.map((ov) => resolvePath(ov.file, editDir));
-  const { filterComplex, outLabel } = compositeFilterComplex(overlays, hasSubs ? subtitlesPath : null);
-  const args = compositeArgs(basePath, overlayPaths, filterComplex, outLabel, outPath);
-  await run(args, { capture: true });
-}
-async function applyLoudnormTwoPass(inputPath, outputPath, preview) {
-  if (preview) {
-    await run(loudnormApplyArgs(inputPath, outputPath, loudnormOnePassFilter()), { capture: true });
-    return true;
-  }
-  const res = await run(loudnormPass1Args(inputPath), { capture: true, check: false, echo: true });
-  const measurement = parseLoudnessJson(res.stderr);
-  if (measurement === null) {
-    process.stderr.write("  loudnorm measurement failed \u2014 falling back to 1-pass\n");
-    return applyLoudnormTwoPass(inputPath, outputPath, true);
-  }
-  const filterStr = loudnormPass2Filter(measurement);
-  await run(loudnormApplyArgs(inputPath, outputPath, filterStr), { capture: true });
-  return true;
-}
-async function render(edlPath2, output, opts = {}) {
-  const preview = opts.preview ?? false;
-  const draft = opts.draft ?? false;
-  const buildSubtitles = opts.buildSubtitles ?? false;
-  const noSubtitles = opts.noSubtitles ?? false;
-  const noLoudnorm = opts.noLoudnorm ?? false;
-  const resolvedEdlPath = resolve(edlPath2);
-  if (!existsSync4(resolvedEdlPath)) {
-    throw new Error(`edl not found: ${resolvedEdlPath}`);
-  }
-  const edl = JSON.parse(readFileSync5(resolvedEdlPath, "utf-8"));
-  const editDir = dirname(resolvedEdlPath);
-  const outPath = resolve(output);
-  const segmentPaths = await extractAllSegments(edl, editDir, preview, draft);
-  const baseName = draft ? "base_draft.mov" : preview ? "base_preview.mov" : "base.mov";
-  const basePath = resolve(editDir, baseName);
-  await concatSegments(segmentPaths, basePath, editDir);
-  let subsPath = null;
-  if (!noSubtitles) {
-    if (buildSubtitles) {
-      subsPath = resolve(editDir, "master.srt");
-      const transcripts = loadTranscripts(edl, editDir);
-      writeFileSync4(subsPath, buildSrt(edl.ranges, transcripts));
-    } else if (edl.subtitles) {
-      const candidate = resolvePath(edl.subtitles, editDir);
-      if (existsSync4(candidate)) {
-        subsPath = candidate;
-      } else {
-        process.stderr.write(`warning: subtitles path in EDL does not exist: ${candidate}
-`);
-        subsPath = null;
-      }
-    }
-  }
-  const overlays = edl.overlays ?? [];
-  const tmpComposite = outPath.replace(/\.[^./\\]*$/, "") + ".prenorm.mov";
-  await buildFinalComposite(basePath, overlays, subsPath, tmpComposite, editDir);
-  if (noLoudnorm) {
-    await run(
-      [
-        "ffmpeg",
-        "-y",
-        "-i",
-        tmpComposite,
-        "-c:v",
-        "copy",
-        "-c:a",
-        "aac",
-        "-b:a",
-        "192k",
-        "-ar",
-        "48000",
-        "-movflags",
-        "+faststart",
-        outPath
-      ],
-      { capture: true }
-    );
-  } else {
-    await applyLoudnormTwoPass(tmpComposite, outPath, draft);
-  }
-  rmSync3(tmpComposite, { force: true });
-  const sizeMb = statSync2(outPath).size / (1024 * 1024);
-  process.stderr.write(`
-done: ${outPath} (${pyFixed(sizeMb, 1)} MB)
-`);
-}
-
-// src/timeline.ts
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname2, join as join6, basename as basename4 } from "path";
-import { fileURLToPath } from "url";
-import { createCanvas, loadImage, GlobalFonts } from "@napi-rs/canvas";
-var BG = "rgb(18, 18, 22)";
-var FG = "rgb(235, 235, 235)";
-var DIM = "rgb(110, 110, 120)";
-var WAVE = "rgb(140, 180, 255)";
-var WAVE_FILL = "rgba(140, 180, 255, 0.235)";
-var SILENCE = "rgba(50, 80, 120, 0.470)";
-var WAVE_BG = "rgb(28, 28, 34)";
-var FONT_FAMILY = "DejaVuSansMono";
-var fontRegistered = false;
-function ensureFont() {
-  if (fontRegistered) return;
-  fontRegistered = true;
-  try {
-    const fontPath = fileURLToPath(new URL("./assets/DejaVuSansMono.ttf", import.meta.url));
-    GlobalFonts.registerFromPath(fontPath, FONT_FAMILY);
-  } catch {
-  }
-}
-function font(size) {
-  return `${size}px "${FONT_FAMILY}", monospace`;
-}
-async function extractFrames(video, start, end, n, destDir) {
-  await mkdir(destDir, { recursive: true });
-  if (n < 1) n = 1;
-  let times;
-  if (n === 1) {
-    times = [(start + end) / 2];
-  } else {
-    const step = (end - start) / (n - 1);
-    times = Array.from({ length: n }, (_, i) => start + i * step);
-  }
-  const paths = [];
-  for (let i = 0; i < times.length; i++) {
-    const t = times[i];
-    const out = join6(destDir, `f_${String(i).padStart(3, "0")}.jpg`);
-    const cmd = [
-      "ffmpeg",
-      "-y",
-      "-ss",
-      t.toFixed(3),
-      "-i",
-      video,
-      "-frames:v",
-      "1",
-      "-q:v",
-      "4",
-      "-vf",
-      "scale=320:-2",
-      out
-    ];
-    await run(cmd, { capture: true, check: true, echo: false });
-    paths.push(out);
-  }
-  return paths;
-}
-function computeEnvelope(pcm, samples) {
-  const n = pcm.length;
-  if (n === 0 || samples <= 0) {
-    return new Array(Math.max(0, samples)).fill(0);
-  }
-  const window = Math.max(1, Math.floor(n / samples));
-  const usableWindows = Math.floor(n / window);
-  const nWindows = Math.min(usableWindows, samples);
-  const env = new Array(samples).fill(0);
-  let maxVal = 0;
-  for (let w = 0; w < nWindows; w++) {
-    let sumSq = 0;
-    const base = w * window;
-    for (let k = 0; k < window; k++) {
-      const f = pcm[base + k] / 32768;
-      sumSq += f * f;
-    }
-    const rms = Math.sqrt(sumSq / window);
-    env[w] = rms;
-    if (rms > maxVal) maxVal = rms;
-  }
-  if (maxVal > 0) {
-    for (let i = 0; i < samples; i++) env[i] = env[i] / maxVal;
-  }
-  return env;
-}
-async function computeEnvelopeFromVideo(video, start, end, samples) {
-  const tmp = await mkdtemp(join6(tmpdir3(), "tl-wav-"));
-  const wav = join6(tmp, "audio.wav");
-  try {
-    const cmd = [
-      "ffmpeg",
-      "-y",
-      "-ss",
-      start.toFixed(3),
-      "-i",
-      video,
-      "-t",
-      (end - start).toFixed(3),
-      "-vn",
-      "-ac",
-      "1",
-      "-ar",
-      "16000",
-      "-c:a",
-      "pcm_s16le",
-      wav
-    ];
-    const r = await run(cmd, { capture: true, check: false, echo: false });
-    if (r.code !== 0) return new Array(samples).fill(0);
-    let buf;
-    try {
-      buf = await readFile(wav);
-    } catch {
-      return new Array(samples).fill(0);
-    }
-    if (buf.length === 0) return new Array(samples).fill(0);
-    const pcm = parseWavPcmS16le(buf);
-    if (pcm.length === 0) return new Array(samples).fill(0);
-    return computeEnvelope(pcm, samples);
-  } finally {
-    await rm(tmp, { recursive: true, force: true });
-  }
-}
-function parseWavPcmS16le(buf) {
-  if (buf.length < 12 || buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WAVE") {
-    return bytesToInt16(buf, 0, buf.length);
-  }
-  let offset = 12;
-  while (offset + 8 <= buf.length) {
-    const chunkId = buf.toString("ascii", offset, offset + 4);
-    const chunkSize = buf.readUInt32LE(offset + 4);
-    const dataStart = offset + 8;
-    if (chunkId === "data") {
-      const dataEnd = Math.min(dataStart + chunkSize, buf.length);
-      return bytesToInt16(buf, dataStart, dataEnd);
-    }
-    offset = dataStart + chunkSize + chunkSize % 2;
-  }
-  return new Int16Array(0);
-}
-function bytesToInt16(buf, startByte, endByte) {
-  let len = endByte - startByte;
-  if (len < 0) len = 0;
-  const count = Math.floor(len / 2);
-  const out = new Int16Array(count);
-  for (let i = 0; i < count; i++) {
-    out[i] = buf.readInt16LE(startByte + i * 2);
-  }
-  return out;
-}
-function wordsInRange2(transcript, start, end) {
-  const out = [];
-  for (const w of transcript.words ?? []) {
-    const ws = w.start;
-    const we = w.end;
-    if (ws === null || ws === void 0 || we === null || we === void 0) continue;
-    if (we <= start || ws >= end) continue;
-    out.push(w);
-  }
-  return out;
-}
-function findSilences(words, start, end, threshold = 0.4) {
-  const gaps = [];
-  let prevEnd = start;
-  for (const w of words) {
-    if (w.type === "spacing") continue;
-    const wStart = w.start ?? start;
-    const ws = Math.max(start, wStart);
-    if (ws - prevEnd >= threshold) {
-      gaps.push([prevEnd, ws]);
-    }
-    const we = w.end ?? ws;
-    prevEnd = Math.max(prevEnd, we);
-  }
-  if (end - prevEnd >= threshold) {
-    gaps.push([prevEnd, end]);
-  }
-  return gaps;
-}
-async function timelineView(video, start, end, output, opts = {}) {
-  ensureFont();
-  const nFrames = opts.nFrames ?? 10;
-  if (end <= start) {
-    throw new Error("end must be > start");
-  }
-  try {
-    const dur2 = await mediaDuration(video);
-    if (dur2 > 0 && end > dur2) {
-      end = dur2;
-      if (end <= start) {
-        throw new Error("end clamps to <= start (range is past EOF)");
-      }
-    }
-  } catch {
-  }
-  const tmp = await mkdtemp(join6(tmpdir3(), "tl-frames-"));
-  try {
-    process.stderr.write(
-      `extracting ${nFrames} frames from ${start.toFixed(2)}s to ${end.toFixed(2)}s
-`
-    );
-    const framePaths = await extractFrames(video, start, end, nFrames, tmp);
-    const frameH = 180;
-    const filmstripY = 50;
-    const filmstripH = frameH;
-    const waveY = filmstripY + filmstripH + 20;
-    const waveH = 220;
-    const labelY = waveY + waveH + 10;
-    const canvasHeight = labelY + 60;
-    const frames = [];
-    for (const fp of framePaths) {
-      const img = await loadImage(fp);
-      const aspect = img.width / img.height;
-      const newW = Math.trunc(frameH * aspect);
-      frames.push({ img, w: newW });
-    }
-    const totalFrameW = frames.reduce((acc, f) => acc + f.w, 0) + Math.max(0, frames.length - 1) * 4;
-    const contentW = Math.max(1400, totalFrameW);
-    const canvasWidth = Math.max(1920, contentW + 100);
-    const canvas = createCanvas(canvasWidth, canvasHeight);
-    const ctx = canvas.getContext("2d");
-    ctx.fillStyle = BG;
-    ctx.fillRect(0, 0, canvasWidth, canvasHeight);
-    ctx.textBaseline = "top";
-    ctx.textAlign = "left";
-    ctx.fillStyle = FG;
-    ctx.font = font(22);
-    ctx.fillText(
-      `${basename4(video)}   ${start.toFixed(2)}s \u2192 ${end.toFixed(2)}s   (${(end - start).toFixed(2)}s, ${nFrames} frames)`,
-      50,
-      12
-    );
-    const stripWidth = canvasWidth - 100;
-    let drawWidth;
-    if (totalFrameW <= stripWidth) {
-      let cursor = 50;
-      for (const f of frames) {
-        ctx.drawImage(f.img, cursor, filmstripY, f.w, frameH);
-        cursor += f.w + 4;
-      }
-      drawWidth = cursor - 50;
-    } else {
-      const scale = stripWidth / totalFrameW;
-      const newH = Math.trunc(frameH * scale);
-      let cursor = 50;
-      for (const f of frames) {
-        const newW = Math.trunc(f.w * scale);
-        ctx.drawImage(f.img, cursor, filmstripY + Math.trunc((filmstripH - newH) / 2), newW, newH);
-        cursor += newW + Math.max(2, Math.trunc(4 * scale));
-      }
-      drawWidth = cursor - 50;
-    }
-    const stripX0 = 50;
-    const stripX1 = 50 + drawWidth;
-    const stripSpan = stripX1 - stripX0;
-    const timeToX = (t) => {
-      const frac = (t - start) / Math.max(1e-6, end - start);
-      return Math.trunc(stripX0 + frac * stripSpan);
-    };
-    ctx.fillStyle = WAVE_BG;
-    ctx.fillRect(stripX0, waveY, stripX1 - stripX0, waveH);
-    let words = [];
-    if (opts.transcript) {
-      try {
-        const raw = await readFile(opts.transcript, "utf-8");
-        const data = JSON.parse(raw);
-        words = wordsInRange2(data, start, end);
-      } catch {
-        words = [];
-      }
-    }
-    const silences = words.length > 0 ? findSilences(words, start, end, 0.4) : [];
-    ctx.fillStyle = SILENCE;
-    for (const [a, b] of silences) {
-      const xa = timeToX(a);
-      const xb = timeToX(b);
-      ctx.fillRect(xa, waveY, xb - xa, waveH);
-    }
-    const samples = Math.max(stripSpan, 200);
-    const env = await computeEnvelopeFromVideo(video, start, end, samples);
-    const midY = waveY + Math.trunc(waveH / 2);
-    const maxAmp = Math.trunc(waveH / 2) - 8;
-    const pointsTop = [];
-    const pointsBot = [];
-    const denom = Math.max(1, env.length - 1);
-    for (let i = 0; i < env.length; i++) {
-      const v = env[i];
-      const xi = stripX0 + Math.trunc(i * stripSpan / denom);
-      const a = Math.trunc(v * maxAmp);
-      pointsTop.push([xi, midY - a]);
-      pointsBot.push([xi, midY + a]);
-    }
-    if (pointsTop.length > 0) {
-      ctx.fillStyle = WAVE_FILL;
-      ctx.beginPath();
-      ctx.moveTo(pointsTop[0][0], pointsTop[0][1]);
-      for (let i = 1; i < pointsTop.length; i++) ctx.lineTo(pointsTop[i][0], pointsTop[i][1]);
-      for (let i = pointsBot.length - 1; i >= 0; i--) ctx.lineTo(pointsBot[i][0], pointsBot[i][1]);
-      ctx.closePath();
-      ctx.fill();
-      ctx.strokeStyle = WAVE;
-      ctx.lineWidth = 1;
-      ctx.lineJoin = "round";
-      ctx.beginPath();
-      ctx.moveTo(pointsTop[0][0], pointsTop[0][1]);
-      for (let i = 1; i < pointsTop.length; i++) ctx.lineTo(pointsTop[i][0], pointsTop[i][1]);
-      ctx.stroke();
-      ctx.beginPath();
-      ctx.moveTo(pointsBot[0][0], pointsBot[0][1]);
-      for (let i = 1; i < pointsBot.length; i++) ctx.lineTo(pointsBot[i][0], pointsBot[i][1]);
-      ctx.stroke();
-    }
-    ctx.font = font(12);
-    let lastLabelX = -9999;
-    for (const w of words) {
-      if (w.type !== "word") continue;
-      const ws = w.start;
-      const we = w.end;
-      const text = (w.text ?? "").trim();
-      if (!text || ws === null || ws === void 0 || we === null || we === void 0) continue;
-      if (we - ws < 0.05) continue;
-      const cx = Math.trunc((timeToX(ws) + timeToX(we)) / 2);
-      if (cx - lastLabelX < 28) continue;
-      ctx.strokeStyle = DIM;
-      ctx.lineWidth = 1;
-      ctx.beginPath();
-      ctx.moveTo(cx + 0.5, waveY - 4);
-      ctx.lineTo(cx + 0.5, waveY);
-      ctx.stroke();
-      ctx.fillStyle = FG;
-      ctx.fillText(text, cx + 2, waveY - 18);
-      lastLabelX = cx;
-    }
-    const rulerY = waveY + waveH + 2;
-    const nTicks = 6;
-    ctx.font = font(14);
-    for (let i = 0; i <= nTicks; i++) {
-      const frac = i / nTicks;
-      const t = start + frac * (end - start);
-      const xi = stripX0 + Math.trunc(frac * stripSpan);
-      ctx.strokeStyle = DIM;
-      ctx.lineWidth = 1;
-      ctx.beginPath();
-      ctx.moveTo(xi + 0.5, rulerY);
-      ctx.lineTo(xi + 0.5, rulerY + 6);
-      ctx.stroke();
-      ctx.fillStyle = DIM;
-      ctx.fillText(`${t.toFixed(2)}s`, xi - 20, rulerY + 8);
-    }
-    if (silences.length > 0) {
-      const txt = `shaded bands = silences \u2265 400ms (${silences.length} gap(s))`;
-      ctx.font = font(14);
-      ctx.fillStyle = DIM;
-      ctx.fillText(txt, stripX0, labelY + 30);
-    }
-    await mkdir(dirname2(output), { recursive: true });
-    const png = await canvas.encode("png");
-    await writeFile(output, png);
-    try {
-      const s = await stat(output);
-      process.stderr.write(`saved: ${output}  (${Math.trunc(s.size / 1024)} KB)
-`);
-    } catch {
-    }
-  } finally {
-    await rm(tmp, { recursive: true, force: true });
-  }
-}
-
-// src/artifacts.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync as readdirSync2, rmSync as rmSync4, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
-function loadWords(tpath, opts = {}) {
-  const data = JSON.parse(readFileSync6(tpath, "utf8"));
-  const out = [];
-  for (const w of data.words ?? []) {
-    const typ = w.type ?? "word";
-    if (typ === "word" || opts.includeEvents && typ === "audio_event") {
-      if (w.start !== null && w.start !== void 0 && w.end !== null && w.end !== void 0) out.push(w);
-    }
-  }
-  out.sort((a, b) => Number(a.start) - Number(b.start) || Number(a.end) - Number(b.end));
-  return out;
-}
-function writeWordDump(tpath, outPath, gapThreshold = 0.3) {
-  const words = loadWords(tpath, { includeEvents: true });
-  const lines = [];
-  let prevEnd = null;
-  for (const w of words) {
-    const start = Number(w.start);
-    const end = Number(w.end);
-    if (prevEnd !== null && start - prevEnd >= gapThreshold) {
-      lines.push(`---- gap ${(start - prevEnd).toFixed(3)}s ----`);
-    }
-    const typ = w.type ?? "word";
-    const text = (w.text ?? "").trim();
-    lines.push(`[${pyFixedPad(start, 7, 3)}-${pyFixedPad(end, 7, 3)}] ${typ}: ${text}`);
-    prevEnd = end;
-  }
-  writeFileSync5(outPath, lines.join("\n") + "\n", "utf8");
-}
-async function writeCoverage(jobDir, source, tpath) {
-  const words = loadWords(tpath);
-  const lastEnd = words.length ? Number(words[words.length - 1].end) : 0;
-  const sourceDuration = await mediaDuration(source);
-  const path = join7(jobDir, "coverage.json");
-  writeFileSync5(
-    path,
-    JSON.stringify(
-      {
-        source_duration_s: pyRound(sourceDuration, 3),
-        last_word_end_s: pyRound(lastEnd, 3),
-        coverage_gap_s: pyRound(sourceDuration - lastEnd, 3),
-        word_count: words.length
-      },
-      null,
-      2
-    ) + "\n",
-    "utf8"
-  );
-  return path;
-}
-async function writeTranscriptArtifacts(jobDir, source, tpath) {
-  packTranscripts(jobDir);
-  writeFileSync5(join7(jobDir, "flags.txt"), screenTakes(tpath), "utf8");
-  writeWordDump(tpath, join7(jobDir, "word_dump.txt"));
-  await writeCoverage(jobDir, source, tpath);
-}
-async function ensureTranscribed(jobDir, source, stem, opts = {}) {
-  const tpath = transcriptPath(jobDir, stem);
-  if (opts.force && existsSync5(tpath)) unlinkSync(tpath);
-  if (!existsSync5(tpath)) {
-    await transcribeOne(source, {
-      editDir: jobDir,
-      language: opts.language,
-      numSpeakers: opts.numSpeakers,
-      noHeal: opts.noHeal,
-      force: opts.force,
-      apiKey: opts.apiKey
-    });
-  }
-  await writeTranscriptArtifacts(jobDir, source, tpath);
-  return tpath;
-}
-function edlPath(jobDir) {
-  return join7(jobDir, "edl.json");
-}
-function readEdl(jobDir) {
-  const path = edlPath(jobDir);
-  if (!existsSync5(path)) return null;
-  return JSON.parse(readFileSync6(path, "utf8"));
-}
-function cutBoundaries(ranges) {
-  const boundaries = [];
-  let outputTime = 0;
-  for (let idx = 0; idx < ranges.length - 1; idx++) {
-    const current = ranges[idx];
-    const nxt = ranges[idx + 1];
-    outputTime += Number(current.end) - Number(current.start);
-    const removed = Math.max(0, Number(nxt.start) - Number(current.end));
-    boundaries.push({
-      index: idx,
-      output_time_s: pyRound(outputTime, 3),
-      removed_source_gap_s: pyRound(removed, 3),
-      source_before: Number(current.end),
-      source_after: Number(nxt.start)
-    });
-  }
-  return boundaries;
-}
-function writeBoundaries(jobDir) {
-  const edl = readEdl(jobDir);
-  if (!edl) return null;
-  const path = join7(jobDir, "cut_boundaries.json");
-  writeFileSync5(path, JSON.stringify(cutBoundaries(edl.ranges ?? []), null, 2) + "\n", "utf8");
-  return path;
-}
-async function timelinePng(video, start, end, output, transcript) {
-  if (end <= start) return false;
-  try {
-    await timelineView(video, start, end, output, transcript ? { transcript } : {});
-    return true;
-  } catch {
-    process.stderr.write(`warning: timeline_view failed for ${output}
-`);
-    return false;
-  }
-}
-async function generateQcImages(jobDir, opts = {}) {
-  const maxImages = opts.maxImages ?? 24;
-  const edl = readEdl(jobDir);
-  if (!edl) return null;
-  const preview = opts.preview ?? join7(jobDir, "preview.mp4");
-  if (!existsSync5(preview)) return null;
-  const qc = join7(jobDir, "qc");
-  mkdirSync3(qc, { recursive: true });
-  for (const f of readdirSync2(qc)) {
-    if (f.endsWith(".png")) rmSync4(join7(qc, f));
-  }
-  const previewDuration = await mediaDuration(preview);
-  if (previewDuration > 0.5) {
-    const openingEnd = Math.min(previewDuration - 0.2, 3);
-    if (openingEnd > 0.2) await timelinePng(preview, 0, openingEnd, join7(qc, "preview_opening.png"));
-    const outroStart = Math.max(0, previewDuration - 3);
-    const outroEnd = Math.max(0.05, previewDuration - 0.2);
-    if (outroEnd > outroStart) await timelinePng(preview, outroStart, outroEnd, join7(qc, "preview_outro.png"));
-  }
-  const boundaries = cutBoundaries(edl.ranges ?? []);
-  writeBoundaries(jobDir);
-  const ranked = [...boundaries].sort((a, b) => b.removed_source_gap_s - a.removed_source_gap_s);
-  let idx = 1;
-  for (const boundary of ranked.slice(0, maxImages)) {
-    const center = boundary.output_time_s;
-    const start = Math.max(0, center - 1.25);
-    const end = Math.min(Math.max(0.05, previewDuration - 0.2), center + 1.25);
-    await timelinePng(preview, start, end, join7(qc, `preview_join_${String(idx).padStart(2, "0")}.png`));
-    idx++;
-  }
-  return qc;
-}
-function parseTimeFromText(text) {
-  const m = text.match(/(?<!\d)(\d{1,3}(?:\.\d+)?)(?:\s*s|\b)/);
-  if (m) {
-    const v = Number(m[1]);
-    if (Number.isFinite(v)) return v;
-  }
-  const mmss = text.match(/(\d{1,2}):(\d{2})(?:\.(\d+))?/);
-  if (mmss) {
-    const minutes = Number(mmss[1]);
-    const seconds = Number(mmss[2]);
-    const frac = mmss[3] ? Number("0." + mmss[3]) : 0;
-    return minutes * 60 + seconds + frac;
-  }
-  return null;
-}
-function outputTimeForIssue(edl, issue) {
-  const ranges = edl.ranges ?? [];
-  let index = issue.range_index;
-  if (typeof index === "number" && !Number.isInteger(index)) index = Math.trunc(index);
-  if (typeof index !== "number" || index < 0 || index >= ranges.length) return 0;
-  const prior = ranges.slice(0, index).reduce((acc, r) => acc + (Number(r.end) - Number(r.start)), 0);
-  const sourceT = parseTimeFromText(String(issue.where ?? ""));
-  if (sourceT === null) return prior;
-  const start = Number(ranges[index].start);
-  const end = Number(ranges[index].end);
-  if (start <= sourceT && sourceT <= end) return prior + (sourceT - start);
-  return prior;
-}
-function writeWarningsFromReview(jobDir) {
-  const reviewPath = join7(jobDir, "review.json");
-  const edl = readEdl(jobDir) ?? { ranges: [] };
-  const warnings = [];
-  if (existsSync5(reviewPath)) {
-    const review = JSON.parse(readFileSync6(reviewPath, "utf8"));
-    (review.issues ?? []).forEach((issue, i) => {
-      warnings.push({
-        id: `w${i + 1}`,
-        severity: issue.severity ?? "warning",
-        output_time_s: pyRound(outputTimeForIssue(edl, issue), 2),
-        range_index: issue.range_index,
-        problem: issue.problem ?? "",
-        fix: issue.fix ?? ""
-      });
-    });
-  }
-  const path = join7(jobDir, "warnings.json");
-  writeFileSync5(path, JSON.stringify(warnings, null, 2) + "\n", "utf8");
-  return path;
-}
-function artifactPaths(jobDir, stem) {
-  return {
-    source_json: join7(jobDir, "source.json"),
-    vertical_src: join7(jobDir, "vertical_src.mp4"),
-    transcript: transcriptPath(jobDir, stem),
-    takes_packed: join7(jobDir, "takes_packed.md"),
-    flags: join7(jobDir, "flags.txt"),
-    word_dump: join7(jobDir, "word_dump.txt"),
-    coverage: join7(jobDir, "coverage.json"),
-    edl: join7(jobDir, "edl.json"),
-    preview: join7(jobDir, "preview.mp4"),
-    review: join7(jobDir, "review.json"),
-    verify: join7(jobDir, "verify.json"),
-    warnings: join7(jobDir, "warnings.json"),
-    qc_dir: join7(jobDir, "qc"),
-    author_prompt: join7(jobDir, "prompts", "author-edl.prompt.md"),
-    review_prompt: join7(jobDir, "prompts", "review.prompt.md"),
-    fix_prompt: join7(jobDir, "prompts", "fix.prompt.md")
-  };
-}
-function writeAgentManifest(jobDir, source, stem, mode) {
-  const manifest = {
-    mode,
-    job_dir: jobDir,
-    source,
-    artifacts: artifactPaths(jobDir, stem),
-    agent_contract: {
-      no_internal_agent_execution: true,
-      cli_only: "use only the `video-editing` CLI; never run video-use helpers or ffmpeg directly",
-      edl_author: "external agent writes edl.json from prompts and artifacts",
-      render: "video-editing render --job-dir <job> --mode preview|draft|final",
-      verify: "video-editing verify --job-dir <job> --json",
-      inspect: "video-editing inspect --job-dir <job> --join <i>"
-    }
-  };
-  const path = join7(jobDir, "agent_manifest.json");
-  writeFileSync5(path, JSON.stringify(manifest, null, 2) + "\n", "utf8");
-  return path;
-}
-async function statusPayload(jobDir) {
-  const { loadJob } = await import("./job-OFCSLPBV.js");
-  const job = loadJob(jobDir);
-  const stem = job.stem;
-  const previewPath = join7(jobDir, "preview.mp4");
-  const payload = {
-    job_dir: jobDir,
-    source: job.source,
-    source_duration_s: job.duration_s,
-    artifacts: artifactPaths(jobDir, stem)
-  };
-  const tpath = transcriptPath(jobDir, stem);
-  if (existsSync5(tpath)) {
-    const words = loadWords(tpath);
-    const lastEnd = words.length ? Number(words[words.length - 1].end) : 0;
-    payload.transcript = {
-      word_count: words.length,
-      last_word_end_s: pyRound(lastEnd, 3),
-      coverage_gap_s: pyRound((Number(job.duration_s) || 0) - lastEnd, 3)
-    };
-  }
-  const edl = readEdl(jobDir);
-  if (edl) {
-    payload.edl = {
-      range_count: (edl.ranges ?? []).length,
-      total_duration_s: edl.total_duration_s,
-      grade: edl.grade
-    };
-  }
-  if (existsSync5(previewPath)) {
-    const probe = await ffprobe(previewPath);
-    const stream = videoStream(probe);
-    payload.preview = {
-      duration_s: Number(probe.format?.duration ?? 0) || 0,
-      width: Math.trunc(Number(stream.width ?? 0)) || 0,
-      height: Math.trunc(Number(stream.height ?? 0)) || 0
-    };
-  }
-  const reviewPath = join7(jobDir, "review.json");
-  if (existsSync5(reviewPath)) {
-    const review = JSON.parse(readFileSync6(reviewPath, "utf8"));
-    payload.review = { verdict: review.verdict, issue_count: (review.issues ?? []).length };
-  }
-  const verifyPath = join7(jobDir, "verify.json");
-  if (existsSync5(verifyPath)) {
-    const verify2 = JSON.parse(readFileSync6(verifyPath, "utf8"));
-    payload.verify = { verdict: verify2.verdict, finding_count: (verify2.joins ?? []).length };
-  }
-  let qcCount = 0;
-  const qcDir = join7(jobDir, "qc");
-  if (existsSync5(qcDir)) qcCount = readdirSync2(qcDir).filter((f) => f.endsWith(".png")).length;
-  payload.qc_png_count = qcCount;
-  return payload;
-}
-
-// src/verify.ts
-import { existsSync as existsSync6, mkdtempSync as mkdtempSync3, readFileSync as readFileSync7, rmSync as rmSync5 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join8, parse as parsePath } from "path";
-async function transcribeWindow(preview, startS, lengthS, apiKey) {
-  const work = mkdtempSync3(join8(tmpdir4(), "ve-verify-"));
-  try {
-    const wav = join8(work, "win.wav");
-    await run(
-      [
-        "ffmpeg",
-        "-y",
-        "-ss",
-        startS.toFixed(3),
-        "-i",
-        preview,
-        "-t",
-        lengthS.toFixed(3),
-        "-vn",
-        "-ac",
-        "1",
-        "-ar",
-        "16000",
-        "-c:a",
-        "pcm_s16le",
-        wav
-      ],
-      { echo: false }
-    );
-    await transcribeOne(wav, { editDir: work, noHeal: true, apiKey });
-    const tpath = join8(work, "transcripts", `${parsePath(wav).name}.json`);
-    if (!existsSync6(tpath)) return [];
-    const data = JSON.parse(readFileSync7(tpath, "utf8"));
-    const out = [];
-    for (const w of data.words ?? []) {
-      if ((w.type ?? "word") !== "word") continue;
-      if (w.start === null || w.start === void 0 || w.end === null || w.end === void 0) continue;
-      const text = (w.text ?? "").trim();
-      const norm2 = anchorNorm(text);
-      if (!norm2) continue;
-      out.push({ text, norm: norm2, start: Number(w.start), end: Number(w.end) });
-    }
-    return out;
-  } finally {
-    rmSync5(work, { recursive: true, force: true });
-  }
-}
-var ADJACENCY_SLACK = 3;
-function duplicatedSpans(words) {
-  const out = [];
-  let i = 0;
-  while (i < words.length) {
-    let matched = false;
-    for (let n = 4; n >= 2 && !matched; n--) {
-      if (i + n > words.length) continue;
-      const gramA = words.slice(i, i + n).map((w) => w.norm).join(" ");
-      for (let off = n; off <= n + ADJACENCY_SLACK; off++) {
-        const j = i + off;
-        if (j + n > words.length) break;
-        const gramB = words.slice(j, j + n).map((w) => w.norm).join(" ");
-        if (gramA === gramB) {
-          out.push({ text: words.slice(i, j + n).map((w) => w.text).join(" "), n });
-          i = j + n;
-          matched = true;
-          break;
-        }
-      }
-    }
-    if (!matched) i++;
-  }
-  return out;
-}
-function duplicatedPhrases(words) {
-  return duplicatedSpans(words).map((d) => d.text);
-}
-function duplicatedPhrase(words) {
-  return duplicatedPhrases(words)[0] ?? null;
-}
-function dupSeverity(span) {
-  return span.n >= 3 ? "error" : "warning";
-}
-function straddlingGap(words, joinOffset) {
-  let worst = 0;
-  for (let i = 0; i < words.length - 1; i++) {
-    const a = words[i];
-    const b = words[i + 1];
-    const gap = b.start - a.end;
-    if (gap <= 0) continue;
-    if (a.end <= joinOffset && joinOffset <= b.start) worst = Math.max(worst, gap);
-  }
-  return worst;
-}
-async function verify(jobDir, opts = {}) {
-  const windowS = opts.windowS ?? 6;
-  const gapThreshold = opts.gapThresholdS ?? 0.6;
-  const preview = join8(jobDir, "preview.mp4");
-  if (!existsSync6(preview)) throw new Error(`preview not found (render first): ${preview}`);
-  const edl = readEdl(jobDir);
-  if (!edl) throw new Error(`edl.json not found in ${jobDir}`);
-  const previewDur = await mediaDuration(preview);
-  const findings = [];
-  if (opts.full) {
-    const words = await transcribeWindow(preview, 0, previewDur, opts.apiKey);
-    for (const span of duplicatedSpans(words)) {
-      const severity = dupSeverity(span);
-      const note = severity === "warning" ? " (2-word repeat \u2014 adjudicate: spelled acronym/number/emphasis vs retake)" : "";
-      findings.push({ index: -1, output_time_s: 0, duplicated_phrase: span.text, severity, detail: `duplicated phrase in preview: "${span.text}"${note}` });
-    }
-    if (words.length) {
-      const head = words[0].start;
-      if (head > gapThreshold) {
-        findings.push({ index: -1, output_time_s: 0, gap_s: head, severity: "warning", detail: `leading dead air ${head.toFixed(2)}s before first word` });
-      }
-      const tail = previewDur - words[words.length - 1].end;
-      if (tail > gapThreshold) {
-        findings.push({ index: -1, output_time_s: previewDur, gap_s: tail, severity: "warning", detail: `trailing dead air ${tail.toFixed(2)}s after last word` });
-      }
-    }
-    const verdict2 = findings.some((f) => f.severity === "error") ? "needs-fixes" : "clean";
-    return { verdict: verdict2, mode: "full", joins: findings, confidence: `re-transcribed full preview (${previewDur.toFixed(1)}s)` };
-  }
-  const boundaries = cutBoundaries(edl.ranges ?? []);
-  for (const b of boundaries) {
-    const center = b.output_time_s;
-    const winStart = Math.max(0, center - windowS / 2);
-    const winLen = Math.min(windowS, previewDur - winStart);
-    if (winLen < 1) continue;
-    const words = await transcribeWindow(preview, winStart, winLen, opts.apiKey);
-    const joinOffset = center - winStart;
-    for (const span of duplicatedSpans(words)) {
-      const severity = dupSeverity(span);
-      const detail = severity === "error" ? `duplicated phrase across join ${b.index}: "${span.text}" (likely a retake left in)` : `2-word repeat near join ${b.index}: "${span.text}" (adjudicate: spelled acronym/number/emphasis vs retake)`;
-      findings.push({ index: b.index, output_time_s: center, duplicated_phrase: span.text, severity, detail });
-    }
-    const gap = straddlingGap(words, joinOffset);
-    if (gap > gapThreshold) {
-      const sev = gap > gapThreshold * 2 ? "error" : "warning";
-      findings.push({ index: b.index, output_time_s: center, gap_s: gap, severity: sev, detail: `dead air ${gap.toFixed(2)}s at join ${b.index} (not tightened)` });
-    }
-  }
-  const verdict = findings.some((f) => f.severity === "error") ? "needs-fixes" : "clean";
-  return {
-    verdict,
-    mode: "joins",
-    joins: findings,
-    confidence: `re-transcribed ${boundaries.length} join window(s) @ ${windowS}s, heal off`
-  };
-}
-
-// src/silence.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, readdirSync as readdirSync3 } from "fs";
-import { join as join9, resolve as resolve2 } from "path";
-var INTRA_WORD_TOL = 0.06;
-function isIntraWord(a, b, words) {
-  for (const w of words) {
-    if (w.start < a - INTRA_WORD_TOL && w.end > b + INTRA_WORD_TOL) return true;
-  }
-  return false;
-}
-var DEFAULT_DESILENCE = {
-  noiseDb: -36,
-  minSilence: 0.14,
-  targetGap: 0.09,
-  leadKeep: 0.04,
-  trailKeep: 0.05,
-  minSegment: 0.1
-};
-var EPS = 1e-3;
-function f32(x) {
-  return pyFixed(x, 3);
-}
-function silenceDetectArgs(source, noiseDb, minSilenceS) {
-  return [
-    "ffmpeg",
-    "-hide_banner",
-    "-nostats",
-    "-i",
-    source,
-    "-af",
-    `silencedetect=noise=${noiseDb}dB:d=${f32(minSilenceS)}`,
-    "-vn",
-    "-f",
-    "null",
-    "-"
-  ];
-}
-function parseSilenceDetect(stderr, sourceDurationS = 0) {
-  const intervals = [];
-  let pendingStart = null;
-  for (const line of stderr.split(/\r?\n/)) {
-    const mStart = line.match(/silence_start:\s*(-?[0-9]+(?:\.[0-9]+)?)/);
-    if (mStart) {
-      pendingStart = Number(mStart[1]);
-      continue;
-    }
-    const mEnd = line.match(/silence_end:\s*(-?[0-9]+(?:\.[0-9]+)?)/);
-    if (mEnd && pendingStart !== null) {
-      const end = Number(mEnd[1]);
-      if (end > pendingStart) intervals.push({ start: pendingStart, end });
-      pendingStart = null;
-    }
-  }
-  if (pendingStart !== null && sourceDurationS > pendingStart) {
-    intervals.push({ start: pendingStart, end: sourceDurationS });
-  }
-  return intervals;
-}
-function appendNote(reason, note) {
-  return reason && reason.length > 0 ? `${reason} [${note}]` : `[${note}]`;
-}
-function tightenRange(range, silences, opts = DEFAULT_DESILENCE, words = []) {
-  const s = Number(range.start);
-  const e = Number(range.end);
-  if (!(e > s)) return [{ ...range }];
-  const clipped = silences.map((sil) => {
-    const a = Math.max(sil.start, s);
-    const b = Math.min(sil.end, e);
-    return { a, b, touchesStart: sil.start <= s + EPS, touchesEnd: sil.end >= e - EPS };
-  }).filter((c) => c.b - c.a >= opts.minSilence - EPS).sort((x, y) => x.a - y.a);
-  if (clipped.length === 0) return [{ ...range }];
-  const segs = [];
-  let segStart = s;
-  let i = 0;
-  while (i < clipped.length && clipped[i].touchesStart && clipped[i].a <= segStart + EPS) {
-    segStart = Math.min(clipped[i].b - opts.leadKeep, e);
-    i++;
-  }
-  let open = true;
-  for (; i < clipped.length; i++) {
-    const sil = clipped[i];
-    if (!sil.touchesEnd && isIntraWord(sil.a, sil.b, words)) continue;
-    const segEnd = Math.min(sil.a + opts.trailKeep, e);
-    if (segEnd - segStart >= opts.minSegment) segs.push([segStart, segEnd]);
-    if (sil.touchesEnd) {
-      open = false;
-      break;
-    }
-    segStart = Math.max(sil.b - opts.leadKeep, sil.a);
-  }
-  if (open && e - segStart >= opts.minSegment) segs.push([segStart, e]);
-  if (segs.length === 0) return [{ ...range }];
-  return segs.map(([a, b], idx) => ({
-    ...range,
-    start: pyRound(a, 3),
-    end: pyRound(b, 3),
-    reason: appendNote(range.reason, idx === 0 ? "desilenced" : `desilenced ${idx + 1}/${segs.length}`)
-  }));
-}
-function tightenRanges(ranges, silencesBySource, opts = DEFAULT_DESILENCE, wordsBySource = {}) {
-  return ranges.flatMap(
-    (r) => tightenRange(r, silencesBySource[r.source] ?? [], opts, wordsBySource[r.source] ?? [])
-  );
-}
-function wordsFromTranscriptFile(path) {
-  const t = JSON.parse(readFileSync8(path, "utf8"));
-  const out = [];
-  for (const w of t.words ?? []) {
-    if (w.type !== "word") continue;
-    if (typeof w.start === "number" && typeof w.end === "number" && w.end > w.start) {
-      out.push({ start: w.start, end: w.end });
-    }
-  }
-  return out;
-}
-function loadWordsBySource(edl, editDir) {
-  const dir = resolve2(editDir, "transcripts");
-  const allJson = existsSync7(dir) ? readdirSync3(dir).filter((f) => f.endsWith(".json")) : [];
-  const out = {};
-  for (const name of Object.keys(edl.sources)) {
-    let path = join9(dir, `${name}.json`);
-    if (!existsSync7(path)) {
-      if (allJson.length === 1) path = join9(dir, allJson[0]);
-      else {
-        out[name] = [];
-        continue;
-      }
-    }
-    try {
-      out[name] = wordsFromTranscriptFile(path);
-    } catch {
-      out[name] = [];
-    }
-  }
-  return out;
-}
-function totalDuration(ranges) {
-  return ranges.reduce((acc, r) => acc + (Number(r.end) - Number(r.start)), 0);
-}
-async function detectSilences(source, noiseDb, minSilenceS, sourceDurationS) {
-  const res = await run(silenceDetectArgs(source, noiseDb, minSilenceS), {
-    capture: true,
-    check: false,
-    echo: false
-  });
-  return parseSilenceDetect(res.stderr, sourceDurationS);
-}
-async function desilenceEdl(edl, editDir, opts = DEFAULT_DESILENCE) {
-  const silencesBySource = {};
-  for (const [name, rel] of Object.entries(edl.sources)) {
-    const srcPath = resolvePath(rel, editDir);
-    const dur2 = await mediaDuration(srcPath);
-    silencesBySource[name] = await detectSilences(srcPath, opts.noiseDb, opts.minSilence, dur2);
-  }
-  const wordsBySource = loadWordsBySource(edl, editDir);
-  const durationBefore = totalDuration(edl.ranges);
-  const newRanges = tightenRanges(edl.ranges, silencesBySource, opts, wordsBySource);
-  const durationAfter = totalDuration(newRanges);
-  const newEdl = {
-    ...edl,
-    ranges: newRanges,
-    total_duration_s: pyRound(durationAfter, 2),
-    desilenced: true
-  };
-  return {
-    edl: newEdl,
-    stats: {
-      rangesBefore: edl.ranges.length,
-      rangesAfter: newRanges.length,
-      durationBefore: pyRound(durationBefore, 2),
-      durationAfter: pyRound(durationAfter, 2),
-      removedS: pyRound(durationBefore - durationAfter, 2)
-    }
-  };
-}
-
-// src/prompts.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join10 } from "path";
-function learnedEditingGuardrails(jobDir, stem) {
-  const tpath = transcriptPath(jobDir, stem);
-  return `
-## V1 Learned Guardrails
-
-Before writing or reviewing the EDL, build a short plain-English understanding of the video:
-- What is the topic?
-- What named people, companies, products, and technical terms are likely being said?
-- What is the intended sentence meaning around each retake cluster?
-
-Treat the ElevenLabs Scribe transcript as word-timing evidence, not perfect text. Proper nouns and domain terms may be wrong. If a token looks semantically wrong but the surrounding sentence makes a better reading obvious, use the transcript timing but write the corrected human meaning in \`quote\` / \`reason\`.
-
-When transcript text and content disagree, inspect media at the decision point:
-- Use \`video-editing inspect --job-dir "${jobDir}" --video vertical_src --start <start> --end <end>\` (filmstrip + waveform + transcript labels PNG; transcript "${tpath}").
-- Read the filmstrip/waveform/labels before choosing the cut. Use it to find where the real spoken word starts, especially when Scribe mishears a proper noun or collapses a word.
-- For the opener, any named entity, and every retake join, verify the rendered preview with \`video-editing verify\` and \`video-editing inspect\` after rendering.
-
-Boundary rules learned from preview failures:
-- Clipped tokens ending in \`-\` (examples: \`s-\`, \`re-\`, \`li-\`, \`ei-\`) are danger zones. Do not end a kept range only a few milliseconds before a clipped token. Leave an audio guard band, preferably 80-150ms when the source gives you room.
-- Keep the first token of the chosen final take, even if it is a connector like "and", "so", or "but", when it belongs to the spoken sentence. Do not trim to the first important-looking content word.
-- The first 10 seconds are high stakes. After rendering, inspect the opening by listening or by \`video-editing inspect\` and fix any clipped syllable, doubled consonant, or missing connector before presenting the preview.
-- A clean text range is not enough. If the preview sounds like a doubled first letter/syllable across a join, move the previous range end earlier or the next range start later on word boundaries and rerender.
-`;
-}
-function agentizePrompt(text, jobDir, stem) {
-  let out = text.replace(/\{\{JOBDIR\}\}/g, jobDir).replace(/\{\{STEM\}\}/g, stem);
-  out = out.replace("{{JOBDIR}}/transcripts/<stem>.json", transcriptPath(jobDir, stem));
-  out = out.replace(/HEADLESS RULES[^\n]*:/, "AGENT RULES:");
-  if (!out.includes("## V1 Learned Guardrails")) {
-    out = out.trimEnd() + "\n\n" + learnedEditingGuardrails(jobDir, stem).trim() + "\n";
-  }
-  return out;
-}
-function templatePath(name) {
-  return fileURLToPath2(new URL(`./templates/${name}`, import.meta.url));
-}
-function writeVideoEditingPrompt(jobDir, stem, templateName, outName) {
-  const text = readFileSync9(templatePath(templateName), "utf8");
-  const path = join10(jobDir, "prompts", outName);
-  writeFileSync6(path, agentizePrompt(text, jobDir, stem), "utf8");
-  return path;
-}
-function writeSilencePrompt(jobDir, stem, opts) {
-  const tpath = transcriptPath(jobDir, stem);
-  const text = `You are an expert video editor using the \`video-editing\` CLI.
-
-The CLI has already prepared the job. Your job is to write ${jobDir}/edl.json. Use ONLY the \`video-editing\` CLI for execution \u2014 never run video-use helpers or ffmpeg directly.
-
-Inputs (already generated):
-- Master: ${jobDir}/vertical_src.mp4
-- Transcript: ${tpath}
-- Packed transcript: ${jobDir}/takes_packed.md
-- Flags: ${jobDir}/flags.txt
-- Word dump: ${jobDir}/word_dump.txt
-
-Brief:
-- Cut silences only.
-- Keep every spoken word and every complete phrase.
-- Trim dead air at the head and outro.
-- For inter-phrase gaps >= ${opts.minGap.toFixed(2)}s, tighten toward about ${opts.targetGap.toFixed(2)}s of air.
-- Snap every cut to word boundaries from the ElevenLabs Scribe transcript.
-- Use lead pad about ${opts.leadPad.toFixed(2)}s and trail pad about ${opts.trailPad.toFixed(2)}s, staying within clean silence.
-- Output clean cuts only: grade "none", overlays [], no subtitles.
-
-${learnedEditingGuardrails(jobDir, stem)}
-
-Write exactly this EDL schema:
-{
-  "version": 1,
-  "sources": {"SRC": "${jobDir}/vertical_src.mp4"},
-  "grade": "none",
-  "ranges": [
-    {"source": "SRC", "start": 0.0, "end": 1.0, "beat": "speech 1", "quote": "...", "reason": "..."}
-  ],
-  "overlays": [],
-  "total_duration_s": 0.0
-}
-
-After writing the EDL, run:
-video-editing render --job-dir ${jobDir} --mode preview
-video-editing verify --job-dir ${jobDir} --json
-`;
-  const path = join10(jobDir, "prompts", "cut-silences.prompt.md");
-  writeFileSync6(path, text, "utf8");
-  return path;
-}
-
-// src/timeline-v2/schema.ts
-import { z } from "zod";
-var provenanceSchema = z.object({
-  round: z.number().int().nullable().default(null),
-  changeId: z.string().nullable().default(null),
-  actor: z.enum(["agent", "user"]).default("agent")
-}).strict().default({ round: null, changeId: null, actor: "agent" });
-var wordsAnchorSchema = z.object({
-  type: z.literal("words"),
-  source: z.string().min(1),
-  phrase: z.string().min(1),
-  /** 1-based occurrence index when the phrase appears more than once. */
-  occurrence: z.number().int().min(1).optional(),
-  /** Cached resolution in SOURCE seconds. */
-  resolved: z.object({ start: z.number().min(0), end: z.number().min(0) }).strict().optional(),
-  /** Collapse the span to one instant (phrase start or end). */
-  edge: z.enum(["start", "end"]).optional()
-}).strict();
-var sourceAnchorSchema = z.object({
-  type: z.literal("source"),
-  source: z.string().min(1),
-  start: z.number().min(0),
-  end: z.number().min(0)
-}).strict();
-var outputAnchorSchema = z.object({
-  type: z.literal("output"),
-  at: z.union([z.enum(["start", "end", "full"]), z.object({ after: z.string().min(1) }).strict()]),
-  durationS: z.number().positive().optional()
-}).strict();
-var anchorSchema = z.discriminatedUnion("type", [
-  wordsAnchorSchema,
-  sourceAnchorSchema,
-  outputAnchorSchema
-]);
-var timelineSourceSchema = z.object({
-  /** Path (absolute or job-dir-relative) to the media file. */
-  path: z.string().min(1),
-  durationS: z.number().positive().optional(),
-  /** "sha256:<hex>" of the transcript JSON this doc's cached anchor
-   *  resolutions were computed against. */
-  transcriptHash: z.string().optional()
-}).strict();
-var desilenceSettingsSchema = z.object({
-  noiseDb: z.number(),
-  minSilence: z.number().positive(),
-  targetGap: z.number().min(0),
-  leadKeep: z.number().min(0),
-  trailKeep: z.number().min(0),
-  minSegment: z.number().min(0)
-}).partial().strict();
-var gradeSettingSchema = z.object({ preset: z.string(), intensity: z.number().min(0).max(1).optional() }).strict();
-var settingsSchema = z.object({
-  canvas: z.object({ w: z.number().int().positive(), h: z.number().int().positive() }).strict().default({ w: 1080, h: 1920 }),
-  /** "none" | preset name | raw ffmpeg filter | "auto" (same as EDL grade),
-   *  or a declarative {preset, intensity?} grade for the composition path. */
-  grade: z.union([z.string(), gradeSettingSchema]).default("none"),
-  loudnorm: z.boolean().default(true),
-  /** Optional DesilenceOptions subset; merged over DEFAULT_DESILENCE. */
-  desilence: desilenceSettingsSchema.optional()
-}).strict().default({ canvas: { w: 1080, h: 1920 }, grade: "none", loudnorm: true });
-var cutRangeSchema = z.object({
-  id: z.string().min(1),
-  source: z.string().min(1),
-  start: z.number().min(0),
-  end: z.number().min(0),
-  beat: z.string().optional(),
-  quote: z.string().optional(),
-  reason: z.string().optional(),
-  /** Optional per-range grade override (kept for v1 EDL round-trips). */
-  grade: z.string().optional(),
-  provenance: provenanceSchema
-}).strict();
-var cutSchema = z.object({ ranges: z.array(cutRangeSchema).default([]) }).strict().default({ ranges: [] });
-var CSS_COLOR_RE = /^(#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|[a-zA-Z]+)$/;
-var captionOverrideSchema = z.object({
-  id: z.string().min(1),
-  anchor: wordsAnchorSchema,
-  op: z.enum(["replace-text", "hide", "break-line", "style"]),
-  text: z.string().optional(),
-  /** op:"style" — per-word color (hex or simple CSS color name). */
-  color: z.string().regex(CSS_COLOR_RE, "must be a hex color or a simple CSS color name").optional(),
-  /** op:"style" — per-word animated emphasis at the word's onset. */
-  emphasis: z.enum(["pop", "highlight"]).optional(),
-  provenance: provenanceSchema
-}).strict();
-var captionPresetSchema = z.enum(["grouped", "opus-karaoke"]);
-var captionStyleSchema = z.object({
-  /** Max words per grouped cue (preset "grouped" only). */
-  maxWords: z.number().int().min(1).max(20).optional(),
-  /** Inter-word gap (seconds) that ends a phrase — a hard cue boundary
-   *  (preset "grouped" only). */
-  gapBreakS: z.number().min(0).max(5).optional(),
-  /** Seconds each cue's display start is shifted EARLIER (clamped to the
-   *  previous cue's end / the segment's outStart). */
-  leadS: z.number().min(0).max(1).optional(),
-  /** Max seconds a cue is held past its last word to bridge the gap to the
-   *  next cue (never past the segment's outEnd). */
-  holdS: z.number().min(0).max(5).optional(),
-  /** Per-word highlight sweep within grouped cues (karaoke-style). */
-  karaoke: z.boolean().optional()
-}).passthrough();
-var CAPTION_STYLE_DEFAULTS = { maxWords: 4, gapBreakS: 0.6, leadS: 0.08, holdS: 0.9 };
-var captionsSchema = z.object({
-  enabled: z.boolean().default(false),
-  preset: captionPresetSchema.default("grouped"),
-  style: captionStyleSchema.default({}),
-  overrides: z.array(captionOverrideSchema).default([])
-}).strict().default({ enabled: false, preset: "grouped", style: {}, overrides: [] });
-var onCutSchema = z.enum(["clip", "drop", "error"]);
-var zoomRectSchema = z.object({
-  x: z.number().min(0).max(1),
-  y: z.number().min(0).max(1),
-  w: z.number().min(0).max(1),
-  h: z.number().min(0).max(1)
-}).strict();
-var zoomSchema = z.object({
-  id: z.string().min(1),
-  anchor: anchorSchema,
-  onCut: onCutSchema.default("clip"),
-  rect: zoomRectSchema,
-  scale: z.number().gt(1).lte(3),
-  /** Ramp target: when present, the zoom animates from the base rect/scale
-   *  to `to` over the zoom window (`ease` shapes the ramp). */
-  to: z.object({
-    rect: zoomRectSchema.optional(),
-    scale: z.number().gt(1).lte(3).optional()
-  }).strict().optional(),
-  ease: z.object({ in: z.number().min(0), out: z.number().min(0) }).strict().default({ in: 0.25, out: 0.25 }),
-  provenance: provenanceSchema
-}).strict();
-var assetRefSchema = z.object({ ref: z.string().min(1) }).strict();
-var overlayFxSchema = z.object({
-  preset: z.enum(["fade", "pop", "slide-up", "slide-down", "scale-in"]),
-  durationS: z.number().positive().max(2)
-}).strict();
-var overlaySchema = z.object({
-  id: z.string().min(1),
-  kind: z.enum(["text", "title-card", "image", "sticker"]),
-  anchor: anchorSchema,
-  onCut: onCutSchema.default("drop"),
-  layout: z.object({
-    x: z.number().min(0).max(1).default(0.5),
-    y: z.number().min(0).max(1).default(0.82),
-    align: z.enum(["left", "center", "right"]).default("center"),
-    safeArea: z.boolean().default(true)
-  }).strict().default({ x: 0.5, y: 0.82, align: "center", safeArea: true }),
-  text: z.string().optional(),
-  style: z.object({ preset: z.string().optional() }).passthrough().default({}),
-  durationS: z.number().positive().optional(),
-  asset: assetRefSchema.optional(),
-  /** Entrance/exit presets (image/sticker overlays). */
-  enter: overlayFxSchema.optional(),
-  exit: overlayFxSchema.optional(),
-  /** Size as canvas fractions (w of canvas width, h of canvas height). */
-  size: z.object({
-    w: z.number().min(0).max(1).optional(),
-    h: z.number().min(0).max(1).optional()
-  }).strict().optional(),
-  /** Stacking order (CSS z-index); temporal lanes stay non-overlapping. */
-  z: z.number().int().min(0).max(50).optional(),
-  provenance: provenanceSchema
-}).strict();
-var audioSchema = z.object({
-  id: z.string().min(1),
-  kind: z.enum(["music", "sfx"]),
-  asset: assetRefSchema,
-  anchor: anchorSchema,
-  gainDb: z.number().default(-18),
-  duckToSpeech: z.boolean().default(true),
-  fadeOutS: z.number().min(0).optional(),
-  provenance: provenanceSchema
-}).strict();
-var timelineV2Schema = z.object({
-  version: z.literal(2),
-  id: z.string().regex(/^tl_/, 'timeline id must start with "tl_"'),
-  sources: z.record(timelineSourceSchema).refine((s) => Object.keys(s).length > 0, {
-    message: "at least one source is required"
-  }),
-  settings: settingsSchema,
-  cut: cutSchema,
-  captions: captionsSchema,
-  zooms: z.array(zoomSchema).default([]),
-  overlays: z.array(overlaySchema).default([]),
-  audio: z.array(audioSchema).default([])
-}).strict();
-function emptyDiagnostics() {
-  return { errors: [], warnings: [], dropped: [] };
-}
-function parseTimeline(raw) {
-  if (raw !== null && typeof raw === "object" && typeof raw.captions === "object" && raw.captions !== null && "cues" in raw.captions) {
-    return {
-      doc: null,
-      errors: [
-        {
-          path: "captions.cues",
-          code: "captions-authored-cues",
-          message: "caption cues are derived by compile and must never be stored in timeline.json",
-          suggestion: "remove captions.cues; author only enabled/preset/style/overrides"
-        }
-      ]
-    };
-  }
-  const parsed = timelineV2Schema.safeParse(raw);
-  if (!parsed.success) {
-    return {
-      doc: null,
-      errors: parsed.error.issues.map((iss) => ({
-        path: iss.path.map((p) => typeof p === "number" ? `[${p}]` : p).join(".").replace(/\.\[/g, "["),
-        code: `schema:${iss.code}`,
-        message: iss.message
-      }))
-    };
-  }
-  return { doc: parsed.data, errors: [] };
-}
-var EPS2 = 1e-6;
-function itemIds(doc) {
-  return [
-    ...doc.cut.ranges.map((r) => r.id),
-    ...doc.captions.overrides.map((o) => o.id),
-    ...doc.zooms.map((zm) => zm.id),
-    ...doc.overlays.map((ov) => ov.id),
-    ...doc.audio.map((a) => a.id)
-  ];
-}
-function checkAnchorSource(anchor, doc, path, errors) {
-  if (anchor.type === "output") return;
-  if (!(anchor.source in doc.sources)) {
-    errors.push({
-      path: `${path}.source`,
-      code: "unknown-source",
-      message: `anchor references unknown source "${anchor.source}"`,
-      suggestion: `known sources: ${Object.keys(doc.sources).join(", ")}`
-    });
-  }
-  if (anchor.type === "source" && anchor.end <= anchor.start) {
-    errors.push({
-      path,
-      code: "bad-anchor-span",
-      message: `source anchor end (${anchor.end}) must be greater than start (${anchor.start})`
-    });
-  }
-}
-function validateTimeline(doc) {
-  const errors = [];
-  const warnings = [];
-  const seen = /* @__PURE__ */ new Map();
-  for (const id of itemIds(doc)) seen.set(id, (seen.get(id) ?? 0) + 1);
-  for (const [id, count] of seen) {
-    if (count > 1) {
-      errors.push({
-        path: "(items)",
-        code: "duplicate-id",
-        message: `item id "${id}" is used ${count} times; ids must be unique across all items`
-      });
-    }
-  }
-  const lastEndBySource = /* @__PURE__ */ new Map();
-  doc.cut.ranges.forEach((r, i) => {
-    const path = `cut.ranges[${i}]`;
-    if (!(r.source in doc.sources)) {
-      errors.push({
-        path: `${path}.source`,
-        code: "unknown-source",
-        message: `cut range "${r.id}" references unknown source "${r.source}"`,
-        suggestion: `known sources: ${Object.keys(doc.sources).join(", ")}`
-      });
-      return;
-    }
-    if (r.end <= r.start) {
-      errors.push({
-        path,
-        code: "bad-range",
-        message: `cut range "${r.id}" has end (${r.end}) <= start (${r.start})`
-      });
-      return;
-    }
-    const dur2 = doc.sources[r.source].durationS;
-    if (dur2 !== void 0 && r.end > dur2 + EPS2) {
-      errors.push({
-        path: `${path}.end`,
-        code: "range-out-of-bounds",
-        message: `cut range "${r.id}" ends at ${r.end}s but source "${r.source}" is ${dur2}s long`
-      });
-    }
-    const prev = lastEndBySource.get(r.source);
-    if (prev !== void 0) {
-      if (r.start < prev.end - EPS2) {
-        const code = r.start <= doc.cut.ranges[prev.index].start + EPS2 ? "range-order" : "range-overlap";
-        errors.push({
-          path,
-          code,
-          message: code === "range-order" ? `cut range "${r.id}" is out of order: ranges of source "${r.source}" must be sorted by start` : `cut range "${r.id}" overlaps the previous range of source "${r.source}" (starts at ${r.start} before previous end ${prev.end})`
-        });
-      }
-    }
-    lastEndBySource.set(r.source, { end: r.end, index: i });
-  });
-  doc.captions.overrides.forEach((o, i) => {
-    checkAnchorSource(o.anchor, doc, `captions.overrides[${i}].anchor`, errors);
-    if (o.op === "replace-text" && (o.text === void 0 || o.text.length === 0)) {
-      errors.push({
-        path: `captions.overrides[${i}].text`,
-        code: "missing-text",
-        message: `caption override "${o.id}" has op "replace-text" but no text`
-      });
-    }
-    if (o.op === "style" && o.color === void 0 && o.emphasis === void 0) {
-      errors.push({
-        path: `captions.overrides[${i}]`,
-        code: "missing-style",
-        message: `caption override "${o.id}" has op "style" but neither color nor emphasis`,
-        suggestion: 'set color (e.g. "#ff5c5c") and/or emphasis ("pop" | "highlight")'
-      });
-    }
-  });
-  doc.zooms.forEach((zm, i) => {
-    const path = `zooms[${i}]`;
-    checkAnchorSource(zm.anchor, doc, `${path}.anchor`, errors);
-    if (zm.rect.x + zm.rect.w > 1 + EPS2 || zm.rect.y + zm.rect.h > 1 + EPS2) {
-      errors.push({
-        path: `${path}.rect`,
-        code: "bad-rect",
-        message: `zoom "${zm.id}" rect exceeds the unit canvas (x+w=${zm.rect.x + zm.rect.w}, y+h=${zm.rect.y + zm.rect.h})`,
-        suggestion: "keep x+w <= 1 and y+h <= 1"
-      });
-    }
-    if (zm.to !== void 0) {
-      if (zm.to.rect === void 0 && zm.to.scale === void 0) {
-        errors.push({
-          path: `${path}.to`,
-          code: "empty-ramp",
-          message: `zoom "${zm.id}" has a ramp target "to" with neither rect nor scale`,
-          suggestion: "set to.rect and/or to.scale, or remove to"
-        });
-      }
-      const tr = zm.to.rect;
-      if (tr && (tr.x + tr.w > 1 + EPS2 || tr.y + tr.h > 1 + EPS2)) {
-        errors.push({
-          path: `${path}.to.rect`,
-          code: "bad-rect",
-          message: `zoom "${zm.id}" to.rect exceeds the unit canvas (x+w=${tr.x + tr.w}, y+h=${tr.y + tr.h})`,
-          suggestion: "keep x+w <= 1 and y+h <= 1"
-        });
-      }
-    }
-  });
-  doc.overlays.forEach((ov, i) => {
-    const path = `overlays[${i}]`;
-    checkAnchorSource(ov.anchor, doc, `${path}.anchor`, errors);
-    if ((ov.kind === "image" || ov.kind === "sticker") && !ov.asset) {
-      errors.push({
-        path: `${path}.asset`,
-        code: "missing-asset",
-        message: `overlay "${ov.id}" has kind "${ov.kind}" but no asset`
-      });
-    }
-    if ((ov.kind === "text" || ov.kind === "title-card") && (ov.text === void 0 || ov.text.length === 0)) {
-      errors.push({
-        path: `${path}.text`,
-        code: "missing-text",
-        message: `overlay "${ov.id}" has kind "${ov.kind}" but no text`
-      });
-    }
-  });
-  doc.audio.forEach((a, i) => {
-    checkAnchorSource(a.anchor, doc, `audio[${i}].anchor`, errors);
-  });
-  const fullAudio = doc.audio.filter((a) => a.anchor.type === "output" && a.anchor.at === "full");
-  if (fullAudio.length > 1) {
-    errors.push({
-      path: "audio",
-      code: "multiple-full-audio",
-      message: `at most one audio item may use at:"full" (found ${fullAudio.length}: ${fullAudio.map((a) => a.id).join(", ")})`
-    });
-  }
-  const ids = new Set(itemIds(doc));
-  const checkAfter = (anchor, ownerId, path) => {
-    if (anchor.type !== "output" || typeof anchor.at === "string") return;
-    const target = anchor.at.after;
-    if (!ids.has(target)) {
-      errors.push({
-        path,
-        code: "unknown-after-target",
-        message: `after:"${target}" does not reference any existing item id`
-      });
-    } else if (target === ownerId) {
-      errors.push({
-        path,
-        code: "after-cycle",
-        message: `item "${ownerId}" cannot be anchored after itself`
-      });
-    }
-  };
-  doc.zooms.forEach((zm, i) => checkAfter(zm.anchor, zm.id, `zooms[${i}].anchor.at.after`));
-  doc.overlays.forEach((ov, i) => checkAfter(ov.anchor, ov.id, `overlays[${i}].anchor.at.after`));
-  doc.audio.forEach((a, i) => checkAfter(a.anchor, a.id, `audio[${i}].anchor.at.after`));
-  return { errors, warnings };
-}
-
-// src/timeline-v2/capabilities.ts
-var CAPABILITIES = {
-  cut: { status: "ready" },
-  "captions.karaoke": { status: "ready" },
-  // Per-word color/emphasis styling — rendered by composeHtml (render-proven).
-  "captions.word-style": { status: "ready" },
-  // Karaoke per-word sweep compiles + composes, but the sweep itself has not
-  // been through a validation render yet.
-  "captions.karaoke-highlight": { status: "staged" },
-  zoom: { status: "ready" },
-  // Animated zoom ramps (base → to over the window) — render-proven GSAP path.
-  "zoom.ramp": { status: "ready" },
-  "overlay.text": { status: "ready" },
-  "overlay.title-card": { status: "ready" },
-  "overlay.image": { status: "ready" },
-  "overlay.sticker": { status: "ready" },
-  "overlay.enter-exit": { status: "ready" },
-  // Audio beds/sfx are schema-complete but the render integration is staged.
-  "audio.music": { status: "staged" },
-  "audio.sfx": { status: "staged" },
-  // Declarative color grade (data-color-grading) — not yet render-proven.
-  grade: { status: "staged" }
-};
-function usesFromDoc(doc) {
-  const uses = [];
-  const add = (k) => {
-    if (!uses.includes(k)) uses.push(k);
-  };
-  if (doc.cut.ranges.length > 0) add("cut");
-  if (doc.captions.enabled) {
-    add("captions.karaoke");
-    if (doc.captions.overrides.some((o) => o.op === "style")) add("captions.word-style");
-    if (doc.captions.style.karaoke === true) add("captions.karaoke-highlight");
-  }
-  if (doc.zooms.length > 0) add("zoom");
-  if (doc.zooms.some((zm) => zm.to !== void 0)) add("zoom.ramp");
-  for (const ov of doc.overlays) {
-    add(`overlay.${ov.kind}`);
-    if (ov.enter !== void 0 || ov.exit !== void 0) add("overlay.enter-exit");
-  }
-  for (const a of doc.audio) add(`audio.${a.kind}`);
-  if (typeof doc.settings.grade === "object") add("grade");
-  return uses;
-}
-function checkCapabilities(uses, registry = CAPABILITIES) {
-  const errors = [];
-  const warnings = [];
-  for (const key of uses) {
-    const status = registry[key]?.status ?? "none";
-    if (status === "none") {
-      errors.push({
-        path: "(capabilities)",
-        code: "capability-none",
-        message: `feature "${key}" is used by this timeline but is not available in this build`,
-        suggestion: "remove the items using it, or upgrade the renderer",
-        context: { feature: key, status }
-      });
-    } else if (status === "staged") {
-      warnings.push({
-        path: "(capabilities)",
-        code: "capability-staged",
-        message: `feature "${key}" is staged: it compiles into the plan but the render path may not honor it yet`,
-        context: { feature: key, status }
-      });
-    }
-  }
-  return { errors, warnings };
-}
-
-// src/timeline-v2/anchors.ts
-function normalizeToken(text) {
-  return text.trim().toLowerCase().replace(/^[^\p{L}\p{N}]+/gu, "").replace(/[^\p{L}\p{N}]+$/gu, "");
-}
-function normalizePhrase(phrase) {
-  return phrase.split(/\s+/).map(normalizeToken).filter((t) => t.length > 0);
-}
-function wordStream(transcript) {
-  const words = [];
-  for (const w of transcript.words ?? []) {
-    if ((w.type ?? "word") !== "word") continue;
-    if (typeof w.start !== "number" || typeof w.end !== "number") continue;
-    words.push(w);
-  }
-  words.sort((a, b) => Number(a.start) - Number(b.start) || Number(a.end) - Number(b.end));
-  return words.map((w, i) => {
-    const text = (w.text ?? "").trim();
-    return { index: i, start: Number(w.start), end: Number(w.end), text, norm: normalizeToken(text) };
-  });
-}
-function contextAround(stream, from, to, pad = 5) {
-  const before = stream.slice(Math.max(0, from - pad), from).map((w) => w.text);
-  const matched = stream.slice(from, to + 1).map((w) => w.text);
-  const after = stream.slice(to + 1, to + 1 + pad).map((w) => w.text);
-  const parts = [];
-  if (from - pad > 0) parts.push("\u2026");
-  parts.push(...before, `\xAB${matched.join(" ")}\xBB`, ...after);
-  if (to + 1 + pad < stream.length) parts.push("\u2026");
-  return parts.join(" ");
-}
-function findPhrase(stream, phrase) {
-  const tokens = normalizePhrase(phrase);
-  if (tokens.length === 0) return [];
-  const matches = [];
-  for (let i = 0; i + tokens.length <= stream.length; i++) {
-    let ok = true;
-    for (let j = 0; j < tokens.length; j++) {
-      if (stream[i + j].norm !== tokens[j]) {
-        ok = false;
-        break;
-      }
-    }
-    if (!ok) continue;
-    const last = i + tokens.length - 1;
-    matches.push({
-      occurrence: matches.length + 1,
-      start: stream[i].start,
-      end: stream[last].end,
-      words: stream.slice(i, last + 1).map((w) => ({ start: w.start, end: w.end, text: w.text })),
-      context: contextAround(stream, i, last),
-      wordIndex: i
-    });
-  }
-  return matches;
-}
-function levenshtein(a, b) {
-  const m = a.length;
-  const n = b.length;
-  if (m === 0) return n;
-  if (n === 0) return m;
-  let prev = new Array(n + 1);
-  let cur = new Array(n + 1);
-  for (let j = 0; j <= n; j++) prev[j] = j;
-  for (let i = 1; i <= m; i++) {
-    cur[0] = i;
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
-    }
-    [prev, cur] = [cur, prev];
-  }
-  return prev[n];
-}
-function fuzzySuggestions(stream, phrase, limit = 3) {
-  const tokens = normalizePhrase(phrase);
-  if (tokens.length === 0 || stream.length === 0) return [];
-  const target = tokens.join(" ");
-  const n = Math.min(tokens.length, stream.length);
-  const scored = [];
-  for (let i = 0; i + n <= stream.length; i++) {
-    const window = stream.slice(i, i + n);
-    const joined = window.map((w) => w.norm).join(" ");
-    const dist = levenshtein(target, joined);
-    const similarity = 1 - dist / Math.max(target.length, joined.length, 1);
-    scored.push({
-      start: window[0].start,
-      end: window[n - 1].end,
-      text: window.map((w) => w.text).join(" "),
-      similarity: Math.round(similarity * 1e3) / 1e3
-    });
-  }
-  scored.sort((a, b) => b.similarity - a.similarity || a.start - b.start);
-  return scored.slice(0, limit).filter((s) => s.similarity > 0);
-}
-function resolvePhrase(stream, phrase, opts = {}) {
-  const matches = findPhrase(stream, phrase);
-  if (matches.length === 0) {
-    return { status: "not-found", suggestions: fuzzySuggestions(stream, phrase) };
-  }
-  if (opts.occurrence !== void 0) {
-    const m = matches[opts.occurrence - 1];
-    if (!m) return { status: "ambiguous", candidates: matches };
-    return { status: "ok", match: m, matches };
-  }
-  if (matches.length === 1) return { status: "ok", match: matches[0], matches };
-  if (opts.nearS !== void 0) {
-    const near = opts.nearS;
-    let best = matches[0];
-    for (const m of matches) {
-      if (Math.abs(m.start - near) < Math.abs(best.start - near)) best = m;
-    }
-    return { status: "ok", match: best, matches };
-  }
-  return { status: "ambiguous", candidates: matches };
-}
-
-// src/timeline-v2/compile.ts
-import { createHash } from "crypto";
-var EPS3 = 1e-3;
-function timelineHash(doc) {
-  const canon = (v) => {
-    if (Array.isArray(v)) return v.map(canon);
-    if (v !== null && typeof v === "object") {
-      const out = {};
-      for (const k of Object.keys(v).sort()) {
-        const val = v[k];
-        if (val !== void 0) out[k] = canon(val);
-      }
-      return out;
-    }
-    return v;
-  };
-  const json = JSON.stringify(canon(doc));
-  return "sha256:" + createHash("sha256").update(json, "utf8").digest("hex");
-}
-function r3(x) {
-  return pyRound(x, 3);
-}
-function wordSpansFromTranscript(t) {
-  if (!t) return [];
-  const out = [];
-  for (const w of t.words ?? []) {
-    if (w.type !== "word") continue;
-    if (typeof w.start === "number" && typeof w.end === "number" && w.end > w.start) {
-      out.push({ start: w.start, end: w.end });
-    }
-  }
-  return out;
-}
-function mapSpan(segments, source, a, b) {
-  let covered = 0;
-  let outStart = Infinity;
-  let outEnd = -Infinity;
-  const parts = [];
-  segments.forEach((seg, segIndex) => {
-    if (seg.source !== source) return;
-    const srcA = Math.max(a, seg.srcStart);
-    const srcB = Math.min(b, seg.srcEnd);
-    const isPoint = b - a <= EPS3;
-    if (isPoint ? !(a >= seg.srcStart - EPS3 && a <= seg.srcEnd + EPS3) : srcB - srcA <= 0) return;
-    covered += Math.max(0, srcB - srcA);
-    const oA = seg.outStart + (Math.max(srcA, seg.srcStart) - seg.srcStart);
-    const oB = seg.outStart + (Math.min(srcB, seg.srcEnd) - seg.srcStart);
-    outStart = Math.min(outStart, oA);
-    outEnd = Math.max(outEnd, isPoint ? oA : oB);
-    parts.push({ segIndex, srcA, srcB });
-  });
-  if (parts.length === 0) return { covered: 0, outStart: 0, outEnd: 0, parts };
-  return { covered, outStart, outEnd, parts };
-}
-function compileTimeline(doc, ctx = {}) {
-  const diagnostics = emptyDiagnostics();
-  const uses = usesFromDoc(doc);
-  const sem = validateTimeline(doc);
-  diagnostics.errors.push(...sem.errors);
-  diagnostics.warnings.push(...sem.warnings);
-  const cap = checkCapabilities(uses, ctx.capabilities ?? CAPABILITIES);
-  diagnostics.errors.push(...cap.errors);
-  diagnostics.warnings.push(...cap.warnings);
-  if (ctx.assetsPresent) {
-    const checkAsset = (ref, path, id) => {
-      if (ref === void 0 || ctx.assetsPresent[ref] !== false) return;
-      diagnostics.errors.push({
-        path,
-        code: "asset-missing",
-        message: `"${id}" references asset "${ref}" but no such file exists in the job dir`,
-        suggestion: `place the file at <job>/${ref} (asset refs are job-dir-relative paths)`
-      });
-    };
-    doc.overlays.forEach((ov, i) => checkAsset(ov.asset?.ref, `overlays[${i}].asset.ref`, ov.id));
-    doc.audio.forEach((a, i) => checkAsset(a.asset.ref, `audio[${i}].asset.ref`, a.id));
-  }
-  if (diagnostics.errors.length > 0) {
-    return { ok: false, plan: null, legacyEdl: null, diagnostics, uses };
-  }
-  const streams = {};
-  for (const name of Object.keys(doc.sources)) {
-    const t = ctx.transcripts?.[name];
-    streams[name] = t ? wordStream(t) : void 0;
-  }
-  const resolveWords = (anchor, path) => {
-    const src = doc.sources[anchor.source];
-    const hashMatches = src.transcriptHash !== void 0 && src.transcriptHash === ctx.transcriptHashes?.[anchor.source];
-    if (anchor.resolved && hashMatches) return anchor.resolved;
-    const stream = streams[anchor.source];
-    if (!stream) {
-      if (anchor.resolved) {
-        diagnostics.warnings.push({
-          path,
-          code: "anchor-unverified-cache",
-          message: `no transcript available for source "${anchor.source}"; using the cached resolved span for "${anchor.phrase}" without verification`
-        });
-        return anchor.resolved;
-      }
-      diagnostics.errors.push({
-        path,
-        code: "anchor-unresolvable",
-        message: `cannot resolve phrase "${anchor.phrase}": no transcript available for source "${anchor.source}"`,
-        suggestion: "run `video-editing transcribe` first"
-      });
-      return null;
-    }
-    const outcome = resolvePhrase(stream, anchor.phrase, { occurrence: anchor.occurrence });
-    if (outcome.status === "ok") return { start: outcome.match.start, end: outcome.match.end };
-    if (outcome.status === "ambiguous") {
-      diagnostics.errors.push({
-        path,
-        code: "anchor-ambiguous",
-        message: `phrase "${anchor.phrase}" matches ${outcome.candidates.length} times in source "${anchor.source}"; add occurrence or a tighter phrase`,
-        suggestion: "set anchor.occurrence (1-based), or use `timeline resolve --near`",
-        context: {
-          candidates: outcome.candidates.map((c) => ({
-            occurrence: c.occurrence,
-            start: c.start,
-            end: c.end,
-            context: c.context
-          }))
-        }
-      });
-      return null;
-    }
-    diagnostics.errors.push({
-      path,
-      code: "anchor-not-found",
-      message: `phrase "${anchor.phrase}" not found in source "${anchor.source}"`,
-      suggestion: outcome.suggestions.length ? `nearest matches: ${outcome.suggestions.map((s) => `"${s.text}" @${s.start}s`).join("; ")}` : void 0,
-      context: { suggestions: outcome.suggestions }
-    });
-    return null;
-  };
-  const desilenceOpts = { ...DEFAULT_DESILENCE, ...doc.settings.desilence ?? {} };
-  const runDesilence = ctx.desilence !== false;
-  const tightened = [];
-  for (const r of doc.cut.ranges) {
-    const clean = { source: r.source, start: r.start, end: r.end };
-    if (r.beat !== void 0) clean.beat = r.beat;
-    if (r.quote !== void 0) clean.quote = r.quote;
-    if (r.reason !== void 0) clean.reason = r.reason;
-    if (r.grade !== void 0) clean.grade = r.grade;
-    const subs = runDesilence ? tightenRange(
-      clean,
-      ctx.silencesBySource?.[r.source] ?? [],
-      desilenceOpts,
-      ctx.wordsBySource?.[r.source] ?? wordSpansFromTranscript(ctx.transcripts?.[r.source])
-    ) : [clean];
-    for (const sub of subs) tightened.push({ range: sub, rangeId: r.id });
-  }
-  const segments = [];
-  let cursor = 0;
-  tightened.forEach(({ range, rangeId }, i) => {
-    const dur2 = Number(range.end) - Number(range.start);
-    segments.push({
-      id: `seg_${i}`,
-      source: range.source,
-      srcStart: Number(range.start),
-      srcEnd: Number(range.end),
-      outStart: r3(cursor),
-      outEnd: r3(cursor + dur2),
-      rangeId,
-      videoOps: []
-    });
-    cursor += dur2;
-  });
-  const outputDurationS = r3(cursor);
-  const itemOutEnd = /* @__PURE__ */ new Map();
-  for (const seg of segments) itemOutEnd.set(seg.rangeId, seg.outEnd);
-  const dropItem = (id, path, why) => {
-    diagnostics.warnings.push({
-      path,
-      code: "on-cut-dropped",
-      message: why
-    });
-    diagnostics.dropped.push(id);
-  };
-  const sourceSpanFor = (item, path, applyEdge) => {
-    const anchor = item.anchor;
-    if (anchor.type === "source") return { source: anchor.source, a: anchor.start, b: anchor.end };
-    if (anchor.type === "words") {
-      const span = resolveWords(anchor, `${path}.anchor`);
-      if (!span) return null;
-      let a = span.start;
-      let b = span.end;
-      if (applyEdge && anchor.edge === "start") b = a;
-      else if (applyEdge && anchor.edge === "end") a = b;
-      return { source: anchor.source, a, b };
-    }
-    return null;
-  };
-  let fatal = false;
-  doc.zooms.forEach((zm, i) => {
-    const path = `zooms[${i}]`;
-    if (zm.anchor.type === "output") {
-      const span = resolveOutputSpan(zm.anchor, void 0, path);
-      if (!span) return;
-      attachZoomOpsByOutput(zm, span.outStart, span.outEnd);
-      return;
-    }
-    if (zm.anchor.type === "words" && zm.anchor.edge !== void 0) {
-      diagnostics.warnings.push({
-        path: `${path}.anchor.edge`,
-        code: "edge-ignored",
-        message: `zoom "${zm.id}": anchor.edge is ignored for zooms; the full phrase span is used`
-      });
-    }
-    const src = sourceSpanFor(zm, path, false);
-    if (!src) {
-      fatal = true;
-      return;
-    }
-    const { a, b } = src;
-    const m = mapSpan(segments, src.source, a, b);
-    const want = b - a;
-    if (m.covered <= EPS3) {
-      if (zm.onCut === "error") {
-        diagnostics.errors.push({
-          path,
-          code: "on-cut-error",
-          message: `zoom "${zm.id}" spans [${a}, ${b}]s of source "${src.source}" which is entirely removed by the cut`
-        });
-        fatal = true;
-      } else {
-        dropItem(zm.id, path, `zoom "${zm.id}" was dropped: its span [${a}, ${b}]s is entirely outside the kept ranges`);
-      }
-      return;
-    }
-    if (m.covered < want - EPS3) {
-      if (zm.onCut === "error") {
-        diagnostics.errors.push({
-          path,
-          code: "on-cut-error",
-          message: `zoom "${zm.id}" spans [${a}, ${b}]s of source "${src.source}" but only ${m.covered.toFixed(3)}s of it survives the cut (onCut:"error")`
-        });
-        fatal = true;
-        return;
-      }
-      if (zm.onCut === "drop") {
-        dropItem(zm.id, path, `zoom "${zm.id}" was dropped: its span is only partially inside the kept ranges (onCut:"drop")`);
-        return;
-      }
-    }
-    for (const part of m.parts) {
-      const seg = segments[part.segIndex];
-      seg.videoOps.push({
-        kind: "zoom",
-        itemId: zm.id,
-        rect: zm.rect,
-        scale: zm.scale,
-        ease: zm.ease,
-        tIn: r3(part.srcA - seg.srcStart),
-        tOut: r3(part.srcB - seg.srcStart),
-        ...rampFields(zm)
-      });
-    }
-  });
-  function rampFields(zm) {
-    if (zm.to === void 0) return {};
-    return {
-      ...zm.to.rect !== void 0 ? { toRect: zm.to.rect } : {},
-      ...zm.to.scale !== void 0 ? { toScale: zm.to.scale } : {}
-    };
-  }
-  function attachZoomOpsByOutput(zm, outA, outB) {
-    for (const seg of segments) {
-      const a = Math.max(outA, seg.outStart);
-      const b = Math.min(outB, seg.outEnd);
-      if (b - a <= EPS3) continue;
-      seg.videoOps.push({
-        kind: "zoom",
-        itemId: zm.id,
-        rect: zm.rect,
-        scale: zm.scale,
-        ease: zm.ease,
-        tIn: r3(a - seg.outStart),
-        tOut: r3(b - seg.outStart),
-        ...rampFields(zm)
-      });
-    }
-  }
-  function resolveOutputSpan(anchor, itemDurationS, path) {
-    const d = anchor.durationS ?? itemDurationS;
-    if (typeof anchor.at === "string") {
-      if (anchor.at === "full") return { outStart: 0, outEnd: outputDurationS };
-      if (d === void 0) {
-        diagnostics.errors.push({
-          path,
-          code: "missing-duration",
-          message: `output anchor at:"${anchor.at}" needs a durationS`
-        });
-        fatal = true;
-        return null;
-      }
-      if (anchor.at === "start") return { outStart: 0, outEnd: Math.min(d, outputDurationS) };
-      return { outStart: Math.max(0, outputDurationS - d), outEnd: outputDurationS };
-    }
-    const targetEnd = itemOutEnd.get(anchor.at.after);
-    if (targetEnd === void 0) {
-      diagnostics.errors.push({
-        path,
-        code: "after-unresolved",
-        message: `after:"${anchor.at.after}" could not be resolved to an output time (missing, cyclic, or dropped target)`
-      });
-      fatal = true;
-      return null;
-    }
-    if (d === void 0) {
-      diagnostics.errors.push({
-        path,
-        code: "missing-duration",
-        message: `output anchor after:"${anchor.at.after}" needs a durationS`
-      });
-      fatal = true;
-      return null;
-    }
-    const outStart = Math.min(targetEnd, outputDurationS);
-    return { outStart, outEnd: Math.min(outStart + d, outputDurationS) };
-  }
-  const events = [];
-  const pending = [
-    ...doc.overlays.map((item, i) => ({ kind: "overlay", item, path: `overlays[${i}]` })),
-    ...doc.audio.map((item, i) => ({ kind: "audio", item, path: `audio[${i}]` }))
-  ];
-  const emitOverlay = (item, outStart, outEnd) => {
-    const overlay = {
-      kind: item.kind,
-      layout: item.layout,
-      style: item.style
-    };
-    if (item.text !== void 0) overlay.text = item.text;
-    if (item.asset !== void 0) overlay.asset = item.asset;
-    if (item.enter !== void 0) overlay.enter = item.enter;
-    if (item.exit !== void 0) overlay.exit = item.exit;
-    if (item.size !== void 0) overlay.size = item.size;
-    if (item.z !== void 0) overlay.z = item.z;
-    events.push({ kind: "overlay", itemId: item.id, outStart: r3(outStart), outEnd: r3(outEnd), overlay });
-    itemOutEnd.set(item.id, r3(outEnd));
-  };
-  const emitAudio = (item, outStart, outEnd) => {
-    const audio = {
-      kind: item.kind,
-      asset: item.asset,
-      gainDb: item.gainDb,
-      duckToSpeech: item.duckToSpeech
-    };
-    if (item.fadeOutS !== void 0) audio.fadeOutS = item.fadeOutS;
-    events.push({ kind: "audio", itemId: item.id, outStart: r3(outStart), outEnd: r3(outEnd), audio });
-    itemOutEnd.set(item.id, r3(outEnd));
-  };
-  const resolvePending = (p, deferOk) => {
-    const { item, path } = p;
-    const anchor = item.anchor;
-    if (anchor.type === "output") {
-      if (typeof anchor.at !== "string" && !itemOutEnd.has(anchor.at.after)) {
-        if (diagnostics.dropped.includes(anchor.at.after)) {
-          dropItem(item.id, path, `"${item.id}" was dropped: its after:"${anchor.at.after}" target was dropped`);
-          return true;
-        }
-        if (deferOk) return false;
-        diagnostics.errors.push({
-          path,
-          code: "after-unresolved",
-          message: `after:"${anchor.at.after}" could not be resolved to an output time (missing or cyclic target)`
-        });
-        fatal = true;
-        return true;
-      }
-      const itemDur2 = p.kind === "overlay" ? p.item.durationS : void 0;
-      const span = resolveOutputSpan(anchor, itemDur2, path);
-      if (!span) return true;
-      if (p.kind === "overlay") emitOverlay(p.item, span.outStart, span.outEnd);
-      else emitAudio(p.item, span.outStart, span.outEnd);
-      return true;
-    }
-    const src = sourceSpanFor(item, path, true);
-    if (!src) {
-      fatal = true;
-      return true;
-    }
-    let { a, b } = src;
-    const itemDur = p.kind === "overlay" ? p.item.durationS : void 0;
-    if (itemDur !== void 0) b = a + itemDur;
-    if (b - a <= EPS3) {
-      diagnostics.errors.push({
-        path,
-        code: "missing-duration",
-        message: `"${item.id}" resolves to a zero-length span; give it a durationS or a wider anchor`
-      });
-      fatal = true;
-      return true;
-    }
-    const m = mapSpan(segments, src.source, a, b);
-    const onCut = p.kind === "overlay" ? p.item.onCut : "clip";
-    if (m.covered <= EPS3) {
-      if (onCut === "error") {
-        diagnostics.errors.push({
-          path,
-          code: "on-cut-error",
-          message: `"${item.id}" spans [${a}, ${b}]s of source "${src.source}" which is entirely removed by the cut`
-        });
-        fatal = true;
-      } else {
-        dropItem(item.id, path, `"${item.id}" was dropped: its span [${a}, ${b}]s is entirely outside the kept ranges`);
-      }
-      return true;
-    }
-    if (m.covered < b - a - EPS3) {
-      if (onCut === "error") {
-        diagnostics.errors.push({
-          path,
-          code: "on-cut-error",
-          message: `"${item.id}" is only partially inside the kept ranges (onCut:"error")`
-        });
-        fatal = true;
-        return true;
-      }
-      if (onCut === "drop") {
-        dropItem(item.id, path, `"${item.id}" was dropped: its span is only partially inside the kept ranges (onCut:"drop")`);
-        return true;
-      }
-    }
-    if (p.kind === "overlay") emitOverlay(p.item, m.outStart, m.outEnd);
-    else emitAudio(p.item, m.outStart, m.outEnd);
-    return true;
-  };
-  let queue = pending;
-  for (let pass = 0; pass < pending.length + 1 && queue.length > 0; pass++) {
-    const next = [];
-    for (const p of queue) {
-      if (!resolvePending(p, true)) next.push(p);
-    }
-    if (next.length === queue.length) {
-      for (const p of next) resolvePending(p, false);
-      queue = [];
-      break;
-    }
-    queue = next;
-  }
-  if (doc.captions.enabled) {
-    deriveCaptionCues(doc, segments, streams, events, diagnostics, resolveWords, () => {
-      fatal = true;
-    });
-  }
-  if (diagnostics.errors.length > 0 || fatal) {
-    return { ok: false, plan: null, legacyEdl: null, diagnostics, uses };
-  }
-  const legacyRanges = tightened.map(({ range }) => range);
-  const legacyEdl = {
-    version: 1,
-    sources: Object.fromEntries(Object.entries(doc.sources).map(([k, v]) => [k, v.path])),
-    // The declarative {preset, intensity?} grade belongs to the composition
-    // path (data-color-grading); the ffmpeg EDL only understands strings.
-    grade: typeof doc.settings.grade === "string" ? doc.settings.grade : "none",
-    ranges: legacyRanges,
-    overlays: [],
-    total_duration_s: pyRound(
-      legacyRanges.reduce((acc, r) => acc + (Number(r.end) - Number(r.start)), 0),
-      2
-    )
-  };
-  if (runDesilence) legacyEdl.desilenced = true;
-  events.sort((x, y) => x.outStart - y.outStart);
-  const plan = {
-    version: 1,
-    fromTimeline: doc.id,
-    timelineHash: timelineHash(doc),
-    outputDurationS,
-    segments,
-    events,
-    uses,
-    boundaries: cutBoundaries(legacyRanges)
-  };
-  return { ok: true, plan, legacyEdl, diagnostics, uses };
-}
-var SENTENCE_END_RE = /[.?!]["'”’»)\]׳״]*$/u;
-var SECONDARY_PUNCT_RE = /[,;:—-]["'”’»)\]׳״]*$/u;
-function packPhrase(phrase, maxWords) {
-  const L = phrase.length;
-  if (L <= maxWords) return [phrase];
-  const k = Math.ceil(L / maxWords);
-  const base = Math.floor(L / k);
-  const rem = L % k;
-  const targets = [];
-  for (let i = 0; i < k; i++) targets.push(i < rem ? base + 1 : base);
-  const minSize = Math.min(2, base);
-  const splits = [];
-  let prev = 0;
-  let even = 0;
-  for (let i = 1; i < k; i++) {
-    even += targets[i - 1];
-    const cuesLeft = k - i;
-    let best = -1;
-    let bestKey = null;
-    for (const c of [even - 1, even, even + 1]) {
-      if (c <= prev || c >= L) continue;
-      const size = c - prev;
-      if (size < minSize || size > maxWords) continue;
-      const remaining = L - c;
-      if (remaining < cuesLeft * minSize || remaining > cuesLeft * maxWords) continue;
-      const punct = SECONDARY_PUNCT_RE.test(phrase[c - 1].text) ? 1 : 0;
-      const gap = pyRound(phrase[c].start - phrase[c - 1].end, 3);
-      const key = [punct, gap, -Math.abs(c - even), -c];
-      if (bestKey === null || key[0] > bestKey[0] || key[0] === bestKey[0] && (key[1] > bestKey[1] || key[1] === bestKey[1] && (key[2] > bestKey[2] || key[2] === bestKey[2] && key[3] > bestKey[3]))) {
-        best = c;
-        bestKey = key;
-      }
-    }
-    if (best < 0) best = Math.min(Math.max(even, prev + 1), L - cuesLeft);
-    splits.push(best);
-    prev = best;
-  }
-  const cues = [];
-  let at = 0;
-  for (const s of [...splits, L]) {
-    cues.push(phrase.slice(at, s));
-    at = s;
-  }
-  return cues;
-}
-function deriveCaptionCues(doc, segments, streams, events, diagnostics, resolveWords, markFatal) {
-  const overrides = [];
-  for (let i = 0; i < doc.captions.overrides.length; i++) {
-    const o = doc.captions.overrides[i];
-    const span = resolveWords(o.anchor, `captions.overrides[${i}].anchor`);
-    if (!span) {
-      markFatal();
-      continue;
-    }
-    const ro = { id: o.id, op: o.op, source: o.anchor.source, ...span };
-    if (o.text !== void 0) ro.text = o.text;
-    if (o.color !== void 0) ro.color = o.color;
-    if (o.emphasis !== void 0) ro.emphasis = o.emphasis;
-    overrides.push(ro);
-  }
-  const TOL = 1e-3;
-  const covers = (o, source, w) => o.source === source && w.start >= o.start - TOL && w.end <= o.end + TOL;
-  const overrideFor = (source, w) => overrides.find((o) => o.op !== "style" && covers(o, source, w));
-  const styleFor = (source, w) => overrides.find((o) => o.op === "style" && covers(o, source, w));
-  const style = doc.captions.style;
-  const maxWords = style.maxWords ?? CAPTION_STYLE_DEFAULTS.maxWords;
-  const gapBreakS = style.gapBreakS ?? CAPTION_STYLE_DEFAULTS.gapBreakS;
-  const leadS = style.leadS ?? CAPTION_STYLE_DEFAULTS.leadS;
-  const holdS = style.holdS ?? CAPTION_STYLE_DEFAULTS.holdS;
-  const karaoke = style.karaoke === true;
-  const wordByWord = doc.captions.preset === "opus-karaoke";
-  const emittedReplacements = /* @__PURE__ */ new Set();
-  for (const seg of segments) {
-    const stream = streams[seg.source];
-    if (!stream) {
-      diagnostics.warnings.push({
-        path: "captions",
-        code: "no-transcript",
-        message: `captions are enabled but source "${seg.source}" has no transcript; no cues derived for it`
-      });
-      continue;
-    }
-    const rawCues = [];
-    let group = [];
-    let groupBreakAfter = false;
-    const flush = () => {
-      if (group.length === 0) return;
-      const chunks = wordByWord ? [group] : packPhrase(group, maxWords);
-      chunks.forEach((words, ci) => {
-        const cue = {
-          start: words[0].start,
-          end: words[words.length - 1].end,
-          words,
-          endCap: seg.outEnd
-        };
-        if (groupBreakAfter && ci === chunks.length - 1) cue.lineBreakAfter = true;
-        rawCues.push(cue);
-      });
-      group = [];
-      groupBreakAfter = false;
-    };
-    for (const w of stream) {
-      if (w.end <= seg.srcStart || w.start >= seg.srcEnd) continue;
-      if (!w.text) continue;
-      const ov = overrideFor(seg.source, w);
-      if (ov?.op === "hide") continue;
-      if (ov?.op === "replace-text") {
-        flush();
-        if (emittedReplacements.has(ov.id)) continue;
-        emittedReplacements.add(ov.id);
-        const m = mapSpan(segments, ov.source, Math.max(ov.start, seg.srcStart), ov.end);
-        if (m.covered <= 0) continue;
-        rawCues.push({
-          start: m.outStart,
-          end: m.outEnd,
-          words: [{ start: m.outStart, end: m.outEnd, text: ov.text ?? "" }],
-          itemId: ov.id,
-          endCap: Math.max(seg.outEnd, m.outEnd)
-        });
-        continue;
-      }
-      const localStart = Math.max(w.start, seg.srcStart);
-      const localEnd = Math.min(w.end, seg.srcEnd);
-      const outStart = seg.outStart + (localStart - seg.srcStart);
-      const outEnd = seg.outStart + (localEnd - seg.srcStart);
-      if (group.length > 0) {
-        const prev = group[group.length - 1];
-        if (outStart - prev.end > gapBreakS || SENTENCE_END_RE.test(prev.text)) {
-          flush();
-        }
-      }
-      const rw = { start: outStart, end: outEnd, text: w.text };
-      const styleOv = styleFor(seg.source, w);
-      if (styleOv?.color !== void 0) rw.color = styleOv.color;
-      if (styleOv?.emphasis !== void 0) rw.emphasis = styleOv.emphasis;
-      group.push(rw);
-      const brk = overrides.find(
-        (o) => o.op === "break-line" && o.source === seg.source && Math.abs(w.end - o.end) <= 0.05 && w.start >= o.start - TOL
-      );
-      if (brk) {
-        groupBreakAfter = true;
-        flush();
-      } else if (wordByWord) {
-        flush();
-      }
-    }
-    flush();
-    let floor = Math.max(seg.outStart, 0);
-    for (let i = 0; i < rawCues.length; i++) {
-      const cue = rawCues[i];
-      const displayStart = Math.max(cue.start - leadS, Math.min(floor, cue.start));
-      const capped = Math.min(cue.end + holdS, cue.endCap);
-      const next = rawCues[i + 1];
-      const displayEnd = next ? Math.min(Math.max(next.start - leadS, cue.end), capped) : capped;
-      floor = displayEnd;
-      const outStart = pyRound(displayStart, 3);
-      const event = {
-        kind: "caption-cue",
-        outStart,
-        outEnd: pyRound(displayEnd, 3),
-        words: cue.words.map((rw) => {
-          const word = {
-            t: pyRound(rw.start - displayStart, 3),
-            d: pyRound(rw.end - rw.start, 3),
-            text: rw.text
-          };
-          if (rw.color !== void 0) word.color = rw.color;
-          if (rw.emphasis !== void 0) word.emphasis = rw.emphasis;
-          return word;
-        })
-      };
-      if (karaoke) event.karaoke = true;
-      if (cue.lineBreakAfter) event.lineBreakAfter = true;
-      if (cue.itemId !== void 0) event.itemId = cue.itemId;
-      events.push(event);
-    }
-  }
-}
-
-// src/timeline-v2/edl-lift.ts
-import { randomUUID } from "crypto";
-function timelineFromEdl(edl, opts = {}) {
-  const sources = {};
-  for (const [name, path] of Object.entries(edl.sources ?? {})) {
-    sources[name] = { path };
-    const dur2 = opts.sourceDurations?.[name];
-    if (dur2 !== void 0) sources[name].durationS = dur2;
-    const hash = opts.transcriptHashes?.[name];
-    if (hash !== void 0) sources[name].transcriptHash = hash;
-  }
-  const ranges = (edl.ranges ?? []).map((r, i) => {
-    const out = {
-      id: `rng_${i + 1}`,
-      source: r.source,
-      start: Number(r.start),
-      end: Number(r.end),
-      provenance: { round: null, changeId: null, actor: "agent" }
-    };
-    if (r.beat !== void 0) out.beat = r.beat;
-    if (r.quote !== void 0) out.quote = r.quote;
-    if (r.reason !== void 0) out.reason = r.reason;
-    if (r.grade !== void 0) out.grade = r.grade;
-    return out;
-  });
-  return {
-    version: 2,
-    id: opts.id ?? `tl_${randomUUID()}`,
-    sources,
-    settings: {
-      canvas: { w: 1080, h: 1920 },
-      grade: edl.grade ?? "none",
-      loudnorm: true
-    },
-    cut: { ranges },
-    captions: { enabled: false, preset: "grouped", style: {}, overrides: [] },
-    zooms: [],
-    overlays: [],
-    audio: []
-  };
-}
-
-// src/timeline-v2/compose.ts
-var COMPOSE_WIDTH = 1080;
-var COMPOSE_HEIGHT = 1920;
-var COMPOSE_ENTRY = "index.html";
-var COMPOSE_VIDEO_SRC = "media/source.mp4";
-var COMPOSE_AUDIO_SRC = "media/audio.m4a";
-var COMPOSE_ASSET_PREFIX = "media/";
-var COMPOSE_GSAP_SRC = "https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js";
-var STICKER_DEFAULT_W = 0.25;
-var IMAGE_DEFAULT_W = 0.5;
-function isImgOverlay(ev) {
-  return ev.kind === "overlay" && ev.overlay !== void 0 && (ev.overlay.kind === "image" || ev.overlay.kind === "sticker") && typeof ev.overlay.asset?.ref === "string";
-}
-function composeCounts(plan) {
-  const events = plan.events ?? [];
-  let cues = 0;
-  let overlays = 0;
-  for (const ev of events) {
-    if (ev.kind === "caption-cue") {
-      const text = (ev.words ?? []).map((w) => w.text).join(" ").trim();
-      if (text) cues++;
-    } else if (ev.kind === "overlay" && ev.overlay && typeof ev.overlay.text === "string" && (ev.overlay.kind === "title-card" || ev.overlay.kind === "text")) {
-      overlays++;
-    } else if (isImgOverlay(ev)) {
-      overlays++;
-    }
-  }
-  const zooms = plan.segments.reduce(
-    (n, s) => n + (s.videoOps ?? []).filter((op) => op.kind === "zoom").length,
-    0
-  );
-  return { segments: plan.segments.length, cues, zooms, overlays };
-}
-function composeHtml(plan, options = {}) {
-  const segments = plan.segments;
-  const events = plan.events ?? [];
-  const src = escAttr(options.videoSrc ?? COMPOSE_VIDEO_SRC);
-  const audioSrc = escAttr(options.audioSrc ?? COMPOSE_AUDIO_SRC);
-  const parts = [];
-  const tweens = [];
-  const totalDuration2 = segments.length ? Math.max(...segments.map((s) => s.outEnd)) : 0;
-  const gradeAttr = options.grade ? ` data-color-grading='${escSquote(
-    JSON.stringify({
-      preset: options.grade.preset,
-      ...options.grade.intensity !== void 0 ? { intensity: options.grade.intensity } : {}
-    })
-  )}'` : "";
-  segments.forEach((seg, i) => {
-    parts.push(
-      `<video id="seg-${i}" class="clip vid" src="${src}" preload="auto" muted playsinline data-start="${num(seg.outStart)}" data-duration="${num(seg.outEnd - seg.outStart)}" data-media-start="${num(seg.srcStart)}" data-track-index="0"${gradeAttr}></video>`
-    );
-  });
-  parts.push(
-    `<audio id="cut-audio" class="clip" src="${audioSrc}" preload="auto" data-start="0" data-duration="${num(totalDuration2)}" data-media-start="0" data-track-index="1" data-volume="1"></audio>`
-  );
-  segments.forEach((seg, i) => {
-    (seg.videoOps ?? []).forEach((op, j) => {
-      if (op.kind !== "zoom") return;
-      const rect = op.rect ?? { x: 0.25, y: 0.25, w: 0.5, h: 0.5 };
-      const cx = ((rect.x + rect.w / 2) * 100).toFixed(1);
-      const cy = ((rect.y + rect.h / 2) * 100).toFixed(1);
-      parts.push(
-        `<video id="zoom-${i}-${j}" class="clip vid" src="${src}" preload="auto" muted playsinline data-start="${num(seg.outStart + op.tIn)}" data-duration="${num(op.tOut - op.tIn)}" data-media-start="${num(seg.srcStart + op.tIn)}" data-track-index="5" style="transform: scale(${op.scale}); transform-origin: ${cx}% ${cy}%"></video>`
-      );
-      if (isRamp(op)) {
-        const from = { scale: op.scale };
-        const to = { scale: op.toScale ?? op.scale };
-        if (op.toRect) {
-          const tr = op.toRect;
-          from.transformOrigin = `${cx}% ${cy}%`;
-          to.transformOrigin = `${((tr.x + tr.w / 2) * 100).toFixed(1)}% ${((tr.y + tr.h / 2) * 100).toFixed(1)}%`;
-        }
-        to.duration = Math.max(0.05, op.tOut - op.tIn);
-        to.ease = rampEase(op.ease);
-        tweens.push(gsapFromTo(`#zoom-${i}-${j}`, from, to, seg.outStart + op.tIn));
-      }
-    });
-  });
-  let cueIdx = 0;
-  let ovIdx = 0;
-  let imgLane = 0;
-  let styledCues = false;
-  let imgOverlays = false;
-  for (const ev of events) {
-    if (ev.kind === "caption-cue") {
-      const words = ev.words ?? [];
-      const text = words.map((w) => w.text).join(" ").trim();
-      if (!text) continue;
-      const idx = cueIdx++;
-      const styled = ev.karaoke === true || words.some((w) => w.color !== void 0 || w.emphasis !== void 0);
-      let inner = escHtml(text);
-      if (styled) {
-        styledCues = true;
-        inner = words.map((w, wi) => {
-          const style = w.color !== void 0 ? ` style="color:${escAttr(w.color)}"` : "";
-          return `<span id="w-${idx}-${wi}" class="wd"${style}>${escHtml(w.text)}</span>`;
-        }).join(" ");
-        words.forEach((w, wi) => {
-          const at = ev.outStart + w.t;
-          const target = `#w-${idx}-${wi}`;
-          if (w.emphasis === "pop") {
-            tweens.push(gsapFromTo(target, { scale: 1 }, { scale: 1.35, duration: 0.3, ease: "back.out(2)" }, at));
-          } else if (w.emphasis === "highlight") {
-            tweens.push(
-              gsapFromTo(
-                target,
-                { backgroundColor: "rgba(255,235,59,0)" },
-                { backgroundColor: "rgba(255,235,59,0.85)", duration: 0.25, ease: "none" },
-                at
-              )
-            );
-          }
-          if (ev.karaoke === true) {
-            const d = Math.min(0.25, Math.max(0.05, w.d));
-            tweens.push(gsapFromTo(target, { opacity: 0.4 }, { opacity: 1, duration: d, ease: "none" }, at));
-          }
-        });
-      }
-      parts.push(
-        `<div id="cue-${idx}" class="clip cue" dir="auto" data-start="${num(ev.outStart)}" data-duration="${num(Math.max(0.05, ev.outEnd - ev.outStart))}" data-track-index="10">${inner}</div>`
-      );
-      continue;
-    }
-    if (ev.kind === "overlay" && isImgOverlay(ev)) {
-      imgOverlays = true;
-      const o = ev.overlay;
-      const idx = ovIdx++;
-      const defaultW = o.kind === "sticker" ? STICKER_DEFAULT_W : IMAGE_DEFAULT_W;
-      const wPx = (o.size?.w ?? defaultW) * COMPOSE_WIDTH;
-      const hPx = o.size?.h !== void 0 ? o.size.h * COMPOSE_HEIGHT : wPx;
-      const left = (o.layout?.x ?? 0.5) * COMPOSE_WIDTH - wPx / 2;
-      const top = (o.layout?.y ?? 0.82) * COMPOSE_HEIGHT - hPx / 2;
-      const zStyle = o.z !== void 0 ? `;z-index:${o.z}` : "";
-      const dur2 = Math.max(0.05, ev.outEnd - ev.outStart);
-      parts.push(
-        `<img id="ov-${idx}" class="clip img" src="${escAttr(COMPOSE_ASSET_PREFIX + o.asset.ref)}" alt="" data-start="${num(ev.outStart)}" data-duration="${num(dur2)}" data-track-index="${30 + imgLane++}" style="left:${num(left)}px;top:${num(top)}px;width:${num(wPx)}px;height:${num(hPx)}px${zStyle}">`
-      );
-      if (o.enter) {
-        const d = Math.min(o.enter.durationS, dur2);
-        const [from, to] = fxVars(o.enter.preset, "enter");
-        tweens.push(gsapFromTo(`#ov-${idx}`, from, { ...to, duration: d }, ev.outStart));
-      }
-      if (o.exit) {
-        const d = Math.min(o.exit.durationS, dur2);
-        const [from, to] = fxVars(o.exit.preset, "exit");
-        tweens.push(gsapFromTo(`#ov-${idx}`, from, { ...to, duration: d }, ev.outEnd - d));
-      }
-      continue;
-    }
-    if (ev.kind === "overlay" && ev.overlay && typeof ev.overlay.text === "string") {
-      const o = ev.overlay;
-      const text = ev.overlay.text;
-      const dur2 = num(Math.max(0.05, ev.outEnd - ev.outStart));
-      if (o.kind === "title-card") {
-        parts.push(
-          `<div id="ov-${ovIdx++}" class="clip card" data-start="${num(ev.outStart)}" data-duration="${dur2}" data-track-index="20"><span>${escHtml(text)}</span></div>`
-        );
-      } else if (o.kind === "text") {
-        const x = ((o.layout?.x ?? 0.5) * 100).toFixed(1);
-        const y = ((o.layout?.y ?? 0.82) * 100).toFixed(1);
-        parts.push(
-          `<div id="ov-${ovIdx++}" class="clip otext" style="left:${x}%;top:${y}%" data-start="${num(ev.outStart)}" data-duration="${dur2}" data-track-index="20">${escHtml(text)}</div>`
-        );
-      }
-    }
-  }
-  const animated = tweens.length > 0;
-  let extraCss = "";
-  if (styledCues) {
-    extraCss += `  .wd { display: inline-block; border-radius: 0.12em; }
-`;
-  }
-  if (imgOverlays) {
-    extraCss += `  .img { inset: auto; object-fit: contain; }
-`;
-  }
-  const gsapTag = animated ? `
-<script src="${COMPOSE_GSAP_SRC}"></script>` : "";
-  const noTimeline = animated ? "" : "data-no-timeline ";
-  const script = animated ? `
-<script>
-window.__timelines = window.__timelines || {};
-const tl = gsap.timeline({ paused: true });
-${tweens.join(
-    "\n"
-  )}
-window.__timelines["root"] = tl;
-</script>` : "";
-  return `<!doctype html>
-<html>
-<head>
-<meta charset="utf-8">${gsapTag}
-<style>
-  html, body { margin: 0; padding: 0; background: #000; }
-  #root { position: relative; width: ${COMPOSE_WIDTH}px; height: ${COMPOSE_HEIGHT}px; overflow: hidden; background: #000; }
-  .clip { position: absolute; inset: 0; }
-  .vid { width: 100%; height: 100%; object-fit: cover; }
-  .cue {
-    top: auto; bottom: 15%; height: auto; inset-inline: 0;
-    text-align: center; color: #fff; font: 600 54px/1.25 -apple-system, "Segoe UI", Arial, sans-serif;
-    text-shadow: 0 2px 12px rgba(0,0,0,.85); padding: 0 60px;
-  }
-  .card {
-    background: rgba(0,0,0,.92); display: flex; align-items: center; justify-content: center;
-    color: #fff; font: 700 72px/1.2 -apple-system, "Segoe UI", Arial, sans-serif;
-    text-align: center; padding: 0 90px;
-  }
-  .otext {
-    inset: auto; transform: translate(-50%, -50%); width: max-content; max-width: 90%;
-    color: #fff; font: 600 48px/1.25 -apple-system, "Segoe UI", Arial, sans-serif;
-    text-shadow: 0 2px 12px rgba(0,0,0,.85); text-align: center;
-  }
-${extraCss}</style>
-</head>
-<body>
-<div id="root" data-composition-id="root" ${noTimeline}data-start="0" data-duration="${num(totalDuration2)}" data-width="${COMPOSE_WIDTH}" data-height="${COMPOSE_HEIGHT}">
-${parts.join("\n")}
-</div>${script}
-</body>
-</html>
-`;
-}
-function isRamp(op) {
-  return op.toRect !== void 0 || op.toScale !== void 0;
-}
-function rampEase(ease) {
-  const i = ease?.in ?? 0;
-  const o = ease?.out ?? 0;
-  if (i > 0 && o > 0) return "power2.inOut";
-  if (i > 0) return "power2.in";
-  if (o > 0) return "power2.out";
-  return "none";
-}
-function gsapFromTo(target, from, to, at) {
-  return `tl.fromTo(${JSON.stringify(target)}, ${tweenVars(from)}, ${tweenVars(to)}, ${num(at)});`;
-}
-function tweenVars(v) {
-  const inner = Object.entries(v).map(([k, val]) => `${k}: ${typeof val === "number" ? num(val) : JSON.stringify(val)}`).join(", ");
-  return `{ ${inner} }`;
-}
-function fxVars(preset, phase) {
-  const P = {
-    "fade:enter": [{ opacity: 0 }, { opacity: 1, ease: "power1.out" }],
-    "fade:exit": [{ opacity: 1 }, { opacity: 0, ease: "power1.in" }],
-    "pop:enter": [{ scale: 0.2, opacity: 0 }, { scale: 1, opacity: 1, ease: "back.out(2)" }],
-    "pop:exit": [{ scale: 1, opacity: 1 }, { scale: 0.2, opacity: 0, ease: "back.in(2)" }],
-    "slide-up:enter": [{ y: 60, opacity: 0 }, { y: 0, opacity: 1, ease: "power2.out" }],
-    "slide-up:exit": [{ y: 0, opacity: 1 }, { y: -60, opacity: 0, ease: "power2.in" }],
-    "slide-down:enter": [{ y: -60, opacity: 0 }, { y: 0, opacity: 1, ease: "power2.out" }],
-    "slide-down:exit": [{ y: 0, opacity: 1 }, { y: 60, opacity: 0, ease: "power2.in" }],
-    "scale-in:enter": [{ scale: 0.6, opacity: 0 }, { scale: 1, opacity: 1, ease: "power2.out" }],
-    "scale-in:exit": [{ scale: 1, opacity: 1 }, { scale: 0.6, opacity: 0, ease: "power2.in" }]
-  };
-  const [from, to] = P[`${preset}:${phase}`];
-  return [{ ...from }, { ...to }];
-}
-function num(x) {
-  return String(Number(x.toFixed(3)));
-}
-function escHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escAttr(s) {
-  return escHtml(s).replace(/"/g, "&quot;");
-}
-function escSquote(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/'/g, "&#39;");
-}
-
-// src/timeline-v2/io.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync10, readdirSync as readdirSync4, writeFileSync as writeFileSync7 } from "fs";
-import { join as join11, resolve as resolve3 } from "path";
-function timelineJsonPath(jobDir) {
-  return join11(jobDir, "timeline.json");
-}
-function planPath(jobDir) {
-  return join11(jobDir, "resolved", "plan.json");
-}
-function diagnosticsPath(jobDir) {
-  return join11(jobDir, "resolved", "diagnostics.json");
-}
-function loadTimeline(jobDir) {
-  const path = timelineJsonPath(jobDir);
-  if (!existsSync8(path)) {
-    return {
-      doc: null,
-      raw: null,
-      errors: [
-        {
-          path: "(file)",
-          code: "missing-file",
-          message: `timeline not found: ${path}`,
-          suggestion: "author timeline.json, or lift an existing edl.json with timelineFromEdl"
-        }
-      ]
-    };
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync10(path, "utf8"));
-  } catch (err) {
-    return {
-      doc: null,
-      raw: null,
-      errors: [
-        {
-          path: "(file)",
-          code: "invalid-json",
-          message: `timeline.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
-        }
-      ]
-    };
-  }
-  const parsed = parseTimeline(raw);
-  return { doc: parsed.doc, errors: parsed.errors, raw };
-}
-function transcriptFileForSource(jobDir, name) {
-  const dir = resolve3(jobDir, "transcripts");
-  const direct = join11(dir, `${name}.json`);
-  if (existsSync8(direct)) return direct;
-  const allJson = existsSync8(dir) ? readdirSync4(dir).filter((f) => f.endsWith(".json")) : [];
-  if (allJson.length === 1) return join11(dir, allJson[0]);
-  return null;
-}
-function sha256File(path) {
-  return "sha256:" + createHash2("sha256").update(readFileSync10(path)).digest("hex");
-}
-async function gatherCompileCtx(jobDir, doc, opts = {}) {
-  const transcripts = {};
-  const transcriptHashes = {};
-  for (const name of Object.keys(doc.sources)) {
-    const file = transcriptFileForSource(jobDir, name);
-    if (!file) continue;
-    try {
-      transcripts[name] = JSON.parse(readFileSync10(file, "utf8"));
-      transcriptHashes[name] = sha256File(file);
-    } catch {
-      transcripts[name] = void 0;
-    }
-  }
-  const ctx = { transcripts, transcriptHashes };
-  const assetsPresent = {};
-  const statRef = (ref) => {
-    if (ref !== void 0 && !(ref in assetsPresent)) {
-      assetsPresent[ref] = existsSync8(resolvePath(ref, jobDir));
-    }
-  };
-  for (const ov of doc.overlays) statRef(ov.asset?.ref);
-  for (const a of doc.audio) statRef(a.asset.ref);
-  if (Object.keys(assetsPresent).length > 0) ctx.assetsPresent = assetsPresent;
-  if (!opts.noDetect) {
-    const dopts = { ...DEFAULT_DESILENCE, ...doc.settings.desilence ?? {} };
-    const silencesBySource = {};
-    for (const [name, src] of Object.entries(doc.sources)) {
-      const srcPath = resolvePath(src.path, jobDir);
-      const dur2 = src.durationS ?? await mediaDuration(srcPath);
-      silencesBySource[name] = await detectSilences(srcPath, dopts.noiseDb, dopts.minSilence, dur2);
-    }
-    ctx.silencesBySource = silencesBySource;
-  }
-  return ctx;
-}
-function writeCompileArtifacts(jobDir, result) {
-  const dir = join11(jobDir, "resolved");
-  mkdirSync4(dir, { recursive: true });
-  const written = { diagnostics: diagnosticsPath(jobDir) };
-  writeFileSync7(written.diagnostics, JSON.stringify(result.diagnostics, null, 2) + "\n", "utf8");
-  if (result.ok && result.plan) {
-    written.plan = planPath(jobDir);
-    writeFileSync7(written.plan, JSON.stringify(result.plan, null, 2) + "\n", "utf8");
-  }
-  if (result.ok && result.legacyEdl) {
-    written.edl = join11(jobDir, "edl.json");
-    writeFileSync7(written.edl, JSON.stringify(result.legacyEdl, null, 2) + "\n", "utf8");
-  }
-  return written;
-}
-function updateCaptionsBlock(jobDir, preset) {
-  const path = timelineJsonPath(jobDir);
-  if (!existsSync8(path)) throw new Error(`timeline not found: ${path}`);
-  const raw = JSON.parse(readFileSync10(path, "utf8"));
-  const captions = raw.captions !== null && typeof raw.captions === "object" ? raw.captions : {};
-  captions.enabled = true;
-  captions.preset = preset;
-  raw.captions = captions;
-  writeFileSync7(path, JSON.stringify(raw, null, 2) + "\n", "utf8");
-  return { raw };
-}
-function formatDiagnostics(d) {
-  const lines = [];
-  for (const e of d.errors) lines.push(`  [error] ${e.path}: ${e.message}${e.suggestion ? ` (${e.suggestion})` : ""}`);
-  for (const w of d.warnings) lines.push(`  [warn]  ${w.path}: ${w.message}`);
-  if (d.dropped.length > 0) lines.push(`  dropped: ${d.dropped.join(", ")}`);
-  return lines;
-}
-
-export {
-  configDir,
-  configEnvPath,
-  loadApiKey,
-  ensureVerticalMaster,
-  transcribeOne,
-  screenTakes,
-  packTranscripts,
-  PRESETS,
-  getPreset,
-  decideGradeFilter,
-  autoGradeForClip,
-  render,
-  computeEnvelope,
-  timelineView,
-  loadWords,
-  writeWordDump,
-  writeCoverage,
-  writeTranscriptArtifacts,
-  ensureTranscribed,
-  edlPath,
-  readEdl,
-  cutBoundaries,
-  writeBoundaries,
-  generateQcImages,
-  writeWarningsFromReview,
-  artifactPaths,
-  writeAgentManifest,
-  statusPayload,
-  duplicatedSpans,
-  duplicatedPhrases,
-  duplicatedPhrase,
-  straddlingGap,
-  verify,
-  DEFAULT_DESILENCE,
-  silenceDetectArgs,
-  parseSilenceDetect,
-  tightenRange,
-  tightenRanges,
-  loadWordsBySource,
-  detectSilences,
-  desilenceEdl,
-  learnedEditingGuardrails,
-  agentizePrompt,
-  writeVideoEditingPrompt,
-  writeSilencePrompt,
-  timelineV2Schema,
-  parseTimeline,
-  validateTimeline,
-  CAPABILITIES,
-  usesFromDoc,
-  checkCapabilities,
-  normalizeToken,
-  normalizePhrase,
-  wordStream,
-  findPhrase,
-  fuzzySuggestions,
-  resolvePhrase,
-  timelineHash,
-  compileTimeline,
-  timelineFromEdl,
-  COMPOSE_WIDTH,
-  COMPOSE_HEIGHT,
-  COMPOSE_ENTRY,
-  COMPOSE_VIDEO_SRC,
-  COMPOSE_AUDIO_SRC,
-  composeCounts,
-  composeHtml,
-  timelineJsonPath,
-  planPath,
-  diagnosticsPath,
-  loadTimeline,
-  transcriptFileForSource,
-  sha256File,
-  gatherCompileCtx,
-  writeCompileArtifacts,
-  updateCaptionsBlock,
-  formatDiagnostics
-};