@effing/ffs 0.1.2 → 0.3.0

package/dist/chunk-XSCNUWZJ.js

@@ -0,0 +1,935 @@
+import {
+  EffieRenderer,
+  createTransientStore,
+  ffsFetch,
+  storeKeys
+} from "./chunk-J64HSZNQ.js";
+
+// src/handlers/shared.ts
+import "express";
+
+// src/proxy.ts
+import http from "http";
+import { Readable } from "stream";
+var HttpProxy = class {
+  server = null;
+  _port = null;
+  startPromise = null;
+  get port() {
+    return this._port;
+  }
+  /**
+   * Transform a URL to go through the proxy.
+   * @throws Error if proxy not started
+   */
+  transformUrl(url) {
+    if (this._port === null) throw new Error("Proxy not started");
+    return `http://127.0.0.1:${this._port}/${url}`;
+  }
+  /**
+   * Start the proxy server. Safe to call multiple times.
+   */
+  async start() {
+    if (this._port !== null) return;
+    if (this.startPromise) {
+      await this.startPromise;
+      return;
+    }
+    this.startPromise = this.doStart();
+    await this.startPromise;
+  }
+  async doStart() {
+    this.server = http.createServer(async (req, res) => {
+      try {
+        const originalUrl = this.parseProxyPath(req.url || "");
+        if (!originalUrl) {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Bad Request: invalid proxy path");
+          return;
+        }
+        const response = await ffsFetch(originalUrl, {
+          method: req.method,
+          headers: this.filterHeaders(req.headers),
+          bodyTimeout: 0
+          // No timeout for streaming
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        res.writeHead(response.status, headers);
+        if (response.body) {
+          const nodeStream = Readable.fromWeb(response.body);
+          nodeStream.pipe(res);
+          nodeStream.on("error", (err) => {
+            console.error("Proxy stream error:", err);
+            res.destroy();
+          });
+        } else {
+          res.end();
+        }
+      } catch (err) {
+        console.error("Proxy request error:", err);
+        if (!res.headersSent) {
+          res.writeHead(502, { "Content-Type": "text/plain" });
+          res.end("Bad Gateway");
+        } else {
+          res.destroy();
+        }
+      }
+    });
+    await new Promise((resolve) => {
+      this.server.listen(0, "127.0.0.1", () => {
+        this._port = this.server.address().port;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Parse the proxy path to extract the original URL.
+   * Path format: /{originalUrl}
+   */
+  parseProxyPath(path) {
+    if (!path.startsWith("/http://") && !path.startsWith("/https://")) {
+      return null;
+    }
+    return path.slice(1);
+  }
+  /**
+   * Filter headers to forward to the upstream server.
+   * Removes hop-by-hop headers that shouldn't be forwarded.
+   */
+  filterHeaders(headers) {
+    const skip = /* @__PURE__ */ new Set([
+      "host",
+      "connection",
+      "keep-alive",
+      "transfer-encoding",
+      "te",
+      "trailer",
+      "upgrade",
+      "proxy-authorization",
+      "proxy-authenticate"
+    ]);
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (!skip.has(key.toLowerCase()) && typeof value === "string") {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Close the proxy server and reset state.
+   */
+  close() {
+    this.server?.close();
+    this.server = null;
+    this._port = null;
+    this.startPromise = null;
+  }
+};
+
+// src/handlers/shared.ts
+import { effieDataSchema } from "@effing/effie";
+async function createServerContext() {
+  const port = process.env.FFS_PORT || 2e3;
+  const httpProxy = new HttpProxy();
+  await httpProxy.start();
+  return {
+    transientStore: createTransientStore(),
+    httpProxy,
+    baseUrl: process.env.FFS_BASE_URL || `http://localhost:${port}`,
+    skipValidation: !!process.env.FFS_SKIP_VALIDATION && process.env.FFS_SKIP_VALIDATION !== "false",
+    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) {
+  const isWrapped = typeof body === "object" && body !== null && "effie" in body;
+  const rawEffieData = isWrapped ? body.effie : body;
+  if (!skipValidation) {
+    const result = effieDataSchema.safeParse(rawEffieData);
+    if (!result.success) {
+      return {
+        error: "Invalid effie data",
+        issues: result.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      };
+    }
+    return { effie: result.data };
+  } else {
+    const effie = rawEffieData;
+    if (!effie?.segments) {
+      return { error: "Invalid effie data: missing segments" };
+    }
+    return { effie };
+  }
+}
+function setupCORSHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET");
+}
+function setupSSEResponse(res) {
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+}
+function createSSEEventSender(res) {
+  return (event, data) => {
+    res.write(`event: ${event}
+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, 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";
+}
+var inFlightFetches = /* @__PURE__ */ new Map();
+async function createWarmupJob(req, res, ctx) {
+  try {
+    const parseResult = parseEffieData(req.body, ctx.skipValidation);
+    if ("error" in parseResult) {
+      res.status(400).json(parseResult);
+      return;
+    }
+    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}`
+    });
+  } catch (error) {
+    console.error("Error creating warmup job:", error);
+    res.status(500).json({ error: "Failed to create warmup job" });
+  }
+}
+async function streamWarmupJob(req, res, ctx) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    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;
+    }
+    setupSSEResponse(res);
+    const sendEvent = createSSEEventSender(res);
+    try {
+      await warmupSources(job.sources, sendEvent, ctx);
+      sendEvent("complete", { status: "ready" });
+    } catch (error) {
+      sendEvent("error", { message: String(error) });
+    } finally {
+      res.end();
+    }
+  } catch (error) {
+    console.error("Error in warmup streaming:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Warmup streaming failed" });
+    } else {
+      res.end();
+    }
+  }
+}
+async function purgeCache(req, res, ctx) {
+  try {
+    const parseResult = parseEffieData(req.body, ctx.skipValidation);
+    if ("error" in parseResult) {
+      res.status(400).json(parseResult);
+      return;
+    }
+    const sources = extractEffieSources(parseResult.effie);
+    let purged = 0;
+    for (const url of sources) {
+      const ck = storeKeys.source(url);
+      if (await ctx.transientStore.exists(ck)) {
+        await ctx.transientStore.delete(ck);
+        purged++;
+      }
+    }
+    res.json({ purged, total: sources.length });
+  } catch (error) {
+    console.error("Error purging cache:", error);
+    res.status(500).json({ error: "Failed to purge cache" });
+  }
+}
+async function warmupSources(sources, sendEvent, ctx) {
+  const total = sources.length;
+  sendEvent("start", { total });
+  let cached = 0;
+  let failed = 0;
+  let skipped = 0;
+  const sourcesToCache = [];
+  for (const source of sources) {
+    if (shouldSkipWarmup(source)) {
+      skipped++;
+      sendEvent("progress", {
+        url: source.url,
+        status: "skipped",
+        reason: "http-video-audio-passthrough",
+        cached,
+        failed,
+        skipped,
+        total
+      });
+    } else {
+      sourcesToCache.push(source);
+    }
+  }
+  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++;
+      sendEvent("progress", {
+        url: sourcesToCache[i].url,
+        status: "hit",
+        cached,
+        failed,
+        skipped,
+        total
+      });
+    }
+  }
+  const uncached = sourcesToCache.filter(
+    (_, i) => !existsMap.get(sourceCacheKeys[i])
+  );
+  if (uncached.length === 0) {
+    sendEvent("summary", { cached, failed, skipped, total });
+    return;
+  }
+  const keepalive = setInterval(() => {
+    sendEvent("keepalive", { cached, failed, skipped, total });
+  }, 25e3);
+  const queue = [...uncached];
+  const workers = Array.from(
+    { length: Math.min(ctx.warmupConcurrency, queue.length) },
+    async () => {
+      while (queue.length > 0) {
+        const source = queue.shift();
+        const cacheKey = storeKeys.source(source.url);
+        const startTime = Date.now();
+        try {
+          let fetchPromise = inFlightFetches.get(cacheKey);
+          if (!fetchPromise) {
+            fetchPromise = fetchAndCache(source.url, cacheKey, sendEvent, ctx);
+            inFlightFetches.set(cacheKey, fetchPromise);
+          }
+          await fetchPromise;
+          inFlightFetches.delete(cacheKey);
+          cached++;
+          sendEvent("progress", {
+            url: source.url,
+            status: "cached",
+            cached,
+            failed,
+            skipped,
+            total,
+            ms: Date.now() - startTime
+          });
+        } catch (error) {
+          inFlightFetches.delete(cacheKey);
+          failed++;
+          sendEvent("progress", {
+            url: source.url,
+            status: "error",
+            error: String(error),
+            cached,
+            failed,
+            skipped,
+            total,
+            ms: Date.now() - startTime
+          });
+        }
+      }
+    }
+  );
+  await Promise.all(workers);
+  clearInterval(keepalive);
+  sendEvent("summary", { cached, failed, skipped, total });
+}
+async function fetchAndCache(url, cacheKey, sendEvent, ctx) {
+  const response = await ffsFetch(url, {
+    headersTimeout: 10 * 60 * 1e3,
+    // 10 minutes
+    bodyTimeout: 20 * 60 * 1e3
+    // 20 minutes
+  });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  sendEvent("downloading", { url, status: "started", bytesReceived: 0 });
+  const sourceStream = Readable2.fromWeb(
+    response.body
+  );
+  let totalBytes = 0;
+  let lastEventTime = Date.now();
+  const PROGRESS_INTERVAL = 1e4;
+  const progressStream = new Transform({
+    transform(chunk, _encoding, callback) {
+      totalBytes += chunk.length;
+      const now = Date.now();
+      if (now - lastEventTime >= PROGRESS_INTERVAL) {
+        sendEvent("downloading", {
+          url,
+          status: "downloading",
+          bytesReceived: totalBytes
+        });
+        lastEventTime = now;
+      }
+      callback(null, chunk);
+    }
+  });
+  const trackedStream = sourceStream.pipe(progressStream);
+  await ctx.transientStore.put(
+    cacheKey,
+    trackedStream,
+    ctx.transientStore.sourceTtlMs
+  );
+}
+
+export {
+  createServerContext,
+  createRenderJob,
+  streamRenderJob,
+  createWarmupAndRenderJob,
+  streamWarmupAndRenderJob,
+  proxyRemoteSSE,
+  proxyBinaryStream,
+  createWarmupJob,
+  streamWarmupJob,
+  purgeCache
+};
+//# sourceMappingURL=chunk-XSCNUWZJ.js.map