motionrender 0.2.2 → 0.2.4

package/dist/cli.js

@@ -1272,10 +1272,146 @@ var init_src4 = __esm({
   }
 });
 
+// packages/ffmpeg/src/auto-install.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, renameSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { createGunzip } from "node:zlib";
+function hasSystemFfmpeg() {
+  if (checkedSystemFfmpeg) return systemFfmpegAvailable;
+  try {
+    const res = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    systemFfmpegAvailable = res.status === 0;
+  } catch {
+    systemFfmpegAvailable = false;
+  }
+  checkedSystemFfmpeg = true;
+  return systemFfmpegAvailable;
+}
+function hasSystemFfprobe() {
+  if (checkedSystemFfprobe) return systemFfprobeAvailable;
+  try {
+    const res = spawnSync("ffprobe", ["-version"], { stdio: "ignore" });
+    systemFfprobeAvailable = res.status === 0;
+  } catch {
+    systemFfprobeAvailable = false;
+  }
+  checkedSystemFfprobe = true;
+  return systemFfprobeAvailable;
+}
+function getPlatformArch() {
+  const p2 = process.platform;
+  const a = process.arch;
+  if (p2 === "win32") return { platform: "win32", arch: "x64" };
+  if (p2 === "darwin") return { platform: "darwin", arch: a === "arm64" ? "arm64" : "x64" };
+  if (p2 === "linux") return { platform: "linux", arch: a === "arm64" ? "arm64" : a === "arm" ? "arm" : "x64" };
+  return { platform: p2, arch: a };
+}
+async function downloadAndExtract(name2, destPath, onProgress) {
+  const { platform, arch } = getPlatformArch();
+  const url = `${BASE_URL}/${name2}-${platform}-${arch}.gz`;
+  if (onProgress) onProgress(`Downloading ${name2} (${platform}-${arch})...`);
+  const res = await fetch(url, { redirect: "follow" });
+  if (!res.ok || !res.body) {
+    throw new Error(`Failed to download ${name2} from ${url} (HTTP ${res.status})`);
+  }
+  const tmpPath = `${destPath}.tmp-${Date.now()}`;
+  try {
+    const fileStream = createWriteStream(tmpPath);
+    const nodeReadable = Readable.fromWeb(res.body);
+    await pipeline(nodeReadable, createGunzip(), fileStream);
+    if (!isWin) {
+      chmodSync(tmpPath, 493);
+    }
+    if (existsSync(destPath)) {
+      try {
+        unlinkSync(destPath);
+      } catch {
+      }
+    }
+    renameSync(tmpPath, destPath);
+  } catch (err) {
+    try {
+      if (existsSync(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureFfmpeg(options3) {
+  if (ensureFfmpegPromise) return ensureFfmpegPromise;
+  ensureFfmpegPromise = (async () => {
+    const ffmpegFromEnv = process.env.OVE_FFMPEG_PATH;
+    const ffprobeFromEnv = process.env.OVE_FFPROBE_PATH;
+    const hasLocalFfmpeg = existsSync(localFfmpegPath);
+    const hasLocalFfprobe = existsSync(localFfprobePath);
+    const hasSysFfmpeg = !ffmpegFromEnv && !hasLocalFfmpeg ? hasSystemFfmpeg() : false;
+    const hasSysFfprobe = !ffprobeFromEnv && !hasLocalFfprobe ? hasSystemFfprobe() : false;
+    const ffmpegReady = Boolean(ffmpegFromEnv || hasLocalFfmpeg || hasSysFfmpeg);
+    const ffprobeReady = Boolean(ffprobeFromEnv || hasLocalFfprobe || hasSysFfprobe);
+    if (ffmpegReady && ffprobeReady) {
+      return { ffmpeg: getFfmpegPath(), ffprobe: getFfprobePath() };
+    }
+    if (!existsSync(binDir)) {
+      mkdirSync(binDir, { recursive: true });
+    }
+    const log = options3?.onProgress ?? ((msg) => console.log(msg));
+    if (!ffmpegReady) {
+      log("FFmpeg not found. Automatically downloading static build (one-time setup)...");
+      await downloadAndExtract("ffmpeg", localFfmpegPath, log);
+      log("\u2713 FFmpeg installed successfully.");
+    }
+    if (!ffprobeReady) {
+      log("ffprobe not found. Automatically downloading static build (one-time setup)...");
+      await downloadAndExtract("ffprobe", localFfprobePath, log);
+      log("\u2713 ffprobe installed successfully.");
+    }
+    return { ffmpeg: getFfmpegPath(), ffprobe: getFfprobePath() };
+  })();
+  try {
+    return await ensureFfmpegPromise;
+  } catch (err) {
+    ensureFfmpegPromise = null;
+    throw err;
+  }
+}
+var isWin, binDir, localFfmpegPath, localFfprobePath, checkedSystemFfmpeg, systemFfmpegAvailable, checkedSystemFfprobe, systemFfprobeAvailable, getFfmpegPath, getFfprobePath, RELEASE_TAG, BASE_URL, ensureFfmpegPromise;
+var init_auto_install = __esm({
+  "packages/ffmpeg/src/auto-install.ts"() {
+    "use strict";
+    isWin = process.platform === "win32";
+    binDir = join2(homedir(), ".motionrender", "bin");
+    localFfmpegPath = join2(binDir, isWin ? "ffmpeg.exe" : "ffmpeg");
+    localFfprobePath = join2(binDir, isWin ? "ffprobe.exe" : "ffprobe");
+    checkedSystemFfmpeg = false;
+    systemFfmpegAvailable = false;
+    checkedSystemFfprobe = false;
+    systemFfprobeAvailable = false;
+    getFfmpegPath = () => {
+      if (process.env.OVE_FFMPEG_PATH) return process.env.OVE_FFMPEG_PATH;
+      if (existsSync(localFfmpegPath)) return localFfmpegPath;
+      if (hasSystemFfmpeg()) return "ffmpeg";
+      return localFfmpegPath;
+    };
+    getFfprobePath = () => {
+      if (process.env.OVE_FFPROBE_PATH) return process.env.OVE_FFPROBE_PATH;
+      if (existsSync(localFfprobePath)) return localFfprobePath;
+      if (hasSystemFfprobe()) return "ffprobe";
+      return localFfprobePath;
+    };
+    RELEASE_TAG = "b6.1.1";
+    BASE_URL = `https://github.com/eugeneware/ffmpeg-static/releases/download/${RELEASE_TAG}`;
+    ensureFfmpegPromise = null;
+  }
+});
+
 // packages/ffmpeg/src/index.ts
 import { spawn } from "node:child_process";
 import { once } from "node:events";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 function envelopeExpression(points) {
   if (points.length === 1) return num2(points[0][1]);
   const segment = (i) => {
@@ -1350,11 +1486,13 @@ function concatSegments(segments, listFile, output, audio, options3 = {}) {
   const list = segments.map((s) => `file '${s.replace(/\\/g, "/").replace(/'/g, "'\\''")}'`).join("\n");
   return import("node:fs/promises").then((fs) => fs.writeFile(listFile, list)).then(() => run(["-y", "-f", "concat", "-safe", "0", "-i", listFile, ...audioCodec ? audioMixArgs(audio, audioCodec) : [], ...audio && audioCodec ? [] : ["-map", "0:v"], "-c:v", "copy", ...options3.format === "mp4" || options3.format === void 0 ? ["-movflags", "+faststart"] : [], output], "ignore").done);
 }
-function extractFrames(source, outDir, options3) {
+async function extractFrames(source, outDir, options3) {
+  await ensureFfmpeg();
   const { fps, maxWidth, maxHeight, durationSeconds, startSeconds } = options3;
-  return run(["-v", "error", "-y", ...startSeconds ? ["-ss", String(startSeconds)] : [], ...durationSeconds === void 0 ? [] : ["-t", String(durationSeconds)], "-i", source, "-an", "-vf", `fps=${fps},scale=w='min(iw,${maxWidth})':h='min(ih,${maxHeight})':force_original_aspect_ratio=decrease`, "-q:v", "2", join2(outDir, "%06d.jpg")], "ignore").done;
+  return run(["-v", "error", "-y", ...startSeconds ? ["-ss", String(startSeconds)] : [], ...durationSeconds === void 0 ? [] : ["-t", String(durationSeconds)], "-i", source, "-an", "-vf", `fps=${fps},scale=w='min(iw,${maxWidth})':h='min(ih,${maxHeight})':force_original_aspect_ratio=decrease`, "-q:v", "2", join3(outDir, "%06d.jpg")], "ignore").done;
 }
-function checkFfmpeg() {
+async function checkFfmpeg() {
+  await ensureFfmpeg();
   return new Promise((resolve27, reject) => {
     const child = spawn(ffmpegPath(), ["-hide_banner", "-encoders"]);
     let out = "";
@@ -1371,7 +1509,8 @@ function checkFfmpeg() {
     });
   });
 }
-function hasAudioStream(path) {
+async function hasAudioStream(path) {
+  await ensureFfmpeg();
   return new Promise((resolve27, reject) => {
     const child = spawn(ffprobePath(), ["-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", path]);
     let out = "";
@@ -1380,7 +1519,8 @@ function hasAudioStream(path) {
     child.on("close", (c) => c === 0 ? resolve27(out.trim().length > 0) : reject(new Error(`ffprobe could not read ${path}`)));
   });
 }
-function probe(path) {
+async function probe(path) {
+  await ensureFfmpeg();
   return new Promise((resolve27, reject) => {
     const child = spawn(ffprobePath(), ["-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path]);
     let out = "";
@@ -1389,7 +1529,8 @@ function probe(path) {
     child.on("close", (c) => c === 0 ? resolve27(out.trim()) : reject(new Error("ffprobe failed")));
   });
 }
-function extractAudio(source, output) {
+async function extractAudio(source, output) {
+  await ensureFfmpeg();
   return new Promise((resolve27, reject) => {
     const child = spawn(ffmpegPath(), ["-y", "-i", source, "-vn", "-c:a", "aac", "-b:a", "96k", output], { stdio: ["ignore", "ignore", "pipe"] });
     let error = "";
@@ -1406,10 +1547,12 @@ var x264Presets, defaultPreset, ffmpegPath, ffprobePath, notFound, num2, seconds
 var init_src5 = __esm({
   "packages/ffmpeg/src/index.ts"() {
     "use strict";
+    init_auto_install();
+    init_auto_install();
     x264Presets = ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"];
     defaultPreset = "veryfast";
-    ffmpegPath = () => process.env.OVE_FFMPEG_PATH || "ffmpeg";
-    ffprobePath = () => process.env.OVE_FFPROBE_PATH || "ffprobe";
+    ffmpegPath = () => getFfmpegPath();
+    ffprobePath = () => getFfprobePath();
     notFound = (tool, env) => new Error(`${tool} was not found. Install FFmpeg (it includes ${tool}) and put it on PATH, or set ${env} to the executable.`);
     num2 = (n) => {
       const text = n.toFixed(5).replace(/\.?0+$/, "");
@@ -1452,13 +1595,13 @@ var init_src5 = __esm({
 // packages/core/src/media.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdir, readFile as readFile2, stat as stat2, writeFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { createHash } from "node:crypto";
 async function measureSource(source) {
   const version = isUrl(source) ? "" : await stat2(source).then((s) => `${s.size}:${s.mtimeMs}`, () => {
     throw new Error(`Media not found: ${source}`);
   });
-  const key = createHash("sha256").update(`${source}|${version}|v1`).digest("hex").slice(0, 32), file2 = join3(mediaCache(), `${key}.json`);
+  const key = createHash("sha256").update(`${source}|${version}|v1`).digest("hex").slice(0, 32), file2 = join4(mediaCache(), `${key}.json`);
   const cached2 = await readFile2(file2, "utf8").then(JSON.parse, () => void 0);
   if (cached2) {
     void touchCacheEntry(file2);
@@ -1645,15 +1788,15 @@ ${layer.css ?? ""}`, refs = [...text.matchAll(/(?<![\w:-])src\s*=\s*(["'])([^"']
 
 // packages/renderer/src/video.ts
 import { mkdir as mkdir2, readdir as readdir2, rename, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { createHash as createHash2, randomUUID } from "node:crypto";
 async function decode(source, key, first = 0) {
   const version = isUrl(source) ? "" : await stat3(source).then((s) => `${s.size}:${s.mtimeMs}`, () => {
     throw new Error(`Video not found: ${source}`);
   });
-  const dir = join4(videoCacheRoot(), createHash2("sha256").update(JSON.stringify({ source, version, ...key })).digest("hex").slice(0, 32));
+  const dir = join5(videoCacheRoot(), createHash2("sha256").update(JSON.stringify({ source, version, ...key })).digest("hex").slice(0, 32));
   const count = async () => (await readdir2(dir)).filter((f) => f.endsWith(".jpg")).length;
-  if (await stat3(join4(dir, complete)).then(() => true, () => false)) {
+  if (await stat3(join5(dir, complete)).then(() => true, () => false)) {
     void touchCacheEntry(dir);
     return { dir, count: first + await count(), first };
   }
@@ -1661,9 +1804,9 @@ async function decode(source, key, first = 0) {
   await mkdir2(scratch, { recursive: true });
   try {
     await extractFrames(source, scratch, key);
-    await writeFile2(join4(scratch, complete), "");
+    await writeFile2(join5(scratch, complete), "");
     await rename(scratch, dir).catch(async (error) => {
-      if (!await stat3(join4(dir, complete)).then(() => true, () => false)) throw error;
+      if (!await stat3(join5(dir, complete)).then(() => true, () => false)) throw error;
     });
   } finally {
     await rm2(scratch, { recursive: true, force: true });
@@ -1692,7 +1835,7 @@ var init_video = __esm({
     init_src3();
     init_src4();
     init_src5();
-    videoFrameFile = (video, index) => join4(video.dir, `${String(Math.max(0, index - video.first) + 1).padStart(6, "0")}.jpg`);
+    videoFrameFile = (video, index) => join5(video.dir, `${String(Math.max(0, index - video.first) + 1).padStart(6, "0")}.jpg`);
     videoCacheRoot = () => cacheDir("video");
     complete = ".complete";
   }
@@ -1772,29 +1915,29 @@ var init_pool = __esm({
 });
 
 // packages/graphics/src/fonts.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { dirname, join as join5 } from "node:path";
+import { dirname, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 function builtinFontDir() {
   const bundled = fileURLToPath(new URL("./fonts/", import.meta.url));
-  if (existsSync(join5(bundled, builtinFontFaces[0].file))) return bundled;
-  return join5(dirname(createRequire(import.meta.url).resolve("@fontsource-variable/inter/package.json")), "files");
+  if (existsSync2(join6(bundled, builtinFontFaces[0].file))) return bundled;
+  return join6(dirname(createRequire(import.meta.url).resolve("@fontsource-variable/inter/package.json")), "files");
 }
 var cached, builtinFonts;
 var init_fonts = __esm({
   "packages/graphics/src/fonts.ts"() {
     "use strict";
     init_src6();
-    builtinFonts = () => cached ??= Promise.all(builtinFontFaces.map(async (face) => ({ ...face, src: `builtin:${face.file}`, url: `data:font/woff2;base64,${(await readFile3(join5(builtinFontDir(), face.file))).toString("base64")}` })));
+    builtinFonts = () => cached ??= Promise.all(builtinFontFaces.map(async (face) => ({ ...face, src: `builtin:${face.file}`, url: `data:font/woff2;base64,${(await readFile3(join6(builtinFontDir(), face.file))).toString("base64")}` })));
   }
 });
 
 // packages/graphics/src/runtime.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var runtimeDir, read, textLayoutSource, lottieFile, lottiePath, lottieSource, canvasRuntimeSource, layoutText, layoutRich;
 var init_runtime = __esm({
@@ -1802,14 +1945,14 @@ var init_runtime = __esm({
     "use strict";
     runtimeDir = () => {
       const bundled = fileURLToPath2(new URL("./runtime/", import.meta.url));
-      return existsSync2(join6(bundled, "canvas-runtime.js")) ? bundled : fileURLToPath2(new URL("../runtime/", import.meta.url));
+      return existsSync3(join7(bundled, "canvas-runtime.js")) ? bundled : fileURLToPath2(new URL("../runtime/", import.meta.url));
     };
-    read = (name2) => readFileSync(join6(runtimeDir(), name2), "utf8");
+    read = (name2) => readFileSync(join7(runtimeDir(), name2), "utf8");
     textLayoutSource = read("text-layout.js");
     lottieFile = "lottie_light_canvas.min.js";
     lottiePath = () => {
-      const bundled = join6(runtimeDir(), lottieFile);
-      return existsSync2(bundled) ? bundled : createRequire2(import.meta.url).resolve(`lottie-web/build/player/${lottieFile}`);
+      const bundled = join7(runtimeDir(), lottieFile);
+      return existsSync3(bundled) ? bundled : createRequire2(import.meta.url).resolve(`lottie-web/build/player/${lottieFile}`);
     };
     lottieSource = readFileSync(lottiePath(), "utf8");
     canvasRuntimeSource = `${textLayoutSource}
@@ -1821,28 +1964,70 @@ ${read("canvas-runtime.js")}`;
 
 // packages/renderer/src/index.ts
 import { chromium } from "playwright";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { availableParallelism } from "node:os";
+async function ensureChromium(options3) {
+  if (existsSync4(chromium.executablePath())) return;
+  for (const channel of ["chrome", "msedge"]) {
+    try {
+      const b = await chromium.launch({ headless: true, channel, args: browserArgs });
+      await b.close();
+      return;
+    } catch {
+    }
+  }
+  if (ensureChromiumPromise) return ensureChromiumPromise;
+  ensureChromiumPromise = (async () => {
+    const log = options3?.onProgress ?? ((msg) => console.log(msg));
+    log("No Chrome, Edge, or Chromium browser detected.");
+    log("Downloading Playwright Chromium (one-time setup)...");
+    const { createRequire: createRequire3 } = await import("node:module");
+    const { dirname: dirname21, join: join25 } = await import("node:path");
+    const { spawn: spawn4 } = await import("node:child_process");
+    const req = createRequire3(import.meta.url);
+    const cli = join25(dirname21(req.resolve("playwright/package.json")), "cli.js");
+    await new Promise((resolve27, reject) => {
+      const child = spawn4(process.execPath, [cli, "install", "chromium"], { stdio: "inherit" });
+      child.on("close", (code) => {
+        if (code === 0) resolve27();
+        else reject(new Error(`Chromium installation failed (exit code ${code})`));
+      });
+      child.on("error", reject);
+    });
+    log("\u2713 Playwright Chromium installed successfully.");
+  })();
+  try {
+    await ensureChromiumPromise;
+  } catch (err) {
+    ensureChromiumPromise = null;
+    throw err;
+  }
+}
 async function launchBrowser() {
   const explicit = process.env.OVE_CHROMIUM_EXECUTABLE;
   if (explicit) {
-    if (!existsSync3(explicit)) throw new Error(`OVE_CHROMIUM_EXECUTABLE points to ${explicit}, which does not exist.`);
+    if (!existsSync4(explicit)) throw new Error(`OVE_CHROMIUM_EXECUTABLE points to ${explicit}, which does not exist.`);
     return chromium.launch({ headless: true, executablePath: explicit, args: browserArgs });
   }
-  if (existsSync3(chromium.executablePath())) return chromium.launch({ headless: true, args: browserArgs });
+  if (existsSync4(chromium.executablePath())) return chromium.launch({ headless: true, args: browserArgs });
   for (const channel of ["chrome", "msedge"]) {
     try {
       return await chromium.launch({ headless: true, channel, args: browserArgs });
     } catch {
     }
   }
-  throw new Error(`No Chromium-based browser was found. ${browserInstallHint}`);
+  try {
+    await ensureChromium();
+    return await chromium.launch({ headless: true, args: browserArgs });
+  } catch (error) {
+    throw new Error(`No Chromium-based browser was found and auto-install failed: ${error.message}. ${browserInstallHint}`);
+  }
 }
 async function describeBrowser() {
   const browser = await launchBrowser();
   try {
-    return `${browser.browserType().name()} ${browser.version()}${process.env.OVE_CHROMIUM_EXECUTABLE ? ` (OVE_CHROMIUM_EXECUTABLE=${process.env.OVE_CHROMIUM_EXECUTABLE})` : existsSync3(chromium.executablePath()) ? " (Playwright Chromium)" : " (installed Chrome/Edge)"}`;
+    return `${browser.browserType().name()} ${browser.version()}${process.env.OVE_CHROMIUM_EXECUTABLE ? ` (OVE_CHROMIUM_EXECUTABLE=${process.env.OVE_CHROMIUM_EXECUTABLE})` : existsSync4(chromium.executablePath()) ? " (Playwright Chromium)" : " (installed Chrome/Edge)"}`;
   } finally {
     await browser.close();
   }
@@ -1966,7 +2151,7 @@ async function* renderFrames(renderer, from, to, options3 = {}) {
     await Promise.allSettled(pending);
   }
 }
-var scaledSize, runtime, sheetPage, allLayers, browserArgs, browserInstallHint, defaultConcurrency;
+var scaledSize, runtime, sheetPage, allLayers, browserArgs, browserInstallHint, ensureChromiumPromise, defaultConcurrency;
 var init_src7 = __esm({
   "packages/renderer/src/index.ts"() {
     "use strict";
@@ -1987,6 +2172,7 @@ for(let i=0;i<images.length;i++){const img=new Image();img.src=images[i];await i
     allLayers = (composition) => composition.scenes.flatMap((scene) => scene.layers);
     browserArgs = ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", ...(process.env.OVE_CHROMIUM_ARGS ?? "").split(/\s+/).filter(Boolean)];
     browserInstallHint = `Install one with "ove browser install" (Playwright's Chromium, about 150 MB), install Google Chrome, or set OVE_CHROMIUM_EXECUTABLE to a Chromium-based browser.`;
+    ensureChromiumPromise = null;
     defaultConcurrency = () => Math.max(1, Math.min(4, Math.floor(availableParallelism() / 2)));
   }
 });
@@ -1995,13 +2181,13 @@ for(let i=0;i<images.length;i++){const img=new Image();img.src=images[i];await i
 import { stat as stat4 } from "node:fs/promises";
 import { spawn as spawn3 } from "node:child_process";
 import { mkdtemp, rm as rm3, mkdir as mkdir3, rename as rename2 } from "node:fs/promises";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { createHash as createHash3 } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function sfxFile(name2) {
-  const file2 = join7(sfxDir(), `${name2}-${createHash3("sha256").update(JSON.stringify(sfxArgs(name2, ""))).digest("hex").slice(0, 12)}.wav`);
-  if (existsSync4(file2)) {
+  const file2 = join8(sfxDir(), `${name2}-${createHash3("sha256").update(JSON.stringify(sfxArgs(name2, ""))).digest("hex").slice(0, 12)}.wav`);
+  if (existsSync5(file2)) {
     void touchCacheEntry(file2);
     return Promise.resolve(file2);
   }
@@ -2049,7 +2235,7 @@ async function planAudio(composition, baseDir, probe2 = hasAudioStream) {
 }
 async function measureMix(mix) {
   if (!mix.clips.length) return void 0;
-  const dir = await mkdtemp(join7(tmpdir2(), "ove-loudness-")), wav = join7(dir, "mix.wav");
+  const dir = await mkdtemp(join8(tmpdir2(), "ove-loudness-")), wav = join8(dir, "mix.wav");
   try {
     const args = audioMixArgs(mix, ["-c:a", "pcm_s16le"]), video = args.indexOf("0:v");
     if (video > 0) args.splice(video - 1, 2);
@@ -2274,7 +2460,7 @@ var init_review = __esm({
 // packages/core/src/distributed.ts
 import { mkdtemp as mkdtemp2, rm as rm4, writeFile as writeFile4, mkdir as mkdir4 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join8, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join9, resolve as resolve2 } from "node:path";
 import { timingSafeEqual } from "node:crypto";
 function planChunks(first, last, chunkSize) {
   if (!Number.isInteger(chunkSize) || chunkSize < 1) throw new Error("Chunk size must be a positive whole number of frames");
@@ -2298,7 +2484,7 @@ async function renderDistributed(composition, options3) {
   if (!Number.isInteger(first) || !Number.isInteger(last) || first < 0 || last < first || last >= composition.durationFrames) throw new Error(`Frame range must be within 0\u2013${composition.durationFrames - 1}`);
   const chunkSettings = { format, codec: settings.codec, transparent: settings.transparent, preset: options3.preset ?? defaultPreset, crf: settings.crf, bitrate: settings.bitrate, scale: settings.scale };
   const jobs = planChunks(first, last, options3.chunkSize ?? Math.max(30, Math.ceil((last - first + 1) / (options3.workers.length * 2)))), total = last - first + 1, retries = options3.retries ?? 2;
-  const work = await mkdtemp2(join8(tmpdir3(), "ove-chunks-")), segments = new Array(jobs.length), attempts = /* @__PURE__ */ new Map();
+  const work = await mkdtemp2(join9(tmpdir3(), "ove-chunks-")), segments = new Array(jobs.length), attempts = /* @__PURE__ */ new Map();
   const abort = new AbortController();
   const onOuterAbort = () => abort.abort(options3.signal?.reason);
   options3.signal?.addEventListener("abort", onOuterAbort);
@@ -2312,7 +2498,7 @@ async function renderDistributed(composition, options3) {
         const job = queue.shift();
         try {
           const bytes = await worker.renderChunk(target, job, chunkSettings, abort.signal);
-          const file2 = join8(work, `chunk-${String(job.index).padStart(5, "0")}.${format}`);
+          const file2 = join9(work, `chunk-${String(job.index).padStart(5, "0")}.${format}`);
           await writeFile4(file2, bytes);
           segments[job.index] = file2;
           failures = 0;
@@ -2345,7 +2531,7 @@ async function renderDistributed(composition, options3) {
     if (segments.some((s) => !s)) throw new Error("Some chunks were not rendered");
     await mkdir4(dirname2(output), { recursive: true });
     const audio = await masterAudio(target, baseDir).then((mix) => mix && { ...mix, durationSeconds: total / composition.fps, offsetSeconds: first / composition.fps });
-    await concatSegments(segments, join8(work, "segments.txt"), output, audio, { format, audioBitrate: settings.audioBitrate });
+    await concatSegments(segments, join9(work, "segments.txt"), output, audio, { format, audioBitrate: settings.audioBitrate });
     return { output, format, frames: total, durationSeconds: Number(await probe(output)) || total / composition.fps };
   } finally {
     options3.signal?.removeEventListener("abort", onOuterAbort);
@@ -2377,13 +2563,14 @@ var init_distributed = __esm({
 
 // packages/core/src/index.ts
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname3, extname as extname3, join as join9, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, extname as extname3, join as join10, resolve as resolve3 } from "node:path";
 function checkRange(composition, range) {
   const [first, last] = range ?? [0, composition.durationFrames - 1];
   if (!Number.isInteger(first) || !Number.isInteger(last) || first < 0 || last < first || last >= composition.durationFrames) throw new Error(`Frame range must be whole frames within 0\u2013${composition.durationFrames - 1}, first \u2264 last; got ${first}\u2013${last}`);
   return [first, last];
 }
 async function renderMedia(composition, options3) {
+  await ensureFfmpeg();
   const baseDir = options3.baseDir ?? process.cwd(), output = resolve3(options3.output);
   const format = options3.format ?? formatForOutput(output, composition.export.format);
   const settings = exportSchema.parse({ ...composition.export, ...Object.fromEntries(Object.entries({ crf: options3.crf, bitrate: options3.bitrate, audioBitrate: options3.audioBitrate, scale: options3.scale, loudness: options3.loudness }).filter(([, v]) => v !== void 0)), format, codec: options3.codec ?? (format === "mp4" ? composition.export.codec : "h264"), transparent: options3.transparent ?? composition.export.transparent });
@@ -2402,7 +2589,7 @@ async function renderMedia(composition, options3) {
     for await (const png of renderFrames(renderer, first, last + 1)) {
       throwIfAborted();
       if (encoder) await encoder.write(png);
-      else await writeFile5(join9(output, `frame-${String(frame).padStart(6, "0")}.png`), png);
+      else await writeFile5(join10(output, `frame-${String(frame).padStart(6, "0")}.png`), png);
       frame++;
       options3.onProgress?.({ frame: frame - 1, rendered: frame - first, total });
     }
@@ -2457,11 +2644,11 @@ var init_src8 = __esm({
 
 // packages/cli/src/blocks.ts
 import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function listJson(dir, kind) {
   const names = (await readdir3(dir)).filter((name2) => name2.endsWith(".json")).sort();
-  const items = await Promise.all(names.map((name2) => readJson(join10(dir, name2))));
+  const items = await Promise.all(names.map((name2) => readJson(join11(dir, name2))));
   for (const item of items) if (!idPattern.test(item.id)) throw new Error(`${kind} ids use lowercase letters, digits and dashes, not "${item.id}"`);
   return items;
 }
@@ -4012,7 +4199,7 @@ var init_compose = __esm({
 
 // packages/ai/src/history.ts
 import { copyFile, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import { basename, dirname as dirname4, join as join11, resolve as resolve4 } from "node:path";
+import { basename, dirname as dirname4, join as join12, resolve as resolve4 } from "node:path";
 async function listRevisions(compositionFile) {
   const text = await readText(indexFile(compositionFile));
   if (!text) return [];
@@ -4045,11 +4232,11 @@ async function saveRevision(compositionFile, meta) {
   const composition = JSON.parse(text.replace(/^/, ""));
   const list = await listRevisions(compositionFile);
   const last = list.at(-1);
-  const previous = last ? JSON.parse(await readText(join11(historyDir(compositionFile), last.file)) ?? "null") : void 0;
+  const previous = last ? JSON.parse(await readText(join12(historyDir(compositionFile), last.file)) ?? "null") : void 0;
   const n = (last?.n ?? 0) + 1;
   const revision = { n, file: `${pad(n)}.json`, at: (/* @__PURE__ */ new Date()).toISOString(), ...meta, frames: Number(composition.durationFrames) || 0, scenes: scenesOf(composition).length, changes: summarizeChange(previous, composition) };
   await mkdir6(historyDir(compositionFile), { recursive: true });
-  await writeFile6(join11(historyDir(compositionFile), revision.file), text);
+  await writeFile6(join12(historyDir(compositionFile), revision.file), text);
   await writeFile6(indexFile(compositionFile), JSON.stringify([...list, revision], null, 2) + "\n");
   return revision;
 }
@@ -4060,15 +4247,15 @@ async function ensureBaseline(compositionFile) {
 async function restoreRevision(compositionFile, n) {
   const found = (await listRevisions(compositionFile)).find((revision) => revision.n === n);
   if (!found) throw new Error(`There is no revision ${n}`);
-  await copyFile(join11(historyDir(compositionFile), found.file), resolve4(compositionFile));
+  await copyFile(join12(historyDir(compositionFile), found.file), resolve4(compositionFile));
   return saveRevision(compositionFile, { kind: "restore", label: `Restored revision ${n}`, restoredFrom: n });
 }
 var historyDir, indexFile, pad, readText, scenesOf, defaults;
 var init_history = __esm({
   "packages/ai/src/history.ts"() {
     "use strict";
-    historyDir = (compositionFile) => join11(dirname4(resolve4(compositionFile)), "history", basename(compositionFile).replace(/\.json$/i, ""));
-    indexFile = (compositionFile) => join11(historyDir(compositionFile), "index.json");
+    historyDir = (compositionFile) => join12(dirname4(resolve4(compositionFile)), "history", basename(compositionFile).replace(/\.json$/i, ""));
+    indexFile = (compositionFile) => join12(historyDir(compositionFile), "index.json");
     pad = (n) => String(n).padStart(4, "0");
     readText = (file2) => readFile7(file2, "utf8").then((text) => text, () => void 0);
     scenesOf = (composition) => Array.isArray(composition?.scenes) ? composition.scenes : [];
@@ -4243,6 +4430,13 @@ var init_template = __esm({
     };
     templatesFor = (templates, size) => templates.filter((template) => sameShape(template, size));
     systemText = `You fill in ready-made video templates. Reply with JSON only: {"template": "<id>", "theme": "<theme id, only for templates that take a theme>", "values": {"<variable>": <value>, ...}}.
+Choose the template that best matches the story structure and topic of the brief (stories and stats -> story-tall; features and cards -> showcase-tall; tips and steps -> social-reel).
+For templates that take a theme, ALWAYS choose the theme that best matches the mood, industry, and visual tone of the brief:
+- "midnight": modern tech, SaaS, B2B, cloud, finance
+- "neon": gaming, nightlife, social apps, crypto, cutting-edge AI
+- "espresso": artisan craft, food & beverage, coffee, lifestyle, podcasts, warmth
+- "paper": clean editorial, education, publishing, thought leadership, light minimalist
+- "signal": high-impact, fitness, sports, breaking news, urgency
 Picture variables (image, image2\u2026) take the id of one supplied picture, or "" for none; never invent ids. Examples only show the length and kind of text wanted: never reuse their wording (including labels like INTRODUCING); use the brief's own names, numbers and details, and prefer a concrete line over a generic one such as "Ready to start?". Rules: write the words viewers will read, never a description of the video; do not invent dates, prices or claims that are not in the brief; use only the listed variable names; write real copy for the brief, about as long as each example (never much longer); "color" values are hex like "#f4d58d"; list values are arrays of objects with the listed fields.
 If no template suits the brief, reply {"template": "none"}.`;
   }
@@ -4273,7 +4467,7 @@ var init_captions2 = __esm({
 
 // packages/ai/src/narrate.ts
 import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, join as join12, resolve as resolve6 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join13, resolve as resolve6 } from "node:path";
 function cleanScript(text) {
   return text.replace(/^\s*(narration|narrator|voiceover|vo)\s*:\s*/gim, "").replace(/^#{1,6}\s+/gm, "").replace(/\*\*|__|`/g, "").replace(/^\s*[-*]\s+/gm, "").replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4338,7 +4532,7 @@ async function narrate(provider, options3) {
   await mkdir8(options3.outDir, { recursive: true });
   options3.onProgress?.("Synthesising speech\u2026");
   const audio = await provider.speak(text, { voice: options3.voice, signal: options3.signal });
-  const audioFile = join12(options3.outDir, `narration.${audio.extension}`);
+  const audioFile = join13(options3.outDir, `narration.${audio.extension}`);
   await writeFile8(audioFile, audio.data);
   options3.onProgress?.("Transcribing for word timings\u2026");
   let transcript = { text: "", words: [], cues: [] };
@@ -4358,7 +4552,7 @@ async function narrate(provider, options3) {
   let captionsFile;
   const hasCaptions = options3.captions !== false && (transcript.words.length > 0 || transcript.cues.length > 0);
   if (hasCaptions) {
-    captionsFile = join12(options3.outDir, "narration.captions.json");
+    captionsFile = join13(options3.outDir, "narration.captions.json");
     await writeFile8(captionsFile, JSON.stringify(transcript.words.length ? { words: transcript.words } : { cues: transcript.cues }, null, 2) + "\n");
   }
   let composition;
@@ -4389,7 +4583,7 @@ async function captionAudio(provider, options3) {
   }
   const outDir = options3.outDir ?? dirname6(audioFile);
   await mkdir8(outDir, { recursive: true });
-  const captionsFile = join12(outDir, `${basename2(audioFile).replace(/\.[^.]+$/, "")}.captions.json`);
+  const captionsFile = join13(outDir, `${basename2(audioFile).replace(/\.[^.]+$/, "")}.captions.json`);
   await writeFile8(captionsFile, JSON.stringify(transcript.words.length ? { words: transcript.words } : { cues: transcript.cues }, null, 2) + "\n");
   let composition;
   if (options3.composition) {
@@ -4418,7 +4612,7 @@ var init_narrate = __esm({
 
 // packages/ai/src/voiceover.ts
 import { mkdir as mkdir9, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { dirname as dirname7, join as join14 } from "node:path";
 function mergeNarration(source, resolved) {
   const live = resolved.scenes.filter((scene) => scene.id !== "narration" && scene.id !== "captions"), extra = resolved.scenes.filter((scene) => scene.id === "narration" || scene.id === "captions");
   if (!Array.isArray(source.scenes) || source.scenes.length !== live.length || source.scenes.some((scene, i) => scene?.id !== live[i].id)) return void 0;
@@ -4517,7 +4711,7 @@ async function narrateScenes(provider, composition, options3) {
   next.durationFrames = Math.max(...live.map((scene) => Number(scene.startFrame) + Number(scene.durationFrames)));
   const wav = concatWav(timeline);
   await mkdir9(options3.outDir, { recursive: true });
-  const audioFile = join13(options3.outDir, "narration.wav");
+  const audioFile = join14(options3.outDir, "narration.wav");
   await writeFile9(audioFile, wav);
   let transcript = { text: "", words: [], cues: [] };
   if (provider.transcribe) {
@@ -4526,7 +4720,7 @@ async function narrateScenes(provider, composition, options3) {
   } else options3.onProgress?.("This provider cannot transcribe, so captions are skipped.");
   let captionsFile;
   if (transcript.words.length || transcript.cues.length) {
-    captionsFile = join13(options3.outDir, "narration.captions.json");
+    captionsFile = join14(options3.outDir, "narration.captions.json");
     await writeFile9(captionsFile, JSON.stringify(transcript.words.length ? { words: transcript.words } : { cues: transcript.cues }, null, 2) + "\n");
   }
   const baseDir = options3.compositionPath ? dirname7(options3.compositionPath) : options3.outDir;
@@ -4553,7 +4747,7 @@ var init_voiceover = __esm({
 
 // packages/ai/src/edit.ts
 import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename3, join as join14, resolve as resolve7 } from "node:path";
+import { basename as basename3, join as join15, resolve as resolve7 } from "node:path";
 function planCuts(transcript, options3 = {}) {
   const maxSilence = options3.maxSilence ?? 0.5, padding = options3.padding ?? 0.3;
   const words = transcript.words.filter((w) => Number.isFinite(w.start) && Number.isFinite(w.end) && w.end >= w.start).sort((a, b) => a.start - b.start);
@@ -4632,8 +4826,8 @@ async function editVideo(provider, options3) {
   options3.onProgress?.("Reading the clip\u2026");
   if (await hasAudioStream(clip2) === false) throw new Error(`${basename3(clip2)} has no audio track; there is nothing to transcribe`);
   const sourceSeconds = Number(await probe(clip2)) || 0;
-  await mkdir10(join14(outDir, "assets"), { recursive: true });
-  const audioFile = join14(outDir, "assets", "source-audio.m4a");
+  await mkdir10(join15(outDir, "assets"), { recursive: true });
+  const audioFile = join15(outDir, "assets", "source-audio.m4a");
   options3.onProgress?.("Extracting the audio\u2026");
   await extractAudio(clip2, audioFile);
   options3.onProgress?.("Transcribing\u2026");
@@ -4643,7 +4837,7 @@ async function editVideo(provider, options3) {
   const plan = planCuts(transcript, { maxSilence: options3.maxSilence, keepFillers: options3.keepFillers, padding: options3.padding });
   let captionsFile;
   if (options3.captions !== false) {
-    captionsFile = join14(outDir, "assets", "edit-captions.json");
+    captionsFile = join15(outDir, "assets", "edit-captions.json");
     await writeFile10(captionsFile, JSON.stringify({ words: plan.words }, null, 2) + "\n");
   }
   const composition = editComposition({
@@ -4682,7 +4876,7 @@ var init_edit = __esm({
 
 // packages/ai/src/shorts.ts
 import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile11 } from "node:fs/promises";
-import { basename as basename4, join as join15, resolve as resolve8 } from "node:path";
+import { basename as basename4, join as join16, resolve as resolve8 } from "node:path";
 function sentencesOf(words, maxSilence) {
   const sentences = [];
   let current = [];
@@ -4741,7 +4935,7 @@ async function shortsFrom(provider, options3) {
   if (await hasAudioStream(clip2) === false) throw new Error(`${basename4(clip2)} has no audio track; there is nothing to transcribe`);
   const sourceSeconds = Number(await probe(clip2)) || 0;
   await mkdir11(outDir, { recursive: true });
-  const audioFile = join15(outDir, "source-audio.m4a");
+  const audioFile = join16(outDir, "source-audio.m4a");
   options3.onProgress?.("Extracting the audio\u2026");
   await extractAudio(clip2, audioFile);
   options3.onProgress?.("Transcribing\u2026");
@@ -4754,12 +4948,12 @@ async function shortsFrom(provider, options3) {
   for (const [i, candidate] of candidates.entries()) {
     const name2 = `short-${String(i + 1).padStart(2, "0")}`;
     options3.onProgress?.(`Writing ${name2}\u2026`);
-    const dir = join15(outDir, name2);
+    const dir = join16(outDir, name2);
     const plan = shortsCandidatePlan(candidate, options3.cut !== false, options3.maxSilence ?? 0.5, options3.keepFillers ?? false);
     let captionsFile;
     if (options3.captions !== false) {
-      captionsFile = join15(dir, "assets", "captions.json");
-      await mkdir11(join15(dir, "assets"), { recursive: true });
+      captionsFile = join16(dir, "assets", "captions.json");
+      await mkdir11(join16(dir, "assets"), { recursive: true });
       await writeFile11(captionsFile, JSON.stringify({ words: plan.words }, null, 2) + "\n");
     }
     const composition = editComposition({
@@ -5161,7 +5355,7 @@ var init_brand_scraper = __esm({
 
 // packages/ai/src/agent.ts
 import { mkdir as mkdir13, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join16, resolve as resolve11 } from "node:path";
+import { join as join17, resolve as resolve11 } from "node:path";
 function detectReelFormat(brief) {
   return /\b(reel|short|9:16|viral|tiktok|instagram|shorts|reels|vertical)\b/i.test(brief);
 }
@@ -5244,7 +5438,7 @@ async function runVideoAgent(provider, options3, buildHelper) {
   const fps = options3.fps ?? 30;
   const durationSeconds = options3.durationSeconds ?? 6;
   const durationFrames = Math.max(30, Math.round(durationSeconds * fps));
-  const dir = resolve11(options3.dir ?? join16(process.cwd(), `agent-video-${Date.now()}`));
+  const dir = resolve11(options3.dir ?? join17(process.cwd(), `agent-video-${Date.now()}`));
   options3.onProgress?.(`\u{1F3AC} Video Director Agent initializing in ${dir}\u2026`);
   await mkdir13(dir, { recursive: true });
   const messages2 = [
@@ -5261,9 +5455,9 @@ Make it visually stunning, cinematic, and punchy. Write the complete video.tsx f
   let attempts = 0;
   let currentTask = "compose";
   const maxAttempts = 3;
-  const videoPath = join16(dir, "video.tsx");
-  const compositionPath = join16(dir, "composition.json");
-  const bundlePath = join16(dir, "video.bundle.js");
+  const videoPath = join17(dir, "video.tsx");
+  const compositionPath = join17(dir, "composition.json");
+  const bundlePath = join17(dir, "video.bundle.js");
   while (attempts < maxAttempts) {
     attempts++;
     options3.onProgress?.(`\u26A1 Generating React motion code with ${provider.id} (${currentTask}, attempt ${attempts}/${maxAttempts})\u2026`);
@@ -5783,17 +5977,31 @@ var init_plan = __esm({
     init_registry();
     paths = ["template", "json", "react"];
     allowedPaths = (options3) => (options3.paths ?? paths).filter((path) => path !== "react" || options3.allowReact);
-    systemText2 = (options3) => `You are the production planner for Open Video Engine. Decide how the brief below should be produced, before anything is generated.
+    systemText2 = (options3) => `You are the creative production planner for Open Video Engine. Decide how the brief below should be produced, before anything is generated.
 Reply with ONE JSON object and nothing else:
 {
   "path": "template" | "json" | "react",
-  "template": "<template id>",            // only with "template": the one template that suits the brief
+  "template": "<template id>",            // only with "template": the one template that best suits the brief's structure and topic
   "theme": "<theme id>",                  // optional, only with a template that takes a theme
   "idea": "<what the video says, in one line>",
   "beats": [{ "name": "Hook", "onScreen": "what is on screen, concretely", "seconds": 3, "motion": "how it moves in" }],
   "reasons": ["why this path suits this brief"]
 }
-Templates are the primary path: choose "template" whenever one listed template suits the brief's kind and aspect ratio, even when its length differs \u2014 a template's length is its own, and a length difference is not a reason to leave the template route. Choose "json" only when no template fits the kind and aspect: a bespoke composition with scene layers, camera moves and kinetic type. Choose "react" only when allowed: it writes React code for bespoke high-end motion graphics. Every beat needs a concrete picture, not a mood.
+Templates provide proven layouts, but pick the template that specifically fits the brief's narrative style:
+- Testimonials, customer stories, quotes, metrics, or personal founder stories: choose "story-tall" or "quote-card".
+- Multi-feature tours, app UI cards, feature lists, and product showcases: choose "showcase-tall", "product-wide" or "product-card".
+- Quick tips, 3-step processes, how-to guides, and numbered reels: choose "social-reel".
+- Company keynotes, presentations, and product launch films: choose "keynote-wide", "launch-wide" or "case-study".
+- Choose "json" when the brief requires a bespoke kinetic video with custom motion graphics, camera moves, and scene architecture.
+- Choose "react" only when allowed: it writes React code for bespoke high-end motion graphics.
+
+Themes: For templates that take a theme, ALWAYS choose the theme matching the tone and brand of the brief:
+- "midnight": modern tech, SaaS, B2B, cloud, finance (deep slate navy, sky blue).
+- "neon": gaming, nightlife, social apps, crypto, cutting-edge AI (dark violet, hot magenta, electric lime).
+- "espresso": artisan craft, food & beverage, coffee, lifestyle, podcasts, warmth (dark espresso, amber gold).
+- "paper": clean editorial, education, publishing, thought leadership (clean light aesthetic, deep ink).
+- "signal": high-impact, fitness, sports, breaking news, urgency (bold monochrome with alert red).
+Every beat needs a concrete picture, not a mood.
 Reply with "path" set to one of: ${allowedPaths(options3).join(" | ")}.
 Available capabilities:
 ${describeCapabilities(options3.registry, options3)}`;
@@ -5840,7 +6048,7 @@ __export(templates_exports, {
   templatesDir: () => templatesDir
 });
 import { readdir as readdir5, readFile as readFile12 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function assertTemplateId(id2) {
   if (!idPattern2.test(id2)) throw new Error(`Template ids use lowercase letters, digits and dashes, not "${id2}"`);
@@ -5882,8 +6090,8 @@ function infoFrom(id2, meta, composition) {
 }
 async function readTemplate(id2, root = templatesDir) {
   const safe = assertTemplateId(id2);
-  const dir = join17(root, safe);
-  const [meta, composition] = await Promise.all([readJson2(join17(dir, "template.json")), readJson2(join17(dir, "composition.json"))]);
+  const dir = join18(root, safe);
+  const [meta, composition] = await Promise.all([readJson2(join18(dir, "template.json")), readJson2(join18(dir, "composition.json"))]);
   return { dir, info: infoFrom(safe, meta, composition), composition };
 }
 async function listTemplates(root = templatesDir) {
@@ -5928,7 +6136,7 @@ async function cliRegistry() {
 async function composeSmart(provider, options3, mode = {}) {
   const needsFull = mode.full || !!options3.fields?.length || (options3.assets ?? []).some((asset) => asset.type !== "image");
   let plan;
-  if (!mode.noPlan) {
+  if (!mode.noPlan && !mode.full && !mode.template) {
     const registry = mode.registry ?? await cliRegistry();
     try {
       plan = await planBuild(provider, { ...options3, registry, maxAttempts: Math.min(options3.maxAttempts ?? 2, 2) });
@@ -5936,13 +6144,16 @@ async function composeSmart(provider, options3, mode = {}) {
       options3.onProgress?.(`Planning skipped (${error.message.split("\n")[0]}); using the built-in routing.`);
     }
   }
-  const templatePath = plan ? plan.path === "template" : !needsFull;
+  const templatePath = (plan ? plan.path === "template" : !needsFull) || Boolean(mode.template);
   if (templatePath && !needsFull) {
     try {
       const choices = await templateChoices();
-      const picked = plan?.template ? choices.filter((choice) => choice.id === plan.template) : choices;
-      const themes = plan?.theme ? (await listThemes()).filter((theme) => theme.id === plan.theme) : await listThemes();
-      const filled2 = await composeFromTemplate(provider, picked.length ? picked : choices, { ...options3, themes });
+      const targetTemplateId = mode.template ?? plan?.template;
+      const picked = targetTemplateId ? choices.filter((choice) => choice.id === targetTemplateId) : choices;
+      const targetThemeId = mode.theme ?? plan?.theme;
+      const allThemes = await listThemes();
+      const themes = targetThemeId ? allThemes.filter((theme) => theme.id === targetThemeId) : allThemes;
+      const filled2 = await composeFromTemplate(provider, picked.length ? picked : choices, { ...options3, themes: themes.length ? themes : allThemes });
       if (filled2) {
         const wanted = options3.durationSeconds;
         const current = filled2.composition.durationFrames / filled2.composition.fps;
@@ -6348,7 +6559,7 @@ var init_bundle = __esm({
 import { createServer } from "node:http";
 import { watch } from "node:fs";
 import { readFile as readFile14, writeFile as writeFile15 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname11, extname as extname4, isAbsolute as isAbsolute4, join as join19, relative as relative3, resolve as resolve13 } from "node:path";
+import { basename as basename6, dirname as dirname11, extname as extname4, isAbsolute as isAbsolute4, join as join20, relative as relative3, resolve as resolve13 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 async function startDevServer(file2, options3 = {}) {
   const path = resolve13(file2), baseDir = dirname11(path), concurrency = options3.concurrency ?? defaultConcurrency();
@@ -6492,7 +6703,7 @@ data: ${JSON.stringify({ version, error: error ?? null })}
       if (req.method === "GET" && url.pathname.startsWith("/fonts/")) {
         const face = builtinFontFaces.find((f) => `/fonts/${f.file}` === url.pathname);
         if (!face) return send2(res, 404, "text/plain", "Not found");
-        return send2(res, 200, "font/woff2", await readFile14(join19(builtinFontDir(), face.file)));
+        return send2(res, 200, "font/woff2", await readFile14(join20(builtinFontDir(), face.file)));
       }
       if (req.method === "GET" && url.pathname.startsWith("/media/")) {
         const target = resolve13(baseDir, decodeURIComponent(url.pathname.slice("/media/".length)));
@@ -6716,7 +6927,7 @@ var init_http = __esm({
 
 // packages/storage/src/index.ts
 import { cp as cp2, mkdir as mkdir15, readdir as readdir7, readFile as readFile16, rename as rename3, stat as stat6, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname12, extname as extname6, isAbsolute as isAbsolute5, join as join21, relative as relativePath, resolve as resolve14, sep } from "node:path";
+import { dirname as dirname12, extname as extname6, isAbsolute as isAbsolute5, join as join22, relative as relativePath, resolve as resolve14, sep } from "node:path";
 function within(root, target) {
   const rel = relativePath(resolve14(root), resolve14(target));
   return rel !== "" && rel !== ".." && !rel.startsWith(".." + sep) && !isAbsolute5(rel);
@@ -6740,7 +6951,7 @@ var init_src10 = __esm({
       tenantRoot(who) {
         if (who.tenantId === LOCAL_PRINCIPAL.tenantId) return this.root;
         if (!tenantPattern.test(who.tenantId)) throw new Error("That account name is not valid");
-        return join21(this.root, "_tenants", who.tenantId);
+        return join22(this.root, "_tenants", who.tenantId);
       }
       /** A path inside the principal's space: relative values resolve from `base` (default: the space itself), absolute ones must already be inside. */
       resolve(who, value, label = "path", base) {
@@ -6757,7 +6968,7 @@ var init_src10 = __esm({
         return this.resolve(who, id2, "project");
       }
       file(who, id2) {
-        return join21(this.projectDir(who, id2), "composition.json");
+        return join22(this.projectDir(who, id2), "composition.json");
       }
       async ids(who) {
         const entries2 = await readdir7(this.tenantRoot(who), { withFileTypes: true }).catch(() => []);
@@ -6772,7 +6983,7 @@ var init_src10 = __esm({
         const taken = new Set((await readdir7(space).catch(() => [])).map(String)), base = slugify(name2);
         let id2 = base, n = 1;
         while (taken.has(id2)) id2 = `${base}-${++n}`;
-        await mkdir15(join21(space, id2, "assets"), { recursive: true });
+        await mkdir15(join22(space, id2, "assets"), { recursive: true });
         return id2;
       }
       async readRaw(who, id2) {
@@ -6794,37 +7005,37 @@ var init_src10 = __esm({
         return copy;
       }
       async trash(who, id2) {
-        const dir = this.projectDir(who, id2), trash = join21(this.tenantRoot(who), ".trash");
+        const dir = this.projectDir(who, id2), trash = join22(this.tenantRoot(who), ".trash");
         await mkdir15(trash, { recursive: true });
-        await rename3(dir, join21(trash, `${id2}-${Date.now()}`));
+        await rename3(dir, join22(trash, `${id2}-${Date.now()}`));
       }
       async assets(who, id2) {
-        const folder = join21(this.projectDir(who, id2), "assets"), out = [];
+        const folder = join22(this.projectDir(who, id2), "assets"), out = [];
         for (const name2 of await readdir7(folder).catch(() => [])) {
           const kind = assetKinds[extname6(name2).toLowerCase()];
           if (!kind) continue;
-          out.push({ name: name2, path: `assets/${name2}`, kind, bytes: (await stat6(join21(folder, name2))).size });
+          out.push({ name: name2, path: `assets/${name2}`, kind, bytes: (await stat6(join22(folder, name2))).size });
         }
         return out;
       }
       async putAsset(who, id2, name2, bytes) {
         const clean = name2.split(/[\\/]/).pop().replace(/[^A-Za-z0-9._-]+/g, "-");
         if (!assetKinds[extname6(clean).toLowerCase()]) throw new Error(`Pictures, video and audio only (${Object.keys(assetKinds).join(" ")})`);
-        const folder = join21(this.projectDir(who, id2), "assets");
+        const folder = join22(this.projectDir(who, id2), "assets");
         await mkdir15(folder, { recursive: true });
         const taken = new Set(await readdir7(folder).catch(() => []));
         let final = clean;
         for (let n = 2; taken.has(final); n++) final = clean.replace(/(\.[^.]*)?$/, `-${n}$1`);
-        await writeFile16(join21(folder, final), bytes);
+        await writeFile16(join22(folder, final), bytes);
         return this.assets(who, id2);
       }
       async thumb(who, id2) {
-        const cache = join21(this.projectDir(who, id2), ".studio", "thumb.png");
+        const cache = join22(this.projectDir(who, id2), ".studio", "thumb.png");
         const [source, cached2] = await Promise.all([stat6(this.file(who, id2)), stat6(cache).catch(() => void 0)]);
         return cached2 && cached2.mtimeMs >= source.mtimeMs ? readFile16(cache) : void 0;
       }
       async putThumb(who, id2, png) {
-        const cache = join21(this.projectDir(who, id2), ".studio", "thumb.png");
+        const cache = join22(this.projectDir(who, id2), ".studio", "thumb.png");
         await mkdir15(dirname12(cache), { recursive: true });
         await writeFile16(cache, png);
       }
@@ -6832,7 +7043,7 @@ var init_src10 = __esm({
         const walk = async (dir) => {
           let total = 0;
           for (const entry of await readdir7(dir, { withFileTypes: true }).catch(() => [])) {
-            const path = join21(dir, entry.name);
+            const path = join22(dir, entry.name);
             total += entry.isDirectory() ? entry.name === "_tenants" ? 0 : await walk(path) : (await stat6(path).catch(() => ({ size: 0 }))).size;
           }
           return total;
@@ -7001,7 +7212,9 @@ function createHandlers(env) {
         maxAttempts: integerIn(input.maxAttempts, 3, "maxAttempts", 1, 10),
         onProgress: (message2) => progress(message2)
       };
-      const result = await capabilities.composeSmart(ai, options3, { full });
+      const theme = typeof input.theme === "string" && input.theme.trim() ? input.theme.trim() : void 0;
+      const template = typeof input.template === "string" && input.template.trim() ? input.template.trim() : void 0;
+      const result = await capabilities.composeSmart(ai, options3, { full, theme, template });
       let composition = result.composition;
       let narration;
       if (options3.narration) {
@@ -7504,7 +7717,7 @@ var init_src11 = __esm({
 });
 
 // services/api/src/routes/jobs.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { readFile as readFile20 } from "node:fs/promises";
 function jobsRoutes() {
   const start = async (c, kind) => {
@@ -7551,7 +7764,7 @@ ${user}` });
     { method: "GET", path: "/api/still", handle: async (c) => {
       if (c.deps.mode !== "local") return c.json(404, { error: "Not found" });
       const { store } = c.deps, id2 = (c.url.searchParams.get("file") ?? "").split("/")[0] ?? "";
-      const baseDir = (await store.workdir(c.who, id2)).dir, raw = JSON.parse((await readFile20(join22(baseDir, "composition.json"), "utf8")).replace(/^/, ""));
+      const baseDir = (await store.workdir(c.who, id2)).dir, raw = JSON.parse((await readFile20(join23(baseDir, "composition.json"), "utf8")).replace(/^/, ""));
       const composition = await attachCaptions(loadComposition(raw), baseDir), requested = c.url.searchParams.get("frame");
       const frame = requested === null ? Math.floor(composition.durationFrames / 2) : integerIn(requested, 0, "frame", 0, Math.max(0, composition.durationFrames - 1));
       c.send(200, "image/png", await renderStill(composition, { frame, baseDir }));
@@ -9379,7 +9592,7 @@ __export(ai_studio_exports, {
   within: () => within
 });
 import { mkdir as mkdir18, readFile as readFile21 } from "node:fs/promises";
-import { join as join23, resolve as resolve19 } from "node:path";
+import { join as join24, resolve as resolve19 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function jobEnvFor(store, requireProvider, providerInfo, local) {
   return (who) => ({
@@ -9469,7 +9682,7 @@ var init_ai_studio = __esm({
       },
       async font(path) {
         const face = builtinFontFaces.find((f) => `/fonts/${f.file}` === path);
-        return face ? readFile21(join23(builtinFontDir(), face.file)) : void 0;
+        return face ? readFile21(join24(builtinFontDir(), face.file)) : void 0;
       }
     };
     studioApp = { dir: fileURLToPath8(new URL("../studio", import.meta.url)), fallbackPage: aiStudioPage };
@@ -9676,7 +9889,7 @@ __export(build_exports, {
   buildReact: () => buildReact,
   runBuild: () => runBuild
 });
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { mkdir as mkdir20, readFile as readFile22, writeFile as writeFile21 } from "node:fs/promises";
 import { basename as basename7, dirname as dirname17, resolve as resolve22 } from "node:path";
 import { fileURLToPath as fileURLToPath9, pathToFileURL } from "node:url";
@@ -9687,7 +9900,7 @@ async function buildReact(source, output) {
   } catch {
     throw new Error("Building a React video needs esbuild, react and react-dom in your project: npm install --save-dev esbuild react react-dom");
   }
-  const reactEntry = existsSync5(fileURLToPath9(new URL("./react.js", import.meta.url))) ? fileURLToPath9(new URL("./react.js", import.meta.url)) : fileURLToPath9(new URL("../../react/src/index.ts", import.meta.url));
+  const reactEntry = existsSync6(fileURLToPath9(new URL("./react.js", import.meta.url))) ? fileURLToPath9(new URL("./react.js", import.meta.url)) : fileURLToPath9(new URL("../../react/src/index.ts", import.meta.url));
   const common = {
     bundle: true,
     jsx: "automatic",
@@ -10882,7 +11095,7 @@ import { resolve as resolve26, dirname as dirname20 } from "node:path";
 init_src();
 init_templates();
 import { cp, mkdir as mkdir14, readdir as readdir6, readFile as readFile13, rm as rm5, writeFile as writeFile14 } from "node:fs/promises";
-import { basename as basename5, join as join18, relative as relative2, resolve as resolve12 } from "node:path";
+import { basename as basename5, join as join19, relative as relative2, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 var starterTemplate = fileURLToPath5(new URL("../templates/starter", import.meta.url));
 var skillDir = fileURLToPath5(new URL("../skills/ove", import.meta.url));
@@ -10896,24 +11109,24 @@ var isEmptyDir = async (dir) => {
   }
 };
 async function listFiles(dir) {
-  return (await readdir6(dir, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).map((e) => join18(e.parentPath, e.name));
+  return (await readdir6(dir, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).map((e) => join19(e.parentPath, e.name));
 }
 async function initProject(dir, options3 = {}) {
   const target = resolve12(dir);
   if (!options3.force && !await isEmptyDir(target)) throw new Error(`${target} is not empty; pass --force to write into it anyway`);
-  const source = options3.template ? join18(templatesDir, assertTemplateId(options3.template)) : starterTemplate;
+  const source = options3.template ? join19(templatesDir, assertTemplateId(options3.template)) : starterTemplate;
   await mkdir14(target, { recursive: true });
   await cp(source, target, { recursive: true, force: true });
-  await rm5(join18(target, "template.json"), { force: true });
-  const compositionPath = join18(target, "composition.json");
+  await rm5(join19(target, "template.json"), { force: true });
+  const compositionPath = join19(target, "composition.json");
   const name2 = basename5(target);
   const composition = JSON.parse((await readFile13(compositionPath, "utf8")).replace(/^\uFEFF/, ""));
   composition.id = name2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "video";
   composition.name = name2;
   loadComposition(composition);
   await writeFile14(compositionPath, JSON.stringify(composition, null, 2) + "\n");
-  await writeFile14(join18(target, "composition.schema.json"), JSON.stringify(compositionJsonSchema, null, 2) + "\n");
-  if (options3.skill !== false) await cp(skillsRoot, join18(target, ".claude", "skills"), { recursive: true, force: true });
+  await writeFile14(join19(target, "composition.schema.json"), JSON.stringify(compositionJsonSchema, null, 2) + "\n");
+  if (options3.skill !== false) await cp(skillsRoot, join19(target, ".claude", "skills"), { recursive: true, force: true });
   return (await listFiles(target)).map((file2) => relative2(target, file2)).sort();
 }
 
@@ -10993,7 +11206,7 @@ init_src8();
 import { createServer as createServer2 } from "node:http";
 import { mkdtemp as mkdtemp3, readFile as readFile15, rm as rm6 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { randomBytes } from "node:crypto";
 async function startWorker(options3 = {}) {
   const token = options3.token || randomBytes(18).toString("base64url"), host = options3.host ?? "127.0.0.1", log = options3.log ?? (() => {
@@ -11028,8 +11241,8 @@ async function startWorker(options3 = {}) {
       if (job.preset && !x264Presets.includes(job.preset)) return send2(res, 400, "text/plain", "Unknown preset");
       jobs++;
       const run4 = queue.then(async () => {
-        const dir = await mkdtemp3(join20(tmpdir4(), "ove-worker-"));
-        const output = join20(dir, `chunk.${format}`);
+        const dir = await mkdtemp3(join21(tmpdir4(), "ove-worker-"));
+        const output = join21(dir, `chunk.${format}`);
         const started = Date.now();
         try {
           await renderMedia(composition, { output, format, codec: job.codec, transparent: job.transparent, preset: job.preset, crf: job.crf, bitrate: job.bitrate, scale: job.scale, frameRange: range, concurrency, audio: false });
@@ -11063,8 +11276,7 @@ async function startWorker(options3 = {}) {
 }
 
 // packages/cli/src/index.ts
-import { spawnSync } from "node:child_process";
-import { createRequire as createRequire3 } from "node:module";
+import { spawnSync as spawnSync2 } from "node:child_process";
 try {
   process.loadEnvFile?.();
 } catch {
@@ -11264,7 +11476,7 @@ async function doctor() {
   } catch (error) {
     line(false, "FFmpeg", error.message);
   }
-  const probe2 = spawnSync(ffprobePath(), ["-version"], { encoding: "utf8" });
+  const probe2 = spawnSync2(ffprobePath(), ["-version"], { encoding: "utf8" });
   line(!probe2.error && probe2.status === 0, "ffprobe", probe2.error ? "not found (install FFmpeg, or set OVE_FFPROBE_PATH)" : (probe2.stdout.split(/\r?\n/)[0] ?? "").trim());
   try {
     line(true, "Browser", await describeBrowser());
@@ -11309,10 +11521,8 @@ Press Ctrl+C to stop.`);
     process.once("SIGTERM", stop);
   } else if (command === "browser") {
     if (file !== "install") throw new Error("Usage: ove browser install");
-    const cli = createRequire3(import.meta.url).resolve("playwright/cli");
     console.log("Downloading Playwright Chromium\u2026");
-    const result = spawnSync(process.execPath, [cli, "install", "chromium"], { stdio: "inherit" });
-    if (result.status !== 0) throw new Error("Chromium download failed; see the output above.");
+    await ensureChromium();
   } else if (command === "schema") {
     const json = JSON.stringify(compositionJsonSchema, null, 2) + "\n";
     const output = option4("--output");