@effing/ffs 0.1.1 → 0.2.0

package/dist/server.js

@@ -302,12 +302,160 @@ var cacheKeys = {
   renderJob: renderJobCacheKey
 };
 
+// src/proxy.ts
+import http from "http";
+import { Readable } from "stream";
+
+// src/fetch.ts
+import { fetch, Agent } from "undici";
+async function ffsFetch(url, options) {
+  const {
+    method,
+    body,
+    headers,
+    headersTimeout = 3e5,
+    // 5 minutes
+    bodyTimeout = 3e5
+    // 5 minutes
+  } = options ?? {};
+  const agent = new Agent({ headersTimeout, bodyTimeout });
+  return fetch(url, {
+    method,
+    body,
+    headers: { "User-Agent": "FFS (+https://effing.dev/ffs)", ...headers },
+    dispatcher: agent
+  });
+}
+
+// src/proxy.ts
+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(path3) {
+    if (!path3.startsWith("/http://") && !path3.startsWith("/https://")) {
+      return null;
+    }
+    return path3.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";
-function createServerContext() {
+async function createServerContext() {
   const port2 = process.env.FFS_PORT || 2e3;
+  const httpProxy = new HttpProxy();
+  await httpProxy.start();
   return {
     cacheStorage: createCacheStorage(),
+    httpProxy,
     baseUrl: process.env.FFS_BASE_URL || `http://localhost:${port2}`,
     skipValidation: !!process.env.FFS_SKIP_VALIDATION && process.env.FFS_SKIP_VALIDATION !== "false",
     cacheConcurrency: parseInt(process.env.FFS_CACHE_CONCURRENCY || "4", 10)
@@ -357,32 +505,15 @@ data: ${JSON.stringify(data)}
 
 // src/handlers/caching.ts
 import "express";
-import { Readable, Transform } from "stream";
+import { Readable as Readable2, Transform } from "stream";
 import { randomUUID } from "crypto";
-
-// src/fetch.ts
-import { fetch, Agent } from "undici";
-async function ffsFetch(url, options) {
-  const {
-    method,
-    body,
-    headers,
-    headersTimeout = 3e5,
-    // 5 minutes
-    bodyTimeout = 3e5
-    // 5 minutes
-  } = options ?? {};
-  const agent = new Agent({ headersTimeout, bodyTimeout });
-  return fetch(url, {
-    method,
-    body,
-    headers: { "User-Agent": "FFS (+https://effing.dev/ffs)", ...headers },
-    dispatcher: agent
-  });
+import {
+  extractEffieSources,
+  extractEffieSourcesWithTypes
+} from "@effing/effie";
+function shouldSkipWarmup(source) {
+  return source.type === "video" || source.type === "audio";
 }
-
-// src/handlers/caching.ts
-import { extractEffieSources } from "@effing/effie";
 var inFlightFetches = /* @__PURE__ */ new Map();
 async function createWarmupJob(req, res, ctx2) {
   try {
@@ -391,7 +522,7 @@ async function createWarmupJob(req, res, ctx2) {
       res.status(400).json(parseResult);
       return;
     }
-    const sources = extractEffieSources(parseResult.effie);
+    const sources = extractEffieSourcesWithTypes(parseResult.effie);
     const jobId = randomUUID();
     await ctx2.cacheStorage.putJson(cacheKeys.warmupJob(jobId), { sources });
     res.json({
@@ -457,53 +588,75 @@ async function purgeCache(req, res, ctx2) {
 }
 async function warmupSources(sources, sendEvent, ctx2) {
   const total = sources.length;
-  const sourceCacheKeys = sources.map(cacheKeys.source);
   sendEvent("start", { total });
-  const existsMap = await ctx2.cacheStorage.existsMany(sourceCacheKeys);
   let cached = 0;
   let failed = 0;
-  for (let i = 0; i < sources.length; i++) {
+  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) => cacheKeys.source(s.url));
+  const existsMap = await ctx2.cacheStorage.existsMany(sourceCacheKeys);
+  for (let i = 0; i < sourcesToCache.length; i++) {
     if (existsMap.get(sourceCacheKeys[i])) {
       cached++;
       sendEvent("progress", {
-        url: sources[i],
+        url: sourcesToCache[i].url,
         status: "hit",
         cached,
         failed,
+        skipped,
         total
       });
     }
   }
-  const uncached = sources.filter((_, i) => !existsMap.get(sourceCacheKeys[i]));
+  const uncached = sourcesToCache.filter(
+    (_, i) => !existsMap.get(sourceCacheKeys[i])
+  );
   if (uncached.length === 0) {
-    sendEvent("summary", { cached, failed, total });
+    sendEvent("summary", { cached, failed, skipped, total });
     return;
   }
   const keepalive = setInterval(() => {
-    sendEvent("keepalive", { cached, failed, total });
+    sendEvent("keepalive", { cached, failed, skipped, total });
   }, 25e3);
   const queue = [...uncached];
   const workers = Array.from(
     { length: Math.min(ctx2.cacheConcurrency, queue.length) },
     async () => {
       while (queue.length > 0) {
-        const url = queue.shift();
-        const cacheKey = cacheKeys.source(url);
+        const source = queue.shift();
+        const cacheKey = cacheKeys.source(source.url);
         const startTime = Date.now();
         try {
           let fetchPromise = inFlightFetches.get(cacheKey);
           if (!fetchPromise) {
-            fetchPromise = fetchAndCache(url, cacheKey, sendEvent, ctx2);
+            fetchPromise = fetchAndCache(source.url, cacheKey, sendEvent, ctx2);
             inFlightFetches.set(cacheKey, fetchPromise);
           }
           await fetchPromise;
           inFlightFetches.delete(cacheKey);
           cached++;
           sendEvent("progress", {
-            url,
+            url: source.url,
             status: "cached",
             cached,
             failed,
+            skipped,
             total,
             ms: Date.now() - startTime
           });
@@ -511,11 +664,12 @@ async function warmupSources(sources, sendEvent, ctx2) {
           inFlightFetches.delete(cacheKey);
           failed++;
           sendEvent("progress", {
-            url,
+            url: source.url,
             status: "error",
             error: String(error),
             cached,
             failed,
+            skipped,
             total,
             ms: Date.now() - startTime
           });
@@ -525,7 +679,7 @@ async function warmupSources(sources, sendEvent, ctx2) {
   );
   await Promise.all(workers);
   clearInterval(keepalive);
-  sendEvent("summary", { cached, failed, total });
+  sendEvent("summary", { cached, failed, skipped, total });
 }
 async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
   const response = await ffsFetch(url, {
@@ -538,7 +692,7 @@ async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
     throw new Error(`${response.status} ${response.statusText}`);
   }
   sendEvent("downloading", { url, status: "started", bytesReceived: 0 });
-  const sourceStream = Readable.fromWeb(
+  const sourceStream = Readable2.fromWeb(
     response.body
   );
   let totalBytes = 0;
@@ -568,7 +722,7 @@ import "express";
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/render.ts
-import { Readable as Readable2 } from "stream";
+import { Readable as Readable3 } from "stream";
 import { createReadStream as createReadStream2 } from "fs";
 
 // src/motion.ts
@@ -815,14 +969,14 @@ var FFmpegRunner = class {
   constructor(command) {
     this.command = command;
   }
-  async run(sourceResolver, imageTransformer) {
+  async run(sourceFetcher, imageTransformer, referenceResolver, urlTransformer) {
     const tempDir = await fs2.mkdtemp(path2.join(os2.tmpdir(), "ffs-"));
     const fileMapping = /* @__PURE__ */ new Map();
-    const sourceCache = /* @__PURE__ */ new Map();
-    const fetchAndSaveSource = async (input, inputName) => {
-      const stream = await sourceResolver({
+    const fetchCache = /* @__PURE__ */ new Map();
+    const fetchAndSaveSource = async (input, sourceUrl, inputName) => {
+      const stream = await sourceFetcher({
         type: input.type,
-        src: input.source
+        src: sourceUrl
       });
       if (input.type === "animation") {
         const extractionDir = path2.join(tempDir, inputName);
@@ -864,17 +1018,27 @@ var FFmpegRunner = class {
       this.command.inputs.map(async (input) => {
         if (input.type === "color") return;
         const inputName = `ffmpeg_input_${input.index.toString().padStart(3, "0")}`;
+        const sourceUrl = referenceResolver ? referenceResolver(input.source) : input.source;
+        if ((input.type === "video" || input.type === "audio") && (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://"))) {
+          const finalUrl = urlTransformer ? urlTransformer(sourceUrl) : sourceUrl;
+          fileMapping.set(input.index, finalUrl);
+          return;
+        }
         const shouldCache = input.source.startsWith("#");
         if (shouldCache) {
-          let fetchPromise = sourceCache.get(input.source);
+          let fetchPromise = fetchCache.get(input.source);
           if (!fetchPromise) {
-            fetchPromise = fetchAndSaveSource(input, inputName);
-            sourceCache.set(input.source, fetchPromise);
+            fetchPromise = fetchAndSaveSource(input, sourceUrl, inputName);
+            fetchCache.set(input.source, fetchPromise);
           }
           const filePath = await fetchPromise;
           fileMapping.set(input.index, filePath);
         } else {
-          const filePath = await fetchAndSaveSource(input, inputName);
+          const filePath = await fetchAndSaveSource(
+            input,
+            sourceUrl,
+            inputName
+          );
           fileMapping.set(input.index, filePath);
         }
       })
@@ -970,19 +1134,14 @@ var EffieRenderer = class {
   ffmpegRunner;
   allowLocalFiles;
   cacheStorage;
+  httpProxy;
   constructor(effieData, options) {
     this.effieData = effieData;
     this.allowLocalFiles = options?.allowLocalFiles ?? false;
     this.cacheStorage = options?.cacheStorage;
+    this.httpProxy = options?.httpProxy;
   }
   async fetchSource(src) {
-    if (src.startsWith("#")) {
-      const sourceName = src.slice(1);
-      if (!(sourceName in this.effieData.sources)) {
-        throw new Error(`Named source "${sourceName}" not found`);
-      }
-      src = this.effieData.sources[sourceName];
-    }
     if (src.startsWith("data:")) {
       const commaIndex = src.indexOf(",");
       if (commaIndex === -1) {
@@ -992,7 +1151,7 @@ var EffieRenderer = class {
       const isBase64 = meta.endsWith(";base64");
       const data = src.slice(commaIndex + 1);
       const buffer = isBase64 ? Buffer.from(data, "base64") : Buffer.from(decodeURIComponent(data));
-      return Readable2.from(buffer);
+      return Readable3.from(buffer);
     }
     if (src.startsWith("file:")) {
       if (!this.allowLocalFiles) {
@@ -1024,7 +1183,7 @@ var EffieRenderer = class {
     if (!response.body) {
       throw new Error(`No body for ${src}`);
     }
-    return Readable2.fromWeb(response.body);
+    return Readable3.fromWeb(response.body);
   }
   buildAudioFilter({
     duration,
@@ -1276,6 +1435,12 @@ var EffieRenderer = class {
         segmentBgInputIndices.push(null);
       }
     }
+    const globalBgSegmentIndices = [];
+    for (let i = 0; i < this.effieData.segments.length; i++) {
+      if (segmentBgInputIndices[i] === null) {
+        globalBgSegmentIndices.push(i);
+      }
+    }
     for (const segment of this.effieData.segments) {
       for (const layer of segment.layers) {
         inputs.push(this.buildLayerInput(layer, segment.duration, inputIndex));
@@ -1312,6 +1477,26 @@ var EffieRenderer = class {
     const filterParts = [];
     const videoSegmentLabels = [];
     const audioSegmentLabels = [];
+    const globalBgFifoLabels = /* @__PURE__ */ new Map();
+    const bgFilter = `fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight}:force_original_aspect_ratio=increase,crop=${frameWidth}:${frameHeight}`;
+    if (globalBgSegmentIndices.length === 1) {
+      const fifoLabel = `bg_fifo_0`;
+      filterParts.push(`[${globalBgInputIdx}:v]${bgFilter},fifo[${fifoLabel}]`);
+      globalBgFifoLabels.set(globalBgSegmentIndices[0], fifoLabel);
+    } else if (globalBgSegmentIndices.length > 1) {
+      const splitCount = globalBgSegmentIndices.length;
+      const splitOutputLabels = globalBgSegmentIndices.map(
+        (_, i) => `bg_split_${i}`
+      );
+      filterParts.push(
+        `[${globalBgInputIdx}:v]${bgFilter},split=${splitCount}${splitOutputLabels.map((l) => `[${l}]`).join("")}`
+      );
+      for (let i = 0; i < splitCount; i++) {
+        const fifoLabel = `bg_fifo_${i}`;
+        filterParts.push(`[${splitOutputLabels[i]}]fifo[${fifoLabel}]`);
+        globalBgFifoLabels.set(globalBgSegmentIndices[i], fifoLabel);
+      }
+    }
     for (let segIdx = 0; segIdx < this.effieData.segments.length; segIdx++) {
       const segment = this.effieData.segments[segIdx];
       const bgLabel = `bg_seg${segIdx}`;
@@ -1322,9 +1507,12 @@ var EffieRenderer = class {
           `[${segBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},trim=start=${segBgSeek}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
         );
       } else {
-        filterParts.push(
-          `[${globalBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},trim=start=${backgroundSeek + currentTime}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
-        );
+        const fifoLabel = globalBgFifoLabels.get(segIdx);
+        if (fifoLabel) {
+          filterParts.push(
+            `[${fifoLabel}]trim=start=${backgroundSeek + currentTime}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
+          );
+        }
       }
       const vidLabel = `vid_seg${segIdx}`;
       filterParts.push(
@@ -1408,6 +1596,20 @@ var EffieRenderer = class {
       }
     };
   }
+  /**
+   * Resolves a source reference to its actual URL.
+   * If the source is a #reference, returns the resolved URL.
+   * Otherwise, returns the source as-is.
+   */
+  resolveReference(src) {
+    if (src.startsWith("#")) {
+      const sourceName = src.slice(1);
+      if (sourceName in this.effieData.sources) {
+        return this.effieData.sources[sourceName];
+      }
+    }
+    return src;
+  }
   /**
    * Renders the effie data to a video stream.
    * @param scaleFactor - Scale factor for output dimensions
@@ -1415,9 +1617,12 @@ var EffieRenderer = class {
   async render(scaleFactor = 1) {
     const ffmpegCommand = this.buildFFmpegCommand("-", scaleFactor);
     this.ffmpegRunner = new FFmpegRunner(ffmpegCommand);
+    const urlTransformer = this.httpProxy ? (url) => this.httpProxy.transformUrl(url) : void 0;
     return this.ffmpegRunner.run(
       async ({ src }) => this.fetchSource(src),
-      this.createImageTransformer(scaleFactor)
+      this.createImageTransformer(scaleFactor),
+      (src) => this.resolveReference(src),
+      urlTransformer
     );
   }
   close() {
@@ -1520,7 +1725,8 @@ async function streamRenderJob(req, res, ctx2) {
 }
 async function streamRenderDirect(res, job, ctx2) {
   const renderer = new EffieRenderer(job.effie, {
-    cacheStorage: ctx2.cacheStorage
+    cacheStorage: ctx2.cacheStorage,
+    httpProxy: ctx2.httpProxy
   });
   const videoStream = await renderer.render(job.scale);
   res.on("close", () => {
@@ -1582,7 +1788,10 @@ async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
     timings.uploadCoverTime = Date.now() - uploadCoverStartTime;
   }
   const renderStartTime = Date.now();
-  const renderer = new EffieRenderer(effie, { cacheStorage: ctx2.cacheStorage });
+  const renderer = new EffieRenderer(effie, {
+    cacheStorage: ctx2.cacheStorage,
+    httpProxy: ctx2.httpProxy
+  });
   const videoStream = await renderer.render(scale);
   const chunks = [];
   for await (const chunk of videoStream) {
@@ -1612,7 +1821,8 @@ async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
 // src/server.ts
 var app = express4();
 app.use(bodyParser.json({ limit: "50mb" }));
-var ctx = createServerContext();
+var ctx = await createServerContext();
+console.log(`FFS HTTP proxy listening on port ${ctx.httpProxy.port}`);
 function validateAuth(req, res) {
   const apiKey = process.env.FFS_API_KEY;
   if (!apiKey) return true;
@@ -1643,6 +1853,7 @@ var server = app.listen(port, () => {
 });
 function shutdown() {
   console.log("Shutting down FFS server...");
+  ctx.httpProxy.close();
   ctx.cacheStorage.close();
   server.close(() => {
     console.log("FFS server stopped");

package/dist/server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/server.ts"],"sourcesContent":["import express from \"express\";\nimport bodyParser from \"body-parser\";\nimport {\n  createServerContext,\n  createWarmupJob,\n  streamWarmupJob,\n  purgeCache,\n  createRenderJob,\n  streamRenderJob,\n} from \"./handlers\";\n\nconst app: express.Express = express();\napp.use(bodyParser.json({ limit: \"50mb\" })); // Support large JSON requests\n\nconst ctx = createServerContext();\n\nfunction validateAuth(req: express.Request, res: express.Response): boolean {\n  const apiKey = process.env.FFS_API_KEY;\n  if (!apiKey) return true; // No auth required if api key not set\n\n  const authHeader = req.headers.authorization;\n  if (!authHeader || authHeader !== `Bearer ${apiKey}`) {\n    res.status(401).json({ error: \"Unauthorized\" });\n    return false;\n  }\n  return true;\n}\n\n// Routes with auth (POST endpoints)\napp.post(\"/warmup\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  createWarmupJob(req, res, ctx);\n});\napp.post(\"/purge\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  purgeCache(req, res, ctx);\n});\napp.post(\"/render\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  createRenderJob(req, res, ctx);\n});\n\n// Routes without auth (GET endpoints use job ID as capability token)\napp.get(\"/warmup/:id\", (req, res) => streamWarmupJob(req, res, ctx));\napp.get(\"/render/:id\", (req, res) => streamRenderJob(req, res, ctx));\n\n// Server lifecycle\nconst port = process.env.FFS_PORT || 2000; // ffmpeg was conceived in the year 2000\nconst server = app.listen(port, () => {\n  console.log(`FFS server listening on port ${port}`);\n});\n\nfunction shutdown() {\n  console.log(\"Shutting down FFS server...\");\n  ctx.cacheStorage.close();\n  server.close(() => {\n    console.log(\"FFS server stopped\");\n    process.exit(0);\n  });\n}\n\nprocess.on(\"SIGTERM\", shutdown);\nprocess.on(\"SIGINT\", shutdown);\n\nexport { app };\n"],"mappings":";;;;;;;;;;;AAAA,OAAO,aAAa;AACpB,OAAO,gBAAgB;AAUvB,IAAM,MAAuB,QAAQ;AACrC,IAAI,IAAI,WAAW,KAAK,EAAE,OAAO,OAAO,CAAC,CAAC;AAE1C,IAAM,MAAM,oBAAoB;AAEhC,SAAS,aAAa,KAAsB,KAAgC;AAC1E,QAAM,SAAS,QAAQ,IAAI;AAC3B,MAAI,CAAC,OAAQ,QAAO;AAEpB,QAAM,aAAa,IAAI,QAAQ;AAC/B,MAAI,CAAC,cAAc,eAAe,UAAU,MAAM,IAAI;AACpD,QAAI,OAAO,GAAG,EAAE,KAAK,EAAE,OAAO,eAAe,CAAC;AAC9C,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAGA,IAAI,KAAK,WAAW,CAAC,KAAK,QAAQ;AAChC,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,kBAAgB,KAAK,KAAK,GAAG;AAC/B,CAAC;AACD,IAAI,KAAK,UAAU,CAAC,KAAK,QAAQ;AAC/B,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,aAAW,KAAK,KAAK,GAAG;AAC1B,CAAC;AACD,IAAI,KAAK,WAAW,CAAC,KAAK,QAAQ;AAChC,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,kBAAgB,KAAK,KAAK,GAAG;AAC/B,CAAC;AAGD,IAAI,IAAI,eAAe,CAAC,KAAK,QAAQ,gBAAgB,KAAK,KAAK,GAAG,CAAC;AACnE,IAAI,IAAI,eAAe,CAAC,KAAK,QAAQ,gBAAgB,KAAK,KAAK,GAAG,CAAC;AAGnE,IAAM,OAAO,QAAQ,IAAI,YAAY;AACrC,IAAM,SAAS,IAAI,OAAO,MAAM,MAAM;AACpC,UAAQ,IAAI,gCAAgC,IAAI,EAAE;AACpD,CAAC;AAED,SAAS,WAAW;AAClB,UAAQ,IAAI,6BAA6B;AACzC,MAAI,aAAa,MAAM;AACvB,SAAO,MAAM,MAAM;AACjB,YAAQ,IAAI,oBAAoB;AAChC,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACH;AAEA,QAAQ,GAAG,WAAW,QAAQ;AAC9B,QAAQ,GAAG,UAAU,QAAQ;","names":[]}
+{"version":3,"sources":["../src/server.ts"],"sourcesContent":["import express from \"express\";\nimport bodyParser from \"body-parser\";\nimport {\n  createServerContext,\n  createWarmupJob,\n  streamWarmupJob,\n  purgeCache,\n  createRenderJob,\n  streamRenderJob,\n} from \"./handlers\";\n\nconst app: express.Express = express();\napp.use(bodyParser.json({ limit: \"50mb\" })); // Support large JSON requests\n\nconst ctx = await createServerContext();\nconsole.log(`FFS HTTP proxy listening on port ${ctx.httpProxy.port}`);\n\nfunction validateAuth(req: express.Request, res: express.Response): boolean {\n  const apiKey = process.env.FFS_API_KEY;\n  if (!apiKey) return true; // No auth required if api key not set\n\n  const authHeader = req.headers.authorization;\n  if (!authHeader || authHeader !== `Bearer ${apiKey}`) {\n    res.status(401).json({ error: \"Unauthorized\" });\n    return false;\n  }\n  return true;\n}\n\n// Routes with auth (POST endpoints)\napp.post(\"/warmup\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  createWarmupJob(req, res, ctx);\n});\napp.post(\"/purge\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  purgeCache(req, res, ctx);\n});\napp.post(\"/render\", (req, res) => {\n  if (!validateAuth(req, res)) return;\n  createRenderJob(req, res, ctx);\n});\n\n// Routes without auth (GET endpoints use job ID as capability token)\napp.get(\"/warmup/:id\", (req, res) => streamWarmupJob(req, res, ctx));\napp.get(\"/render/:id\", (req, res) => streamRenderJob(req, res, ctx));\n\n// Server lifecycle\nconst port = process.env.FFS_PORT || 2000; // ffmpeg was conceived in the year 2000\nconst server = app.listen(port, () => {\n  console.log(`FFS server listening on port ${port}`);\n});\n\nfunction shutdown() {\n  console.log(\"Shutting down FFS server...\");\n  ctx.httpProxy.close();\n  ctx.cacheStorage.close();\n  server.close(() => {\n    console.log(\"FFS server stopped\");\n    process.exit(0);\n  });\n}\n\nprocess.on(\"SIGTERM\", shutdown);\nprocess.on(\"SIGINT\", shutdown);\n\nexport { app };\n"],"mappings":";;;;;;;;;;;AAAA,OAAO,aAAa;AACpB,OAAO,gBAAgB;AAUvB,IAAM,MAAuB,QAAQ;AACrC,IAAI,IAAI,WAAW,KAAK,EAAE,OAAO,OAAO,CAAC,CAAC;AAE1C,IAAM,MAAM,MAAM,oBAAoB;AACtC,QAAQ,IAAI,oCAAoC,IAAI,UAAU,IAAI,EAAE;AAEpE,SAAS,aAAa,KAAsB,KAAgC;AAC1E,QAAM,SAAS,QAAQ,IAAI;AAC3B,MAAI,CAAC,OAAQ,QAAO;AAEpB,QAAM,aAAa,IAAI,QAAQ;AAC/B,MAAI,CAAC,cAAc,eAAe,UAAU,MAAM,IAAI;AACpD,QAAI,OAAO,GAAG,EAAE,KAAK,EAAE,OAAO,eAAe,CAAC;AAC9C,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAGA,IAAI,KAAK,WAAW,CAAC,KAAK,QAAQ;AAChC,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,kBAAgB,KAAK,KAAK,GAAG;AAC/B,CAAC;AACD,IAAI,KAAK,UAAU,CAAC,KAAK,QAAQ;AAC/B,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,aAAW,KAAK,KAAK,GAAG;AAC1B,CAAC;AACD,IAAI,KAAK,WAAW,CAAC,KAAK,QAAQ;AAChC,MAAI,CAAC,aAAa,KAAK,GAAG,EAAG;AAC7B,kBAAgB,KAAK,KAAK,GAAG;AAC/B,CAAC;AAGD,IAAI,IAAI,eAAe,CAAC,KAAK,QAAQ,gBAAgB,KAAK,KAAK,GAAG,CAAC;AACnE,IAAI,IAAI,eAAe,CAAC,KAAK,QAAQ,gBAAgB,KAAK,KAAK,GAAG,CAAC;AAGnE,IAAM,OAAO,QAAQ,IAAI,YAAY;AACrC,IAAM,SAAS,IAAI,OAAO,MAAM,MAAM;AACpC,UAAQ,IAAI,gCAAgC,IAAI,EAAE;AACpD,CAAC;AAED,SAAS,WAAW;AAClB,UAAQ,IAAI,6BAA6B;AACzC,MAAI,UAAU,MAAM;AACpB,MAAI,aAAa,MAAM;AACvB,SAAO,MAAM,MAAM;AACjB,YAAQ,IAAI,oBAAoB;AAChC,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACH;AAEA,QAAQ,GAAG,WAAW,QAAQ;AAC9B,QAAQ,GAAG,UAAU,QAAQ;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effing/ffs",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "FFmpeg-based effie rendering service",
   "type": "module",
   "exports": {
@@ -33,7 +33,7 @@
     "tar-stream": "^3.1.7",
     "undici": "^7.3.0",
     "zod": "^3.25.76",
-    "@effing/effie": "0.1.1"
+    "@effing/effie": "0.2.0"
   },
   "devDependencies": {
     "@types/body-parser": "^1.19.5",

package/dist/cache-BUVFfGZF.d.ts

@@ -1,25 +0,0 @@
-import { Readable } from 'stream';
-
-/**
- * Cache storage interface
- */
-interface CacheStorage {
-    /** Store a stream with the given key */
-    put(key: string, stream: Readable): Promise<void>;
-    /** Get a stream for the given key, or null if not found */
-    getStream(key: string): Promise<Readable | null>;
-    /** Check if a key exists */
-    exists(key: string): Promise<boolean>;
-    /** Check if multiple keys exist (batch operation) */
-    existsMany(keys: string[]): Promise<Map<string, boolean>>;
-    /** Delete a key */
-    delete(key: string): Promise<void>;
-    /** Store JSON data */
-    putJson(key: string, data: object): Promise<void>;
-    /** Get JSON data, or null if not found */
-    getJson<T>(key: string): Promise<T | null>;
-    /** Close and cleanup resources */
-    close(): void;
-}
-
-export type { CacheStorage as C };