reframe-video 0.6.5 → 0.6.6

package/dist/browserEntry.js

@@ -342,6 +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"],
     path: [...COMMON_PROPS, "d", "fill", "stroke", "strokeWidth", "progress", "originX", "originY"],
     group: COMMON_PROPS
   };
@@ -786,6 +787,33 @@
           });
           return;
         }
+        case "video": {
+          const width = num(id, "width", node.props.width);
+          const height = num(id, "height", node.props.height);
+          const [ax, ay] = ANCHOR_FACTORS[node.props.anchor ?? "top-left"];
+          const fps = compiled2.ir.fps ?? 30;
+          const start = node.props.start ?? 0;
+          const rate = node.props.rate ?? 1;
+          const clipStart = node.props.clipStart ?? 0;
+          const srcT = clipStart + Math.max(0, t - start) * rate;
+          const frame = Math.max(0, Math.round(srcT * fps));
+          ops.push({
+            type: "video",
+            id,
+            transform: matrix,
+            opacity,
+            src: str(id, "src", node.props.src),
+            width,
+            height,
+            offsetX: -width * ax,
+            offsetY: -height * ay,
+            frame,
+            ...node.props.fit && node.props.fit !== "fill" ? { fit: node.props.fit } : {},
+            ...fx,
+            ...clipSpread
+          });
+          return;
+        }
         case "path": {
           const ox = num(id, "originX", node.props.originX ?? 0);
           const oy = num(id, "originY", node.props.originY ?? 0);
@@ -879,7 +907,7 @@
     for (const s of paint.stops) g.addColorStop(Math.max(0, Math.min(1, s.offset)), s.color);
     return g;
   }
-  function renderFrame(ctx2, compiled2, t, images2) {
+  function renderFrame(ctx2, compiled2, t, images2, videos2) {
     const { size, background } = compiled2.ir;
     ctx2.setTransform(1, 0, 0, 1, 0, 0);
     ctx2.clearRect(0, 0, size.width, size.height);
@@ -887,9 +915,9 @@
       ctx2.fillStyle = background;
       ctx2.fillRect(0, 0, size.width, size.height);
     }
-    drawDisplayList(ctx2, evaluate(compiled2, t), images2);
+    drawDisplayList(ctx2, evaluate(compiled2, t), images2, videos2);
   }
-  function drawDisplayList(ctx2, ops, images2) {
+  function drawDisplayList(ctx2, ops, images2, videos2) {
     for (const op of ops) {
       ctx2.save();
       if (op.clips) {
@@ -971,28 +999,11 @@
           break;
         }
         case "image": {
-          const img = images2?.get(op.src);
-          if (img) {
-            if (op.fit === "cover") {
-              const [iw, ih] = intrinsicSize(img);
-              const { sx, sy, sw, sh } = coverRect(iw, ih, op.width, op.height);
-              ctx2.drawImage(img, sx, sy, sw, sh, op.offsetX, op.offsetY, op.width, op.height);
-            } else {
-              ctx2.drawImage(img, op.offsetX, op.offsetY, op.width, op.height);
-            }
-          } else {
-            ctx2.fillStyle = "#2A2A30";
-            ctx2.fillRect(op.offsetX, op.offsetY, op.width, op.height);
-            ctx2.strokeStyle = "#FF00FF";
-            ctx2.lineWidth = 2;
-            ctx2.strokeRect(op.offsetX, op.offsetY, op.width, op.height);
-            ctx2.beginPath();
-            ctx2.moveTo(op.offsetX, op.offsetY);
-            ctx2.lineTo(op.offsetX + op.width, op.offsetY + op.height);
-            ctx2.moveTo(op.offsetX + op.width, op.offsetY);
-            ctx2.lineTo(op.offsetX, op.offsetY + op.height);
-            ctx2.stroke();
-          }
+          drawRaster(ctx2, images2?.get(op.src), op);
+          break;
+        }
+        case "video": {
+          drawRaster(ctx2, videos2?.frame(op.src, op.frame), op);
           break;
         }
         case "path": {
@@ -1047,6 +1058,29 @@
     const a = img;
     return [a.naturalWidth || a.width || 0, a.naturalHeight || a.height || 0];
   }
+  function drawRaster(ctx2, img, op) {
+    if (img) {
+      if (op.fit === "cover") {
+        const [iw, ih] = intrinsicSize(img);
+        const { sx, sy, sw, sh } = coverRect(iw, ih, op.width, op.height);
+        ctx2.drawImage(img, sx, sy, sw, sh, op.offsetX, op.offsetY, op.width, op.height);
+      } else {
+        ctx2.drawImage(img, op.offsetX, op.offsetY, op.width, op.height);
+      }
+      return;
+    }
+    ctx2.fillStyle = "#2A2A30";
+    ctx2.fillRect(op.offsetX, op.offsetY, op.width, op.height);
+    ctx2.strokeStyle = "#FF00FF";
+    ctx2.lineWidth = 2;
+    ctx2.strokeRect(op.offsetX, op.offsetY, op.width, op.height);
+    ctx2.beginPath();
+    ctx2.moveTo(op.offsetX, op.offsetY);
+    ctx2.lineTo(op.offsetX + op.width, op.offsetY + op.height);
+    ctx2.moveTo(op.offsetX + op.width, op.offsetY);
+    ctx2.lineTo(op.offsetX, op.offsetY + op.height);
+    ctx2.stroke();
+  }
   function quoteFamily(family) {
     return family.includes(" ") && !family.includes('"') ? `"${family}"` : family;
   }
@@ -1069,9 +1103,22 @@
   var ctx = null;
   var canvas = null;
   var images = /* @__PURE__ */ new Map();
+  var videoFrames = /* @__PURE__ */ new Map();
+  var decode = (dataUrl) => {
+    const img = new Image();
+    img.src = dataUrl;
+    return img.decode().then(() => img);
+  };
+  var videos = {
+    frame(src, index) {
+      const frames = videoFrames.get(src);
+      if (!frames || frames.length === 0) return void 0;
+      return frames[Math.max(0, Math.min(index, frames.length - 1))];
+    }
+  };
   window.__reframe = {
-    // fully decode every image before the first frame — renderFrame is sync
-    async init(ir, assets = {}) {
+    // fully decode every image/video frame before the first frame — renderFrame is sync
+    async init(ir, assets = {}, videoAssets = {}) {
       compiled = compileScene(ir);
       canvas = document.createElement("canvas");
       canvas.width = ir.size.width;
@@ -1079,19 +1126,19 @@
       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]) => {
-          const img = new Image();
-          img.src = dataUrl;
-          await img.decode();
-          images.set(src, img);
+      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)));
         })
-      );
+      ]);
       return { duration: compiled.duration, fps: ir.fps ?? 30 };
     },
     renderFrame(t) {
       if (!compiled || !ctx || !canvas) throw new Error("init() not called");
-      renderFrame(ctx, compiled, t, images);
+      renderFrame(ctx, compiled, t, images, videos);
       return canvas.toDataURL("image/png");
     }
   };

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env tsx
 
 // ../render-cli/src/cli.ts
-import { mkdtemp as mkdtemp3, readFile as readFile4, rm as rm3 } from "node:fs/promises";
-import { tmpdir as tmpdir4 } from "node:os";
-import { basename, dirname as dirname7, join as join6, resolve as resolve4 } from "node:path";
+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";
 
 // ../core/src/ir.ts
 var DEFAULT_CROSSFADE = 0.5;
@@ -347,6 +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"],
   path: [...COMMON_PROPS, "d", "fill", "stroke", "strokeWidth", "progress", "originX", "originY"],
   group: COMMON_PROPS
 };
@@ -1044,13 +1045,13 @@ var EASE_TABLE = {
 var EASE_NAMES = Object.keys(EASE_TABLE);
 
 // ../core/src/assets.ts
-function collectImageSrcs(ir) {
+function collectSrcs(ir, type) {
   const srcs = /* @__PURE__ */ new Set();
-  const imageIds = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
   const walkNodes = (nodes) => {
     for (const node of nodes) {
-      if (node.type === "image") {
-        imageIds.add(node.id);
+      if (node.type === type) {
+        ids.add(node.id);
         srcs.add(node.props.src);
       }
       if (node.type === "group") walkNodes(node.children);
@@ -1059,14 +1060,14 @@ function collectImageSrcs(ir) {
   walkNodes(ir.nodes);
   for (const overrides of Object.values(ir.states ?? {})) {
     for (const [nodeId, props] of Object.entries(overrides)) {
-      if (imageIds.has(nodeId) && typeof props.src === "string") srcs.add(props.src);
+      if (ids.has(nodeId) && typeof props.src === "string") srcs.add(props.src);
     }
   }
   const walkTimeline = (step) => {
     if (!step) return;
     if (step.kind === "seq" || step.kind === "par" || step.kind === "stagger") {
       for (const child of step.children) walkTimeline(child);
-    } else if (step.kind === "tween" && imageIds.has(step.target)) {
+    } else if (step.kind === "tween" && ids.has(step.target)) {
       const src = step.props.src;
       if (typeof src === "string") srcs.add(src);
     }
@@ -1074,6 +1075,12 @@ function collectImageSrcs(ir) {
   walkTimeline(ir.timeline);
   return [...srcs];
 }
+function collectImageSrcs(ir) {
+  return collectSrcs(ir, "image");
+}
+function collectVideoSrcs(ir) {
+  return collectSrcs(ir, "video");
+}
 
 // ../render-cli/src/audio/index.ts
 import { dirname as dirname2 } from "node:path";
@@ -1394,10 +1401,10 @@ async function buildAudioTrack(plan, scenePath, videoIn, outFile) {
 }
 
 // ../render-cli/src/composition.ts
-import { spawn as spawn3 } from "node:child_process";
-import { copyFile, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname5, join as join5 } from "node:path";
+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";
 
 // ../render-cli/src/encode.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -1420,12 +1427,12 @@ async function encodeMp4(framesDir, fps, outFile) {
     "+faststart",
     outFile
   ];
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     const proc = spawn2("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on("close", (code) => {
-      if (code === 0) resolve5();
+      if (code === 0) resolve6();
       else reject(new Error(`ffmpeg exited with ${code}:
 ${stderr.slice(-2e3)}`));
     });
@@ -1435,7 +1442,7 @@ ${stderr.slice(-2e3)}`));
 
 // ../render-cli/src/frameLoop.ts
 import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join4, dirname as dirname4 } from "node:path";
+import { join as join5, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 import { build } from "esbuild";
 import { chromium } from "playwright";
@@ -1496,6 +1503,96 @@ async function buildImageAssets(ir, sceneDir) {
   return assets;
 }
 
+// ../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";
+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"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on(
+      "close",
+      (code) => code === 0 ? resolve6() : reject(new Error(`ffmpeg exited ${code}:
+${stderr.slice(-2e3)}`))
+    );
+    proc.on("error", reject);
+  });
+}
+function neededSeconds(node, duration) {
+  const start = node.props.start ?? 0;
+  const rate = node.props.rate ?? 1;
+  const clipStart = node.props.clipStart ?? 0;
+  return clipStart + Math.max(0, duration - start) * Math.max(0, rate) + 1 / 30;
+}
+function videoNodes(ir) {
+  const out = [];
+  const walk = (nodes) => {
+    for (const n of nodes) {
+      if (n.type === "video") out.push(n);
+      if (n.type === "group") walk(n.children);
+    }
+  };
+  walk(ir.nodes);
+  return out;
+}
+async function buildVideoFrameAssets(ir, sceneDir, fps, duration) {
+  const srcs = collectVideoSrcs(ir);
+  if (srcs.length === 0) return {};
+  const nodes = videoNodes(ir);
+  const reachBySrc = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const reach = neededSeconds(n, duration);
+    reachBySrc.set(n.props.src, Math.max(reachBySrc.get(n.props.src) ?? 0, reach));
+  }
+  const assets = {};
+  for (const src of srcs) {
+    if (!VIDEO_EXT.has(extname2(src).toLowerCase())) {
+      throw new Error(
+        `video "${src}": unsupported format "${extname2(src)}" \u2014 supported: ${[...VIDEO_EXT].join(" ")}`
+      );
+    }
+    const candidates = [isAbsolute3(src) ? src : null, resolve3(sceneDir, src)].filter(
+      (c) => c !== null
+    );
+    const found = candidates.find((c) => existsSync3(c));
+    if (!found) throw new Error(`video "${src}" not found (tried: ${candidates.join(", ")})`);
+    const dir = await mkdtemp2(join4(tmpdir3(), "reframe-vframes-"));
+    try {
+      const seconds = Math.max(1 / fps, reachBySrc.get(src) ?? duration);
+      await runFfmpeg([
+        "-y",
+        "-i",
+        found,
+        "-t",
+        seconds.toFixed(3),
+        "-vf",
+        `fps=${fps},scale='min(iw,1280)':-2`,
+        "-q:v",
+        "4",
+        join4(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")}`)
+      );
+      if (assets[src].length === 0) throw new Error(`video "${src}": ffmpeg extracted no frames`);
+    } finally {
+      await rm2(dir, { recursive: true, force: true });
+    }
+  }
+  return assets;
+}
+function resolveTiming(ir, opts) {
+  const fps = opts.fps ?? ir.fps ?? 30;
+  const duration = opts.duration ?? compileScene(ir).duration;
+  return { fps, duration };
+}
+
 // ../render-cli/src/vclock.ts
 var VCLOCK_SOURCE = String.raw`
 (() => {
@@ -1569,7 +1666,7 @@ async function injectFonts(page) {
     await document.fonts.ready;
   });
 }
-var framePath = (dir, i) => join4(dir, `${String(i).padStart(5, "0")}.png`);
+var framePath = (dir, i) => join5(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"]
@@ -1585,14 +1682,14 @@ var bundleCache = null;
 async function browserBundle() {
   if (bundleCache) return bundleCache;
   if (true) {
-    const { readFile: readFile5 } = await import("node:fs/promises");
-    bundleCache = await readFile5(
-      join4(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.js"),
+    const { readFile: readFile6 } = await import("node:fs/promises");
+    bundleCache = await readFile6(
+      join5(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.js"),
       "utf8"
     );
     return bundleCache;
   }
-  const entry = join4(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.ts");
+  const entry = join5(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.ts");
   const result = await build({
     entryPoints: [entry],
     bundle: true,
@@ -1605,7 +1702,10 @@ async function browserBundle() {
 }
 async function captureIr(ir, opts) {
   await mkdir2(opts.framesDir, { recursive: true });
-  const assets = await buildImageAssets(ir, opts.sceneDir ?? process.cwd());
+  const sceneDir = opts.sceneDir ?? process.cwd();
+  const assets = await buildImageAssets(ir, sceneDir);
+  const { fps, duration } = resolveTiming(ir, opts);
+  const videoAssets = await buildVideoFrameAssets(ir, sceneDir, fps, duration);
   const bundle = await browserBundle();
   return withPage(ir.size, async (page) => {
     await page.setContent(
@@ -1613,12 +1713,10 @@ async function captureIr(ir, opts) {
     );
     await injectFonts(page);
     await page.addScriptTag({ content: bundle });
-    const info = await page.evaluate(
-      ([sceneIr, imageAssets]) => window.__reframe.init(sceneIr, imageAssets),
-      [ir, assets]
+    await page.evaluate(
+      ([sceneIr, imageAssets, vAssets]) => window.__reframe.init(sceneIr, imageAssets, vAssets),
+      [ir, assets, videoAssets]
     );
-    const fps = opts.fps ?? info.fps;
-    const duration = opts.duration ?? info.duration;
     const frameCount = Math.max(1, Math.round(duration * fps));
     for (let f = 0; f < frameCount; f++) {
       const dataUrl = await page.evaluate((t) => window.__reframe.renderFrame(t), f / fps);
@@ -1651,25 +1749,25 @@ async function captureHtml(htmlPath, opts) {
 }
 
 // ../render-cli/src/composition.ts
-function runFfmpeg(args) {
-  return new Promise((resolve5, reject) => {
-    const proc = spawn3("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+function runFfmpeg2(args) {
+  return new Promise((resolve6, 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 ? resolve5() : reject(new Error(`ffmpeg exited ${code}:
+    proc.on("close", (code) => code === 0 ? resolve6() : 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 mkdtemp2(join5(tmpdir3(), "reframe-frames-"));
+  const framesDir = await mkdtemp3(join6(tmpdir4(), "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 rm2(framesDir, { recursive: true, force: true });
+    await rm3(framesDir, { recursive: true, force: true });
   }
 }
 async function renderStandaloneScene(scene, sceneDir, fps, noAudio, out) {
@@ -1677,8 +1775,8 @@ async function renderStandaloneScene(scene, sceneDir, fps, noAudio, out) {
   if (plan) {
     const videoOut = `${out}.video.mp4`;
     await renderSceneVideo(scene, sceneDir, fps, videoOut);
-    await buildAudioTrack(plan, join5(sceneDir, "scene"), videoOut, out);
-    await rm2(videoOut, { force: true });
+    await buildAudioTrack(plan, join6(sceneDir, "scene"), videoOut, out);
+    await rm3(videoOut, { force: true });
   } else {
     await renderSceneVideo(scene, sceneDir, fps, out);
   }
@@ -1690,10 +1788,10 @@ async function concatVideos(files, out) {
   }
   const list = `${out}.concat.txt`;
   await writeFile4(list, files.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n"));
-  await runFfmpeg(["-y", "-f", "concat", "-safe", "0", "-i", list, "-c", "copy", "-movflags", "+faststart", out]);
+  await runFfmpeg2(["-y", "-f", "concat", "-safe", "0", "-i", list, "-c", "copy", "-movflags", "+faststart", out]);
 }
 async function xfade2(a, b, overlap, offset, out) {
-  await runFfmpeg([
+  await runFfmpeg2([
     "-y",
     "-i",
     a,
@@ -1721,7 +1819,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 = join5(tmp, `step${i}.mp4`);
+    const step = join6(tmp, `step${i}.mp4`);
     if (overlap <= 0) {
       await concatVideos([acc, videos[i].file], step);
       accDur += duration;
@@ -1743,15 +1841,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 mkdtemp2(join5(tmpdir3(), "reframe-comp-"));
+  const tmp = await mkdtemp3(join6(tmpdir4(), "reframe-comp-"));
   try {
     const videos = [];
     for (const p of cc.scenes) {
-      const file = join5(tmp, `${sanitize(p.id)}.mp4`);
+      const file = join6(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 = join5(tmp, "combined.mp4");
+    const combined = join6(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);
@@ -1768,19 +1866,19 @@ async function renderComposition(comp, opts) {
     }
     return { duration: cc.duration, sceneCount: cc.scenes.length };
   } finally {
-    await rm2(tmp, { recursive: true, force: true });
+    await rm3(tmp, { recursive: true, force: true });
   }
 }
 
 // ../render-cli/src/loadScene.ts
 import { build as build2 } from "esbuild";
-import { readFile as readFile3 } from "node:fs/promises";
-import { dirname as dirname6, resolve as resolve3 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname6, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var HERE = dirname6(fileURLToPath4(import.meta.url));
-var CORE_ENTRY = true ? resolve3(HERE, "index.js") : resolve3(HERE, "..", "..", "core", "src", "index.ts");
+var CORE_ENTRY = true ? resolve4(HERE, "index.js") : resolve4(HERE, "..", "..", "core", "src", "index.ts");
 async function loadDefault(path2) {
-  if (path2.endsWith(".json")) return JSON.parse(await readFile3(path2, "utf8"));
+  if (path2.endsWith(".json")) return JSON.parse(await readFile4(path2, "utf8"));
   let code;
   try {
     const out = await build2({
@@ -1828,7 +1926,7 @@ function parseArgs(argv) {
   }
   const args = {
     mode,
-    input: resolve4(input),
+    input: resolve5(input),
     out: `${basename(input).replace(/\.[^.]+$/, "")}.mp4`,
     keepFrames: false,
     overlays: [],
@@ -1840,8 +1938,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 = resolve4(rest[++i]);
-    else if (a === "--overlay") args.overlays.push(resolve4(rest[++i]));
+    else if (a === "--frames-dir") args.framesDir = resolve5(rest[++i]);
+    else if (a === "--overlay") args.overlays.push(resolve5(rest[++i]));
     else if (a === "--no-audio") args.noAudio = true;
     else if (a === "--scene") args.scene = rest[++i];
     else {
@@ -1870,14 +1968,14 @@ async function main() {
     );
     return;
   }
-  const framesDir = args.framesDir ?? await mkdtemp3(join6(tmpdir4(), "reframe-frames-"));
+  const framesDir = args.framesDir ?? await mkdtemp4(join7(tmpdir5(), "reframe-frames-"));
   let result;
   let audioJob = null;
   if (args.mode === "ir") {
     let ir = loaded.ir;
     if (args.overlays.length > 0) {
       const docs = await Promise.all(
-        args.overlays.map(async (p) => JSON.parse(await readFile4(p, "utf8")))
+        args.overlays.map(async (p) => JSON.parse(await readFile5(p, "utf8")))
       );
       const composed = composeScene(ir, ...docs);
       console.error(formatComposeReport(composed.report));
@@ -1909,10 +2007,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 rm3(audioJob.videoOut, { force: true });
+    await rm4(audioJob.videoOut, { force: true });
   }
   if (!args.keepFrames && args.framesDir === void 0) {
-    await rm3(framesDir, { recursive: true, force: true });
+    await rm4(framesDir, { recursive: true, force: true });
   }
   console.log(
     `${args.out} (${result.frameCount} frames @ ${result.fps}fps${audioJob ? `, ${audioJob.plan.cues.length} audio cues` : ""})`