motionrender 0.2.1 → 0.2.3

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";
@@ -483,7 +483,35 @@ var captionLines = (cues, maxWords) => cues.flatMap((cue) => cue.words && cue.wo
 
 // packages/schema/src/index.ts
 var color = z3.string().regex(colorPattern);
-var fontWeight = z3.union([z3.number().int().min(1).max(1e3), z3.enum(["normal", "bold"])]);
+var fontWeightMap = {
+  thin: 100,
+  hairline: 100,
+  extralight: 200,
+  ultralight: 200,
+  "extra-light": 200,
+  "ultra-light": 200,
+  light: 300,
+  regular: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  "semi-bold": 600,
+  "demi-bold": 600,
+  extrabold: 800,
+  ultrabold: 800,
+  "extra-bold": 800,
+  "ultra-bold": 800,
+  black: 900,
+  heavy: 900
+};
+var fontWeight = z3.preprocess((val) => {
+  if (typeof val === "string") {
+    const s = val.trim().toLowerCase();
+    if (/^\d+$/.test(s)) return parseInt(s, 10);
+    if (s in fontWeightMap) return fontWeightMap[s];
+  }
+  return val;
+}, z3.union([z3.number().int().min(1).max(1e3), z3.enum(["normal", "bold"])]));
 var fontStyle = z3.enum(["normal", "italic"]);
 var easingSchema = z3.union([z3.enum(["linear", "easeIn", "easeOut", "easeInOut", "easeInCubic", "easeOutCubic", "easeInOutCubic", "easeInQuart", "easeOutQuart", "easeInOutQuart", "easeInExpo", "easeOutExpo", "easeInOutExpo", "easeInBack", "easeOutBack", "spring", "hold", "land", "snap", "glide", "pop", "move", "exit", "drift"]).describe("land, snap, glide and pop for entries, move within the frame, exit for leaving, drift for slow continuous motion; or a standard curve"), z3.tuple([z3.number().min(0).max(1), z3.number(), z3.number().min(0).max(1), z3.number()]).describe("Cubic B\xE9zier control points [x1, y1, x2, y2], as in CSS")]);
 var colorProperties = ["fill", "color", "stroke"];
@@ -837,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
@@ -1194,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+$/, "");
@@ -1308,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 = "";
@@ -1330,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 = "";
@@ -1339,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 = "";
@@ -1363,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);
@@ -1438,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";
 
@@ -1530,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 };
   }
@@ -1549,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 });
@@ -1642,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}
@@ -1688,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();
   }
@@ -1836,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 = "";
@@ -1850,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);
   }
@@ -1905,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);
@@ -1932,6 +2139,16 @@ async function measureLoudness(composition, baseDir) {
 var area = (a) => Math.max(0, a.x1 - a.x0) * Math.max(0, a.y1 - a.y0);
 var overlap = (a, b) => Math.max(0, Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0)) * Math.max(0, Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0));
 var seconds2 = (frame, fps) => `${(frame / fps).toFixed(1)} s`;
+function safeZoneBands(width, height, override) {
+  const screen = width * 16 / 9, letterbox = height >= width ? Math.max(0, (screen - height) / 2) : 0;
+  const inset = { ...height >= width ? { top: Math.max(0, 0.08 * screen - letterbox) / height, bottom: Math.max(0, 0.18 * screen - letterbox) / height, left: 0.02, right: 0.11 } : {}, ...override };
+  const bands = [];
+  if (inset.bottom) bands.push({ name: "bottom UI band", hint: `Reels and TikTok draw their controls over the bottom ${Math.round(inset.bottom * height)} px: keep text above y ${Math.round(height - inset.bottom * height)}`, x0: 0, y0: height - inset.bottom * height, x1: width, y1: height });
+  if (inset.right) bands.push({ name: "right UI band", hint: `the action buttons cover the right ${Math.round(inset.right * width)} px: keep text left of x ${Math.round(width - inset.right * width)}`, x0: width - inset.right * width, y0: 0, x1: width, y1: height });
+  if (inset.top) bands.push({ name: "top UI band", hint: `search and the camera cover the top ${Math.round(inset.top * height)} px: keep text below y ${Math.round(inset.top * height)}`, x0: 0, y0: 0, x1: width, y1: inset.top * height });
+  if (inset.left) bands.push({ name: "left UI band", hint: `keep text right of x ${Math.round(inset.left * width)}`, x0: 0, y0: 0, x1: inset.left * width, y1: height });
+  return bands;
+}
 async function reviewComposition(composition, options = {}) {
   const { fps, width, height, durationFrames } = composition, baseDir = options.baseDir ?? process.cwd();
   const every = Math.max(1, Math.round(options.every ?? fps / 2)), frames = [];
@@ -1980,6 +2197,12 @@ async function reviewComposition(composition, options = {}) {
     const other = report.texts.find((o) => o !== t && o.id !== t.id && visible(o) && overlap(t, o) > 0.15 * Math.min(area(t), area(o)) && (t.kind === "captions" || o.kind === "captions" || t.id < o.id));
     return other ? t.kind === "captions" || other.kind === "captions" ? `"${(t.kind === "captions" ? other : t).text}" sits under the captions: keep content out of the captions band` : `"${t.text}" overlaps "${other.text}"` : void 0;
   }, "error");
+  const bands = safeZoneBands(width, height, options.safeZone);
+  if (bands.length) persistent("safe-zone", hold, (t) => {
+    if (!visible(t)) return;
+    const band = bands.find((b) => overlap(t, b) > 0.25 * area(t));
+    return band ? `"${t.text}" sits in the ${band.name}: ${band.hint}` : void 0;
+  }, "warning");
   const crowded = reports.map((r) => r.texts.filter((t) => visible(t) && t.kind === "text").reduce((n, t) => n + t.words, 0) > 40), busy = crowded.findIndex((_, i) => i + hold <= crowded.length && crowded.slice(i, i + hold).every(Boolean));
   if (busy >= 0) issues.push({ severity: "warning", code: "busy", message: `More than 40 words on screen at ${seconds2(frames[busy], fps)}: split it across beats or cut words`, frame: frames[busy] });
   const texts = reports.flatMap((r) => r.texts).filter((t) => visible(t) && t.kind === "text"), sizes = [...new Set(texts.map((t) => Math.round(t.baseSize)))].sort((a, b) => b - a), colours = [...new Set(texts.map((t) => t.color.toLowerCase()).filter((c) => c !== "gradient"))];
@@ -2078,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");
@@ -2102,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);
@@ -2116,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;
@@ -2149,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);
@@ -2182,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 });
@@ -2200,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 });
     }
@@ -2266,12 +2490,15 @@ export {
   dropFillerWords,
   duckSchema,
   easingSchema,
+  ensureChromium,
+  ensureFfmpeg,
   evaluateFrame,
   expandMattes,
   expandSceneGrades,
   exportSchema,
   ffmpegPath,
   ffprobePath,
+  fillers,
   formatCaptions,
   formatForOutput,
   frameToSeconds,