motionrender 0.2.2 → 0.2.4

package/dist/index.js

@@ -1,6 +1,6 @@
 // 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";
 
 // packages/schema/src/index.ts
 import { z as z3 } from "zod";
@@ -865,7 +865,7 @@ var describeError = (error) => error instanceof z3.ZodError ? z3.prettifyError(e
 // 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";
 
 // packages/animation/src/index.ts
@@ -1222,11 +1222,143 @@ async function toDataUrl(source) {
 // packages/ffmpeg/src/index.ts
 import { spawn } from "node:child_process";
 import { once } from "node:events";
+import { join as join3 } from "node:path";
+
+// 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";
+var isWin = process.platform === "win32";
+var binDir = join2(homedir(), ".motionrender", "bin");
+var localFfmpegPath = join2(binDir, isWin ? "ffmpeg.exe" : "ffmpeg");
+var localFfprobePath = join2(binDir, isWin ? "ffprobe.exe" : "ffprobe");
+var checkedSystemFfmpeg = false;
+var systemFfmpegAvailable = false;
+var checkedSystemFfprobe = false;
+var systemFfprobeAvailable = false;
+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;
+}
+var getFfmpegPath = () => {
+  if (process.env.OVE_FFMPEG_PATH) return process.env.OVE_FFMPEG_PATH;
+  if (existsSync(localFfmpegPath)) return localFfmpegPath;
+  if (hasSystemFfmpeg()) return "ffmpeg";
+  return localFfmpegPath;
+};
+var getFfprobePath = () => {
+  if (process.env.OVE_FFPROBE_PATH) return process.env.OVE_FFPROBE_PATH;
+  if (existsSync(localFfprobePath)) return localFfprobePath;
+  if (hasSystemFfprobe()) return "ffprobe";
+  return localFfprobePath;
+};
+var RELEASE_TAG = "b6.1.1";
+var BASE_URL = `https://github.com/eugeneware/ffmpeg-static/releases/download/${RELEASE_TAG}`;
+function getPlatformArch() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === "win32") return { platform: "win32", arch: "x64" };
+  if (p === "darwin") return { platform: "darwin", arch: a === "arm64" ? "arm64" : "x64" };
+  if (p === "linux") return { platform: "linux", arch: a === "arm64" ? "arm64" : a === "arm" ? "arm" : "x64" };
+  return { platform: p, 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;
+  }
+}
+var ensureFfmpegPromise = null;
+async function ensureFfmpeg(options) {
+  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 = options?.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;
+  }
+}
+
+// packages/ffmpeg/src/index.ts
 var x264Presets = ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"];
 var defaultPreset = "veryfast";
-var ffmpegPath = () => process.env.OVE_FFMPEG_PATH || "ffmpeg";
-var ffprobePath = () => process.env.OVE_FFPROBE_PATH || "ffprobe";
+var ffmpegPath = () => getFfmpegPath();
+var ffprobePath = () => getFfprobePath();
 var 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.`);
 var num2 = (n) => {
   const text = n.toFixed(5).replace(/\.?0+$/, "");
@@ -1336,12 +1468,14 @@ function concatSegments(segments, listFile, output, audio, options = {}) {
   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", ...options.format === "mp4" || options.format === void 0 ? ["-movflags", "+faststart"] : [], output], "ignore").done);
 }
-function extractFrames(source, outDir, options) {
+async function extractFrames(source, outDir, options) {
+  await ensureFfmpeg();
   const { fps, maxWidth, maxHeight, durationSeconds, startSeconds } = options;
-  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;
 }
 var requiredEncoders = { mp4: ["libx264", "aac"], "mp4 (h265)": ["libx265"], webm: ["libvpx-vp9", "libopus"], mov: ["prores_ks", "pcm_s16le"], gif: ["gif"], "video layers": ["mjpeg"] };
-function checkFfmpeg() {
+async function checkFfmpeg() {
+  await ensureFfmpeg();
   return new Promise((resolve4, reject) => {
     const child = spawn(ffmpegPath(), ["-hide_banner", "-encoders"]);
     let out = "";
@@ -1358,7 +1492,8 @@ function checkFfmpeg() {
     });
   });
 }
-function hasAudioStream(path) {
+async function hasAudioStream(path) {
+  await ensureFfmpeg();
   return new Promise((resolve4, reject) => {
     const child = spawn(ffprobePath(), ["-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", path]);
     let out = "";
@@ -1367,7 +1502,8 @@ function hasAudioStream(path) {
     child.on("close", (c) => c === 0 ? resolve4(out.trim().length > 0) : reject(new Error(`ffprobe could not read ${path}`)));
   });
 }
-function probe(path) {
+async function probe(path) {
+  await ensureFfmpeg();
   return new Promise((resolve4, reject) => {
     const child = spawn(ffprobePath(), ["-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path]);
     let out = "";
@@ -1391,7 +1527,7 @@ 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), file = join3(mediaCache(), `${key}.json`);
+  const key = createHash("sha256").update(`${source}|${version}|v1`).digest("hex").slice(0, 32), file = join4(mediaCache(), `${key}.json`);
   const cached2 = await readFile2(file, "utf8").then(JSON.parse, () => void 0);
   if (cached2) {
     void touchCacheEntry(file);
@@ -1466,7 +1602,7 @@ async function prepareComposition(raw, values = {}, baseDir = process.cwd()) {
 
 // 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";
 
@@ -1558,18 +1694,18 @@ var prepareOperations = (operations, fps = 30) => {
 
 // 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";
-var videoFrameFile = (video, index) => join4(video.dir, `${String(Math.max(0, index - video.first) + 1).padStart(6, "0")}.jpg`);
+var videoFrameFile = (video, index) => join5(video.dir, `${String(Math.max(0, index - video.first) + 1).padStart(6, "0")}.jpg`);
 var videoCacheRoot = () => cacheDir("video");
 var complete = ".complete";
 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 };
   }
@@ -1577,9 +1713,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 });
@@ -1670,34 +1806,34 @@ async function createPagePool(open, discard, size, timeoutMs = defaultFrameTimeo
 }
 
 // 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;
-var 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")}` })));
+var 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 = () => {
   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));
 };
-var read = (name2) => readFileSync(join6(runtimeDir(), name2), "utf8");
+var read = (name2) => readFileSync(join7(runtimeDir(), name2), "utf8");
 var textLayoutSource = read("text-layout.js");
 var lottieFile = "lottie_light_canvas.min.js";
 var 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}`);
 };
 var lottieSource = readFileSync(lottiePath(), "utf8");
 var canvasRuntimeSource = `${textLayoutSource}
@@ -1716,25 +1852,68 @@ for(let i=0;i<images.length;i++){const img=new Image();img.src=images[i];await i
 var allLayers = (composition) => composition.scenes.flatMap((scene) => scene.layers);
 var browserArgs = ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", ...(process.env.OVE_CHROMIUM_ARGS ?? "").split(/\s+/).filter(Boolean)];
 var 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.`;
+var ensureChromiumPromise = null;
+async function ensureChromium(options) {
+  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 = options?.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: dirname4, join: join11 } = await import("node:path");
+    const { spawn: spawn4 } = await import("node:child_process");
+    const req = createRequire3(import.meta.url);
+    const cli = join11(dirname4(req.resolve("playwright/package.json")), "cli.js");
+    await new Promise((resolve4, reject) => {
+      const child = spawn4(process.execPath, [cli, "install", "chromium"], { stdio: "inherit" });
+      child.on("close", (code) => {
+        if (code === 0) resolve4();
+        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();
   }
@@ -1864,10 +2043,10 @@ async function* renderFrames(renderer, from, to, options = {}) {
 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";
 var runFfmpeg = (args) => new Promise((resolve4, reject) => {
   const child = spawn3(ffmpegPath(), args, { stdio: ["ignore", "ignore", "pipe"] });
   let err = "";
@@ -1878,8 +2057,8 @@ var runFfmpeg = (args) => new Promise((resolve4, reject) => {
 var sfxDir = () => cacheDir("sfx");
 var making = /* @__PURE__ */ new Map();
 function sfxFile(name2) {
-  const file = join7(sfxDir(), `${name2}-${createHash3("sha256").update(JSON.stringify(sfxArgs(name2, ""))).digest("hex").slice(0, 12)}.wav`);
-  if (existsSync4(file)) {
+  const file = join8(sfxDir(), `${name2}-${createHash3("sha256").update(JSON.stringify(sfxArgs(name2, ""))).digest("hex").slice(0, 12)}.wav`);
+  if (existsSync5(file)) {
     void touchCacheEntry(file);
     return Promise.resolve(file);
   }
@@ -1933,7 +2112,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);
@@ -2122,7 +2301,7 @@ async function reviewComposition(composition, options = {}) {
 // 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");
@@ -2146,7 +2325,7 @@ async function renderDistributed(composition, options) {
   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: options.preset ?? defaultPreset, crf: settings.crf, bitrate: settings.bitrate, scale: settings.scale };
   const jobs = planChunks(first, last, options.chunkSize ?? Math.max(30, Math.ceil((last - first + 1) / (options.workers.length * 2)))), total = last - first + 1, retries = options.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(options.signal?.reason);
   options.signal?.addEventListener("abort", onOuterAbort);
@@ -2160,7 +2339,7 @@ async function renderDistributed(composition, options) {
         const job = queue.shift();
         try {
           const bytes = await worker.renderChunk(target, job, chunkSettings, abort.signal);
-          const file = join8(work, `chunk-${String(job.index).padStart(5, "0")}.${format}`);
+          const file = join9(work, `chunk-${String(job.index).padStart(5, "0")}.${format}`);
           await writeFile4(file, bytes);
           segments[job.index] = file;
           failures = 0;
@@ -2193,7 +2372,7 @@ async function renderDistributed(composition, options) {
     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 {
     options.signal?.removeEventListener("abort", onOuterAbort);
@@ -2226,6 +2405,7 @@ function checkRange(composition, range) {
   return [first, last];
 }
 async function renderMedia(composition, options) {
+  await ensureFfmpeg();
   const baseDir = options.baseDir ?? process.cwd(), output = resolve3(options.output);
   const format = options.format ?? formatForOutput(output, composition.export.format);
   const settings = exportSchema.parse({ ...composition.export, ...Object.fromEntries(Object.entries({ crf: options.crf, bitrate: options.bitrate, audioBitrate: options.audioBitrate, scale: options.scale, loudness: options.loudness }).filter(([, v]) => v !== void 0)), format, codec: options.codec ?? (format === "mp4" ? composition.export.codec : "h264"), transparent: options.transparent ?? composition.export.transparent });
@@ -2244,7 +2424,7 @@ async function renderMedia(composition, options) {
     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++;
       options.onProgress?.({ frame: frame - 1, rendered: frame - first, total });
     }
@@ -2310,6 +2490,8 @@ export {
   dropFillerWords,
   duckSchema,
   easingSchema,
+  ensureChromium,
+  ensureFfmpeg,
   evaluateFrame,
   expandMattes,
   expandSceneGrades,

package/dist/types/packages/cli/src/templates.d.ts

@@ -56,6 +56,8 @@ export declare function composeSmart(provider: AiProvider, options: ComposeOptio
     full?: boolean;
     noPlan?: boolean;
     registry?: Registry;
+    theme?: string;
+    template?: string;
 }): Promise<ComposeResult & {
     template?: string;
     source?: Record<string, unknown>;

package/dist/types/packages/core/src/index.d.ts

@@ -8,8 +8,8 @@ export { cacheRoot, cacheUsage, cleanCache, type CacheUsage } from '../../assets
 export { reviewComposition, type ReviewIssue, type ReviewResult, type ReviewOptions } from './review.js';
 export { measureMedia, attachCaptions, prepareComposition, captionTrack } from './media.js';
 export * from './distributed.js';
-export { createRenderer, renderFrames, defaultConcurrency, launchBrowser, describeBrowser, browserInstallHint, type Renderer } from '../../renderer/src/index.js';
-export { x264Presets, defaultPreset, checkFfmpeg, requiredEncoders, ffmpegPath, ffprobePath, type X264Preset } from '../../ffmpeg/src/index.js';
+export { createRenderer, renderFrames, defaultConcurrency, launchBrowser, describeBrowser, ensureChromium, browserInstallHint, type Renderer } from '../../renderer/src/index.js';
+export { x264Presets, defaultPreset, checkFfmpeg, requiredEncoders, ffmpegPath, ffprobePath, ensureFfmpeg, type X264Preset } from '../../ffmpeg/src/index.js';
 export type OutputFormat = typeof outputFormats[number];
 export type LoadedComposition = {
     composition: Composition;

package/dist/types/packages/ffmpeg/src/auto-install.d.ts

@@ -0,0 +1,12 @@
+export declare const localFfmpegPath: string;
+export declare const localFfprobePath: string;
+export declare function hasSystemFfmpeg(): boolean;
+export declare function hasSystemFfprobe(): boolean;
+export declare const getFfmpegPath: () => string;
+export declare const getFfprobePath: () => string;
+export declare function ensureFfmpeg(options?: {
+    onProgress?: (msg: string) => void;
+}): Promise<{
+    ffmpeg: string;
+    ffprobe: string;
+}>;

package/dist/types/packages/ffmpeg/src/index.d.ts

@@ -1,3 +1,4 @@
+export { ensureFfmpeg, hasSystemFfmpeg, hasSystemFfprobe, localFfmpegPath, localFfprobePath } from './auto-install.js';
 export declare const x264Presets: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"];
 export type X264Preset = typeof x264Presets[number];
 export type EncodeOptions = {

package/dist/types/packages/jobs/src/env.d.ts

@@ -30,6 +30,9 @@ export interface JobPaths {
 export type JobCapabilities = {
     composeSmart(provider: AiProvider, options: ComposeOptions, mode: {
         full?: boolean;
+        noPlan?: boolean;
+        theme?: string;
+        template?: string;
     }): Promise<ComposeResult & {
         template?: string;
         source?: Record<string, unknown>;

package/dist/types/packages/renderer/src/index.d.ts

@@ -26,6 +26,9 @@ export declare const scaledSize: (composition: Composition, scale?: number) => {
     height: number;
 };
 export declare const 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.";
+export declare function ensureChromium(options?: {
+    onProgress?: (msg: string) => void;
+}): Promise<void>;
 export declare function launchBrowser(): Promise<Browser>;
 export declare function describeBrowser(): Promise<string>;
 export declare const defaultConcurrency: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "motionrender",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "JSON-first, frame-deterministic motion graphics video engine: render compositions to MP4, WebM, ProRes, GIF or PNG frames from Node or the command line.",
   "license": "MIT",
   "type": "module",