storyforge 0.8.0 → 0.9.0

package/dist/{bridge-poller-HA7G7ILD.js → bridge-poller-DNGPP5MA.js}

@@ -135,10 +135,10 @@ var require_p_limit = __commonJS({
 // src/bridge-poller.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import * as crypto from "crypto";
-import * as fs11 from "fs";
+import * as fs15 from "fs";
 
 // ../pipeline/src/clip-render/render-chunk.ts
-import * as fs10 from "fs";
+import * as fs13 from "fs";
 import * as path11 from "path";
 
 // ../../node_modules/zod/v3/external.js
@@ -619,8 +619,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...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, path12, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -5999,11 +5999,11 @@ var renderRemotionHtmlCanvas = async () => {
 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");
+  const apiKey2 = process.env.PEXELS_API_KEY;
+  if (!apiKey2) throw new Error("stock+remotion: PEXELS_API_KEY not set");
   const url = `https://api.pexels.com/videos/search?query=${encodeURIComponent(query)}&per_page=5&size=medium`;
   const resp = await fetch(url, {
-    headers: { Authorization: apiKey },
+    headers: { Authorization: apiKey2 },
     signal
   });
   if (!resp.ok) {
@@ -6158,6 +6158,343 @@ var renderDocumentaryV2 = async (shot, ctx) => {
   });
 };
 
+// ../pipeline/src/clip-render/engines/cloud/lambda.ts
+import * as fs9 from "fs";
+var DEFAULT_REGION = "us-east-1";
+function readLambdaCfg() {
+  const functionName = process.env.REMOTION_LAMBDA_FUNCTION_NAME;
+  const serveUrl = process.env.REMOTION_LAMBDA_SERVE_URL;
+  if (!functionName) {
+    throw new Error(
+      "lambda engine: REMOTION_LAMBDA_FUNCTION_NAME not set. Deploy via `npx remotion lambda functions deploy`."
+    );
+  }
+  if (!serveUrl) {
+    throw new Error(
+      "lambda engine: REMOTION_LAMBDA_SERVE_URL not set. Deploy via `npx remotion lambda sites create`."
+    );
+  }
+  const region = process.env.REMOTION_LAMBDA_REGION ?? process.env.AWS_REGION ?? DEFAULT_REGION;
+  return { functionName, serveUrl, region };
+}
+var renderDocumentaryV2Lambda = async (shot, ctx) => {
+  if (ctx.signal?.aborted) throw new Error("aborted");
+  if (!shot.prompt) {
+    throw new Error(
+      `lambda: shot.prompt must be CompositionV2Data JSON or a path (shot ${shot.id})`
+    );
+  }
+  ctx.progress.emit({ phase: "preparing", shotId: shot.id });
+  let data;
+  if (shot.prompt.trimStart().startsWith("{")) {
+    data = JSON.parse(shot.prompt);
+  } else {
+    if (!fs9.existsSync(shot.prompt)) {
+      throw new Error(`lambda: CompositionV2Data file not found: ${shot.prompt}`);
+    }
+    data = JSON.parse(fs9.readFileSync(shot.prompt, "utf8"));
+  }
+  const cfg = readLambdaCfg();
+  let renderMediaOnLambda;
+  let getRenderProgress;
+  try {
+    const mod = await import("./client-5FQUWSRI.js");
+    renderMediaOnLambda = mod.renderMediaOnLambda;
+    getRenderProgress = mod.getRenderProgress;
+  } catch (err) {
+    throw new Error(
+      `lambda: @remotion/lambda is not installed. Run \`npm i -w @forge/remotion @remotion/lambda@4.0.457\`. Original: ${err.message}`
+    );
+  }
+  ctx.progress.emit({
+    phase: "rendering",
+    shotId: shot.id,
+    framesRendered: 0,
+    totalFrames: data.totalDurationFrames
+  });
+  const startedAt = Date.now();
+  const compId = ctx.aspect === "9:16" ? "DocumentaryV2Vertical" : "DocumentaryV2";
+  const { renderId, bucketName } = await renderMediaOnLambda({
+    region: cfg.region,
+    functionName: cfg.functionName,
+    serveUrl: cfg.serveUrl,
+    composition: compId,
+    inputProps: { compositionData: data },
+    codec: "h264",
+    imageFormat: "jpeg",
+    crf: 18,
+    privacy: "public",
+    maxRetries: 1
+    // framesPerLambda omitted — Remotion auto-tunes for cost vs speed
+  });
+  const HARD_DEADLINE_MS = 10 * 6e4;
+  const POLL_INTERVAL_MS2 = 2e3;
+  let lastFramesRendered = 0;
+  let outKey = null;
+  let totalCost = 0;
+  while (Date.now() - startedAt < HARD_DEADLINE_MS) {
+    if (ctx.signal?.aborted) throw new Error("aborted");
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
+    const progress = await getRenderProgress({
+      renderId,
+      bucketName,
+      functionName: cfg.functionName,
+      region: cfg.region
+    });
+    if (progress.fatalErrorEncountered) {
+      const errMsg = progress.errors?.[0]?.message ?? "fatal error";
+      throw new Error(`lambda render failed: ${errMsg}`);
+    }
+    if (typeof progress.framesRendered === "number" && progress.framesRendered > lastFramesRendered) {
+      lastFramesRendered = progress.framesRendered;
+      const totalFrames = data.totalDurationFrames;
+      ctx.progress.emit({
+        phase: "rendering",
+        shotId: shot.id,
+        framesRendered: lastFramesRendered,
+        totalFrames
+      });
+    }
+    if (typeof progress.costs?.accruedSoFar === "number") {
+      totalCost = progress.costs.accruedSoFar;
+    }
+    if (progress.done) {
+      outKey = progress.outKey ?? null;
+      break;
+    }
+  }
+  if (!outKey) {
+    throw new Error(`lambda render timed out after ${HARD_DEADLINE_MS / 1e3}s`);
+  }
+  ctx.progress.emit({ phase: "compositing", shotId: shot.id, percent: 90 });
+  const s3Url = `https://s3.${cfg.region}.amazonaws.com/${bucketName}/${outKey}`;
+  const resp = await fetch(s3Url, { signal: ctx.signal });
+  if (!resp.ok) {
+    throw new Error(`lambda: failed to fetch rendered MP4 from S3 (${resp.status}): ${s3Url}`);
+  }
+  const buf = Buffer.from(await resp.arrayBuffer());
+  fs9.writeFileSync(ctx.sceneOutPath, buf);
+  if (totalCost > 0) {
+    ctx.progress.emit({
+      phase: "compositing",
+      shotId: shot.id,
+      percent: 95,
+      warnings: [`lambda cost: $${totalCost.toFixed(4)}`]
+    });
+  }
+};
+
+// ../pipeline/src/clip-render/engines/cloud/runpod-manim.ts
+import * as fs10 from "fs";
+
+// ../pipeline/src/clip-render/engines/cloud/runpod-client.ts
+var RUNPOD_BASE = "https://api.runpod.ai/v2";
+function apiKey() {
+  const key = process.env.RUNPOD_API_KEY;
+  if (!key) {
+    throw new Error("RUNPOD_API_KEY not set in env");
+  }
+  return key;
+}
+async function submitJob(endpointId, payload, signal) {
+  const url = `${RUNPOD_BASE}/${endpointId}/run`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey()}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload),
+    signal
+  });
+  if (!resp.ok) {
+    const tail = (await resp.text().catch(() => "")).slice(0, 300);
+    throw new Error(`runpod submit failed (${resp.status}): ${tail}`);
+  }
+  const body = await resp.json();
+  if (!body.id) throw new Error("runpod submit: response missing id");
+  return { jobId: body.id };
+}
+async function getJobStatus(endpointId, jobId, signal) {
+  const url = `${RUNPOD_BASE}/${endpointId}/status/${jobId}`;
+  const resp = await fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${apiKey()}` },
+    signal
+  });
+  if (!resp.ok) {
+    throw new Error(`runpod status fetch failed (${resp.status})`);
+  }
+  return await resp.json();
+}
+async function cancelJob(endpointId, jobId) {
+  await fetch(`${RUNPOD_BASE}/${endpointId}/cancel/${jobId}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey()}` }
+  });
+}
+async function runJob(endpointId, payload, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 10 * 6e4;
+  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
+  const { jobId } = await submitJob(endpointId, payload, opts.signal);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (opts.signal?.aborted) {
+      void cancelJob(endpointId, jobId).catch(() => {
+      });
+      throw new Error("runpod: aborted");
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    const status = await getJobStatus(endpointId, jobId, opts.signal);
+    opts.onPoll?.(status);
+    if (status.status === "COMPLETED") return status;
+    if (status.status === "FAILED" || status.status === "CANCELLED" || status.status === "TIMED_OUT") {
+      throw new Error(`runpod job ${status.status.toLowerCase()}: ${status.error ?? "no detail"}`);
+    }
+  }
+  void cancelJob(endpointId, jobId).catch(() => {
+  });
+  throw new Error(`runpod job timed out after ${timeoutMs / 1e3}s (jobId=${jobId})`);
+}
+function decodeBase64Mp4(output) {
+  if (!output || typeof output !== "object") {
+    throw new Error("runpod: job output is not an object");
+  }
+  const o = output;
+  if (o.error) {
+    const tail = o.stderr ? `
+  stderr: ${o.stderr.slice(-400)}` : "";
+    throw new Error(`runpod worker: ${o.error}${tail}`);
+  }
+  if (typeof o.video_b64 !== "string" || o.video_b64.length === 0) {
+    throw new Error("runpod: job output missing video_b64");
+  }
+  const buf = Buffer.from(o.video_b64, "base64");
+  if (typeof o.size === "number" && o.size !== buf.length) {
+    throw new Error(`runpod: decoded size mismatch (expected ${o.size}, got ${buf.length})`);
+  }
+  if (buf.length === 0) {
+    throw new Error("runpod: decoded video_b64 is empty");
+  }
+  return buf;
+}
+
+// ../pipeline/src/clip-render/engines/cloud/runpod-manim.ts
+var renderManimRunPod = async (shot, ctx) => {
+  if (ctx.signal?.aborted) throw new Error("aborted");
+  if (!shot.manimCode || shot.manimCode.trim().length === 0) {
+    throw new Error(`runpod-manim: shot.manimCode required for shot ${shot.id}`);
+  }
+  const endpointId = process.env.RUNPOD_MANIM_ENDPOINT_ID;
+  if (!endpointId) {
+    throw new Error(
+      "runpod-manim: RUNPOD_MANIM_ENDPOINT_ID not set. Deploy via `cd apps/web/lib/runpod && python -m runpod_flash deploy flash-manim.py`."
+    );
+  }
+  ctx.progress.emit({ phase: "preparing", shotId: shot.id });
+  const status = await runJob(
+    endpointId,
+    {
+      // Flash unpacks `input` via **kwargs into the handler. Our handler
+      // signature is `async def render_manim_scene(input_data: dict)`, so
+      // the payload must be nested under `input_data`.
+      input: {
+        input_data: {
+          python_source: shot.manimCode,
+          scene_class: "GeneratedScene",
+          fps: ctx.fps,
+          quality: "high"
+          // manim --quality h => 1080p60; we'll downsample at concat
+        }
+      },
+      executionTimeout: 600
+    },
+    {
+      timeoutMs: 12 * 6e4,
+      pollIntervalMs: 3e3,
+      signal: ctx.signal,
+      onPoll: (s) => {
+        const phase = s.status === "IN_QUEUE" ? "preparing" : "rendering";
+        ctx.progress.emit({
+          phase,
+          shotId: shot.id,
+          warnings: s.delayTime ? [`runpod queue: ${(s.delayTime / 1e3).toFixed(1)}s`] : void 0
+        });
+      }
+    }
+  );
+  ctx.progress.emit({ phase: "compositing", shotId: shot.id, percent: 90 });
+  const buf = decodeBase64Mp4(status.output);
+  fs10.writeFileSync(ctx.sceneOutPath, buf);
+  if (status.executionTime) {
+    const cost = status.executionTime / 1e3 * 19e-5;
+    ctx.progress.emit({
+      phase: "compositing",
+      shotId: shot.id,
+      percent: 95,
+      warnings: [`runpod-manim cost: $${cost.toFixed(4)}`]
+    });
+  }
+};
+
+// ../pipeline/src/clip-render/engines/cloud/runpod-hyperframes.ts
+import * as fs11 from "fs";
+var renderHyperframesRunPod = async (shot, ctx) => {
+  if (ctx.signal?.aborted) throw new Error("aborted");
+  if (!shot.hyperframesHtml || shot.hyperframesHtml.trim().length === 0) {
+    throw new Error(`runpod-hyperframes: shot.hyperframesHtml required for shot ${shot.id}`);
+  }
+  const endpointId = process.env.RUNPOD_HYPERFRAMES_ENDPOINT_ID;
+  if (!endpointId) {
+    throw new Error(
+      "runpod-hyperframes: RUNPOD_HYPERFRAMES_ENDPOINT_ID not set. Deploy via `cd apps/web/lib/runpod && python -m runpod_flash deploy flash-hyperframes.py`."
+    );
+  }
+  ctx.progress.emit({ phase: "preparing", shotId: shot.id });
+  const dims = ctx.aspect === "9:16" ? { width: 1080, height: 1920 } : { width: 1920, height: 1080 };
+  const status = await runJob(
+    endpointId,
+    {
+      // Flash unpacks `input` via **kwargs into the handler. Our handler
+      // signature is `async def render_hyperframes_html(input_data: dict)`,
+      // so the payload must be nested under `input_data`.
+      input: {
+        input_data: {
+          html: shot.hyperframesHtml,
+          durationSec: shot.durationSec,
+          fps: ctx.fps,
+          width: dims.width,
+          height: dims.height
+        }
+      },
+      executionTimeout: 600
+    },
+    {
+      timeoutMs: 12 * 6e4,
+      pollIntervalMs: 3e3,
+      signal: ctx.signal,
+      onPoll: (s) => {
+        ctx.progress.emit({
+          phase: s.status === "IN_QUEUE" ? "preparing" : "rendering",
+          shotId: shot.id
+        });
+      }
+    }
+  );
+  ctx.progress.emit({ phase: "compositing", shotId: shot.id, percent: 90 });
+  const buf = decodeBase64Mp4(status.output);
+  fs11.writeFileSync(ctx.sceneOutPath, buf);
+  if (status.executionTime) {
+    const cost = status.executionTime / 1e3 * 19e-5;
+    ctx.progress.emit({
+      phase: "compositing",
+      shotId: shot.id,
+      percent: 95,
+      warnings: [`runpod-hyperframes cost: $${cost.toFixed(4)}`]
+    });
+  }
+};
+
 // ../pipeline/src/clip-render/engines/index.ts
 var ENGINE_ADAPTERS = {
   "gemini+remotion": renderGeminiRemotion,
@@ -6170,6 +6507,24 @@ var ENGINE_ADAPTERS = {
   "remotion+htmlcanvas": renderRemotionHtmlCanvas,
   "documentary-v2": renderDocumentaryV2
 };
+var CLOUD_ENGINE_ADAPTERS = {
+  "documentary-v2": renderDocumentaryV2Lambda,
+  "manim": renderManimRunPod,
+  // manim+remotion + gemini+manim+remotion: planner emits the manim leg
+  // as a separate shot, so the cloud manim adapter handles them indirectly.
+  "manim+remotion": renderManimRunPod,
+  "gemini+manim+remotion": renderManimRunPod,
+  "hyperframes": renderHyperframesRunPod
+};
+function pickAdapter(engine, provider = "local") {
+  if (provider === "cloud") {
+    const cloud = CLOUD_ENGINE_ADAPTERS[engine];
+    if (cloud) return { adapter: cloud, resolvedProvider: "cloud" };
+  }
+  const local = ENGINE_ADAPTERS[engine];
+  if (!local) throw new Error(`no adapter registered for engine "${engine}"`);
+  return { adapter: local, resolvedProvider: "local" };
+}
 var MANIM_ENGINES = /* @__PURE__ */ new Set([
   "manim",
   "manim+remotion",
@@ -6180,7 +6535,7 @@ function isManimEngine(engine) {
 }
 
 // ../pipeline/src/clip-render/fs-layout.ts
-import * as fs9 from "fs";
+import * as fs12 from "fs";
 import * as path10 from "path";
 function resolveProjectRoot(projectSlug, callerOutputDir) {
   if (callerOutputDir && callerOutputDir.length > 0) {
@@ -6222,13 +6577,13 @@ function ensureChunkDirs(paths) {
     paths.remotionDir,
     paths.hyperframesDir
   ]) {
-    fs9.mkdirSync(dir, { recursive: true });
+    fs12.mkdirSync(dir, { recursive: true });
   }
 }
 function appendProgress(progressLogPath, event) {
   try {
-    fs9.mkdirSync(path10.dirname(progressLogPath), { recursive: true });
-    fs9.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
+    fs12.mkdirSync(path10.dirname(progressLogPath), { recursive: true });
+    fs12.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -6334,7 +6689,7 @@ async function renderChunk(spec, opts = {}) {
       const concatTarget = path11.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 && fs10.existsSync(spec.audioPath);
+      const audioAvailable = !!spec.audioPath && fs13.existsSync(spec.audioPath);
       if (audioAvailable) {
         tracker.emit({ phase: "muxing", percent: 95 });
         await muxAudio(concatTarget, spec.audioPath, paths.finalClipPath, {
@@ -6346,7 +6701,7 @@ async function renderChunk(spec, opts = {}) {
         } else {
           warnings.push("no audioPath in spec \u2014 wrote silent clip");
         }
-        fs10.copyFileSync(concatTarget, paths.finalClipPath);
+        fs13.copyFileSync(concatTarget, paths.finalClipPath);
       }
       tracker.emit({ phase: "done", percent: 100 });
       const renderTimeMs2 = (opts.now ?? Date.now)() - startedAt;
@@ -6400,9 +6755,17 @@ function abortedResult(spec, engine, fallbackDepth, startedAt, now) {
   };
 }
 async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
-  const adapter = ENGINE_ADAPTERS[engine];
-  if (!adapter) throw new Error(`no adapter registered for engine "${engine}"`);
-  tracker.emit({ phase: "preparing", percent: 5 });
+  const provider = spec.provider ?? "local";
+  const { adapter, resolvedProvider } = pickAdapter(engine, provider);
+  const providerWarnings = [];
+  if (provider === "cloud" && resolvedProvider === "local") {
+    providerWarnings.push(`engine "${engine}" has no cloud variant \u2014 fell back to local`);
+  }
+  tracker.emit({
+    phase: "preparing",
+    percent: 5,
+    warnings: providerWarnings.length > 0 ? providerWarnings : void 0
+  });
   const shots = spec.shots.length > 0 ? spec.shots : [implicitShot(spec)];
   for (let i = 0; i < shots.length; i++) {
     if (opts.signal?.aborted) throw new Error("aborted");
@@ -6418,7 +6781,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
       progress: tracker,
       resolvedEngine: engine
     };
-    fs10.mkdirSync(path11.dirname(ctx.sceneOutPath), { recursive: true });
+    fs13.mkdirSync(path11.dirname(ctx.sceneOutPath), { recursive: true });
     const release = opts.acquireManimSlot ? await opts.acquireManimSlot() : void 0;
     try {
       tracker.emit({
@@ -6430,7 +6793,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
     } finally {
       release?.();
     }
-    if (!fs10.existsSync(ctx.sceneOutPath)) {
+    if (!fs13.existsSync(ctx.sceneOutPath)) {
       throw new Error(
         `engine ${engine} produced no output at ${ctx.sceneOutPath} for shot ${shot.id}`
       );
@@ -6449,6 +6812,49 @@ function implicitShot(spec) {
 // ../pipeline/src/clip-render/orchestrator.ts
 var import_p_limit = __toESM(require_p_limit());
 import * as os from "os";
+
+// ../pipeline/src/clip-render/manifest.ts
+import * as fs14 from "fs";
+import * as path12 from "path";
+function buildLocalManifestStub(specs, results, now = () => /* @__PURE__ */ new Date()) {
+  const specByChunk = new Map(specs.map((s) => [s.chunkId, s]));
+  const entries = [];
+  for (const r of results) {
+    if (!r.ok || !r.outputPath) continue;
+    const spec = specByChunk.get(r.chunkId);
+    if (!spec) continue;
+    let size = 0;
+    try {
+      const stat = fs14.statSync(r.outputPath);
+      if (stat.isFile()) size = stat.size;
+    } catch {
+      continue;
+    }
+    if (size === 0) continue;
+    entries.push({
+      kind: "clips",
+      chunkId: r.chunkId,
+      ext: "mp4",
+      size,
+      localPath: r.outputPath,
+      aspect: spec.aspect
+    });
+  }
+  return { writtenAt: now().toISOString(), version: 1, entries };
+}
+function localManifestStubPath(root) {
+  return path12.join(root, "manifest.local.json");
+}
+function writeLocalManifestStub(root, stub) {
+  fs14.mkdirSync(root, { recursive: true });
+  const target = localManifestStubPath(root);
+  const tmp = `${target}.tmp-${process.pid}`;
+  fs14.writeFileSync(tmp, JSON.stringify(stub, null, 2));
+  fs14.renameSync(tmp, target);
+  return target;
+}
+
+// ../pipeline/src/clip-render/orchestrator.ts
 function resolveConcurrency(requested) {
   if (typeof requested === "number" && requested > 0) {
     return Math.max(1, Math.floor(requested));
@@ -6535,6 +6941,16 @@ async function renderChunksParallel(specs, options = {}) {
   }
   const totalRenderTimeMs = Date.now() - startedAt;
   const ok = results.every((r) => r?.ok);
+  if (specs.length > 0) {
+    const stub = buildLocalManifestStub(specs, results);
+    if (stub.entries.length > 0) {
+      try {
+        const root = resolveProjectRoot(specs[0].projectSlug, specs[0].outputDir);
+        writeLocalManifestStub(root, stub);
+      } catch {
+      }
+    }
+  }
   return { ok, results, totalRenderTimeMs, observedPeakConcurrency };
 }
 function abortedSkeleton(spec) {
@@ -6614,8 +7030,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 path12 = (r.stdout ?? "").trim();
-    return { available: !!path12, path: path12 || null };
+    const path13 = (r.stdout ?? "").trim();
+    return { available: !!path13, path: path13 || null };
   }
   async heartbeat() {
     if (this.stopped) return;
@@ -6858,6 +7274,41 @@ var BridgePoller = class {
       }
       const okCount = result.results.filter((r) => r.ok).length;
       const uploadedCount = uploadOutcomes.filter((u) => u.ok).length;
+      const artifacts = [];
+      for (let i = 0; i < uploadOutcomes.length; i++) {
+        const u = uploadOutcomes[i];
+        const r = result.results.find((x) => x.chunkId === u.chunkId);
+        const spec = specByChunk.get(u.chunkId);
+        if (!u.ok || !u.storjKey || !r || !spec) continue;
+        let size = 0;
+        try {
+          const fsm = await import("fs/promises");
+          const stat = await fsm.stat(r.outputPath);
+          size = stat.size;
+        } catch {
+        }
+        artifacts.push({
+          kind: "clips",
+          chunkId: u.chunkId,
+          ext: "mp4",
+          size,
+          storjKey: u.storjKey,
+          aspect: spec.aspect
+        });
+      }
+      let manifestUploadOk = false;
+      let manifestUploadError;
+      if (artifacts.length > 0) {
+        const manifest = {
+          slug: payload.specs[0]?.projectSlug ?? "",
+          version: 1,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          artifacts
+        };
+        const m = await this.uploadManifest(jobId, payload.projectId, manifest);
+        manifestUploadOk = m.ok;
+        manifestUploadError = m.error;
+      }
       const summary = {
         kind: "render-clips",
         ok: result.ok && uploadedCount === okCount,
@@ -6866,6 +7317,8 @@ var BridgePoller = class {
         failed: result.results.length - okCount,
         uploaded: uploadedCount,
         uploadFailed: uploadOutcomes.filter((u) => !u.ok).length,
+        manifestUploadOk,
+        manifestUploadError,
         totalRenderTimeMs: result.totalRenderTimeMs,
         observedPeakConcurrency: result.observedPeakConcurrency
       };
@@ -6885,12 +7338,12 @@ var BridgePoller = class {
    */
   async uploadClipToStorj(bridgeJobId, projectId, spec, result) {
     try {
-      const fs12 = await import("fs/promises");
-      const stat = await fs12.stat(result.outputPath);
+      const fs16 = await import("fs/promises");
+      const stat = await fs16.stat(result.outputPath);
       if (!stat.isFile() || stat.size === 0) {
         return { ok: false, error: `local clip empty or missing at ${result.outputPath}` };
       }
-      const buf = await fs12.readFile(result.outputPath);
+      const buf = await fs16.readFile(result.outputPath);
       const durationFrames = Math.max(1, Math.round(result.durationSec * 30));
       const form = new FormData();
       form.append("bridgeJobId", bridgeJobId);
@@ -6918,6 +7371,34 @@ var BridgePoller = class {
       return { ok: false, error: err.message };
     }
   }
+  /**
+   * POST the assembled ProjectManifest to /api/cli-bridge/upload-manifest.
+   * Called once per render-clips batch after every clip uploads. The
+   * server validates tenancy, stamps slug + updatedAt, and writes the
+   * canonical manifest.json to Storj.
+   */
+  async uploadManifest(bridgeJobId, projectId, manifest) {
+    try {
+      const resp = await fetch(`${this.baseUrl}/api/cli-bridge/upload-manifest`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ bridgeJobId, projectId, manifest }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      const text = await resp.text().catch(() => "");
+      if (!resp.ok) {
+        return { ok: false, error: `HTTP ${resp.status}: ${text.slice(0, 300)}` };
+      }
+      const parsed = text ? JSON.parse(text) : {};
+      log.info(`[bridge] manifest uploaded -> ${parsed.storjKey ?? "(no key)"}`);
+      return { ok: true, storjKey: parsed.storjKey };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
   /** POST a single RenderProgress event to /api/render-progress. */
   async postRenderProgress(bridgeJobId, projectId, event) {
     try {
@@ -6955,9 +7436,9 @@ var BridgePoller = class {
         error: `stitch-final job requires @forge/pipeline/stitch (not installed): ${err.message}`
       };
     }
-    const path12 = await import("path");
-    const projectRoot = path12.resolve(process.cwd(), "forge-renders", payload.projectSlug);
-    const clipsDir = path12.join(projectRoot, "clips");
+    const path13 = await import("path");
+    const projectRoot = path13.resolve(process.cwd(), "forge-renders", payload.projectSlug);
+    const clipsDir = path13.join(projectRoot, "clips");
     const publish = async (phase, eventPayload) => {
       try {
         await fetch(`${this.baseUrl}/api/cli-bridge/stitch-event`, {
@@ -6983,7 +7464,7 @@ var BridgePoller = class {
         projectSlug: payload.projectSlug,
         clipsDir,
         chunkOrder: payload.chunkOrder ?? [],
-        masterAudioPath: path12.isAbsolute(masterAudioRel) ? masterAudioRel : path12.join(projectRoot, masterAudioRel),
+        masterAudioPath: path13.isAbsolute(masterAudioRel) ? masterAudioRel : path13.join(projectRoot, masterAudioRel),
         outputDir: projectRoot,
         aspect: payload.aspect,
         skipTransitions: payload.skipTransitions,
@@ -7167,10 +7648,10 @@ function collectImagesFromCodexStdout(stdout, maxCount) {
   for (const p of paths) {
     if (images.length >= maxCount) break;
     try {
-      const stat = fs11.statSync(p);
+      const stat = fs15.statSync(p);
       if (!stat.isFile() || stat.size <= 0) continue;
       images.push({
-        base64: fs11.readFileSync(p).toString("base64"),
+        base64: fs15.readFileSync(p).toString("base64"),
         mimeType: mimeTypeForPath(p),
         model: "codex-cli:imagegen"
       });