storyforge 0.7.1 → 0.7.2

package/dist/{bridge-poller-NSYYEHB3.js → bridge-poller-Z74DF5GN.js}

@@ -4,7 +4,7 @@ import {
   muxAudio,
   probeDuration,
   runCmd
-} from "./chunk-M6JAFPDI.js";
+} from "./chunk-5SWMYFFS.js";
 import {
   log
 } from "./chunk-GJQ45C5W.js";
@@ -91,18 +91,18 @@ var require_p_limit = __commonJS({
           queue.dequeue()();
         }
       };
-      const run = async (fn, resolve7, ...args) => {
+      const run = async (fn, resolve3, ...args) => {
         activeCount++;
         const result = (async () => fn(...args))();
-        resolve7(result);
+        resolve3(result);
         try {
           await result;
         } catch {
         }
         next();
       };
-      const enqueue = (fn, resolve7, ...args) => {
-        queue.enqueue(run.bind(null, fn, resolve7, ...args));
+      const enqueue = (fn, resolve3, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve3, ...args));
         (async () => {
           await Promise.resolve();
           if (activeCount < concurrency && queue.size > 0) {
@@ -110,8 +110,8 @@ var require_p_limit = __commonJS({
           }
         })();
       };
-      const generator = (fn, ...args) => new Promise((resolve7) => {
-        enqueue(fn, resolve7, ...args);
+      const generator = (fn, ...args) => new Promise((resolve3) => {
+        enqueue(fn, resolve3, ...args);
       });
       Object.defineProperties(generator, {
         activeCount: {
@@ -135,11 +135,11 @@ var require_p_limit = __commonJS({
 // src/bridge-poller.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import * as crypto from "crypto";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 // ../pipeline/src/clip-render/render-chunk.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -619,8 +619,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path10, errorMaps, issueData } = params;
-  const fullPath = [...path10, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -736,11 +736,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path10, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path10;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -5353,16 +5353,65 @@ function nextFallback(engine) {
 var DEFAULT_RENDER_CONCURRENCY = 4;
 
 // ../pipeline/src/clip-render/engines/gemini-manim-remotion.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
-// ../pipeline/src/clip-render/engines/manim.ts
+// ../pipeline/src/clip-render/remotion-root.ts
 import * as fs from "fs";
 import * as path from "path";
+var MAX_PARENTS = 8;
+function findRemotionRoot(startDir = process.cwd()) {
+  const envRoot = process.env.FORGE_REMOTION_ROOT;
+  if (envRoot && envRoot.trim().length > 0) {
+    const abs = path.resolve(envRoot);
+    const entry = path.join(abs, "src", "Root.tsx");
+    if (fs.existsSync(entry)) {
+      return { cwd: abs, entry, source: "env" };
+    }
+  }
+  let cur = path.resolve(startDir);
+  for (let i = 0; i <= MAX_PARENTS; i++) {
+    const candidate = path.join(cur, "packages", "remotion", "src", "Root.tsx");
+    if (fs.existsSync(candidate)) {
+      const cwd = path.dirname(path.dirname(candidate));
+      return { cwd, entry: candidate, source: "monorepo-walk" };
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  cur = path.resolve(startDir);
+  for (let i = 0; i <= MAX_PARENTS; i++) {
+    const candidate = path.join(cur, "node_modules", "@forge", "remotion", "dist", "Root.js");
+    if (fs.existsSync(candidate)) {
+      const cwd = path.dirname(path.dirname(candidate));
+      return { cwd, entry: candidate, source: "node_modules" };
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function requireRemotionRoot(startDir = process.cwd()) {
+  const root = findRemotionRoot(startDir);
+  if (root) return root;
+  throw new Error(
+    `clip-render: cannot locate a Remotion project root.
+Searched from ${startDir} up ${MAX_PARENTS} levels for both:
+  - packages/remotion/src/Root.tsx (monorepo dev)
+  - node_modules/@forge/remotion/dist/Root.js (published)
+Set FORGE_REMOTION_ROOT to override, or run storyforge from a path inside the forge monorepo.`
+  );
+}
+
+// ../pipeline/src/clip-render/engines/manim.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 function findMp4(dir) {
-  if (!fs.existsSync(dir)) return null;
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
+  if (!fs2.existsSync(dir)) return null;
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const full = path2.join(dir, entry.name);
     if (entry.isDirectory()) {
       const f = findMp4(full);
       if (f) return f;
@@ -5377,11 +5426,11 @@ var renderManim = async (shot, ctx) => {
     throw new Error(`manim engine requires shot.manimCode for shot ${shot.id}`);
   }
   if (ctx.signal?.aborted) throw new Error("aborted");
-  const manimWorkDir = path.join(ctx.tmpDir, "manim", shot.id);
-  fs.mkdirSync(manimWorkDir, { recursive: true });
-  const scriptPath = path.join(manimWorkDir, `${shot.id}.py`);
-  const mediaDir = path.join(manimWorkDir, "media");
-  fs.writeFileSync(scriptPath, shot.manimCode);
+  const manimWorkDir = path2.join(ctx.tmpDir, "manim", shot.id);
+  fs2.mkdirSync(manimWorkDir, { recursive: true });
+  const scriptPath = path2.join(manimWorkDir, `${shot.id}.py`);
+  const mediaDir = path2.join(manimWorkDir, "media");
+  fs2.writeFileSync(scriptPath, shot.manimCode);
   ctx.progress.emit({ phase: "rendering", shotId: shot.id });
   const r = await runCmd(
     "python3",
@@ -5403,9 +5452,9 @@ var renderManim = async (shot, ctx) => {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
     throw new Error(`manim render failed (code ${r.code}): ${tail}`);
   }
-  const mp4 = findMp4(path.join(mediaDir, "videos"));
+  const mp4 = findMp4(path2.join(mediaDir, "videos"));
   if (!mp4) throw new Error("manim produced no MP4 output");
-  fs.copyFileSync(mp4, ctx.sceneOutPath);
+  fs2.copyFileSync(mp4, ctx.sceneOutPath);
 };
 
 // ../pipeline/src/clip-render/engines/gemini-manim-remotion.ts
@@ -5418,13 +5467,13 @@ async function resolveImageToLocal(imagePath, cacheDir, shotId, signal) {
       );
     }
     const buf = Buffer.from(await resp.arrayBuffer());
-    fs2.mkdirSync(cacheDir, { recursive: true });
-    const ext = path2.extname(new URL(imagePath).pathname) || ".png";
-    const local = path2.join(cacheDir, `${shotId}_bg${ext}`);
-    fs2.writeFileSync(local, buf);
+    fs3.mkdirSync(cacheDir, { recursive: true });
+    const ext = path3.extname(new URL(imagePath).pathname) || ".png";
+    const local = path3.join(cacheDir, `${shotId}_bg${ext}`);
+    fs3.writeFileSync(local, buf);
     return local;
   }
-  if (!fs2.existsSync(imagePath)) {
+  if (!fs3.existsSync(imagePath)) {
     throw new Error(`gemini+manim+remotion: imagePath does not exist: ${imagePath}`);
   }
   return imagePath;
@@ -5440,12 +5489,12 @@ var renderGeminiManimRemotion = async (shot, ctx) => {
   ctx.progress.emit({ phase: "preparing", shotId: shot.id });
   const localImage = await resolveImageToLocal(
     shot.imagePath,
-    path2.join(ctx.tmpDir, "remotion", "images"),
+    path3.join(ctx.tmpDir, "remotion", "images"),
     shot.id,
     ctx.signal
   );
-  const manimSceneOut = path2.join(ctx.tmpDir, "manim", `${shot.id}_manim.mp4`);
-  fs2.mkdirSync(path2.dirname(manimSceneOut), { recursive: true });
+  const manimSceneOut = path3.join(ctx.tmpDir, "manim", `${shot.id}_manim.mp4`);
+  fs3.mkdirSync(path3.dirname(manimSceneOut), { recursive: true });
   ctx.progress.emit({ phase: "rendering", shotId: shot.id });
   await renderManim(shot, { ...ctx, sceneOutPath: manimSceneOut });
   const manimDurationSec = await probeDuration(manimSceneOut) ?? 7;
@@ -5453,9 +5502,9 @@ var renderGeminiManimRemotion = async (shot, ctx) => {
   const totalFrames = Math.max(1, Math.round(shot.durationSec * ctx.fps));
   if (ctx.signal?.aborted) throw new Error("aborted");
   ctx.progress.emit({ phase: "compositing", shotId: shot.id });
-  const propsPath = path2.join(ctx.tmpDir, "remotion", `${shot.id}_gmr_props.json`);
-  fs2.mkdirSync(path2.dirname(propsPath), { recursive: true });
-  fs2.writeFileSync(
+  const propsPath = path3.join(ctx.tmpDir, "remotion", `${shot.id}_gmr_props.json`);
+  fs3.mkdirSync(path3.dirname(propsPath), { recursive: true });
+  fs3.writeFileSync(
     propsPath,
     JSON.stringify(
       {
@@ -5470,14 +5519,14 @@ var renderGeminiManimRemotion = async (shot, ctx) => {
       2
     )
   );
-  const entryArg = path2.resolve(process.cwd(), "packages/remotion/src/Root.tsx");
+  const remotion = requireRemotionRoot();
   const compId = ctx.aspect === "9:16" ? "ForgeVideoVertical" : "ForgeVideo";
   const r = await runCmd(
     "npx",
     [
       "remotion",
       "render",
-      entryArg,
+      remotion.entry,
       compId,
       "--props",
       propsPath,
@@ -5486,11 +5535,11 @@ var renderGeminiManimRemotion = async (shot, ctx) => {
       "--concurrency",
       "4"
     ],
-    { timeoutMs: 3e5, signal: ctx.signal }
+    { timeoutMs: 3e5, signal: ctx.signal, cwd: remotion.cwd }
   );
   if (r.code !== 0) {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
-    fs2.copyFileSync(manimSceneOut, ctx.sceneOutPath);
+    fs3.copyFileSync(manimSceneOut, ctx.sceneOutPath);
     ctx.progress.emit({
       phase: "compositing",
       shotId: shot.id,
@@ -5500,8 +5549,8 @@ var renderGeminiManimRemotion = async (shot, ctx) => {
 };
 
 // ../pipeline/src/clip-render/engines/gemini-remotion.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var ASPECT_DIMS = {
   "16:9": { width: 1920, height: 1080 },
   "9:16": { width: 1080, height: 1920 }
@@ -5513,13 +5562,13 @@ async function resolveImageToLocal2(imagePath, cacheDir, shotId, signal) {
       throw new Error(`gemini+remotion: image fetch failed ${resp.status} for ${imagePath}`);
     }
     const buf = Buffer.from(await resp.arrayBuffer());
-    fs3.mkdirSync(cacheDir, { recursive: true });
-    const ext = path3.extname(new URL(imagePath).pathname) || ".png";
-    const local = path3.join(cacheDir, `${shotId}_bg${ext}`);
-    fs3.writeFileSync(local, buf);
+    fs4.mkdirSync(cacheDir, { recursive: true });
+    const ext = path4.extname(new URL(imagePath).pathname) || ".png";
+    const local = path4.join(cacheDir, `${shotId}_bg${ext}`);
+    fs4.writeFileSync(local, buf);
     return local;
   }
-  if (!fs3.existsSync(imagePath)) {
+  if (!fs4.existsSync(imagePath)) {
     throw new Error(`gemini+remotion: imagePath does not exist: ${imagePath}`);
   }
   return imagePath;
@@ -5532,15 +5581,15 @@ var renderGeminiRemotion = async (shot, ctx) => {
   ctx.progress.emit({ phase: "preparing", shotId: shot.id });
   const localImage = await resolveImageToLocal2(
     shot.imagePath,
-    path3.join(ctx.tmpDir, "remotion", "images"),
+    path4.join(ctx.tmpDir, "remotion", "images"),
     shot.id,
     ctx.signal
   );
   const durationFrames = Math.max(1, Math.round(shot.durationSec * ctx.fps));
   const dims = ASPECT_DIMS[ctx.aspect];
-  const propsPath = path3.join(ctx.tmpDir, "remotion", `${shot.id}_gr_props.json`);
-  fs3.mkdirSync(path3.dirname(propsPath), { recursive: true });
-  fs3.writeFileSync(
+  const propsPath = path4.join(ctx.tmpDir, "remotion", `${shot.id}_gr_props.json`);
+  fs4.mkdirSync(path4.dirname(propsPath), { recursive: true });
+  fs4.writeFileSync(
     propsPath,
     JSON.stringify(
       {
@@ -5556,7 +5605,7 @@ var renderGeminiRemotion = async (shot, ctx) => {
       2
     )
   );
-  const entryArg = path3.resolve(process.cwd(), "packages/remotion/src/Root.tsx");
+  const remotion = requireRemotionRoot();
   const compId = ctx.aspect === "9:16" ? "ForgeVideoVertical" : "ForgeVideo";
   ctx.progress.emit({
     phase: "compositing",
@@ -5569,7 +5618,7 @@ var renderGeminiRemotion = async (shot, ctx) => {
     [
       "remotion",
       "render",
-      entryArg,
+      remotion.entry,
       compId,
       "--props",
       propsPath,
@@ -5578,7 +5627,7 @@ var renderGeminiRemotion = async (shot, ctx) => {
       "--concurrency",
       "4"
     ],
-    { timeoutMs: 3e5, signal: ctx.signal }
+    { timeoutMs: 3e5, signal: ctx.signal, cwd: remotion.cwd }
   );
   if (r.code !== 0) {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
@@ -5595,7 +5644,7 @@ var renderGeminiRemotion = async (shot, ctx) => {
 // ../pipeline/src/clip-render/engines/hyperframes.ts
 import { mkdir, writeFile } from "fs/promises";
 import { spawn } from "child_process";
-import path4 from "path";
+import path5 from "path";
 
 // ../pipeline/src/clip-render/engines/hyperframes-template.ts
 function dimensionsForAspect(aspect) {
@@ -5671,10 +5720,10 @@ var HyperFramesNotInstalledError = class extends Error {
   }
 };
 async function defaultHyperframesAvailable() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve3) => {
     const proc = spawn("which", ["hyperframes"], { stdio: ["ignore", "pipe", "pipe"] });
-    proc.on("close", (code) => resolve7(code === 0));
-    proc.on("error", () => resolve7(false));
+    proc.on("close", (code) => resolve3(code === 0));
+    proc.on("error", () => resolve3(false));
   });
 }
 async function defaultRunHyperframes(htmlPath, outputMp4, fps, onStdoutLine) {
@@ -5682,7 +5731,7 @@ async function defaultRunHyperframes(htmlPath, outputMp4, fps, onStdoutLine) {
   await runProcess("npx", args, onStdoutLine);
 }
 function runProcess(cmd, args, onLine) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     let proc;
     try {
       proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -5707,7 +5756,7 @@ function runProcess(cmd, args, onLine) {
     });
     proc.on("error", reject);
     proc.on("close", (code) => {
-      if (code === 0) resolve7();
+      if (code === 0) resolve3();
       else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}
 ${stderrTail}`));
     });
@@ -5742,9 +5791,9 @@ var renderHyperframes = async (shot, ctx) => {
     throw new HyperFramesNotInstalledError();
   }
   const html = resolveShotHtml(shot, ctx.aspect);
-  const htmlDir = path4.join(ctx.tmpDir, "hyperframes");
+  const htmlDir = path5.join(ctx.tmpDir, "hyperframes");
   await mkdir(htmlDir, { recursive: true });
-  const htmlPath = path4.join(htmlDir, `shot-${shot.id}.html`);
+  const htmlPath = path5.join(htmlDir, `shot-${shot.id}.html`);
   await writeFile(htmlPath, html, "utf8");
   ctx.progress.emit({
     phase: "rendering",
@@ -5766,12 +5815,12 @@ var renderHyperframes = async (shot, ctx) => {
 };
 
 // ../pipeline/src/clip-render/engines/manim-remotion.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 var renderManimRemotion = async (shot, ctx) => {
   if (ctx.signal?.aborted) throw new Error("aborted");
-  const manimSceneOut = path5.join(ctx.tmpDir, "manim", `${shot.id}_manim.mp4`);
-  fs4.mkdirSync(path5.dirname(manimSceneOut), { recursive: true });
+  const manimSceneOut = path6.join(ctx.tmpDir, "manim", `${shot.id}_manim.mp4`);
+  fs5.mkdirSync(path6.dirname(manimSceneOut), { recursive: true });
   const manimCtx = { ...ctx, sceneOutPath: manimSceneOut };
   ctx.progress.emit({ phase: "rendering", shotId: shot.id });
   await renderManim(shot, manimCtx);
@@ -5780,9 +5829,9 @@ var renderManimRemotion = async (shot, ctx) => {
   const totalFrames = Math.max(1, Math.round(shot.durationSec * ctx.fps));
   if (ctx.signal?.aborted) throw new Error("aborted");
   ctx.progress.emit({ phase: "compositing", shotId: shot.id });
-  const propsPath = path5.join(ctx.tmpDir, "remotion", `${shot.id}_mr_props.json`);
-  fs4.mkdirSync(path5.dirname(propsPath), { recursive: true });
-  fs4.writeFileSync(
+  const propsPath = path6.join(ctx.tmpDir, "remotion", `${shot.id}_mr_props.json`);
+  fs5.mkdirSync(path6.dirname(propsPath), { recursive: true });
+  fs5.writeFileSync(
     propsPath,
     JSON.stringify(
       {
@@ -5796,14 +5845,14 @@ var renderManimRemotion = async (shot, ctx) => {
       2
     )
   );
-  const entryArg = path5.resolve(process.cwd(), "packages/remotion/src/Root.tsx");
+  const remotion = requireRemotionRoot();
   const compId = ctx.aspect === "9:16" ? "ForgeVideoVertical" : "ForgeVideo";
   const r = await runCmd(
     "npx",
     [
       "remotion",
       "render",
-      entryArg,
+      remotion.entry,
       compId,
       "--props",
       propsPath,
@@ -5812,11 +5861,11 @@ var renderManimRemotion = async (shot, ctx) => {
       "--concurrency",
       "4"
     ],
-    { timeoutMs: 3e5, signal: ctx.signal }
+    { timeoutMs: 3e5, signal: ctx.signal, cwd: remotion.cwd }
   );
   if (r.code !== 0) {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
-    fs4.copyFileSync(manimSceneOut, ctx.sceneOutPath);
+    fs5.copyFileSync(manimSceneOut, ctx.sceneOutPath);
     ctx.progress.emit({
       phase: "compositing",
       shotId: shot.id,
@@ -5827,18 +5876,18 @@ var renderManimRemotion = async (shot, ctx) => {
 };
 
 // ../pipeline/src/clip-render/engines/remotion.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 var ASPECT_DIMS2 = {
   "16:9": { width: 1920, height: 1080 },
   "9:16": { width: 1080, height: 1920 }
 };
 function writeEntryForInlineTsx(ctx, shotId, durationFrames) {
   const dims = ASPECT_DIMS2[ctx.aspect];
-  const dir = path6.join(ctx.tmpDir, "remotion", shotId);
-  fs5.mkdirSync(dir, { recursive: true });
-  const componentPath = path6.join(dir, `${shotId}.tsx`);
-  const entryPath = path6.join(dir, `${shotId}_entry.tsx`);
+  const dir = path7.join(ctx.tmpDir, "remotion", shotId);
+  fs6.mkdirSync(dir, { recursive: true });
+  const componentPath = path7.join(dir, `${shotId}.tsx`);
+  const entryPath = path7.join(dir, `${shotId}_entry.tsx`);
   const compId = "GeneratedChunk";
   const entry = `import { registerRoot } from 'remotion';
 import React from 'react';
@@ -5859,7 +5908,7 @@ const Root: React.FC = () => (
 
 registerRoot(Root);
 `;
-  fs5.writeFileSync(entryPath, entry);
+  fs6.writeFileSync(entryPath, entry);
   return { entryPath, componentPath, compId };
 }
 var renderRemotion = async (shot, ctx) => {
@@ -5867,22 +5916,26 @@ var renderRemotion = async (shot, ctx) => {
   const durationFrames = Math.max(1, Math.round(shot.durationSec * ctx.fps));
   let entryArg;
   let compId;
+  let remotionCwd;
   if (shot.remotionTsx && shot.remotionTsx.trim().length > 0) {
     const { entryPath, componentPath, compId: id } = writeEntryForInlineTsx(
       ctx,
       shot.id,
       durationFrames
     );
-    fs5.writeFileSync(componentPath, shot.remotionTsx);
+    fs6.writeFileSync(componentPath, shot.remotionTsx);
     entryArg = entryPath;
     compId = id;
+    remotionCwd = requireRemotionRoot().cwd;
   } else {
-    entryArg = path6.resolve(process.cwd(), "packages/remotion/src/Root.tsx");
+    const remotion = requireRemotionRoot();
+    entryArg = remotion.entry;
     compId = ctx.aspect === "9:16" ? "ForgeVideoVertical" : "ForgeVideo";
+    remotionCwd = remotion.cwd;
   }
-  const propsPath = path6.join(ctx.tmpDir, "remotion", `${shot.id}_props.json`);
-  fs5.mkdirSync(path6.dirname(propsPath), { recursive: true });
-  fs5.writeFileSync(
+  const propsPath = path7.join(ctx.tmpDir, "remotion", `${shot.id}_props.json`);
+  fs6.mkdirSync(path7.dirname(propsPath), { recursive: true });
+  fs6.writeFileSync(
     propsPath,
     JSON.stringify(
       {
@@ -5914,7 +5967,7 @@ var renderRemotion = async (shot, ctx) => {
       "--concurrency",
       "4"
     ],
-    { timeoutMs: 3e5, signal: ctx.signal }
+    { timeoutMs: 3e5, signal: ctx.signal, cwd: remotionCwd }
   );
   if (r.code !== 0) {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
@@ -5934,8 +5987,8 @@ var renderRemotionHtmlCanvas = async () => {
 };
 
 // ../pipeline/src/clip-render/engines/stock-remotion.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 async function searchAndDownloadPexels(query, desiredDuration, outputPath, signal) {
   const apiKey = process.env.PEXELS_API_KEY;
   if (!apiKey) throw new Error("stock+remotion: PEXELS_API_KEY not set");
@@ -5963,8 +6016,8 @@ async function searchAndDownloadPexels(query, desiredDuration, outputPath, signa
     throw new Error(`stock+remotion: Pexels download failed ${videoResp.status}`);
   }
   const buf = Buffer.from(await videoResp.arrayBuffer());
-  fs6.mkdirSync(path7.dirname(outputPath), { recursive: true });
-  fs6.writeFileSync(outputPath, buf);
+  fs7.mkdirSync(path8.dirname(outputPath), { recursive: true });
+  fs7.writeFileSync(outputPath, buf);
 }
 var renderStockRemotion = async (shot, ctx) => {
   if (ctx.signal?.aborted) throw new Error("aborted");
@@ -5973,13 +6026,13 @@ var renderStockRemotion = async (shot, ctx) => {
     throw new Error(`stock+remotion requires shot.prompt or intent for shot ${shot.id}`);
   }
   ctx.progress.emit({ phase: "preparing", shotId: shot.id });
-  const stockPath = path7.join(ctx.tmpDir, "remotion", `${shot.id}_stock.mp4`);
+  const stockPath = path8.join(ctx.tmpDir, "remotion", `${shot.id}_stock.mp4`);
   await searchAndDownloadPexels(query, shot.durationSec, stockPath, ctx.signal);
   if (ctx.signal?.aborted) throw new Error("aborted");
   ctx.progress.emit({ phase: "compositing", shotId: shot.id });
   const totalFrames = Math.max(1, Math.round(shot.durationSec * ctx.fps));
-  const propsPath = path7.join(ctx.tmpDir, "remotion", `${shot.id}_stock_props.json`);
-  fs6.writeFileSync(
+  const propsPath = path8.join(ctx.tmpDir, "remotion", `${shot.id}_stock_props.json`);
+  fs7.writeFileSync(
     propsPath,
     JSON.stringify(
       {
@@ -5992,14 +6045,14 @@ var renderStockRemotion = async (shot, ctx) => {
       2
     )
   );
-  const entryArg = path7.resolve(process.cwd(), "packages/remotion/src/Root.tsx");
+  const remotion = requireRemotionRoot();
   const compId = ctx.aspect === "9:16" ? "ForgeVideoVertical" : "ForgeVideo";
   const r = await runCmd(
     "npx",
     [
       "remotion",
       "render",
-      entryArg,
+      remotion.entry,
       compId,
       "--props",
       propsPath,
@@ -6008,11 +6061,11 @@ var renderStockRemotion = async (shot, ctx) => {
       "--concurrency",
       "4"
     ],
-    { timeoutMs: 3e5, signal: ctx.signal }
+    { timeoutMs: 3e5, signal: ctx.signal, cwd: remotion.cwd }
   );
   if (r.code !== 0) {
     const tail = r.stderr.split("\n").slice(-5).join(" ").slice(0, 300);
-    fs6.copyFileSync(stockPath, ctx.sceneOutPath);
+    fs7.copyFileSync(stockPath, ctx.sceneOutPath);
     ctx.progress.emit({
       phase: "compositing",
       shotId: shot.id,
@@ -6042,11 +6095,11 @@ function isManimEngine(engine) {
 }
 
 // ../pipeline/src/clip-render/fs-layout.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function resolveProjectRoot(projectSlug, callerOutputDir) {
   if (callerOutputDir && callerOutputDir.length > 0) {
-    if (!path8.isAbsolute(callerOutputDir)) {
+    if (!path9.isAbsolute(callerOutputDir)) {
       throw new Error(
         `clip-render: spec.outputDir must be absolute, got "${callerOutputDir}"`
       );
@@ -6056,41 +6109,41 @@ function resolveProjectRoot(projectSlug, callerOutputDir) {
   if (!projectSlug || /[/\\]/.test(projectSlug)) {
     throw new Error(`clip-render: invalid projectSlug "${projectSlug}"`);
   }
-  return path8.resolve(process.cwd(), "forge-renders", projectSlug);
+  return path9.resolve(process.cwd(), "forge-renders", projectSlug);
 }
 function chunkPaths(projectSlug, chunkId, callerOutputDir) {
   if (!chunkId || /[/\\]/.test(chunkId)) {
     throw new Error(`clip-render: invalid chunkId "${chunkId}"`);
   }
   const root = resolveProjectRoot(projectSlug, callerOutputDir);
-  const tmpDir = path8.join(root, ".tmp", chunkId);
+  const tmpDir = path9.join(root, ".tmp", chunkId);
   return {
     root,
-    finalClipPath: path8.join(root, "clips", `${chunkId}.mp4`),
+    finalClipPath: path9.join(root, "clips", `${chunkId}.mp4`),
     tmpDir,
-    scenesDir: path8.join(tmpDir, "scenes"),
-    manimDir: path8.join(tmpDir, "manim"),
-    remotionDir: path8.join(tmpDir, "remotion"),
-    hyperframesDir: path8.join(tmpDir, "hyperframes"),
-    progressLogPath: path8.join(root, "progress.json")
+    scenesDir: path9.join(tmpDir, "scenes"),
+    manimDir: path9.join(tmpDir, "manim"),
+    remotionDir: path9.join(tmpDir, "remotion"),
+    hyperframesDir: path9.join(tmpDir, "hyperframes"),
+    progressLogPath: path9.join(root, "progress.json")
   };
 }
 function ensureChunkDirs(paths) {
   for (const dir of [
-    path8.dirname(paths.finalClipPath),
+    path9.dirname(paths.finalClipPath),
     paths.tmpDir,
     paths.scenesDir,
     paths.manimDir,
     paths.remotionDir,
     paths.hyperframesDir
   ]) {
-    fs7.mkdirSync(dir, { recursive: true });
+    fs8.mkdirSync(dir, { recursive: true });
   }
 }
 function appendProgress(progressLogPath, event) {
   try {
-    fs7.mkdirSync(path8.dirname(progressLogPath), { recursive: true });
-    fs7.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
+    fs8.mkdirSync(path9.dirname(progressLogPath), { recursive: true });
+    fs8.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -6193,10 +6246,10 @@ async function renderChunk(spec, opts = {}) {
       await renderWithEngine(spec, engine, paths, fps, tracker, opts);
       tracker.emit({ phase: "compositing", percent: 85 });
       const scenePaths = spec.shots.map((s) => sceneOutPath(paths, s));
-      const concatTarget = path9.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
+      const concatTarget = path10.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
       await concatScenes(scenePaths, concatTarget, { signal: opts.signal });
       if (opts.signal?.aborted) throw new Error("aborted");
-      const audioAvailable = !!spec.audioPath && fs8.existsSync(spec.audioPath);
+      const audioAvailable = !!spec.audioPath && fs9.existsSync(spec.audioPath);
       if (audioAvailable) {
         tracker.emit({ phase: "muxing", percent: 95 });
         await muxAudio(concatTarget, spec.audioPath, paths.finalClipPath, {
@@ -6208,7 +6261,7 @@ async function renderChunk(spec, opts = {}) {
         } else {
           warnings.push("no audioPath in spec \u2014 wrote silent clip");
         }
-        fs8.copyFileSync(concatTarget, paths.finalClipPath);
+        fs9.copyFileSync(concatTarget, paths.finalClipPath);
       }
       tracker.emit({ phase: "done", percent: 100 });
       const renderTimeMs2 = (opts.now ?? Date.now)() - startedAt;
@@ -6247,7 +6300,7 @@ async function renderChunk(spec, opts = {}) {
   };
 }
 function sceneOutPath(paths, shot) {
-  return path9.join(paths.scenesDir, `${shot.id}.mp4`);
+  return path10.join(paths.scenesDir, `${shot.id}.mp4`);
 }
 function abortedResult(spec, engine, fallbackDepth, startedAt, now) {
   return {
@@ -6280,7 +6333,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
       progress: tracker,
       resolvedEngine: engine
     };
-    fs8.mkdirSync(path9.dirname(ctx.sceneOutPath), { recursive: true });
+    fs9.mkdirSync(path10.dirname(ctx.sceneOutPath), { recursive: true });
     const release = opts.acquireManimSlot ? await opts.acquireManimSlot() : void 0;
     try {
       tracker.emit({
@@ -6292,7 +6345,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
     } finally {
       release?.();
     }
-    if (!fs8.existsSync(ctx.sceneOutPath)) {
+    if (!fs9.existsSync(ctx.sceneOutPath)) {
       throw new Error(
         `engine ${engine} produced no output at ${ctx.sceneOutPath} for shot ${shot.id}`
       );
@@ -6476,8 +6529,8 @@ var BridgePoller = class {
     if (!/^[a-z][a-z0-9-]*$/i.test(name)) return { available: false, path: null };
     const r = spawnSync("which", [name], { encoding: "utf-8", timeout: 2e3 });
     if (r.status !== 0) return { available: false, path: null };
-    const path10 = (r.stdout ?? "").trim();
-    return { available: !!path10, path: path10 || null };
+    const path11 = (r.stdout ?? "").trim();
+    return { available: !!path11, path: path11 || null };
   }
   async heartbeat() {
     if (this.stopped) return;
@@ -6745,16 +6798,16 @@ var BridgePoller = class {
   async invokeStitchFinal(jobId, payload) {
     let stitchFinalVideo;
     try {
-      const mod = await import("./stitch-7XB7ZA4D.js");
+      const mod = await import("./stitch-BYQJTBWS.js");
       stitchFinalVideo = mod.stitchFinalVideo;
     } catch (err) {
       return {
         error: `stitch-final job requires @forge/pipeline/stitch (not installed): ${err.message}`
       };
     }
-    const path10 = await import("path");
-    const projectRoot = path10.resolve(process.cwd(), "forge-renders", payload.projectSlug);
-    const clipsDir = path10.join(projectRoot, "clips");
+    const path11 = await import("path");
+    const projectRoot = path11.resolve(process.cwd(), "forge-renders", payload.projectSlug);
+    const clipsDir = path11.join(projectRoot, "clips");
     const publish = async (phase, eventPayload) => {
       try {
         await fetch(`${this.baseUrl}/api/cli-bridge/stitch-event`, {
@@ -6780,7 +6833,7 @@ var BridgePoller = class {
         projectSlug: payload.projectSlug,
         clipsDir,
         chunkOrder: payload.chunkOrder ?? [],
-        masterAudioPath: path10.isAbsolute(masterAudioRel) ? masterAudioRel : path10.join(projectRoot, masterAudioRel),
+        masterAudioPath: path11.isAbsolute(masterAudioRel) ? masterAudioRel : path11.join(projectRoot, masterAudioRel),
         outputDir: projectRoot,
         aspect: payload.aspect,
         skipTransitions: payload.skipTransitions,
@@ -6964,10 +7017,10 @@ function collectImagesFromCodexStdout(stdout, maxCount) {
   for (const p of paths) {
     if (images.length >= maxCount) break;
     try {
-      const stat = fs9.statSync(p);
+      const stat = fs10.statSync(p);
       if (!stat.isFile() || stat.size <= 0) continue;
       images.push({
-        base64: fs9.readFileSync(p).toString("base64"),
+        base64: fs10.readFileSync(p).toString("base64"),
         mimeType: mimeTypeForPath(p),
         model: "codex-cli:imagegen"
       });
@@ -6999,7 +7052,7 @@ function mimeTypeForPath(p) {
   return "image/png";
 }
 function runSpawn(cmd, args, stdin, timeoutMs, onSpawn) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     const proc = spawn2(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
     if (onSpawn) {
       try {
@@ -7033,7 +7086,7 @@ function runSpawn(cmd, args, stdin, timeoutMs, onSpawn) {
         return;
       }
       if (code !== 0) reject(new Error(`${cmd} exit ${code}: ${stderr.slice(-300)}`));
-      else resolve7(stdout);
+      else resolve3(stdout);
     });
     proc.stdin.end(stdin);
   });

package/dist/{chunk-M6JAFPDI.js → chunk-5SWMYFFS.js}

@@ -4,8 +4,8 @@
 import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
-var defaultRunner = (cmd, args, { timeoutMs = 3e5, signal }) => new Promise((resolve, reject) => {
-  const child = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
+var defaultRunner = (cmd, args, { timeoutMs = 3e5, signal, cwd }) => new Promise((resolve, reject) => {
+  const child = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"], cwd });
   let stdout = "";
   let stderr = "";
   let timer;

package/dist/index.js

@@ -1615,7 +1615,7 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
         return "0.0.0";
       })();
       void (async () => {
-        const { BridgePoller } = await import("./bridge-poller-NSYYEHB3.js");
+        const { BridgePoller } = await import("./bridge-poller-Z74DF5GN.js");
         const poller = new BridgePoller({ baseUrl: bridgeUrl, token: bridgeToken, clientVersion: `storyforge ${pkgVersion}` });
         poller.start();
       })();
@@ -1992,7 +1992,7 @@ async function installRenderersCommand(opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.7.1";
+var VERSION = "0.7.2";
 var HELP = `
 storyforge \u2014 local bridge for the Forge video production web app
 

package/dist/{stitch-7XB7ZA4D.js → stitch-BYQJTBWS.js}

@@ -5,7 +5,7 @@ import {
   buildNormalizeClipArgs,
   probeDuration,
   runCmd
-} from "./chunk-M6JAFPDI.js";
+} from "./chunk-5SWMYFFS.js";
 import "./chunk-NSPRIPOP.js";
 
 // ../pipeline/src/stitch/stitch-final.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "StoryForge — local bridge for the Forge video production web app. Parallel clip-render orchestrator (Remotion 4 + Manim + HyperFrames + ffmpeg) + final video stitcher + dependency doctor.",
   "type": "module",
   "bin": {