@effing/ffs 0.6.0 → 0.7.0

package/dist/server.js

@@ -3,10 +3,10 @@ import {
   createTransientStore,
   ffsFetch,
   storeKeys
-} from "./chunk-PERB3C4S.js";
+} from "./chunk-AUH73KG2.js";
 
 // src/server.ts
-import express5 from "express";
+import express4 from "express";
 import bodyParser from "body-parser";
 
 // src/handlers/shared.ts
@@ -195,445 +195,6 @@ data: ${JSON.stringify(data)}
 `);
   };
 }
-
-// src/handlers/caching.ts
-import "express";
-import { Readable as Readable2, Transform } from "stream";
-import { randomUUID as randomUUID3 } from "crypto";
-import {
-  extractEffieSources,
-  extractEffieSourcesWithTypes as extractEffieSourcesWithTypes2
-} from "@effing/effie";
-
-// src/handlers/orchestrating.ts
-import "express";
-import { randomUUID as randomUUID2 } from "crypto";
-import { extractEffieSourcesWithTypes, effieDataSchema as effieDataSchema3 } from "@effing/effie";
-
-// src/handlers/rendering.ts
-import "express";
-import { randomUUID } from "crypto";
-import { effieDataSchema as effieDataSchema2 } from "@effing/effie";
-async function createRenderJob(req, res, ctx2, options) {
-  try {
-    const isWrapped = "effie" in req.body;
-    let rawEffieData;
-    let scale;
-    let upload;
-    if (isWrapped) {
-      const options2 = req.body;
-      if (typeof options2.effie === "string") {
-        const response = await ffsFetch(options2.effie);
-        if (!response.ok) {
-          throw new Error(
-            `Failed to fetch Effie data: ${response.status} ${response.statusText}`
-          );
-        }
-        rawEffieData = await response.json();
-      } else {
-        rawEffieData = options2.effie;
-      }
-      scale = options2.scale ?? 1;
-      upload = options2.upload;
-    } else {
-      rawEffieData = req.body;
-      scale = parseFloat(req.query.scale?.toString() || "1");
-    }
-    let effie;
-    if (!ctx2.skipValidation) {
-      const result = effieDataSchema2.safeParse(rawEffieData);
-      if (!result.success) {
-        res.status(400).json({
-          error: "Invalid effie data",
-          issues: result.error.issues.map((issue) => ({
-            path: issue.path.join("."),
-            message: issue.message
-          }))
-        });
-        return;
-      }
-      effie = result.data;
-    } else {
-      const data = rawEffieData;
-      if (!data?.segments) {
-        res.status(400).json({ error: "Invalid effie data: missing segments" });
-        return;
-      }
-      effie = data;
-    }
-    const jobId = randomUUID();
-    const job = {
-      effie,
-      scale,
-      upload,
-      createdAt: Date.now(),
-      metadata: options?.metadata
-    };
-    await ctx2.transientStore.putJson(
-      storeKeys.renderJob(jobId),
-      job,
-      ctx2.transientStore.jobDataTtlMs
-    );
-    res.json({
-      id: jobId,
-      url: `${ctx2.baseUrl}/render/${jobId}`
-    });
-  } catch (error) {
-    console.error("Error creating render job:", error);
-    res.status(500).json({ error: "Failed to create render job" });
-  }
-}
-async function streamRenderJob(req, res, ctx2) {
-  try {
-    setupCORSHeaders(res);
-    const jobId = req.params.id;
-    const jobStoreKey = storeKeys.renderJob(jobId);
-    const job = await ctx2.transientStore.getJson(jobStoreKey);
-    if (!job) {
-      res.status(404).json({ error: "Job not found or expired" });
-      return;
-    }
-    if (ctx2.renderBackendResolver) {
-      const backend = ctx2.renderBackendResolver(job.effie, job.metadata);
-      if (backend) {
-        await proxyRenderFromBackend(res, jobId, backend);
-        return;
-      }
-    }
-    ctx2.transientStore.delete(jobStoreKey);
-    if (job.upload) {
-      await streamRenderWithUpload(res, job, ctx2);
-    } else {
-      await streamRenderDirect(res, job, ctx2);
-    }
-  } catch (error) {
-    console.error("Error in render:", error);
-    if (!res.headersSent) {
-      res.status(500).json({ error: "Rendering failed" });
-    } else {
-      res.end();
-    }
-  }
-}
-async function streamRenderDirect(res, job, ctx2) {
-  const { EffieRenderer } = await import("./render-MUKKTCF6.js");
-  const renderer = new EffieRenderer(job.effie, {
-    transientStore: ctx2.transientStore,
-    httpProxy: ctx2.httpProxy
-  });
-  const videoStream = await renderer.render(job.scale);
-  res.on("close", () => {
-    videoStream.destroy();
-    renderer.close();
-  });
-  res.set("Content-Type", "video/mp4");
-  videoStream.pipe(res);
-}
-async function streamRenderWithUpload(res, job, ctx2) {
-  setupSSEResponse(res);
-  const sendEvent = createSSEEventSender(res);
-  const keepalive = setInterval(() => {
-    sendEvent("keepalive", { status: "rendering" });
-  }, 25e3);
-  try {
-    sendEvent("started", { status: "rendering" });
-    const timings = await renderAndUploadInternal(
-      job.effie,
-      job.scale,
-      job.upload,
-      sendEvent,
-      ctx2
-    );
-    sendEvent("complete", { status: "uploaded", timings });
-  } catch (error) {
-    sendEvent("error", { message: String(error) });
-  } finally {
-    clearInterval(keepalive);
-    res.end();
-  }
-}
-async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
-  const timings = {};
-  if (upload.coverUrl) {
-    const fetchCoverStartTime = Date.now();
-    const coverFetchResponse = await ffsFetch(effie.cover);
-    if (!coverFetchResponse.ok) {
-      throw new Error(
-        `Failed to fetch cover image: ${coverFetchResponse.status} ${coverFetchResponse.statusText}`
-      );
-    }
-    const coverBuffer = Buffer.from(await coverFetchResponse.arrayBuffer());
-    timings.fetchCoverTime = Date.now() - fetchCoverStartTime;
-    const uploadCoverStartTime = Date.now();
-    const uploadCoverResponse = await ffsFetch(upload.coverUrl, {
-      method: "PUT",
-      body: coverBuffer,
-      headers: {
-        "Content-Type": "image/png",
-        "Content-Length": coverBuffer.length.toString()
-      }
-    });
-    if (!uploadCoverResponse.ok) {
-      throw new Error(
-        `Failed to upload cover: ${uploadCoverResponse.status} ${uploadCoverResponse.statusText}`
-      );
-    }
-    timings.uploadCoverTime = Date.now() - uploadCoverStartTime;
-  }
-  const renderStartTime = Date.now();
-  const { EffieRenderer } = await import("./render-MUKKTCF6.js");
-  const renderer = new EffieRenderer(effie, {
-    transientStore: ctx2.transientStore,
-    httpProxy: ctx2.httpProxy
-  });
-  const videoStream = await renderer.render(scale);
-  const chunks = [];
-  for await (const chunk of videoStream) {
-    chunks.push(Buffer.from(chunk));
-  }
-  const videoBuffer = Buffer.concat(chunks);
-  timings.renderTime = Date.now() - renderStartTime;
-  sendEvent("keepalive", { status: "uploading" });
-  const uploadStartTime = Date.now();
-  const uploadResponse = await ffsFetch(upload.videoUrl, {
-    method: "PUT",
-    body: videoBuffer,
-    headers: {
-      "Content-Type": "video/mp4",
-      "Content-Length": videoBuffer.length.toString()
-    }
-  });
-  if (!uploadResponse.ok) {
-    throw new Error(
-      `Failed to upload rendered video: ${uploadResponse.status} ${uploadResponse.statusText}`
-    );
-  }
-  timings.uploadTime = Date.now() - uploadStartTime;
-  return timings;
-}
-async function proxyRenderFromBackend(res, jobId, backend) {
-  const backendUrl = `${backend.baseUrl}/render/${jobId}`;
-  const response = await ffsFetch(backendUrl, {
-    headers: backend.apiKey ? { Authorization: `Bearer ${backend.apiKey}` } : void 0
-  });
-  if (!response.ok) {
-    res.status(response.status).json({ error: "Backend render failed" });
-    return;
-  }
-  const contentType = response.headers.get("content-type") || "";
-  if (contentType.includes("text/event-stream")) {
-    setupSSEResponse(res);
-    const sendEvent = createSSEEventSender(res);
-    const reader = response.body?.getReader();
-    if (!reader) {
-      sendEvent("error", { message: "No response body from backend" });
-      res.end();
-      return;
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (res.destroyed) {
-          reader.cancel();
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        let currentEvent = "";
-        let currentData = "";
-        for (const line of lines) {
-          if (line.startsWith("event: ")) {
-            currentEvent = line.slice(7);
-          } else if (line.startsWith("data: ")) {
-            currentData = line.slice(6);
-          } else if (line === "" && currentEvent && currentData) {
-            try {
-              const data = JSON.parse(currentData);
-              sendEvent(currentEvent, data);
-            } catch {
-            }
-            currentEvent = "";
-            currentData = "";
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      res.end();
-    }
-  } else {
-    await proxyBinaryStream(response, res);
-  }
-}
-
-// src/handlers/orchestrating.ts
-async function createWarmupAndRenderJob(req, res, ctx2, options) {
-  try {
-    const body = req.body;
-    let rawEffieData;
-    if (typeof body.effie === "string") {
-      const response = await ffsFetch(body.effie);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch Effie data: ${response.status} ${response.statusText}`
-        );
-      }
-      rawEffieData = await response.json();
-    } else {
-      rawEffieData = body.effie;
-    }
-    let effie;
-    if (!ctx2.skipValidation) {
-      const result = effieDataSchema3.safeParse(rawEffieData);
-      if (!result.success) {
-        res.status(400).json({
-          error: "Invalid effie data",
-          issues: result.error.issues.map((issue) => ({
-            path: issue.path.join("."),
-            message: issue.message
-          }))
-        });
-        return;
-      }
-      effie = result.data;
-    } else {
-      const data = rawEffieData;
-      if (!data?.segments) {
-        res.status(400).json({ error: "Invalid effie data: missing segments" });
-        return;
-      }
-      effie = data;
-    }
-    const sources = extractEffieSourcesWithTypes(effie);
-    const scale = body.scale ?? 1;
-    const upload = body.upload;
-    const jobId = randomUUID2();
-    const warmupJobId = randomUUID2();
-    const renderJobId = randomUUID2();
-    const job = {
-      effie,
-      sources,
-      scale,
-      upload,
-      warmupJobId,
-      renderJobId,
-      createdAt: Date.now(),
-      metadata: options?.metadata
-    };
-    await ctx2.transientStore.putJson(
-      storeKeys.warmupAndRenderJob(jobId),
-      job,
-      ctx2.transientStore.jobDataTtlMs
-    );
-    await ctx2.transientStore.putJson(
-      storeKeys.warmupJob(warmupJobId),
-      { sources, metadata: options?.metadata },
-      ctx2.transientStore.jobDataTtlMs
-    );
-    await ctx2.transientStore.putJson(
-      storeKeys.renderJob(renderJobId),
-      {
-        effie,
-        scale,
-        upload,
-        createdAt: Date.now(),
-        metadata: options?.metadata
-      },
-      ctx2.transientStore.jobDataTtlMs
-    );
-    res.json({
-      id: jobId,
-      url: `${ctx2.baseUrl}/warmup-and-render/${jobId}`
-    });
-  } catch (error) {
-    console.error("Error creating warmup-and-render job:", error);
-    res.status(500).json({ error: "Failed to create warmup-and-render job" });
-  }
-}
-async function streamWarmupAndRenderJob(req, res, ctx2) {
-  try {
-    setupCORSHeaders(res);
-    const jobId = req.params.id;
-    const jobStoreKey = storeKeys.warmupAndRenderJob(jobId);
-    const job = await ctx2.transientStore.getJson(jobStoreKey);
-    ctx2.transientStore.delete(jobStoreKey);
-    if (!job) {
-      res.status(404).json({ error: "Job not found" });
-      return;
-    }
-    const warmupBackend = ctx2.warmupBackendResolver ? ctx2.warmupBackendResolver(job.sources, job.metadata) : null;
-    const renderBackend = ctx2.renderBackendResolver ? ctx2.renderBackendResolver(job.effie, job.metadata) : null;
-    setupSSEResponse(res);
-    const sendEvent = createSSEEventSender(res);
-    let keepalivePhase = "warmup";
-    const keepalive = setInterval(() => {
-      sendEvent("keepalive", { phase: keepalivePhase });
-    }, 25e3);
-    try {
-      if (warmupBackend) {
-        await proxyRemoteSSE(
-          `${warmupBackend.baseUrl}/warmup/${job.warmupJobId}`,
-          sendEvent,
-          "warmup:",
-          res,
-          warmupBackend.apiKey ? { Authorization: `Bearer ${warmupBackend.apiKey}` } : void 0
-        );
-      } else {
-        const warmupSender = prefixEventSender(sendEvent, "warmup:");
-        await warmupSources(job.sources, warmupSender, ctx2);
-        warmupSender("complete", { status: "ready" });
-      }
-      keepalivePhase = "render";
-      if (renderBackend) {
-        await proxyRemoteSSE(
-          `${renderBackend.baseUrl}/render/${job.renderJobId}`,
-          sendEvent,
-          "render:",
-          res,
-          renderBackend.apiKey ? { Authorization: `Bearer ${renderBackend.apiKey}` } : void 0
-        );
-      } else {
-        const renderSender = prefixEventSender(sendEvent, "render:");
-        if (job.upload) {
-          renderSender("started", { status: "rendering" });
-          const timings = await renderAndUploadInternal(
-            job.effie,
-            job.scale,
-            job.upload,
-            renderSender,
-            ctx2
-          );
-          renderSender("complete", { status: "uploaded", timings });
-        } else {
-          const videoUrl = `${ctx2.baseUrl}/render/${job.renderJobId}`;
-          sendEvent("complete", { status: "ready", videoUrl });
-        }
-      }
-      if (job.upload && !renderBackend) {
-        sendEvent("complete", { status: "done" });
-      }
-    } catch (error) {
-      sendEvent("error", {
-        phase: keepalivePhase,
-        message: String(error)
-      });
-    } finally {
-      clearInterval(keepalive);
-      res.end();
-    }
-  } catch (error) {
-    console.error("Error in warmup-and-render streaming:", error);
-    if (!res.headersSent) {
-      res.status(500).json({ error: "Warmup-and-render streaming failed" });
-    } else {
-      res.end();
-    }
-  }
-}
 function prefixEventSender(sendEvent, prefix) {
   return (event, data) => {
     sendEvent(`${prefix}${event}`, data);
@@ -714,6 +275,13 @@ async function proxyBinaryStream(response, res) {
 }
 
 // src/handlers/caching.ts
+import "express";
+import { Readable as Readable2, Transform } from "stream";
+import { randomUUID } from "crypto";
+import {
+  extractEffieSources,
+  extractEffieSourcesWithTypes
+} from "@effing/effie";
 function shouldSkipWarmup(source) {
   return source.type === "video" || source.type === "audio";
 }
@@ -725,24 +293,24 @@ async function createWarmupJob(req, res, ctx2, options) {
       res.status(400).json(parseResult);
       return;
     }
-    const sources = extractEffieSourcesWithTypes2(parseResult.effie);
-    const jobId = randomUUID3();
+    const sources = extractEffieSourcesWithTypes(parseResult.effie);
+    const jobId = randomUUID();
     const job = { sources, metadata: options?.metadata };
     await ctx2.transientStore.putJson(
       storeKeys.warmupJob(jobId),
       job,
-      ctx2.transientStore.jobDataTtlMs
+      ctx2.transientStore.ttlMs
     );
     res.json({
       id: jobId,
-      url: `${ctx2.baseUrl}/warmup/${jobId}`
+      progressUrl: `${ctx2.baseUrl}/warmup/${jobId}/progress`
     });
   } catch (error) {
     console.error("Error creating warmup job:", error);
     res.status(500).json({ error: "Failed to create warmup job" });
   }
 }
-async function streamWarmupJob(req, res, ctx2) {
+async function streamWarmupProgress(req, res, ctx2) {
   try {
     setupCORSHeaders(res);
     const jobId = req.params.id;
@@ -759,7 +327,7 @@ async function streamWarmupJob(req, res, ctx2) {
         const sendEvent2 = createSSEEventSender(res);
         try {
           await proxyRemoteSSE(
-            `${backend.baseUrl}/warmup/${jobId}`,
+            `${backend.baseUrl}/warmup/${jobId}/progress`,
             sendEvent2,
             "",
             res,
@@ -791,6 +359,17 @@ async function streamWarmupJob(req, res, ctx2) {
     }
   }
 }
+async function purgeCachedSources(urls, store) {
+  let purged = 0;
+  for (const url of urls) {
+    const ck = storeKeys.source(url);
+    if (await store.exists(ck)) {
+      await store.delete(ck);
+      purged++;
+    }
+  }
+  return { purged, total: urls.length };
+}
 async function purgeCache(req, res, ctx2) {
   try {
     const parseResult = parseEffieData(req.body, ctx2.skipValidation);
@@ -799,15 +378,8 @@ async function purgeCache(req, res, ctx2) {
       return;
     }
     const sources = extractEffieSources(parseResult.effie);
-    let purged = 0;
-    for (const url of sources) {
-      const ck = storeKeys.source(url);
-      if (await ctx2.transientStore.exists(ck)) {
-        await ctx2.transientStore.delete(ck);
-        purged++;
-      }
-    }
-    res.json({ purged, total: sources.length });
+    const result = await purgeCachedSources(sources, ctx2.transientStore);
+    res.json(result);
   } catch (error) {
     console.error("Error purging cache:", error);
     res.status(500).json({ error: "Failed to purge cache" });
@@ -944,12 +516,296 @@ async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
   await ctx2.transientStore.put(
     cacheKey,
     trackedStream,
-    ctx2.transientStore.sourceTtlMs
+    ctx2.transientStore.ttlMs
   );
 }
 
+// src/handlers/rendering.ts
+import "express";
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  extractEffieSourcesWithTypes as extractEffieSourcesWithTypes2,
+  extractEffieSources as extractEffieSources2,
+  effieDataSchema as effieDataSchema2
+} from "@effing/effie";
+async function createRenderJob(req, res, ctx2, options) {
+  try {
+    const body = req.body;
+    let rawEffieData;
+    if (typeof body.effie === "string") {
+      const response = await ffsFetch(body.effie);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch Effie data: ${response.status} ${response.statusText}`
+        );
+      }
+      rawEffieData = await response.json();
+    } else {
+      rawEffieData = body.effie;
+    }
+    let effie;
+    if (!ctx2.skipValidation) {
+      const result = effieDataSchema2.safeParse(rawEffieData);
+      if (!result.success) {
+        res.status(400).json({
+          error: "Invalid effie data",
+          issues: result.error.issues.map((issue) => ({
+            path: issue.path.join("."),
+            message: issue.message
+          }))
+        });
+        return;
+      }
+      effie = result.data;
+    } else {
+      const data = rawEffieData;
+      if (!data?.segments) {
+        res.status(400).json({ error: "Invalid effie data: missing segments" });
+        return;
+      }
+      effie = data;
+    }
+    const sources = extractEffieSourcesWithTypes2(effie);
+    const scale = body.scale ?? 1;
+    const upload = body.upload;
+    const purge = body.purge;
+    const jobId = randomUUID2();
+    const warmupJobId = randomUUID2();
+    const job = {
+      effie,
+      sources,
+      scale,
+      upload,
+      purge,
+      warmupJobId,
+      createdAt: Date.now(),
+      metadata: options?.metadata
+    };
+    await ctx2.transientStore.putJson(
+      storeKeys.renderJob(jobId),
+      job,
+      ctx2.transientStore.ttlMs
+    );
+    await ctx2.transientStore.putJson(
+      storeKeys.warmupJob(warmupJobId),
+      { sources, metadata: options?.metadata },
+      ctx2.transientStore.ttlMs
+    );
+    res.json({
+      id: jobId,
+      progressUrl: `${ctx2.baseUrl}/render/${jobId}/progress`
+    });
+  } catch (error) {
+    console.error("Error creating render job:", error);
+    res.status(500).json({ error: "Failed to create render job" });
+  }
+}
+async function streamRenderProgress(req, res, ctx2) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    const jobStoreKey = storeKeys.renderJob(jobId);
+    const job = await ctx2.transientStore.getJson(jobStoreKey);
+    ctx2.transientStore.delete(jobStoreKey);
+    if (!job) {
+      res.status(404).json({ error: "Job not found" });
+      return;
+    }
+    const warmupBackend = ctx2.warmupBackendResolver ? ctx2.warmupBackendResolver(job.sources, job.metadata) : null;
+    const renderBackend = ctx2.renderBackendResolver ? ctx2.renderBackendResolver(job.effie, job.metadata) : null;
+    setupSSEResponse(res);
+    const sendEvent = createSSEEventSender(res);
+    let keepalivePhase = "warmup";
+    const keepalive = setInterval(() => {
+      sendEvent("keepalive", { phase: keepalivePhase });
+    }, 25e3);
+    try {
+      if (job.purge) {
+        const sourceUrls = extractEffieSources2(job.effie);
+        const purgeResult = await purgeCachedSources(
+          sourceUrls,
+          ctx2.transientStore
+        );
+        sendEvent("purge:complete", purgeResult);
+      }
+      if (warmupBackend) {
+        await proxyRemoteSSE(
+          `${warmupBackend.baseUrl}/warmup/${job.warmupJobId}/progress`,
+          sendEvent,
+          "warmup:",
+          res,
+          warmupBackend.apiKey ? { Authorization: `Bearer ${warmupBackend.apiKey}` } : void 0
+        );
+      } else {
+        const warmupSender = prefixEventSender(sendEvent, "warmup:");
+        await warmupSources(job.sources, warmupSender, ctx2);
+        warmupSender("complete", { status: "ready" });
+      }
+      keepalivePhase = "render";
+      if (renderBackend) {
+        await proxyRemoteSSE(
+          `${renderBackend.baseUrl}/render/${jobId}/progress`,
+          sendEvent,
+          "render:",
+          res,
+          renderBackend.apiKey ? { Authorization: `Bearer ${renderBackend.apiKey}` } : void 0
+        );
+      } else {
+        if (job.upload) {
+          const renderSender = prefixEventSender(sendEvent, "render:");
+          renderSender("started", { status: "rendering" });
+          const timings = await renderAndUploadInternal(
+            job.effie,
+            job.scale,
+            job.upload,
+            renderSender,
+            ctx2
+          );
+          renderSender("complete", { status: "uploaded", timings });
+          sendEvent("complete", { status: "done" });
+        } else {
+          const videoJob = { effie: job.effie, scale: job.scale };
+          await ctx2.transientStore.putJson(
+            storeKeys.videoJob(jobId),
+            videoJob,
+            ctx2.transientStore.ttlMs
+          );
+          const videoUrl = `${ctx2.baseUrl}/render/${jobId}/video`;
+          sendEvent("ready", { videoUrl });
+        }
+      }
+    } catch (error) {
+      sendEvent("error", {
+        phase: keepalivePhase,
+        message: String(error)
+      });
+    } finally {
+      clearInterval(keepalive);
+      res.end();
+    }
+  } catch (error) {
+    console.error("Error in render progress streaming:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Render progress streaming failed" });
+    } else {
+      res.end();
+    }
+  }
+}
+async function streamRenderVideo(req, res, ctx2) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    const videoJobKey = storeKeys.videoJob(jobId);
+    const videoJob = await ctx2.transientStore.getJson(videoJobKey);
+    if (!videoJob) {
+      res.status(404).json({ error: "Video not found or expired" });
+      return;
+    }
+    ctx2.transientStore.delete(videoJobKey);
+    if (ctx2.renderBackendResolver) {
+      const backend = ctx2.renderBackendResolver(videoJob.effie);
+      if (backend) {
+        const backendUrl = `${backend.baseUrl}/render/${jobId}/video`;
+        const response = await ffsFetch(backendUrl, {
+          headers: backend.apiKey ? { Authorization: `Bearer ${backend.apiKey}` } : void 0
+        });
+        if (!response.ok) {
+          res.status(response.status).json({ error: "Backend render failed" });
+          return;
+        }
+        await proxyBinaryStream(response, res);
+        return;
+      }
+    }
+    await streamRenderDirect(res, videoJob, ctx2);
+  } catch (error) {
+    console.error("Error streaming video:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Video streaming failed" });
+    } else {
+      res.end();
+    }
+  }
+}
+async function streamRenderDirect(res, job, ctx2) {
+  const { EffieRenderer } = await import("./render-E3U44GOC.js");
+  const renderer = new EffieRenderer(job.effie, {
+    transientStore: ctx2.transientStore,
+    httpProxy: ctx2.httpProxy
+  });
+  const videoStream = await renderer.render(job.scale);
+  res.on("close", () => {
+    videoStream.destroy();
+    renderer.close();
+  });
+  res.set("Content-Type", "video/mp4");
+  res.set("Cache-Control", "public, immutable, max-age=86400");
+  videoStream.pipe(res);
+}
+async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
+  const timings = {};
+  if (upload.coverUrl) {
+    const fetchCoverStartTime = Date.now();
+    const coverFetchResponse = await ffsFetch(effie.cover);
+    if (!coverFetchResponse.ok) {
+      throw new Error(
+        `Failed to fetch cover image: ${coverFetchResponse.status} ${coverFetchResponse.statusText}`
+      );
+    }
+    const coverBuffer = Buffer.from(await coverFetchResponse.arrayBuffer());
+    timings.fetchCoverTime = Date.now() - fetchCoverStartTime;
+    const uploadCoverStartTime = Date.now();
+    const uploadCoverResponse = await ffsFetch(upload.coverUrl, {
+      method: "PUT",
+      body: coverBuffer,
+      headers: {
+        "Content-Type": "image/png",
+        "Content-Length": coverBuffer.length.toString()
+      }
+    });
+    if (!uploadCoverResponse.ok) {
+      throw new Error(
+        `Failed to upload cover: ${uploadCoverResponse.status} ${uploadCoverResponse.statusText}`
+      );
+    }
+    timings.uploadCoverTime = Date.now() - uploadCoverStartTime;
+  }
+  const renderStartTime = Date.now();
+  const { EffieRenderer } = await import("./render-E3U44GOC.js");
+  const renderer = new EffieRenderer(effie, {
+    transientStore: ctx2.transientStore,
+    httpProxy: ctx2.httpProxy
+  });
+  const videoStream = await renderer.render(scale);
+  const chunks = [];
+  for await (const chunk of videoStream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const videoBuffer = Buffer.concat(chunks);
+  timings.renderTime = Date.now() - renderStartTime;
+  sendEvent("keepalive", { status: "uploading" });
+  const uploadStartTime = Date.now();
+  const uploadResponse = await ffsFetch(upload.videoUrl, {
+    method: "PUT",
+    body: videoBuffer,
+    headers: {
+      "Content-Type": "video/mp4",
+      "Content-Length": videoBuffer.length.toString()
+    }
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Failed to upload rendered video: ${uploadResponse.status} ${uploadResponse.statusText}`
+    );
+  }
+  timings.uploadTime = Date.now() - uploadStartTime;
+  return timings;
+}
+
 // src/server.ts
-var app = express5();
+var app = express4();
+app.disable("x-powered-by");
 app.use(bodyParser.json({ limit: "50mb" }));
 var ctx = await createServerContext();
 if (ctx.httpProxy) {
@@ -977,16 +833,15 @@ app.post("/render", (req, res) => {
   if (!validateAuth(req, res)) return;
   createRenderJob(req, res, ctx);
 });
-app.post("/warmup-and-render", (req, res) => {
-  if (!validateAuth(req, res)) return;
-  createWarmupAndRenderJob(req, res, ctx);
-});
-app.get("/warmup/:id", (req, res) => streamWarmupJob(req, res, ctx));
-app.get("/render/:id", (req, res) => streamRenderJob(req, res, ctx));
 app.get(
-  "/warmup-and-render/:id",
-  (req, res) => streamWarmupAndRenderJob(req, res, ctx)
+  "/warmup/:id/progress",
+  (req, res) => streamWarmupProgress(req, res, ctx)
+);
+app.get(
+  "/render/:id/progress",
+  (req, res) => streamRenderProgress(req, res, ctx)
 );
+app.get("/render/:id/video", (req, res) => streamRenderVideo(req, res, ctx));
 var port = process.env.FFS_PORT || process.env.PORT || 2e3;
 var server = app.listen(port, () => {
   console.log(`FFS server listening on port ${port}`);