reframe-video 0.6.6 → 0.6.8

package/dist/browserEntry.js

@@ -342,7 +342,7 @@
     line: ["x1", "y1", "x2", "y2", "stroke", "strokeWidth", "opacity", "progress", ...FX_PROPS],
     text: [...COMMON_PROPS, "content", "contentDecimals", "contentThousands", "fontFamily", "fontSize", "fontWeight", "fill", "letterSpacing"],
     image: [...COMMON_PROPS, "src", "width", "height", "fit"],
-    video: [...COMMON_PROPS, "src", "width", "height", "fit", "start", "rate", "clipStart"],
+    video: [...COMMON_PROPS, "src", "width", "height", "fit", "start", "rate", "clipStart", "volume"],
     path: [...COMMON_PROPS, "d", "fill", "stroke", "strokeWidth", "progress", "originX", "originY"],
     group: COMMON_PROPS
   };
@@ -1104,11 +1104,26 @@
   var canvas = null;
   var images = /* @__PURE__ */ new Map();
   var videoFrames = /* @__PURE__ */ new Map();
-  var decode = (dataUrl) => {
+  async function decode(dataUrl, label = "") {
     const img = new Image();
     img.src = dataUrl;
-    return img.decode().then(() => img);
-  };
+    try {
+      await img.decode();
+      return img;
+    } catch (e) {
+      throw new Error(`decode failed for ${label} (len=${dataUrl.length}): ${String(e)}`);
+    }
+  }
+  async function decodeAll(urls, label) {
+    const out = new Array(urls.length);
+    const LIMIT = 8;
+    for (let base = 0; base < urls.length; base += LIMIT) {
+      const batch = urls.slice(base, base + LIMIT);
+      const decoded = await Promise.all(batch.map((u, j) => decode(u, `${label}#${base + j}`)));
+      for (let j = 0; j < decoded.length; j++) out[base + j] = decoded[j];
+    }
+    return out;
+  }
   var videos = {
     frame(src, index) {
       const frames = videoFrames.get(src);
@@ -1126,14 +1141,14 @@
       document.body.appendChild(canvas);
       ctx = canvas.getContext("2d", { willReadFrequently: true });
       if (!ctx) throw new Error("could not create 2d context");
-      await Promise.all([
-        ...Object.entries(assets).map(async ([src, dataUrl]) => {
-          images.set(src, await decode(dataUrl));
-        }),
-        ...Object.entries(videoAssets).map(async ([src, frames]) => {
-          videoFrames.set(src, await Promise.all(frames.map(decode)));
+      await Promise.all(
+        Object.entries(assets).map(async ([src, dataUrl]) => {
+          images.set(src, await decode(dataUrl, `image ${src}`));
         })
-      ]);
+      );
+      for (const [src, frames] of Object.entries(videoAssets)) {
+        videoFrames.set(src, await decodeAll(frames, `video ${src}`));
+      }
       return { duration: compiled.duration, fps: ir.fps ?? 30 };
     },
     renderFrame(t) {

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env tsx
 
 // ../render-cli/src/cli.ts
-import { mkdtemp as mkdtemp4, readFile as readFile5, rm as rm4 } from "node:fs/promises";
-import { tmpdir as tmpdir5 } from "node:os";
-import { basename, dirname as dirname7, join as join7, resolve as resolve5 } from "node:path";
+import { mkdtemp as mkdtemp5, readFile as readFile5, rm as rm5 } from "node:fs/promises";
+import { tmpdir as tmpdir6 } from "node:os";
+import { basename, dirname as dirname7, join as join9, resolve as resolve6 } from "node:path";
 
 // ../core/src/ir.ts
 var DEFAULT_CROSSFADE = 0.5;
@@ -347,7 +347,7 @@ var PROPS_BY_TYPE = {
   line: ["x1", "y1", "x2", "y2", "stroke", "strokeWidth", "opacity", "progress", ...FX_PROPS],
   text: [...COMMON_PROPS, "content", "contentDecimals", "contentThousands", "fontFamily", "fontSize", "fontWeight", "fill", "letterSpacing"],
   image: [...COMMON_PROPS, "src", "width", "height", "fit"],
-  video: [...COMMON_PROPS, "src", "width", "height", "fit", "start", "rate", "clipStart"],
+  video: [...COMMON_PROPS, "src", "width", "height", "fit", "start", "rate", "clipStart", "volume"],
   path: [...COMMON_PROPS, "d", "fill", "stroke", "strokeWidth", "progress", "originX", "originY"],
   group: COMMON_PROPS
 };
@@ -885,11 +885,34 @@ var SFX_DURATION = {
   thud: 0.25
 };
 var FILE_CUE_DURATION = 0.4;
+function collectClipAudio(ir, duration, warnings) {
+  const out = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "video") {
+        const gain = node.props.volume ?? 1;
+        const start = node.props.start ?? 0;
+        if (gain <= 0) continue;
+        if (start >= duration) {
+          warnings.push(`video "${node.id}": start ${start.toFixed(2)}s past the scene end \u2014 audio dropped`);
+          continue;
+        }
+        out.push({ nodeId: node.id, src: node.props.src, start, rate: node.props.rate ?? 1, clipStart: node.props.clipStart ?? 0, gain });
+      }
+      if (node.type === "group") walk(node.children);
+    }
+  };
+  walk(ir.nodes);
+  return out;
+}
 function resolveAudioPlan(compiled) {
   const audio = compiled.ir.audio;
-  if (!audio || !audio.bgm && (audio.cues ?? []).length === 0) return null;
   const warnings = [];
   const duration = compiled.duration;
+  const clipAudio = collectClipAudio(compiled.ir, duration, warnings);
+  if (!audio || !audio.bgm && (audio.cues ?? []).length === 0) {
+    return clipAudio.length === 0 ? null : { duration, bgm: null, cues: [], duckWindows: [], clipAudio, warnings };
+  }
   const cues = [];
   for (const [index, cue] of (audio.cues ?? []).entries()) {
     let anchor;
@@ -925,6 +948,7 @@ function resolveAudioPlan(compiled) {
     bgm: resolveBgm(audio.bgm),
     cues,
     duckWindows: mergeDuckWindows(cues, duration),
+    clipAudio,
     warnings
   };
 }
@@ -958,6 +982,7 @@ function resolveCompositionAudioPlan(comp) {
   const duration = comp.duration;
   const warnings = [];
   const cues = [];
+  const clipAudio = [];
   for (const placement of comp.scenes) {
     const plan = resolveAudioPlan(placement.compiled);
     if (!plan) continue;
@@ -970,6 +995,11 @@ function resolveCompositionAudioPlan(comp) {
       if (t >= duration) continue;
       cues.push({ ...cue, t });
     }
+    for (const clip of plan.clipAudio) {
+      const start = clip.start + placement.start;
+      if (start >= duration) continue;
+      clipAudio.push({ ...clip, start });
+    }
   }
   for (const [index, cue] of (audio?.cues ?? []).entries()) {
     if (typeof cue.at !== "number") {
@@ -989,13 +1019,14 @@ function resolveCompositionAudioPlan(comp) {
       source: cue.sfx ? { kind: "sfx", name: cue.sfx, params: cue.params ?? {} } : { kind: "file", path: cue.file }
     });
   }
-  if (!audio?.bgm && cues.length === 0) return null;
+  if (!audio?.bgm && cues.length === 0 && clipAudio.length === 0) return null;
   cues.sort((a, b) => a.t - b.t);
   return {
     duration,
     bgm: resolveBgm(audio?.bgm),
     cues,
     duckWindows: mergeDuckWindows(cues, duration),
+    clipAudio,
     warnings
   };
 }
@@ -1083,7 +1114,9 @@ function collectVideoSrcs(ir) {
 }
 
 // ../render-cli/src/audio/index.ts
-import { dirname as dirname2 } from "node:path";
+import { copyFile, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname2, join as join4 } from "node:path";
 
 // ../render-cli/src/audio/sfx.ts
 import { mkdir, rename, writeFile } from "node:fs/promises";
@@ -1305,12 +1338,85 @@ async function resolveBgmFile(source, duration, sceneDir) {
   return writeCached(`ambient-pad-${duration.toFixed(2)}`, () => synthAmbientPad(duration));
 }
 
-// ../render-cli/src/audio/mux.ts
+// ../render-cli/src/audio/clip.ts
 import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+function run(cmd, args) {
+  return new Promise((res, reject) => {
+    const proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "", stderr = "";
+    proc.stdout.on("data", (d) => stdout += d.toString());
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
+    proc.on("error", reject);
+  });
+}
+async function hasAudioStream(file) {
+  const { stdout } = await run("ffprobe", [
+    "-v",
+    "error",
+    "-select_streams",
+    "a",
+    "-show_entries",
+    "stream=index",
+    "-of",
+    "csv=p=0",
+    file
+  ]);
+  return stdout.trim().length > 0;
+}
+function resolveSrc(src, sceneDir) {
+  const candidates = [isAbsolute2(src) ? src : null, resolve2(sceneDir, src)].filter(
+    (c) => c !== null
+  );
+  const found = candidates.find((c) => existsSync2(c));
+  if (!found) throw new Error(`video "${src}" not found (tried: ${candidates.join(", ")})`);
+  return found;
+}
+async function resolveClipAudio(entry, sceneDir, workDir) {
+  const src = resolveSrc(entry.src, sceneDir);
+  if (!await hasAudioStream(src)) return null;
+  const out = join2(workDir, `clip-${entry.nodeId}.wav`);
+  const { code, stderr } = await run("ffmpeg", [
+    "-y",
+    "-i",
+    src,
+    "-vn",
+    "-ac",
+    "2",
+    "-ar",
+    "44100",
+    "-c:a",
+    "pcm_s16le",
+    out
+  ]);
+  if (code !== 0) throw new Error(`clip audio extract failed for "${entry.src}":
+${stderr.slice(-1500)}`);
+  return out;
+}
+
+// ../render-cli/src/audio/mux.ts
+import { spawn as spawn2 } from "node:child_process";
 import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var FORMAT = "aformat=sample_rates=44100:channel_layouts=stereo";
+function atempoChain(rate) {
+  if (!(rate > 0) || rate === 1) return [];
+  const out = [];
+  let r = rate;
+  while (r > 2) {
+    out.push("atempo=2.0");
+    r /= 2;
+  }
+  while (r < 0.5) {
+    out.push("atempo=0.5");
+    r /= 0.5;
+  }
+  out.push(`atempo=${r.toFixed(4)}`);
+  return out;
+}
 function buildFilterGraph(plan, inputs) {
   const lines = [];
   const mixIn = ["[anchor]"];
@@ -1343,15 +1449,25 @@ function buildFilterGraph(plan, inputs) {
     mixIn.push(`[c${i}]`);
     inputIndex++;
   });
+  (inputs.clipFiles ?? []).forEach(({ audio }, i) => {
+    const chain = [];
+    if (audio.clipStart > 0) chain.push(`atrim=start=${audio.clipStart.toFixed(3)}`, "asetpts=PTS-STARTPTS");
+    chain.push(...atempoChain(audio.rate), FORMAT, `volume=${audio.gain}`);
+    const delayMs = Math.round(audio.start * 1e3);
+    if (delayMs > 0) chain.push(`adelay=${delayMs}:all=1`);
+    lines.push(`[${inputIndex}:a]${chain.join(",")}[k${i}]`);
+    mixIn.push(`[k${i}]`);
+    inputIndex++;
+  });
   lines.push(
     `${mixIn.join("")}amix=inputs=${mixIn.length}:duration=first:normalize=0,alimiter=limit=0.891,aresample=async=1:first_pts=0[aout]`
   );
   return lines.join(";\n");
 }
 async function muxAudio(videoIn, plan, inputs, outFile) {
-  const work = await mkdtemp(join2(tmpdir2(), "reframe-mux-"));
+  const work = await mkdtemp(join3(tmpdir2(), "reframe-mux-"));
   try {
-    const graphFile = join2(work, "graph.txt");
+    const graphFile = join3(work, "graph.txt");
     await writeFile2(graphFile, buildFilterGraph(plan, inputs));
     const args = [
       "-y",
@@ -1359,6 +1475,7 @@ async function muxAudio(videoIn, plan, inputs, outFile) {
       videoIn,
       ...plan.bgm && inputs.bgmFile ? ["-i", inputs.bgmFile] : [],
       ...inputs.cueFiles.flatMap((f) => ["-i", f]),
+      ...(inputs.clipFiles ?? []).flatMap((c) => ["-i", c.file]),
       "-filter_complex_script",
       graphFile,
       "-map",
@@ -1377,7 +1494,7 @@ async function muxAudio(videoIn, plan, inputs, outFile) {
       outFile
     ];
     await new Promise((resolvePromise, reject) => {
-      const proc = spawn("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+      const proc = spawn2("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
       let stderr = "";
       proc.stderr.on("data", (d) => stderr += d.toString());
       proc.on("close", (code) => {
@@ -1397,17 +1514,32 @@ async function buildAudioTrack(plan, scenePath, videoIn, outFile) {
   const sceneDir = dirname2(scenePath);
   const cueFiles = await Promise.all(plan.cues.map((cue) => resolveCueFile(cue, sceneDir)));
   const bgmFile = plan.bgm ? await resolveBgmFile(plan.bgm.source, plan.duration, sceneDir) : null;
-  await muxAudio(videoIn, plan, { cueFiles, bgmFile }, outFile);
+  const work = await mkdtemp2(join4(tmpdir3(), "reframe-clipaudio-"));
+  try {
+    const clipFiles = [];
+    for (const entry of plan.clipAudio) {
+      const file = await resolveClipAudio(entry, sceneDir, work);
+      if (file) clipFiles.push({ audio: entry, file });
+      else console.error(`audio: video "${entry.nodeId}" has no audio track \u2014 skipped`);
+    }
+    if (!plan.bgm && plan.cues.length === 0 && clipFiles.length === 0) {
+      await copyFile(videoIn, outFile);
+      return;
+    }
+    await muxAudio(videoIn, plan, { cueFiles, bgmFile, clipFiles }, outFile);
+  } finally {
+    await rm2(work, { recursive: true, force: true });
+  }
 }
 
 // ../render-cli/src/composition.ts
-import { spawn as spawn4 } from "node:child_process";
-import { copyFile, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { spawn as spawn5 } from "node:child_process";
+import { copyFile as copyFile2, mkdtemp as mkdtemp4, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir5 } from "node:os";
+import { dirname as dirname5, join as join8 } from "node:path";
 
 // ../render-cli/src/encode.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 async function encodeMp4(framesDir, fps, outFile) {
   const args = [
     "-y",
@@ -1427,12 +1559,12 @@ async function encodeMp4(framesDir, fps, outFile) {
     "+faststart",
     outFile
   ];
-  await new Promise((resolve6, reject) => {
-    const proc = spawn2("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+  await new Promise((resolve7, reject) => {
+    const proc = spawn3("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else reject(new Error(`ffmpeg exited with ${code}:
 ${stderr.slice(-2e3)}`));
     });
@@ -1442,23 +1574,23 @@ ${stderr.slice(-2e3)}`));
 
 // ../render-cli/src/frameLoop.ts
 import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join5, dirname as dirname4 } from "node:path";
+import { join as join7, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 import { build } from "esbuild";
 import { chromium } from "playwright";
 
 // ../render-cli/src/fonts.ts
 import { readFile } from "node:fs/promises";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var FONTS_DIR = true ? join3(dirname3(fileURLToPath2(import.meta.url)), "..", "assets", "fonts") : join3(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "..", "assets", "fonts");
+var FONTS_DIR = true ? join5(dirname3(fileURLToPath2(import.meta.url)), "..", "assets", "fonts") : join5(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "..", "assets", "fonts");
 var WEIGHTS = [400, 700, 800];
 var cssCache = null;
 async function fontFaceCss() {
   if (cssCache) return cssCache;
   const rules = await Promise.all(
     WEIGHTS.map(async (weight) => {
-      const data = await readFile(join3(FONTS_DIR, `inter-${weight}.woff2`));
+      const data = await readFile(join5(FONTS_DIR, `inter-${weight}.woff2`));
       return `@font-face {
   font-family: "Inter";
   font-style: normal;
@@ -1473,8 +1605,8 @@ async function fontFaceCss() {
 
 // ../render-cli/src/images.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-import { extname, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { extname, isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
 var MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -1490,10 +1622,10 @@ async function buildImageAssets(ir, sceneDir) {
         `image "${src}": unsupported format "${extname(src)}" \u2014 supported: ${Object.keys(MIME).join(" ")}`
       );
     }
-    const candidates = [isAbsolute2(src) ? src : null, resolve2(sceneDir, src)].filter(
+    const candidates = [isAbsolute3(src) ? src : null, resolve3(sceneDir, src)].filter(
       (c) => c !== null
     );
-    const found = candidates.find((c) => existsSync2(c));
+    const found = candidates.find((c) => existsSync3(c));
     if (!found) {
       throw new Error(`image "${src}" not found (tried: ${candidates.join(", ")})`);
     }
@@ -1504,20 +1636,20 @@ async function buildImageAssets(ir, sceneDir) {
 }
 
 // ../render-cli/src/videos.ts
-import { spawn as spawn3 } from "node:child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile3, readdir, rm as rm2 } from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { extname as extname2, isAbsolute as isAbsolute3, join as join4, resolve as resolve3 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { mkdtemp as mkdtemp3, readFile as readFile3, readdir, rm as rm3 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { extname as extname2, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "node:path";
 var VIDEO_EXT = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".m4v", ".mkv"]);
 function runFfmpeg(args) {
-  return new Promise((resolve6, reject) => {
-    const proc = spawn3("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+  return new Promise((resolve7, reject) => {
+    const proc = spawn4("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on(
       "close",
-      (code) => code === 0 ? resolve6() : reject(new Error(`ffmpeg exited ${code}:
+      (code) => code === 0 ? resolve7() : reject(new Error(`ffmpeg exited ${code}:
 ${stderr.slice(-2e3)}`))
     );
     proc.on("error", reject);
@@ -1556,12 +1688,12 @@ async function buildVideoFrameAssets(ir, sceneDir, fps, duration) {
         `video "${src}": unsupported format "${extname2(src)}" \u2014 supported: ${[...VIDEO_EXT].join(" ")}`
       );
     }
-    const candidates = [isAbsolute3(src) ? src : null, resolve3(sceneDir, src)].filter(
+    const candidates = [isAbsolute4(src) ? src : null, resolve4(sceneDir, src)].filter(
       (c) => c !== null
     );
-    const found = candidates.find((c) => existsSync3(c));
+    const found = candidates.find((c) => existsSync4(c));
     if (!found) throw new Error(`video "${src}" not found (tried: ${candidates.join(", ")})`);
-    const dir = await mkdtemp2(join4(tmpdir3(), "reframe-vframes-"));
+    const dir = await mkdtemp3(join6(tmpdir4(), "reframe-vframes-"));
     try {
       const seconds = Math.max(1 / fps, reachBySrc.get(src) ?? duration);
       await runFfmpeg([
@@ -1574,15 +1706,15 @@ async function buildVideoFrameAssets(ir, sceneDir, fps, duration) {
         `fps=${fps},scale='min(iw,1280)':-2`,
         "-q:v",
         "4",
-        join4(dir, "%05d.jpg")
+        join6(dir, "%05d.jpg")
       ]);
       const files = (await readdir(dir)).filter((f) => f.endsWith(".jpg")).sort();
       assets[src] = await Promise.all(
-        files.map(async (f) => `data:image/jpeg;base64,${(await readFile3(join4(dir, f))).toString("base64")}`)
+        files.map(async (f) => `data:image/jpeg;base64,${(await readFile3(join6(dir, f))).toString("base64")}`)
       );
       if (assets[src].length === 0) throw new Error(`video "${src}": ffmpeg extracted no frames`);
     } finally {
-      await rm2(dir, { recursive: true, force: true });
+      await rm3(dir, { recursive: true, force: true });
     }
   }
   return assets;
@@ -1666,7 +1798,7 @@ async function injectFonts(page) {
     await document.fonts.ready;
   });
 }
-var framePath = (dir, i) => join5(dir, `${String(i).padStart(5, "0")}.png`);
+var framePath = (dir, i) => join7(dir, `${String(i).padStart(5, "0")}.png`);
 async function withPage(size, fn) {
   const browser = await chromium.launch({
     args: ["--force-color-profile=srgb", "--font-render-hinting=none"]
@@ -1684,12 +1816,12 @@ async function browserBundle() {
   if (true) {
     const { readFile: readFile6 } = await import("node:fs/promises");
     bundleCache = await readFile6(
-      join5(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.js"),
+      join7(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.js"),
       "utf8"
     );
     return bundleCache;
   }
-  const entry = join5(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.ts");
+  const entry = join7(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.ts");
   const result = await build({
     entryPoints: [entry],
     bundle: true,
@@ -1750,24 +1882,24 @@ async function captureHtml(htmlPath, opts) {
 
 // ../render-cli/src/composition.ts
 function runFfmpeg2(args) {
-  return new Promise((resolve6, reject) => {
-    const proc = spawn4("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+  return new Promise((resolve7, reject) => {
+    const proc = spawn5("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr.on("data", (d) => stderr += d.toString());
-    proc.on("close", (code) => code === 0 ? resolve6() : reject(new Error(`ffmpeg exited ${code}:
+    proc.on("close", (code) => code === 0 ? resolve7() : reject(new Error(`ffmpeg exited ${code}:
 ${stderr.slice(-2e3)}`)));
     proc.on("error", reject);
   });
 }
 var sanitize = (id) => id.replace(/[^a-z0-9_-]/gi, "_");
 async function renderSceneVideo(scene, sceneDir, fps, out) {
-  const framesDir = await mkdtemp3(join6(tmpdir4(), "reframe-frames-"));
+  const framesDir = await mkdtemp4(join8(tmpdir5(), "reframe-frames-"));
   try {
     const result = await captureIr(scene, { framesDir, sceneDir, ...fps !== void 0 && { fps } });
     await encodeMp4(result.framesDir, result.fps, out);
     return { fps: result.fps, frameCount: result.frameCount };
   } finally {
-    await rm3(framesDir, { recursive: true, force: true });
+    await rm4(framesDir, { recursive: true, force: true });
   }
 }
 async function renderStandaloneScene(scene, sceneDir, fps, noAudio, out) {
@@ -1775,15 +1907,15 @@ async function renderStandaloneScene(scene, sceneDir, fps, noAudio, out) {
   if (plan) {
     const videoOut = `${out}.video.mp4`;
     await renderSceneVideo(scene, sceneDir, fps, videoOut);
-    await buildAudioTrack(plan, join6(sceneDir, "scene"), videoOut, out);
-    await rm3(videoOut, { force: true });
+    await buildAudioTrack(plan, join8(sceneDir, "scene"), videoOut, out);
+    await rm4(videoOut, { force: true });
   } else {
     await renderSceneVideo(scene, sceneDir, fps, out);
   }
 }
 async function concatVideos(files, out) {
   if (files.length === 1) {
-    await copyFile(files[0], out);
+    await copyFile2(files[0], out);
     return;
   }
   const list = `${out}.concat.txt`;
@@ -1819,7 +1951,7 @@ async function combineWithTransitions(videos, out, tmp) {
   let accDur = videos[0].placement.duration;
   for (let i = 1; i < videos.length; i++) {
     const { overlap, duration } = videos[i].placement;
-    const step = join6(tmp, `step${i}.mp4`);
+    const step = join8(tmp, `step${i}.mp4`);
     if (overlap <= 0) {
       await concatVideos([acc, videos[i].file], step);
       accDur += duration;
@@ -1830,7 +1962,7 @@ async function combineWithTransitions(videos, out, tmp) {
     }
     acc = step;
   }
-  await copyFile(acc, out);
+  await copyFile2(acc, out);
 }
 async function renderComposition(comp, opts) {
   const cc = compileComposition(comp);
@@ -1841,15 +1973,15 @@ async function renderComposition(comp, opts) {
     await renderStandaloneScene(p.scene, sceneDir, opts.fps, opts.noAudio, opts.out);
     return { duration: p.duration, sceneCount: 1 };
   }
-  const tmp = await mkdtemp3(join6(tmpdir4(), "reframe-comp-"));
+  const tmp = await mkdtemp4(join8(tmpdir5(), "reframe-comp-"));
   try {
     const videos = [];
     for (const p of cc.scenes) {
-      const file = join6(tmp, `${sanitize(p.id)}.mp4`);
+      const file = join8(tmp, `${sanitize(p.id)}.mp4`);
       const { fps } = await renderSceneVideo(p.scene, sceneDir, opts.fps, file);
       videos.push({ id: p.id, file, placement: p, fps });
     }
-    const combined = join6(tmp, "combined.mp4");
+    const combined = join8(tmp, "combined.mp4");
     const allCut = cc.scenes.every((s) => s.overlap === 0);
     if (allCut) await concatVideos(videos.map((v) => v.file), combined);
     else await combineWithTransitions(videos, combined, tmp);
@@ -1859,24 +1991,24 @@ async function renderComposition(comp, opts) {
         for (const w of plan.warnings) console.error(`audio: ${w}`);
         await buildAudioTrack(plan, opts.compositionPath, combined, opts.out);
       } else {
-        await copyFile(combined, opts.out);
+        await copyFile2(combined, opts.out);
       }
     } else {
-      await copyFile(combined, opts.out);
+      await copyFile2(combined, opts.out);
     }
     return { duration: cc.duration, sceneCount: cc.scenes.length };
   } finally {
-    await rm3(tmp, { recursive: true, force: true });
+    await rm4(tmp, { recursive: true, force: true });
   }
 }
 
 // ../render-cli/src/loadScene.ts
 import { build as build2 } from "esbuild";
 import { readFile as readFile4 } from "node:fs/promises";
-import { dirname as dirname6, resolve as resolve4 } from "node:path";
+import { dirname as dirname6, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var HERE = dirname6(fileURLToPath4(import.meta.url));
-var CORE_ENTRY = true ? resolve4(HERE, "index.js") : resolve4(HERE, "..", "..", "core", "src", "index.ts");
+var CORE_ENTRY = true ? resolve5(HERE, "index.js") : resolve5(HERE, "..", "..", "core", "src", "index.ts");
 async function loadDefault(path2) {
   if (path2.endsWith(".json")) return JSON.parse(await readFile4(path2, "utf8"));
   let code;
@@ -1926,7 +2058,7 @@ function parseArgs(argv) {
   }
   const args = {
     mode,
-    input: resolve5(input),
+    input: resolve6(input),
     out: `${basename(input).replace(/\.[^.]+$/, "")}.mp4`,
     keepFrames: false,
     overlays: [],
@@ -1938,8 +2070,8 @@ function parseArgs(argv) {
     else if (a === "--fps") args.fps = Number(rest[++i]);
     else if (a === "--duration") args.duration = Number(rest[++i]);
     else if (a === "--keep-frames") args.keepFrames = true;
-    else if (a === "--frames-dir") args.framesDir = resolve5(rest[++i]);
-    else if (a === "--overlay") args.overlays.push(resolve5(rest[++i]));
+    else if (a === "--frames-dir") args.framesDir = resolve6(rest[++i]);
+    else if (a === "--overlay") args.overlays.push(resolve6(rest[++i]));
     else if (a === "--no-audio") args.noAudio = true;
     else if (a === "--scene") args.scene = rest[++i];
     else {
@@ -1968,7 +2100,7 @@ async function main() {
     );
     return;
   }
-  const framesDir = args.framesDir ?? await mkdtemp4(join7(tmpdir5(), "reframe-frames-"));
+  const framesDir = args.framesDir ?? await mkdtemp5(join9(tmpdir6(), "reframe-frames-"));
   let result;
   let audioJob = null;
   if (args.mode === "ir") {
@@ -2007,10 +2139,10 @@ async function main() {
   await encodeMp4(result.framesDir, result.fps, audioJob ? audioJob.videoOut : args.out);
   if (audioJob) {
     await buildAudioTrack(audioJob.plan, args.input, audioJob.videoOut, args.out);
-    await rm4(audioJob.videoOut, { force: true });
+    await rm5(audioJob.videoOut, { force: true });
   }
   if (!args.keepFrames && args.framesDir === void 0) {
-    await rm4(framesDir, { recursive: true, force: true });
+    await rm5(framesDir, { recursive: true, force: true });
   }
   console.log(
     `${args.out} (${result.frameCount} frames @ ${result.fps}fps${audioJob ? `, ${audioJob.plan.cues.length} audio cues` : ""})`