@odori/cli 0.0.7 → 0.0.9

package/dist/{chunk-STVORYOF.js → chunk-TDM65HRW.js}

@@ -317,7 +317,7 @@ var toComponent = (item) => ({
 });
 var snapshotItems = async () => {
   try {
-    const loaded = await import("./registry-snapshot-ADKSTGDR.js");
+    const loaded = await import("./registry-snapshot-TKH2KAC3.js");
     return loaded.default.items;
   } catch {
     throw new Error(
@@ -809,553 +809,438 @@ var registryCommand = async () => {
 };
 
 // src/commands/dev.ts
-import { relative as relative7, resolve as resolve19 } from "path";
-import { homedir as homedir2 } from "os";
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
+import { relative as relative8, resolve as resolve20 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
 
-// src/jobs.ts
-import { mkdir as mkdir6, readFile as readFile7, readdir as readdir3, rename, writeFile as writeFile7 } from "fs/promises";
+// src/keystore.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join2, resolve as resolve8 } from "path";
-var buildsDir = (config) => resolve8(config.root, config.outDir, "builds");
-var jobFile = (config, id) => join2(buildsDir(config), `${id}.json`);
-var createJob = async (config, manifest, output, render) => {
-  await mkdir6(buildsDir(config), { recursive: true });
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const job = {
-    id: `job-${manifest.manifestHash.slice(0, 10)}-${Date.now().toString(36)}`,
-    videoId: manifest.videoId,
-    manifestHash: manifest.manifestHash,
-    status: "queued",
-    progress: 0,
-    attempts: 0,
-    logs: [],
-    createdAt: now,
-    updatedAt: now
-  };
-  const record = { job, manifest, output, ...render ? { render } : {} };
-  await writeFile7(jobFile(config, job.id), `${JSON.stringify(record, null, 2)}
-`, "utf8");
-  return record;
-};
-var readJob = async (config, id) => {
-  const file = jobFile(config, id);
-  if (!existsSync8(file)) throw new Error(`Unknown job "${id}". Run odori jobs to list them.`);
-  return JSON.parse(await readFile7(file, "utf8"));
-};
-var writeLocks = /* @__PURE__ */ new Map();
-var withJobLock = (id, task) => {
-  const previous = writeLocks.get(id) ?? Promise.resolve();
-  const next = previous.then(task, task);
-  writeLocks.set(
-    id,
-    next.catch(() => void 0)
-  );
-  return next;
-};
-var writeRecord = async (config, record) => {
-  const file = jobFile(config, record.job.id);
-  const temporary = `${file}.${process.pid}.tmp`;
-  await writeFile7(temporary, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-  await rename(temporary, file);
-};
-var updateJob = async (config, job) => withJobLock(job.id, async () => {
-  const record = await readJob(config, job.id);
-  const next = { ...job, logs: record.job.logs, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  await writeRecord(config, { ...record, job: next });
-  return next;
-});
-var appendJobLog = async (config, id, message2) => withJobLock(id, async () => {
-  const record = await readJob(config, id);
-  const next = {
-    ...record.job,
-    logs: [...record.job.logs.slice(-49), `${(/* @__PURE__ */ new Date()).toISOString()} ${message2}`],
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeRecord(config, { ...record, job: next });
-  return next;
-});
-var alive = (pid) => {
-  if (!pid) return false;
+import { chmod as chmod2, mkdir as mkdir6, readFile as readFile7, rm as rm3, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join2 } from "path";
+var storePath = () => join2(process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config"), "odori", "keys.json");
+var readStore = async () => {
+  const path = storePath();
+  if (!existsSync8(path)) return {};
   try {
-    process.kill(pid, 0);
-    return true;
+    const parsed = JSON.parse(await readFile7(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return Object.fromEntries(Object.entries(parsed).filter(([, value]) => typeof value === "string"));
   } catch {
-    return false;
+    return {};
   }
 };
-var reconcileJobs = async (config) => {
-  const stale = (await listJobs(config, { reconcile: false })).filter(
-    (job) => (job.status === "rendering" || job.status === "encoding") && !alive(job.pid)
-  );
-  for (const job of stale) {
-    await updateJob(config, {
-      ...job,
-      status: "failed",
-      error: "The render process exited before the job finished."
+var writeStore = async (store) => {
+  const path = storePath();
+  if (Object.keys(store).length === 0) {
+    await rm3(path, { force: true });
+    return;
+  }
+  await mkdir6(dirname4(path), { recursive: true, mode: 448 });
+  await writeFile7(path, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  await chmod2(path, 384);
+};
+var storedKey = async (variable) => (await readStore())[variable];
+var setStoredKey = async (variable, value) => {
+  const store = await readStore();
+  store[variable] = value;
+  await writeStore(store);
+};
+var clearStoredKey = async (variable) => {
+  const store = await readStore();
+  delete store[variable];
+  await writeStore(store);
+};
+var keySource = async (variable) => {
+  if (process.env[variable]) return "environment";
+  if ((await readStore())[variable]) return "stored";
+  return null;
+};
+
+// src/providers.ts
+var elevenlabs = {
+  name: "elevenlabs",
+  title: "ElevenLabs Music",
+  docsUrl: "https://elevenlabs.io/docs/api-reference/music",
+  keyVariable: "ELEVENLABS_API_KEY",
+  async verifyKey(apiKey) {
+    const response = await fetch("https://api.elevenlabs.io/v1/user", {
+      headers: { "xi-api-key": apiKey },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (response.ok) return true;
+    if (response.status === 401 || response.status === 403) return false;
+    throw new Error(`ElevenLabs answered ${response.status} to a key check.`);
+  },
+  async generate({ prompt, seconds, apiKey }) {
+    const response = await fetch("https://api.elevenlabs.io/v1/music", {
+      method: "POST",
+      headers: { "xi-api-key": apiKey, "content-type": "application/json" },
+      body: JSON.stringify({ prompt, music_length_ms: Math.round(seconds * 1e3) }),
+      signal: AbortSignal.timeout(3e5)
     });
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      throw new Error(
+        `ElevenLabs returned ${response.status} ${response.statusText}.` + (detail ? `
+${detail.slice(0, 400)}` : "") + (response.status === 401 ? `
+Is ${elevenlabs.keyVariable} a current key?` : "")
+      );
+    }
+    const type = response.headers.get("content-type") ?? "";
+    const extension = type.includes("wav") ? "wav" : type.includes("mp4") ? "m4a" : "mp3";
+    return { bytes: new Uint8Array(await response.arrayBuffer()), extension };
   }
-  return stale.length;
 };
-var listJobs = async (config, options = {}) => {
-  if (!existsSync8(buildsDir(config))) return [];
-  if (options.reconcile !== false) await reconcileJobs(config);
-  const files = (await readdir3(buildsDir(config))).filter((file) => file.endsWith(".json"));
-  const jobs = [];
-  for (const file of files) {
-    try {
-      const raw = await readFile7(join2(buildsDir(config), file), "utf8");
-      jobs.push(JSON.parse(raw).job);
-    } catch {
-      continue;
+var elevenlabsVoice = {
+  name: "elevenlabs",
+  title: "ElevenLabs Speech",
+  docsUrl: "https://elevenlabs.io/docs/api-reference/text-to-speech",
+  keyVariable: "ELEVENLABS_API_KEY",
+  // Rachel, the provider's most neutral narrator. --voice overrides.
+  defaultVoice: "21m00Tcm4TlvDq8ikWAM",
+  verifyKey: (apiKey) => elevenlabs.verifyKey(apiKey),
+  async speak({ script, voice, apiKey }) {
+    const response = await fetch(
+      `https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voice)}/with-timestamps?output_format=mp3_44100_128`,
+      {
+        method: "POST",
+        headers: { "xi-api-key": apiKey, "content-type": "application/json" },
+        body: JSON.stringify({ text: script, model_id: "eleven_multilingual_v2" }),
+        signal: AbortSignal.timeout(3e5)
+      }
+    );
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      throw new Error(
+        `ElevenLabs returned ${response.status} ${response.statusText}.` + (detail ? `
+${detail.slice(0, 400)}` : "") + (response.status === 401 ? `
+Is ${elevenlabsVoice.keyVariable} a current key?` : "")
+      );
     }
+    const payload = await response.json();
+    return {
+      bytes: Uint8Array.from(Buffer.from(payload.audio_base64, "base64")),
+      extension: "mp3",
+      alignment: {
+        characters: payload.alignment.characters,
+        startSeconds: payload.alignment.character_start_times_seconds,
+        endSeconds: payload.alignment.character_end_times_seconds
+      }
+    };
   }
-  return jobs.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 };
-var JobQueue = class {
-  chain = Promise.resolve();
-  enqueue(task) {
-    const result = this.chain.then(task, task);
-    this.chain = result.catch(() => void 0);
-    return result;
+var voiceProviders = { elevenlabs: elevenlabsVoice };
+var resolveVoiceProvider = (name) => {
+  const provider = voiceProviders[name];
+  if (!provider) {
+    throw new Error(
+      `No voice provider named "${name}". Available: ${Object.keys(voiceProviders).join(", ")}.`
+    );
+  }
+  return provider;
+};
+var musicProviders = { elevenlabs };
+var resolveMusicProvider = (name) => {
+  const provider = musicProviders[name];
+  if (!provider) {
+    throw new Error(
+      `No music provider named "${name}". Available: ${Object.keys(musicProviders).join(", ")}.`
+    );
   }
+  return provider;
 };
+var resolveKey = async (provider) => process.env[provider.keyVariable] ?? await storedKey(provider.keyVariable);
 
-// src/discovery.ts
-import { mkdir as mkdir7, readdir as readdir4, readFile as readFile8, stat, writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import { join as join3, relative as relative6, resolve as resolve9, sep as sep2 } from "path";
-import { hashString as hashString3 } from "odori";
-var IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", ".odori", "out", "dist", ".next"]);
-var walk = async (directory2, files = []) => {
-  const entries = await readdir4(directory2, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || IGNORED.has(entry.name)) continue;
-    const full = join3(directory2, entry.name);
-    if (entry.isDirectory()) await walk(full, files);
-    else files.push(full);
+// src/commands/bed.ts
+import { spawn as spawn3 } from "child_process";
+import { mkdir as mkdir10, stat, writeFile as writeFile11 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join5, relative as relative6, resolve as resolve12 } from "path";
+
+// src/render.ts
+import { spawn as spawn2 } from "child_process";
+import { copyFile as copyFile2, mkdir as mkdir9, rm as rm4, writeFile as writeFile10 } from "fs/promises";
+import { cpus } from "os";
+import { dirname as dirname5, join as join4, resolve as resolve11 } from "path";
+import { chromium } from "playwright-core";
+
+// src/audio-mix.ts
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve9 } from "path";
+import { duckEnvelope, envelopeAtFrame } from "odori";
+
+// src/cues.ts
+import { existsSync as existsSync9, statSync } from "fs";
+import { mkdir as mkdir7, writeFile as writeFile8 } from "fs/promises";
+import { basename, resolve as resolve8 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import {
+  SAMPLE_RATE,
+  cueSamples,
+  cueUrl,
+  defaultLayout,
+  encodeWav,
+  isCueDefinition,
+  resolveEntryLayout
+} from "odori";
+var cueCacheDir = (config) => resolve8(config.root, config.outDir, "cues");
+var cueFile = (config, url) => resolve8(cueCacheDir(config), basename(url));
+var materializeCues = async (config, brands, fps) => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const brand of brands) {
+    for (const value of Object.values(brand.audio.cues)) {
+      if (isCueDefinition(value)) seen.set(cueUrl(value), value);
+    }
   }
-  return files;
+  if (seen.size === 0) return [];
+  await mkdir7(cueCacheDir(config), { recursive: true });
+  const written = [];
+  for (const [url, cue] of seen) {
+    const file = cueFile(config, url);
+    if (existsSync9(file)) {
+      written.push({ cue, file, rendered: false });
+      continue;
+    }
+    const samples = cueSamples(cue, fps);
+    const signal = cue.render({ samples, sampleRate: SAMPLE_RATE });
+    await writeFile8(file, encodeWav(signal));
+    written.push({ cue, file, rendered: true });
+  }
+  return written;
 };
-var toIdentifier = (value, prefix) => {
-  const cleaned = value.replace(
-    /[^a-zA-Z0-9]+(.)?/g,
-    (_, character) => character ? character.toUpperCase() : ""
-  );
-  return `${prefix}${cleaned.charAt(0).toUpperCase()}${cleaned.slice(1)}`;
+var known = /* @__PURE__ */ new Map();
+var rendered = /* @__PURE__ */ new Map();
+var registerCues = (brands, fps) => {
+  for (const brand of brands) {
+    for (const value of Object.values(brand.audio.cues)) {
+      if (isCueDefinition(value)) known.set(cueUrl(value), { cue: value, fps });
+    }
+  }
+  return known.size;
 };
-var AUDIO_EXTENSIONS = /\.(m4a|mp3|wav|aac|ogg|opus|flac)$/i;
-var discoverAudio = async (config) => {
-  const root = resolve9(config.root, config.audioDir);
-  if (!existsSync9(root)) return [];
-  const publicRoot = resolve9(config.root, "public");
-  const files = (await walk(root)).filter((file) => AUDIO_EXTENSIONS.test(file)).sort();
-  return Promise.all(
-    files.map(async (file) => ({
-      name: relative6(root, file).replace(AUDIO_EXTENSIONS, "").split(sep2).join("/"),
-      url: file.startsWith(`${publicRoot}${sep2}`) ? `/${relative6(publicRoot, file).split(sep2).join("/")}` : `/${relative6(config.root, file).split(sep2).join("/")}`,
-      relativeFile: relative6(config.root, file),
-      bytes: (await stat(file)).size
-    }))
-  );
+var renderedCue = (url) => {
+  const cached = rendered.get(url);
+  if (cached) return cached;
+  const entry = known.get(url);
+  if (!entry) return null;
+  const signal = entry.cue.render({ samples: cueSamples(entry.cue, entry.fps), sampleRate: SAMPLE_RATE });
+  const wav = encodeWav(signal);
+  rendered.set(url, wav);
+  return wav;
 };
-var discoverProject = async (config) => {
-  const videosRoot = resolve9(config.root, config.videosDir);
-  if (!existsSync9(videosRoot)) {
-    throw new Error(`No ${config.videosDir}/ directory found in ${config.root}. Run "odori init" first.`);
-  }
-  const files = (await walk(videosRoot)).sort();
-  const audio = await discoverAudio(config);
-  const videos = [];
-  const previews = [];
-  const brands = [];
-  const categories = [];
-  const hashParts = [];
-  const importedBy = {};
-  const componentsRoot = resolve9(config.root, config.componentsDir);
-  for (const file of files) {
-    const relativeFile = relative6(config.root, file);
-    let contents = "";
-    if (/\.(tsx|ts|css|json)$/.test(file)) {
-      contents = await readFile8(file, "utf8");
-      hashParts.push(`${relativeFile}:${hashString3(contents)}`);
-    }
-    const base = file.split(sep2).pop() ?? "";
-    if (base === "category.json") {
-      const path = relative6(componentsRoot, resolve9(file, "..")).split(sep2).join("/");
-      if (!path.startsWith("..")) {
-        try {
-          const declared = JSON.parse(contents);
-          categories.push({
-            path,
-            ...typeof declared.name === "string" ? { name: declared.name } : {},
-            ...typeof declared.order === "number" ? { order: declared.order } : {}
-          });
-        } catch (error) {
-          log.warn(
-            `${relativeFile} is not valid JSON, so that directory names itself: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
+var isBrand = (value) => typeof value === "object" && value !== null && value.kind === "odori-brand";
+var isLayout = (value) => typeof value === "object" && value !== null && value.kind === "odori-layout";
+var importFresh = async (file) => await import(`${pathToFileURL2(file).href}?odori=${statSync(file).mtimeMs}`);
+var registerProjectCues = async (graph, load = importFresh) => {
+  for (const discovered of graph.brands) {
+    try {
+      const values = Object.values(await load(discovered.file));
+      registerCues(values.filter(isBrand), defaultLayout.format.fps);
+      for (const layout of values.filter(isLayout)) registerCues([layout.brand], layout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] could not read cues from ${discovered.relativeFile}: ${message(error)}`);
     }
-    if (base === "video.tsx") {
-      for (const match of contents.matchAll(/from\s+["'][^"']*\/components\/([^/"']+)\//g)) {
-        (importedBy[match[1]] ??= /* @__PURE__ */ new Set()).add(relative6(videosRoot, file).replace(/\/?video\.tsx$/, "") || "video");
-      }
+  }
+  for (const video of graph.videos) {
+    try {
+      const module = await load(video.file);
+      if (!module.default || !module.metadata) continue;
+      const entry = { component: module.default, metadata: module.metadata };
+      const layout = resolveEntryLayout(entry);
+      registerCues([layout.brand], layout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] generated cues in ${video.relativeFile} may use the default frame rate: ${message(error)}`);
     }
-    if (base === "video.tsx") {
-      const slug = relative6(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep2).join("/") || "video";
-      videos.push({
-        slug,
-        file,
-        relativeFile,
-        importPath: file,
-        identifier: toIdentifier(slug, "video")
-      });
-    } else if (
-      // A brand module is recognized by what it does, not where it sits. The
-      // scaffold defines its brand in videos/layout.tsx, so a directory-name
-      // rule alone left the default project's brand invisible to everything
-      // that reads this list — most visibly the dev server's cue registry,
-      // which then answered new cue URLs with 404s until a restart. Installed
-      // component source is excluded the way brand-file.ts excludes it: a
-      // component may mention defineBrand without being where a brand lives.
-      /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx") && !file.startsWith(componentsRoot + sep2) && (file.split(sep2).includes("brands") || contents.includes("defineBrand("))
-    ) {
-      const name = base.replace(/\.tsx?$/, "");
-      brands.push({
-        name,
-        file,
-        relativeFile,
-        // From the whole relative path, like previews: basenames repeat
-        // (`layout.tsx` beside `brands/layout.ts`), identifiers cannot.
-        identifier: toIdentifier(
-          `${relative6(videosRoot, file).replace(/\.tsx?$/, "").split(sep2).join("-")}-module`,
-          "brands"
-        )
-      });
-    } else if (base.endsWith(".preview.tsx")) {
-      const name = base.replace(/\.preview\.tsx$/, "");
-      previews.push({
-        name,
-        file,
-        relativeFile,
-        importPath: file,
-        identifier: toIdentifier(`${relative6(videosRoot, file).split(sep2).join("-")}`, "preview")
-      });
-    }
-  }
-  for (const preview of previews) {
-    const users = importedBy[preview.name];
-    if (users) preview.usedBy = [...users].sort();
   }
-  return { videos, previews, brands, audio, categories, sourceHash: hashString3(hashParts.join("|")) };
+  return known.size;
 };
-var generateImports = (graph, outDir) => {
-  const importPath = (file) => {
-    const relativePath = relative6(outDir, file).split(sep2).join("/");
-    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-  };
-  const lines = [
-    "// Generated by odori. Do not edit.",
-    'import type {VideoEntry} from "odori";',
-    "",
-    ...graph.videos.map(
-      (video) => `import ${video.identifier}, {metadata as ${video.identifier}Metadata} from "${importPath(video.file)}";`
-    ),
-    ...graph.previews.map((preview) => `import ${preview.identifier} from "${importPath(preview.file)}";`),
-    ...graph.brands.map((brand) => `import * as ${brand.identifier} from "${importPath(brand.file)}";`),
-    "",
-    "export const videos: VideoEntry[] = [",
-    ...graph.videos.map(
-      (video) => `  {component: ${video.identifier}, metadata: {...${video.identifier}Metadata, id: ${video.identifier}Metadata.id || ${JSON.stringify(video.slug)}}},`
-    ),
-    "];",
-    "",
-    "export const componentPreviews = [",
-    ...graph.previews.map((preview) => `  {id: ${JSON.stringify(preview.name)}, preview: ${preview.identifier}},`),
-    "];",
-    "",
-    "export const brands = [",
-    ...graph.brands.map(
-      (brand) => `  ...Object.values(${brand.identifier}).filter((value) => (value as {kind?: string})?.kind === "odori-brand"),`
-    ),
-    "];",
-    ""
+var message = (error) => error instanceof Error ? error.message : String(error);
+
+// src/audio-mix.ts
+var resolveCueFile = (config, src) => {
+  if (/^https?:\/\//.test(src)) return null;
+  if (src.startsWith("/__odori/cue/")) {
+    const generated = cueFile(config, src);
+    return existsSync10(generated) ? generated : null;
+  }
+  const candidates = [
+    resolve9(config.root, "public", src.replace(/^\//, "")),
+    resolve9(config.root, src.replace(/^\//, ""))
   ];
-  return lines.join("\n");
+  return candidates.find((candidate) => existsSync10(candidate)) ?? null;
 };
-var writeGenerated = async (config, graph) => {
-  const outDir = resolve9(config.root, config.outDir);
-  await mkdir7(outDir, { recursive: true });
-  const target = join3(outDir, "imports.generated.ts");
-  await writeFile8(target, generateImports(graph, outDir), "utf8");
-  await writeFile8(
-    join3(outDir, "catalog.json"),
-    `${JSON.stringify(
-      {
-        sourceHash: graph.sourceHash,
-        videos: graph.videos.map((video) => ({ slug: video.slug, file: video.relativeFile })),
-        previews: graph.previews.map((preview) => ({
-          name: preview.name,
-          file: preview.relativeFile,
-          usedBy: preview.usedBy ?? []
-        })),
-        brands: graph.brands.map((brand) => ({ name: brand.name, file: brand.relativeFile })),
-        audio: graph.audio.map((entry) => ({ name: entry.name, url: entry.url, file: entry.relativeFile }))
-      },
-      null,
-      2
-    )}
-`,
-    "utf8"
+var volumeFilter = (cue, cues, fps) => {
+  const authored = cue.gainPoints ?? [];
+  const frames = [
+    .../* @__PURE__ */ new Set([
+      ...duckEnvelope(cue, cues).map((point) => point.frame),
+      ...authored.map((point) => point.frame)
+    ])
+  ].sort(
+    (left, right) => left - right
   );
-  return target;
+  const duck = duckEnvelope(cue, cues);
+  const points = frames.map((frame) => ({
+    seconds: (frame - cue.fromFrame) / fps,
+    value: envelopeAtFrame(duck, frame) * (authored.length > 0 ? envelopeAtFrame(authored, frame) : 1) * cue.gain
+  }));
+  const constant = points.every((point) => point.value === points[0].value);
+  if (constant) return `volume=${(points[0]?.value ?? cue.gain).toFixed(4)}`;
+  let expression = points[points.length - 1].value.toFixed(4);
+  for (let index = points.length - 1; index > 0; index -= 1) {
+    const previous = points[index - 1];
+    const current = points[index];
+    const span = current.seconds - previous.seconds;
+    const segment = span <= 0 ? current.value.toFixed(4) : `${previous.value.toFixed(4)}+${(current.value - previous.value).toFixed(4)}*(t-${previous.seconds.toFixed(
+      4
+    )})/${span.toFixed(4)}`;
+    expression = `if(lt(t,${current.seconds.toFixed(4)}),${segment},${expression})`;
+  }
+  return `volume=volume='${expression}':eval=frame`;
+};
+var buildAudioFilter = (inputs, options) => {
+  const { fps, durationInFrames, targetLufs } = options;
+  const totalSeconds = durationInFrames / fps;
+  const cues = inputs.map(({ cue }) => cue);
+  const parts = [];
+  const labels = [];
+  inputs.forEach(({ cue }, index) => {
+    const start = cue.trimStartSeconds;
+    const length2 = cue.durationInFrames / fps;
+    const delay = Math.round(cue.fromFrame / fps * 1e3);
+    const volume = volumeFilter(cue, cues, fps);
+    const label = `a${index}`;
+    const chain = [
+      // Index 1 is the video input, so audio inputs start at 1.
+      cue.loop ? `aloop=loop=-1:size=2147483647` : null,
+      // Every input is brought to one format before anything else touches it.
+      // Cues are mono, files are usually stereo, and a graph that leaves the
+      // difference to be inferred works on the encoder that happens to be
+      // installed and fails on the pinned one.
+      "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo",
+      `atrim=start=${start.toFixed(4)}:duration=${length2.toFixed(4)}`,
+      "asetpts=PTS-STARTPTS",
+      cue.fadeInFrames > 0 ? `afade=t=in:st=0:d=${(cue.fadeInFrames / fps).toFixed(4)}` : null,
+      cue.fadeOutFrames > 0 ? `afade=t=out:st=${Math.max(0, length2 - cue.fadeOutFrames / fps).toFixed(4)}:d=${(cue.fadeOutFrames / fps).toFixed(4)}` : null,
+      volume,
+      delay > 0 ? `adelay=${delay}|${delay}` : null,
+      `apad=whole_dur=${totalSeconds.toFixed(4)}`,
+      `atrim=duration=${totalSeconds.toFixed(4)}`
+    ].filter(Boolean).join(",");
+    parts.push(`[${index + 1}:a]${chain}[${label}]`);
+    labels.push(`[${label}]`);
+  });
+  parts.push(
+    `${labels.join("")}amix=inputs=${labels.length}:normalize=0:dropout_transition=0[mixed]`,
+    // loudnorm resamples to its own rate and can drop the layout on the way
+    // out, so the last link states the output format rather than negotiating
+    // it with whatever encoder is downstream.
+    /* No LRA target: a mix cannot be given a loudness range it does not have,
+       so asking for one states an intent the filter cannot honour. Measured
+       against the beds here it changes nothing either way, which is the point
+       — the range comes from the material, and asking for eleven from a bed
+       mastered to two only hides that. */
+    `[mixed]loudnorm=I=${targetLufs}:TP=-1.5,aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo[audio]`
+  );
+  return { filter: parts.join(";"), label: "[audio]" };
 };
 
-// src/project.ts
-import { resolve as resolve12 } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-import {
-  createRenderManifest,
-  entryDurationInFrames,
-  resolveEntryLayout,
-  resolveVideoId
-} from "odori";
+// src/chunks.ts
+var length = (chunk) => chunk.end - chunk.start + 1;
+var planChunks = ({
+  durationInFrames,
+  scenes = [],
+  concurrency,
+  maxChunkFrames = 120
+}) => {
+  if (durationInFrames <= 0) return { chunks: [], lanes: [] };
+  const bounded = Math.max(1, Math.min(concurrency, durationInFrames));
+  const ordered = [...scenes].filter((scene) => scene.durationInFrames > 0).sort((left, right) => left.start - right.start);
+  const spans = [];
+  let cursor = 0;
+  for (const scene of ordered) {
+    if (scene.start > cursor) spans.push({ start: cursor, end: scene.start - 1 });
+    const end = Math.min(durationInFrames - 1, scene.start + scene.durationInFrames - 1);
+    if (end >= scene.start) spans.push({ start: scene.start, end, sceneId: scene.id });
+    cursor = end + 1;
+  }
+  if (cursor < durationInFrames) spans.push({ start: cursor, end: durationInFrames - 1 });
+  const chunks = [];
+  for (const span of spans) {
+    const target = Math.max(1, Math.min(maxChunkFrames, Math.ceil(durationInFrames / bounded)));
+    const total = span.end - span.start + 1;
+    const pieces = Math.max(1, Math.ceil(total / target));
+    const size = Math.ceil(total / pieces);
+    for (let piece = 0; piece < pieces; piece += 1) {
+      const start = span.start + piece * size;
+      const end = Math.min(span.end, start + size - 1);
+      if (start > end) continue;
+      chunks.push({ index: chunks.length, start, end, sceneId: span.sceneId });
+    }
+  }
+  const lanes = Array.from({ length: bounded }, () => []);
+  const loads = new Array(bounded).fill(0);
+  for (const chunk of [...chunks].sort((left, right) => length(right) - length(left))) {
+    let lane = 0;
+    for (let index = 1; index < bounded; index += 1) if (loads[index] < loads[lane]) lane = index;
+    lanes[lane].push(chunk);
+    loads[lane] += length(chunk);
+  }
+  for (const lane of lanes) lane.sort((left, right) => left.start - right.start);
+  return { chunks, lanes: lanes.filter((lane) => lane.length > 0) };
+};
+var chunkFrames = (chunk) => Array.from({ length: length(chunk) }, (_, offset) => chunk.start + offset);
 
-// src/integrity.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve10 } from "path";
-var cacheFile = (config) => resolve10(config.root, config.outDir, "cache", "integrity.json");
-var readCache = async (config) => {
-  const file = cacheFile(config);
-  if (!existsSync10(file)) return {};
+// src/chunk-cache.ts
+import { existsSync as existsSync11 } from "fs";
+import { copyFile, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import { join as join3, resolve as resolve10 } from "path";
+import { hashValue } from "odori";
+var cacheDir2 = (config) => resolve10(config.root, config.outDir, "cache", "chunks");
+var chunkKey = (identity) => hashValue({
+  videoId: identity.videoId,
+  // The browser that drew the frames is part of what the frames are. Without
+  // it, upgrading Chrome silently reuses pixels the new build would not have
+  // produced, which is the exact drift the pinned toolchain exists to stop.
+  renderer: identity.renderer ?? null,
+  // A chunk is an encoded file, not a bag of frames: H.264 chunks cannot be
+  // copied into a WebM, so a cache that ignored the codec would hand the
+  // muxer streams it cannot write.
+  format: identity.format ?? null,
+  sceneId: identity.chunk.sceneId ?? null,
+  start: identity.chunk.start,
+  end: identity.chunk.end,
+  width: identity.width,
+  height: identity.height,
+  fps: identity.fps,
+  preset: identity.preset,
+  quality: identity.quality ?? null,
+  scale: identity.scale ?? null,
+  input: identity.input ?? null
+});
+var readChunkRecord = async (config, key) => {
+  const meta = join3(cacheDir2(config), `${key}.json`);
+  const media = join3(cacheDir2(config), `${key}.mp4`);
+  if (!existsSync11(meta) || !existsSync11(media)) return null;
   try {
-    return JSON.parse(await readFile9(file, "utf8"));
+    return JSON.parse(await readFile8(meta, "utf8"));
   } catch {
-    return {};
+    return null;
   }
 };
-var writeCache = async (config, cache) => {
-  const file = cacheFile(config);
-  await mkdir8(dirname4(file), { recursive: true });
-  await writeFile9(file, `${JSON.stringify(cache, null, 2)}
+var useChunkRecord = async (config, key, destination) => {
+  await copyFile(join3(cacheDir2(config), `${key}.mp4`), destination);
+};
+var writeChunkRecord = async (config, key, signatures, file) => {
+  const directory2 = cacheDir2(config);
+  await mkdir8(directory2, { recursive: true });
+  await copyFile(file, join3(directory2, `${key}.mp4`));
+  const record = { key, signatures, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile9(join3(directory2, `${key}.json`), `${JSON.stringify(record)}
 `, "utf8");
 };
-var sha256 = (bytes) => `sha256-${createHash3("sha256").update(bytes).digest("base64")}`;
-var localCandidates = (config, url) => [
-  resolve10(config.root, "public", url.replace(/^\//, "")),
-  resolve10(config.root, url.replace(/^\//, ""))
-];
-var isServed = (config, file) => file.startsWith(resolve10(config.root, "public") + "/");
-var createIntegrityResolver = async (config) => {
-  const cache = await readCache(config);
-  const warned = /* @__PURE__ */ new Set();
-  let dirty = false;
-  const resolveIntegrity = async (url) => {
-    if (url.startsWith("/__odori/cue/")) return `cue-${url.slice(url.lastIndexOf("-") + 1).replace(/\.wav$/, "")}`;
-    const local = localCandidates(config, url).find((candidate) => existsSync10(candidate));
-    if (local) {
-      if (!isServed(config, local) && !warned.has(url)) {
-        warned.add(url);
-        log.warn(`${url} resolves to ${local}, which is outside public/ and will not be served. Move it into public/.`);
-      }
-      const bytes = await readFile9(local);
-      const { mtimeMs } = await import("fs/promises").then((fs) => fs.stat(local));
-      const hit = cache[url];
-      if (hit && hit.mtimeMs === mtimeMs && hit.size === bytes.byteLength) return hit.integrity;
-      const integrity = sha256(bytes);
-      cache[url] = { integrity, size: bytes.byteLength, mtimeMs };
-      dirty = true;
-      return integrity;
-    }
-    if (!/^https?:\/\//.test(url)) return "unresolved";
-    if (cache[url]) return cache[url].integrity;
-    try {
-      const response = await fetch(url, { signal: AbortSignal.timeout(1e4) });
-      if (!response.ok) return "unresolved";
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      const integrity = sha256(bytes);
-      cache[url] = { integrity, size: bytes.byteLength };
-      dirty = true;
-      return integrity;
-    } catch {
-      return "unresolved";
-    }
-  };
-  return {
-    resolve: resolveIntegrity,
-    flush: async () => {
-      if (dirty) await writeCache(config, cache);
-    }
-  };
-};
-
-// src/prepare-cache.ts
-import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir9, readFile as readFile10, readdir as readdir5, rm as rm3, writeFile as writeFile10 } from "fs/promises";
-import { join as join4, resolve as resolve11 } from "path";
-import { hashValue } from "odori";
-
-// src/paths.ts
-var outputName = (id) => id.split("/").join("-");
-var fileKey = (id) => id.split("/").join("+");
-
-// src/prepare-cache.ts
-var directory = (config) => resolve11(config.root, config.outDir, "cache", "prepare");
-var prepareCacheKey = (key) => `${fileKey(key.videoId)}__${hashValue(key)}`;
-var readPrepareCache = async (config, key) => {
-  const file = join4(directory(config), `${prepareCacheKey(key)}.json`);
-  if (!existsSync11(file)) return { hit: false, value: void 0 };
-  try {
-    const entry = JSON.parse(await readFile10(file, "utf8"));
-    return { hit: true, value: entry.value };
-  } catch {
-    return { hit: false, value: void 0 };
-  }
-};
-var writePrepareCache = async (config, key, value) => {
-  if (value === void 0) return;
-  const target = directory(config);
-  await mkdir9(target, { recursive: true });
-  const entry = { key, value, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-  await writeFile10(join4(target, `${prepareCacheKey(key)}.json`), `${JSON.stringify(entry, null, 2)}
-`, "utf8");
-};
-var clearPrepareCache = async (config, videoId) => {
-  const target = directory(config);
-  if (!existsSync11(target)) return 0;
-  const files = await readdir5(target);
-  const matches = files.filter((file) => videoId ? file.startsWith(`${fileKey(videoId)}__`) : file.endsWith(".json"));
-  await Promise.all(matches.map((file) => rm3(join4(target, file), { force: true })));
-  return matches.length;
-};
-
-// src/project.ts
-var loadVideos = async (graph) => {
-  const loaded = [];
-  for (const discovered of graph.videos) {
-    const module = await import(pathToFileURL2(discovered.file).href);
-    if (!module.default || !module.metadata) {
-      throw new Error(`${discovered.relativeFile} must export metadata and a default React component.`);
-    }
-    const entry = {
-      component: module.default,
-      metadata: { ...module.metadata, id: resolveVideoId(module.metadata.id, discovered.slug) }
-    };
-    loaded.push({
-      entry,
-      file: discovered.file,
-      relativeFile: discovered.relativeFile,
-      durationInFrames: entryDurationInFrames(entry, resolveEntryLayout(entry))
-    });
-  }
-  const byId = /* @__PURE__ */ new Map();
-  for (const video of loaded) {
-    const id = video.entry.metadata.id;
-    const first = byId.get(id);
-    if (first) throw new Error(`Duplicate video id "${id}":
-  ${first}
-  ${video.relativeFile}`);
-    byId.set(id, video.relativeFile);
-  }
-  return loaded;
-};
-var findVideo = (videos, id) => {
-  const found = videos.find((video) => video.entry.metadata.id === id);
-  if (!found) {
-    throw new Error(
-      `Unknown video "${id}". Known videos: ${videos.map((video) => video.entry.metadata.id).join(", ") || "none"}`
-    );
-  }
-  return found;
-};
-var runPrepare = async (video, config, graph, input, options = {}) => {
-  const prepareFile = resolve12(video.file, "..", "prepare.ts");
-  let prepare;
-  try {
-    const module = await import(pathToFileURL2(prepareFile).href);
-    prepare = module.prepare ?? module.default;
-  } catch (error) {
-    if (error.code === "ERR_MODULE_NOT_FOUND") return void 0;
-    throw error;
-  }
-  if (!prepare) return void 0;
-  const key = {
-    videoId: video.entry.metadata.id,
-    sourceHash: graph.sourceHash,
-    input,
-    version: prepare.version ?? "1"
-  };
-  if (!options.refresh) {
-    const cached = await readPrepareCache(config, key);
-    if (cached.hit) return cached.value;
-  }
-  const memo = /* @__PURE__ */ new Map();
-  const value = await prepare.run({
-    input,
-    assets: {
-      resolve: async (reference) => {
-        const asset = (config.assets ?? []).find((item) => item.reference === reference);
-        if (!asset) throw new Error(`Unknown asset reference: ${reference}`);
-        return asset.url;
-      }
-    },
-    cache: {
-      getOrSet: async (cacheKey, factory) => {
-        if (!memo.has(cacheKey)) memo.set(cacheKey, await factory());
-        return memo.get(cacheKey);
-      }
-    }
-  });
-  await writePrepareCache(config, key, value);
-  return value;
-};
-var freezeManifest = async (video, graph, config, rawInput, options = {}) => {
-  const layout = resolveEntryLayout(video.entry);
-  const merged = { ...video.entry.metadata.defaultProps, ...rawInput };
-  const input = video.entry.metadata.schema ? video.entry.metadata.schema.parse(merged) : merged;
-  const prepared = await runPrepare(video, config, graph, input, { refresh: options.refreshPrepare });
-  const integrity = await createIntegrityResolver(config);
-  const assets = await Promise.all(
-    (config.assets ?? []).map(async (asset) => ({ ...asset, integrity: await integrity.resolve(asset.url) }))
-  );
-  const audio = await Promise.all(
-    (options.audio ?? []).map(async (cue) => ({ ...cue, integrity: await integrity.resolve(cue.src) }))
-  );
-  const fonts = await Promise.all(
-    layout.brand.fonts.map(async (font) => ({
-      family: font.family,
-      url: font.url,
-      integrity: await integrity.resolve(font.url)
-    }))
-  );
-  await integrity.flush();
-  for (const cue of audio) {
-    if (cue.integrity === "unresolved") log.warn(`Audio source could not be resolved for hashing: ${cue.src}`);
-  }
-  const manifest = createRenderManifest({
-    entry: video.entry,
-    layout,
-    input,
-    prepared,
-    sourceHash: graph.sourceHash,
-    durationInFrames: video.durationInFrames,
-    scenes: options.scenes ?? [],
-    audio,
-    assets,
-    fonts,
-    // Which Chrome drew it and which FFmpeg encoded it. Two files that differ
-    // are then a question with an answer rather than a mystery.
-    toolchain: await renderToolchain(config),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  return { manifest, input, prepared };
-};
+var signaturesMatch = (recorded, observed) => recorded.length === observed.length && recorded.every((signature, index) => signature === observed[index]);
 
 // src/formats.ts
 var QUALITIES = ["studio", "social", "web"];
@@ -1471,315 +1356,42 @@ var resolveFormat = (requested, output) => {
 var alphaWarning = (format, transparent) => transparent && !format.alpha ? `${format.name} has no alpha channel, so the transparent background will render black. Use webm, prores, or png.` : null;
 
 // src/render.ts
-import { spawn as spawn2 } from "child_process";
-import { copyFile as copyFile2, mkdir as mkdir12, rm as rm4, writeFile as writeFile13 } from "fs/promises";
-import { cpus } from "os";
-import { dirname as dirname5, join as join6, resolve as resolve16 } from "path";
-import { chromium } from "playwright-core";
-
-// src/audio-mix.ts
-import { existsSync as existsSync13 } from "fs";
-import { resolve as resolve14 } from "path";
-import { duckEnvelope, envelopeAtFrame } from "odori";
-
-// src/cues.ts
-import { existsSync as existsSync12, statSync } from "fs";
-import { mkdir as mkdir10, writeFile as writeFile11 } from "fs/promises";
-import { basename, resolve as resolve13 } from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
-import {
-  SAMPLE_RATE,
-  cueSamples,
-  cueUrl,
-  defaultLayout,
-  encodeWav,
-  isCueDefinition,
-  resolveEntryLayout as resolveEntryLayout2
-} from "odori";
-var cueCacheDir = (config) => resolve13(config.root, config.outDir, "cues");
-var cueFile = (config, url) => resolve13(cueCacheDir(config), basename(url));
-var materializeCues = async (config, brands, fps) => {
-  const seen = /* @__PURE__ */ new Map();
-  for (const brand of brands) {
-    for (const value of Object.values(brand.audio.cues)) {
-      if (isCueDefinition(value)) seen.set(cueUrl(value), value);
-    }
-  }
-  if (seen.size === 0) return [];
-  await mkdir10(cueCacheDir(config), { recursive: true });
-  const written = [];
-  for (const [url, cue] of seen) {
-    const file = cueFile(config, url);
-    if (existsSync12(file)) {
-      written.push({ cue, file, rendered: false });
-      continue;
-    }
-    const samples = cueSamples(cue, fps);
-    const signal = cue.render({ samples, sampleRate: SAMPLE_RATE });
-    await writeFile11(file, encodeWav(signal));
-    written.push({ cue, file, rendered: true });
+var encodeParam = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+var renderUrl = (origin, target, frame) => {
+  const params = new URLSearchParams({ render: "1", video: target.videoId, frame: String(frame) });
+  if (target.input) params.set("input", encodeParam(target.input));
+  if (target.prepared !== void 0) params.set("prepared", encodeParam(target.prepared));
+  return `${origin}/?${params.toString()}`;
+};
+var DEFAULT_GRAPHICS = "software";
+var browserArgs = (graphics = DEFAULT_GRAPHICS) => graphics === "gpu" ? ["--use-gl=angle", "--use-angle=default"] : ["--enable-unsafe-swiftshader"];
+var openRenderPage = async (origin, target, config, graphics = DEFAULT_GRAPHICS) => {
+  const executablePath = await browserExecutable(config);
+  const browser = await chromium.launch({ executablePath, headless: true, args: browserArgs(graphics) });
+  const page = await browser.newPage({
+    viewport: { width: target.width, height: target.height },
+    deviceScaleFactor: 1
+  });
+  const errors = [];
+  page.on("pageerror", (error) => errors.push(error.message));
+  await page.goto(renderUrl(origin, target, 0), { waitUntil: "networkidle" });
+  try {
+    await page.locator('[data-odori-frame="0"]').waitFor({ timeout: 2e4 });
+  } catch {
+    await browser.close();
+    throw new Error(`The video did not mount.${errors.length ? ` ${errors.join(" ")}` : ""}`);
   }
-  return written;
+  await page.evaluate(() => document.fonts.ready);
+  return { browser, page, errors };
 };
-var known = /* @__PURE__ */ new Map();
-var rendered = /* @__PURE__ */ new Map();
-var registerCues = (brands, fps) => {
-  for (const brand of brands) {
-    for (const value of Object.values(brand.audio.cues)) {
-      if (isCueDefinition(value)) known.set(cueUrl(value), { cue: value, fps });
-    }
+var seekTo = async (page, frame, errors) => {
+  await page.evaluate((next) => window.__ODORI_SET_FRAME__?.(next), frame);
+  try {
+    await page.locator(`[data-odori-frame="${frame}"]`).waitFor({ timeout: 2e4 });
+  } catch (error) {
+    const reported = errors?.length ? ` ${[...new Set(errors)].join(" ")}` : "";
+    throw new Error(`Frame ${frame} never became ready.${reported}`, { cause: error });
   }
-  return known.size;
-};
-var renderedCue = (url) => {
-  const cached = rendered.get(url);
-  if (cached) return cached;
-  const entry = known.get(url);
-  if (!entry) return null;
-  const signal = entry.cue.render({ samples: cueSamples(entry.cue, entry.fps), sampleRate: SAMPLE_RATE });
-  const wav = encodeWav(signal);
-  rendered.set(url, wav);
-  return wav;
-};
-var isBrand = (value) => typeof value === "object" && value !== null && value.kind === "odori-brand";
-var isLayout = (value) => typeof value === "object" && value !== null && value.kind === "odori-layout";
-var importFresh = async (file) => await import(`${pathToFileURL3(file).href}?odori=${statSync(file).mtimeMs}`);
-var registerProjectCues = async (graph, load = importFresh) => {
-  for (const discovered of graph.brands) {
-    try {
-      const values = Object.values(await load(discovered.file));
-      registerCues(values.filter(isBrand), defaultLayout.format.fps);
-      for (const layout of values.filter(isLayout)) registerCues([layout.brand], layout.format.fps);
-    } catch (error) {
-      log.warn(`[odori] could not read cues from ${discovered.relativeFile}: ${message(error)}`);
-    }
-  }
-  for (const video of graph.videos) {
-    try {
-      const module = await load(video.file);
-      if (!module.default || !module.metadata) continue;
-      const entry = { component: module.default, metadata: module.metadata };
-      const layout = resolveEntryLayout2(entry);
-      registerCues([layout.brand], layout.format.fps);
-    } catch (error) {
-      log.warn(`[odori] generated cues in ${video.relativeFile} may use the default frame rate: ${message(error)}`);
-    }
-  }
-  return known.size;
-};
-var message = (error) => error instanceof Error ? error.message : String(error);
-
-// src/audio-mix.ts
-var resolveCueFile = (config, src) => {
-  if (/^https?:\/\//.test(src)) return null;
-  if (src.startsWith("/__odori/cue/")) {
-    const generated = cueFile(config, src);
-    return existsSync13(generated) ? generated : null;
-  }
-  const candidates = [
-    resolve14(config.root, "public", src.replace(/^\//, "")),
-    resolve14(config.root, src.replace(/^\//, ""))
-  ];
-  return candidates.find((candidate) => existsSync13(candidate)) ?? null;
-};
-var volumeFilter = (cue, cues, fps) => {
-  const authored = cue.gainPoints ?? [];
-  const frames = [
-    .../* @__PURE__ */ new Set([
-      ...duckEnvelope(cue, cues).map((point) => point.frame),
-      ...authored.map((point) => point.frame)
-    ])
-  ].sort(
-    (left, right) => left - right
-  );
-  const duck = duckEnvelope(cue, cues);
-  const points = frames.map((frame) => ({
-    seconds: (frame - cue.fromFrame) / fps,
-    value: envelopeAtFrame(duck, frame) * (authored.length > 0 ? envelopeAtFrame(authored, frame) : 1) * cue.gain
-  }));
-  const constant = points.every((point) => point.value === points[0].value);
-  if (constant) return `volume=${(points[0]?.value ?? cue.gain).toFixed(4)}`;
-  let expression = points[points.length - 1].value.toFixed(4);
-  for (let index = points.length - 1; index > 0; index -= 1) {
-    const previous = points[index - 1];
-    const current = points[index];
-    const span = current.seconds - previous.seconds;
-    const segment = span <= 0 ? current.value.toFixed(4) : `${previous.value.toFixed(4)}+${(current.value - previous.value).toFixed(4)}*(t-${previous.seconds.toFixed(
-      4
-    )})/${span.toFixed(4)}`;
-    expression = `if(lt(t,${current.seconds.toFixed(4)}),${segment},${expression})`;
-  }
-  return `volume=volume='${expression}':eval=frame`;
-};
-var buildAudioFilter = (inputs, options) => {
-  const { fps, durationInFrames, targetLufs } = options;
-  const totalSeconds = durationInFrames / fps;
-  const cues = inputs.map(({ cue }) => cue);
-  const parts = [];
-  const labels = [];
-  inputs.forEach(({ cue }, index) => {
-    const start = cue.trimStartSeconds;
-    const length2 = cue.durationInFrames / fps;
-    const delay = Math.round(cue.fromFrame / fps * 1e3);
-    const volume = volumeFilter(cue, cues, fps);
-    const label = `a${index}`;
-    const chain = [
-      // Index 1 is the video input, so audio inputs start at 1.
-      cue.loop ? `aloop=loop=-1:size=2147483647` : null,
-      // Every input is brought to one format before anything else touches it.
-      // Cues are mono, files are usually stereo, and a graph that leaves the
-      // difference to be inferred works on the encoder that happens to be
-      // installed and fails on the pinned one.
-      "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo",
-      `atrim=start=${start.toFixed(4)}:duration=${length2.toFixed(4)}`,
-      "asetpts=PTS-STARTPTS",
-      cue.fadeInFrames > 0 ? `afade=t=in:st=0:d=${(cue.fadeInFrames / fps).toFixed(4)}` : null,
-      cue.fadeOutFrames > 0 ? `afade=t=out:st=${Math.max(0, length2 - cue.fadeOutFrames / fps).toFixed(4)}:d=${(cue.fadeOutFrames / fps).toFixed(4)}` : null,
-      volume,
-      delay > 0 ? `adelay=${delay}|${delay}` : null,
-      `apad=whole_dur=${totalSeconds.toFixed(4)}`,
-      `atrim=duration=${totalSeconds.toFixed(4)}`
-    ].filter(Boolean).join(",");
-    parts.push(`[${index + 1}:a]${chain}[${label}]`);
-    labels.push(`[${label}]`);
-  });
-  parts.push(
-    `${labels.join("")}amix=inputs=${labels.length}:normalize=0:dropout_transition=0[mixed]`,
-    // loudnorm resamples to its own rate and can drop the layout on the way
-    // out, so the last link states the output format rather than negotiating
-    // it with whatever encoder is downstream.
-    `[mixed]loudnorm=I=${targetLufs}:TP=-1.5:LRA=11,aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo[audio]`
-  );
-  return { filter: parts.join(";"), label: "[audio]" };
-};
-
-// src/chunks.ts
-var length = (chunk) => chunk.end - chunk.start + 1;
-var planChunks = ({
-  durationInFrames,
-  scenes = [],
-  concurrency,
-  maxChunkFrames = 120
-}) => {
-  if (durationInFrames <= 0) return { chunks: [], lanes: [] };
-  const bounded = Math.max(1, Math.min(concurrency, durationInFrames));
-  const ordered = [...scenes].filter((scene) => scene.durationInFrames > 0).sort((left, right) => left.start - right.start);
-  const spans = [];
-  let cursor = 0;
-  for (const scene of ordered) {
-    if (scene.start > cursor) spans.push({ start: cursor, end: scene.start - 1 });
-    const end = Math.min(durationInFrames - 1, scene.start + scene.durationInFrames - 1);
-    if (end >= scene.start) spans.push({ start: scene.start, end, sceneId: scene.id });
-    cursor = end + 1;
-  }
-  if (cursor < durationInFrames) spans.push({ start: cursor, end: durationInFrames - 1 });
-  const chunks = [];
-  for (const span of spans) {
-    const target = Math.max(1, Math.min(maxChunkFrames, Math.ceil(durationInFrames / bounded)));
-    const total = span.end - span.start + 1;
-    const pieces = Math.max(1, Math.ceil(total / target));
-    const size = Math.ceil(total / pieces);
-    for (let piece = 0; piece < pieces; piece += 1) {
-      const start = span.start + piece * size;
-      const end = Math.min(span.end, start + size - 1);
-      if (start > end) continue;
-      chunks.push({ index: chunks.length, start, end, sceneId: span.sceneId });
-    }
-  }
-  const lanes = Array.from({ length: bounded }, () => []);
-  const loads = new Array(bounded).fill(0);
-  for (const chunk of [...chunks].sort((left, right) => length(right) - length(left))) {
-    let lane = 0;
-    for (let index = 1; index < bounded; index += 1) if (loads[index] < loads[lane]) lane = index;
-    lanes[lane].push(chunk);
-    loads[lane] += length(chunk);
-  }
-  for (const lane of lanes) lane.sort((left, right) => left.start - right.start);
-  return { chunks, lanes: lanes.filter((lane) => lane.length > 0) };
-};
-var chunkFrames = (chunk) => Array.from({ length: length(chunk) }, (_, offset) => chunk.start + offset);
-
-// src/chunk-cache.ts
-import { existsSync as existsSync14 } from "fs";
-import { copyFile, mkdir as mkdir11, readFile as readFile11, writeFile as writeFile12 } from "fs/promises";
-import { join as join5, resolve as resolve15 } from "path";
-import { hashValue as hashValue2 } from "odori";
-var cacheDir2 = (config) => resolve15(config.root, config.outDir, "cache", "chunks");
-var chunkKey = (identity) => hashValue2({
-  videoId: identity.videoId,
-  // The browser that drew the frames is part of what the frames are. Without
-  // it, upgrading Chrome silently reuses pixels the new build would not have
-  // produced, which is the exact drift the pinned toolchain exists to stop.
-  renderer: identity.renderer ?? null,
-  // A chunk is an encoded file, not a bag of frames: H.264 chunks cannot be
-  // copied into a WebM, so a cache that ignored the codec would hand the
-  // muxer streams it cannot write.
-  format: identity.format ?? null,
-  sceneId: identity.chunk.sceneId ?? null,
-  start: identity.chunk.start,
-  end: identity.chunk.end,
-  width: identity.width,
-  height: identity.height,
-  fps: identity.fps,
-  preset: identity.preset,
-  quality: identity.quality ?? null,
-  scale: identity.scale ?? null,
-  input: identity.input ?? null
-});
-var readChunkRecord = async (config, key) => {
-  const meta = join5(cacheDir2(config), `${key}.json`);
-  const media = join5(cacheDir2(config), `${key}.mp4`);
-  if (!existsSync14(meta) || !existsSync14(media)) return null;
-  try {
-    return JSON.parse(await readFile11(meta, "utf8"));
-  } catch {
-    return null;
-  }
-};
-var useChunkRecord = async (config, key, destination) => {
-  await copyFile(join5(cacheDir2(config), `${key}.mp4`), destination);
-};
-var writeChunkRecord = async (config, key, signatures, file) => {
-  const directory2 = cacheDir2(config);
-  await mkdir11(directory2, { recursive: true });
-  await copyFile(file, join5(directory2, `${key}.mp4`));
-  const record = { key, signatures, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-  await writeFile12(join5(directory2, `${key}.json`), `${JSON.stringify(record)}
-`, "utf8");
-};
-var signaturesMatch = (recorded, observed) => recorded.length === observed.length && recorded.every((signature, index) => signature === observed[index]);
-
-// src/render.ts
-var encodeParam = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64");
-var renderUrl = (origin, target, frame) => {
-  const params = new URLSearchParams({ render: "1", video: target.videoId, frame: String(frame) });
-  if (target.input) params.set("input", encodeParam(target.input));
-  if (target.prepared !== void 0) params.set("prepared", encodeParam(target.prepared));
-  return `${origin}/?${params.toString()}`;
-};
-var BROWSER_ARGS = ["--enable-unsafe-swiftshader"];
-var openRenderPage = async (origin, target, config) => {
-  const executablePath = await browserExecutable(config);
-  const browser = await chromium.launch({ executablePath, headless: true, args: BROWSER_ARGS });
-  const page = await browser.newPage({
-    viewport: { width: target.width, height: target.height },
-    deviceScaleFactor: 1
-  });
-  const errors = [];
-  page.on("pageerror", (error) => errors.push(error.message));
-  await page.goto(renderUrl(origin, target, 0), { waitUntil: "networkidle" });
-  try {
-    await page.locator('[data-odori-frame="0"]').waitFor({ timeout: 2e4 });
-  } catch {
-    await browser.close();
-    throw new Error(`The video did not mount.${errors.length ? ` ${errors.join(" ")}` : ""}`);
-  }
-  await page.evaluate(() => document.fonts.ready);
-  return { browser, page, errors };
-};
-var seekTo = async (page, frame) => {
-  await page.evaluate((next) => window.__ODORI_SET_FRAME__?.(next), frame);
-  await page.locator(`[data-odori-frame="${frame}"]`).waitFor({ timeout: 2e4 });
 };
 var readTimeline = async (page) => page.evaluate(() => window.__ODORI_TIMELINE__ ?? { scenes: [], durationInFrames: 0 });
 var readAudio = async (page) => page.evaluate(() => window.__ODORI_AUDIO__ ?? { cues: [], durationInFrames: 0 });
@@ -1890,11 +1502,11 @@ Run "odori install" when you have a connection, or set ffmpegPath in odori.confi
 var ensureFfmpeg = async (config) => {
   await ffmpegExecutable(config);
 };
-var renderStill = async (origin, target, frame, output, config) => {
-  const { browser, page, errors } = await openRenderPage(origin, target, config);
+var renderStill = async (origin, target, frame, output, config, graphics = DEFAULT_GRAPHICS) => {
+  const { browser, page, errors } = await openRenderPage(origin, target, config, graphics);
   try {
-    await mkdir12(dirname5(output), { recursive: true });
-    await seekTo(page, frame);
+    await mkdir9(dirname5(output), { recursive: true });
+    await seekTo(page, frame, errors);
     await page.screenshot({ path: output });
     if (errors.length > 0) log.warn(`The page reported an error while rendering: ${errors[0]}`);
     return output;
@@ -1915,7 +1527,7 @@ var sequencePattern = (output) => {
   const dot = output.lastIndexOf(".");
   const stem = dot > 0 ? output.slice(0, dot) : output;
   const extension = dot > 0 ? output.slice(dot) : ".png";
-  return join6(stem, `%05d${extension}`);
+  return join4(stem, `%05d${extension}`);
 };
 var LOSSLESS = {
   name: "lossless",
@@ -1950,11 +1562,11 @@ var openChunkEncoder = (ffmpeg, file, fps, encode, format, signal) => {
   return { child, done };
 };
 var captureLane = async (origin, target, config, lane, stats, options) => {
-  let session = await openRenderPage(origin, target, config);
+  let session = await openRenderPage(origin, target, config, options.graphics);
   const errors = session.errors;
   const reopen = async () => {
     await session.browser.close().catch(() => void 0);
-    session = await openRenderPage(origin, target, config);
+    session = await openRenderPage(origin, target, config, options.graphics);
     session.errors.push(...errors);
   };
   const signatureOf = async () => await session.page.evaluate(SIGNATURE_SCRIPT);
@@ -1989,7 +1601,7 @@ var captureLane = async (origin, target, config, lane, stats, options) => {
           if (options.signal?.aborted) throw new Error("Render cancelled.");
           for (let attempt = 0; ; attempt += 1) {
             try {
-              await seekTo(session.page, frame);
+              await seekTo(session.page, frame, session.errors);
               const signature = await signatureOf();
               let image;
               if (options.skipUnchanged && previousFrame && signature === previousSignature) {
@@ -2033,147 +1645,816 @@ var captureLane = async (origin, target, config, lane, stats, options) => {
       throw new Error(`The page reported an error during capture: ${session.errors.slice(0, 3).join(" ")}`);
     }
   }
-};
-var renderMovie = async (origin, target, output, config, onProgress, options = {}) => {
-  const ffmpeg = await ffmpegExecutable(config);
-  const browserPath = await browserExecutable(config);
-  const renderer = (await resolveBrowser(config))?.version ?? browserPath;
-  const requested = Math.max(1, Math.min(options.concurrency ?? config.concurrency ?? defaultConcurrency(), 16));
-  const encode = {
-    preset: options.preset ?? config.preset ?? "medium",
-    quality: options.quality ?? "studio",
-    scale: options.scale ?? 1
+};
+var renderMovie = async (origin, target, output, config, onProgress, options = {}) => {
+  const ffmpeg = await ffmpegExecutable(config);
+  const browserPath = await browserExecutable(config);
+  const graphics = options.graphics ?? DEFAULT_GRAPHICS;
+  const renderer = `${(await resolveBrowser(config))?.version ?? browserPath}:${graphics}`;
+  const requested = Math.max(1, Math.min(options.concurrency ?? config.concurrency ?? defaultConcurrency(), 16));
+  const encode = {
+    preset: options.preset ?? config.preset ?? "medium",
+    quality: options.quality ?? "studio",
+    scale: options.scale ?? 1
+  };
+  const format = options.format ?? FORMATS.mp4;
+  const chunkable = format.chunked;
+  const chunkFormat = chunkable ? format : LOSSLESS;
+  const skipUnchanged = options.skipUnchangedFrames ?? config.skipUnchangedFrames ?? true;
+  const cache = options.cache ?? config.cacheChunks ?? true;
+  const work = options.workDir ?? resolve11(config.root, config.outDir, "frames", `${target.videoId.split("/").join("-")}-${Date.now().toString(36)}`);
+  await mkdir9(work, { recursive: true });
+  const concurrency = chunkable ? requested : 1;
+  const { chunks, lanes } = planChunks({
+    durationInFrames: target.durationInFrames,
+    scenes: target.scenes,
+    concurrency
+  });
+  const chunkFile = (chunk) => join4(work, `chunk-${String(chunk.index).padStart(4, "0")}${chunkable ? format.extension : ".mkv"}`);
+  const stats = { captured: 0, reused: 0, cachedChunks: 0 };
+  let succeeded = false;
+  try {
+    await mkdir9(dirname5(output), { recursive: true });
+    const captureStart = performance.now();
+    await Promise.all(
+      lanes.map(
+        (lane) => captureLane(origin, target, config, lane, stats, {
+          skipUnchanged,
+          graphics,
+          signal: options.signal,
+          encode,
+          format: chunkFormat,
+          ffmpeg,
+          workDir: work,
+          chunkFile,
+          cacheIdentity: cache ? (chunk) => ({
+            videoId: target.videoId,
+            chunk,
+            renderer,
+            format: chunkFormat.name,
+            width: target.width,
+            height: target.height,
+            fps: target.fps,
+            preset: encode.preset,
+            // Both change the encoded bytes, so both are part of what a
+            // chunk is: a half-size chunk must never answer for a full
+            // one. A lossless intermediate is the exception by design —
+            // the final pass applies them, so one capture serves all.
+            quality: chunkable ? encode.quality : void 0,
+            scale: chunkable ? encode.scale : void 0,
+            input: target.input
+          }) : void 0,
+          onFrame: () => onProgress?.(stats.captured / Math.max(1, target.durationInFrames), "rendering")
+        })
+      )
+    );
+    const captureMs = performance.now() - captureStart;
+    onProgress?.(1, "encoding");
+    const mixInputs = (options.audio === false ? [] : target.audio ?? []).map((cue) => {
+      const file = resolveCueFile(config, cue.src);
+      if (!file) log.warn(`Skipping audio cue ${cue.src}: only project-local files can be encoded.`);
+      return file ? { file, cue } : null;
+    }).filter((item) => item !== null);
+    const muxStart = performance.now();
+    const ordered = chunks.map(chunkFile);
+    const silent = join4(work, `video${chunkable ? format.extension : ".mkv"}`);
+    if (ordered.length === 1) {
+      await copyFile2(ordered[0], silent);
+    } else {
+      const list = join4(work, "chunks.txt");
+      await writeFile10(list, ordered.map((file) => `file '${file.split("'").join("'\\''")}'`).join("\n"), "utf8");
+      await run(ffmpeg, ["-y", "-f", "concat", "-safe", "0", "-i", list, "-c", "copy", silent], options.signal);
+    }
+    if (!chunkable) {
+      const destination = format.name === "png" && !output.includes("%") ? sequencePattern(output) : output;
+      if (destination !== output) await mkdir9(dirname5(destination), { recursive: true });
+      await run(ffmpeg, ["-y", "-i", silent, ...format.args(encode), destination], options.signal);
+      if (mixInputs.length > 0) {
+        log.detail(`${format.name} carries no audio track; ${mixInputs.length} cue(s) were not mixed in.`);
+      }
+    } else if (mixInputs.length === 0 || !format.audio) {
+      const faststart = format.extension === ".mp4" || format.extension === ".mov";
+      await run(
+        ffmpeg,
+        ["-y", "-i", silent, "-c", "copy", ...faststart ? ["-movflags", "+faststart"] : [], output],
+        options.signal
+      );
+    } else {
+      const { filter, label } = buildAudioFilter(mixInputs, {
+        fps: target.fps,
+        durationInFrames: target.durationInFrames,
+        targetLufs: target.targetLufs ?? -14
+      });
+      const args = ["-y", "-i", silent];
+      for (const { cue, file } of mixInputs) args.push(...cue.loop ? ["-stream_loop", "-1"] : [], "-i", file);
+      args.push(
+        "-filter_complex",
+        filter,
+        "-map",
+        "0:v",
+        "-map",
+        label,
+        "-c:v",
+        "copy",
+        // WebM cannot carry AAC; every other container here can.
+        "-c:a",
+        format.extension === ".webm" ? "libopus" : "aac",
+        "-b:a",
+        "192k",
+        "-ar",
+        "48000",
+        "-shortest",
+        ...format.extension === ".mp4" || format.extension === ".mov" ? ["-movflags", "+faststart"] : [],
+        output
+      );
+      await run(ffmpeg, args, options.signal);
+    }
+    options.onTimings?.({
+      captureMs: Math.round(captureMs),
+      encodeMs: Math.round(performance.now() - muxStart),
+      frames: target.durationInFrames,
+      reusedFrames: stats.reused,
+      cachedChunks: stats.cachedChunks,
+      chunks: chunks.length,
+      concurrency: lanes.length
+    });
+    succeeded = true;
+    return output;
+  } finally {
+    if (succeeded && !options.workDir) await rm4(work, { recursive: true, force: true });
+    else if (!succeeded) log.detail(`Chunks left for inspection in ${work}`);
+  }
+};
+
+// src/commands/bed.ts
+var STEM_LUFS = -20;
+var STEM_PEAK = -1.5;
+var run2 = (command2, args) => new Promise((resolveRun, rejectRun) => {
+  const child = spawn3(command2, args, { stdio: ["ignore", "ignore", "pipe"] });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  child.on("error", rejectRun);
+  child.on("exit", (code) => {
+    if (code === 0) resolveRun(stderr);
+    else rejectRun(new Error(`ffmpeg exited with ${code}: ${stderr.slice(-800)}`));
+  });
+});
+var measure = async (ffmpeg, file) => {
+  const stderr = await run2(ffmpeg, [
+    "-i",
+    file,
+    "-af",
+    `loudnorm=I=${STEM_LUFS}:TP=${STEM_PEAK}:print_format=json`,
+    "-f",
+    "null",
+    "-"
+  ]);
+  const start = stderr.lastIndexOf("{");
+  const end = stderr.lastIndexOf("}");
+  if (start === -1 || end === -1) throw new Error(`Could not read loudness from ${basename2(file)}.`);
+  return JSON.parse(stderr.slice(start, end + 1));
+};
+var round = (value) => Number(value).toFixed(1);
+var generateSource = async (config, prompt, options) => {
+  const provider = resolveMusicProvider(options.provider ?? config.generation?.music ?? "elevenlabs");
+  const apiKey = await resolveKey(provider);
+  if (!apiKey) {
+    throw new Error(
+      `Generating with ${provider.name} needs a key: set ${provider.keyVariable} in the environment,
+or paste one once into Studio\u2019s integrations page ("odori dev", then Integrations).
+Either way it is sent only to the provider and never stored in the project.`
+    );
+  }
+  const seconds = options.seconds ?? 60;
+  log.detail(`Generating ${seconds}s with ${provider.name}`);
+  const { bytes, extension } = await provider.generate({ prompt, seconds, apiKey });
+  const stem = options.output ? basename2(options.output, extname(options.output)) : prompt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "generated";
+  const directory2 = options.output ? dirname6(resolve12(config.root, options.output)) : join5(config.root, "public", "audio");
+  await mkdir10(directory2, { recursive: true });
+  const source = join5(directory2, `${stem}-source.${extension}`);
+  await writeFile11(source, bytes);
+  log.detail(`  kept the original at ${basename2(source)} (${(bytes.length / 1024).toFixed(0)} KB)`);
+  return source;
+};
+var prepareBed = async (config, input, options = {}) => {
+  const source = options.generate ? await generateSource(config, input, options) : resolve12(config.root, input);
+  if (!options.generate) {
+    await stat(source).catch(() => {
+      throw new Error(`No file at ${input}.`);
+    });
+  }
+  const ffmpeg = await ffmpegExecutable(config);
+  const target = options.target ?? STEM_LUFS;
+  const name = basename2(source, extname(source)).replace(/-source$/, "");
+  const destination = options.output ? resolve12(config.root, options.output) : join5(config.root, "public", "audio", `${name}.m4a`);
+  await mkdir10(dirname6(destination), { recursive: true });
+  log.detail(`Measuring ${basename2(source)}`);
+  const measured = await measure(ffmpeg, source);
+  await run2(ffmpeg, [
+    "-y",
+    "-i",
+    source,
+    "-af",
+    `loudnorm=I=${target}:TP=${STEM_PEAK}:measured_I=${measured.input_i}:measured_TP=${measured.input_tp}:measured_LRA=${measured.input_lra}:measured_thresh=${measured.input_thresh}:linear=true`,
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    destination
+  ]);
+  const after = await measure(ffmpeg, destination);
+  const bytes = (await stat(destination)).size;
+  const before = { lufs: Number(measured.input_i), peak: Number(measured.input_tp), range: Number(measured.input_lra) };
+  const warnings = [];
+  if (before.range < 4) {
+    warnings.push(
+      `A range of ${round(before.range)} LU is very compressed. Mastered music sits around 5 to 8, and film score higher. Levelling cannot restore range a recording does not have; this bed will sit flat under the cut.`
+    );
+  }
+  if (before.peak > 0) {
+    warnings.push(`The source peaked at ${round(before.peak)} dBTP, which is above full scale.`);
+  }
+  const role = options.role ?? `bed.${name.replace(/^bed[-.]?/, "") || "main"}`;
+  const publicDir = join5(config.root, "public");
+  const relativeToPublic = relative6(publicDir, destination);
+  const url = relativeToPublic.startsWith("..") ? null : "/" + relativeToPublic.split("\\").join("/");
+  const registered = url ? await registerCueInBrand(config, { name: role, url }, name) : null;
+  return { source, destination, role, url, registered, before, after: { lufs: Number(after.input_i), peak: Number(after.input_tp) }, bytes, warnings };
+};
+var bedCommand = async (input, options = {}) => {
+  const config = await loadConfig(process.cwd());
+  const report = await prepareBed(config, input, options);
+  log.info(`Prepared ${basename2(report.destination)}`);
+  log.detail(`  loudness  ${round(report.before.lufs)} \u2192 ${round(report.after.lufs)} LUFS`);
+  log.detail(`  peak      ${round(report.before.peak)} \u2192 ${round(report.after.peak)} dBTP`);
+  log.detail(`  range     ${round(report.before.range)} LU`);
+  log.detail(`  size      ${(report.bytes / 1024).toFixed(0)} KB`);
+  for (const warning of report.warnings) {
+    log.detail("");
+    log.detail(`  ${warning}`);
+  }
+  log.detail("");
+  if (report.registered?.already) {
+    log.detail(`  "${report.role}" is already registered in ${report.registered.file}`);
+  } else if (report.registered) {
+    log.detail(`  registered "${report.role}" in ${report.registered.file}`);
+  } else if (report.url) {
+    log.detail("  No brand with an audio cues block was found. Register it by hand:");
+    log.detail(`    audio: {cues: {"${report.role}": "${report.url}"}}`);
+  } else {
+    log.detail("  The output is outside public/, so it cannot be registered or served.");
+  }
+  log.detail("  Place it in a video:");
+  log.detail(`    <Audio src="${report.role}" fadeIn="1s" fadeOut="1.5s" duckUnder />`);
+};
+
+// src/jobs.ts
+import { mkdir as mkdir11, readFile as readFile9, readdir as readdir3, rename, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { join as join6, resolve as resolve13 } from "path";
+var buildsDir = (config) => resolve13(config.root, config.outDir, "builds");
+var jobFile = (config, id) => join6(buildsDir(config), `${id}.json`);
+var createJob = async (config, manifest, output, render) => {
+  await mkdir11(buildsDir(config), { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const job = {
+    id: `job-${manifest.manifestHash.slice(0, 10)}-${Date.now().toString(36)}`,
+    videoId: manifest.videoId,
+    manifestHash: manifest.manifestHash,
+    status: "queued",
+    progress: 0,
+    attempts: 0,
+    logs: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  const record = { job, manifest, output, ...render ? { render } : {} };
+  await writeFile12(jobFile(config, job.id), `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  return record;
+};
+var readJob = async (config, id) => {
+  const file = jobFile(config, id);
+  if (!existsSync12(file)) throw new Error(`Unknown job "${id}". Run odori jobs to list them.`);
+  return JSON.parse(await readFile9(file, "utf8"));
+};
+var writeLocks = /* @__PURE__ */ new Map();
+var withJobLock = (id, task) => {
+  const previous = writeLocks.get(id) ?? Promise.resolve();
+  const next = previous.then(task, task);
+  writeLocks.set(
+    id,
+    next.catch(() => void 0)
+  );
+  return next;
+};
+var writeRecord = async (config, record) => {
+  const file = jobFile(config, record.job.id);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile12(temporary, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  await rename(temporary, file);
+};
+var updateJob = async (config, job) => withJobLock(job.id, async () => {
+  const record = await readJob(config, job.id);
+  const next = { ...job, logs: record.job.logs, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeRecord(config, { ...record, job: next });
+  return next;
+});
+var appendJobLog = async (config, id, message2) => withJobLock(id, async () => {
+  const record = await readJob(config, id);
+  const next = {
+    ...record.job,
+    logs: [...record.job.logs.slice(-49), `${(/* @__PURE__ */ new Date()).toISOString()} ${message2}`],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeRecord(config, { ...record, job: next });
+  return next;
+});
+var alive = (pid) => {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var reconcileJobs = async (config) => {
+  const stale = (await listJobs(config, { reconcile: false })).filter(
+    (job) => (job.status === "rendering" || job.status === "encoding") && !alive(job.pid)
+  );
+  for (const job of stale) {
+    await updateJob(config, {
+      ...job,
+      status: "failed",
+      error: "The render process exited before the job finished."
+    });
+  }
+  return stale.length;
+};
+var listJobs = async (config, options = {}) => {
+  if (!existsSync12(buildsDir(config))) return [];
+  if (options.reconcile !== false) await reconcileJobs(config);
+  const files = (await readdir3(buildsDir(config))).filter((file) => file.endsWith(".json"));
+  const jobs = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile9(join6(buildsDir(config), file), "utf8");
+      jobs.push(JSON.parse(raw).job);
+    } catch {
+      continue;
+    }
+  }
+  return jobs.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+};
+var JobQueue = class {
+  chain = Promise.resolve();
+  enqueue(task) {
+    const result = this.chain.then(task, task);
+    this.chain = result.catch(() => void 0);
+    return result;
+  }
+};
+
+// src/discovery.ts
+import { mkdir as mkdir12, readdir as readdir4, readFile as readFile10, stat as stat2, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import { join as join7, relative as relative7, resolve as resolve14, sep as sep2 } from "path";
+import { hashString as hashString3 } from "odori";
+var IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", ".odori", "out", "dist", ".next"]);
+var walk = async (directory2, files = []) => {
+  const entries = await readdir4(directory2, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || IGNORED.has(entry.name)) continue;
+    const full = join7(directory2, entry.name);
+    if (entry.isDirectory()) await walk(full, files);
+    else files.push(full);
+  }
+  return files;
+};
+var toIdentifier = (value, prefix) => {
+  const cleaned = value.replace(
+    /[^a-zA-Z0-9]+(.)?/g,
+    (_, character) => character ? character.toUpperCase() : ""
+  );
+  return `${prefix}${cleaned.charAt(0).toUpperCase()}${cleaned.slice(1)}`;
+};
+var AUDIO_EXTENSIONS = /\.(m4a|mp3|wav|aac|ogg|opus|flac)$/i;
+var discoverAudio = async (config) => {
+  const root = resolve14(config.root, config.audioDir);
+  if (!existsSync13(root)) return [];
+  const publicRoot = resolve14(config.root, "public");
+  const files = (await walk(root)).filter((file) => AUDIO_EXTENSIONS.test(file)).sort();
+  return Promise.all(
+    files.map(async (file) => ({
+      name: relative7(root, file).replace(AUDIO_EXTENSIONS, "").split(sep2).join("/"),
+      url: file.startsWith(`${publicRoot}${sep2}`) ? `/${relative7(publicRoot, file).split(sep2).join("/")}` : `/${relative7(config.root, file).split(sep2).join("/")}`,
+      relativeFile: relative7(config.root, file),
+      bytes: (await stat2(file)).size
+    }))
+  );
+};
+var discoverProject = async (config) => {
+  const videosRoot = resolve14(config.root, config.videosDir);
+  if (!existsSync13(videosRoot)) {
+    throw new Error(`No ${config.videosDir}/ directory found in ${config.root}. Run "odori init" first.`);
+  }
+  const files = (await walk(videosRoot)).sort();
+  const audio = await discoverAudio(config);
+  const videos = [];
+  const previews = [];
+  const brands = [];
+  const categories = [];
+  const hashParts = [];
+  const importedBy = {};
+  const componentsRoot = resolve14(config.root, config.componentsDir);
+  for (const file of files) {
+    const relativeFile = relative7(config.root, file);
+    let contents = "";
+    if (/\.(tsx|ts|css|json)$/.test(file)) {
+      contents = await readFile10(file, "utf8");
+      hashParts.push(`${relativeFile}:${hashString3(contents)}`);
+    }
+    const base = file.split(sep2).pop() ?? "";
+    if (base === "category.json") {
+      const path = relative7(componentsRoot, resolve14(file, "..")).split(sep2).join("/");
+      if (!path.startsWith("..")) {
+        try {
+          const declared = JSON.parse(contents);
+          categories.push({
+            path,
+            ...typeof declared.name === "string" ? { name: declared.name } : {},
+            ...typeof declared.order === "number" ? { order: declared.order } : {}
+          });
+        } catch (error) {
+          log.warn(
+            `${relativeFile} is not valid JSON, so that directory names itself: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    if (base === "video.tsx") {
+      for (const match of contents.matchAll(/from\s+["'][^"']*\/components\/([^/"']+)\//g)) {
+        (importedBy[match[1]] ??= /* @__PURE__ */ new Set()).add(relative7(videosRoot, file).replace(/\/?video\.tsx$/, "") || "video");
+      }
+    }
+    if (base === "video.tsx") {
+      const slug = relative7(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep2).join("/") || "video";
+      videos.push({
+        slug,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(slug, "video")
+      });
+    } else if (
+      // A brand module is recognized by what it does, not where it sits. The
+      // scaffold defines its brand in videos/layout.tsx, so a directory-name
+      // rule alone left the default project's brand invisible to everything
+      // that reads this list — most visibly the dev server's cue registry,
+      // which then answered new cue URLs with 404s until a restart. Installed
+      // component source is excluded the way brand-file.ts excludes it: a
+      // component may mention defineBrand without being where a brand lives.
+      /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx") && !file.startsWith(componentsRoot + sep2) && (file.split(sep2).includes("brands") || contents.includes("defineBrand("))
+    ) {
+      const name = base.replace(/\.tsx?$/, "");
+      brands.push({
+        name,
+        file,
+        relativeFile,
+        // From the whole relative path, like previews: basenames repeat
+        // (`layout.tsx` beside `brands/layout.ts`), identifiers cannot.
+        identifier: toIdentifier(
+          `${relative7(videosRoot, file).replace(/\.tsx?$/, "").split(sep2).join("-")}-module`,
+          "brands"
+        )
+      });
+    } else if (base.endsWith(".preview.tsx")) {
+      const name = base.replace(/\.preview\.tsx$/, "");
+      previews.push({
+        name,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(`${relative7(videosRoot, file).split(sep2).join("-")}`, "preview")
+      });
+    }
+  }
+  for (const preview of previews) {
+    const users = importedBy[preview.name];
+    if (users) preview.usedBy = [...users].sort();
+  }
+  return { videos, previews, brands, audio, categories, sourceHash: hashString3(hashParts.join("|")) };
+};
+var generateImports = (graph, outDir) => {
+  const importPath = (file) => {
+    const relativePath = relative7(outDir, file).split(sep2).join("/");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  };
+  const lines = [
+    "// Generated by odori. Do not edit.",
+    'import type {VideoEntry} from "odori";',
+    "",
+    ...graph.videos.map(
+      (video) => `import ${video.identifier}, {metadata as ${video.identifier}Metadata} from "${importPath(video.file)}";`
+    ),
+    ...graph.previews.map((preview) => `import ${preview.identifier} from "${importPath(preview.file)}";`),
+    ...graph.brands.map((brand) => `import * as ${brand.identifier} from "${importPath(brand.file)}";`),
+    "",
+    "export const videos: VideoEntry[] = [",
+    ...graph.videos.map(
+      (video) => `  {component: ${video.identifier}, metadata: {...${video.identifier}Metadata, id: ${video.identifier}Metadata.id || ${JSON.stringify(video.slug)}}},`
+    ),
+    "];",
+    "",
+    "export const componentPreviews = [",
+    ...graph.previews.map((preview) => `  {id: ${JSON.stringify(preview.name)}, preview: ${preview.identifier}},`),
+    "];",
+    "",
+    "export const brands = [",
+    ...graph.brands.map(
+      (brand) => `  ...Object.values(${brand.identifier}).filter((value) => (value as {kind?: string})?.kind === "odori-brand"),`
+    ),
+    "];",
+    ""
+  ];
+  return lines.join("\n");
+};
+var writeGenerated = async (config, graph) => {
+  const outDir = resolve14(config.root, config.outDir);
+  await mkdir12(outDir, { recursive: true });
+  const target = join7(outDir, "imports.generated.ts");
+  await writeFile13(target, generateImports(graph, outDir), "utf8");
+  await writeFile13(
+    join7(outDir, "catalog.json"),
+    `${JSON.stringify(
+      {
+        sourceHash: graph.sourceHash,
+        videos: graph.videos.map((video) => ({ slug: video.slug, file: video.relativeFile })),
+        previews: graph.previews.map((preview) => ({
+          name: preview.name,
+          file: preview.relativeFile,
+          usedBy: preview.usedBy ?? []
+        })),
+        brands: graph.brands.map((brand) => ({ name: brand.name, file: brand.relativeFile })),
+        audio: graph.audio.map((entry) => ({ name: entry.name, url: entry.url, file: entry.relativeFile }))
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  return target;
+};
+
+// src/project.ts
+import { resolve as resolve17 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import {
+  createRenderManifest,
+  entryDurationInFrames,
+  resolveEntryLayout as resolveEntryLayout2,
+  resolveVideoId
+} from "odori";
+
+// src/integrity.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync14 } from "fs";
+import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname7, resolve as resolve15 } from "path";
+var cacheFile = (config) => resolve15(config.root, config.outDir, "cache", "integrity.json");
+var readCache = async (config) => {
+  const file = cacheFile(config);
+  if (!existsSync14(file)) return {};
+  try {
+    return JSON.parse(await readFile11(file, "utf8"));
+  } catch {
+    return {};
+  }
+};
+var writeCache = async (config, cache) => {
+  const file = cacheFile(config);
+  await mkdir13(dirname7(file), { recursive: true });
+  await writeFile14(file, `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+};
+var sha256 = (bytes) => `sha256-${createHash3("sha256").update(bytes).digest("base64")}`;
+var localCandidates = (config, url) => [
+  resolve15(config.root, "public", url.replace(/^\//, "")),
+  resolve15(config.root, url.replace(/^\//, ""))
+];
+var isServed = (config, file) => file.startsWith(resolve15(config.root, "public") + "/");
+var createIntegrityResolver = async (config) => {
+  const cache = await readCache(config);
+  const warned = /* @__PURE__ */ new Set();
+  let dirty = false;
+  const resolveIntegrity = async (url) => {
+    if (url.startsWith("/__odori/cue/")) return `cue-${url.slice(url.lastIndexOf("-") + 1).replace(/\.wav$/, "")}`;
+    const local = localCandidates(config, url).find((candidate) => existsSync14(candidate));
+    if (local) {
+      if (!isServed(config, local) && !warned.has(url)) {
+        warned.add(url);
+        log.warn(`${url} resolves to ${local}, which is outside public/ and will not be served. Move it into public/.`);
+      }
+      const bytes = await readFile11(local);
+      const { mtimeMs } = await import("fs/promises").then((fs) => fs.stat(local));
+      const hit = cache[url];
+      if (hit && hit.mtimeMs === mtimeMs && hit.size === bytes.byteLength) return hit.integrity;
+      const integrity = sha256(bytes);
+      cache[url] = { integrity, size: bytes.byteLength, mtimeMs };
+      dirty = true;
+      return integrity;
+    }
+    if (!/^https?:\/\//.test(url)) return "unresolved";
+    if (cache[url]) return cache[url].integrity;
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      if (!response.ok) return "unresolved";
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      const integrity = sha256(bytes);
+      cache[url] = { integrity, size: bytes.byteLength };
+      dirty = true;
+      return integrity;
+    } catch {
+      return "unresolved";
+    }
+  };
+  return {
+    resolve: resolveIntegrity,
+    flush: async () => {
+      if (dirty) await writeCache(config, cache);
+    }
+  };
+};
+
+// src/prepare-cache.ts
+import { existsSync as existsSync15 } from "fs";
+import { mkdir as mkdir14, readFile as readFile12, readdir as readdir5, rm as rm5, writeFile as writeFile15 } from "fs/promises";
+import { join as join8, resolve as resolve16 } from "path";
+import { hashValue as hashValue2 } from "odori";
+
+// src/paths.ts
+var outputName = (id) => id.split("/").join("-");
+var fileKey = (id) => id.split("/").join("+");
+
+// src/prepare-cache.ts
+var directory = (config) => resolve16(config.root, config.outDir, "cache", "prepare");
+var prepareCacheKey = (key) => `${fileKey(key.videoId)}__${hashValue2(key)}`;
+var readPrepareCache = async (config, key) => {
+  const file = join8(directory(config), `${prepareCacheKey(key)}.json`);
+  if (!existsSync15(file)) return { hit: false, value: void 0 };
+  try {
+    const entry = JSON.parse(await readFile12(file, "utf8"));
+    return { hit: true, value: entry.value };
+  } catch {
+    return { hit: false, value: void 0 };
+  }
+};
+var writePrepareCache = async (config, key, value) => {
+  if (value === void 0) return;
+  const target = directory(config);
+  await mkdir14(target, { recursive: true });
+  const entry = { key, value, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile15(join8(target, `${prepareCacheKey(key)}.json`), `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+};
+var clearPrepareCache = async (config, videoId) => {
+  const target = directory(config);
+  if (!existsSync15(target)) return 0;
+  const files = await readdir5(target);
+  const matches = files.filter((file) => videoId ? file.startsWith(`${fileKey(videoId)}__`) : file.endsWith(".json"));
+  await Promise.all(matches.map((file) => rm5(join8(target, file), { force: true })));
+  return matches.length;
+};
+
+// src/project.ts
+var loadVideos = async (graph) => {
+  const loaded = [];
+  for (const discovered of graph.videos) {
+    const module = await import(pathToFileURL3(discovered.file).href);
+    if (!module.default || !module.metadata) {
+      throw new Error(`${discovered.relativeFile} must export metadata and a default React component.`);
+    }
+    const entry = {
+      component: module.default,
+      metadata: { ...module.metadata, id: resolveVideoId(module.metadata.id, discovered.slug) }
+    };
+    loaded.push({
+      entry,
+      file: discovered.file,
+      relativeFile: discovered.relativeFile,
+      durationInFrames: entryDurationInFrames(entry, resolveEntryLayout2(entry))
+    });
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const video of loaded) {
+    const id = video.entry.metadata.id;
+    const first = byId.get(id);
+    if (first) throw new Error(`Duplicate video id "${id}":
+  ${first}
+  ${video.relativeFile}`);
+    byId.set(id, video.relativeFile);
+  }
+  return loaded;
+};
+var findVideo = (videos, id) => {
+  const found = videos.find((video) => video.entry.metadata.id === id);
+  if (!found) {
+    throw new Error(
+      `Unknown video "${id}". Known videos: ${videos.map((video) => video.entry.metadata.id).join(", ") || "none"}`
+    );
+  }
+  return found;
+};
+var runPrepare = async (video, config, graph, input, options = {}) => {
+  const prepareFile = resolve17(video.file, "..", "prepare.ts");
+  let prepare;
+  try {
+    const module = await import(pathToFileURL3(prepareFile).href);
+    prepare = module.prepare ?? module.default;
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") return void 0;
+    throw error;
+  }
+  if (!prepare) return void 0;
+  const key = {
+    videoId: video.entry.metadata.id,
+    sourceHash: graph.sourceHash,
+    input,
+    version: prepare.version ?? "1"
   };
-  const format = options.format ?? FORMATS.mp4;
-  const chunkable = format.chunked;
-  const chunkFormat = chunkable ? format : LOSSLESS;
-  const skipUnchanged = options.skipUnchangedFrames ?? config.skipUnchangedFrames ?? true;
-  const cache = options.cache ?? config.cacheChunks ?? true;
-  const work = options.workDir ?? resolve16(config.root, config.outDir, "frames", `${target.videoId.split("/").join("-")}-${Date.now().toString(36)}`);
-  await mkdir12(work, { recursive: true });
-  const concurrency = chunkable ? requested : 1;
-  const { chunks, lanes } = planChunks({
-    durationInFrames: target.durationInFrames,
-    scenes: target.scenes,
-    concurrency
-  });
-  const chunkFile = (chunk) => join6(work, `chunk-${String(chunk.index).padStart(4, "0")}${chunkable ? format.extension : ".mkv"}`);
-  const stats = { captured: 0, reused: 0, cachedChunks: 0 };
-  let succeeded = false;
-  try {
-    await mkdir12(dirname5(output), { recursive: true });
-    const captureStart = performance.now();
-    await Promise.all(
-      lanes.map(
-        (lane) => captureLane(origin, target, config, lane, stats, {
-          skipUnchanged,
-          signal: options.signal,
-          encode,
-          format: chunkFormat,
-          ffmpeg,
-          workDir: work,
-          chunkFile,
-          cacheIdentity: cache ? (chunk) => ({
-            videoId: target.videoId,
-            chunk,
-            renderer,
-            format: chunkFormat.name,
-            width: target.width,
-            height: target.height,
-            fps: target.fps,
-            preset: encode.preset,
-            // Both change the encoded bytes, so both are part of what a
-            // chunk is: a half-size chunk must never answer for a full
-            // one. A lossless intermediate is the exception by design —
-            // the final pass applies them, so one capture serves all.
-            quality: chunkable ? encode.quality : void 0,
-            scale: chunkable ? encode.scale : void 0,
-            input: target.input
-          }) : void 0,
-          onFrame: () => onProgress?.(stats.captured / Math.max(1, target.durationInFrames), "rendering")
-        })
-      )
-    );
-    const captureMs = performance.now() - captureStart;
-    onProgress?.(1, "encoding");
-    const mixInputs = (options.audio === false ? [] : target.audio ?? []).map((cue) => {
-      const file = resolveCueFile(config, cue.src);
-      if (!file) log.warn(`Skipping audio cue ${cue.src}: only project-local files can be encoded.`);
-      return file ? { file, cue } : null;
-    }).filter((item) => item !== null);
-    const muxStart = performance.now();
-    const ordered = chunks.map(chunkFile);
-    const silent = join6(work, `video${chunkable ? format.extension : ".mkv"}`);
-    if (ordered.length === 1) {
-      await copyFile2(ordered[0], silent);
-    } else {
-      const list = join6(work, "chunks.txt");
-      await writeFile13(list, ordered.map((file) => `file '${file.split("'").join("'\\''")}'`).join("\n"), "utf8");
-      await run(ffmpeg, ["-y", "-f", "concat", "-safe", "0", "-i", list, "-c", "copy", silent], options.signal);
-    }
-    if (!chunkable) {
-      const destination = format.name === "png" && !output.includes("%") ? sequencePattern(output) : output;
-      if (destination !== output) await mkdir12(dirname5(destination), { recursive: true });
-      await run(ffmpeg, ["-y", "-i", silent, ...format.args(encode), destination], options.signal);
-      if (mixInputs.length > 0) {
-        log.detail(`${format.name} carries no audio track; ${mixInputs.length} cue(s) were not mixed in.`);
+  if (!options.refresh) {
+    const cached = await readPrepareCache(config, key);
+    if (cached.hit) return cached.value;
+  }
+  const memo = /* @__PURE__ */ new Map();
+  const value = await prepare.run({
+    input,
+    assets: {
+      resolve: async (reference) => {
+        const asset = (config.assets ?? []).find((item) => item.reference === reference);
+        if (!asset) throw new Error(`Unknown asset reference: ${reference}`);
+        return asset.url;
+      }
+    },
+    cache: {
+      getOrSet: async (cacheKey, factory) => {
+        if (!memo.has(cacheKey)) memo.set(cacheKey, await factory());
+        return memo.get(cacheKey);
       }
-    } else if (mixInputs.length === 0 || !format.audio) {
-      const faststart = format.extension === ".mp4" || format.extension === ".mov";
-      await run(
-        ffmpeg,
-        ["-y", "-i", silent, "-c", "copy", ...faststart ? ["-movflags", "+faststart"] : [], output],
-        options.signal
-      );
-    } else {
-      const { filter, label } = buildAudioFilter(mixInputs, {
-        fps: target.fps,
-        durationInFrames: target.durationInFrames,
-        targetLufs: target.targetLufs ?? -14
-      });
-      const args = ["-y", "-i", silent];
-      for (const { cue, file } of mixInputs) args.push(...cue.loop ? ["-stream_loop", "-1"] : [], "-i", file);
-      args.push(
-        "-filter_complex",
-        filter,
-        "-map",
-        "0:v",
-        "-map",
-        label,
-        "-c:v",
-        "copy",
-        // WebM cannot carry AAC; every other container here can.
-        "-c:a",
-        format.extension === ".webm" ? "libopus" : "aac",
-        "-b:a",
-        "192k",
-        "-ar",
-        "48000",
-        "-shortest",
-        ...format.extension === ".mp4" || format.extension === ".mov" ? ["-movflags", "+faststart"] : [],
-        output
-      );
-      await run(ffmpeg, args, options.signal);
     }
-    options.onTimings?.({
-      captureMs: Math.round(captureMs),
-      encodeMs: Math.round(performance.now() - muxStart),
-      frames: target.durationInFrames,
-      reusedFrames: stats.reused,
-      cachedChunks: stats.cachedChunks,
-      chunks: chunks.length,
-      concurrency: lanes.length
-    });
-    succeeded = true;
-    return output;
-  } finally {
-    if (succeeded && !options.workDir) await rm4(work, { recursive: true, force: true });
-    else if (!succeeded) log.detail(`Chunks left for inspection in ${work}`);
+  });
+  await writePrepareCache(config, key, value);
+  return value;
+};
+var freezeManifest = async (video, graph, config, rawInput, options = {}) => {
+  const layout = resolveEntryLayout2(video.entry);
+  const merged = { ...video.entry.metadata.defaultProps, ...rawInput };
+  const input = video.entry.metadata.schema ? video.entry.metadata.schema.parse(merged) : merged;
+  const prepared = await runPrepare(video, config, graph, input, { refresh: options.refreshPrepare });
+  const integrity = await createIntegrityResolver(config);
+  const assets = await Promise.all(
+    (config.assets ?? []).map(async (asset) => ({ ...asset, integrity: await integrity.resolve(asset.url) }))
+  );
+  const audio = await Promise.all(
+    (options.audio ?? []).map(async (cue) => ({ ...cue, integrity: await integrity.resolve(cue.src) }))
+  );
+  const fonts = await Promise.all(
+    layout.brand.fonts.map(async (font) => ({
+      family: font.family,
+      url: font.url,
+      integrity: await integrity.resolve(font.url)
+    }))
+  );
+  await integrity.flush();
+  for (const cue of audio) {
+    if (cue.integrity === "unresolved") log.warn(`Audio source could not be resolved for hashing: ${cue.src}`);
   }
+  const manifest = createRenderManifest({
+    entry: video.entry,
+    layout,
+    input,
+    prepared,
+    sourceHash: graph.sourceHash,
+    durationInFrames: video.durationInFrames,
+    scenes: options.scenes ?? [],
+    audio,
+    assets,
+    fonts,
+    // Which Chrome drew it and which FFmpeg encoded it. Two files that differ
+    // are then a question with an answer rather than a mystery.
+    toolchain: await renderToolchain(config),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { manifest, input, prepared };
 };
 
 // src/open.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 var command = () => {
   if (process.platform === "darwin") return { bin: "open", args: [] };
   if (process.platform === "win32") return { bin: "cmd", args: ["/c", "start", ""] };
@@ -2190,7 +2471,7 @@ var openInBrowser = (url) => {
   const resolved = command();
   if (!resolved) return;
   try {
-    const child = spawn3(resolved.bin, [...resolved.args, url], { stdio: "ignore", detached: true });
+    const child = spawn4(resolved.bin, [...resolved.args, url], { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -2199,25 +2480,32 @@ var openInBrowser = (url) => {
 };
 
 // src/server.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath } from "url";
 import { createServer } from "vite";
 import react from "@vitejs/plugin-react";
-import { readFile as readFile12 } from "fs/promises";
-import { dirname as dirname6, resolve as resolve17, sep as sep3 } from "path";
-var cliRoot = resolve17(dirname6(fileURLToPath(import.meta.url)), "..");
-var studioRoot = resolve17(cliRoot, "studio");
-var studioEntry = resolve17(studioRoot, "index.html");
-var installRoot = resolve17(cliRoot, "..", "..");
+import { readFile as readFile13 } from "fs/promises";
+import { dirname as dirname8, resolve as resolve18, sep as sep3 } from "path";
+var cliRoot = resolve18(dirname8(fileURLToPath(import.meta.url)), "..");
+var studioRoot = resolve18(cliRoot, "studio");
+var studioEntry = resolve18(studioRoot, "index.html");
+var installRoot = resolve18(cliRoot, "..", "..");
 var VIRTUAL_ID = "virtual:odori-project";
 var RESOLVED_ID = `\0${VIRTUAL_ID}`;
+var cliVersion = () => {
+  try {
+    return createRequire2(import.meta.url)("../package.json").version;
+  } catch {
+    return "dev";
+  }
+};
 var runtimeSource = (root) => {
-  for (const from of [resolve17(root, "package.json"), import.meta.url]) {
+  for (const from of [resolve18(root, "package.json"), import.meta.url]) {
     try {
       const manifest = createRequire2(from).resolve("odori/package.json");
-      const src = resolve17(manifest, "..", "src");
-      if (existsSync15(resolve17(src, "index.tsx"))) return src;
+      const src = resolve18(manifest, "..", "src");
+      if (existsSync16(resolve18(src, "index.tsx"))) return src;
     } catch {
     }
   }
@@ -2262,6 +2550,7 @@ var odoriProjectPlugin = (config, getGraph) => ({
         audioDir: config.audioDir,
         docsUrl: config.docsUrl,
         audio: graph.audio,
+        version: cliVersion(),
         sourceHash: graph.sourceHash,
         assets: config.assets ?? [],
         files: {
@@ -2340,15 +2629,15 @@ var startStudioServer = async (initialConfig, options = {}) => {
     ],
     // The project's public/ directory is served at the root, so brand fonts,
     // logos, and footage resolve identically in preview and render.
-    publicDir: existsSync15(resolve17(config.root, "public")) ? resolve17(config.root, "public") : false,
+    publicDir: existsSync16(resolve18(config.root, "public")) ? resolve18(config.root, "public") : false,
     resolve: {
       dedupe: ["react", "react-dom", "odori"],
       // Only when the runtime is present as source. A consumer resolves the
       // published package through its exports map instead.
       alias: odoriSrc ? [
-        { find: /^odori\/preview$/, replacement: resolve17(odoriSrc, "preview.ts") },
-        { find: /^odori\/manifest$/, replacement: resolve17(odoriSrc, "manifest.ts") },
-        { find: /^odori$/, replacement: resolve17(odoriSrc, "index.tsx") }
+        { find: /^odori\/preview$/, replacement: resolve18(odoriSrc, "preview.ts") },
+        { find: /^odori\/manifest$/, replacement: resolve18(odoriSrc, "manifest.ts") },
+        { find: /^odori$/, replacement: resolve18(odoriSrc, "index.tsx") }
       ] : []
     },
     server: {
@@ -2378,7 +2667,7 @@ var startStudioServer = async (initialConfig, options = {}) => {
     }, 150);
   };
   const rediscover = async (file) => {
-    if (!file.startsWith(resolve17(config.root, config.videosDir))) return;
+    if (!file.startsWith(resolve18(config.root, config.videosDir))) return;
     const isEntry = file.endsWith("video.tsx") || file.endsWith(".preview.tsx") || file.includes(`${sep3}brands${sep3}`);
     if (!isEntry) return;
     try {
@@ -2395,7 +2684,7 @@ var startStudioServer = async (initialConfig, options = {}) => {
   };
   vite.watcher.on("add", (file) => void rediscover(file));
   vite.watcher.on("unlink", (file) => void rediscover(file));
-  vite.watcher.add(resolve17(config.root, config.videosDir));
+  vite.watcher.add(resolve18(config.root, config.videosDir));
   const reloadConfig = async (file) => {
     if (!/odori\.config\.(?:ts|mjs|js)$/.test(file)) return;
     try {
@@ -2412,14 +2701,14 @@ var startStudioServer = async (initialConfig, options = {}) => {
     vite.ws.send({ type: "full-reload" });
   };
   const refreshCues = (file) => {
-    if (!file.startsWith(resolve17(config.root, config.videosDir) + sep3)) return;
+    if (!file.startsWith(resolve18(config.root, config.videosDir) + sep3)) return;
     if (!/\.tsx?$/.test(file)) return;
     scheduleCueRefresh();
   };
   vite.watcher.on("change", (file) => refreshCues(file));
   vite.watcher.on("change", (file) => void reloadConfig(file));
   for (const name of ["odori.config.ts", "odori.config.mjs", "odori.config.js"]) {
-    vite.watcher.add(resolve17(config.root, name));
+    vite.watcher.add(resolve18(config.root, name));
   }
   vite.middlewares.use(async (request, response, next) => {
     const url = (request.url ?? "/").split("?")[0];
@@ -2429,7 +2718,7 @@ var startStudioServer = async (initialConfig, options = {}) => {
       return;
     }
     try {
-      const html = await readFile12(studioEntry, "utf8");
+      const html = await readFile13(studioEntry, "utf8");
       response.statusCode = 200;
       response.setHeader("content-type", "text/html");
       response.end(await vite.transformIndexHtml(url, html));
@@ -2450,7 +2739,7 @@ var startStudioServer = async (initialConfig, options = {}) => {
 };
 
 // src/commands/exportVideo.ts
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 import { resolveEntryLayout as resolveEntryLayout4 } from "odori";
 
 // src/commands/shared.ts
@@ -2566,6 +2855,7 @@ var runJob = async (config, origin, record, video, options = {}) => exportQueue.
         scale: options.scale ?? record.render?.scale,
         format: options.format ?? (record.render?.format ? resolveFormat(record.render.format, record.output) : void 0),
         audio: options.audio ?? record.render?.audio,
+        graphics: options.graphics ?? record.render?.graphics,
         skipUnchangedFrames: options.skipUnchangedFrames,
         signal: controller.signal,
         onTimings: (timings) => {
@@ -2620,7 +2910,7 @@ var exportCommand = async (id, options = {}) => {
         options.input ?? {},
         { scenes: compiled.scenes, audio: compiled.audio }
       );
-      const output = resolve18(
+      const output = resolve19(
         config.root,
         options.output ?? `${config.exportDir}/${outputName(id)}${format.extension}`
       );
@@ -2629,11 +2919,16 @@ var exportCommand = async (id, options = {}) => {
         quality,
         scale,
         audio: options.audio !== false,
+        graphics: options.fast ? "gpu" : "software",
         ...options.preset ? { preset: options.preset } : {}
       });
     })();
     const video = findVideo(videos, record.manifest.videoId);
     log.detail(`job ${record.job.id} manifest ${record.manifest.manifestHash}`);
+    const backend = options.fast ? "gpu" : record.render?.graphics ?? "software";
+    log.detail(
+      backend === "gpu" ? "graphics: this machine's GPU. Faster, and the pixels are specific to it." : "graphics: software, reproducible on any machine"
+    );
     if (options.retry) log.detail(`retrying attempt ${record.job.attempts + 1} from the frozen manifest`);
     if (record.manifest.audio.length > 0) {
       log.detail(`${record.manifest.audio.length} audio cue(s) at ${record.manifest.format.durationInFrames} frames`);
@@ -2646,6 +2941,7 @@ var exportCommand = async (id, options = {}) => {
       scale: options.retry && options.scale === void 0 ? void 0 : scale,
       format: options.retry ? void 0 : format,
       audio: options.audio,
+      graphics: options.fast ? "gpu" : void 0,
       skipUnchangedFrames: options.skipUnchangedFrames,
       onProgress: (next) => {
         if (next.status === "rendering" || next.status === "encoding") {
@@ -2688,8 +2984,8 @@ var json = (response, status, payload) => {
   response.end(JSON.stringify(payload));
 };
 var exportDestination = (config) => {
-  const downloads = resolve19(homedir2(), "Downloads");
-  return existsSync16(downloads) ? downloads : resolve19(config.root, config.exportDir);
+  const downloads = resolve20(homedir3(), "Downloads");
+  return existsSync17(downloads) ? downloads : resolve20(config.root, config.exportDir);
 };
 var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
 var hostOf = (value) => {
@@ -2748,7 +3044,7 @@ var devCommand = async (options = {}) => {
               );
               const frame = Number(body.frame ?? 0);
               const inline = body.inline === true;
-              const file = inline ? resolve19(config.root, config.outDir, `${outputName(video.entry.metadata.id)}-${frame}.png`) : resolve19(exportDestination(config), `${outputName(video.entry.metadata.id)}-${frame}.png`);
+              const file = inline ? resolve20(config.root, config.outDir, `${outputName(video.entry.metadata.id)}-${frame}.png`) : resolve20(exportDestination(config), `${outputName(video.entry.metadata.id)}-${frame}.png`);
               await renderStill(
                 origin,
                 targetFor(
@@ -2764,7 +3060,7 @@ var devCommand = async (options = {}) => {
               if (inline) {
                 response.statusCode = 200;
                 response.setHeader("content-type", "image/png");
-                response.end(await readFile13(file));
+                response.end(await readFile14(file));
                 return;
               }
               json(response, 200, { id: "still", status: "ready", progress: 1, output: file });
@@ -2786,7 +3082,7 @@ var devCommand = async (options = {}) => {
                 input,
                 { scenes: compiled.scenes, audio: compiled.audio }
               );
-              const output = resolve19(
+              const output = resolve20(
                 exportDestination(config),
                 `${outputName(video.entry.metadata.id)}${format.extension}`
               );
@@ -2822,8 +3118,8 @@ var devCommand = async (options = {}) => {
             }
             if (request.method === "GET" && url.startsWith("/source")) {
               const asked = new URL(url, "http://localhost").searchParams.get("file") ?? "";
-              const file = resolve19(config.root, asked);
-              const inside = relative7(config.root, file);
+              const file = resolve20(config.root, asked);
+              const inside = relative8(config.root, file);
               const readable = /\.(tsx?|jsx?|css|json|md)$/.test(file);
               if (!inside || inside.startsWith("..") || !readable) {
                 json(response, 400, { error: `Refusing to read ${asked}.` });
@@ -2832,12 +3128,75 @@ var devCommand = async (options = {}) => {
               try {
                 response.statusCode = 200;
                 response.setHeader("content-type", "text/plain; charset=utf-8");
-                response.end(await readFile13(file, "utf8"));
+                response.end(await readFile14(file, "utf8"));
               } catch {
                 json(response, 404, { error: `${asked} is not there.` });
               }
               return;
             }
+            if (request.method === "POST" && url.startsWith("/generate")) {
+              const body = await readBody(request);
+              const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+              if (!prompt) {
+                json(response, 400, { error: "A prompt is required." });
+                return;
+              }
+              const report = await prepareBed(config, prompt, {
+                generate: true,
+                seconds: typeof body.seconds === "number" ? Math.min(300, Math.max(5, body.seconds)) : void 0,
+                role: typeof body.role === "string" && body.role.trim() ? body.role.trim() : void 0,
+                provider: typeof body.provider === "string" ? body.provider : void 0
+              });
+              json(response, 200, {
+                ...report,
+                source: relative8(config.root, report.source),
+                destination: relative8(config.root, report.destination)
+              });
+              return;
+            }
+            if (url === "/integrations" || url === "/integrations/") {
+              if (request.method === "GET") {
+                const providers = await Promise.all(
+                  Object.values(musicProviders).map(async (provider) => ({
+                    name: provider.name,
+                    title: provider.title,
+                    kind: "music",
+                    keyVariable: provider.keyVariable,
+                    docsUrl: provider.docsUrl,
+                    source: await keySource(provider.keyVariable)
+                  }))
+                );
+                json(response, 200, { providers });
+                return;
+              }
+              if (request.method === "POST") {
+                const body = await readBody(request);
+                const provider = musicProviders[String(body.provider ?? "")];
+                if (!provider) {
+                  json(response, 400, { error: `No provider named ${JSON.stringify(body.provider)}.` });
+                  return;
+                }
+                const key = typeof body.key === "string" ? body.key.trim() : "";
+                if (!key) {
+                  await clearStoredKey(provider.keyVariable);
+                  json(response, 200, { source: await keySource(provider.keyVariable), verified: null });
+                  return;
+                }
+                let verified = null;
+                try {
+                  verified = await provider.verifyKey(key);
+                } catch {
+                  verified = null;
+                }
+                if (verified === false) {
+                  json(response, 400, { error: `${provider.title} rejected that key.` });
+                  return;
+                }
+                await setStoredKey(provider.keyVariable, key);
+                json(response, 200, { source: await keySource(provider.keyVariable), verified });
+                return;
+              }
+            }
             if (request.method === "GET" && url.startsWith("/jobs")) {
               json(response, 200, await listJobs(config));
               return;
@@ -2862,16 +3221,16 @@ var devCommand = async (options = {}) => {
 
 // src/commands/doctor.ts
 import { constants } from "fs";
-import { access, mkdir as mkdir13, readFile as readFile14, rm as rm5, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
+import { access, mkdir as mkdir15, readFile as readFile15, rm as rm6, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { relative as relative8, resolve as resolve20 } from "path";
+import { relative as relative9, resolve as resolve21 } from "path";
 var MINIMUM_NODE = 20;
 var version = (value) => value.replace(/^v/, "").split(".").map(Number);
 var runChecks = async (root) => {
   const checks = [];
   const config = await loadConfig(root);
-  const require2 = createRequire3(resolve20(root, "package.json"));
+  const require2 = createRequire3(resolve21(root, "package.json"));
   const [major] = version(process.version);
   checks.push({
     name: "Node",
@@ -2882,7 +3241,7 @@ var runChecks = async (root) => {
   let react2 = "not found";
   let reactOk = false;
   try {
-    const manifest = JSON.parse(await readFile14(require2.resolve("react/package.json"), "utf8"));
+    const manifest = JSON.parse(await readFile15(require2.resolve("react/package.json"), "utf8"));
     react2 = manifest.version;
     reactOk = version(react2)[0] >= 19;
   } catch {
@@ -2894,16 +3253,16 @@ var runChecks = async (root) => {
     ok: reactOk,
     fix: "The runtime needs React 19. Install it: npm install react@19 react-dom@19"
   });
-  const videosDir = resolve20(config.root, config.videosDir);
+  const videosDir = resolve21(config.root, config.videosDir);
   checks.push({
     name: "Source root",
-    detail: existsSync17(videosDir) ? relative8(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
-    ok: existsSync17(videosDir),
+    detail: existsSync18(videosDir) ? relative9(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
+    ok: existsSync18(videosDir),
     fix: 'Run "odori init" to add the videos source root.'
   });
   checks.push({
     name: "Config",
-    detail: config.configPath ? relative8(config.root, config.configPath) : "defaults (no odori.config.ts)",
+    detail: config.configPath ? relative9(config.root, config.configPath) : "defaults (no odori.config.ts)",
     // Loading got this far, so a config that exists also parsed.
     ok: true
   });
@@ -2929,25 +3288,25 @@ var runChecks = async (root) => {
     detail: unpinned.length === 0 ? `pinned binaries from ${cacheRoot()}` : `${unpinned.length} of 2 from the host; frames may differ from another machine`,
     ok: true
   });
-  const generated = resolve20(config.root, ".odori");
+  const generated = resolve21(config.root, ".odori");
   let writable = false;
   try {
-    await mkdir13(generated, { recursive: true });
-    const probe = resolve20(generated, ".doctor");
-    await writeFile14(probe, "", "utf8");
+    await mkdir15(generated, { recursive: true });
+    const probe = resolve21(generated, ".doctor");
+    await writeFile16(probe, "", "utf8");
     await access(probe, constants.W_OK);
-    await rm5(probe, { force: true });
+    await rm6(probe, { force: true });
     writable = true;
   } catch {
     writable = false;
   }
-  const componentsRoot = resolve20(root, config.componentsDir);
+  const componentsRoot = resolve21(root, config.componentsDir);
   const orphans = [];
-  if (existsSync17(componentsRoot)) {
+  if (existsSync18(componentsRoot)) {
     const { readdir: readdir9 } = await import("fs/promises");
     for (const entry of await readdir9(componentsRoot, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const files = await readdir9(resolve20(componentsRoot, entry.name));
+      const files = await readdir9(resolve21(componentsRoot, entry.name));
       const source = files.some((file) => /\.tsx$/.test(file) && !file.endsWith(".preview.tsx"));
       const fixture = files.some((file) => file.endsWith(".preview.tsx"));
       if (source && !fixture) orphans.push(entry.name);
@@ -2960,11 +3319,21 @@ var runChecks = async (root) => {
     warn: orphans.length > 0,
     fix: `Add a sibling <name>.preview.tsx with defineComponentPreview so Studio can play it on its own. A component with no fixture only ever renders inside a video.`
   });
+  for (const provider of Object.values(musicProviders)) {
+    const source = await keySource(provider.keyVariable);
+    checks.push({
+      name: `Provider: ${provider.name}`,
+      detail: source === "environment" ? `connected (${provider.keyVariable})` : source === "stored" ? "connected (key stored on this machine)" : "not configured",
+      ok: true,
+      warn: source === null,
+      fix: `Optional. To generate with ${provider.title}: set ${provider.keyVariable}, or paste a key in Studio's integrations page.`
+    });
+  }
   checks.push({
     name: "Generated cache",
     detail: writable ? ".odori/ is writable" : ".odori/ cannot be written",
     ok: writable,
-    fix: `Odori writes its import graph and render cache to ${relative8(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`
+    fix: `Odori writes its import graph and render cache to ${relative9(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`
   });
   return checks;
 };
@@ -2991,14 +3360,14 @@ var doctorCommand = async (root = process.cwd()) => {
 };
 
 // src/commands/init.ts
-import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile16 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import { relative as relative10, resolve as resolve22 } from "path";
+import { mkdir as mkdir17, readFile as readFile16, writeFile as writeFile18 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import { relative as relative11, resolve as resolve23 } from "path";
 
 // src/commands/new.ts
-import { mkdir as mkdir14, readdir as readdir6, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import { relative as relative9, resolve as resolve21 } from "path";
+import { mkdir as mkdir16, readdir as readdir6, writeFile as writeFile17 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import { relative as relative10, resolve as resolve22 } from "path";
 var titleCase = (value) => value.split(/[-_\s]+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 var pascalCase = (value) => titleCase(value).replace(/\s+/g, "");
 var videoTemplate = (name, hasLayout) => `import {Scene, Video, defineVideoMetadata} from "odori";
@@ -3056,27 +3425,27 @@ ${closing}
 `;
 };
 var installedParts = async (config) => {
-  const componentsDir = resolve21(config.root, config.componentsDir);
-  if (!existsSync18(componentsDir)) return { title: false, end: false };
+  const componentsDir = resolve22(config.root, config.componentsDir);
+  if (!existsSync19(componentsDir)) return { title: false, end: false };
   const entries = (await readdir6(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   return { title: entries.includes("title-reveal"), end: entries.includes("end-card") };
 };
 var newCommand = async (name, options = {}) => {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) throw new Error("Use a lowercase, dash separated name.");
   const config = await loadConfig(process.cwd());
-  const directory2 = resolve21(config.root, config.videosDir, name);
-  const file = resolve21(directory2, "video.tsx");
-  if (existsSync18(file)) throw new Error(`${relative9(config.root, file)} already exists.`);
-  const hasLayout = existsSync18(resolve21(config.root, config.videosDir, "layout.tsx"));
+  const directory2 = resolve22(config.root, config.videosDir, name);
+  const file = resolve22(directory2, "video.tsx");
+  if (existsSync19(file)) throw new Error(`${relative10(config.root, file)} already exists.`);
+  const hasLayout = existsSync19(resolve22(config.root, config.videosDir, "layout.tsx"));
   const parts = options.blank === true ? { title: false, end: false } : await installedParts(config);
   const composed = parts.title || parts.end;
-  await mkdir14(directory2, { recursive: true });
-  await writeFile15(
+  await mkdir16(directory2, { recursive: true });
+  await writeFile17(
     file,
     composed ? composedTemplate(name, hasLayout, parts) : videoTemplate(name, hasLayout),
     "utf8"
   );
-  log.success(`Created ${relative9(config.root, file)}`);
+  log.success(`Created ${relative10(config.root, file)}`);
   if (composed) log.detail("Composed from the components this project has installed.");
   else if (options.blank !== true) {
     log.detail("No registry components installed yet: odori add title-reveal end-card");
@@ -3110,45 +3479,58 @@ export const productLayout = defineVideoLayout({
 });
 `;
 var initCommand = async (root = process.cwd()) => {
-  const videosDir = resolve22(root, defaultConfig.videosDir);
-  await mkdir15(resolve22(videosDir, "components"), { recursive: true });
+  const videosDir = resolve23(root, defaultConfig.videosDir);
+  await mkdir17(resolve23(videosDir, "components"), { recursive: true });
   const files = [
-    [resolve22(root, "odori.config.ts"), CONFIG_TEMPLATE],
-    [resolve22(videosDir, "layout.tsx"), LAYOUT_TEMPLATE],
-    [resolve22(videosDir, "launch", "video.tsx"), videoTemplate("launch", true)]
+    [resolve23(root, "odori.config.ts"), CONFIG_TEMPLATE],
+    [resolve23(videosDir, "layout.tsx"), LAYOUT_TEMPLATE],
+    [resolve23(videosDir, "launch", "video.tsx"), videoTemplate("launch", true)]
   ];
   for (const [file, contents] of files) {
-    if (existsSync19(file)) {
-      log.detail(`Kept existing ${relative10(root, file)}`);
+    if (existsSync20(file)) {
+      log.detail(`Kept existing ${relative11(root, file)}`);
       continue;
     }
-    await mkdir15(resolve22(file, ".."), { recursive: true });
-    await writeFile16(file, contents, "utf8");
-    log.success(`Created ${relative10(root, file)}`);
+    await mkdir17(resolve23(file, ".."), { recursive: true });
+    await writeFile18(file, contents, "utf8");
+    log.success(`Created ${relative11(root, file)}`);
   }
   await ensureModuleType(root);
   log.detail("Next: odori doctor, then odori add title-reveal end-card, then odori dev.");
 };
 var ensureModuleType = async (root) => {
-  const file = resolve22(root, "package.json");
-  if (!existsSync19(file)) {
+  const file = resolve23(root, "package.json");
+  if (!existsSync20(file)) {
     log.warn('No package.json here. Odori needs an ESM package: run npm init, then add "type": "module".');
     return;
   }
   let manifest;
   try {
-    manifest = JSON.parse(await readFile15(file, "utf8"));
+    manifest = JSON.parse(await readFile16(file, "utf8"));
   } catch {
     log.warn('package.json is not readable JSON, so "type": "module" was not set. Odori needs it.');
     return;
   }
   if (manifest.type === "module") return;
   manifest.type = "module";
-  await writeFile16(file, `${JSON.stringify(manifest, null, 2)}
+  await writeFile18(file, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   log.success('Set "type": "module" in package.json');
 };
 
+// src/commands/integrations.ts
+var integrationsCommand = async () => {
+  log.title("Integrations");
+  for (const provider of Object.values(musicProviders)) {
+    const source = await keySource(provider.keyVariable);
+    const status = source === "environment" ? `connected (${provider.keyVariable})` : source === "stored" ? "connected (stored on this machine)" : `not configured \u2014 set ${provider.keyVariable}, or paste a key in Studio`;
+    log.info(`  ${provider.name.padEnd(14)} music  ${status}`);
+  }
+  log.detail("");
+  log.detail('  Generate through a task command: odori bed "warm ambient, no drums" --generate');
+  log.detail("  Keys are read from the environment first, then ~/.config/odori. Never the project.");
+};
+
 // src/commands/inspect.ts
 import { isOdoriSchema, resolveEntryLayout as resolveEntryLayout5 } from "odori";
 var inspectCommand = async (id, options = {}) => {
@@ -3235,8 +3617,50 @@ var listCommand = async () => {
   }
 };
 
+// src/commands/narrate.ts
+import { mkdir as mkdir18, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename3, dirname as dirname9, extname as extname2, join as join9, resolve as resolve24 } from "path";
+import { wordsFromCharacters } from "odori";
+var narrateCommand = async (script, options = {}) => {
+  if (!script.trim()) throw new Error('Give the script to read, for example: odori narrate "One definition. Every render."');
+  const config = await loadConfig(process.cwd());
+  const provider = resolveVoiceProvider(options.provider ?? "elevenlabs");
+  const apiKey = await resolveKey(provider);
+  if (!apiKey) {
+    throw new Error(
+      `Narrating with ${provider.name} needs a key: set ${provider.keyVariable} in the environment,
+or paste one once into Studio\u2019s integrations page ("odori dev", then Integrations).
+Either way it is sent only to the provider and never stored in the project.`
+    );
+  }
+  const voice = options.voice ?? provider.defaultVoice;
+  log.detail(`Recording ${script.split(/\s+/).length} words with ${provider.title}`);
+  const { bytes, extension, alignment } = await provider.speak({ script, voice, apiKey });
+  const words = wordsFromCharacters(alignment);
+  if (words.length === 0) throw new Error("The provider returned no word timings, so captions cannot be derived. Nothing was written.");
+  const stem = options.output ? basename3(options.output, extname2(options.output)) : script.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "narration";
+  const directory2 = options.output ? dirname9(resolve24(config.root, options.output)) : join9(config.root, "public", "audio");
+  await mkdir18(directory2, { recursive: true });
+  const audioFile = join9(directory2, `${stem}.${extension}`);
+  await writeFile19(audioFile, bytes);
+  const role = options.role ?? "voice.narration";
+  const url = `/audio/${basename3(audioFile)}`;
+  const narration = { script, provider: provider.name, voice, audio: role, words };
+  const timingFile = join9(directory2, `${stem}.narration.json`);
+  await writeFile19(timingFile, `${JSON.stringify(narration, null, 2)}
+`, "utf8");
+  const registered = await registerCueInBrand(config, { name: role, url }, stem);
+  const seconds = words[words.length - 1].endSeconds;
+  log.success(`Recorded ${seconds.toFixed(1)}s to ${basename3(audioFile)} (${(bytes.length / 1024).toFixed(0)} KB)`);
+  log.success(`Word timings in ${basename3(timingFile)}`);
+  if (registered) log.detail(`Registered "${role}" in the brand`);
+  log.detail("In a video:");
+  log.detail(`  <Audio src="${role}" />`);
+  log.detail(`  <Captions cues={captionCues(narration, fps)} />  // import narration from the json`);
+};
+
 // src/commands/frame.ts
-import { resolve as resolve23 } from "path";
+import { resolve as resolve25 } from "path";
 import { framesFromOffset, resolveEntryLayout as resolveEntryLayout7 } from "odori";
 var frameCommand = async (id, options = {}) => {
   const at = options.at ?? 0;
@@ -3258,7 +3682,7 @@ var frameCommand = async (id, options = {}) => {
       throw new Error(`Frame ${frame} is past the last frame (${manifest.format.durationInFrames - 1}).`);
     }
     const target = targetFor({ ...video, durationInFrames: manifest.format.durationInFrames }, input, prepared);
-    const file = resolve23(config.root, options.output ?? `${config.exportDir}/${outputName(id)}-${frame}.png`);
+    const file = resolve25(config.root, options.output ?? `${config.exportDir}/${outputName(id)}-${frame}.png`);
     return renderStill(server.url, target, frame, file, config);
   });
   log.success(`Frame ${frame} written to ${output}`);
@@ -3269,9 +3693,9 @@ var frameCommand = async (id, options = {}) => {
 import { isOdoriSchema as isOdoriSchema2, resolveEntryLayout as resolveEntryLayout9 } from "odori";
 
 // src/contracts.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { readdir as readdir7 } from "fs/promises";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve26 } from "path";
 import { cueUrl as cueUrl2, isCueDefinition as isCueDefinition2, resolveEntryLayout as resolveEntryLayout8 } from "odori";
 var primaryFamily = (stack) => (stack.split(",")[0] ?? "").trim().replace(/^["']|["']$/g, "");
 var SYSTEM_FAMILIES = /* @__PURE__ */ new Set([
@@ -3338,8 +3762,8 @@ var checkAudioWindows = (cues, brand, videoId) => {
   return failures;
 };
 var checkInstalledContracts = async (config, videos) => {
-  const componentsDir = resolve24(config.root, config.componentsDir);
-  const onDisk = existsSync20(componentsDir) ? (await readdir7(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+  const componentsDir = resolve26(config.root, config.componentsDir);
+  const onDisk = existsSync21(componentsDir) ? (await readdir7(componentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
   const names = /* @__PURE__ */ new Set([...Object.keys(await readProvenance(config)), ...onDisk]);
   if (names.size === 0) return [];
   const { items } = await resolveRegistry(config, { allowNetwork: false });
@@ -3360,9 +3784,9 @@ var checkInstalledContracts = async (config, videos) => {
 };
 
 // src/determinism.ts
-import { readdir as readdir8, readFile as readFile16 } from "fs/promises";
-import { existsSync as existsSync21 } from "fs";
-import { join as join7, relative as relative11, resolve as resolve25 } from "path";
+import { readdir as readdir8, readFile as readFile17 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
+import { join as join10, relative as relative12, resolve as resolve27 } from "path";
 var FORBIDDEN = [
   {
     pattern: /\bMath\.random\s*\(/,
@@ -3396,18 +3820,18 @@ var scanSource = (source, file) => {
 var walk2 = async (directory2, files = []) => {
   for (const entry of await readdir8(directory2, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-    const full = join7(directory2, entry.name);
+    const full = join10(directory2, entry.name);
     if (entry.isDirectory()) await walk2(full, files);
     else if (/\.(tsx|ts|jsx|js)$/.test(entry.name) && !/\.preview\.(tsx|jsx)$/.test(entry.name)) files.push(full);
   }
   return files;
 };
 var checkDeterminism = async (config) => {
-  const root = resolve25(config.root, config.videosDir);
-  if (!existsSync21(root)) return [];
+  const root = resolve27(config.root, config.videosDir);
+  if (!existsSync22(root)) return [];
   const files = await walk2(root);
   const findings = await Promise.all(
-    files.map(async (file) => scanSource(await readFile16(file, "utf8"), relative11(config.root, file)))
+    files.map(async (file) => scanSource(await readFile17(file, "utf8"), relative12(config.root, file)))
   );
   return findings.flat();
 };
@@ -3478,12 +3902,13 @@ var CANVAS_SCRIPT = `(() => {
 })()`;
 var FRAME_SCRIPT = `(() => {
   var root = document.querySelector("[data-odori-video]");
-  if (!root) return {overflow: [], small: [], empty: true, painted: 0};
+  if (!root) return {overflow: [], small: [], empty: true, painted: 0, faded: 0};
 
   var bounds = root.getBoundingClientRect();
   var overflow = [];
   var small = [];
   var painted = 0;
+  var faded = 0;
   var nodes = Array.prototype.slice.call(root.querySelectorAll("*"));
 
   for (var index = 0; index < nodes.length; index += 1) {
@@ -3496,7 +3921,22 @@ var FRAME_SCRIPT = `(() => {
     var box = node.getBoundingClientRect();
     if (box.width === 0 || box.height === 0) continue;
     var style = getComputedStyle(node);
-    if (style.visibility === "hidden" || Number(style.opacity) < 0.02) continue;
+    if (style.visibility === "hidden") continue;
+    /* Opacity inherits down the tree in effect even though it does not
+       inherit as a property: a parent faded to nothing takes its children
+       with it, while each child still computes its own opacity as 1. Reading
+       one node's value therefore judges text nobody can see. A scene that has
+       faded out is the common case, and it was reporting its hidden dialogue
+       as unreadable. */
+    var effective = 1;
+    for (var up = node; up && up !== root.parentElement; up = up.parentElement) {
+      effective *= Number(getComputedStyle(up).opacity);
+      if (effective < 0.02) break;
+    }
+    if (effective < 0.02) {
+      faded += 1;
+      continue;
+    }
     painted += 1;
 
     var media = ["IMG", "SVG", "CANVAS", "VIDEO"].indexOf(node.tagName) >= 0;
@@ -3521,12 +3961,27 @@ var FRAME_SCRIPT = `(() => {
      * content the video is actually about, which is what stays checked.
      */
     var chrome = node.closest("[data-odori-chrome]") !== null;
-    if (
-      box.right > bounds.right + 1 ||
-      box.left < bounds.left - 1 ||
-      box.bottom > bounds.bottom + 1 ||
-      box.top < bounds.top - 1
-    ) {
+
+    /*
+     * Crossing the frame edge is not a fault. Film bleeds: a surface runs past
+     * the corner, a push-in takes a headline wider than the shot, a full-frame
+     * image is cropped rather than letterboxed. The old rule flagged any box
+     * that crossed by a pixel, which is a rule about a document, not about a
+     * cut, and the only reason the recreations passed it is that five sampled
+     * frames happened to miss their own bleeds.
+     *
+     * What is worth reporting is content with no intersection at all: nothing
+     * of it is on screen at the frame that was sampled, which is what a layout
+     * mistake looks like. Deliberate overscan does that too, and says so with
+     * data-odori-bleed.
+     */
+    var bleed = node.closest("[data-odori-bleed]") !== null;
+    var offCanvas =
+      box.right <= bounds.left ||
+      box.left >= bounds.right ||
+      box.bottom <= bounds.top ||
+      box.top >= bounds.bottom;
+    if (offCanvas && !bleed) {
       if (overflow.indexOf(label) < 0) overflow.push(label);
     }
 
@@ -3550,7 +4005,7 @@ var FRAME_SCRIPT = `(() => {
     }
   }
 
-  return {overflow: overflow.slice(0, 5), small: small.slice(0, 5), empty: false, painted: painted};
+  return {overflow: overflow.slice(0, 5), small: small.slice(0, 5), empty: false, painted: painted, faded: faded};
 })()`;
 var testVideo = async (origin, video, config, failures, quiet = false) => {
   const id = video.entry.metadata.id;
@@ -3559,7 +4014,7 @@ var testVideo = async (origin, video, config, failures, quiet = false) => {
     const result = video.entry.metadata.schema.safeParse(video.entry.metadata.defaultProps ?? {});
     if (!result.success) failures.push({ video: id, message: `defaultProps fail the schema: ${result.issues.join("; ")}` });
   }
-  const { browser, page } = await openRenderPage(origin, targetFor(video), config);
+  const { browser, page, errors } = await openRenderPage(origin, targetFor(video), config);
   try {
     const timeline = await readTimeline(page);
     failures.push(...checkAudioWindows((await readAudio(page)).cues, layout.brand, id));
@@ -3576,16 +4031,16 @@ var testVideo = async (origin, video, config, failures, quiet = false) => {
     }
     const samples = [0, Math.floor(total / 4), Math.floor(total / 2), Math.floor(total * 3 / 4), total - 1];
     for (const frame of [...new Set(samples)]) {
-      await seekTo(page, frame);
+      await seekTo(page, frame, errors);
       const result = await page.evaluate(FRAME_SCRIPT);
       if (result.empty) failures.push({ video: id, message: `Frame ${frame} rendered no video root.` });
-      if (!result.empty && result.painted < 2) {
+      if (!result.empty && result.painted < 2 && result.faded < 2) {
         failures.push({ video: id, message: `Frame ${frame} is blank.` });
       }
       for (const item of result.overflow) {
         failures.push({
           video: id,
-          message: `Frame ${frame}: ${item} escapes the ${layout.format.width}x${layout.format.height} canvas.`
+          message: `Frame ${frame}: ${item} is entirely outside the ${layout.format.width}x${layout.format.height} canvas.`
         });
       }
       for (const item of result.small) {
@@ -3593,8 +4048,8 @@ var testVideo = async (origin, video, config, failures, quiet = false) => {
       }
       const canvases = await page.evaluate(CANVAS_SCRIPT);
       if (canvases.length > 0) {
-        await seekTo(page, frame === 0 ? Math.min(total - 1, frame + 1) : frame - 1);
-        await seekTo(page, frame);
+        await seekTo(page, frame === 0 ? Math.min(total - 1, frame + 1) : frame - 1, errors);
+        await seekTo(page, frame, errors);
         const again = await page.evaluate(CANVAS_SCRIPT);
         for (const canvas of canvases) {
           const second = again.find((item) => item.index === canvas.index);
@@ -3666,7 +4121,7 @@ var testCommand = async (id, options = {}) => {
 };
 
 // src/cli.ts
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["force", "dry-run", "json", "no-audio", "no-frame-skip", "no-open", "open", "help", "version"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["force", "dry-run", "json", "no-audio", "fast", "no-frame-skip", "no-open", "open", "help", "version"]);
 var RENAMED = { still: "frame" };
 var parseArgs = (argv) => {
   const [command2 = "help", ...rest] = argv;
@@ -3720,13 +4175,16 @@ var COMMAND_FLAGS = {
   new: ["blank"],
   add: ["force", "dry-run"],
   registry: [],
+  integrations: [],
   diff: ["full"],
   update: ["force"],
   list: [],
   inspect: ["json", "input"],
   frame: ["at", "output", "input"],
+  bed: ["role", "output", "target", "generate", "provider", "seconds"],
+  narrate: ["output", "voice", "role", "provider"],
   test: ["json"],
-  export: ["output", "input", "concurrency", "preset", "format", "quality", "scale", "no-audio", "no-frame-skip", "retry"],
+  export: ["output", "input", "concurrency", "preset", "format", "quality", "scale", "no-audio", "fast", "no-frame-skip", "retry"],
   jobs: [],
   help: []
 };
@@ -3765,6 +4223,21 @@ var USAGE = {
   Discover project resources and start Studio.`,
   init: `odori init
   Add videos/ and odori.config.ts to a project.`,
+  bed: `odori bed <file> [--role <name>] [--target <lufs>] [--output <path>]
+  Prepare an audio file to sit under a video: measure it, level it to the stem
+  target every other bed is prepared to, and write it where audio is served.
+  With --generate the positional is a prompt instead of a path: the track is
+  generated with a provider (--provider, default elevenlabs, key from
+  ELEVENLABS_API_KEY), then prepared identically. --seconds sets its length.`,
+  narrate: `odori narrate <script> [--output <path>] [--voice <id>] [--role <cue>]
+  Record the script as narration. Writes the audio and a .narration.json with
+  the time every word starts and ends, and registers the cue role (default
+  voice.narration) in the brand. Captions derive from the timings at compose
+  time, so they cannot drift from the voice.`,
+  integrations: `odori integrations
+  List generation providers and whether each is connected. Configuration
+  lives in the environment or Studio's integrations page; generation happens
+  in task commands like "odori bed --generate".`,
   doctor: `odori doctor
   Check Node, React, the source root, Chrome, FFmpeg, and the generated cache.`,
   install: `odori install
@@ -3795,11 +4268,15 @@ var USAGE = {
   check, for CI.`,
   export: `odori export <id> [--output <path>] [--input <json>] [--concurrency <n>]
              [--preset <name>] [--format <name>] [--quality <tier>] [--scale <n>]
-             [--no-audio] [--no-frame-skip] [--retry <job>]
+             [--no-audio] [--fast] [--no-frame-skip] [--retry <job>]
   Render and encode a distributable file. --format is mp4, webm, prores, gif,
   or png; without it the output's extension decides, and mp4 is the default.
   --quality is studio, social, or web. --scale multiplies the output size,
-  0.25 to 2. --no-audio writes the picture with no sound. A retry keeps the
+  0.25 to 2. --no-audio writes the picture with no sound.
+  --fast draws on this machine's GPU rather than the reproducible software
+  backend. Measured here: about five percent on ordinary post-processing, and
+  fourteen times on a shader that is genuinely per-pixel expensive. The pixels
+  it makes belong to this machine, so keep it for iterating. A retry keeps the
   settings its job was created with.`,
   jobs: `odori jobs
   List export jobs and their status.`
@@ -3821,6 +4298,7 @@ Usage
   odori frame <id> --at 4s          Render one deterministic frame to a PNG
   odori test [id] [--json]         Validate contracts and representative frames
   odori export <id> [--output f]   Render and encode a distributable file
+  odori narrate <script>          Record narration with word timings
   odori jobs                       List export jobs and their status
 
 Options
@@ -3839,7 +4317,7 @@ Options
 
 Run "odori <command> --help" for one command, or "odori doctor" to check setup.
 `;
-var cliVersion = () => {
+var cliVersion2 = () => {
   try {
     const require2 = createRequire4(import.meta.url);
     return require2("../package.json").version;
@@ -3847,11 +4325,11 @@ var cliVersion = () => {
     return "unknown";
   }
 };
-var run2 = async (argv) => {
+var run3 = async (argv) => {
   const { command: command2, positionals, flags } = parseArgs(argv);
   try {
     if (command2 === "--version" || command2 === "-v" || command2 === "version") {
-      log.info(`odori ${cliVersion()} (node ${process.version})`);
+      log.info(`odori ${cliVersion2()} (node ${process.version})`);
       return 0;
     }
     if (flags.help === true && USAGE[command2]) {
@@ -3877,6 +4355,9 @@ var run2 = async (argv) => {
       case "init":
         await initCommand();
         return 0;
+      case "integrations":
+        await integrationsCommand();
+        return 0;
       case "doctor":
         return await doctorCommand();
       case "install":
@@ -3902,6 +4383,25 @@ var run2 = async (argv) => {
       case "inspect":
         await inspectCommand(positionals[0] ?? "", { json: flags.json === true, input: parseInput(flags) });
         return 0;
+      case "bed":
+        if (!positionals[0]) throw new Error('Which file? "odori bed ./track.mp3".');
+        await bedCommand(positionals[0], {
+          role: typeof flags.role === "string" ? flags.role : void 0,
+          output: typeof flags.output === "string" ? flags.output : void 0,
+          target: numberFlag(flags, "target"),
+          generate: flags.generate === true,
+          provider: typeof flags.provider === "string" ? flags.provider : void 0,
+          seconds: numberFlag(flags, "seconds")
+        });
+        return 0;
+      case "narrate":
+        await narrateCommand(positionals.join(" "), {
+          output: typeof flags.output === "string" ? flags.output : void 0,
+          voice: typeof flags.voice === "string" ? flags.voice : void 0,
+          role: typeof flags.role === "string" ? flags.role : void 0,
+          provider: typeof flags.provider === "string" ? flags.provider : void 0
+        });
+        return 0;
       case "frame":
         await frameCommand(positionals[0] ?? "", {
           // A duration, so "4s" and "120f" both work; a bare number is
@@ -3924,6 +4424,7 @@ var run2 = async (argv) => {
           scale: numberFlag(flags, "scale"),
           format: typeof flags.format === "string" ? flags.format : void 0,
           audio: flags["no-audio"] === true ? false : void 0,
+          fast: flags.fast === true,
           skipUnchangedFrames: flags["no-frame-skip"] === true ? false : void 0,
           retry: typeof flags.retry === "string" ? flags.retry : void 0
         });
@@ -4032,5 +4533,5 @@ export {
   initCommand,
   parseArgs,
   checkFlags,
-  run2 as run
+  run3 as run
 };