@odori/cli 0.0.2

package/dist/chunk-7XJL2BYO.js

@@ -0,0 +1,3552 @@
+// src/cli.ts
+import { createRequire as createRequire4 } from "module";
+
+// src/log.ts
+var ESC = String.fromCharCode(27);
+var wrap = (code, value) => `${ESC}[${code}m${value}${ESC}[0m`;
+var log = {
+  info: (message2) => console.log(message2),
+  detail: (message2) => console.log(wrap("2", message2)),
+  title: (message2) => console.log(wrap("1", message2)),
+  success: (message2) => console.log(`${wrap("32", "ok")} ${message2}`),
+  warn: (message2) => console.warn(`${wrap("33", "!")} ${message2}`),
+  error: (message2) => console.error(`${wrap("31", "x")} ${message2}`),
+  progress: (message2) => {
+    if (process.stdout.isTTY) process.stdout.write(`\r${wrap("2", message2)}${ESC}[K`);
+  },
+  progressDone: () => {
+    if (process.stdout.isTTY) process.stdout.write(`\r${ESC}[K`);
+  }
+};
+
+// src/commands/add.ts
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { relative as relative3, resolve as resolve6 } from "path";
+import { hashString as hashString2 } from "odori";
+
+// src/config.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+var defaultConfig = {
+  videosDir: "videos",
+  outDir: ".odori",
+  exportDir: "out",
+  componentsDir: "videos/components",
+  audioDir: "public/audio",
+  port: 4300,
+  docsUrl: "https://odori.dev/docs"
+};
+var CHROME_CANDIDATES = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/usr/bin/google-chrome",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser"
+];
+var resolveChromePath = (configured) => {
+  const candidates = [configured, process.env.ODORI_CHROME, ...CHROME_CANDIDATES].filter(Boolean);
+  return candidates.find((candidate) => existsSync(candidate));
+};
+var loadConfig = async (root) => {
+  for (const name of ["odori.config.ts", "odori.config.mjs", "odori.config.js"]) {
+    const configPath = resolve(root, name);
+    if (!existsSync(configPath)) continue;
+    const loaded = await import(pathToFileURL(configPath).href);
+    return { ...defaultConfig, ...loaded.default ?? {}, root, configPath };
+  }
+  return { ...defaultConfig, root };
+};
+var defineConfig = (config) => config;
+
+// src/brand-file.ts
+import { readFile, readdir, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join, relative, resolve as resolve2 } from "path";
+var SOURCE = /\.tsx?$/;
+var brandFiles = async (config) => {
+  const root = resolve2(config.root, config.videosDir);
+  if (!existsSync2(root)) return [];
+  const found = [];
+  const walk3 = async (directory2, depth) => {
+    for (const entry of await readdir(directory2, { withFileTypes: true })) {
+      const path = join(directory2, entry.name);
+      if (entry.isDirectory()) {
+        if (path === resolve2(config.root, config.componentsDir)) continue;
+        await walk3(path, depth + 1);
+        continue;
+      }
+      if (!SOURCE.test(entry.name)) continue;
+      const source = await readFile(path, "utf8");
+      if (source.includes("defineBrand(")) found.push({ file: path, depth });
+    }
+  };
+  await walk3(root, 0);
+  return found.sort((left, right) => left.depth - right.depth).map((entry) => entry.file);
+};
+var registerCueInBrand = async (config, cue, componentName) => {
+  for (const file of await brandFiles(config)) {
+    const source = await readFile(file, "utf8");
+    if (source.includes(`"${cue.name}"`) || source.includes(`'${cue.name}'`)) {
+      return { file: relative(config.root, file), already: true };
+    }
+    const block = source.match(/(audio:\s*\{[\s\S]*?cues:\s*\{)([\s\S]*?)(\n(\s*)\},)/);
+    const inline = source.match(/(audio:\s*\{[^\n}]*cues:\s*\{)([^\n{}]*)(\})/);
+    let withCue;
+    if (block) {
+      const indent = `${block[4]}  `;
+      const entry = `
+${indent}"${cue.name}": ${cue.export}(),`;
+      withCue = source.replace(block[0], `${block[1]}${block[2]}${entry}${block[3]}`);
+    } else if (inline) {
+      const existing = inline[2].trim();
+      const entry = `"${cue.name}": ${cue.export}()`;
+      withCue = source.replace(inline[0], `${inline[1]}${existing ? `${existing.replace(/,$/, "")}, ` : ""}${entry}${inline[3]}`);
+    } else {
+      continue;
+    }
+    const from = resolve2(config.root, config.componentsDir, componentName, componentName);
+    const specifier = relative(resolve2(file, ".."), from).split("\\").join("/");
+    const importLine = `import {${cue.export}} from "${specifier.startsWith(".") ? specifier : `./${specifier}`}";`;
+    const withImport = withCue.includes(importLine) ? withCue : withCue.replace(/^(import [\s\S]*?;\n)/, `$1${importLine}
+`);
+    await writeFile(file, withImport, "utf8");
+    return { file: relative(config.root, file), already: false };
+  }
+  return null;
+};
+
+// src/registry-source.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+
+// src/binaries.ts
+import { spawn } from "child_process";
+import { chmod, mkdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname, resolve as resolve3 } from "path";
+import { install, computeExecutablePath, Browser, resolveBuildId, detectBrowserPlatform } from "@puppeteer/browsers";
+var CHROME_BUILD = "131.0.6778.204";
+var FFMPEG_PACKAGE = "ffmpeg-static";
+var cacheRoot = () => process.env.ODORI_CACHE ?? resolve3(process.env.XDG_CACHE_HOME ?? resolve3(homedir(), ".cache"), "odori");
+var browserCache = () => resolve3(cacheRoot(), "browsers");
+var ffmpegCache = () => resolve3(cacheRoot(), "ffmpeg", "5.3.0");
+var onPath = (command2, args) => new Promise((done) => {
+  const child = spawn(command2, args, { stdio: "ignore" });
+  child.on("error", () => done(false));
+  child.on("close", (code) => done(code === 0));
+});
+var managedBrowserPath = () => {
+  const platform = detectBrowserPlatform();
+  if (!platform) return null;
+  return computeExecutablePath({
+    browser: Browser.CHROMEHEADLESSSHELL,
+    buildId: CHROME_BUILD,
+    cacheDir: browserCache(),
+    platform
+  });
+};
+var resolveBrowser = async (config) => {
+  if (config.chromePath && existsSync3(config.chromePath)) {
+    return { path: config.chromePath, origin: "configured", version: "unknown" };
+  }
+  if (process.env.ODORI_CHROME && existsSync3(process.env.ODORI_CHROME)) {
+    return { path: process.env.ODORI_CHROME, origin: "environment", version: "unknown" };
+  }
+  const managed = managedBrowserPath();
+  if (managed && existsSync3(managed)) return { path: managed, origin: "managed", version: CHROME_BUILD };
+  const system = resolveChromePath();
+  return system ? { path: system, origin: "system", version: "unknown" } : null;
+};
+var packagedFfmpeg = () => {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const path = require2(FFMPEG_PACKAGE);
+    return path && existsSync3(path) ? path : null;
+  } catch {
+    return null;
+  }
+};
+var managedFfmpegPath = () => resolve3(ffmpegCache(), process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg");
+var resolveFfmpeg = async (config) => {
+  if (config.ffmpegPath && existsSync3(config.ffmpegPath)) {
+    return { path: config.ffmpegPath, origin: "configured", version: "unknown" };
+  }
+  if (process.env.ODORI_FFMPEG && existsSync3(process.env.ODORI_FFMPEG)) {
+    return { path: process.env.ODORI_FFMPEG, origin: "environment", version: "unknown" };
+  }
+  const managed = managedFfmpegPath();
+  if (existsSync3(managed)) return { path: managed, origin: "managed", version: "5.3.0" };
+  const packaged = packagedFfmpeg();
+  if (packaged) return { path: packaged, origin: "package", version: "5.3.0" };
+  if (await onPath("ffmpeg", ["-version"])) return { path: "ffmpeg", origin: "system", version: "unknown" };
+  return null;
+};
+var installBrowser = async (options = {}) => {
+  const platform = detectBrowserPlatform();
+  if (!platform) {
+    throw new Error(`No managed Chrome build for ${process.platform}/${process.arch}. Set chromePath in odori.config.ts.`);
+  }
+  const existing = managedBrowserPath();
+  if (existing && existsSync3(existing)) return existing;
+  const buildId = await resolveBuildId(Browser.CHROMEHEADLESSSHELL, platform, CHROME_BUILD).catch(() => CHROME_BUILD);
+  const installed = await install({
+    browser: Browser.CHROMEHEADLESSSHELL,
+    buildId,
+    cacheDir: browserCache(),
+    platform,
+    downloadProgressCallback: (downloaded, total) => options.onProgress?.(total ? downloaded / total : 0)
+  });
+  return installed.executablePath;
+};
+var installFfmpeg = async () => {
+  const managed = managedFfmpegPath();
+  if (existsSync3(managed)) return managed;
+  const packaged = packagedFfmpeg();
+  if (packaged) {
+    await mkdir(dirname(managed), { recursive: true });
+    await writeFile2(managed, await readFile2(packaged));
+    await chmod(managed, 493);
+    return managed;
+  }
+  const require2 = createRequire(import.meta.url);
+  const installer = require2.resolve(`${FFMPEG_PACKAGE}/install.js`);
+  await mkdir(dirname(managed), { recursive: true });
+  await new Promise((done, fail) => {
+    const child = spawn(process.execPath, [installer], {
+      // The package writes to its own directory, which is where it also looks.
+      cwd: dirname(installer),
+      env: { ...process.env, FFMPEG_BIN_PATH: managed },
+      stdio: "inherit"
+    });
+    child.on("error", fail);
+    child.on("close", (code) => code === 0 ? done() : fail(new Error(`FFmpeg download exited with ${code}`)));
+  });
+  if (!existsSync3(managed)) {
+    const unpacked = packagedFfmpeg();
+    if (!unpacked) throw new Error("FFmpeg downloaded but no binary was produced.");
+    await writeFile2(managed, await readFile2(unpacked));
+    await chmod(managed, 493);
+  }
+  return managed;
+};
+var renderToolchain = async (config) => {
+  const [browser, ffmpeg] = await Promise.all([resolveBrowser(config), resolveFfmpeg(config)]);
+  return {
+    chrome: browser?.version ?? "missing",
+    chromeOrigin: browser?.origin ?? "missing",
+    ffmpeg: ffmpeg?.version ?? "missing",
+    ffmpegOrigin: ffmpeg?.origin ?? "missing"
+  };
+};
+var installCommand = async () => {
+  log.title("odori install");
+  let lastReported = -1;
+  const chrome = await installBrowser({
+    onProgress: (fraction) => {
+      const percent = Math.floor(fraction * 100);
+      if (percent >= lastReported + 10) {
+        lastReported = percent;
+        log.progress(`Chrome ${CHROME_BUILD}: ${percent}%`);
+      }
+    }
+  });
+  log.progressDone();
+  log.success(`Chrome ${CHROME_BUILD}`);
+  log.detail(chrome);
+  const ffmpeg = await installFfmpeg();
+  log.success("FFmpeg 5.3.0");
+  log.detail(ffmpeg);
+  log.detail(`Cached in ${cacheRoot()}. Set ODORI_CACHE to move it.`);
+  return 0;
+};
+
+// src/registry-source.ts
+var normalizeComponentName = (name) => name.replace(/^@odori\//, "");
+var DEFAULT_URL = "https://odori.dev/r/v1";
+var registryUrl = (config) => (config.registryUrl ?? process.env.ODORI_REGISTRY ?? DEFAULT_URL).replace(/\/$/, "");
+var cacheDir = (url) => resolve4(cacheRoot(), "registry", createHash("sha256").update(url).digest("hex").slice(0, 16));
+var toComponent = (item) => ({
+  name: item.name,
+  namespaced: item.meta?.namespaced ?? `@odori/${item.name}`,
+  kind: item.meta?.kind ?? "component",
+  ...item.meta?.cue ? { cue: item.meta.cue } : {},
+  family: item.meta?.family ?? "Uncategorized",
+  description: item.description ?? "",
+  files: item.files.map((file) => file.path.split("/").pop() ?? file.path),
+  registryDependencies: item.registryDependencies ?? [],
+  contract: item.meta?.contract
+});
+var snapshotItems = async () => {
+  try {
+    const loaded = await import("./registry-snapshot-NIH2JMQ6.js");
+    return loaded.default.items;
+  } catch {
+    throw new Error(
+      "No registry available: the network and the cache both failed, and this CLI has no snapshot built into it. Run `pnpm snapshot` in packages/odori-cli, or set registryUrl to a reachable registry."
+    );
+  }
+};
+var bundled = async () => (await snapshotItems()).map(toComponent);
+var fetchJson = async (url, timeoutMs = 8e3) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal, headers: { accept: "application/json" } });
+    if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var resolveRegistry = async (config, options = {}) => {
+  const url = registryUrl(config);
+  const cache = resolve4(cacheDir(url), "registry.json");
+  if (options.allowNetwork !== false) {
+    try {
+      const index = await fetchJson(`${url}/registry.json`);
+      if (!Array.isArray(index.items)) throw new Error("the index has no items array");
+      await mkdir2(dirname2(cache), { recursive: true });
+      await writeFile3(cache, JSON.stringify(index), "utf8");
+      return { items: index.items.map(toComponent), origin: "network", detail: url };
+    } catch {
+    }
+  }
+  if (existsSync4(cache)) {
+    try {
+      const index = JSON.parse(await readFile3(cache, "utf8"));
+      return { items: index.items.map(toComponent), origin: "cache", detail: cache };
+    } catch {
+    }
+  }
+  return { items: await bundled(), origin: "bundled", detail: "the copy built into this CLI" };
+};
+var resolveItem = async (config, name, options = {}) => {
+  const url = registryUrl(config);
+  const cache = resolve4(cacheDir(url), `${name}.json`);
+  if (options.allowNetwork !== false) {
+    try {
+      const item2 = await fetchJson(`${url}/${name}.json`);
+      if (item2?.name !== name) throw new Error(`the document at ${url}/${name}.json is for "${item2?.name}"`);
+      await mkdir2(dirname2(cache), { recursive: true });
+      await writeFile3(cache, JSON.stringify(item2), "utf8");
+      return { item: item2, origin: "network" };
+    } catch {
+    }
+  }
+  if (existsSync4(cache)) {
+    try {
+      return { item: JSON.parse(await readFile3(cache, "utf8")), origin: "cache" };
+    } catch {
+    }
+  }
+  const item = (await snapshotItems()).find((entry) => entry.name === name);
+  if (!item) throw new Error(`No component named "${name}" in the registry at ${url}, in the cache, or in this CLI.`);
+  return { item, origin: "bundled" };
+};
+var verifyIntegrity = (item) => {
+  const expected = item.meta?.integrity;
+  if (!expected) return;
+  const hash = createHash("sha256");
+  for (const file of [...item.files].sort((left, right) => left.path.localeCompare(right.path))) {
+    hash.update(file.path);
+    hash.update("\0");
+    hash.update(file.content);
+    hash.update("\0");
+  }
+  const actual = `sha256-${hash.digest("base64")}`;
+  if (actual === expected) return;
+  throw new Error(
+    `The files for "${item.name}" do not match the hash the registry published.
+  expected ${expected}
+  received ${actual}
+Nothing was written. This is a truncated download, a stale proxy, or a tampered document.`
+  );
+};
+
+// src/commands/update.ts
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { relative as relative2, resolve as resolve5 } from "path";
+import { hashString } from "odori";
+
+// src/diff.ts
+var lcs = (left, right) => {
+  const table = Array.from({ length: left.length + 1 }, () => new Array(right.length + 1).fill(0));
+  for (let i = left.length - 1; i >= 0; i -= 1) {
+    for (let j = right.length - 1; j >= 0; j -= 1) {
+      table[i][j] = left[i] === right[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  return table;
+};
+var diffLines = (before, after) => {
+  const left = before.split("\n");
+  const right = after.split("\n");
+  const table = lcs(left, right);
+  const output = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (left[i] === right[j]) {
+      output.push({ type: "context", text: left[i] });
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      output.push({ type: "remove", text: left[i] });
+      i += 1;
+    } else {
+      output.push({ type: "add", text: right[j] });
+      j += 1;
+    }
+  }
+  while (i < left.length) output.push({ type: "remove", text: left[i++] });
+  while (j < right.length) output.push({ type: "add", text: right[j++] });
+  return output;
+};
+var countChanges = (lines) => ({
+  added: lines.filter((line) => line.type === "add").length,
+  removed: lines.filter((line) => line.type === "remove").length
+});
+var formatDiff = (lines, context = 2) => {
+  const keep = /* @__PURE__ */ new Set();
+  lines.forEach((line, index) => {
+    if (line.type === "context") return;
+    for (let offset = -context; offset <= context; offset += 1) keep.add(index + offset);
+  });
+  const output = [];
+  let skipping = false;
+  lines.forEach((line, index) => {
+    if (!keep.has(index)) {
+      if (!skipping) output.push("  ...");
+      skipping = true;
+      return;
+    }
+    skipping = false;
+    const marker = line.type === "add" ? "+" : line.type === "remove" ? "-" : " ";
+    output.push(`${marker} ${line.text}`);
+  });
+  return output;
+};
+
+// src/commands/update.ts
+var provenanceFile = (config) => resolve5(config.root, config.outDir, "components.json");
+var readProvenance = async (config) => {
+  const file = provenanceFile(config);
+  if (!existsSync5(file)) return {};
+  return JSON.parse(await readFile4(file, "utf8"));
+};
+var writeProvenance = async (config, provenance) => {
+  await mkdir3(resolve5(config.root, config.outDir), { recursive: true });
+  await writeFile4(provenanceFile(config), `${JSON.stringify(provenance, null, 2)}
+`, "utf8");
+};
+var componentStatus = async (config, only) => {
+  const { items: registry } = await resolveRegistry(config);
+  const provenance = await readProvenance(config);
+  const wanted = only?.map(normalizeComponentName);
+  const names = Object.keys(provenance).filter((name) => !wanted || wanted.includes(name));
+  const statuses = [];
+  for (const name of names) {
+    const component = registry.find((item2) => item2.name === name);
+    if (!component) continue;
+    const { item } = await resolveItem(config, name);
+    const upstreamFiles = new Map(item.files.map((file) => [file.path.split("/").pop() ?? file.path, file.content]));
+    const files = await Promise.all(
+      component.files.map(async (file) => {
+        const localPath = resolve5(config.root, config.componentsDir, name, file);
+        const content = upstreamFiles.get(file);
+        if (content === void 0) throw new Error(`The registry document for "${name}" has no file named ${file}.`);
+        const local = existsSync5(localPath) ? hashString(await readFile4(localPath, "utf8")) : null;
+        return {
+          file,
+          localPath,
+          content,
+          local,
+          installed: provenance[name]?.hashes[file] ?? null,
+          upstream: hashString(content)
+        };
+      })
+    );
+    const missing = files.some((file) => file.local === null);
+    const modified = files.some((file) => file.local !== null && file.local !== file.installed);
+    const outdated = files.some((file) => file.installed !== file.upstream);
+    const state = missing ? "missing" : modified && outdated ? "diverged" : modified ? "modified" : outdated ? "outdated" : "pristine";
+    statuses.push({ name, state, files });
+  }
+  return statuses.sort((left, right) => left.name.localeCompare(right.name));
+};
+var LABELS = {
+  pristine: "up to date",
+  modified: "modified locally",
+  outdated: "update available",
+  diverged: "modified locally and updated upstream",
+  missing: "files missing"
+};
+var diffCommand = async (names, options = {}) => {
+  const config = await loadConfig(process.cwd());
+  const statuses = await componentStatus(config, names.length > 0 ? names : void 0);
+  if (statuses.length === 0) {
+    log.detail("No registry components are installed yet. Run odori add first.");
+    return;
+  }
+  for (const status of statuses) {
+    log.title(`@odori/${status.name}  ${LABELS[status.state]}`);
+    for (const file of status.files) {
+      if (file.local === null) {
+        log.error(`  ${file.file} is missing from ${relative2(config.root, resolve5(file.localPath, ".."))}`);
+        continue;
+      }
+      if (file.local === file.upstream) {
+        log.detail(`  ${file.file} identical to upstream`);
+        continue;
+      }
+      const lines = diffLines(await readFile4(file.localPath, "utf8"), file.content);
+      const { added, removed } = countChanges(lines);
+      log.info(`  ${file.file}  +${added} -${removed} against upstream`);
+      if (options.full) for (const line of formatDiff(lines)) log.detail(`    ${line}`);
+    }
+  }
+  if (!options.full) log.detail("Pass --full to print the diff.");
+};
+var updateCommand = async (names, options = {}) => {
+  const config = await loadConfig(process.cwd());
+  const statuses = await componentStatus(config, names.length > 0 ? names : void 0);
+  if (statuses.length === 0) {
+    log.detail("No registry components are installed yet. Run odori add first.");
+    return;
+  }
+  const provenance = await readProvenance(config);
+  let updated = 0;
+  let skipped = 0;
+  for (const status of statuses) {
+    if (status.state === "pristine") {
+      log.detail(`@odori/${status.name} is up to date`);
+      continue;
+    }
+    if (status.state === "modified") {
+      log.detail(`@odori/${status.name} is modified locally, and upstream has not changed`);
+      continue;
+    }
+    if ((status.state === "diverged" || status.state === "missing") && !options.force) {
+      log.warn(`@odori/${status.name}: ${LABELS[status.state]}. Review with odori diff ${status.name}, then use --force.`);
+      skipped += 1;
+      continue;
+    }
+    for (const file of status.files) {
+      await mkdir3(resolve5(file.localPath, ".."), { recursive: true });
+      await writeFile4(file.localPath, file.content, "utf8");
+    }
+    provenance[status.name] = {
+      source: `@odori/${status.name}`,
+      version: "0.1.0",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      hashes: Object.fromEntries(status.files.map((file) => [file.file, file.upstream]))
+    };
+    updated += 1;
+    log.success(`@odori/${status.name} updated`);
+  }
+  await writeProvenance(config, provenance);
+  log.detail(`${updated} updated, ${skipped} left for review.`);
+};
+
+// src/commands/add.ts
+var addCommand = async (names, options = {}) => {
+  if (names.length === 0) throw new Error("Name at least one component, for example @odori/title-reveal.");
+  const config = await loadConfig(process.cwd());
+  const source = await resolveRegistry(config);
+  const registry = source.items;
+  const provenance = await readProvenance(config);
+  if (source.origin === "network") log.detail(`registry: ${source.detail}`);
+  else if (source.origin === "cache") log.detail(`registry: cached copy of ${registryUrl(config)} (offline)`);
+  else log.warn(`registry: the copy built into this CLI. It may be older than ${registryUrl(config)}.`);
+  const queue = [...names.map(normalizeComponentName)];
+  const installed = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (installed.includes(name)) continue;
+    const component = registry.find((item2) => item2.name === name);
+    if (!component) {
+      throw new Error(`Unknown component "${name}". Known: ${registry.map((item2) => item2.namespaced).join(", ")}`);
+    }
+    queue.push(...component.registryDependencies.map(normalizeComponentName));
+    for (const cue of component.contract.requires.audio) {
+      const provider = registry.find((item2) => item2.cue?.name === cue);
+      if (provider) queue.push(provider.name);
+      else log.warn(`${component.namespaced} needs a "${cue}" cue and no registry entry provides one.`);
+    }
+    const { item } = await resolveItem(config, component.name);
+    verifyIntegrity(item);
+    const target = resolve6(config.root, config.componentsDir, component.name);
+    const hashes = {};
+    for (const file of item.files) {
+      const destination = resolve6(config.root, file.target);
+      const exists = existsSync6(destination);
+      log.detail(`  ${exists ? "replace" : "create "} ${relative3(config.root, destination)}`);
+    }
+    if (options.dryRun) {
+      installed.push(component.name);
+      continue;
+    }
+    await mkdir4(target, { recursive: true });
+    for (const file of item.files) {
+      const name2 = file.path.split("/").pop() ?? file.path;
+      const destination = resolve6(config.root, file.target);
+      hashes[name2] = hashString2(file.content);
+      if (existsSync6(destination) && !options.force) {
+        const current = hashString2(await readFile5(destination, "utf8"));
+        const recorded = provenance[component.name]?.hashes[name2];
+        if (current !== recorded) {
+          log.warn(`${relative3(config.root, destination)} was modified locally. Keeping your version. Use --force to replace it.`);
+          continue;
+        }
+      }
+      await mkdir4(resolve6(destination, ".."), { recursive: true });
+      await writeFile5(destination, file.content, "utf8");
+    }
+    provenance[component.name] = {
+      source: component.namespaced,
+      version: "0.1.0",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      hashes
+    };
+    installed.push(component.name);
+    log.success(`${component.namespaced} to ${relative3(config.root, target)}/`);
+    if (component.kind === "cue" && component.cue) {
+      log.detail(
+        `  ${component.family} \xB7 ${component.contract.recommendedDurationInFrames} frames \xB7 registers "${component.cue.name}"`
+      );
+      const registered = await registerCueInBrand(config, component.cue, component.name);
+      if (registered?.already) {
+        log.detail(`  "${component.cue.name}" is already registered in ${registered.file}`);
+      } else if (registered) {
+        log.detail(`  registered "${component.cue.name}" in ${registered.file}`);
+      } else {
+        log.warn(`  No brand with an audio.cues block found. Add it yourself:`);
+        log.detail(`    import {${component.cue.export}} from "./components/${component.name}/${component.name}";`);
+        log.detail(`    audio: {cues: {"${component.cue.name}": ${component.cue.export}()}}`);
+      }
+    } else {
+      log.detail(
+        `  ${component.family} \xB7 recommended ${component.contract.recommendedDurationInFrames} frames \xB7 ${component.contract.aspectRatios.join(", ")}`
+      );
+    }
+  }
+  if (options.dryRun) {
+    log.detail("Nothing was written. Drop --dry-run to install.");
+    return;
+  }
+  await writeProvenance(config, provenance);
+  log.detail("Run odori dev to preview the installed component fixtures.");
+};
+var registryCommand = async () => {
+  const config = await loadConfig(process.cwd());
+  const source = await resolveRegistry(config);
+  const registry = source.items;
+  const families = [...new Set(registry.map((component) => component.family))];
+  for (const family of families) {
+    log.title(family);
+    for (const component of registry.filter((item) => item.family === family)) {
+      log.info(`  ${component.namespaced.padEnd(26)} ${component.description}`);
+      log.detail(
+        component.kind === "cue" && component.cue ? `    sound \xB7 ${component.contract.recommendedDurationInFrames} frames \xB7 registers "${component.cue.name}"` : `    ${component.contract.aspectRatios.join(", ")} \xB7 min ${component.contract.minimumDurationInFrames} frames \xB7 reduced motion: ${component.contract.reducedMotion}`
+      );
+    }
+  }
+  log.detail(
+    source.origin === "network" ? `${registry.length} entries from ${source.detail}` : source.origin === "cache" ? `${registry.length} entries from the cache (offline). Latest is at ${registryUrl(config)}.` : `${registry.length} entries from the copy built into this CLI. Latest is at ${registryUrl(config)}.`
+  );
+};
+
+// src/commands/dev.ts
+import { resolve as resolve18 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+
+// src/jobs.ts
+import { mkdir as mkdir5, readFile as readFile6, readdir as readdir2, rename, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { join as join2, resolve as resolve7 } from "path";
+var buildsDir = (config) => resolve7(config.root, config.outDir, "builds");
+var jobFile = (config, id) => join2(buildsDir(config), `${id}.json`);
+var createJob = async (config, manifest, output) => {
+  await mkdir5(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 };
+  await writeFile6(jobFile(config, job.id), `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  return record;
+};
+var readJob = async (config, id) => {
+  const file = jobFile(config, id);
+  if (!existsSync7(file)) throw new Error(`Unknown job "${id}". Run odori jobs to list them.`);
+  return JSON.parse(await readFile6(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 writeFile6(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 (!existsSync7(buildsDir(config))) return [];
+  if (options.reconcile !== false) await reconcileJobs(config);
+  const files = (await readdir2(buildsDir(config))).filter((file) => file.endsWith(".json"));
+  const jobs = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile6(join2(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 mkdir6, readdir as readdir3, readFile as readFile7, stat, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { join as join3, relative as relative4, resolve as resolve8, sep } 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 readdir3(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);
+  }
+  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 = resolve8(config.root, config.audioDir);
+  if (!existsSync8(root)) return [];
+  const publicRoot = resolve8(config.root, "public");
+  const files = (await walk(root)).filter((file) => AUDIO_EXTENSIONS.test(file)).sort();
+  return Promise.all(
+    files.map(async (file) => ({
+      name: relative4(root, file).replace(AUDIO_EXTENSIONS, "").split(sep).join("/"),
+      url: file.startsWith(`${publicRoot}${sep}`) ? `/${relative4(publicRoot, file).split(sep).join("/")}` : `/${relative4(config.root, file).split(sep).join("/")}`,
+      relativeFile: relative4(config.root, file),
+      bytes: (await stat(file)).size
+    }))
+  );
+};
+var discoverProject = async (config) => {
+  const videosRoot = resolve8(config.root, config.videosDir);
+  if (!existsSync8(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 hashParts = [];
+  for (const file of files) {
+    const relativeFile = relative4(config.root, file);
+    if (/\.(tsx|ts|css|json)$/.test(file)) {
+      const contents = await readFile7(file, "utf8");
+      hashParts.push(`${relativeFile}:${hashString3(contents)}`);
+    }
+    const base = file.split(sep).pop() ?? "";
+    if (base === "video.tsx") {
+      const slug = relative4(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep).join("/") || "video";
+      videos.push({
+        slug,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(slug, "video")
+      });
+    } else if (file.split(sep).includes("brands") && /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx")) {
+      const name = base.replace(/\.tsx?$/, "");
+      brands.push({
+        name,
+        file,
+        relativeFile,
+        identifier: toIdentifier(`${name}-module`, "brands")
+      });
+    } else if (base.endsWith(".preview.tsx")) {
+      const name = base.replace(/\.preview\.tsx$/, "");
+      previews.push({
+        name,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(`${relative4(videosRoot, file).split(sep).join("-")}`, "preview")
+      });
+    }
+  }
+  return { videos, previews, brands, audio, sourceHash: hashString3(hashParts.join("|")) };
+};
+var generateImports = (graph, outDir) => {
+  const importPath = (file) => {
+    const relativePath = relative4(outDir, file).split(sep).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 = resolve8(config.root, config.outDir);
+  await mkdir6(outDir, { recursive: true });
+  const target = join3(outDir, "imports.generated.ts");
+  await writeFile7(target, generateImports(graph, outDir), "utf8");
+  await writeFile7(
+    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 })),
+        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 resolve11 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import {
+  createRenderManifest,
+  entryDurationInFrames,
+  resolveEntryLayout,
+  resolveVideoId
+} from "odori";
+
+// src/integrity.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve9 } from "path";
+var cacheFile = (config) => resolve9(config.root, config.outDir, "cache", "integrity.json");
+var readCache = async (config) => {
+  const file = cacheFile(config);
+  if (!existsSync9(file)) return {};
+  try {
+    return JSON.parse(await readFile8(file, "utf8"));
+  } catch {
+    return {};
+  }
+};
+var writeCache = async (config, cache) => {
+  const file = cacheFile(config);
+  await mkdir7(dirname3(file), { recursive: true });
+  await writeFile8(file, `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+};
+var sha256 = (bytes) => `sha256-${createHash2("sha256").update(bytes).digest("base64")}`;
+var localCandidates = (config, url) => [
+  resolve9(config.root, "public", url.replace(/^\//, "")),
+  resolve9(config.root, url.replace(/^\//, ""))
+];
+var isServed = (config, file) => file.startsWith(resolve9(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) => existsSync9(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 readFile8(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 existsSync10 } from "fs";
+import { mkdir as mkdir8, readFile as readFile9, readdir as readdir4, rm, writeFile as writeFile9 } from "fs/promises";
+import { join as join4, resolve as resolve10 } 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) => resolve10(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 (!existsSync10(file)) return { hit: false, value: void 0 };
+  try {
+    const entry = JSON.parse(await readFile9(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 mkdir8(target, { recursive: true });
+  const entry = { key, value, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile9(join4(target, `${prepareCacheKey(key)}.json`), `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+};
+var clearPrepareCache = async (config, videoId) => {
+  const target = directory(config);
+  if (!existsSync10(target)) return 0;
+  const files = await readdir4(target);
+  const matches = files.filter((file) => videoId ? file.startsWith(`${fileKey(videoId)}__`) : file.endsWith(".json"));
+  await Promise.all(matches.map((file) => rm(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 = resolve11(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 };
+};
+
+// src/render.ts
+import { spawn as spawn2 } from "child_process";
+import { copyFile as copyFile2, mkdir as mkdir11, rm as rm2, writeFile as writeFile12 } from "fs/promises";
+import { cpus } from "os";
+import { dirname as dirname4, join as join6, resolve as resolve15 } from "path";
+import { chromium } from "playwright-core";
+
+// src/audio-mix.ts
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve13 } from "path";
+import { duckEnvelope, envelopeAtFrame } from "odori";
+
+// src/cues.ts
+import { existsSync as existsSync11, statSync } from "fs";
+import { mkdir as mkdir9, writeFile as writeFile10 } from "fs/promises";
+import { basename, resolve as resolve12 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import {
+  SAMPLE_RATE,
+  cueSamples,
+  cueUrl,
+  defaultLayout,
+  encodeWav,
+  isCueDefinition,
+  resolveEntryLayout as resolveEntryLayout2
+} from "odori";
+var cueCacheDir = (config) => resolve12(config.root, config.outDir, "cues");
+var cueFile = (config, url) => resolve12(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 mkdir9(cueCacheDir(config), { recursive: true });
+  const written = [];
+  for (const [url, cue] of seen) {
+    const file = cueFile(config, url);
+    if (existsSync11(file)) {
+      written.push({ cue, file, rendered: false });
+      continue;
+    }
+    const samples = cueSamples(cue, fps);
+    const signal = cue.render({ samples, sampleRate: SAMPLE_RATE });
+    await writeFile10(file, encodeWav(signal));
+    written.push({ cue, file, rendered: true });
+  }
+  return written;
+};
+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 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 importFresh = async (file) => await import(`${pathToFileURL3(file).href}?odori=${statSync(file).mtimeMs}`);
+var registerProjectCues = async (graph) => {
+  for (const discovered of graph.brands) {
+    try {
+      const module = await importFresh(discovered.file);
+      registerCues(Object.values(module).filter(isBrand), defaultLayout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] could not read cues from ${discovered.relativeFile}: ${message(error)}`);
+    }
+  }
+  try {
+    for (const video of await loadVideos(graph)) {
+      const layout = resolveEntryLayout2(video.entry);
+      registerCues([layout.brand], layout.format.fps);
+    }
+  } catch (error) {
+    log.warn(`[odori] generated cues 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 existsSync12(generated) ? generated : null;
+  }
+  const candidates = [
+    resolve13(config.root, "public", src.replace(/^\//, "")),
+    resolve13(config.root, src.replace(/^\//, ""))
+  ];
+  return candidates.find((candidate) => existsSync12(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 existsSync13 } from "fs";
+import { copyFile, mkdir as mkdir10, readFile as readFile10, writeFile as writeFile11 } from "fs/promises";
+import { join as join5, resolve as resolve14 } from "path";
+import { hashValue as hashValue2 } from "odori";
+var cacheDir2 = (config) => resolve14(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,
+  input: identity.input ?? null
+});
+var readChunkRecord = async (config, key) => {
+  const meta = join5(cacheDir2(config), `${key}.json`);
+  const media = join5(cacheDir2(config), `${key}.mp4`);
+  if (!existsSync13(meta) || !existsSync13(media)) return null;
+  try {
+    return JSON.parse(await readFile10(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 mkdir10(directory2, { recursive: true });
+  await copyFile(file, join5(directory2, `${key}.mp4`));
+  const record = { key, signatures, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeFile11(join5(directory2, `${key}.json`), `${JSON.stringify(record)}
+`, "utf8");
+};
+var signaturesMatch = (recorded, observed) => recorded.length === observed.length && recorded.every((signature, index) => signature === observed[index]);
+
+// src/formats.ts
+var FORMATS = {
+  mp4: {
+    name: "mp4",
+    extension: ".mp4",
+    alpha: false,
+    chunked: true,
+    audio: true,
+    description: "H.264 in MP4. Plays everywhere; the default.",
+    args: (preset) => ["-c:v", "libx264", "-crf", "17", "-preset", preset, "-pix_fmt", "yuv420p"]
+  },
+  webm: {
+    name: "webm",
+    extension: ".webm",
+    alpha: true,
+    // VP9 in WebM concatenates cleanly through the demuxer, same as H.264.
+    chunked: true,
+    audio: true,
+    description: "VP9 in WebM, with alpha. For the web, and for overlays.",
+    args: () => ["-c:v", "libvpx-vp9", "-crf", "24", "-b:v", "0", "-pix_fmt", "yuva420p", "-row-mt", "1"]
+  },
+  prores: {
+    name: "prores",
+    extension: ".mov",
+    alpha: true,
+    chunked: true,
+    audio: true,
+    description: "ProRes 4444 in MOV, with alpha. For handing to an editor.",
+    args: () => ["-c:v", "prores_ks", "-profile:v", "4444", "-pix_fmt", "yuva444p10le", "-alpha_bits", "8"]
+  },
+  gif: {
+    name: "gif",
+    extension: ".gif",
+    alpha: false,
+    // A GIF's palette is computed across the whole animation, so chunks would
+    // each invent their own and the result would flicker between them.
+    chunked: false,
+    audio: false,
+    description: "An animated GIF, palette optimised. Silent, by the format.",
+    args: () => [
+      "-vf",
+      "split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=3",
+      "-loop",
+      "0"
+    ]
+  },
+  png: {
+    name: "png",
+    extension: ".png",
+    alpha: true,
+    chunked: false,
+    audio: false,
+    description: "A numbered PNG sequence, with alpha. For a compositor.",
+    args: () => ["-c:v", "png", "-pix_fmt", "rgba"]
+  }
+};
+var formatNames = () => Object.keys(FORMATS);
+var resolveFormat = (requested, output) => {
+  if (requested) {
+    const format = FORMATS[requested.toLowerCase()];
+    if (!format) {
+      throw new Error(`Unknown format "${requested}". Available: ${formatNames().join(", ")}`);
+    }
+    return format;
+  }
+  if (output) {
+    const extension = output.slice(output.lastIndexOf(".")).toLowerCase();
+    const matched = Object.values(FORMATS).find((format) => format.extension === extension);
+    if (matched) return matched;
+  }
+  return FORMATS.mp4;
+};
+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
+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 openRenderPage = async (origin, target, config) => {
+  const executablePath = await browserExecutable(config);
+  const browser = await chromium.launch({ executablePath, headless: true });
+  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 });
+var SIGNATURE_SCRIPT = `(() => {
+  var root = document.querySelector("[data-odori-video]");
+  if (!root) return "";
+  var markup = root.outerHTML;
+  var hash = 2166136261;
+  for (var index = 0; index < markup.length; index += 1) {
+    hash ^= markup.charCodeAt(index);
+    hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
+  }
+  return hash.toString(16) + ":" + markup.length;
+})()`;
+var PROBE_SCRIPT = `(async (frames) => {
+  var signature = function () {
+    var root = document.querySelector("[data-odori-video]");
+    if (!root) return "";
+    var markup = root.outerHTML;
+    var hash = 2166136261;
+    for (var index = 0; index < markup.length; index += 1) {
+      hash ^= markup.charCodeAt(index);
+      hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
+    }
+    return hash.toString(16) + ":" + markup.length;
+  };
+  var settled = function (frame) {
+    return new Promise(function (done, fail) {
+      var started = Date.now();
+      var check = function () {
+        var root = document.querySelector("[data-odori-frame]");
+        if (root && root.getAttribute("data-odori-frame") === String(frame)) {
+          done(undefined);
+          return;
+        }
+        if (Date.now() - started > 20000) {
+          fail(new Error("Timed out waiting for frame " + frame));
+          return;
+        }
+        requestAnimationFrame(check);
+      };
+      requestAnimationFrame(check);
+    });
+  };
+  var out = [];
+  for (var index = 0; index < frames.length; index += 1) {
+    window.__ODORI_SET_FRAME__(frames[index]);
+    await settled(frames[index]);
+    out.push(signature());
+  }
+  return out;
+})`;
+var probeSignatures = async (page, frames) => {
+  const signatures = [];
+  for (let index = 0; index < frames.length; index += 60) {
+    const batch = frames.slice(index, index + 60);
+    const result = await page.evaluate(`(${PROBE_SCRIPT})(${JSON.stringify(batch)})`);
+    signatures.push(...result);
+  }
+  return signatures;
+};
+var run = (command2, args, signal) => new Promise((resolveRun, rejectRun) => {
+  if (signal?.aborted) {
+    rejectRun(new Error("Render cancelled."));
+    return;
+  }
+  const child = spawn2(command2, args, { stdio: ["ignore", "ignore", "pipe"] });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const onAbort = () => child.kill("SIGTERM");
+  signal?.addEventListener("abort", onAbort, { once: true });
+  child.on("error", rejectRun);
+  child.on("exit", (code) => {
+    signal?.removeEventListener("abort", onAbort);
+    if (signal?.aborted) rejectRun(new Error("Render cancelled."));
+    else if (code === 0) resolveRun();
+    else rejectRun(new Error(`${command2} exited with ${code}: ${stderr.slice(-800)}`));
+  });
+});
+var browserExecutable = async (config) => {
+  const resolved = await resolveBrowser(config);
+  if (resolved) return resolved.path;
+  log.detail("Downloading the pinned Chrome build. This happens once per machine.");
+  try {
+    return await installBrowser();
+  } catch (error) {
+    throw new Error(
+      `No Chrome available and the managed build could not be downloaded: ${error.message}
+Run "odori install" when you have a connection, or set chromePath in odori.config.ts.`
+    );
+  }
+};
+var ffmpegExecutable = async (config) => {
+  const resolved = await resolveFfmpeg(config);
+  if (resolved) return resolved.path;
+  log.detail("Downloading the pinned FFmpeg build. This happens once per machine.");
+  try {
+    return await installFfmpeg();
+  } catch (error) {
+    throw new Error(
+      `No FFmpeg available and the managed build could not be downloaded: ${error.message}
+Run "odori install" when you have a connection, or set ffmpegPath in odori.config.ts.`
+    );
+  }
+};
+var ensureFfmpeg = async (config) => {
+  await ffmpegExecutable(config);
+};
+var renderStill = async (origin, target, frame, output, config) => {
+  const { browser, page, errors } = await openRenderPage(origin, target, config);
+  try {
+    await mkdir11(dirname4(output), { recursive: true });
+    await seekTo(page, frame);
+    await page.screenshot({ path: output });
+    if (errors.length > 0) log.warn(`The page reported an error while rendering: ${errors[0]}`);
+    return output;
+  } finally {
+    await browser.close();
+  }
+};
+var defaultConcurrency = () => Math.max(1, Math.min(4, cpus().length - 2));
+var writeFrame = (stdin, frame) => new Promise((resolveWrite, rejectWrite) => {
+  if (stdin.write(frame)) {
+    resolveWrite();
+    return;
+  }
+  stdin.once("drain", resolveWrite);
+  stdin.once("error", rejectWrite);
+});
+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}`);
+};
+var openChunkEncoder = (ffmpeg, file, fps, preset, format, signal) => {
+  const child = spawn2(
+    ffmpeg,
+    ["-y", "-f", "image2pipe", "-framerate", String(fps), "-i", "pipe:0", ...format.args(preset), file],
+    { stdio: ["pipe", "ignore", "pipe"] }
+  );
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const onAbort = () => child.kill("SIGTERM");
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const done = new Promise((resolveDone, rejectDone) => {
+    child.on("error", rejectDone);
+    child.on("exit", (code) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (signal?.aborted) rejectDone(new Error("Render cancelled."));
+      else if (code === 0) resolveDone();
+      else rejectDone(new Error(`ffmpeg exited with ${code}: ${stderr.slice(-800)}`));
+    });
+  });
+  return { child, done };
+};
+var captureLane = async (origin, target, config, lane, stats, options) => {
+  let session = await openRenderPage(origin, target, config);
+  const errors = session.errors;
+  const reopen = async () => {
+    await session.browser.close().catch(() => void 0);
+    session = await openRenderPage(origin, target, config);
+    session.errors.push(...errors);
+  };
+  const signatureOf = async () => await session.page.evaluate(SIGNATURE_SCRIPT);
+  try {
+    for (const chunk of lane) {
+      if (options.signal?.aborted) throw new Error("Render cancelled.");
+      const frames = chunkFrames(chunk);
+      const identity = options.cacheIdentity?.(chunk);
+      const key = identity ? chunkKey(identity) : null;
+      if (key) {
+        const record = await readChunkRecord(config, key);
+        if (record) {
+          const observed = await probeSignatures(session.page, frames);
+          if (signaturesMatch(record.signatures, observed)) {
+            await useChunkRecord(config, key, options.chunkFile(chunk));
+            stats.cachedChunks += 1;
+            stats.captured += frames.length;
+            stats.reused += frames.length;
+            for (const _frame of frames) options.onFrame();
+            continue;
+          }
+        }
+      }
+      const file = options.chunkFile(chunk);
+      const encoder = openChunkEncoder(options.ffmpeg, file, target.fps, options.preset, options.format, options.signal);
+      const signatures = [];
+      let previousSignature = null;
+      let previousFrame = null;
+      let written = 0;
+      try {
+        for (const frame of frames) {
+          if (options.signal?.aborted) throw new Error("Render cancelled.");
+          for (let attempt = 0; ; attempt += 1) {
+            try {
+              await seekTo(session.page, frame);
+              const signature = await signatureOf();
+              let image;
+              if (options.skipUnchanged && previousFrame && signature === previousSignature) {
+                image = previousFrame;
+                stats.reused += 1;
+              } else {
+                image = await session.page.screenshot();
+              }
+              await writeFrame(encoder.child.stdin, image);
+              signatures.push(signature);
+              previousSignature = signature;
+              previousFrame = image;
+              written += 1;
+              break;
+            } catch (error) {
+              if (options.signal?.aborted) throw new Error("Render cancelled.");
+              if (attempt >= 1) throw error;
+              log.detail(`Frame ${frame} failed, retrying on a fresh page.`);
+              await reopen();
+              previousSignature = null;
+              previousFrame = null;
+            }
+          }
+          stats.captured += 1;
+          options.onFrame();
+        }
+        encoder.child.stdin?.end();
+        await encoder.done;
+        if (written !== frames.length) {
+          throw new Error(`Chunk ${chunk.index} wrote ${written} of ${frames.length} frames.`);
+        }
+        if (key) await writeChunkRecord(config, key, signatures, file);
+      } catch (error) {
+        encoder.child.kill("SIGTERM");
+        throw error;
+      }
+    }
+  } finally {
+    await session.browser.close().catch(() => void 0);
+    if (session.errors.length > 0) {
+      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 preset = options.preset ?? config.preset ?? "medium";
+  const format = options.format ?? FORMATS.mp4;
+  const chunkable = format.chunked;
+  const skipUnchanged = options.skipUnchangedFrames ?? config.skipUnchangedFrames ?? true;
+  const cache = options.cache ?? config.cacheChunks ?? true;
+  const work = options.workDir ?? resolve15(config.root, config.outDir, "frames", `${target.videoId.split("/").join("-")}-${Date.now().toString(36)}`);
+  await mkdir11(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 mkdir11(dirname4(output), { recursive: true });
+    const captureStart = performance.now();
+    await Promise.all(
+      lanes.map(
+        (lane) => captureLane(origin, target, config, lane, stats, {
+          skipUnchanged,
+          signal: options.signal,
+          preset,
+          format,
+          ffmpeg,
+          workDir: work,
+          chunkFile,
+          cacheIdentity: cache ? (chunk) => ({
+            videoId: target.videoId,
+            chunk,
+            renderer,
+            format: format.name,
+            width: target.width,
+            height: target.height,
+            fps: target.fps,
+            preset,
+            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 = (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 writeFile12(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 mkdir11(dirname4(destination), { recursive: true });
+      await run(ffmpeg, ["-y", "-i", silent, ...format.args(preset), 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 rm2(work, { recursive: true, force: true });
+    else if (!succeeded) log.detail(`Chunks left for inspection in ${work}`);
+  }
+};
+
+// src/open.ts
+import { spawn as spawn3 } from "child_process";
+var command = () => {
+  if (process.platform === "darwin") return { bin: "open", args: [] };
+  if (process.platform === "win32") return { bin: "cmd", args: ["/c", "start", ""] };
+  if (process.platform === "linux") return { bin: "xdg-open", args: [] };
+  return void 0;
+};
+var shouldOpenBrowser = (flag) => {
+  if (flag !== void 0) return flag;
+  if (process.env.ODORI_OPEN === "0" || process.env.ODORI_OPEN === "false") return false;
+  if (process.env.CI) return false;
+  return process.stdout.isTTY === true;
+};
+var openInBrowser = (url) => {
+  const resolved = command();
+  if (!resolved) return;
+  try {
+    const child = spawn3(resolved.bin, [...resolved.args, url], { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+};
+
+// src/server.ts
+import { existsSync as existsSync14 } 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 readFile11 } from "fs/promises";
+import { dirname as dirname5, resolve as resolve16, sep as sep2 } from "path";
+var cliRoot = resolve16(dirname5(fileURLToPath(import.meta.url)), "..");
+var studioRoot = resolve16(cliRoot, "studio");
+var studioEntry = resolve16(studioRoot, "index.html");
+var installRoot = resolve16(cliRoot, "..", "..");
+var VIRTUAL_ID = "virtual:odori-project";
+var RESOLVED_ID = `\0${VIRTUAL_ID}`;
+var runtimeSource = (root) => {
+  for (const from of [resolve16(root, "package.json"), import.meta.url]) {
+    try {
+      const manifest = createRequire2(from).resolve("odori/package.json");
+      const src = resolve16(manifest, "..", "src");
+      if (existsSync14(resolve16(src, "index.tsx"))) return src;
+    } catch {
+    }
+  }
+  return null;
+};
+var odoriProjectPlugin = (config, getGraph) => ({
+  name: "odori:project",
+  resolveId(id) {
+    return id === VIRTUAL_ID ? RESOLVED_ID : null;
+  },
+  load(id) {
+    if (id !== RESOLVED_ID) return null;
+    const graph = getGraph();
+    const fsPath = (file) => JSON.stringify(`/@fs${file}`);
+    return [
+      ...graph.videos.map(
+        (video) => `import ${video.identifier}, {metadata as ${video.identifier}Metadata} from ${fsPath(video.file)};`
+      ),
+      ...graph.previews.map((preview) => `import ${preview.identifier} from ${fsPath(preview.file)};`),
+      ...graph.brands.map((brand) => `import * as ${brand.identifier} from ${fsPath(brand.file)};`),
+      "export const videos = [",
+      ...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}.default ?? ${preview.identifier}},`
+      ),
+      "];",
+      "export const brands = [",
+      ...graph.brands.map(
+        (brand) => `  ...Object.values(${brand.identifier}).filter((value) => value?.kind === "odori-brand"),`
+      ),
+      "];",
+      `export const project = ${JSON.stringify({
+        root: config.root,
+        videosDir: config.videosDir,
+        exportDir: config.exportDir,
+        audioDir: config.audioDir,
+        docsUrl: config.docsUrl,
+        audio: graph.audio,
+        sourceHash: graph.sourceHash,
+        assets: config.assets ?? [],
+        files: {
+          videos: graph.videos.map((video) => ({ id: video.slug, file: video.relativeFile })),
+          previews: graph.previews.map((preview) => ({ id: preview.name, file: preview.relativeFile })),
+          brands: graph.brands.map((brand) => ({ id: brand.name, file: brand.relativeFile }))
+        }
+      })};`
+    ].join("\n");
+  }
+});
+var startStudioServer = async (initialConfig, options = {}) => {
+  let config = initialConfig;
+  const odoriSrc = runtimeSource(config.root);
+  let graph = await discoverProject(config);
+  await writeGenerated(config, graph);
+  await registerProjectCues(graph);
+  const vite = await createServer({
+    root: studioRoot,
+    configFile: false,
+    // Studio owns the fallback so an unknown asset can 404 instead of being
+    // answered with the app's HTML, which would only fail later at decode.
+    appType: "custom",
+    logLevel: "warn",
+    // The API middleware is installed through a plugin so it runs before
+    // Vite's own history fallback, which would otherwise answer with HTML.
+    plugins: [
+      react(),
+      odoriProjectPlugin(config, () => graph),
+      { name: "odori:api", configureServer: (server) => options.middleware?.(server) },
+      {
+        // Generated cues are rendered on demand and served from memory, so a
+        // preview hears the same bytes the encoder will mix. The URL carries a
+        // hash of the score, which makes it safe to cache forever.
+        name: "odori:generated-cues",
+        configureServer: (server) => () => {
+          server.middlewares.use((request, response, next) => {
+            const path = (request.url ?? "").split("?")[0];
+            if (!path.startsWith("/__odori/cue/")) return next();
+            const wav = renderedCue(path);
+            if (!wav) {
+              response.statusCode = 404;
+              response.setHeader("content-type", "text/plain");
+              response.end(`odori: no generated cue for ${path}`);
+              return;
+            }
+            response.statusCode = 200;
+            response.setHeader("content-type", "audio/wav");
+            response.setHeader("content-length", String(wav.byteLength));
+            response.setHeader("cache-control", "public, max-age=31536000, immutable");
+            response.end(Buffer.from(wav));
+          });
+        }
+      },
+      {
+        // A cue pointing at a file that is not there must fail as a missing
+        // file. Vite's history fallback would answer with the Studio's HTML,
+        // which an <audio> element accepts and then silently fails to decode,
+        // turning a typo in a brand's audio map into a preview with no sound
+        // and no error.
+        name: "odori:asset-404",
+        configureServer: (server) => () => {
+          server.middlewares.use((request, response, next) => {
+            const path = (request.url ?? "").split("?")[0];
+            const isAsset = /\.(?:mp3|m4a|wav|ogg|aac|flac|mp4|webm|mov|png|jpe?g|gif|webp|avif|svg|woff2?|ttf|otf)$/i.test(path);
+            if (!isAsset) return next();
+            response.statusCode = 404;
+            response.setHeader("content-type", "text/plain");
+            response.end(`odori: ${path} is not in public/`);
+          });
+        }
+      }
+    ],
+    // The project's public/ directory is served at the root, so brand fonts,
+    // logos, and footage resolve identically in preview and render.
+    publicDir: existsSync14(resolve16(config.root, "public")) ? resolve16(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: resolve16(odoriSrc, "preview.ts") },
+        { find: /^odori\/manifest$/, replacement: resolve16(odoriSrc, "manifest.ts") },
+        { find: /^odori$/, replacement: resolve16(odoriSrc, "index.tsx") }
+      ] : []
+    },
+    server: {
+      host: "127.0.0.1",
+      port: options.port ?? config.port,
+      strictPort: options.strictPort ?? false,
+      fs: { allow: [studioRoot, config.root, installRoot] },
+      watch: { ignored: [`${config.root}/${config.outDir}/**`] }
+    },
+    optimizeDeps: { include: ["react", "react-dom", "react/jsx-dev-runtime"] }
+  });
+  const rediscover = async (file) => {
+    if (!file.startsWith(resolve16(config.root, config.videosDir))) return;
+    const isEntry = file.endsWith("video.tsx") || file.endsWith(".preview.tsx") || file.includes(`${sep2}brands${sep2}`);
+    if (!isEntry) return;
+    try {
+      graph = await discoverProject(config);
+      await writeGenerated(config, graph);
+      await registerProjectCues(graph);
+    } catch (error) {
+      vite.config.logger.warn(`[odori] rediscovery skipped: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    const module = vite.moduleGraph.getModuleById(RESOLVED_ID);
+    if (module) vite.moduleGraph.invalidateModule(module);
+    vite.ws.send({ type: "full-reload" });
+  };
+  vite.watcher.on("add", (file) => void rediscover(file));
+  vite.watcher.on("unlink", (file) => void rediscover(file));
+  vite.watcher.add(resolve16(config.root, config.videosDir));
+  const reloadConfig = async (file) => {
+    if (!/odori\.config\.(?:ts|mjs|js)$/.test(file)) return;
+    try {
+      config = await loadConfig(config.root);
+      graph = await discoverProject(config);
+      await writeGenerated(config, graph);
+      await registerProjectCues(graph);
+    } catch (error) {
+      vite.config.logger.warn(`[odori] config reload skipped: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+    const module = vite.moduleGraph.getModuleById(RESOLVED_ID);
+    if (module) vite.moduleGraph.invalidateModule(module);
+    vite.ws.send({ type: "full-reload" });
+  };
+  const refreshCues = async (file) => {
+    if (!file.startsWith(resolve16(config.root, config.videosDir)) || !file.split(sep2).includes("brands")) return;
+    await registerProjectCues(graph);
+  };
+  vite.watcher.on("change", (file) => void 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(resolve16(config.root, name));
+  }
+  vite.middlewares.use(async (request, response, next) => {
+    const url = (request.url ?? "/").split("?")[0];
+    const routable = request.method === "GET" && !url.startsWith("/@") && !url.startsWith("/__odori") && !/\.[a-zA-Z0-9]+$/.test(url);
+    if (!routable) {
+      next();
+      return;
+    }
+    try {
+      const html = await readFile11(studioEntry, "utf8");
+      response.statusCode = 200;
+      response.setHeader("content-type", "text/html");
+      response.end(await vite.transformIndexHtml(url, html));
+    } catch (error) {
+      next(error);
+    }
+  });
+  await vite.listen();
+  const address = vite.resolvedUrls?.local[0] ?? `http://127.0.0.1:${options.port ?? config.port}`;
+  return {
+    vite,
+    url: address.replace(/\/$/, ""),
+    graph,
+    close: async () => {
+      await vite.close();
+    }
+  };
+};
+
+// src/commands/exportVideo.ts
+import { resolve as resolve17 } from "path";
+import { resolveEntryLayout as resolveEntryLayout4 } from "odori";
+
+// src/commands/shared.ts
+import { resolveEntryLayout as resolveEntryLayout3 } from "odori";
+var createContext = async (root = process.cwd()) => {
+  const config = await loadConfig(root);
+  const graph = await discoverProject(config);
+  const videos = await loadVideos(graph);
+  const brands = /* @__PURE__ */ new Map();
+  for (const video of videos) {
+    const layout = resolveEntryLayout3(video.entry);
+    brands.set(layout.brand.name, layout.brand);
+    registerCues([layout.brand], layout.format.fps);
+  }
+  return { config, graph, videos };
+};
+var targetFor = (video, input, prepared, audio, scenes) => {
+  const layout = resolveEntryLayout3(video.entry);
+  return {
+    videoId: video.entry.metadata.id,
+    width: layout.format.width,
+    height: layout.format.height,
+    fps: layout.format.fps,
+    durationInFrames: video.durationInFrames,
+    input,
+    prepared,
+    audio,
+    scenes,
+    targetLufs: layout.audio.targetLufs
+  };
+};
+var compileInBrowser = async (origin, target, config) => {
+  const { browser, page } = await openRenderPage(origin, target, config);
+  try {
+    const timeline = await readTimeline(page);
+    const track = await readAudio(page);
+    return {
+      durationInFrames: target.durationInFrames || timeline.durationInFrames,
+      scenes: timeline.scenes.map((scene) => ({
+        id: scene.id,
+        start: scene.start,
+        durationInFrames: scene.durationInFrames
+      })),
+      audio: track.cues
+    };
+  } finally {
+    await browser.close();
+  }
+};
+var withServer = async (config, handler) => {
+  const server = await startStudioServer(config, { port: 0 });
+  try {
+    return await handler(server);
+  } finally {
+    await server.close();
+  }
+};
+
+// src/commands/exportVideo.ts
+var exportQueue = new JobQueue();
+var running = /* @__PURE__ */ new Map();
+var cancelJob = (id) => {
+  const controller = running.get(id);
+  if (!controller) return false;
+  controller.abort();
+  return true;
+};
+var runJob = async (config, origin, record, video, options = {}) => exportQueue.enqueue(async () => {
+  const { manifest, output } = record;
+  const controller = new AbortController();
+  running.set(record.job.id, controller);
+  if (options.signal) options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+  let current = await updateJob(config, {
+    ...record.job,
+    status: "rendering",
+    progress: 0,
+    attempts: record.job.attempts + 1,
+    pid: process.pid,
+    error: void 0
+  });
+  options.onProgress?.(current);
+  await appendJobLog(config, current.id, `attempt ${current.attempts} started`);
+  try {
+    const cues = await materializeCues(config, [resolveEntryLayout4(video.entry).brand], manifest.format.fps);
+    const rendered2 = cues.filter((entry) => entry.rendered).length;
+    if (rendered2 > 0) await appendJobLog(config, current.id, `rendered ${rendered2} generated cue(s)`);
+    await renderMovie(
+      origin,
+      // The frozen scene list drives chunking, so chunks follow scene cuts.
+      targetFor(
+        { ...video, durationInFrames: manifest.format.durationInFrames },
+        manifest.input,
+        manifest.prepared,
+        manifest.audio,
+        manifest.scenes
+      ),
+      output,
+      config,
+      (progress, stage) => {
+        const rounded = Math.round(progress * 100);
+        if (rounded % 5 !== 0 && progress < 1) return;
+        void updateJob(config, { ...current, status: stage, progress }).then((next) => {
+          current = next;
+          options.onProgress?.(next);
+        });
+      },
+      {
+        concurrency: options.concurrency,
+        preset: options.preset,
+        format: options.format,
+        skipUnchangedFrames: options.skipUnchangedFrames,
+        signal: controller.signal,
+        onTimings: (timings) => {
+          log.progressDone();
+          const reused = timings.reusedFrames > 0 ? `, ${timings.reusedFrames} reused` : "";
+          const cached = timings.cachedChunks > 0 ? `, ${timings.cachedChunks} chunks from cache` : "";
+          log.detail(
+            `captured ${timings.frames} frames in ${(timings.captureMs / 1e3).toFixed(1)}s on ${timings.concurrency} workers across ${timings.chunks} chunks${reused}${cached}, joined in ${(timings.encodeMs / 1e3).toFixed(1)}s`
+          );
+        }
+      }
+    );
+    current = await updateJob(config, { ...current, status: "ready", progress: 1, pid: void 0, output });
+    await appendJobLog(config, current.id, `ready: ${output}`);
+    options.onProgress?.(current);
+    return current;
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    current = await updateJob(config, { ...current, status: "failed", pid: void 0, error: message2 });
+    await appendJobLog(config, current.id, `failed: ${message2}`);
+    options.onProgress?.(current);
+    throw error;
+  } finally {
+    running.delete(record.job.id);
+  }
+});
+var exportCommand = async (id, options = {}) => {
+  const { config, graph, videos } = await createContext();
+  const format = resolveFormat(options.format ?? config.format, options.output);
+  return withServer(config, async (server) => {
+    const record = options.retry ? await readJob(config, options.retry) : await (async () => {
+      const video2 = findVideo(videos, id);
+      const compiled = await compileInBrowser(server.url, targetFor(video2, options.input), config);
+      const { manifest } = await freezeManifest(
+        { ...video2, durationInFrames: compiled.durationInFrames },
+        graph,
+        config,
+        options.input ?? {},
+        { scenes: compiled.scenes, audio: compiled.audio }
+      );
+      const output = resolve17(
+        config.root,
+        options.output ?? `${config.exportDir}/${outputName(id)}${format.extension}`
+      );
+      return createJob(config, manifest, output);
+    })();
+    const video = findVideo(videos, record.manifest.videoId);
+    log.detail(`job ${record.job.id} manifest ${record.manifest.manifestHash}`);
+    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`);
+    }
+    const job = await runJob(config, server.url, record, video, {
+      concurrency: options.concurrency,
+      preset: options.preset,
+      format,
+      skipUnchangedFrames: options.skipUnchangedFrames,
+      onProgress: (next) => {
+        if (next.status === "rendering" || next.status === "encoding") {
+          log.progress(`${next.status} ${Math.round(next.progress * 100)}%`);
+        }
+      }
+    });
+    log.progressDone();
+    log.success(`Exported ${job.videoId} to ${record.output}`);
+    return job;
+  });
+};
+var jobsCommand = async () => {
+  const { config } = await createContext();
+  const jobs = await listJobs(config);
+  if (jobs.length === 0) {
+    log.detail("No export jobs recorded yet.");
+    return;
+  }
+  log.title(`${jobs.length} export job${jobs.length === 1 ? "" : "s"}`);
+  for (const job of jobs) {
+    const detail = job.status === "ready" ? job.output : job.error ?? `${Math.round(job.progress * 100)}%`;
+    log.info(
+      `  ${job.id}  ${job.videoId.padEnd(20)} ${job.status.padEnd(9)} attempts ${job.attempts}  ${detail ?? ""}`
+    );
+  }
+  log.detail("Retry a failed job with: odori export --retry <job id>");
+};
+
+// src/commands/dev.ts
+var readBody = async (request) => {
+  const chunks = [];
+  for await (const chunk of request) chunks.push(chunk);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+};
+var json = (response, status, payload) => {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(payload));
+};
+var devCommand = async (options = {}) => {
+  const config = await loadConfig(options.root ?? process.cwd());
+  const context = async () => {
+    const graph = await discoverProject(config);
+    return { graph, videos: await loadVideos(graph) };
+  };
+  const server = await startStudioServer(config, {
+    port: options.port ?? config.port,
+    middleware: (vite) => {
+      vite.middlewares.use("/__odori", (request, response, next) => {
+        const url = request.url ?? "/";
+        void (async () => {
+          try {
+            if (request.method === "POST" && url.startsWith("/still")) {
+              const body = await readBody(request);
+              const { graph, videos } = await context();
+              const video = findVideo(videos, String(body.videoId));
+              const input = body.input ?? {};
+              const compiled = await compileInBrowser(origin, targetFor(video, input), config);
+              const { manifest, prepared } = await freezeManifest(
+                { ...video, durationInFrames: compiled.durationInFrames },
+                graph,
+                config,
+                input,
+                { scenes: compiled.scenes, audio: compiled.audio }
+              );
+              const frame = Number(body.frame ?? 0);
+              const inline = body.inline === true;
+              const directory2 = inline ? config.outDir : config.exportDir;
+              const file = resolve18(config.root, `${directory2}/${outputName(video.entry.metadata.id)}-${frame}.png`);
+              await renderStill(
+                origin,
+                targetFor(
+                  { ...video, durationInFrames: manifest.format.durationInFrames },
+                  manifest.input,
+                  prepared,
+                  manifest.audio
+                ),
+                frame,
+                file,
+                config
+              );
+              if (inline) {
+                response.statusCode = 200;
+                response.setHeader("content-type", "image/png");
+                response.end(await readFile12(file));
+                return;
+              }
+              json(response, 200, { id: "still", status: "ready", progress: 1, output: file });
+              return;
+            }
+            if (request.method === "POST" && url.startsWith("/exports")) {
+              const body = await readBody(request);
+              const { graph, videos } = await context();
+              const video = findVideo(videos, String(body.videoId));
+              const input = body.input ?? {};
+              const compiled = await compileInBrowser(origin, targetFor(video, input), config);
+              const { manifest } = await freezeManifest(
+                { ...video, durationInFrames: compiled.durationInFrames },
+                graph,
+                config,
+                input,
+                { scenes: compiled.scenes, audio: compiled.audio }
+              );
+              const output = resolve18(config.root, `${config.exportDir}/${outputName(video.entry.metadata.id)}.mp4`);
+              const record = await createJob(config, manifest, output);
+              json(response, 202, record.job);
+              void runJob(config, origin, record, video).catch((error) => {
+                log.error(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
+              });
+              return;
+            }
+            if (request.method === "POST" && url.startsWith("/retry/")) {
+              const id = url.replace("/retry/", "").split("?")[0];
+              const record = await readJob(config, id);
+              const { videos } = await context();
+              const video = findVideo(videos, record.manifest.videoId);
+              json(response, 202, record.job);
+              void runJob(config, origin, record, video).catch((error) => {
+                log.error(`Retry failed: ${error instanceof Error ? error.message : String(error)}`);
+              });
+              return;
+            }
+            if (request.method === "POST" && url.startsWith("/cancel/")) {
+              const id = url.replace("/cancel/", "").split("?")[0];
+              const cancelled = cancelJob(id);
+              json(response, cancelled ? 202 : 404, { id, cancelled });
+              return;
+            }
+            if (request.method === "GET" && url.startsWith("/jobs/")) {
+              const id = url.replace("/jobs/", "").split("?")[0];
+              json(response, 200, (await readJob(config, id)).job);
+              return;
+            }
+            if (request.method === "GET" && url.startsWith("/jobs")) {
+              json(response, 200, await listJobs(config));
+              return;
+            }
+            next();
+          } catch (error) {
+            json(response, 500, { status: "failed", error: error instanceof Error ? error.message : String(error) });
+          }
+        })();
+      });
+    }
+  });
+  const origin = server.url;
+  const entry = `${origin}/videos`;
+  log.title("Odori Studio");
+  log.info(`  ${entry}`);
+  log.detail(`  ${server.graph.videos.length} videos, ${server.graph.previews.length} component previews`);
+  log.detail(`  watching ${config.videosDir}/`);
+  if (shouldOpenBrowser(options.open ?? config.open)) openInBrowser(entry);
+  return server;
+};
+
+// src/commands/doctor.ts
+import { constants } from "fs";
+import { access, mkdir as mkdir12, readFile as readFile13, rm as rm3, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { relative as relative5, resolve as resolve19 } 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(resolve19(root, "package.json"));
+  const [major] = version(process.version);
+  checks.push({
+    name: "Node",
+    detail: process.version,
+    ok: major >= MINIMUM_NODE,
+    fix: `Odori needs Node ${MINIMUM_NODE} or newer. Install it, for example with: nvm install ${MINIMUM_NODE}`
+  });
+  let react2 = "not found";
+  let reactOk = false;
+  try {
+    const manifest = JSON.parse(await readFile13(require2.resolve("react/package.json"), "utf8"));
+    react2 = manifest.version;
+    reactOk = version(react2)[0] >= 19;
+  } catch {
+    react2 = "not installed";
+  }
+  checks.push({
+    name: "React",
+    detail: react2,
+    ok: reactOk,
+    fix: "The runtime needs React 19. Install it: npm install react@19 react-dom@19"
+  });
+  const videosDir = resolve19(config.root, config.videosDir);
+  checks.push({
+    name: "Source root",
+    detail: existsSync15(videosDir) ? relative5(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
+    ok: existsSync15(videosDir),
+    fix: 'Run "odori init" to add the videos source root.'
+  });
+  checks.push({
+    name: "Config",
+    detail: config.configPath ? relative5(config.root, config.configPath) : "defaults (no odori.config.ts)",
+    // Loading got this far, so a config that exists also parsed.
+    ok: true
+  });
+  const chrome = await resolveBrowser(config);
+  checks.push({
+    name: "Chrome",
+    detail: chrome ? `${chrome.origin === "managed" ? `pinned ${CHROME_BUILD}` : `${chrome.origin}, version unpinned`} \xB7 ${chrome.path}` : "not found",
+    ok: Boolean(chrome),
+    fix: 'Run "odori install" to download the pinned build, or set chromePath in odori.config.ts.'
+  });
+  const ffmpeg = await resolveFfmpeg(config);
+  checks.push({
+    name: "FFmpeg",
+    detail: ffmpeg ? `${ffmpeg.origin === "managed" || ffmpeg.origin === "package" ? "pinned 5.3.0" : `${ffmpeg.origin}, version unpinned`} \xB7 ${ffmpeg.path}` : "not found",
+    ok: Boolean(ffmpeg),
+    fix: 'Run "odori install" to download the pinned build, or set ffmpegPath in odori.config.ts.'
+  });
+  const unpinned = [chrome, ffmpeg].filter(
+    (binary) => binary && binary.origin !== "managed" && binary.origin !== "package"
+  );
+  checks.push({
+    name: "Reproducible",
+    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 = resolve19(config.root, ".odori");
+  let writable = false;
+  try {
+    await mkdir12(generated, { recursive: true });
+    const probe = resolve19(generated, ".doctor");
+    await writeFile13(probe, "", "utf8");
+    await access(probe, constants.W_OK);
+    await rm3(probe, { force: true });
+    writable = true;
+  } catch {
+    writable = false;
+  }
+  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 ${relative5(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`
+  });
+  return checks;
+};
+var doctorCommand = async (root = process.cwd()) => {
+  const checks = await runChecks(root);
+  const width = Math.max(...checks.map((check) => check.name.length));
+  log.title("odori doctor");
+  for (const check of checks) {
+    const label = check.name.padEnd(width);
+    if (check.ok) log.success(`${label}  ${check.detail}`);
+    else log.error(`${label}  ${check.detail}`);
+  }
+  const failed = checks.filter((check) => !check.ok);
+  if (failed.length === 0) {
+    log.detail("Everything a render needs is present.");
+    return 0;
+  }
+  log.info("");
+  for (const check of failed) log.warn(`${check.name}: ${check.fix}`);
+  return 1;
+};
+
+// src/commands/init.ts
+import { mkdir as mkdir14, writeFile as writeFile15 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import { relative as relative7, resolve as resolve21 } from "path";
+
+// src/commands/new.ts
+import { mkdir as mkdir13, readdir as readdir5, writeFile as writeFile14 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import { relative as relative6, resolve as resolve20 } 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";
+${hasLayout ? 'import {productLayout} from "../layout";\n' : ""}
+export const metadata = defineVideoMetadata({
+  id: "${name}",
+  title: "${titleCase(name)}",
+${hasLayout ? "  layout: productLayout,\n" : ""}  duration: "8s",
+});
+
+export default function ${pascalCase(name)}() {
+  return (
+    <Video>
+      <Scene id="opening" duration="5s">
+        <h1 style={{fontSize: 112, fontWeight: 650, letterSpacing: "-0.045em", margin: "auto", textAlign: "center"}}>
+          ${titleCase(name)}
+        </h1>
+      </Scene>
+      <Scene id="end" duration="3s">
+        <p style={{fontSize: 48, margin: "auto", opacity: 0.7}}>Built with odori</p>
+      </Scene>
+    </Video>
+  );
+}
+`;
+var composedTemplate = (name, hasLayout, parts) => {
+  const imports = [
+    'import {Scene, Video, defineVideoMetadata} from "odori";',
+    parts.title ? 'import {TitleReveal} from "../components/title-reveal/title-reveal";' : null,
+    parts.end ? 'import {EndCard} from "../components/end-card/end-card";' : null,
+    hasLayout ? 'import {productLayout} from "../layout";' : null
+  ].filter(Boolean);
+  const opening = parts.title ? `        <TitleReveal title="${titleCase(name)}" detail="Written in ${name}/video.tsx" />` : `        <h1 style={{fontSize: 112, fontWeight: 650, margin: "auto", textAlign: "center"}}>${titleCase(name)}</h1>`;
+  const closing = parts.end ? `        <EndCard title="Ship it" detail="odori export ${name}" />` : `        <p style={{fontSize: 48, margin: "auto", opacity: 0.7}}>Built with odori</p>`;
+  return `${imports.join("\n")}
+
+export const metadata = defineVideoMetadata({
+  id: "${name}",
+  title: "${titleCase(name)}",
+${hasLayout ? "  layout: productLayout,\n" : ""}  duration: "8s",
+});
+
+export default function ${pascalCase(name)}() {
+  return (
+    <Video>
+      <Scene id="opening" duration="5s">
+${opening}
+      </Scene>
+      <Scene id="end" duration="3s">
+${closing}
+      </Scene>
+    </Video>
+  );
+}
+`;
+};
+var installedParts = async (config) => {
+  const componentsDir = resolve20(config.root, config.componentsDir);
+  if (!existsSync16(componentsDir)) return { title: false, end: false };
+  const entries = (await readdir5(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 = resolve20(config.root, config.videosDir, name);
+  const file = resolve20(directory2, "video.tsx");
+  if (existsSync16(file)) throw new Error(`${relative6(config.root, file)} already exists.`);
+  const hasLayout = existsSync16(resolve20(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 mkdir13(directory2, { recursive: true });
+  await writeFile14(
+    file,
+    composed ? composedTemplate(name, hasLayout, parts) : videoTemplate(name, hasLayout),
+    "utf8"
+  );
+  log.success(`Created ${relative6(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 @odori/title-reveal @odori/end-card");
+  }
+  log.detail("Run odori dev to preview it.");
+};
+
+// src/commands/init.ts
+var CONFIG_TEMPLATE = `import {defineConfig} from "@odori/cli";
+
+export default defineConfig({
+  videosDir: "videos",
+  exportDir: "out",
+  port: 4300,
+});
+`;
+var LAYOUT_TEMPLATE = `import {defineBrand, defineVideoLayout} from "odori";
+
+export const productBrand = defineBrand({
+  name: "product",
+  colors: {background: "#08090b", surface: "#111318", foreground: "#f7f8fa", accent: "#7c8cff"},
+  // Empty on purpose: "odori add" writes installed cues into this block,
+  // and without it the only thing it can do is print the lines to paste.
+  audio: {cues: {}, targetLufs: -14},
+});
+
+export const productLayout = defineVideoLayout({
+  format: {width: 1920, height: 1080, fps: 30},
+  brand: productBrand,
+  safeArea: {x: 96, y: 72},
+});
+`;
+var initCommand = async (root = process.cwd()) => {
+  const videosDir = resolve21(root, defaultConfig.videosDir);
+  await mkdir14(resolve21(videosDir, "components"), { recursive: true });
+  const files = [
+    [resolve21(root, "odori.config.ts"), CONFIG_TEMPLATE],
+    [resolve21(videosDir, "layout.tsx"), LAYOUT_TEMPLATE],
+    [resolve21(videosDir, "launch", "video.tsx"), videoTemplate("launch", true)]
+  ];
+  for (const [file, contents] of files) {
+    if (existsSync17(file)) {
+      log.detail(`Kept existing ${relative7(root, file)}`);
+      continue;
+    }
+    await mkdir14(resolve21(file, ".."), { recursive: true });
+    await writeFile15(file, contents, "utf8");
+    log.success(`Created ${relative7(root, file)}`);
+  }
+  log.detail("Next: odori doctor, then odori add @odori/title-reveal @odori/end-card, then odori dev.");
+};
+
+// src/commands/inspect.ts
+import { isOdoriSchema, resolveEntryLayout as resolveEntryLayout5 } from "odori";
+var inspectCommand = async (id, options = {}) => {
+  const { config, graph, videos } = await createContext();
+  const video = findVideo(videos, id);
+  const layout = resolveEntryLayout5(video.entry);
+  const { durationInFrames, scenes, audio } = await withServer(
+    config,
+    (server) => compileInBrowser(server.url, targetFor(video, options.input), config)
+  );
+  const { manifest, input, prepared } = await freezeManifest(
+    { ...video, durationInFrames },
+    graph,
+    config,
+    options.input ?? {},
+    { scenes, audio }
+  );
+  if (options.json) {
+    log.info(JSON.stringify({ metadata: { ...video.entry.metadata, layout: void 0, schema: void 0 }, layout, manifest }, null, 2));
+    return;
+  }
+  log.title(video.entry.metadata.title);
+  log.info(`  id           ${video.entry.metadata.id}`);
+  log.info(`  source       ${video.relativeFile}`);
+  log.info(`  format       ${layout.format.width}x${layout.format.height} at ${layout.format.fps} fps`);
+  log.info(`  duration     ${durationInFrames} frames (${(durationInFrames / layout.format.fps).toFixed(2)}s)`);
+  log.info(`  brand        ${layout.brand.name}`);
+  log.info(`  safe area    ${layout.safeArea.x} x ${layout.safeArea.y}`);
+  log.info(`  manifest     ${manifest.manifestHash}`);
+  log.info(`  source hash  ${manifest.sourceHash}`);
+  log.title("Scenes");
+  for (const scene of scenes) {
+    log.info(
+      `  ${scene.id.padEnd(16)} ${String(scene.start).padStart(5)} to ${String(
+        scene.start + scene.durationInFrames - 1
+      ).padStart(5)}  (${scene.durationInFrames} frames)`
+    );
+  }
+  if (scenes.length === 0) log.detail("  No structured scenes. The composition drives motion directly.");
+  log.title("Inputs");
+  if (isOdoriSchema(video.entry.metadata.schema)) {
+    for (const [name, field] of Object.entries(video.entry.metadata.schema.describe())) {
+      log.info(`  ${name.padEnd(16)} ${field.type.padEnd(8)} ${JSON.stringify(input[name])}`);
+    }
+  } else {
+    log.detail(`  ${JSON.stringify(input)}`);
+  }
+  if (prepared !== void 0) {
+    log.title("Prepared");
+    log.detail(`  ${JSON.stringify(prepared).slice(0, 400)}`);
+  }
+  log.title("Audio");
+  if (manifest.audio.length === 0) log.detail('  Silent. Add <Audio src="/audio/bed.mp3" /> to score it.');
+  for (const cue of manifest.audio) {
+    log.info(
+      `  ${cue.src.padEnd(28)} ${String(cue.fromFrame).padStart(5)} to ${String(
+        cue.fromFrame + cue.durationInFrames - 1
+      ).padStart(5)}  gain ${cue.gain}${cue.duckUnder ? " (ducked)" : ""}`
+    );
+    log.detail(`    ${cue.integrity}`);
+  }
+  log.title("Assets");
+  if (manifest.assets.length === 0 && manifest.fonts.length === 0) log.detail("  None declared.");
+  for (const asset of manifest.assets) log.info(`  ${asset.reference ?? asset.url}`);
+  for (const font of manifest.fonts) log.info(`  font ${font.family} ${font.url} ${font.integrity}`);
+};
+
+// src/commands/list.ts
+import { resolveEntryLayout as resolveEntryLayout6 } from "odori";
+var listCommand = async () => {
+  const { videos, graph, config } = await createContext();
+  log.title(`${videos.length} video${videos.length === 1 ? "" : "s"} in ${config.videosDir}/`);
+  for (const video of videos) {
+    const layout = resolveEntryLayout6(video.entry);
+    const seconds = video.durationInFrames / layout.format.fps;
+    log.info(
+      `  ${video.entry.metadata.id}  ${layout.format.width}x${layout.format.height}  ${layout.format.fps}fps  ${video.durationInFrames ? `${seconds.toFixed(1)}s` : "duration from scenes"}`
+    );
+    log.detail(`    ${video.relativeFile}`);
+  }
+  if (graph.previews.length > 0) {
+    log.title(`${graph.previews.length} component preview${graph.previews.length === 1 ? "" : "s"}`);
+    for (const preview of graph.previews) log.info(`  ${preview.name}  ${preview.relativeFile}`);
+  }
+};
+
+// src/commands/still.ts
+import { resolve as resolve22 } from "path";
+var stillCommand = async (id, options = {}) => {
+  const frame = options.frame ?? 0;
+  if (!Number.isInteger(frame) || frame < 0) {
+    throw new Error(`Frame must be a whole number of frames from the start, got ${String(frame)}.`);
+  }
+  const { config, graph, videos } = await createContext();
+  const video = findVideo(videos, id);
+  const output = await withServer(config, async (server) => {
+    const { durationInFrames, scenes, audio } = await compileInBrowser(server.url, targetFor(video, options.input), config);
+    const { manifest, input, prepared } = await freezeManifest(
+      { ...video, durationInFrames },
+      graph,
+      config,
+      options.input ?? {},
+      { scenes, audio }
+    );
+    if (frame >= manifest.format.durationInFrames) {
+      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 = resolve22(config.root, options.output ?? `${config.exportDir}/${outputName(id)}-${frame}.png`);
+    return renderStill(server.url, target, frame, file, config);
+  });
+  log.success(`Still frame ${frame} written to ${output}`);
+  return output;
+};
+
+// src/commands/test.ts
+import { isOdoriSchema as isOdoriSchema2, resolveEntryLayout as resolveEntryLayout8 } from "odori";
+
+// src/contracts.ts
+import { existsSync as existsSync18 } from "fs";
+import { readdir as readdir6 } from "fs/promises";
+import { resolve as resolve23 } from "path";
+import { cueUrl as cueUrl2, isCueDefinition as isCueDefinition2, resolveEntryLayout as resolveEntryLayout7 } from "odori";
+var primaryFamily = (stack) => (stack.split(",")[0] ?? "").trim().replace(/^["']|["']$/g, "");
+var SYSTEM_FAMILIES = /* @__PURE__ */ new Set([
+  "system-ui",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-serif",
+  "ui-rounded",
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "-apple-system",
+  "BlinkMacSystemFont"
+]);
+var isSystemFamily = (family) => SYSTEM_FAMILIES.has(family);
+var checkComponentRequirements = (installed, brand, videoId) => {
+  const failures = [];
+  for (const component of installed) {
+    for (const cue of component.contract.requires.audio) {
+      if (brand.audio.cues[cue] === void 0) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} needs an audio cue named "${cue}". Add it to brand.audio.cues, or remove the component.`
+        });
+      }
+    }
+    for (const role of component.contract.requires.fonts) {
+      const stack = brand.typography[role];
+      if (!stack) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} needs a "${role}" font. Add brand.typography.${role}.`
+        });
+        continue;
+      }
+      const family = primaryFamily(stack);
+      if (family && !isSystemFamily(family) && !brand.fonts.some((font) => font.family === family)) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} uses the "${role}" font "${family}", which has no file in brand.fonts. Preview and export will fall back to a system face.`
+        });
+      }
+    }
+  }
+  return failures;
+};
+var checkAudioWindows = (cues, brand, videoId) => {
+  const generated = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(brand.audio.cues)) {
+    if (isCueDefinition2(value)) generated.set(cueUrl2(value), { name, definition: value });
+  }
+  const failures = [];
+  for (const cue of cues) {
+    const match = generated.get(cue.src);
+    if (!match || cue.loop) continue;
+    if (cue.durationInFrames <= match.definition.durationInFrames) continue;
+    failures.push({
+      video: videoId,
+      message: `"${match.name}" is ${match.definition.durationInFrames} frames long but is placed over ${cue.durationInFrames}. The rest is silence: declare loops on the cue, pass loop to <Audio>, or shorten the window with duration.`
+    });
+  }
+  return failures;
+};
+var checkInstalledContracts = async (config, videos) => {
+  const componentsDir = resolve23(config.root, config.componentsDir);
+  const onDisk = existsSync18(componentsDir) ? (await readdir6(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 });
+  const installed = items.filter((component) => names.has(component.name));
+  if (installed.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const failures = [];
+  for (const video of videos) {
+    const { brand } = resolveEntryLayout7(video.entry);
+    for (const failure of checkComponentRequirements(installed, brand, video.entry.metadata.id)) {
+      const key = `${brand.name}:${failure.message}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      failures.push(failure);
+    }
+  }
+  return failures;
+};
+
+// src/determinism.ts
+import { readdir as readdir7, readFile as readFile14 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import { join as join7, relative as relative8, resolve as resolve24 } from "path";
+var FORBIDDEN = [
+  {
+    pattern: /\bMath\.random\s*\(/,
+    message: 'Math.random() differs per render worker. Use random("a-seed") from odori, which is stable for a seed.'
+  },
+  {
+    pattern: /\bDate\.now\s*\(/,
+    message: "Date.now() makes the frame depend on when it rendered. Derive time from useFrame(), or pass it through the video's input schema."
+  },
+  {
+    pattern: /\bnew\s+Date\s*\(\s*\)/,
+    message: "new Date() with no argument reads the wall clock. Pass the date through the video's input schema so a re-render produces the same frame."
+  },
+  {
+    pattern: /\bperformance\.now\s*\(/,
+    message: "performance.now() is wall clock. A frame's timing comes from useFrame() and the video's fps."
+  }
+];
+var isComment = (line) => /^\s*(\/\/|\*|\/\*)/.test(line);
+var scanSource = (source, file) => {
+  const findings = [];
+  source.split("\n").forEach((text, index) => {
+    if (isComment(text)) return;
+    if (/odori-allow-nondeterminism/.test(text)) return;
+    for (const { pattern, message: message2 } of FORBIDDEN) {
+      if (pattern.test(text)) findings.push({ file, line: index + 1, source: text.trim(), message: message2 });
+    }
+  });
+  return findings;
+};
+var walk2 = async (directory2, files = []) => {
+  for (const entry of await readdir7(directory2, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = join7(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 = resolve24(config.root, config.videosDir);
+  if (!existsSync19(root)) return [];
+  const files = await walk2(root);
+  const findings = await Promise.all(
+    files.map(async (file) => scanSource(await readFile14(file, "utf8"), relative8(config.root, file)))
+  );
+  return findings.flat();
+};
+
+// src/commands/test.ts
+var CANVAS_SCRIPT = `(() => {
+  var root = document.querySelector("[data-odori-video]");
+  if (!root) return [];
+
+  // Only canvases that are actually on screen. The runtime mounts every scene
+  // a second time, hidden, to collect audio cues, and a hidden copy is not
+  // what the export captures.
+  var canvases = Array.prototype.slice.call(root.querySelectorAll("canvas")).filter(function (canvas) {
+    var box = canvas.getBoundingClientRect();
+    if (box.width === 0 || box.height === 0) return false;
+    var style = getComputedStyle(canvas);
+    return style.visibility !== "hidden" && Number(style.opacity) > 0.02;
+  });
+
+  return canvases.map(function (canvas, index) {
+    var context = canvas.getContext("2d");
+    if (!context || canvas.width === 0 || canvas.height === 0) {
+      return {index: index, hash: "no-context", blank: true};
+    }
+    var data;
+    try {
+      data = context.getImageData(0, 0, canvas.width, canvas.height).data;
+    } catch (error) {
+      return {index: index, hash: "tainted", blank: false};
+    }
+
+    // A prime stride over the whole buffer rather than a coarse grid: a grid
+    // steps over thin content and calls a drawn canvas blank, which is a
+    // failure report about the checker rather than about the video.
+    var pixels = canvas.width * canvas.height;
+    var stride = 97;
+    var hash = 5381;
+    var opaque = 0;
+    for (var pixel = 0; pixel < pixels; pixel += stride) {
+      var offset = pixel * 4;
+      if (data[offset + 3] > 8) opaque += 1;
+      hash =
+        ((hash << 5) + hash + data[offset] + data[offset + 1] * 3 + data[offset + 2] * 7 + data[offset + 3] * 11) | 0;
+    }
+    return {index: index, hash: String(hash), blank: opaque === 0};
+  });
+})()`;
+var FRAME_SCRIPT = `(() => {
+  var root = document.querySelector("[data-odori-video]");
+  if (!root) return {overflow: [], small: [], empty: true, painted: 0};
+
+  var bounds = root.getBoundingClientRect();
+  var overflow = [];
+  var small = [];
+  var painted = 0;
+  var nodes = Array.prototype.slice.call(root.querySelectorAll("*"));
+
+  for (var index = 0; index < nodes.length; index += 1) {
+    var node = nodes[index];
+    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;
+    painted += 1;
+
+    var media = ["IMG", "SVG", "CANVAS", "VIDEO"].indexOf(node.tagName) >= 0;
+    var text = "";
+    for (var child = 0; child < node.childNodes.length; child += 1) {
+      var childNode = node.childNodes[child];
+      if (childNode.nodeType === 3) text += childNode.textContent || "";
+    }
+    text = text.trim();
+    if (!media && text.length === 0) continue;
+
+    var label = text.length > 0 ? '"' + text.slice(0, 32) + '"' : "<" + node.tagName.toLowerCase() + ">";
+    if (
+      box.right > bounds.right + 1 ||
+      box.left < bounds.left - 1 ||
+      box.bottom > bounds.bottom + 1 ||
+      box.top < bounds.top - 1
+    ) {
+      if (overflow.indexOf(label) < 0) overflow.push(label);
+    }
+
+    // Normalize against the shorter side, the same reference useDesignScale
+    // uses, so a vertical cut is not judged as if it were letterboxed.
+    var reference = Math.min(bounds.width, bounds.height);
+    var relative = (parseFloat(style.fontSize) / reference) * 1080;
+    if (text.length > 0 && relative > 0 && relative < 20) {
+      var note = label + " at " + Math.round(relative) + "px";
+      if (small.indexOf(note) < 0) small.push(note);
+    }
+  }
+
+  return {overflow: overflow.slice(0, 5), small: small.slice(0, 5), empty: false, painted: painted};
+})()`;
+var testVideo = async (origin, video, config, failures, quiet = false) => {
+  const id = video.entry.metadata.id;
+  const layout = resolveEntryLayout8(video.entry);
+  if (isOdoriSchema2(video.entry.metadata.schema)) {
+    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);
+  try {
+    const timeline = await readTimeline(page);
+    failures.push(...checkAudioWindows((await readAudio(page)).cues, layout.brand, id));
+    const total = video.durationInFrames || timeline.durationInFrames;
+    if (!total) {
+      failures.push({ video: id, message: "No duration could be resolved." });
+      return;
+    }
+    if (video.durationInFrames && timeline.durationInFrames && video.durationInFrames !== timeline.durationInFrames) {
+      failures.push({
+        video: id,
+        message: `metadata.duration is ${video.durationInFrames} frames but scenes total ${timeline.durationInFrames}.`
+      });
+    }
+    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);
+      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) {
+        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.`
+        });
+      }
+      for (const item of result.small) {
+        failures.push({ video: id, message: `Frame ${frame}: ${item} is too small to read at 1080p.` });
+      }
+      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);
+        const again = await page.evaluate(CANVAS_SCRIPT);
+        for (const canvas of canvases) {
+          const second = again.find((item) => item.index === canvas.index);
+          if (canvas.blank) {
+            failures.push({ video: id, message: `Frame ${frame}: canvas ${canvas.index} drew nothing.` });
+            continue;
+          }
+          if (canvas.hash === "tainted") {
+            failures.push({
+              video: id,
+              message: `Frame ${frame}: canvas ${canvas.index} is tainted by a cross-origin draw, so the export cannot read it. Serve the image from public/ or inline it as a data URL.`
+            });
+            continue;
+          }
+          if (second && second.hash !== canvas.hash) {
+            failures.push({
+              video: id,
+              message: `Frame ${frame}: canvas ${canvas.index} drew differently the second time. A canvas must be a function of the frame: draw from useFrame() through useCanvas(), not from requestAnimationFrame or a clock.`
+            });
+          }
+        }
+      }
+    }
+    if (!quiet) log.success(`${id}: ${[...new Set(samples)].length} frames sampled across ${total} frames`);
+  } finally {
+    await browser.close();
+  }
+};
+var testCommand = async (id, options = {}) => {
+  const { config, videos } = await createContext();
+  const selected = id ? videos.filter((video) => video.entry.metadata.id === id) : videos;
+  if (selected.length === 0) throw new Error(id ? `Unknown video "${id}".` : "No videos discovered.");
+  const failures = [];
+  failures.push(...await checkInstalledContracts(config, selected));
+  for (const finding of await checkDeterminism(config)) {
+    failures.push({
+      video: `${finding.file}:${finding.line}`,
+      message: `${finding.message}
+    ${finding.source}`
+    });
+  }
+  await withServer(config, async (server) => {
+    for (const video of selected) await testVideo(server.url, video, config, failures, options.json === true);
+  });
+  if (options.json === true) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: failures.length === 0,
+          videos: selected.map((video) => video.entry.metadata.id),
+          failures
+        },
+        null,
+        2
+      )}
+`
+    );
+    if (failures.length > 0) throw new Error(`${failures.length} check${failures.length === 1 ? "" : "s"} failed.`);
+    return;
+  }
+  if (failures.length > 0) {
+    for (const failure of failures) log.error(`${failure.video}: ${failure.message}`);
+    throw new Error(`${failures.length} check${failures.length === 1 ? "" : "s"} failed.`);
+  }
+  log.success(`All checks passed for ${selected.length} video${selected.length === 1 ? "" : "s"}.`);
+};
+
+// src/cli.ts
+var parseArgs = (argv) => {
+  const [command2 = "help", ...rest] = argv;
+  const positionals = [];
+  const flags = {};
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token.startsWith("--")) {
+      const equals = token.indexOf("=");
+      if (equals > 2) {
+        flags[token.slice(2, equals)] = token.slice(equals + 1);
+        continue;
+      }
+      const name = token.slice(2);
+      const next = rest[index + 1];
+      if (next === void 0 || next.startsWith("--")) flags[name] = true;
+      else {
+        flags[name] = next;
+        index += 1;
+      }
+    } else {
+      positionals.push(token);
+    }
+  }
+  return { command: command2, positionals, flags };
+};
+var numberFlag = (flags, name) => {
+  const value = flags[name];
+  if (value === void 0) return void 0;
+  const parsed = typeof value === "string" ? Number(value) : Number.NaN;
+  if (!Number.isFinite(parsed)) throw new Error(`--${name} needs a number, got ${String(value)}`);
+  return parsed;
+};
+var parseInput = (flags) => {
+  if (typeof flags.input !== "string") return void 0;
+  try {
+    return JSON.parse(flags.input);
+  } catch (error) {
+    const preview = flags.input.length > 40 ? `${flags.input.slice(0, 40)}\u2026` : flags.input;
+    throw new Error(
+      `--input is not valid JSON: ${error.message}. Received: ${preview}
+A shell eats double quotes, so wrap the whole value in single quotes: --input '{"headline":"Ship it"}'`
+    );
+  }
+};
+var COMMAND_FLAGS = {
+  dev: ["port", "open", "no-open"],
+  init: [],
+  doctor: [],
+  install: [],
+  new: ["blank"],
+  add: ["force", "dry-run"],
+  registry: [],
+  diff: ["full"],
+  update: ["force"],
+  list: [],
+  inspect: ["json", "input"],
+  still: ["frame", "output", "input"],
+  test: ["json"],
+  export: ["output", "input", "concurrency", "preset", "format", "no-frame-skip", "retry"],
+  jobs: [],
+  help: []
+};
+var distance = (left, right) => {
+  const rows = Array.from({ length: left.length + 1 }, (_, index) => [index, ...Array(right.length).fill(0)]);
+  for (let column = 0; column <= right.length; column += 1) rows[0][column] = column;
+  for (let row = 1; row <= left.length; row += 1) {
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      rows[row][column] = Math.min(
+        rows[row - 1][column] + 1,
+        rows[row][column - 1] + 1,
+        rows[row - 1][column - 1] + cost
+      );
+    }
+  }
+  return rows[left.length][right.length];
+};
+var nearest = (value, candidates) => {
+  const ranked = candidates.map((candidate) => ({ candidate, score: distance(value, candidate) })).sort((left, right) => left.score - right.score)[0];
+  return ranked && ranked.score <= 2 ? ranked.candidate : void 0;
+};
+var checkFlags = (command2, flags) => {
+  const allowed = COMMAND_FLAGS[command2];
+  if (!allowed) return;
+  for (const name of Object.keys(flags)) {
+    if (allowed.includes(name) || name === "help") continue;
+    const suggestion = nearest(name, allowed);
+    throw new Error(
+      `Unknown flag --${name} for "odori ${command2}".` + (suggestion ? ` Did you mean --${suggestion}?` : allowed.length > 0 ? ` It accepts: ${allowed.map((item) => `--${item}`).join(", ")}` : " It takes no flags.")
+    );
+  }
+};
+var USAGE = {
+  dev: `odori dev [--port <n>] [--no-open]
+  Discover project resources and start Studio.`,
+  init: `odori init
+  Add videos/ and odori.config.ts to a project.`,
+  doctor: `odori doctor
+  Check Node, React, the source root, Chrome, FFmpeg, and the generated cache.`,
+  install: `odori install
+  Download the pinned Chrome and FFmpeg into the shared cache, so a render
+  never waits and every machine encodes with the same build. Run it in a
+  Dockerfile layer or a CI setup step.`,
+  new: `odori new <name> [--blank]
+  Generate a video.tsx entry. --blank writes plain markup instead of composing
+  the components the project has installed.`,
+  add: `odori add <components...> [--force] [--dry-run]
+  Install editable component source, fetched from the registry and cached.
+  --force replaces local edits. --dry-run lists the files and writes nothing.`,
+  registry: `odori registry
+  List available registry components and cues.`,
+  diff: `odori diff [components] [--full]
+  Compare installed components with upstream.`,
+  update: `odori update [components] [--force]
+  Apply upstream component changes.`,
+  list: `odori list
+  Print discovered video ids and formats.`,
+  inspect: `odori inspect <id> [--json] [--input <json>]
+  Show resolved layout, inputs, scenes, and assets.`,
+  still: `odori still <id> --frame <n> [--output <path>] [--input <json>]
+  Render one deterministic frame.`,
+  test: `odori test [id] [--json]
+  Validate contracts and representative frames. --json emits one object per
+  check, for CI.`,
+  export: `odori export <id> [--output <path>] [--input <json>] [--concurrency <n>]
+             [--preset <name>] [--format <name>] [--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.`,
+  jobs: `odori jobs
+  List export jobs and their status.`
+};
+var HELP = `odori - build videos like applications
+
+Usage
+  odori dev [--port 4300]          Discover project resources and start Studio
+  odori init                       Add videos/ and odori.config.ts to a project
+  odori doctor                     Check everything a render and an encode need
+  odori install                    Download the pinned Chrome and FFmpeg
+  odori new <name>                 Generate a video.tsx entry
+  odori add <components...>        Install editable component source
+  odori registry                   List available registry components
+  odori diff [components]          Compare installed components with upstream
+  odori update [components]        Apply upstream component changes
+  odori list                       Print discovered video ids and formats
+  odori inspect <id> [--json]      Show resolved layout, inputs, scenes, assets
+  odori still <id> --frame 120     Render one deterministic frame
+  odori test [id] [--json]         Validate contracts and representative frames
+  odori export <id> [--output f]   Render and encode a distributable file
+  odori jobs                       List export jobs and their status
+
+Options
+  --input '{"headline":"..."}'     Serializable input for the video schema
+  --output <path>                  Output path for still and export
+  --force                          Replace locally modified component source
+  --concurrency <n>                Parallel render workers for export
+  --preset <name>                  x264 preset for export, default medium
+  --format <name>                  mp4, webm, prores, gif, or png
+  --no-frame-skip                  Capture every frame, even unchanged ones
+  --retry <job id>                 Re-run a recorded job from its frozen manifest
+  --no-open                        Start dev without opening Studio in a browser
+  --json                           Machine readable output, for inspect and test
+
+Run "odori <command> --help" for one command, or "odori doctor" to check setup.
+`;
+var cliVersion = () => {
+  try {
+    const require2 = createRequire4(import.meta.url);
+    return require2("../package.json").version;
+  } catch {
+    return "unknown";
+  }
+};
+var run2 = async (argv) => {
+  const { command: command2, positionals, flags } = parseArgs(argv);
+  try {
+    if (command2 === "--version" || command2 === "-v" || command2 === "version") {
+      log.info(`odori ${cliVersion()} (node ${process.version})`);
+      return 0;
+    }
+    if (flags.help === true && USAGE[command2]) {
+      log.info(USAGE[command2]);
+      return 0;
+    }
+    checkFlags(command2, flags);
+    switch (command2) {
+      case "dev": {
+        const server = await devCommand({
+          port: numberFlag(flags, "port"),
+          open: flags["no-open"] === true ? false : flags.open === true ? true : void 0
+        });
+        await new Promise((resolveDev) => {
+          const stop = () => {
+            void server.close().then(() => resolveDev());
+          };
+          process.on("SIGINT", stop);
+          process.on("SIGTERM", stop);
+        });
+        return 0;
+      }
+      case "init":
+        await initCommand();
+        return 0;
+      case "doctor":
+        return await doctorCommand();
+      case "install":
+        return await installCommand();
+      case "new":
+        await newCommand(positionals[0] ?? "", { blank: flags.blank === true });
+        return 0;
+      case "add":
+        await addCommand(positionals, { force: flags.force === true, dryRun: flags["dry-run"] === true });
+        return 0;
+      case "registry":
+        await registryCommand();
+        return 0;
+      case "diff":
+        await diffCommand(positionals, { full: flags.full === true });
+        return 0;
+      case "update":
+        await updateCommand(positionals, { force: flags.force === true });
+        return 0;
+      case "list":
+        await listCommand();
+        return 0;
+      case "inspect":
+        await inspectCommand(positionals[0] ?? "", { json: flags.json === true, input: parseInput(flags) });
+        return 0;
+      case "still":
+        await stillCommand(positionals[0] ?? "", {
+          frame: numberFlag(flags, "frame") ?? 0,
+          output: typeof flags.output === "string" ? flags.output : void 0,
+          input: parseInput(flags)
+        });
+        return 0;
+      case "test":
+        await testCommand(positionals[0], { json: flags.json === true });
+        return 0;
+      case "export":
+        await exportCommand(positionals[0] ?? "", {
+          output: typeof flags.output === "string" ? flags.output : void 0,
+          input: parseInput(flags),
+          concurrency: numberFlag(flags, "concurrency"),
+          preset: typeof flags.preset === "string" ? flags.preset : void 0,
+          format: typeof flags.format === "string" ? flags.format : void 0,
+          skipUnchangedFrames: flags["no-frame-skip"] === true ? false : void 0,
+          retry: typeof flags.retry === "string" ? flags.retry : void 0
+        });
+        return 0;
+      case "jobs":
+        await jobsCommand();
+        return 0;
+      case "help":
+      case "--help":
+      case "-h":
+        log.info(HELP);
+        return 0;
+      default: {
+        const commands = Object.keys(COMMAND_FLAGS).filter((name) => name !== "help");
+        const suggestion = nearest(command2, commands);
+        log.error(`Unknown command "${command2}".${suggestion ? ` Did you mean "odori ${suggestion}"?` : ""}`);
+        log.info(HELP);
+        return 1;
+      }
+    }
+  } catch (error) {
+    log.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+};
+
+export {
+  resolveChromePath,
+  loadConfig,
+  defineConfig,
+  discoverProject,
+  generateImports,
+  writeGenerated,
+  localCandidates,
+  createIntegrityResolver,
+  outputName,
+  fileKey,
+  prepareCacheKey,
+  readPrepareCache,
+  writePrepareCache,
+  clearPrepareCache,
+  CHROME_BUILD,
+  cacheRoot,
+  resolveBrowser,
+  resolveFfmpeg,
+  installBrowser,
+  installFfmpeg,
+  renderToolchain,
+  loadVideos,
+  findVideo,
+  runPrepare,
+  freezeManifest,
+  startStudioServer,
+  resolveCueFile,
+  buildAudioFilter,
+  planChunks,
+  chunkFrames,
+  FORMATS,
+  formatNames,
+  resolveFormat,
+  alphaWarning,
+  openRenderPage,
+  seekTo,
+  readTimeline,
+  readAudio,
+  probeSignatures,
+  ensureFfmpeg,
+  renderStill,
+  defaultConcurrency,
+  renderMovie,
+  createContext,
+  targetFor,
+  compileInBrowser,
+  withServer,
+  createJob,
+  readJob,
+  updateJob,
+  appendJobLog,
+  reconcileJobs,
+  listJobs,
+  JobQueue,
+  checkDeterminism,
+  exportQueue,
+  cancelJob,
+  runJob,
+  exportCommand,
+  jobsCommand,
+  devCommand,
+  stillCommand,
+  diffLines,
+  countChanges,
+  formatDiff,
+  componentStatus,
+  diffCommand,
+  updateCommand,
+  testCommand,
+  listCommand,
+  inspectCommand,
+  addCommand,
+  newCommand,
+  initCommand,
+  parseArgs,
+  checkFlags,
+  run2 as run
+};