vibemovie 0.1.1 → 0.2.1

package/dist/chunk-LOSCKRIB.js

@@ -0,0 +1,1669 @@
+// src/index.ts
+import { createCascade, createConsentLedger, makeEvent, notify as vibeCoreNotify } from "@pooriaarab/vibe-core";
+import { writeFile } from "fs/promises";
+
+// src/scenes.ts
+var RATIOS = ["16:9", "9:16", "1:1"];
+var TEMPLATES = ["documentary", "speedrun", "meme"];
+var MAX_TASK_ROWS = 5;
+var MAX_DIFF_FILES = 4;
+var MAX_TERM_LINES = 5;
+var PACING = {
+  documentary: { title: 4200, tasks: 4200, diff: 4200, terminal: 4600, merge: 4600, end: 3400 },
+  speedrun: { title: 2500, tasks: 2500, diff: 2500, terminal: 2800, merge: 2800, end: 2200 },
+  meme: { title: 3600, tasks: 3600, diff: 3600, terminal: 3900, merge: 3900, end: 3e3 }
+};
+var TRANSITIONS = {
+  title: "fade",
+  tasks: "slide",
+  diff: "scale",
+  terminal: "rise",
+  merge: "fade",
+  end: "fade"
+};
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function str(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v : null;
+}
+function strArr(v) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.length > 0) : [];
+}
+function firstStr(payload, keys) {
+  for (const k of keys) {
+    const v = str(payload[k]);
+    if (v !== null) return v;
+  }
+  return null;
+}
+function firstNum(payload, keys) {
+  for (const k of keys) {
+    const v = num(payload[k]);
+    if (v !== null) return v;
+  }
+  return null;
+}
+function normalize(events) {
+  const out = [];
+  for (const e of events) {
+    if (!isRecord(e)) continue;
+    const kind = str(e.kind) ?? str(e.type) ?? "event";
+    let ts = 0;
+    if (num(e.ts) !== null) ts = num(e.ts);
+    else if (typeof e.timestamp === "number" && Number.isFinite(e.timestamp)) ts = e.timestamp;
+    else if (typeof e.timestamp === "string") {
+      const parsed = Date.parse(e.timestamp);
+      if (!Number.isNaN(parsed)) ts = parsed;
+    }
+    out.push({
+      kind,
+      ts,
+      agent: str(e.agent),
+      cwd: str(e.cwd),
+      payload: isRecord(e.payload) ? e.payload : {}
+    });
+  }
+  return out.sort((a, b) => a.ts - b.ts);
+}
+function basename(p) {
+  const parts = p.split(/[\\/]/).filter((s) => s.length > 0);
+  return parts.length > 0 ? parts[parts.length - 1] : p;
+}
+function formatMinutes(totalMinutes) {
+  const h = Math.floor(totalMinutes / 60);
+  const m = totalMinutes % 60;
+  return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+var TASK_KINDS = /* @__PURE__ */ new Set(["task-done", "task", "todo-done", "commit", "milestone"]);
+var PR_OPEN_KINDS = /* @__PURE__ */ new Set(["pr-opened", "pull-request", "pull-request-opened"]);
+var PR_MERGE_KINDS = /* @__PURE__ */ new Set(["pr-merged", "pull-request-merged", "merge"]);
+function collectTasks(events) {
+  const rows = [];
+  for (const e of events) {
+    if (!TASK_KINDS.has(e.kind)) continue;
+    const label = firstStr(e.payload, ["label", "task", "title", "summary", "message"]) ?? `Task ${rows.length + 1}`;
+    const durationMin = firstNum(e.payload, ["durationMin", "duration_min", "minutes"]);
+    rows.push(durationMin !== null ? { label, durationMin } : { label });
+  }
+  return rows;
+}
+function collectDiff(events) {
+  const files = /* @__PURE__ */ new Set();
+  let additions = 0;
+  let deletions = 0;
+  let filesChanged = 0;
+  for (const e of events) {
+    for (const f of strArr(e.payload["files"])) files.add(f);
+    additions += firstNum(e.payload, ["additions", "adds", "added"]) ?? 0;
+    deletions += firstNum(e.payload, ["deletions", "dels", "removed"]) ?? 0;
+    const fc = firstNum(e.payload, ["filesChanged", "files_changed"]);
+    if (fc !== null) filesChanged = Math.max(filesChanged, fc);
+  }
+  if (filesChanged === 0) filesChanged = files.size;
+  return { filesChanged, additions, deletions, files: [...files].slice(0, MAX_DIFF_FILES) };
+}
+function collectPr(events) {
+  let opened = null;
+  let merged = null;
+  for (const e of events) {
+    if (PR_MERGE_KINDS.has(e.kind) && merged === null) merged = e;
+    if (PR_OPEN_KINDS.has(e.kind) && opened === null) opened = e;
+  }
+  const source = merged ?? opened;
+  if (source === null) return null;
+  return {
+    pr: firstNum(source.payload, ["pr", "number", "prNumber", "pr_number"]),
+    branch: firstStr(source.payload, ["branch", "base", "into"]) ?? "main",
+    reviewers: firstNum(source.payload, ["reviewers", "reviewedBy", "approvals"]),
+    merged: merged !== null
+  };
+}
+function collectTermLines(events, pr) {
+  const lines = [];
+  const push = (text, cls = "") => {
+    if (lines.length < MAX_TERM_LINES) lines.push({ text, cls });
+  };
+  for (const e of events) {
+    if (lines.length >= MAX_TERM_LINES) break;
+    if (e.kind === "tests-pass") {
+      const passed = firstNum(e.payload, ["passed", "count", "tests"]);
+      push("$ npm test");
+      push(passed !== null ? `\u2713 ${passed} passed` : "\u2713 tests passed", "ok");
+    } else if (e.kind === "tests-fail") {
+      const failed = firstNum(e.payload, ["failed", "count"]);
+      push("$ npm test");
+      push(failed !== null ? `\u2717 ${failed} failing` : "\u2717 tests failing");
+    } else if (e.kind === "error") {
+      const msg = firstStr(e.payload, ["message", "error", "label"]) ?? "something broke";
+      push(`\u2717 ${msg}`);
+    }
+  }
+  if (pr !== null && lines.length <= MAX_TERM_LINES - 2) {
+    push("$ git push");
+    push(`\u2192 pushed to origin/${pr.branch}`, "ok");
+  }
+  if (lines.length === 0 && events.length > 0) {
+    push("$ vibemovie render");
+    push(`\u2713 ${plural(events.length, "event")} recapped`, "ok");
+  }
+  return lines;
+}
+function captions(template, stats) {
+  const { totalMinutes, tasks, diff, pr } = stats;
+  const dur = formatMinutes(totalMinutes);
+  const prWord = pr !== null ? pr.merged ? "merged" : "opened" : "";
+  const prNum = pr?.pr !== null && pr?.pr !== void 0 ? `#${pr.pr} ` : "";
+  if (template === "speedrun") {
+    return {
+      title: totalMinutes > 0 ? `${dur}. go.` : "a session. go.",
+      tasks: `${plural(tasks, "task")}. done.`,
+      diff: `+${diff.additions} \u2212${diff.deletions} across ${plural(diff.filesChanged, "file")}.`,
+      terminal: "green. ship.",
+      merge: `${prNum}${prWord}. next.`,
+      end: "gg."
+    };
+  }
+  if (template === "meme") {
+    return {
+      title: "touch grass? never heard of it.",
+      tasks: `${plural(tasks, "task")} speedrun any%`,
+      diff: "number go up",
+      terminal: "it compiles. ship it.",
+      merge: pr !== null && pr.merged ? "LGTM said the reviewer" : "CI roulette champion",
+      end: "same time tomorrow?"
+    };
+  }
+  return {
+    title: totalMinutes > 0 ? `${dur} in the flow.` : "A session worth replaying.",
+    tasks: `${plural(tasks, "task")} landed, clean.`,
+    diff: diff.additions >= diff.deletions ? `${plural(diff.filesChanged, "file")} touched \u2014 more added than removed.` : `${plural(diff.filesChanged, "file")} touched \u2014 more removed than added.`,
+    terminal: stats.hasTests ? "Tests green. Shipped." : "The commands tell the story.",
+    merge: pr !== null ? `Pull request ${prNum}${prWord}.` : "",
+    end: "That's the session. Run it back."
+  };
+}
+function scene(kind, template, caption, data) {
+  return {
+    id: `scene-${kind}`,
+    kind,
+    transition: TRANSITIONS[kind],
+    duration: PACING[template][kind],
+    caption,
+    data
+  };
+}
+function buildScenes(events, opts = {}) {
+  const template = opts.template ?? "documentary";
+  const norm = normalize(events);
+  const first = norm[0];
+  const last = norm[norm.length - 1];
+  const totalMinutes = first !== void 0 && last !== void 0 && last.ts > first.ts ? Math.round((last.ts - first.ts) / 6e4) : 0;
+  const sessionName = opts.title ?? (first?.cwd != null ? basename(first.cwd) : "vibe session");
+  const agent = first?.agent ?? "agentic";
+  const tasks = collectTasks(norm);
+  const diff = collectDiff(norm);
+  const pr = collectPr(norm);
+  const termLines = collectTermLines(norm, pr);
+  const hasTests = norm.some((e) => e.kind === "tests-pass");
+  const caps = captions(template, { totalMinutes, tasks: tasks.length, diff, pr, hasTests });
+  const scenes = [
+    scene("title", template, caps.title, {
+      sessionName,
+      totalMinutes,
+      subtitle: `${agent} coding session \xB7 recapped on-device`
+    })
+  ];
+  if (tasks.length > 0) {
+    scenes.push(
+      scene("tasks", template, caps.tasks, { total: tasks.length, tasks: tasks.slice(0, MAX_TASK_ROWS) })
+    );
+  }
+  if (diff.filesChanged > 0 || diff.additions + diff.deletions > 0) {
+    scenes.push(scene("diff", template, caps.diff, diff));
+  }
+  if (termLines.length > 0) {
+    scenes.push(scene("terminal", template, caps.terminal, { lines: termLines }));
+  }
+  if (pr !== null) {
+    scenes.push(scene("merge", template, caps.merge, pr));
+  }
+  scenes.push(scene("end", template, caps.end, { tagline: "generated on-device \xB7 hyperframes" }));
+  return scenes;
+}
+
+// src/hyperframes.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function embedJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+var TICK_SVG = '<svg class="tick" width="20" height="20" viewBox="0 0 20 20" fill="none"><circle cx="10" cy="10" r="9" stroke="#3a3024" stroke-width="1.4"/><path d="M5.5 10.2l3 3 6-6.4" stroke="#7fae8a" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" pathLength="1" stroke-dasharray="1" stroke-dashoffset="1"/></svg>';
+function sceneHtml(scene2) {
+  switch (scene2.kind) {
+    case "title": {
+      const d = scene2.data;
+      return `<section class="scene" id="${scene2.id}"><svg class="reel" viewBox="0 0 100 100" fill="none" stroke="currentColor" stroke-width="2"><circle cx="50" cy="50" r="46"/><circle cx="50" cy="20" r="9"/><circle cx="76" cy="65" r="9"/><circle cx="24" cy="65" r="9"/><circle cx="50" cy="50" r="6" fill="currentColor" stroke="none"/></svg><div class="session-title">${escapeHtml(d.sessionName)}</div><div class="session-sub" id="titleCounter">0h 00m</div><div class="session-caption">${escapeHtml(d.subtitle)}</div></section>`;
+    }
+    case "tasks": {
+      const d = scene2.data;
+      const rows = d.tasks.map((t) => {
+        const dur = t.durationMin !== void 0 ? `<span class="dur">${escapeHtml(formatMinutes(t.durationMin))}</span>` : "";
+        return `<div class="task-row">${TICK_SVG}<span class="label">${escapeHtml(t.label)}</span>${dur}</div>`;
+      }).join("");
+      const more = d.total > d.tasks.length ? `<div class="task-more">+${d.total - d.tasks.length} more</div>` : "";
+      return `<section class="scene" id="${scene2.id}"><div class="tasks-head"><b>${d.total}</b> ${d.total === 1 ? "task" : "tasks"} completed</div><div class="task-list">${rows}${more}</div></section>`;
+    }
+    case "diff": {
+      const d = scene2.data;
+      const files = d.files.map((f) => `<div class="f">${escapeHtml(f)}</div>`).join("");
+      const more = d.filesChanged > d.files.length ? `<div class="f">+${d.filesChanged - d.files.length} more</div>` : "";
+      return `<section class="scene" id="${scene2.id}"><div class="diff-head">${d.filesChanged} ${d.filesChanged === 1 ? "file" : "files"} changed</div><div class="diff-bar-wrap"><div class="diff-bar"><div class="add" id="diffAdd"></div><div class="remove" id="diffRemove"></div></div><div class="diff-stats"><span class="plus">+${d.additions}</span><span class="minus">\u2212${d.deletions}</span></div></div><div class="diff-files" id="diffFiles">${files}${more}</div></section>`;
+    }
+    case "terminal": {
+      return `<section class="scene" id="${scene2.id}"><div class="terminal"><div class="terminal-bar"><span></span><span></span><span></span><span class="name">vibe \u2014 zsh</span></div><div class="terminal-body" id="termBody"></div></div></section>`;
+    }
+    case "merge": {
+      const d = scene2.data;
+      const head = d.pr !== null ? `PR #${d.pr} ${d.merged ? "merged" : "opened"}` : `PR ${d.merged ? "merged" : "opened"}`;
+      const sub = `into ${escapeHtml(d.branch)}` + (d.reviewers !== null ? ` \xB7 reviewed by ${d.reviewers}` : "");
+      return `<section class="scene" id="${scene2.id}"><svg class="merge-badge" id="mergeBadge" viewBox="0 0 48 48" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round"><circle cx="14" cy="12" r="4"/><circle cx="14" cy="36" r="4"/><circle cx="34" cy="12" r="4"/><path d="M14 16v12a8 8 0 0 0 8 8h4"/><path d="M34 16v4"/></svg><div class="merge-head">${escapeHtml(head)}</div><div class="merge-sub">${sub}</div><div class="confetti" id="confetti"></div></section>`;
+    }
+    case "end": {
+      const d = scene2.data;
+      return `<section class="scene" id="${scene2.id}"><div class="end-mark">vibe<b>movie</b></div><div class="end-sub">${escapeHtml(d.tagline)}</div><svg class="loop-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M17 2l4 4-4 4"/><path d="M3 12v-2a4 4 0 0 1 4-4h14"/><path d="M7 22l-4-4 4-4"/><path d="M21 12v2a4 4 0 0 1-4 4H3"/></svg></section>`;
+    }
+  }
+}
+function css(ratio) {
+  const screenSizing = ratio === "16:9" ? ".screen{position:relative;aspect-ratio:16/9;overflow:hidden;" : ratio === "9:16" ? ".screen{position:relative;height:min(74vh,760px);width:calc(min(74vh,760px) * 9 / 16);max-width:100%;margin:0 auto;overflow:hidden;" : ".screen{position:relative;height:min(74vh,640px);width:calc(min(74vh,640px));max-width:100%;margin:0 auto;overflow:hidden;";
+  return `
+  :root{
+    --bg: #0a0908; --bg-raised: #14120e; --frame: #050403;
+    --ink: #f2ede1; --ink-dim: #a89e8c; --ink-faint: #6b6255;
+    --gold: #d9a94e; --add: #7fae8a; --remove: #b25a45; --merge: #a084d6;
+    --ease: cubic-bezier(0.16, 1, 0.3, 1); --radius: 14px;
+  }
+  *{ box-sizing: border-box; }
+  html,body{ margin:0; padding:0; min-height:100%; background: var(--bg); color: var(--ink);
+    font-family: -apple-system, "SF Pro Text", "Segoe UI", Roboto, system-ui, sans-serif;
+    -webkit-font-smoothing: antialiased; }
+  body{ padding: 40px 20px 64px; display:flex; justify-content:center; }
+  .stage{ width:100%; max-width: 900px; }
+  .topbar{ display:flex; align-items:baseline; justify-content:space-between; margin-bottom: 22px; flex-wrap: wrap; gap: 10px; }
+  .wordmark{ font-size: 1.35rem; font-weight: 700; letter-spacing: -0.03em; }
+  .wordmark b{ font-weight: 700; color: var(--gold); }
+  .tagline{ display:block; font-size: 0.78rem; color: var(--ink-faint); margin-top: 2px; }
+  .badge-local{ display:inline-flex; align-items:center; gap:7px; font-size: 0.72rem; font-weight: 600;
+    color: var(--ink-dim); background: var(--bg-raised); border: 1px solid #262019;
+    padding: 6px 12px; border-radius: 999px; white-space: nowrap; }
+  .badge-local .dot{ width:7px; height:7px; border-radius:50%; background: #7fc98a; }
+  @media (prefers-reduced-motion: no-preference){
+    .badge-local .dot{ animation: pulse-dot 2.4s var(--ease) infinite; }
+  }
+  @keyframes pulse-dot{ 0%{ box-shadow: 0 0 0 0 rgba(127,201,138,0.45);} 70%{ box-shadow: 0 0 0 6px rgba(127,201,138,0);} 100%{ box-shadow: 0 0 0 0 rgba(127,201,138,0);} }
+  .player{ position: relative; background: var(--frame); border-radius: var(--radius);
+    box-shadow: 0 24px 60px -20px rgba(0,0,0,0.75), 0 2px 0 rgba(255,255,255,0.02) inset;
+    overflow: hidden; border: 1px solid #201a12; }
+  .filmstrip{ height: 12px; background-color: #171009;
+    background-image: radial-gradient(circle 3.2px at 12px 6px, var(--bg) 3.2px, transparent 3.6px);
+    background-size: 24px 12px; background-repeat: repeat-x; }
+  ${screenSizing}
+    background: radial-gradient(120% 100% at 50% 0%, #171008 0%, #0a0705 60%, #050302 100%); }
+  .screen::before{ content:""; position:absolute; inset:0; pointer-events:none; z-index: 5;
+    box-shadow: inset 0 0 90px 20px rgba(0,0,0,0.55); }
+  .scene{ position:absolute; inset:0; display:none; flex-direction:column; align-items:center;
+    justify-content:center; text-align:center; padding: 8% 9%; will-change: transform, opacity; }
+  .scene.is-live{ display:flex; }
+  .reel{ position:absolute; top:8%; right:6%; width: 90px; height: 90px; opacity: .16; }
+  @media (prefers-reduced-motion: no-preference){ .reel{ animation: spin 26s linear infinite; } }
+  @keyframes spin{ to{ transform: rotate(360deg); } }
+  .session-title{ font-size: clamp(1.6rem, 4.4vw, 2.7rem); font-weight: 700; letter-spacing: -0.03em; margin: 0 0 10px; }
+  .session-sub{ font-family: "SF Mono", "Menlo", monospace; font-size: clamp(1rem, 2.6vw, 1.35rem);
+    color: var(--gold); font-weight: 600; letter-spacing: -0.01em; }
+  .session-caption{ margin-top: 14px; font-size: 0.82rem; color: var(--ink-faint); }
+  .tasks-head{ font-size: clamp(1.3rem, 3.4vw, 2rem); font-weight: 700; letter-spacing: -0.03em; margin-bottom: 22px; }
+  .tasks-head b{ color: var(--gold); font-size: 1.25em; }
+  .task-list{ width: min(440px, 84%); display:flex; flex-direction:column; gap: 12px; }
+  .task-row{ display:flex; align-items:center; gap: 12px; text-align:left; padding: 10px 4px; border-bottom: 1px solid #201a12; }
+  .task-row:last-child{ border-bottom: none; }
+  .task-row .tick{ flex: none; }
+  .task-row .label{ flex:1; font-size: 0.92rem; color: var(--ink); }
+  .task-row .dur{ font-family: "SF Mono", Menlo, monospace; font-size: 0.74rem; color: var(--ink-faint); }
+  .task-more{ font-size: 0.8rem; color: var(--ink-faint); text-align:left; padding: 6px 4px 0 32px; }
+  .diff-head{ font-size: clamp(1.3rem, 3.4vw, 2rem); font-weight: 700; letter-spacing: -0.03em; margin-bottom: 20px; }
+  .diff-bar-wrap{ width: min(440px, 84%); }
+  .diff-bar{ height: 14px; border-radius: 7px; overflow:hidden; display:flex; background: #1a140d; }
+  .diff-bar .add{ background: var(--add); height:100%; width:0%; }
+  .diff-bar .remove{ background: var(--remove); height:100%; width:0%; }
+  .diff-stats{ margin-top: 10px; font-family: "SF Mono", Menlo, monospace; font-size: 0.9rem; display:flex; gap: 16px; justify-content:center; }
+  .diff-stats .plus{ color: var(--add); }
+  .diff-stats .minus{ color: var(--remove); }
+  .diff-files{ margin-top: 18px; display:flex; flex-direction:column; gap: 6px; align-items:center; }
+  .diff-files .f{ font-family: "SF Mono", Menlo, monospace; font-size: 0.74rem; color: var(--ink-dim); opacity: 0; transform: translateY(8px); }
+  .terminal{ width: min(460px, 88%); background: #0d0b08; border: 1px solid #241d14; border-radius: 10px;
+    overflow:hidden; text-align:left; box-shadow: 0 14px 34px -16px rgba(0,0,0,0.7); }
+  .terminal-bar{ display:flex; align-items:center; gap:6px; padding: 8px 10px; background: #161109; border-bottom: 1px solid #241d14; }
+  .terminal-bar span{ width:9px; height:9px; border-radius:50%; background:#3a3024; }
+  .terminal-bar .name{ margin-left: 8px; font-size: 0.7rem; color: var(--ink-faint); font-family: "SF Mono", Menlo, monospace; }
+  .terminal-body{ padding: 14px 16px; font-family: "SF Mono", Menlo, monospace; font-size: 0.78rem;
+    line-height: 1.7; min-height: 108px; color: var(--ink-dim); }
+  .terminal-body .ok{ color: var(--add); }
+  .terminal-body .cursor{ display:inline-block; width: 6px; height: 12px; background: var(--gold); vertical-align: -2px; margin-left: 2px; }
+  @media (prefers-reduced-motion: no-preference){ .terminal-body .cursor.blink{ animation: blink 1s steps(1) infinite; } }
+  @keyframes blink{ 50%{ opacity: 0; } }
+  .merge-badge{ width: 74px; height: 74px; margin-bottom: 14px; color: var(--merge); }
+  .merge-head{ font-size: clamp(1.3rem, 3.4vw, 2rem); font-weight:700; letter-spacing:-0.03em; }
+  .merge-sub{ margin-top: 6px; font-size: 0.85rem; color: var(--ink-dim); }
+  .confetti{ position:absolute; inset:0; pointer-events:none; overflow:hidden; }
+  .confetti i{ position:absolute; top:-10%; width: 7px; height: 12px; opacity:0; border-radius: 2px; }
+  .confetti.is-firing i{ animation: fall 1.8s ease-in forwards; }
+  @keyframes fall{ 0%{ opacity: 1; transform: translateY(0) rotate(0deg);} 100%{ opacity: 0; transform: translateY(220px) rotate(300deg);} }
+  .end-mark{ font-size: clamp(1.4rem, 3.6vw, 2.2rem); font-weight:700; letter-spacing:-0.03em; }
+  .end-mark b{ color: var(--gold); }
+  .end-sub{ margin-top: 8px; font-size: 0.8rem; color: var(--ink-faint); }
+  .loop-icon{ width: 26px; height: 26px; margin-top: 16px; color: var(--ink-faint); }
+  @media (prefers-reduced-motion: no-preference){ .loop-icon{ animation: spin 3.5s linear infinite; } }
+  .scene-title{ position:absolute; left: 20px; bottom: 18px; z-index: 6; font-size: 0.72rem; font-weight: 600;
+    letter-spacing: 0.02em; color: var(--ink-dim); background: rgba(5,4,3,0.55); backdrop-filter: blur(6px);
+    padding: 6px 11px; border-radius: 999px; border: 1px solid rgba(255,255,255,0.06);
+    opacity: 0; transform: translateY(6px); transition: opacity .35s var(--ease), transform .35s var(--ease); }
+  .scene-title.is-shown{ opacity: 1; transform: translateY(0); }
+  .captions{ position: relative; z-index: 6; background: var(--bg-raised); border-top: 1px solid #201a12;
+    color: var(--ink); font-size: 0.86rem; padding: 12px 18px; min-height: 20px; text-align:center; }
+  .controls{ display:flex; align-items:center; gap: 12px; padding: 12px 16px;
+    background: var(--bg-raised); border-top: 1px solid #201a12; }
+  .icon-btn{ flex: none; width: 34px; height: 34px; border-radius: 9px; display:flex; align-items:center;
+    justify-content:center; background: #201a12; border: 1px solid #2c2417; color: var(--ink); cursor: pointer;
+    transition: background .16s var(--ease); }
+  .icon-btn:hover{ background: #2c2417; }
+  .icon-btn svg{ width: 15px; height: 15px; }
+  .icon-btn:focus-visible{ outline: 2px solid var(--gold); outline-offset: 2px; }
+  .time{ font-family: "SF Mono", Menlo, monospace; font-size: 0.76rem; color: var(--ink-faint); flex: none; width: 38px; }
+  .time.total{ text-align: right; }
+  .scrubber{ flex: 1; position: relative; height: 22px; display:flex; align-items:center; cursor: pointer; }
+  .scrubber-track{ position:absolute; left:0; right:0; top: 50%; height: 4px; transform: translateY(-50%);
+    background: #241d14; border-radius: 999px; overflow: hidden; }
+  .scrubber-fill{ position:absolute; left:0; top:0; bottom:0; width: 0%; background: var(--gold); border-radius: 999px; }
+  .scrubber-markers{ position:absolute; inset:0; }
+  .scrubber-markers i{ position:absolute; top:50%; width:1px; height: 10px; background: rgba(0,0,0,0.5); transform: translate(0, -50%); }
+  .scrubber-thumb{ position:absolute; top:50%; width: 11px; height:11px; border-radius:50%;
+    background: var(--ink); transform: translate(-50%, -50%); box-shadow: 0 2px 6px rgba(0,0,0,0.5); }
+  .foot{ margin-top: 18px; text-align:center; font-size: 0.74rem; color: var(--ink-faint); }
+  @media (max-width: 560px){ .controls{ flex-wrap: wrap; } }
+`;
+}
+function engineJs(scenesJson) {
+  return `
+(function(){
+"use strict";
+var SCENES = ${scenesJson};
+var offsets = []; var acc = 0; var i;
+for (i = 0; i < SCENES.length; i++) { offsets.push(acc); acc += SCENES[i].duration; }
+var TOTAL = acc;
+
+var els = {};
+for (i = 0; i < SCENES.length; i++) { els[SCENES[i].id] = document.getElementById(SCENES[i].id); }
+
+var sceneTitleEl = document.getElementById('sceneTitle');
+var captionsEl   = document.getElementById('captions');
+var playBtn      = document.getElementById('playBtn');
+var playIcon     = document.getElementById('playIcon');
+var scrubber     = document.getElementById('scrubber');
+var scrubberFill = document.getElementById('scrubberFill');
+var scrubberThumb= document.getElementById('scrubberThumb');
+var scrubberMarkers = document.getElementById('scrubberMarkers');
+var timeCurrent  = document.getElementById('timeCurrent');
+var timeTotal    = document.getElementById('timeTotal');
+
+for (i = 1; i < SCENES.length; i++) {
+  var m = document.createElement('i');
+  m.style.left = (offsets[i] / TOTAL * 100) + '%';
+  scrubberMarkers.appendChild(m);
+}
+
+function fmt(ms){
+  var s = Math.floor(ms/1000);
+  var m = Math.floor(s/60); s = s%60;
+  return m + ':' + (s<10?'0':'') + s;
+}
+timeTotal.textContent = fmt(TOTAL);
+
+function esc(s){
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+function easeOutExpo(x){ return x >= 1 ? 1 : 1 - Math.pow(2, -10*x); }
+function easeOutBack(x){ var c1 = 1.7, c3 = c1+1; return 1 + c3*Math.pow(x-1,3) + c1*Math.pow(x-1,2); }
+function clamp(v,a,b){ return Math.max(a, Math.min(b, v)); }
+
+/* deterministic PRNG so confetti is identical on every play */
+function mulberry32(a){
+  return function(){
+    a |= 0; a = a + 0x6D2B79F5 | 0;
+    var t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var rand = mulberry32(12648430);
+var confettiColors = ['#d9a94e','#7fae8a','#b25a45','#a084d6'];
+function buildConfetti(){
+  var c = document.getElementById('confetti');
+  if (!c) return;
+  c.innerHTML = '';
+  for (var j = 0; j < 16; j++) {
+    var el = document.createElement('i');
+    el.style.left = (8 + rand()*84) + '%';
+    el.style.background = confettiColors[j % confettiColors.length];
+    el.style.animationDelay = (rand()*0.5) + 's';
+    el.style.transform = 'rotate(' + Math.floor(rand()*360) + 'deg)';
+    c.appendChild(el);
+  }
+}
+buildConfetti();
+
+var CPS = 34; /* terminal typing speed, chars per second */
+
+var renderers = {
+  title: function(scene, localT){
+    var el = document.getElementById('titleCounter');
+    var totalMin = Math.round(scene.data.totalMinutes * easeOutExpo(clamp(localT/2400, 0, 1)));
+    var h = Math.floor(totalMin/60), m = totalMin%60;
+    el.textContent = h + 'h ' + (m<10?'0':'') + m + 'm';
+  },
+  tasks: function(scene, localT){
+    var rows = els[scene.id].querySelectorAll('.task-row');
+    for (var j = 0; j < rows.length; j++) {
+      var start = 450 + j*380;
+      var p = easeOutExpo(clamp((localT-start)/420, 0, 1));
+      var row = rows[j];
+      row.style.opacity = p;
+      row.style.transform = 'translateY(' + ((1-p)*14) + 'px)';
+      row.querySelector('.tick path').setAttribute('stroke-dashoffset', String(1-p));
+    }
+  },
+  diff: function(scene, localT){
+    var adds = scene.data.additions, dels = scene.data.deletions;
+    var total = adds + dels;
+    var p = easeOutExpo(clamp((localT-350)/900, 0, 1));
+    document.getElementById('diffAdd').style.width = (p * (total > 0 ? adds/total : 0) * 100) + '%';
+    document.getElementById('diffRemove').style.width = (p * (total > 0 ? dels/total : 0) * 100) + '%';
+    var files = document.getElementById('diffFiles').querySelectorAll('.f');
+    for (var j = 0; j < files.length; j++) {
+      var start = 500 + j*160;
+      var fp = easeOutExpo(clamp((localT-start)/300, 0, 1));
+      files[j].style.opacity = fp;
+      files[j].style.transform = 'translateY(' + ((1-fp)*8) + 'px)';
+    }
+  },
+  terminal: function(scene, localT){
+    var lines = scene.data.lines;
+    var out = '';
+    var t0 = 250;
+    for (var j = 0; j < lines.length; j++) {
+      var elapsed = localT - t0;
+      t0 += (lines[j].text.length / CPS) * 1000 + 260;
+      if (elapsed <= 0) continue;
+      var chars = Math.min(lines[j].text.length, Math.floor(elapsed/1000*CPS));
+      var shown = esc(lines[j].text.slice(0, chars));
+      var typing = chars < lines[j].text.length;
+      var cls = lines[j].cls ? ' class="' + lines[j].cls + '"' : '';
+      out += '<div' + cls + '>' + shown + (typing ? '<span class="cursor blink"></span>' : '') + '</div>';
+    }
+    document.getElementById('termBody').innerHTML = out;
+  },
+  merge: function(scene, localT, justEntered){
+    var p = easeOutBack(clamp(localT/480, 0, 1));
+    var badge = document.getElementById('mergeBadge');
+    badge.style.transform = 'scale(' + Math.max(0,p) + ') rotate(' + ((1-clamp(localT/480,0,1))*-10) + 'deg)';
+    if (justEntered) {
+      var c = document.getElementById('confetti');
+      c.classList.remove('is-firing');
+      void c.offsetWidth;
+      c.classList.add('is-firing');
+    }
+  },
+  end: function(){}
+};
+
+function sceneIndexAt(time){
+  for (var j = SCENES.length-1; j >= 0; j--) { if (time >= offsets[j]) return j; }
+  return 0;
+}
+
+function applyTransition(el, type, localT, dur){
+  var inWin = Math.min(560, dur*0.28);
+  var outWin = Math.min(560, dur*0.28);
+  var opacity = 1, tf = 'none';
+  if (localT < inWin) {
+    var p = easeOutExpo(localT/inWin);
+    if (type==='fade'){ opacity=p; tf = 'scale(' + (0.98+0.02*p) + ')'; }
+    else if (type==='slide'){ opacity=p; tf = 'translateX(' + ((1-p)*44) + 'px)'; }
+    else if (type==='scale'){ opacity=p; tf = 'scale(' + (0.9+0.1*p) + ')'; }
+    else if (type==='rise'){ opacity=p; tf = 'translateY(' + ((1-p)*40) + 'px)'; }
+  } else if (localT > dur-outWin) {
+    var p2 = easeOutExpo((localT-(dur-outWin))/outWin);
+    var q = 1-p2;
+    if (type==='fade'){ opacity=q; tf = 'scale(' + (1-0.02*p2) + ')'; }
+    else if (type==='slide'){ opacity=q; tf = 'translateX(' + (-p2*44) + 'px)'; }
+    else if (type==='scale'){ opacity=q; tf = 'scale(' + (1-0.1*p2) + ')'; }
+    else if (type==='rise'){ opacity=q; tf = 'translateY(' + (-p2*40) + 'px)'; }
+  }
+  el.style.opacity = opacity;
+  el.style.transform = tf;
+}
+
+var isPlaying = true;
+var t = 0;
+var lastSceneIdx = -1;
+var lastFrame = null;
+
+function render(){
+  var idx = sceneIndexAt(t);
+  var scene = SCENES[idx];
+  var localT = t - offsets[idx];
+  var justEntered = idx !== lastSceneIdx;
+
+  for (var j = 0; j < SCENES.length; j++) {
+    var el = els[SCENES[j].id];
+    if (j === idx) {
+      el.classList.add('is-live');
+      applyTransition(el, SCENES[j].transition, localT, SCENES[j].duration);
+    } else {
+      el.classList.remove('is-live');
+    }
+  }
+
+  renderers[scene.kind](scene, localT, justEntered);
+
+  if (justEntered) {
+    sceneTitleEl.textContent = scene.kind.replace(/^\\w/, function(c){ return c.toUpperCase(); });
+    sceneTitleEl.classList.add('is-shown');
+    captionsEl.textContent = scene.caption;
+  }
+  lastSceneIdx = idx;
+
+  var pct = (t/TOTAL*100);
+  scrubberFill.style.width = pct + '%';
+  scrubberThumb.style.left = pct + '%';
+  timeCurrent.textContent = fmt(t);
+}
+
+function loop(ts){
+  if (lastFrame === null) lastFrame = ts;
+  var dt = ts - lastFrame;
+  lastFrame = ts;
+  if (isPlaying) { t += dt; if (t >= TOTAL) t = t % TOTAL; }
+  render();
+  requestAnimationFrame(loop);
+}
+requestAnimationFrame(loop);
+
+function setPlaying(v){
+  isPlaying = v;
+  playBtn.setAttribute('aria-label', v ? 'Pause' : 'Play');
+  playIcon.innerHTML = v
+    ? '<rect x="3" y="2" width="4" height="12" rx="1"/><rect x="9" y="2" width="4" height="12" rx="1"/>'
+    : '<path d="M4 2l10 6-10 6z"/>';
+}
+playBtn.addEventListener('click', function(){ setPlaying(!isPlaying); });
+
+function seekFromEvent(e){
+  var rect = scrubber.getBoundingClientRect();
+  var x = (e.touches ? e.touches[0].clientX : e.clientX) - rect.left;
+  var p = clamp(x/rect.width, 0, 1);
+  t = p * TOTAL;
+  lastSceneIdx = -1;
+  render();
+}
+var dragging = false;
+scrubber.addEventListener('pointerdown', function(e){
+  dragging = true; scrubber.setPointerCapture(e.pointerId); seekFromEvent(e);
+});
+scrubber.addEventListener('pointermove', function(e){ if (dragging) seekFromEvent(e); });
+scrubber.addEventListener('pointerup', function(){ dragging = false; });
+})();
+`;
+}
+function renderHyperframes(scenes, opts = {}) {
+  const ratio = opts.ratio ?? "16:9";
+  const titleScene = scenes.find((s) => s.kind === "title");
+  const docTitle = opts.title ?? titleScene?.data.sessionName ?? "session recap";
+  const scenesJson = embedJson(scenes);
+  const body = scenes.map(sceneHtml).join("\n      ");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>vibemovie \u2014 ${escapeHtml(docTitle)}</title>
+<style>${css(ratio)}</style>
+</head>
+<body>
+<div class="stage">
+
+  <div class="topbar">
+    <div>
+      <div class="wordmark">vibe<b>movie</b></div>
+      <span class="tagline">${escapeHtml(docTitle)}</span>
+    </div>
+    <div class="badge-local"><span class="dot"></span>local \xB7 no data out</div>
+  </div>
+
+  <div class="player">
+    <div class="filmstrip"></div>
+    <div class="screen" id="screen">
+      ${body}
+      <div class="scene-title" id="sceneTitle"></div>
+    </div>
+    <div class="captions" id="captions"></div>
+    <div class="controls">
+      <button class="icon-btn" id="playBtn" aria-label="Pause">
+        <svg id="playIcon" viewBox="0 0 16 16" fill="currentColor"><rect x="3" y="2" width="4" height="12" rx="1"/><rect x="9" y="2" width="4" height="12" rx="1"/></svg>
+      </button>
+      <div class="time" id="timeCurrent">0:00</div>
+      <div class="scrubber" id="scrubber">
+        <div class="scrubber-track"><div class="scrubber-fill" id="scrubberFill"></div></div>
+        <div class="scrubber-markers" id="scrubberMarkers"></div>
+        <div class="scrubber-thumb" id="scrubberThumb"></div>
+      </div>
+      <div class="time total" id="timeTotal">0:00</div>
+    </div>
+  </div>
+
+  <div class="foot">hyperframes \xB7 rendered offline \u2014 no keys, no network, no data out</div>
+
+</div>
+<script>${engineJs(scenesJson)}</script>
+</body>
+</html>
+`;
+}
+
+// src/cinematic.ts
+import { execFileSync } from "child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, join } from "path";
+var ENGINES = ["hyperframes", "cinematic"];
+var STYLE = "cinematic 1980s film still, warm tungsten light with subtle magenta and cyan neon accents, 35mm film grain, shallow depth of field, night";
+var SET = "the SAME single cozy 1980s home office at night: a wooden desk front and center with a glowing laptop and mechanical keyboard, a steaming mug, sticky notes on the wall behind it, a warm desk lamp on the left, and a bookshelf with a glowing retro radio on the right";
+var DEV = "a young woman software developer in her early twenties, big voluminous curly blonde 80s hair, natural makeup with soft neutral eyeshadow and red lipstick, wearing a VIBRANT colorful 80s outfit: a bold color-blocked cropped jacket in hot pink and electric blue over a bright teal tee, vibrant and colorful";
+var LOCK = "Identical woman and identical office as the reference (same face, big curly blonde hair, natural red-lip makeup, vibrant hot-pink-and-blue cropped jacket, teal tee, same desk/laptop/lamp/sticky-notes/bookshelf). Only change pose and camera.";
+var EYE = "looking at what she is doing, not at the camera";
+function plural2(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function deriveReferencePrompts() {
+  return {
+    hero: `${STYLE}. Wide reference of ${DEV}, settling in to work at ${SET}.`,
+    face: `${STYLE}. Clean sharp front-facing headshot portrait of ${DEV}, looking straight at camera, evenly lit, crisp focus on her face.`
+  };
+}
+function beatFor(scene2) {
+  switch (scene2.kind) {
+    case "title": {
+      const d = scene2.data;
+      const dur = d.totalMinutes > 0 ? `${formatMinutes(d.totalMinutes)} in the flow` : "a session worth replaying";
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Wide establishing shot from across the room: she drops into her desk chair and flips open the glowing laptop, screen light spilling onto her face, ${EYE}. ${STYLE}`,
+        motion: `she sits down at the desk and opens the laptop, the screen wakes and lights her face, smooth settle-in. ${STYLE}`,
+        vo: `[energetically] ${d.sessionName} \u2014 ${dur}. Let's run it back.`
+      };
+    }
+    case "tasks": {
+      const d = scene2.data;
+      const first = d.tasks[0]?.label ?? "the first task";
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Close-up side profile: she types fast on the mechanical keyboard, then reaches up and ticks a sticky note on the wall, mid-action, ${EYE}. ${STYLE}`,
+        motion: `she types quickly, then reaches over and checks off a sticky note, natural working rhythm. ${STYLE}`,
+        vo: d.total === 1 ? `[excited] One task landed, clean \u2014 ${first}.` : `[excited] ${plural2(d.total, "task")} landed, clean \u2014 kicked off by ${first}.`
+      };
+    }
+    case "diff": {
+      const d = scene2.data;
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Over-the-shoulder shot from behind her: she leans into the glowing laptop covered in code, one hand mid-scroll, screen glow catching her hair, ${EYE}. ${STYLE}`,
+        motion: `she scrolls through the diff and leans in closer to the code, subtle continuous motion. ${STYLE}`,
+        vo: `[excited] ${plural2(d.filesChanged, "file")} touched \u2014 plus ${d.additions}, minus ${d.deletions}.`
+      };
+    }
+    case "terminal": {
+      const d = scene2.data;
+      const hasTests = d.lines.some((l) => l.cls === "ok" && l.text.includes("passed"));
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Three-quarter shot from the lamp side: she throws a triumphant fist pump at the glowing screen, mid-cheer, ${EYE}. ${STYLE}`,
+        motion: `she reads the screen, then pumps her fist in celebration, energetic. ${STYLE}`,
+        vo: hasTests ? "[shouting] GREEN! Green across the board \u2014 every test, passing!" : "[excited] The commands tell the story \u2014 clean, top to bottom."
+      };
+    }
+    case "merge": {
+      const d = scene2.data;
+      const vo = d.pr !== null ? d.merged ? `[excited] And there it is \u2014 pull request number ${d.pr}, merged into ${d.branch}! No conflicts, no mercy!` : `[excited] Pull request number ${d.pr} is open on ${d.branch} \u2014 reviews incoming!` : d.merged ? `[excited] Merged into ${d.branch}! No conflicts, no mercy!` : `[excited] The pull request is open on ${d.branch}!`;
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Low-angle shot from the desk surface: she hits the enter key with a flourish and throws both hands up, screen glow flaring, mid-celebration, ${EYE}. ${STYLE}`,
+        motion: `she slams enter, throws both hands up and leans back laughing, joyful release. ${STYLE}`,
+        vo
+      };
+    }
+    case "end": {
+      return {
+        kind: scene2.kind,
+        keyframe: `${LOCK} Wide slightly dutch-angle shot: she closes the laptop and leans back in her chair with a satisfied smile, lamplight warm on the room, ${EYE}. ${STYLE}`,
+        motion: `she gently closes the laptop and leans back, smiling, calm settle. ${STYLE}`,
+        vo: `[warmly] ${scene2.caption} This is vibemovie.`
+      };
+    }
+  }
+}
+function deriveBeats(scenes) {
+  return scenes.map(beatFor);
+}
+function cinematicAvailable(env = process.env) {
+  const key = env["WAVESPEED_API_KEY"];
+  return typeof key === "string" && key.trim().length > 0;
+}
+var defaultExec = (file, args) => {
+  execFileSync(file, [...args], { stdio: "ignore" });
+};
+function ffmpegAvailable(execFn = defaultExec) {
+  try {
+    execFn("ffmpeg", ["-version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var API_BASE = "https://api.wavespeed.ai/api/v3";
+var MODEL_T2I = "bytedance/seedream-v4";
+var MODEL_EDIT = "wavespeed-ai/flux-kontext-max";
+var MODEL_I2V = "kwaivgi/kling-v2.5-turbo-pro/image-to-video";
+var MODEL_FACE_SWAP = "wavespeed-ai/video-face-swap";
+var MODEL_TTS = "elevenlabs/eleven-v3";
+var T2I_SIZE = "1920*1080";
+var CLIP_SECONDS = 5;
+var NEGATIVE_PROMPT = "morphing, warping, distorted face, changing outfit, extra fingers, flicker, duplicated objects, ghosting, double image, cloned furniture";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function renderCinematic(scenes, opts) {
+  const apiKey = opts.apiKey ?? process.env["WAVESPEED_API_KEY"];
+  if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+    throw new Error("cinematic: WAVESPEED_API_KEY is required (set it in the environment or pass opts.apiKey)");
+  }
+  const fetchFn = opts.deps?.fetchFn ?? fetch;
+  const execFn = opts.deps?.execFn ?? defaultExec;
+  const sleepFn = opts.deps?.sleepFn ?? sleep;
+  const log = opts.log ?? ((msg) => process.stderr.write(`${msg}
+`));
+  const voiceId = opts.voiceId ?? "George";
+  const workDir = opts.workDir ?? mkdtempSync(join(tmpdir(), "vibemovie-cinematic-"));
+  mkdirSync(workDir, { recursive: true });
+  const headers = { Authorization: `Bearer ${apiKey}` };
+  const post = async (model, body) => {
+    const res = await fetchFn(`${API_BASE}/${model}`, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    const j = await res.json();
+    const id = j.data?.id;
+    if (id === void 0) throw new Error(`cinematic: ${model} did not return a prediction id`);
+    return id;
+  };
+  const poll = async (id, maxTicks = 95, intervalMs = 3e3) => {
+    for (let i = 0; i < maxTicks; i++) {
+      const res = await fetchFn(`${API_BASE}/predictions/${id}/result`, { headers });
+      const j = await res.json();
+      const status = j.data?.status;
+      const out = j.data?.outputs?.[0];
+      if (status === "completed" && out !== void 0) return out;
+      if (status === "failed") throw new Error(`cinematic: prediction ${id} failed`);
+      await sleepFn(intervalMs);
+    }
+    throw new Error(`cinematic: prediction ${id} timed out`);
+  };
+  const download = async (url, path) => {
+    const res = await fetchFn(url);
+    writeFileSync(path, Buffer.from(await res.arrayBuffer()));
+  };
+  const upload = async (path) => {
+    const form = new FormData();
+    form.append("file", new Blob([readFileSync(path)]), basename2(path));
+    const res = await fetchFn(`${API_BASE}/media/upload/binary`, { method: "POST", headers, body: form });
+    const j = await res.json();
+    const url = j.data?.download_url;
+    if (url === void 0) throw new Error("cinematic: media upload failed");
+    return url;
+  };
+  const t2i = async (prompt) => poll(await post(MODEL_T2I, { prompt, size: T2I_SIZE }));
+  const edit = async (prompt, image) => poll(await post(MODEL_EDIT, { prompt, image }));
+  const kling = async (first, last, motion) => poll(
+    await post(MODEL_I2V, {
+      image: first,
+      last_image: last,
+      prompt: motion,
+      duration: CLIP_SECONDS,
+      negative_prompt: NEGATIVE_PROMPT
+    })
+  );
+  const tts = async (text) => poll(
+    await post(MODEL_TTS, {
+      text,
+      voice_id: voiceId,
+      stability: 0.3,
+      similarity: 0.75,
+      use_speaker_boost: true
+    }),
+    60,
+    2500
+  );
+  const beats = deriveBeats(scenes);
+  if (beats.length < 2) throw new Error("cinematic: need at least 2 scenes to build a film");
+  log("cinematic: hero + face ref...");
+  const { hero: heroPrompt, face: facePrompt } = deriveReferencePrompts();
+  const [heroUrl, faceUrl] = await Promise.all([t2i(heroPrompt), t2i(facePrompt)]);
+  log(`cinematic: ${beats.length} keyframes (parallel)...`);
+  const kfUrls = await Promise.all(beats.map((b) => edit(b.keyframe, heroUrl)));
+  const lastKfPath = join(workDir, "end.jpg");
+  await download(kfUrls[kfUrls.length - 1], lastKfPath);
+  const clipCount = beats.length - 1;
+  log(`cinematic: ${clipCount} Kling clips (parallel, first+last frame chained)...`);
+  const clipPaths = await Promise.all(
+    beats.slice(0, -1).map(async (b, i) => {
+      const path = join(workDir, `c${i}.mp4`);
+      try {
+        await download(await kling(kfUrls[i], kfUrls[i + 1], b.motion), path);
+        log(`cinematic:  clip ${i}`);
+        return path;
+      } catch (err) {
+        log(`cinematic:  clip ${i} failed (${err instanceof Error ? err.message : String(err)}) \u2014 skipping`);
+        return null;
+      }
+    })
+  );
+  const clips = clipPaths.filter((p) => p !== null && existsSync(p));
+  if (clips.length === 0) throw new Error("cinematic: all Kling clips failed");
+  const segs = [];
+  for (let i = 0; i < clips.length; i++) {
+    const seg = join(workDir, `s${i}.mp4`);
+    execFn("ffmpeg", [
+      "-y",
+      "-i",
+      clips[i],
+      "-an",
+      "-vf",
+      "scale=1280:720:force_original_aspect_ratio=increase,crop=1280:720,setsar=1,fps=24",
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      seg
+    ]);
+    segs.push(seg);
+  }
+  const endCard = join(workDir, "end.mp4");
+  execFn("ffmpeg", [
+    "-y",
+    "-i",
+    lastKfPath,
+    "-vf",
+    `zoompan=z='min(zoom+0.0008,1.06)':d=${CLIP_SECONDS * 24}:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=1280x720:fps=24,setsar=1`,
+    "-an",
+    "-c:v",
+    "libx264",
+    "-pix_fmt",
+    "yuv420p",
+    endCard
+  ]);
+  segs.push(endCard);
+  const listPath = join(workDir, "list.txt");
+  writeFileSync(listPath, segs.map((s) => `file '${s.replace(/'/g, `'\\''`)}'`).join("\n"));
+  const baseRaw = join(workDir, "base_raw.mp4");
+  execFn("ffmpeg", ["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-an", baseRaw]);
+  log(`cinematic: base cut assembled (${segs.length} segments)`);
+  let base = join(workDir, "base.mp4");
+  try {
+    log("cinematic: face-swap identity lock...");
+    const swapped = await poll(
+      await post(MODEL_FACE_SWAP, { video: await upload(baseRaw), face_image: faceUrl, target_gender: "female" }),
+      140
+    );
+    await download(swapped, base);
+  } catch (err) {
+    log(`cinematic: face-swap failed (${err instanceof Error ? err.message : String(err)}) \u2014 using the raw cut`);
+    copyFileSync(baseRaw, base);
+  }
+  const graded = join(workDir, "base_g.mp4");
+  execFn("ffmpeg", [
+    "-y",
+    "-i",
+    base,
+    "-vf",
+    "eq=contrast=1.06:saturation=1.08:brightness=0.01,colorbalance=rs=0.05:gs=0.01:bs=-0.04:rm=0.03:bm=-0.02,setsar=1",
+    "-an",
+    "-c:v",
+    "libx264",
+    "-pix_fmt",
+    "yuv420p",
+    graded
+  ]);
+  log(`cinematic: ${beats.length} VO lines (parallel)...`);
+  const voPaths = await Promise.all(
+    beats.map(async (b, i) => {
+      const raw = join(workDir, `raw${i}.mp3`);
+      await download(await tts(b.vo), raw);
+      const processed = join(workDir, `r${i}.mp3`);
+      execFn("ffmpeg", [
+        "-y",
+        "-i",
+        raw,
+        "-af",
+        "highpass=f=80,acompressor=threshold=-18dB:ratio=2.5,volume=2dB",
+        processed
+      ]);
+      log(`cinematic:  line ${i} (${voiceId})`);
+      return processed;
+    })
+  );
+  const dur = beats.length * CLIP_SECONDS;
+  const inputs = ["-i", graded];
+  for (const p of voPaths) inputs.push("-i", p);
+  inputs.push("-f", "lavfi", "-i", `anoisesrc=color=pink:d=${dur}:a=0.025`);
+  const hissIdx = 1 + voPaths.length;
+  let fc = "";
+  voPaths.forEach((_, i) => {
+    const d = i * CLIP_SECONDS * 1e3;
+    fc += `[${i + 1}:a]adelay=${d}|${d}[v${i}];`;
+  });
+  fc += `[${hissIdx}:a]highpass=f=300,lowpass=f=3000,volume=0.5[hiss];`;
+  fc += voPaths.map((_, i) => `[v${i}]`).join("") + `[hiss]amix=inputs=${voPaths.length + 1}:duration=longest:dropout_transition=0,volume=1.3[a]`;
+  execFn("ffmpeg", [
+    "-y",
+    ...inputs,
+    "-filter_complex",
+    fc,
+    "-map",
+    "0:v",
+    "-map",
+    "[a]",
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-shortest",
+    opts.out
+  ]);
+  log(`cinematic: DONE -> ${opts.out}`);
+  return { path: opts.out, beats };
+}
+
+// src/recipes/shots.ts
+var SHOT_ROLES = [
+  "hook",
+  "establish",
+  "reveal",
+  "feature",
+  "transition",
+  "hero",
+  "text-card",
+  "close",
+  "action",
+  "emotion"
+];
+var ENERGY_LEVELS = ["low", "med", "high"];
+var shotRecipes = [
+  // ── hook ──────────────────────────────────────────────────────────────
+  {
+    id: "brand-ink-open",
+    role: "hook",
+    name: "Brand Ink Open",
+    purpose: "Stamp the brand wordmark into paper grain before any product shot \u2014 the audience memorizes the name in one quiet held beat.",
+    energy: "low",
+    suggestedSeconds: 3,
+    promptHints: "Wordmark slowly imprints into textured paper grain with a soft letterpress emboss, settles, then holds dead-still for a full breath before anything moves.",
+    pitfall: "The held beat belongs to the wordmark settle frame, not a content card; keep opening energy low so it does not crush the later build."
+  },
+  {
+    id: "magician-card-flourish",
+    role: "hook",
+    name: "Magician Card Flourish",
+    purpose: 'A single hero card is conjured from a flash of light \u2014 the ritual of "making it appear" is the hook.',
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "A short blue star-flash, then the card launches from a tiny point at frame center, spins along a curving arc toward camera, and hard-locks dead-still front-facing at near-full-frame.",
+    pitfall: "The flash must read as light (0.3s), the spin must land exactly front-facing with no settling tail, and the card freezes on arrival \u2014 cheap color-block light effects were repeatedly rejected."
+  },
+  {
+    id: "dataviz-landscape-open",
+    role: "hook",
+    name: "Dataviz Landscape Open",
+    purpose: "A brand-level abstract open: the data world behind the product shot as a dark landscape of glowing streams converging into one trunk.",
+    energy: "low",
+    suggestedSeconds: 6,
+    promptHints: "Slow steady low-altitude camera flight over a dark field; many thin glowing streams flow in from the deep background and merge into a single bright trunk, scattered with small readable ID labels across three depth layers.",
+    pitfall: 'Use at most once per film, and do not pair with glow-flyline in an adjacent segment \u2014 two "dark glowing lines" reads as the same trick.'
+  },
+  {
+    id: "trailer-grammar-moves",
+    role: "hook",
+    name: "Trailer Grammar",
+    purpose: "The structural moments of a trailer \u2014 the open front-loads the three punchiest shots in 0.9s, then a black beat, then the real start.",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Three fastest, most striking shots cut back-to-back in under a second, then hard-cut to pure black and hold one silent beat before the title opens.",
+    pitfall: "The black beat must be pure black and empty \u2014 it is a breath; anything in it breaks the trailer hook."
+  },
+  {
+    id: "input-trigger-moves",
+    role: "hook",
+    name: "Input Trigger",
+    purpose: "First-person grammar \u2014 the viewer is using the product, not watching it. The cursor is the hand; the trigger fires the narrative.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "An enlarged cursor with personality slides in and clicks a target; the camera pushes toward the click point then gently eases back \u2014 slow, anchored on the cursor, it comes back.",
+    pitfall: "Cap at two input-triggers per film \u2014 each should be a section-level switch; three rapid keypresses reads as a bug."
+  },
+  // ── establish ─────────────────────────────────────────────────────────
+  {
+    id: "crane-rise-reveal",
+    role: "establish",
+    name: "Crane Rise Reveal",
+    purpose: "Establish from detail to whole: start glued to one real data row, then a crane arm rises and pulls back so rows flow in until the full dashboard fills frame.",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Camera locked on a tight close-up of a single data row, then rises vertically along Y and pulls back on a decelerating ease, rows streaming in from below as the full dashboard fills the frame and settles to a true still.",
+    pitfall: "The starting detail is stared at 3.2x zoom \u2014 rasterize it hires first or text blurs; pick rise XOR dive per film (do not pair with a drone-dive)."
+  },
+  {
+    id: "overhead-camera-moves",
+    role: "establish",
+    name: "Overhead Camera",
+    purpose: 'The tilt angle itself tells the story: the page lies flat, the camera "looks up" to right it, content rows flowing into view like unrolling a blueprint.',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Page lies flat at a steep tilt showing only a thin perspective band of its top edge; the camera tilts up toward level, rows of content flowing into view one by one until the full page reads flat.",
+    pitfall: 'Pick this OR crane-rise-reveal for an establishing open \u2014 two "reveal opens" in one film reads as the same trick.'
+  },
+  {
+    id: "icon-field-colorize",
+    role: "establish",
+    name: "Icon Field Colorize",
+    purpose: 'Lay out the full capability surface as a field of grey icons, then wash it with brand-color waves \u2014 "look how much this does", lit up at once.',
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "Over a hundred small grey icons stagger into frame and fill it as background texture, hold one beat, then brand color sweeps across as fast descending horizontal waves (blue first, then orange/green/red in lower bands).",
+    pitfall: "The color pass must NOT be a same-frame hard flip \u2014 it is multiple color waves sweeping down over about half a second; a hard flip reads as a swapped image."
+  },
+  {
+    id: "morph-from-primitive",
+    role: "establish",
+    name: "Morph From Primitive",
+    purpose: "The subject grows in place rather than flying in \u2014 a stroked circle takes a breath, then its outline continuously morphs into a rounded card as content fades in.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "A simple stroked circle at center breathes (scale 1 to 1.12 to 1) in anticipation, then its outline smoothly morphs into a rounded-rect card while the content fades in.",
+    pitfall: "The breath is the anticipation beat \u2014 without it the morph reads as a pop; it is the reverse direction from UI-to-primitive."
+  },
+  {
+    id: "skeleton-reveal",
+    role: "establish",
+    name: "Skeleton Reveal",
+    purpose: 'Stage the product UI arrival as three fidelity jumps: hand sketch to grey skeleton bars to real content \u2014 the "becoming real" arc.',
+    energy: "med",
+    suggestedSeconds: 6,
+    promptHints: "UI arrives in three jumps: a quick hand-drawn sketch, a fast swap to grey skeleton bars rolling in, then a slow push as the skeleton resolves into the real filled product UI.",
+    pitfall: 'Each "becomes real" swap is a beat \u2014 the two fidelity transitions are the whole point; rushing them kills the arc.'
+  },
+  // ── reveal ────────────────────────────────────────────────────────────
+  {
+    id: "neon-frame-orbit-drop",
+    role: "reveal",
+    name: "Neon Frame Orbit Drop",
+    purpose: "A grand one-off reveal: a neon frame traces itself then orbits from the left side to the right while all components drop in from above simultaneously and snap into place.",
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "A neon outline frame traces itself, then the camera arcs continuously from the page left side to its right while every component and text drops from above at once, each snapping dead with its shadow vanishing on contact \u2014 a single simultaneous whole-page arrival.",
+    pitfall: '"Simultaneous" is the grammar \u2014 all components start, land, and shed shadows on the same frames; stagger it and it stops being a unified reveal (that is the runway-rain variant instead).'
+  },
+  {
+    id: "spotlight-sweep-moves",
+    role: "reveal",
+    name: "Spotlight Sweep",
+    purpose: "In the dark the audience only sees what the light shows \u2014 light is illumination and editing: where it sweeps, panels appear; when it leaves, they exit.",
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "Near-black scene; a purple-edged spotlight glow creeps along UI panel edges and logos (lit, slightly blurred \u2014 light stroking the interface, not a stroke animation). Move and expand strictly at constant linear speed; a panel lights up where the light touches and dims as it passes.",
+    pitfall: "Constant linear speed is the\u547D\u95E8 \u2014 easing makes the light feel intentional; only linear reads as a mechanical searchlight sweep."
+  },
+  {
+    id: "stroke-segment-build",
+    role: "reveal",
+    name: "Stroke Segment Build",
+    purpose: 'An Alien-titles reveal: the title "develops" \u2014 discrete stroke segments light up out of order, unreadable for most of the time, then the last segments land and the word suddenly reads. Recognition is the hook.',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Title broken into discrete stroke segments; segments light up out of order over the first part (mysterious fragments), then the final key segments land and the full word suddenly reads \u2014 recognition is the beat.",
+    pitfall: "The hook strength depends on how long the unreadable period holds and how late the key segment lands \u2014 do not blow the reveal early."
+  },
+  // ── feature ───────────────────────────────────────────────────────────
+  {
+    id: "deck-deal-flyin",
+    role: "feature",
+    name: "Deck Deal Fly-In",
+    purpose: 'Show "there is a LOT here, pouring in" \u2014 cards deal themselves flying into their grid slots with urgency; build information density as the first impression.',
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "A stack teases (what is this pile?), then dozens of cards deal out and fly into the page, each slamming into its slot with urgency \u2014 the audience feels things pouring in.",
+    pitfall: 'Abstract "flood" multi-round non-convergence was rejected; find a physical metaphor (dealing) before writing motion \u2014 group motion needs a metaphor before code.'
+  },
+  {
+    id: "row-embed",
+    role: "feature",
+    name: "Row Embed",
+    purpose: 'Detail-page rows do not "appear", they "grow in" \u2014 each row drops from above and slots precisely into the layout; the accent seam at embed is the click of it snapping shut.',
+    energy: "med",
+    suggestedSeconds: 2,
+    promptHints: "Structured rows drop from above one by one and slot precisely into the page layout; on each embed a thin accent-colored seam flashes at the join \u2014 the visual foley of it snapping shut.",
+    pitfall: "Fly-in targets MUST be real layout slots that embed on landing \u2014 floating above the grid without landing reads as fake."
+  },
+  {
+    id: "document-typewriter-reveal",
+    role: "feature",
+    name: "Document Typewriter Reveal",
+    purpose: 'The whole real-typeset document writes itself out behind a caret, sidebar entries drop into the rail \u2014 the densest info beat; the whole persuasion is "this document is real".',
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "A full page of real typeset document writes itself out left-to-right behind a single accent caret riding the reveal edge; sidebar history entries drop into the rail in sequence; camera holds on the page with both columns in frame.",
+    pitfall: "Mock content must be publish-grade (native layout, full text, complete sidebar) \u2014 a slapdash screenshot-plus-slogan document forces a full reshoot; never put real customer or member names in mock data."
+  },
+  {
+    id: "type-and-filter",
+    role: "feature",
+    name: "Type And Filter",
+    purpose: 'Let the viewer "do it once" \u2014 see what is typed, how the page responds, where they clicked. The one lens that simulates real human operation, so it must move like a hand, not a script.',
+    energy: "med",
+    suggestedSeconds: 3,
+    promptHints: "Simulated real-speed human operation: type a few characters, the list filters and re-settles, the cursor clicks into a target card that lands in its real grid slot.",
+    pitfall: "First drafts are always too fast \u2014 type at about three frames per character; a filtered target card that floats above the grid instead of landing in a real slot reads as fake."
+  },
+  {
+    id: "before-after-slider-scrub",
+    role: "feature",
+    name: "Before/After Slider Scrub",
+    purpose: "The standard AI-product comparison: same frame, before (flat) overlaid with after (crisp); the divider whips to 70 percent with overshoot, holds, then crawls back to prove where the change is. Fast-sweep then slow-scan is the rhythm.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Two overlaid versions of the same frame (before: flat low-contrast; after: crisp) split by a vertical divider with a round handle; the handle whips hard from the left edge to about 70 percent with overshoot, holds one beat, then crawls back at a fifth of the speed so the difference is readable.",
+    pitfall: "Both versions must share identical layout and camera \u2014 different layouts read as two pages and the comparison fails; use real screenshots for both."
+  },
+  {
+    id: "integration-hub-map",
+    role: "feature",
+    name: "Integration Hub Map",
+    purpose: '"One product connects everything" \u2014 the page flips over to become a hub, icons appear, then light tubes connect to them in two beats and breathe the flow.',
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Old page flips a full 180 degrees to become a new hub page (one fast continuous flip with a brief edge flash at the 90-degree profile, no stop); icons appear all at once, then glowing light tubes connect out to them across two beats and pulse softly to keep flowing.",
+    pitfall: 'The flip must be complete and continuous with no 90-degree-profile pause \u2014 a stop there was rejected; "constant speed" here means no pauses, not literal linear.'
+  },
+  {
+    id: "command-palette-summon",
+    role: "feature",
+    name: "Command Palette Summon",
+    purpose: "The signature ritual: a soft chime, the whole UI dims aside, the command palette drops from upper-center, candidates stagger in; type two letters and the list narrows live.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "A soft chime, the whole UI world dims to make way, a command palette drops from upper-center, candidate rows stagger in; two characters typed at human speed and the list narrows live \u2014 the squeeze comes from row-height collapse, not fade.",
+    pitfall: "Type at real human speed (at least 12 frames between the two keys); the narrowing squeeze must come from row-height collapse, not opacity fade."
+  },
+  {
+    id: "list-stack-press",
+    role: "feature",
+    name: "List Stack Press",
+    purpose: '"Stacking has weight" \u2014 each new card lands and presses the whole pile down before it springs back; the counter ticks in lockstep to nail the quantity.',
+    energy: "med",
+    suggestedSeconds: 3,
+    promptHints: "Feed or inbox cards stack one by one; each new card lands and presses the whole settled pile down, which springs back up; a counter ticks up in lockstep with each landing.",
+    pitfall: "Stack and list info lenses must be shot head-on \u2014 even in a fully stylized film this lens was rolled back to front-view individually; validate camera per lens, do not apply globally."
+  },
+  // ── transition ────────────────────────────────────────────────────────
+  {
+    id: "wipe-transitions",
+    role: "transition",
+    name: "Wipe Transitions",
+    purpose: 'The geometric-wipe family \u2014 both pages stay still while one geometric boundary sweeps across to hand off. Clock-wipe = "dashboard refreshed a screen of data"; blinds-slice = "flip the page".',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Old and new pages both still; a geometric boundary sweeps across to reveal the new \u2014 either a clock-hand radar sweep from center (data-refresh feel) or vertical blinds flipping in a staggered wave (page-turn feel). The wipe edge carries bright highlight lines so it does not read as a slideshow transition.",
+    pitfall: "The wipe boundary MUST carry highlight or glow lines \u2014 a line-less wipe reads as a PowerPoint transition; light lines need a dark edge-stroke on light areas and a bright white core on dark."
+  },
+  {
+    id: "card-flip-reveal",
+    role: "transition",
+    name: "Card Flip Reveal",
+    purpose: 'A semantic flip \u2014 a card front (feature UI) and back (the number it produced) are a cause-and-effect pair; the flip answers "so what?". Three staggered cards read as "results roll in".',
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: 'A row of cards each flips over; the front is the feature UI, the back is the result number it produced \u2014 the flip answers "so what?". Three cards flip in a stagger, reading as consecutive results.',
+    pitfall: "Same technique root as a grid wave-flip but different semantics \u2014 that is batch entrance, this is cause-to-result; do not conflate."
+  },
+  {
+    id: "bubble-swarm-takeover",
+    role: "transition",
+    name: "Bubble Swarm Takeover",
+    purpose: '"Curtain" thinking \u2014 a swarm of brand objects drifts into foreground, swells to fill the frame hiding a hard cut, then drifts apart to reveal the new scene. Longer transitions mean more brand exposure, not slow.',
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "A swarm of brand objects (bubbles, petals, icons) drifts in and swells to completely fill or occlude the frame (hard cut hidden at peak occlusion), then drifts apart to reveal a new scene.",
+    pitfall: 'The peak MUST truly occlude the full frame or the cut shows; the hidden-cut variant is the one-to-three-frame "invisible scissors" \u2014 pick by how long you want the brand on screen.'
+  },
+  {
+    id: "line-carry-transition",
+    role: "transition",
+    name: "Line Carry Transition",
+    purpose: "The scene never changes \u2014 a single line carries you across. A progress bar fills, its tip extends off the card edge; the camera follows it panning into the new world, the line dog-legs to frame the next card.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "A progress bar fills and its tip extends into a long line off the card edge; the camera follows the line panning sideways into a new scene, the line dog-legs to draw the next card frame, the frame closes and content fades in \u2014 the eye never leaves the line.",
+    pitfall: "Graphic continuity IS the transition \u2014 do not cross-fade; the line belongs to the whole cut, not to one element."
+  },
+  {
+    id: "color-block-step-wipe",
+    role: "transition",
+    name: "Color-Block Step Wipe",
+    purpose: "Zero interpolation, zero easing \u2014 color blocks grow like retro pixel-game tiles, every step a hard cut, stillness between steps. The stutter itself is the rhythm.",
+    energy: "high",
+    suggestedSeconds: 3,
+    promptHints: "Brand color blocks grow in hard discrete steps with no easing and no interpolation \u2014 each step is a hard cut, fully still between steps (retro pixel-game tile growth). Three to five steps total; a content card can ride each step.",
+    pitfall: "Distinct from the smooth clock and blinds wipes \u2014 this is the stuttered no-tween pixel feel; do not smooth it out."
+  },
+  {
+    id: "brand-frame-snap",
+    role: "transition",
+    name: "Brand Frame Snap",
+    purpose: "Wrap real screen recordings in a thick brand-color picture frame \u2014 the frame appears first, then its color becomes the chapter code. On a chapter switch the whole frame hard-flips color in one frame.",
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "A thick brand-color picture frame draws around a screen recording (frame first, content second \u2014 ritual); on a chapter switch the entire frame hard-flips to a new brand color in a single frame (no gradient), the window content and corner badges swapping in the same frame.",
+    pitfall: "The flip MUST be same-frame across frame, window content, and badge text \u2014 even two frames apart and the gear-shift scatters into three small animations; keep the color code consistent film-wide."
+  },
+  // ── hero ──────────────────────────────────────────────────────────────
+  {
+    id: "spotlight-hero-card",
+    role: "hero",
+    name: "Spotlight Hero Card",
+    purpose: "The single-protagonist open: a wandering spotlight locks onto one card, the camera pushes in on an angle, the card rises, hovers, is scanned by a contour beam, then reseats.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "A roaming spotlight narrows and locks onto one card in a grid; camera pushes from a flat full-page to a tilted close-up (left-side angle), the card rises with overshoot, hovers with a gentle bob, a glowing rounded-rect contour beam traces it twice (fast-bright then slow-dim), then it reseats.",
+    pitfall: "Open with a SINGLE card and one complete action arc \u2014 a multi-card dance cannot carry a first impression; slow the rise-to-reseat toward three seconds, first drafts are always too fast."
+  },
+  {
+    id: "crash-zoom-punch",
+    role: "hero",
+    name: "Crash Zoom Punch",
+    purpose: 'One beat slams from a wide to a target close-up \u2014 "look at THIS". Land with an overshoot bounce (spring) or a hard impact shake (weight), by emphasis.',
+    energy: "high",
+    suggestedSeconds: 3,
+    promptHints: "In about six frames, crash-zoom from a wide framing to an extreme close-up on the target card filling 60 to 75 percent of frame; either overshoot and rebound 3 to 6 percent (spring) or land hard with a high-frequency impact shake that decays in six frames.",
+    pitfall: "Do not mix the two landings (rebound plus shake reads as a glitch); cap at two crash-zooms per film, and the landing target must be high-res or text blurs."
+  },
+  {
+    id: "runway-ground-skim",
+    role: "hero",
+    name: "Runway Ground Skim",
+    purpose: "Treat the UI as a runway: low-angle, cards hang at staggered heights then rain down in an overlapping fast volley, landing dead with zero bounce, then the whole page stands up to vertical.",
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "Strong low-angle perspective, page lying flat like a runway; UI cards suspended at staggered heights then drop in an overlapping rain (small stagger, gravity acceleration), each landing dead-still with no bounce; once all are down the whole page rotates up to vertical and the camera pulls to center.",
+    pitfall: "The drop feel is crisp: zero bounce (the squish was rejected), a short drop frame count (longer was rejected as slow), and overlapping parallelism (waiting for one to land before starting the next was rejected)."
+  },
+  {
+    id: "segmented-thumb-hero",
+    role: "hero",
+    name: "Segmented Thumb Hero",
+    purpose: 'A mode switch told entirely by the segmented control thumb sliding eight frames \u2014 "we moved from A to B" with no page context; the control is the stage.',
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "Extreme close-up of a segmented control; cursor slides in, presses with a ripple, the thumb slider glides eight frames to the other segment, and a new icon pops in \u2014 four beats: arrival, decision, response, reward.",
+    pitfall: "All four beats are required \u2014 drop the cursor and the UI looks self-animated; drop the icon pop and the switch feels unrewarded."
+  },
+  {
+    id: "space-camera-moves",
+    role: "hero",
+    name: "Space Camera",
+    purpose: "Treat the flat page as a real 3D object the camera flies around \u2014 exploded-view (parts blow out along Z then reassemble) or drone-dive (god-view plunges to a hero close-up).",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Either the whole page tilts in 3D and its components blow out along the Z-axis, hover, then reassemble in reverse with an impact shake; or a near-vertical overhead hover, then a hard dive that air-cushions to a stop on a hero-card close-up, motion-blurred through the dive.",
+    pitfall: "Both variants need real layered or high-res screenshots \u2014 one flat page cannot explode, and the dive lands on a close-up that blurs without hires rasterization; cap at two of these big moves per film."
+  },
+  // ── text-card ─────────────────────────────────────────────────────────
+  {
+    id: "paper-title-card",
+    role: "text-card",
+    name: "Paper Title Card",
+    purpose: 'Give the audience one sentence of breath between two product beats \u2014 say "what is next and why it matters". Letterpress emboss keeps the card in the same world as the paper-and-ink visuals.',
+    energy: "low",
+    suggestedSeconds: 2,
+    promptHints: "A single short phrase embossed into textured paper with a letterpress press, holds for one breath between two scenes \u2014 concrete copy naming the feature and its payoff, never abstract metaphor.",
+    pitfall: "Copy must be concrete (feature name plus specific payoff) \u2014 abstract metaphor words get rewritten; place a guiding card before an important feature, it is a chapter signpost not decoration."
+  },
+  {
+    id: "cel-flash-stomp",
+    role: "text-card",
+    name: "Cel Flash Stomp",
+    purpose: "Stomp-typography alone is just weight; background color-flash alone is just flash. Welded: the word slam-frame is the flash ignition \u2014 subject still, world quaking in peripheral vision. The opposite of screenshake.",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Each word slams down dead-still onto frame; on each slam-frame the solid background color hard-flashes to a new hue and back. Subject rock-still, only the world flashes \u2014 peripheral-vision impact. Three words, three beats.",
+    pitfall: "Sound-dependent \u2014 each word-slam needs a kick and the flash must align to the beat; without the kick it is just a janky strobe."
+  },
+  {
+    id: "gradient-word-sweep",
+    role: "text-card",
+    name: "Gradient Word Sweep",
+    purpose: '"Energize" one keyword in an otherwise-neutral line \u2014 a gradient color sweep zips across the chars like an injection; the wavefront is brightest, then it settles to a steady glow with linking sparks.',
+    energy: "high",
+    suggestedSeconds: 3,
+    promptHints: "One keyword in an otherwise-neutral line gets electrified: a bright gradient color sweep zips across the characters left-to-right in 15 to 20 frames (the wavefront brightest, trailing off), then settles to a steady glow with thin linking sparks between chars breathing.",
+    pitfall: "Fill-process must NOT follow a light dot; sparks appear only after fill; glow stays restrained. A slow sweep reads as a progress bar \u2014 keep it 15 to 20 frames."
+  },
+  {
+    id: "letterspace-materialize",
+    role: "text-card",
+    name: "Letterspace Materialize",
+    purpose: 'The wordmark does not fade or type \u2014 it "crystallizes": all letters strokes begin growing simultaneously and converge to the word in one synchronized breath (wide-tracked caps).',
+    energy: "low",
+    suggestedSeconds: 4,
+    promptHints: "All letters of a wide-tracked uppercase wordmark begin drawing their strokes at once and converge to the complete word in a single synchronized breath \u2014 like an invisible hand writing all letters simultaneously, every letter starting and finishing on the same frames.",
+    pitfall: "Strokes must be continuous (no mask-halves \u2014 a half-then-rest reads as fake) AND synchronized (staggered letters read as typewriter semantics, not whole-word ritual)."
+  },
+  {
+    id: "split-flap-title",
+    role: "text-card",
+    name: "Split-Flap Title",
+    purpose: 'The wordmark as a station-board "broadcast" with mechanical announcing cadence \u2014 for countdowns, ship-dates, metric reveals, or retro-mechanical texture.',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "A title rendered as a split-flap station departure board: a stretch of scrambled flapping, then characters cascade-flip left-to-right to settle on the real title, holding dead-still. Mechanical announcing cadence.",
+    pitfall: "Sound-dependent \u2014 the mechanical flap-click on each settle is half the effect; without it the cascade is lifeless."
+  },
+  {
+    id: "type-rhythm-sync",
+    role: "text-card",
+    name: "Type Rhythm Sync",
+    purpose: "Bind the title hard to the audio track \u2014 beat-bound (drum hits) or speech-bound (narrator word-by-word). The title or slogan synced tight to the music bed.",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Title or slogan bound tight to the audio: variant A \u2014 each syllable or weight-pulse hits on a drum beat in a short decay window (dance feel); variant B \u2014 each word lights up following the narrator cadence (follow-along feel).",
+    pitfall: "Strong sound dependency \u2014 the pulse must really land on the beat; unsynced pulses over a silent track read as broken."
+  },
+  // ── close ─────────────────────────────────────────────────────────────
+  {
+    id: "outro-group-photo-launch",
+    role: "close",
+    name: "Outro Group Photo Launch",
+    purpose: "Recall one representative element from each feature shown for a group photo, then the wordmark enters as the climax \u2014 launch-event scale, energy pushed to the film peak.",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Representative elements from every feature shown fly in from the four edges to gather around the center for a group photo, then the brand wordmark drops in as the climax \u2014 launch-event scale, crane plus stage light plus particles, the film highest energy.",
+    pitfall: "First drafts are almost always too conservative \u2014 start at product-launch-keynote scale with crane, stage-light, particles; structure before effects (the four-way gather is the skeleton, atmosphere comes after)."
+  },
+  {
+    id: "ui-strip-away-outro",
+    role: "close",
+    name: "UI Strip-Away Outro",
+    purpose: 'The only "subtraction" outro \u2014 one click detonates all the UI to exit, leaving black with just the semantic focus (the clicked button). "Launch equals complexity returns to zero".',
+    energy: "med",
+    suggestedSeconds: 4,
+    promptHints: "A single click detonates the entire UI to evaporate \u2014 evaporating in order from the outer edges to the center, one layer every few frames, each layer flying outward off-frame; the black field leaves only the one clicked button.",
+    pitfall: "Evaporation must be ordered (outer-to-center, staggered, each layer with directional motion outward) \u2014 random or same-frame-all-vanish reads as a power-outage glitch."
+  },
+  {
+    id: "ui-to-brand-morph",
+    role: "close",
+    name: "UI To Brand Morph",
+    purpose: 'The brand finale fourth path \u2014 a product UI element morphs itself into the brand logo ("the UI you use every day IS this brand").',
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: 'A product UI element morphs itself into the brand mark \u2014 an icon flips once and resolves into the logo, one continuous deformation telling "the daily-use UI is the brand" in a single beat.',
+    pitfall: "It is a transformation (the reverse direction from morph-from-primitive, and distinct from a gather-without-transform group photo) \u2014 keep it one clean morph, do not pile effects."
+  },
+  {
+    id: "edit-hook-moves",
+    role: "close",
+    name: "Edit Hook (Button Ending)",
+    purpose: "Rhetoric on the timeline itself \u2014 the ending that takes it back: fade to black, logo holds (audience thinks it is over), a sudden easter-egg hard-cut, cut back to logo. A trailer button-ending.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: 'Fade to black, the logo fades in and holds (audience assumes it is over), then a sudden short hard-cut to a UI close-up easter-egg, then hard-cut back to the logo to truly close \u2014 playing with the audience "it is finished" expectation.',
+    pitfall: "At most one per film and only at the very end \u2014 a button-ending mid-film reads as a glitch."
+  },
+  {
+    id: "text-column-converge",
+    role: "close",
+    name: "Text Column Converge",
+    purpose: "Two words sit left and right like a table-of-contents standoff; only on the last word do they converge into the product name \u2014 one convergence retcons the whole rotation as suspense setup. Recap or version-reveal energy.",
+    energy: "med",
+    suggestedSeconds: 6,
+    promptHints: "Words alternate in left and right columns (perfectly still, equal margins), rotating through a feature list; only on the final word do the two halves converge once into the product name \u2014 one single convergence, no gradual shrink.",
+    pitfall: "The convergence must happen exactly once and only at the end; any gradual shrink spoils the reveal and dilutes it to a progress bar."
+  },
+  // ── action ────────────────────────────────────────────────────────────
+  {
+    id: "beat-cut-moves",
+    role: "action",
+    name: "Beat Cut",
+    purpose: "In highlight or sprint segments, make the CUT itself the drumbeat \u2014 trailer-style accelerating approach (rapid cuts into a held freeze) or awards-ceremony consecutive-flash ritual.",
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "The cut itself is the beat: variant A \u2014 trailer-style accelerating approach, several ever-faster cuts building to a dead-still hold; variant B \u2014 awards-ceremony, live footage punctuated by hard flashes then a long held freeze.",
+    pitfall: "Density-type high energy \u2014 sub-second beats, several channels jumping together; without an audio bed of kicks it reads as chaotic, not rhythmic."
+  },
+  {
+    id: "speed-ramp-freeze",
+    role: "action",
+    name: "Speed Ramp Freeze",
+    purpose: "Uniform flow reads as a slideshow. Two time-remap moves on one motion: speed-ramp (fast to gaze to fast, blur on the fast parts only) and freeze-annotate (flow to freeze, marker-pen circle the target to unfreeze).",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "On one continuous motion: variant speed-ramp \u2014 fast, then a slow gaze window, then fast again, with motion blur only on the fast segments (fast-blurred and slow-sharp contrast is half the effect); variant freeze \u2014 flow hard-freezes, a marker-pen circle strokes around the target, then it unfreezes and accelerates to catch up.",
+    pitfall: 'The slow or freeze window needs enough frames or the gaze does not land; the fast-to-slow slope contrast needs about tenfold or "slowed down" is not readable.'
+  },
+  {
+    id: "montage-rhythm-moves",
+    role: "action",
+    name: "Montage Rhythm",
+    purpose: "Paragraph-level rhythm design \u2014 charge-burst (blackout hold then explode), flow-sketch (three ultra-close mechanical clicks then whip to the result), or chain-open (a momentum-handoff opening chain).",
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "Paragraph-level rhythm shapes: A \u2014 pure black silent hold for one beat then explode open (EDM blackout); B \u2014 three ultra-close mechanical detail shots then whip-pan to the lit result; C \u2014 a chain of momentum handoffs opening the film.",
+    pitfall: "Variant A is at most one per film and MUST be sound-designed (the blackout frame cuts audio to dead silence, the explode frame is the audio boom) \u2014 unsynced it reads as broken."
+  },
+  {
+    id: "slam-entrance-moves",
+    role: "action",
+    name: "Slam Entrance",
+    purpose: 'The top of the entrance-vocabulary force scale \u2014 "slam". Directional (fisheye whip-in), weight (drop with ring-plus-dust-plus-shake), or conduction (the shockwave shoves neighbors aside).',
+    energy: "high",
+    suggestedSeconds: 4,
+    promptHints: "Card slams in with weight: A \u2014 fisheye-exaggerated perspective whip-in along the lens snapping flat; B \u2014 card drops at oversized scale, a ring burst plus dust plus impact shake all igniting on the same frame; C \u2014 the shockwave visibly shoves neighbor cards aside and they rebound.",
+    pitfall: "All three carry screenshake \u2014 do not stack shake-family cards in the same shot; one screenshake event per beat."
+  },
+  {
+    id: "scroll-brake-moves",
+    role: "action",
+    name: "Scroll Brake",
+    purpose: 'A whole year of updates scrolls past as a fast blur-band, then an exponential-deceleration hard-brake stops dead on today release, which lifts off highlighted while the rest dims. Density says "always shipping"; the stop says "today is the big one".',
+    energy: "high",
+    suggestedSeconds: 5,
+    promptHints: "A long vertical list scrolls past fast (blurring into a color band), then an exponential-deceleration hard-brake stops dead on one entry \u2014 that entry lifts off the surface and highlights while the rest dims; variant B snaps four L-brackets onto the stopped entry on the exact brake frame.",
+    pitfall: "The high-speed band does not need real readable text (it is a blur) \u2014 placeholder grey blocks are fine; reserve real text for the braked entry."
+  },
+  // ── emotion ───────────────────────────────────────────────────────────
+  {
+    id: "light-play-moves",
+    role: "emotion",
+    name: "Light Play",
+    purpose: "Treat light as a fourth brush (sweep, wipe, bloom): a dark-scene title reveal by a light sweep, crown the hero card with light, or impact-flare the slam frame. Light does what motion cannot.",
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: 'Light as a fourth brushstroke: a soft light sweep reveals a title out of darkness; or a quiet bloom crowns the hero card with light (low energy, the "lit" moment is the peak); or a hard impact-flare blooms on a slam frame.',
+    pitfall: "The crown variant is deliberately low-energy \u2014 the bloom is the only peak; over-animate it and it stops being a crown and becomes a trick."
+  },
+  {
+    id: "tension-camera-moves",
+    role: "emotion",
+    name: "Tension Camera",
+    purpose: 'Small moves, all the force in emotional semantics \u2014 freeze-and-orbit, tilt-righted, imperceptible slow push, or pull-back-dim. Each is a direct word for "what should the audience feel here".',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Small moves, heavy emotion: A \u2014 freeze mid-motion and orbit the camera around to examine; B \u2014 a tilted uneasy angle rolls back to level on the beat; C \u2014 an imperceptibly slow push building pressure, hard-cut to release at the peak; D \u2014 pull back while surroundings extinguish layer by layer, leaving one suspended point.",
+    pitfall: 'Variant C "first two seconds must be unnoticeable" is the design intent, not a flaw \u2014 judge it on full playback, not a frame pull.'
+  },
+  {
+    id: "collab-cursor-moves",
+    role: "emotion",
+    name: "Collab Cursor",
+    purpose: 'Elevate the named collab cursor to an actor \u2014 two named cursors choreograph a handoff story in pure dark space with zero UI, or several drift as ambient particles for "the team is here" warmth.',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: "Named collab cursors (with identity chips) as actors: A \u2014 two named cursors move in dark empty space, their positions telling a handoff story with no UI at all; B \u2014 several cursors drift in and float as ambient particles for team presence, one stopping to type a cameo.",
+    pitfall: "Chip color equals identity code, must be consistent film-wide (blue equals Designer stays blue); a mid-film color change reads as a different person."
+  },
+  {
+    id: "voice-waveform-live",
+    role: "emotion",
+    name: "Voice Waveform Live",
+    purpose: 'The only functional voiceprint \u2014 the "listening to you" live receipt. Speaking towers tall, pauses shrink to a dot-row, history scrolls left. The audience reads "it is really listening" from the rise and fall alone.',
+    energy: "med",
+    suggestedSeconds: 5,
+    promptHints: 'A live functional voiceprint: while "speaking" the waveform towers tall and dynamic, on "pauses" it shrinks to a dot-row, history scrolling left \u2014 the audience reads "it is genuinely listening" from the rise and fall alone, no other content needed.',
+    pitfall: "If the film has a real narrator or voice track, the waveform envelope MUST follow that voice \u2014 the speak and pause segments align to the audio speak and pause; a one-second offset reads as fake."
+  }
+];
+
+// src/recipes/index.ts
+function pickRecipes(role, n) {
+  if (!Number.isInteger(n) || n <= 0) return [];
+  const out = [];
+  for (const r of shotRecipes) {
+    if (out.length >= n) break;
+    if (r.role === role) out.push(r);
+  }
+  return out;
+}
+function recipesForArc(roles) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    const match = shotRecipes.find((r) => r.role === role);
+    if (match !== void 0 && !seen.has(match.id)) {
+      seen.add(match.id);
+      out.push(match);
+    }
+  }
+  return out;
+}
+
+// src/index.ts
+function createHyperframesRunner() {
+  return {
+    capability: "video",
+    available: () => Promise.resolve(true),
+    generate: (req) => {
+      const r = req;
+      return Promise.resolve(renderHyperframes(r.scenes, { ratio: r.ratio, title: r.title }));
+    }
+  };
+}
+async function renderMovie(events, opts = {}) {
+  const scenes = buildScenes(events, opts);
+  const log = opts.log ?? ((msg) => process.stderr.write(`${msg}
+`));
+  const sink = opts.notify ?? vibeCoreNotify;
+  let out = opts.out;
+  if ((opts.engine ?? "hyperframes") === "cinematic") {
+    if (cinematicAvailable() && ffmpegAvailable()) {
+      const cinOut = out ?? "./vibe-recap.mp4";
+      const cinOpts = { out: cinOut, log };
+      if (opts.apiKey !== void 0) cinOpts.apiKey = opts.apiKey;
+      const cin = await renderCinematic(scenes, cinOpts);
+      const result2 = { engine: "cinematic", path: cin.path };
+      notifyRenderDone(sink, result2);
+      return result2;
+    }
+    const why = !cinematicAvailable() ? "WAVESPEED_API_KEY is not set" : "ffmpeg is not on PATH";
+    log(`vibemovie: cinematic engine unavailable (${why}) \u2014 falling back to hyperframes (offline, zero keys)`);
+    if (out !== void 0) {
+      const htmlOut = out.replace(/\.(mp4|mov|webm|mkv)$/i, ".html");
+      if (htmlOut !== out) {
+        log(`vibemovie: writing the hyperframes HTML to ${htmlOut}`);
+        out = htmlOut;
+      }
+    }
+  }
+  const cascade = createCascade({
+    consent: createConsentLedger(),
+    pickLocal: (capability) => Promise.resolve(capability === "video" ? createHyperframesRunner() : null)
+  });
+  const resolved = await cascade.resolve({ capability: "video", allowEgress: false });
+  const provider = resolved.provider;
+  if (resolved.tier !== "local" || !("capability" in provider)) {
+    throw new Error("vibemovie v0 renders via the local Hyperframes tier only");
+  }
+  const req = { scenes };
+  if (opts.ratio !== void 0) req.ratio = opts.ratio;
+  if (opts.title !== void 0) req.title = opts.title;
+  const html = await provider.generate(req);
+  if (out !== void 0) {
+    await writeFile(out, html, "utf8");
+    const result2 = { engine: "hyperframes", html, path: out };
+    notifyRenderDone(sink, result2);
+    return result2;
+  }
+  const result = { engine: "hyperframes", html };
+  notifyRenderDone(sink, result);
+  return result;
+}
+function notifyRenderDone(sink, result) {
+  try {
+    sink(
+      makeEvent("render-done", "vibemovie", process.cwd(), {
+        summary: `rendered ${result.engine} recap${result.path !== void 0 ? ` \u2192 ${result.path}` : ""}`,
+        outputPath: result.path ?? null
+      })
+    );
+  } catch {
+  }
+}
+
+export {
+  RATIOS,
+  TEMPLATES,
+  buildScenes,
+  renderHyperframes,
+  ENGINES,
+  deriveReferencePrompts,
+  deriveBeats,
+  cinematicAvailable,
+  renderCinematic,
+  SHOT_ROLES,
+  ENERGY_LEVELS,
+  shotRecipes,
+  pickRecipes,
+  recipesForArc,
+  renderMovie
+};