@effing/ffs 0.2.0 → 0.3.0

package/dist/{chunk-6YHSYHDY.js → chunk-XSCNUWZJ.js}

@@ -1,9 +1,9 @@
 import {
   EffieRenderer,
-  cacheKeys,
-  createCacheStorage,
-  ffsFetch
-} from "./chunk-A7BAW24L.js";
+  createTransientStore,
+  ffsFetch,
+  storeKeys
+} from "./chunk-J64HSZNQ.js";
 
 // src/handlers/shared.ts
 import "express";
@@ -137,11 +137,13 @@ async function createServerContext() {
   const httpProxy = new HttpProxy();
   await httpProxy.start();
   return {
-    cacheStorage: createCacheStorage(),
+    transientStore: createTransientStore(),
     httpProxy,
     baseUrl: process.env.FFS_BASE_URL || `http://localhost:${port}`,
     skipValidation: !!process.env.FFS_SKIP_VALIDATION && process.env.FFS_SKIP_VALIDATION !== "false",
-    cacheConcurrency: parseInt(process.env.FFS_CACHE_CONCURRENCY || "4", 10)
+    warmupConcurrency: parseInt(process.env.FFS_WARMUP_CONCURRENCY || "4", 10),
+    warmupBackendBaseUrl: process.env.FFS_WARMUP_BACKEND_BASE_URL,
+    renderBackendBaseUrl: process.env.FFS_RENDER_BACKEND_BASE_URL
   };
 }
 function parseEffieData(body, skipValidation) {
@@ -189,11 +191,506 @@ data: ${JSON.stringify(data)}
 // src/handlers/caching.ts
 import "express";
 import { Readable as Readable2, Transform } from "stream";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import {
   extractEffieSources,
-  extractEffieSourcesWithTypes
+  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, ctx) {
+  try {
+    const isWrapped = "effie" in req.body;
+    let rawEffieData;
+    let scale;
+    let upload;
+    if (isWrapped) {
+      const options = req.body;
+      if (typeof options.effie === "string") {
+        const response = await ffsFetch(options.effie);
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch Effie data: ${response.status} ${response.statusText}`
+          );
+        }
+        rawEffieData = await response.json();
+      } else {
+        rawEffieData = options.effie;
+      }
+      scale = options.scale ?? 1;
+      upload = options.upload;
+    } else {
+      rawEffieData = req.body;
+      scale = parseFloat(req.query.scale?.toString() || "1");
+    }
+    let effie;
+    if (!ctx.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()
+    };
+    await ctx.transientStore.putJson(
+      storeKeys.renderJob(jobId),
+      job,
+      ctx.transientStore.jobMetadataTtlMs
+    );
+    res.json({
+      id: jobId,
+      url: `${ctx.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, ctx) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    if (ctx.renderBackendBaseUrl) {
+      await proxyRenderFromBackend(res, jobId, ctx);
+      return;
+    }
+    const jobCacheKey = storeKeys.renderJob(jobId);
+    const job = await ctx.transientStore.getJson(jobCacheKey);
+    ctx.transientStore.delete(jobCacheKey);
+    if (!job) {
+      res.status(404).json({ error: "Job not found or expired" });
+      return;
+    }
+    if (job.upload) {
+      await streamRenderWithUpload(res, job, ctx);
+    } else {
+      await streamRenderDirect(res, job, ctx);
+    }
+  } 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, ctx) {
+  const renderer = new EffieRenderer(job.effie, {
+    transientStore: ctx.transientStore,
+    httpProxy: ctx.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, ctx) {
+  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,
+      ctx
+    );
+    sendEvent("complete", { status: "uploaded", timings });
+  } catch (error) {
+    sendEvent("error", { message: String(error) });
+  } finally {
+    clearInterval(keepalive);
+    res.end();
+  }
+}
+async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx) {
+  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 renderer = new EffieRenderer(effie, {
+    transientStore: ctx.transientStore,
+    httpProxy: ctx.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, ctx) {
+  const backendUrl = `${ctx.renderBackendBaseUrl}/render/${jobId}`;
+  const response = await ffsFetch(backendUrl);
+  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, ctx) {
+  try {
+    const options = req.body;
+    let rawEffieData;
+    if (typeof options.effie === "string") {
+      const response = await ffsFetch(options.effie);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch Effie data: ${response.status} ${response.statusText}`
+        );
+      }
+      rawEffieData = await response.json();
+    } else {
+      rawEffieData = options.effie;
+    }
+    let effie;
+    if (!ctx.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 = options.scale ?? 1;
+    const upload = options.upload;
+    const jobId = randomUUID2();
+    const warmupJobId = randomUUID2();
+    const renderJobId = randomUUID2();
+    const job = {
+      effie,
+      sources,
+      scale,
+      upload,
+      warmupJobId,
+      renderJobId,
+      createdAt: Date.now()
+    };
+    await ctx.transientStore.putJson(
+      storeKeys.warmupAndRenderJob(jobId),
+      job,
+      ctx.transientStore.jobMetadataTtlMs
+    );
+    await ctx.transientStore.putJson(
+      storeKeys.warmupJob(warmupJobId),
+      { sources },
+      ctx.transientStore.jobMetadataTtlMs
+    );
+    await ctx.transientStore.putJson(
+      storeKeys.renderJob(renderJobId),
+      {
+        effie,
+        scale,
+        upload,
+        createdAt: Date.now()
+      },
+      ctx.transientStore.jobMetadataTtlMs
+    );
+    res.json({
+      id: jobId,
+      url: `${ctx.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, ctx) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    const jobCacheKey = storeKeys.warmupAndRenderJob(jobId);
+    const job = await ctx.transientStore.getJson(jobCacheKey);
+    ctx.transientStore.delete(jobCacheKey);
+    if (!job) {
+      res.status(404).json({ error: "Job not found" });
+      return;
+    }
+    setupSSEResponse(res);
+    const sendEvent = createSSEEventSender(res);
+    let keepalivePhase = "warmup";
+    const keepalive = setInterval(() => {
+      sendEvent("keepalive", { phase: keepalivePhase });
+    }, 25e3);
+    try {
+      if (ctx.warmupBackendBaseUrl) {
+        await proxyRemoteSSE(
+          `${ctx.warmupBackendBaseUrl}/warmup/${job.warmupJobId}`,
+          sendEvent,
+          "warmup:",
+          res
+        );
+      } else {
+        const warmupSender = prefixEventSender(sendEvent, "warmup:");
+        await warmupSources(job.sources, warmupSender, ctx);
+        warmupSender("complete", { status: "ready" });
+      }
+      keepalivePhase = "render";
+      if (ctx.renderBackendBaseUrl) {
+        await proxyRemoteSSE(
+          `${ctx.renderBackendBaseUrl}/render/${job.renderJobId}`,
+          sendEvent,
+          "render:",
+          res
+        );
+      } else {
+        const renderSender = prefixEventSender(sendEvent, "render:");
+        if (job.upload) {
+          renderSender("started", { status: "rendering" });
+          const timings = await renderAndUploadInternal(
+            job.effie,
+            job.scale,
+            job.upload,
+            renderSender,
+            ctx
+          );
+          renderSender("complete", { status: "uploaded", timings });
+        } else {
+          const videoUrl = `${ctx.baseUrl}/render/${job.renderJobId}`;
+          sendEvent("complete", { status: "ready", videoUrl });
+        }
+      }
+      if (job.upload && !ctx.renderBackendBaseUrl) {
+        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);
+  };
+}
+async function proxyRemoteSSE(url, sendEvent, prefix, res) {
+  const response = await ffsFetch(url, {
+    headers: {
+      Accept: "text/event-stream"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Remote backend error: ${response.status}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body from remote backend");
+  }
+  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(`${prefix}${currentEvent}`, data);
+          } catch {
+          }
+          currentEvent = "";
+          currentData = "";
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function proxyBinaryStream(response, res) {
+  const contentType = response.headers.get("content-type");
+  if (contentType) res.set("Content-Type", contentType);
+  const contentLength = response.headers.get("content-length");
+  if (contentLength) res.set("Content-Length", contentLength);
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (res.destroyed) {
+        reader.cancel();
+        break;
+      }
+      res.write(value);
+    }
+  } finally {
+    reader.releaseLock();
+    res.end();
+  }
+}
+
+// src/handlers/caching.ts
 function shouldSkipWarmup(source) {
   return source.type === "video" || source.type === "audio";
 }
@@ -205,9 +702,13 @@ async function createWarmupJob(req, res, ctx) {
       res.status(400).json(parseResult);
       return;
     }
-    const sources = extractEffieSourcesWithTypes(parseResult.effie);
-    const jobId = randomUUID();
-    await ctx.cacheStorage.putJson(cacheKeys.warmupJob(jobId), { sources });
+    const sources = extractEffieSourcesWithTypes2(parseResult.effie);
+    const jobId = randomUUID3();
+    await ctx.transientStore.putJson(
+      storeKeys.warmupJob(jobId),
+      { sources },
+      ctx.transientStore.jobMetadataTtlMs
+    );
     res.json({
       id: jobId,
       url: `${ctx.baseUrl}/warmup/${jobId}`
@@ -221,9 +722,24 @@ async function streamWarmupJob(req, res, ctx) {
   try {
     setupCORSHeaders(res);
     const jobId = req.params.id;
-    const jobCacheKey = cacheKeys.warmupJob(jobId);
-    const job = await ctx.cacheStorage.getJson(jobCacheKey);
-    ctx.cacheStorage.delete(jobCacheKey);
+    if (ctx.warmupBackendBaseUrl) {
+      setupSSEResponse(res);
+      const sendEvent2 = createSSEEventSender(res);
+      try {
+        await proxyRemoteSSE(
+          `${ctx.warmupBackendBaseUrl}/warmup/${jobId}`,
+          sendEvent2,
+          "",
+          res
+        );
+      } finally {
+        res.end();
+      }
+      return;
+    }
+    const jobCacheKey = storeKeys.warmupJob(jobId);
+    const job = await ctx.transientStore.getJson(jobCacheKey);
+    ctx.transientStore.delete(jobCacheKey);
     if (!job) {
       res.status(404).json({ error: "Job not found" });
       return;
@@ -257,9 +773,9 @@ async function purgeCache(req, res, ctx) {
     const sources = extractEffieSources(parseResult.effie);
     let purged = 0;
     for (const url of sources) {
-      const ck = cacheKeys.source(url);
-      if (await ctx.cacheStorage.exists(ck)) {
-        await ctx.cacheStorage.delete(ck);
+      const ck = storeKeys.source(url);
+      if (await ctx.transientStore.exists(ck)) {
+        await ctx.transientStore.delete(ck);
         purged++;
       }
     }
@@ -292,8 +808,8 @@ async function warmupSources(sources, sendEvent, ctx) {
       sourcesToCache.push(source);
     }
   }
-  const sourceCacheKeys = sourcesToCache.map((s) => cacheKeys.source(s.url));
-  const existsMap = await ctx.cacheStorage.existsMany(sourceCacheKeys);
+  const sourceCacheKeys = sourcesToCache.map((s) => storeKeys.source(s.url));
+  const existsMap = await ctx.transientStore.existsMany(sourceCacheKeys);
   for (let i = 0; i < sourcesToCache.length; i++) {
     if (existsMap.get(sourceCacheKeys[i])) {
       cached++;
@@ -319,11 +835,11 @@ async function warmupSources(sources, sendEvent, ctx) {
   }, 25e3);
   const queue = [...uncached];
   const workers = Array.from(
-    { length: Math.min(ctx.cacheConcurrency, queue.length) },
+    { length: Math.min(ctx.warmupConcurrency, queue.length) },
     async () => {
       while (queue.length > 0) {
         const source = queue.shift();
-        const cacheKey = cacheKeys.source(source.url);
+        const cacheKey = storeKeys.source(source.url);
         const startTime = Date.now();
         try {
           let fetchPromise = inFlightFetches.get(cacheKey);
@@ -397,203 +913,23 @@ async function fetchAndCache(url, cacheKey, sendEvent, ctx) {
     }
   });
   const trackedStream = sourceStream.pipe(progressStream);
-  await ctx.cacheStorage.put(cacheKey, trackedStream);
-}
-
-// src/handlers/rendering.ts
-import "express";
-import { randomUUID as randomUUID2 } from "crypto";
-import { effieDataSchema as effieDataSchema2 } from "@effing/effie";
-async function createRenderJob(req, res, ctx) {
-  try {
-    const isWrapped = "effie" in req.body;
-    let rawEffieData;
-    let scale;
-    let upload;
-    if (isWrapped) {
-      const options = req.body;
-      if (typeof options.effie === "string") {
-        const response = await ffsFetch(options.effie);
-        if (!response.ok) {
-          throw new Error(
-            `Failed to fetch Effie data: ${response.status} ${response.statusText}`
-          );
-        }
-        rawEffieData = await response.json();
-      } else {
-        rawEffieData = options.effie;
-      }
-      scale = options.scale ?? 1;
-      upload = options.upload;
-    } else {
-      rawEffieData = req.body;
-      scale = parseFloat(req.query.scale?.toString() || "1");
-    }
-    let effie;
-    if (!ctx.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 = randomUUID2();
-    const job = {
-      effie,
-      scale,
-      upload,
-      createdAt: Date.now()
-    };
-    await ctx.cacheStorage.putJson(cacheKeys.renderJob(jobId), job);
-    res.json({
-      id: jobId,
-      url: `${ctx.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, ctx) {
-  try {
-    setupCORSHeaders(res);
-    const jobId = req.params.id;
-    const jobCacheKey = cacheKeys.renderJob(jobId);
-    const job = await ctx.cacheStorage.getJson(jobCacheKey);
-    ctx.cacheStorage.delete(jobCacheKey);
-    if (!job) {
-      res.status(404).json({ error: "Job not found or expired" });
-      return;
-    }
-    if (job.upload) {
-      await streamRenderWithUpload(res, job, ctx);
-    } else {
-      await streamRenderDirect(res, job, ctx);
-    }
-  } 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, ctx) {
-  const renderer = new EffieRenderer(job.effie, {
-    cacheStorage: ctx.cacheStorage,
-    httpProxy: ctx.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, ctx) {
-  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,
-      ctx
-    );
-    sendEvent("complete", { status: "uploaded", timings });
-  } catch (error) {
-    sendEvent("error", { message: String(error) });
-  } finally {
-    clearInterval(keepalive);
-    res.end();
-  }
-}
-async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx) {
-  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 renderer = new EffieRenderer(effie, {
-    cacheStorage: ctx.cacheStorage,
-    httpProxy: ctx.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;
+  await ctx.transientStore.put(
+    cacheKey,
+    trackedStream,
+    ctx.transientStore.sourceTtlMs
+  );
 }
 
 export {
   createServerContext,
+  createRenderJob,
+  streamRenderJob,
+  createWarmupAndRenderJob,
+  streamWarmupAndRenderJob,
+  proxyRemoteSSE,
+  proxyBinaryStream,
   createWarmupJob,
   streamWarmupJob,
-  purgeCache,
-  createRenderJob,
-  streamRenderJob
+  purgeCache
 };
-//# sourceMappingURL=chunk-6YHSYHDY.js.map
+//# sourceMappingURL=chunk-XSCNUWZJ.js.map