@effing/ffs 0.4.1 → 0.6.0

package/dist/server.js

@@ -1,511 +1,20 @@
 #!/usr/bin/env node
+import {
+  createTransientStore,
+  ffsFetch,
+  storeKeys
+} from "./chunk-PERB3C4S.js";
 
 // src/server.ts
 import express5 from "express";
 import bodyParser from "body-parser";
 
-// src/ffmpeg.ts
-import { execFileSync, spawn } from "child_process";
-import { pipeline } from "stream";
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-import pathToFFmpeg from "ffmpeg-static";
-import tar from "tar-stream";
-import { createWriteStream } from "fs";
-import { promisify } from "util";
-var pump = promisify(pipeline);
-var ffmpegBin = process.env.FFMPEG ?? pathToFFmpeg;
-function getFFmpegVersion() {
-  return execFileSync(ffmpegBin, ["-version"], { encoding: "utf8" }).split("\n")[0].trim();
-}
-var FFmpegCommand = class {
-  globalArgs;
-  inputs;
-  filterComplex;
-  outputArgs;
-  constructor(globalArgs, inputs, filterComplex, outputArgs) {
-    this.globalArgs = globalArgs;
-    this.inputs = inputs;
-    this.filterComplex = filterComplex;
-    this.outputArgs = outputArgs;
-  }
-  buildArgs(inputResolver) {
-    const inputArgs = [];
-    for (const input of this.inputs) {
-      if (input.type === "color") {
-        inputArgs.push(...input.preArgs);
-      } else if (input.type === "animation") {
-        inputArgs.push(
-          ...input.preArgs,
-          "-i",
-          path.join(inputResolver(input), "frame_%05d")
-        );
-      } else {
-        inputArgs.push(...input.preArgs, "-i", inputResolver(input));
-      }
-    }
-    const args = [
-      ...this.globalArgs,
-      ...inputArgs,
-      "-filter_complex",
-      this.filterComplex,
-      ...this.outputArgs
-    ];
-    return args;
-  }
-};
-var FFmpegRunner = class {
-  command;
-  ffmpegProc;
-  constructor(command) {
-    this.command = command;
-  }
-  async run(sourceFetcher, imageTransformer, referenceResolver, urlTransformer) {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ffs-"));
-    const fileMapping = /* @__PURE__ */ new Map();
-    const fetchCache = /* @__PURE__ */ new Map();
-    const fetchAndSaveSource = async (input, sourceUrl, inputName) => {
-      const stream = await sourceFetcher({
-        type: input.type,
-        src: sourceUrl
-      });
-      if (input.type === "animation") {
-        const extractionDir = path.join(tempDir, inputName);
-        await fs.mkdir(extractionDir, { recursive: true });
-        const extract = tar.extract();
-        const extractPromise = new Promise((resolve, reject) => {
-          extract.on("entry", async (header, stream2, next) => {
-            if (header.name.startsWith("frame_")) {
-              const transformedStream = imageTransformer ? await imageTransformer(stream2) : stream2;
-              const outputPath = path.join(extractionDir, header.name);
-              const writeStream = createWriteStream(outputPath);
-              transformedStream.pipe(writeStream);
-              writeStream.on("finish", next);
-              writeStream.on("error", reject);
-            }
-          });
-          extract.on("finish", resolve);
-          extract.on("error", reject);
-        });
-        stream.pipe(extract);
-        await extractPromise;
-        return extractionDir;
-      } else if (input.type === "image" && imageTransformer) {
-        const tempFile = path.join(tempDir, inputName);
-        const transformedStream = await imageTransformer(stream);
-        const writeStream = createWriteStream(tempFile);
-        transformedStream.on("error", (e) => writeStream.destroy(e));
-        await pump(transformedStream, writeStream);
-        return tempFile;
-      } else {
-        const tempFile = path.join(tempDir, inputName);
-        const writeStream = createWriteStream(tempFile);
-        stream.on("error", (e) => writeStream.destroy(e));
-        await pump(stream, writeStream);
-        return tempFile;
-      }
-    };
-    await Promise.all(
-      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 = fetchCache.get(input.source);
-          if (!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,
-            sourceUrl,
-            inputName
-          );
-          fileMapping.set(input.index, filePath);
-        }
-      })
-    );
-    const finalArgs = this.command.buildArgs((input) => {
-      const filePath = fileMapping.get(input.index);
-      if (!filePath)
-        throw new Error(`File for input index ${input.index} not found`);
-      return filePath;
-    });
-    const ffmpegProc = spawn(ffmpegBin, finalArgs);
-    ffmpegProc.stderr.on("data", (data) => {
-      console.error(data.toString());
-    });
-    ffmpegProc.on("close", async () => {
-      try {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      } catch (err) {
-        console.error("Error removing temp directory:", err);
-      }
-    });
-    this.ffmpegProc = ffmpegProc;
-    return ffmpegProc.stdout;
-  }
-  close() {
-    if (this.ffmpegProc) {
-      this.ffmpegProc.kill("SIGTERM");
-      this.ffmpegProc = void 0;
-    }
-  }
-};
-
 // src/handlers/shared.ts
 import "express";
 
-// src/storage.ts
-import {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand,
-  HeadObjectCommand,
-  DeleteObjectCommand
-} from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import fs2 from "fs/promises";
-import { createReadStream, createWriteStream as createWriteStream2, existsSync } from "fs";
-import { pipeline as pipeline2 } from "stream/promises";
-import path2 from "path";
-import os2 from "os";
-import crypto from "crypto";
-var DEFAULT_SOURCE_TTL_MS = 60 * 60 * 1e3;
-var DEFAULT_JOB_METADATA_TTL_MS = 8 * 60 * 60 * 1e3;
-var S3TransientStore = class {
-  client;
-  bucket;
-  prefix;
-  sourceTtlMs;
-  jobMetadataTtlMs;
-  constructor(options) {
-    this.client = new S3Client({
-      endpoint: options.endpoint,
-      region: options.region ?? "auto",
-      credentials: options.accessKeyId ? {
-        accessKeyId: options.accessKeyId,
-        secretAccessKey: options.secretAccessKey
-      } : void 0,
-      forcePathStyle: !!options.endpoint
-    });
-    this.bucket = options.bucket;
-    this.prefix = options.prefix ?? "";
-    this.sourceTtlMs = options.sourceTtlMs ?? DEFAULT_SOURCE_TTL_MS;
-    this.jobMetadataTtlMs = options.jobMetadataTtlMs ?? DEFAULT_JOB_METADATA_TTL_MS;
-  }
-  getExpires(ttlMs) {
-    return new Date(Date.now() + ttlMs);
-  }
-  getFullKey(key) {
-    return `${this.prefix}${key}`;
-  }
-  async put(key, stream, ttlMs) {
-    const upload = new Upload({
-      client: this.client,
-      params: {
-        Bucket: this.bucket,
-        Key: this.getFullKey(key),
-        Body: stream,
-        Expires: this.getExpires(ttlMs ?? this.sourceTtlMs)
-      }
-    });
-    await upload.done();
-  }
-  async getStream(key) {
-    try {
-      const response = await this.client.send(
-        new GetObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      return response.Body;
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return null;
-      }
-      throw err;
-    }
-  }
-  async exists(key) {
-    try {
-      await this.client.send(
-        new HeadObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      return true;
-    } catch (err) {
-      const error = err;
-      if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) {
-        return false;
-      }
-      throw err;
-    }
-  }
-  async existsMany(keys) {
-    const results = await Promise.all(
-      keys.map(async (key) => [key, await this.exists(key)])
-    );
-    return new Map(results);
-  }
-  async delete(key) {
-    try {
-      await this.client.send(
-        new DeleteObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return;
-      }
-      throw err;
-    }
-  }
-  async putJson(key, data, ttlMs) {
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: this.getFullKey(key),
-        Body: JSON.stringify(data),
-        ContentType: "application/json",
-        Expires: this.getExpires(ttlMs ?? this.jobMetadataTtlMs)
-      })
-    );
-  }
-  async getJson(key) {
-    try {
-      const response = await this.client.send(
-        new GetObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      const body = await response.Body?.transformToString();
-      if (!body) return null;
-      return JSON.parse(body);
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return null;
-      }
-      throw err;
-    }
-  }
-  close() {
-  }
-};
-var LocalTransientStore = class {
-  baseDir;
-  initialized = false;
-  cleanupInterval;
-  sourceTtlMs;
-  jobMetadataTtlMs;
-  /** For cleanup, use the longer of the two TTLs */
-  maxTtlMs;
-  constructor(options) {
-    this.baseDir = options?.baseDir ?? path2.join(os2.tmpdir(), "ffs-transient");
-    this.sourceTtlMs = options?.sourceTtlMs ?? DEFAULT_SOURCE_TTL_MS;
-    this.jobMetadataTtlMs = options?.jobMetadataTtlMs ?? DEFAULT_JOB_METADATA_TTL_MS;
-    this.maxTtlMs = Math.max(this.sourceTtlMs, this.jobMetadataTtlMs);
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupExpired().catch(console.error);
-    }, 3e5);
-  }
-  /**
-   * Remove files older than max TTL
-   */
-  async cleanupExpired() {
-    if (!this.initialized) return;
-    const now = Date.now();
-    await this.cleanupDir(this.baseDir, now);
-  }
-  async cleanupDir(dir, now) {
-    let entries;
-    try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await this.cleanupDir(fullPath, now);
-        try {
-          await fs2.rmdir(fullPath);
-        } catch {
-        }
-      } else if (entry.isFile()) {
-        try {
-          const stat = await fs2.stat(fullPath);
-          if (now - stat.mtimeMs > this.maxTtlMs) {
-            await fs2.rm(fullPath, { force: true });
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  async ensureDir(filePath) {
-    await fs2.mkdir(path2.dirname(filePath), { recursive: true });
-    this.initialized = true;
-  }
-  filePath(key) {
-    return path2.join(this.baseDir, key);
-  }
-  tmpPathFor(finalPath) {
-    const rand = crypto.randomBytes(8).toString("hex");
-    return `${finalPath}.tmp-${process.pid}-${rand}`;
-  }
-  async put(key, stream, _ttlMs) {
-    const fp = this.filePath(key);
-    await this.ensureDir(fp);
-    const tmpPath = this.tmpPathFor(fp);
-    try {
-      const writeStream = createWriteStream2(tmpPath);
-      await pipeline2(stream, writeStream);
-      await fs2.rename(tmpPath, fp);
-    } catch (err) {
-      await fs2.rm(tmpPath, { force: true }).catch(() => {
-      });
-      throw err;
-    }
-  }
-  async getStream(key) {
-    const fp = this.filePath(key);
-    if (!existsSync(fp)) return null;
-    return createReadStream(fp);
-  }
-  async exists(key) {
-    try {
-      await fs2.access(this.filePath(key));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async existsMany(keys) {
-    const results = await Promise.all(
-      keys.map(async (key) => [key, await this.exists(key)])
-    );
-    return new Map(results);
-  }
-  async delete(key) {
-    await fs2.rm(this.filePath(key), { force: true });
-  }
-  async putJson(key, data, _ttlMs) {
-    const fp = this.filePath(key);
-    await this.ensureDir(fp);
-    const tmpPath = this.tmpPathFor(fp);
-    try {
-      await fs2.writeFile(tmpPath, JSON.stringify(data));
-      await fs2.rename(tmpPath, fp);
-    } catch (err) {
-      await fs2.rm(tmpPath, { force: true }).catch(() => {
-      });
-      throw err;
-    }
-  }
-  async getJson(key) {
-    try {
-      const content = await fs2.readFile(this.filePath(key), "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = void 0;
-    }
-  }
-};
-function createTransientStore() {
-  const sourceTtlMs = process.env.FFS_SOURCE_CACHE_TTL_MS ? parseInt(process.env.FFS_SOURCE_CACHE_TTL_MS, 10) : DEFAULT_SOURCE_TTL_MS;
-  const jobMetadataTtlMs = process.env.FFS_JOB_METADATA_TTL_MS ? parseInt(process.env.FFS_JOB_METADATA_TTL_MS, 10) : DEFAULT_JOB_METADATA_TTL_MS;
-  if (process.env.FFS_TRANSIENT_STORE_BUCKET) {
-    return new S3TransientStore({
-      endpoint: process.env.FFS_TRANSIENT_STORE_ENDPOINT,
-      region: process.env.FFS_TRANSIENT_STORE_REGION ?? "auto",
-      bucket: process.env.FFS_TRANSIENT_STORE_BUCKET,
-      prefix: process.env.FFS_TRANSIENT_STORE_PREFIX,
-      accessKeyId: process.env.FFS_TRANSIENT_STORE_ACCESS_KEY,
-      secretAccessKey: process.env.FFS_TRANSIENT_STORE_SECRET_KEY,
-      sourceTtlMs,
-      jobMetadataTtlMs
-    });
-  }
-  return new LocalTransientStore({
-    baseDir: process.env.FFS_TRANSIENT_STORE_LOCAL_DIR,
-    sourceTtlMs,
-    jobMetadataTtlMs
-  });
-}
-function hashUrl(url) {
-  return crypto.createHash("sha256").update(url).digest("hex").slice(0, 16);
-}
-function sourceStoreKey(url) {
-  return `sources/${hashUrl(url)}`;
-}
-function warmupJobStoreKey(jobId) {
-  return `jobs/warmup/${jobId}.json`;
-}
-function renderJobStoreKey(jobId) {
-  return `jobs/render/${jobId}.json`;
-}
-function warmupAndRenderJobStoreKey(jobId) {
-  return `jobs/warmup-and-render/${jobId}.json`;
-}
-var storeKeys = {
-  source: sourceStoreKey,
-  warmupJob: warmupJobStoreKey,
-  renderJob: renderJobStoreKey,
-  warmupAndRenderJob: warmupAndRenderJobStoreKey
-};
-
 // 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;
@@ -584,11 +93,11 @@ var HttpProxy = class {
    * Parse the proxy path to extract the original URL.
    * Path format: /{originalUrl}
    */
-  parseProxyPath(path3) {
-    if (!path3.startsWith("/http://") && !path3.startsWith("/https://")) {
+  parseProxyPath(path) {
+    if (!path.startsWith("/http://") && !path.startsWith("/https://")) {
       return null;
     }
-    return path3.slice(1);
+    return path.slice(1);
   }
   /**
    * Filter headers to forward to the upstream server.
@@ -627,20 +136,22 @@ var HttpProxy = class {
 
 // src/handlers/shared.ts
 import { effieDataSchema } from "@effing/effie";
-async function createServerContext() {
+async function createServerContext(options) {
   const port2 = process.env.FFS_PORT || process.env.PORT || 2e3;
-  const httpProxy = new HttpProxy();
-  await httpProxy.start();
+  const enableHttpProxy = options?.httpProxy ?? !options?.renderBackendResolver;
+  let httpProxy;
+  if (enableHttpProxy) {
+    httpProxy = new HttpProxy();
+    await httpProxy.start();
+  }
   return {
     transientStore: createTransientStore(),
     httpProxy,
     baseUrl: process.env.FFS_BASE_URL || `http://localhost:${port2}`,
     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,
-    warmupBackendApiKey: process.env.FFS_WARMUP_BACKEND_API_KEY,
-    renderBackendApiKey: process.env.FFS_RENDER_BACKEND_API_KEY
+    warmupBackendResolver: options?.warmupBackendResolver,
+    renderBackendResolver: options?.renderBackendResolver
   };
 }
 function parseEffieData(body, skipValidation) {
@@ -687,7 +198,7 @@ data: ${JSON.stringify(data)}
 
 // src/handlers/caching.ts
 import "express";
-import { Readable as Readable3, Transform } from "stream";
+import { Readable as Readable2, Transform } from "stream";
 import { randomUUID as randomUUID3 } from "crypto";
 import {
   extractEffieSources,
@@ -702,775 +213,17 @@ import { extractEffieSourcesWithTypes, effieDataSchema as effieDataSchema3 } fro
 // src/handlers/rendering.ts
 import "express";
 import { randomUUID } from "crypto";
-
-// src/render.ts
-import { Readable as Readable2 } from "stream";
-import { createReadStream as createReadStream2 } from "fs";
-
-// src/motion.ts
-function getEasingExpression(tNormExpr, easingType) {
-  switch (easingType) {
-    case "ease-in":
-      return `pow(${tNormExpr},2)`;
-    case "ease-out":
-      return `(1-pow(1-(${tNormExpr}),2))`;
-    case "ease-in-out":
-      return `if(lt(${tNormExpr},0.5),2*pow(${tNormExpr},2),1-pow(-2*(${tNormExpr})+2,2)/2)`;
-    case "linear":
-    default:
-      return `(${tNormExpr})`;
-  }
-}
-function processSlideMotion(motion, relativeTimeExpr) {
-  const duration = motion.duration ?? 1;
-  const distance = motion.distance ?? 1;
-  const reverse = motion.reverse ?? false;
-  const easing = motion.easing ?? "linear";
-  const tNormExpr = `(${relativeTimeExpr})/${duration}`;
-  const easedProgressExpr = getEasingExpression(tNormExpr, easing);
-  const finalTimeFactorExpr = reverse ? easedProgressExpr : `(1-(${easedProgressExpr}))`;
-  let activeX;
-  let activeY;
-  let initialX;
-  let initialY;
-  let finalX;
-  let finalY;
-  switch (motion.direction) {
-    case "left": {
-      const offsetXLeft = `${distance}*W`;
-      activeX = `(${offsetXLeft})*${finalTimeFactorExpr}`;
-      activeY = "0";
-      initialX = reverse ? "0" : offsetXLeft;
-      initialY = "0";
-      finalX = reverse ? offsetXLeft : "0";
-      finalY = "0";
-      break;
-    }
-    case "right": {
-      const offsetXRight = `-${distance}*W`;
-      activeX = `(${offsetXRight})*${finalTimeFactorExpr}`;
-      activeY = "0";
-      initialX = reverse ? "0" : offsetXRight;
-      initialY = "0";
-      finalX = reverse ? offsetXRight : "0";
-      finalY = "0";
-      break;
-    }
-    case "up": {
-      const offsetYUp = `${distance}*H`;
-      activeX = "0";
-      activeY = `(${offsetYUp})*${finalTimeFactorExpr}`;
-      initialX = "0";
-      initialY = reverse ? "0" : offsetYUp;
-      finalX = "0";
-      finalY = reverse ? offsetYUp : "0";
-      break;
-    }
-    case "down": {
-      const offsetYDown = `-${distance}*H`;
-      activeX = "0";
-      activeY = `(${offsetYDown})*${finalTimeFactorExpr}`;
-      initialX = "0";
-      initialY = reverse ? "0" : offsetYDown;
-      finalX = "0";
-      finalY = reverse ? offsetYDown : "0";
-      break;
-    }
-  }
-  return { initialX, initialY, activeX, activeY, finalX, finalY, duration };
-}
-function processBounceMotion(motion, relativeTimeExpr) {
-  const amplitude = motion.amplitude ?? 0.5;
-  const duration = motion.duration ?? 1;
-  const initialY = `-overlay_h*${amplitude}`;
-  const finalY = "0";
-  const tNormExpr = `(${relativeTimeExpr})/${duration}`;
-  const activeBounceExpression = `if(lt(${tNormExpr},0.363636),${initialY}+overlay_h*${amplitude}*(7.5625*${tNormExpr}*${tNormExpr}),if(lt(${tNormExpr},0.727273),${initialY}+overlay_h*${amplitude}*(7.5625*(${tNormExpr}-0.545455)*(${tNormExpr}-0.545455)+0.75),if(lt(${tNormExpr},0.909091),${initialY}+overlay_h*${amplitude}*(7.5625*(${tNormExpr}-0.818182)*(${tNormExpr}-0.818182)+0.9375),if(lt(${tNormExpr},0.954545),${initialY}+overlay_h*${amplitude}*(7.5625*(${tNormExpr}-0.954545)*(${tNormExpr}-0.954545)+0.984375),${finalY}))))`;
-  return {
-    initialX: "0",
-    initialY,
-    activeX: "0",
-    activeY: activeBounceExpression,
-    // This expression now scales with duration
-    finalX: "0",
-    finalY,
-    duration
-    // Return the actual duration used
-  };
-}
-function processShakeMotion(motion, relativeTimeExpr) {
-  const intensity = motion.intensity ?? 10;
-  const frequency = motion.frequency ?? 4;
-  const duration = motion.duration ?? 1;
-  const activeX = `${intensity}*sin(${relativeTimeExpr}*PI*${frequency})`;
-  const activeY = `${intensity}*cos(${relativeTimeExpr}*PI*${frequency})`;
-  return {
-    initialX: "0",
-    initialY: "0",
-    activeX,
-    activeY,
-    finalX: "0",
-    finalY: "0",
-    duration
-  };
-}
-function processMotion(delay, motion) {
-  if (!motion) return "x=0:y=0";
-  const start = delay + (motion.start ?? 0);
-  const relativeTimeExpr = `(t-${start})`;
-  let components;
-  switch (motion.type) {
-    case "bounce":
-      components = processBounceMotion(motion, relativeTimeExpr);
-      break;
-    case "shake":
-      components = processShakeMotion(motion, relativeTimeExpr);
-      break;
-    case "slide":
-      components = processSlideMotion(motion, relativeTimeExpr);
-      break;
-    default:
-      motion;
-      throw new Error(
-        `Unsupported motion type: ${motion.type}`
-      );
-  }
-  const motionEndTime = start + components.duration;
-  const xArg = `if(lt(t,${start}),${components.initialX},if(lt(t,${motionEndTime}),${components.activeX},${components.finalX}))`;
-  const yArg = `if(lt(t,${start}),${components.initialY},if(lt(t,${motionEndTime}),${components.activeY},${components.finalY}))`;
-  return `x='${xArg}':y='${yArg}'`;
-}
-
-// src/effect.ts
-function processFadeIn(effect, _frameRate, _frameWidth, _frameHeight) {
-  return `fade=t=in:st=${effect.start}:d=${effect.duration}:alpha=1`;
-}
-function processFadeOut(effect, _frameRate, _frameWidth, _frameHeight) {
-  return `fade=t=out:st=${effect.start}:d=${effect.duration}:alpha=1`;
-}
-function processSaturateIn(effect, _frameRate, _frameWidth, _frameHeight) {
-  return `hue='s=max(0,min(1,(t-${effect.start})/${effect.duration}))'`;
-}
-function processSaturateOut(effect, _frameRate, _frameWidth, _frameHeight) {
-  return `hue='s=max(0,min(1,(${effect.start + effect.duration}-t)/${effect.duration}))'`;
-}
-function processScroll(effect, frameRate, _frameWidth, _frameHeight) {
-  const distance = effect.distance ?? 1;
-  const scroll = distance / (1 + distance);
-  const speed = scroll / (effect.duration * frameRate);
-  switch (effect.direction) {
-    case "left":
-      return `scroll=h=${speed}`;
-    case "right":
-      return `scroll=hpos=${1 - scroll}:h=-${speed}`;
-    case "up":
-      return `scroll=v=${speed}`;
-    case "down":
-      return `scroll=vpos=${1 - scroll}:v=-${speed}`;
-  }
-}
-function processEffect(effect, frameRate, frameWidth, frameHeight) {
-  switch (effect.type) {
-    case "fade-in":
-      return processFadeIn(effect, frameRate, frameWidth, frameHeight);
-    case "fade-out":
-      return processFadeOut(effect, frameRate, frameWidth, frameHeight);
-    case "saturate-in":
-      return processSaturateIn(effect, frameRate, frameWidth, frameHeight);
-    case "saturate-out":
-      return processSaturateOut(effect, frameRate, frameWidth, frameHeight);
-    case "scroll":
-      return processScroll(effect, frameRate, frameWidth, frameHeight);
-    default:
-      effect;
-      throw new Error(
-        `Unsupported effect type: ${effect.type}`
-      );
-  }
-}
-function processEffects(effects, frameRate, frameWidth, frameHeight) {
-  if (!effects || effects.length === 0) return "";
-  const filters = [];
-  for (const effect of effects) {
-    const filter = processEffect(effect, frameRate, frameWidth, frameHeight);
-    filters.push(filter);
-  }
-  return filters.join(",");
-}
-
-// src/transition.ts
-function processTransition(transition) {
-  switch (transition.type) {
-    case "fade": {
-      if ("through" in transition) {
-        return `fade${transition.through}`;
-      }
-      const easing = transition.easing ?? "linear";
-      return {
-        linear: "fade",
-        "ease-in": "fadeslow",
-        "ease-out": "fadefast"
-      }[easing];
-    }
-    case "barn": {
-      const orientation = transition.orientation ?? "horizontal";
-      const mode = transition.mode ?? "open";
-      const prefix = orientation === "vertical" ? "vert" : "horz";
-      return `${prefix}${mode}`;
-    }
-    case "circle": {
-      const mode = transition.mode ?? "open";
-      return `circle${mode}`;
-    }
-    case "wipe":
-    case "slide":
-    case "smooth": {
-      const direction = transition.direction ?? "left";
-      return `${transition.type}${direction}`;
-    }
-    case "slice": {
-      const direction = transition.direction ?? "left";
-      const prefix = {
-        left: "hl",
-        right: "hr",
-        up: "vu",
-        down: "vd"
-      }[direction];
-      return `${prefix}${transition.type}`;
-    }
-    case "zoom": {
-      return "zoomin";
-    }
-    case "dissolve":
-    case "pixelize":
-    case "radial":
-      return transition.type;
-    default:
-      transition;
-      throw new Error(
-        `Unsupported transition type: ${transition.type}`
-      );
-  }
-}
-
-// src/render.ts
-import sharp from "sharp";
-import { fileURLToPath } from "url";
-var EffieRenderer = class {
-  effieData;
-  ffmpegRunner;
-  allowLocalFiles;
-  transientStore;
-  httpProxy;
-  constructor(effieData, options) {
-    this.effieData = effieData;
-    this.allowLocalFiles = options?.allowLocalFiles ?? false;
-    this.transientStore = options?.transientStore;
-    this.httpProxy = options?.httpProxy;
-  }
-  async fetchSource(src) {
-    if (src.startsWith("data:")) {
-      const commaIndex = src.indexOf(",");
-      if (commaIndex === -1) {
-        throw new Error("Invalid data URL");
-      }
-      const meta = src.slice(5, commaIndex);
-      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);
-    }
-    if (src.startsWith("file:")) {
-      if (!this.allowLocalFiles) {
-        throw new Error(
-          "Local file paths are not allowed. Use allowLocalFiles option for trusted operations."
-        );
-      }
-      return createReadStream2(fileURLToPath(src));
-    }
-    if (this.transientStore) {
-      const cachedStream = await this.transientStore.getStream(
-        storeKeys.source(src)
-      );
-      if (cachedStream) {
-        return cachedStream;
-      }
-    }
-    const response = await ffsFetch(src, {
-      headersTimeout: 10 * 60 * 1e3,
-      // 10 minutes
-      bodyTimeout: 20 * 60 * 1e3
-      // 20 minutes
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch ${src}: ${response.status} ${response.statusText}`
-      );
-    }
-    if (!response.body) {
-      throw new Error(`No body for ${src}`);
-    }
-    return Readable2.fromWeb(response.body);
-  }
-  buildAudioFilter({
-    duration,
-    volume,
-    fadeIn,
-    fadeOut
-  }) {
-    const filters = [];
-    if (volume !== void 0) {
-      filters.push(`volume=${volume}`);
-    }
-    if (fadeIn !== void 0) {
-      filters.push(`afade=type=in:start_time=0:duration=${fadeIn}`);
-    }
-    if (fadeOut !== void 0) {
-      filters.push(
-        `afade=type=out:start_time=${duration - fadeOut}:duration=${fadeOut}`
-      );
-    }
-    return filters.length ? filters.join(",") : "anull";
-  }
-  getFrameDimensions(scaleFactor) {
-    return {
-      frameWidth: Math.floor(this.effieData.width * scaleFactor / 2) * 2,
-      frameHeight: Math.floor(this.effieData.height * scaleFactor / 2) * 2
-    };
-  }
-  /**
-   * Builds an FFmpeg input for a background (global or segment).
-   */
-  buildBackgroundInput(background, inputIndex, frameWidth, frameHeight) {
-    if (background.type === "image") {
-      return {
-        index: inputIndex,
-        source: background.source,
-        preArgs: ["-loop", "1", "-framerate", this.effieData.fps.toString()],
-        type: "image"
-      };
-    } else if (background.type === "video") {
-      return {
-        index: inputIndex,
-        source: background.source,
-        preArgs: ["-stream_loop", "-1"],
-        type: "video"
-      };
-    }
-    return {
-      index: inputIndex,
-      source: "",
-      preArgs: [
-        "-f",
-        "lavfi",
-        "-i",
-        `color=${background.color}:size=${frameWidth}x${frameHeight}:rate=${this.effieData.fps}`
-      ],
-      type: "color"
-    };
-  }
-  buildOutputArgs(outputFilename) {
-    return [
-      "-map",
-      "[outv]",
-      "-map",
-      "[outa]",
-      "-c:v",
-      "libx264",
-      "-r",
-      this.effieData.fps.toString(),
-      "-pix_fmt",
-      "yuv420p",
-      "-preset",
-      "fast",
-      "-crf",
-      "28",
-      "-c:a",
-      "aac",
-      "-movflags",
-      "frag_keyframe+empty_moov",
-      "-f",
-      "mp4",
-      outputFilename
-    ];
-  }
-  buildLayerInput(layer, duration, inputIndex) {
-    let preArgs = [];
-    if (layer.type === "image") {
-      preArgs = [
-        "-loop",
-        "1",
-        "-t",
-        duration.toString(),
-        "-framerate",
-        this.effieData.fps.toString()
-      ];
-    } else if (layer.type === "animation") {
-      preArgs = ["-f", "image2", "-framerate", this.effieData.fps.toString()];
-    }
-    return {
-      index: inputIndex,
-      source: layer.source,
-      preArgs,
-      type: layer.type
-    };
-  }
-  /**
-   * Builds filter chain for all layers in a segment.
-   * @param segment - The segment containing layers
-   * @param bgLabel - Label for the background input (e.g., "bg_seg0" or "bg_seg")
-   * @param labelPrefix - Prefix for generated labels (e.g., "seg0_" or "")
-   * @param layerInputOffset - Starting input index for layers
-   * @param frameWidth - Frame width for nullsrc
-   * @param frameHeight - Frame height for nullsrc
-   * @param outputLabel - Label for the final video output
-   * @returns Array of filter parts to add to the filter chain
-   */
-  buildLayerFilters(segment, bgLabel, labelPrefix, layerInputOffset, frameWidth, frameHeight, outputLabel) {
-    const filterParts = [];
-    let currentVidLabel = bgLabel;
-    for (let l = 0; l < segment.layers.length; l++) {
-      const inputIdx = layerInputOffset + l;
-      const layerLabel = `${labelPrefix}layer${l}`;
-      const layer = segment.layers[l];
-      const effectChain = layer.effects ? processEffects(
-        layer.effects,
-        this.effieData.fps,
-        frameWidth,
-        frameHeight
-      ) : "";
-      filterParts.push(
-        `[${inputIdx}:v]trim=start=0:duration=${segment.duration},${effectChain ? effectChain + "," : ""}setsar=1,setpts=PTS-STARTPTS[${layerLabel}]`
-      );
-      let overlayInputLabel = layerLabel;
-      const delay = layer.delay ?? 0;
-      if (delay > 0) {
-        filterParts.push(
-          `nullsrc=size=${frameWidth}x${frameHeight}:duration=${delay},setpts=PTS-STARTPTS[null_${layerLabel}]`
-        );
-        filterParts.push(
-          `[null_${layerLabel}][${layerLabel}]concat=n=2:v=1:a=0[delayed_${layerLabel}]`
-        );
-        overlayInputLabel = `delayed_${layerLabel}`;
-      }
-      const overlayOutputLabel = `${labelPrefix}tmp${l}`;
-      const offset = layer.motion ? processMotion(delay, layer.motion) : "0:0";
-      const fromTime = layer.from ?? 0;
-      const untilTime = layer.until ?? segment.duration;
-      filterParts.push(
-        `[${currentVidLabel}][${overlayInputLabel}]overlay=${offset}:enable='between(t,${fromTime},${untilTime})',fps=${this.effieData.fps}[${overlayOutputLabel}]`
-      );
-      currentVidLabel = overlayOutputLabel;
-    }
-    filterParts.push(`[${currentVidLabel}]null[${outputLabel}]`);
-    return filterParts;
-  }
-  /**
-   * Applies xfade/concat transitions between video segments.
-   * Modifies videoSegmentLabels in place to update labels after transitions.
-   * @param filterParts - Array to append filter parts to
-   * @param videoSegmentLabels - Array of video segment labels (modified in place)
-   */
-  applyTransitions(filterParts, videoSegmentLabels) {
-    let transitionOffset = 0;
-    this.effieData.segments.forEach((segment, i) => {
-      if (i === 0) {
-        transitionOffset = segment.duration;
-        return;
-      }
-      const combineLabel = `[vid_com${i}]`;
-      if (!segment.transition) {
-        transitionOffset += segment.duration;
-        filterParts.push(
-          `${videoSegmentLabels[i - 1]}${videoSegmentLabels[i]}concat=n=2:v=1:a=0,fps=${this.effieData.fps}${combineLabel}`
-        );
-        videoSegmentLabels[i] = combineLabel;
-        return;
-      }
-      const transitionName = processTransition(segment.transition);
-      const transitionDuration = segment.transition.duration;
-      transitionOffset -= transitionDuration;
-      filterParts.push(
-        `${videoSegmentLabels[i - 1]}${videoSegmentLabels[i]}xfade=transition=${transitionName}:duration=${transitionDuration}:offset=${transitionOffset}${combineLabel}`
-      );
-      videoSegmentLabels[i] = combineLabel;
-      transitionOffset += segment.duration;
-    });
-    filterParts.push(`${videoSegmentLabels.at(-1)}null[outv]`);
-  }
-  /**
-   * Applies general audio mixing: concats segment audio and mixes with global audio if present.
-   * @param filterParts - Array to append filter parts to
-   * @param audioSegmentLabels - Array of audio segment labels to concat
-   * @param totalDuration - Total duration for audio trimming
-   * @param generalAudioInputIndex - Input index for general audio (if present)
-   */
-  applyGeneralAudio(filterParts, audioSegmentLabels, totalDuration, generalAudioInputIndex) {
-    if (this.effieData.audio) {
-      const audioSeek = this.effieData.audio.seek ?? 0;
-      const generalAudioFilter = this.buildAudioFilter({
-        duration: totalDuration,
-        volume: this.effieData.audio.volume,
-        fadeIn: this.effieData.audio.fadeIn,
-        fadeOut: this.effieData.audio.fadeOut
-      });
-      filterParts.push(
-        `[${generalAudioInputIndex}:a]atrim=start=${audioSeek}:duration=${totalDuration},${generalAudioFilter},asetpts=PTS-STARTPTS[general_audio]`
-      );
-      filterParts.push(
-        `${audioSegmentLabels.join("")}concat=n=${this.effieData.segments.length}:v=0:a=1,atrim=start=0:duration=${totalDuration}[segments_audio]`
-      );
-      filterParts.push(
-        `[general_audio][segments_audio]amix=inputs=2:duration=longest[outa]`
-      );
-    } else {
-      filterParts.push(
-        `${audioSegmentLabels.join("")}concat=n=${this.effieData.segments.length}:v=0:a=1[outa]`
-      );
-    }
-  }
-  buildFFmpegCommand(outputFilename, scaleFactor = 1) {
-    const globalArgs = ["-y", "-loglevel", "error"];
-    const inputs = [];
-    let inputIndex = 0;
-    const { frameWidth, frameHeight } = this.getFrameDimensions(scaleFactor);
-    const backgroundSeek = this.effieData.background.type === "video" ? this.effieData.background.seek ?? 0 : 0;
-    inputs.push(
-      this.buildBackgroundInput(
-        this.effieData.background,
-        inputIndex,
-        frameWidth,
-        frameHeight
-      )
-    );
-    const globalBgInputIdx = inputIndex;
-    inputIndex++;
-    const segmentBgInputIndices = [];
-    for (const segment of this.effieData.segments) {
-      if (segment.background) {
-        inputs.push(
-          this.buildBackgroundInput(
-            segment.background,
-            inputIndex,
-            frameWidth,
-            frameHeight
-          )
-        );
-        segmentBgInputIndices.push(inputIndex);
-        inputIndex++;
-      } else {
-        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));
-        inputIndex++;
-      }
-    }
-    for (const segment of this.effieData.segments) {
-      if (segment.audio) {
-        inputs.push({
-          index: inputIndex,
-          source: segment.audio.source,
-          preArgs: [],
-          type: "audio"
-        });
-        inputIndex++;
-      }
-    }
-    if (this.effieData.audio) {
-      inputs.push({
-        index: inputIndex,
-        source: this.effieData.audio.source,
-        preArgs: [],
-        type: "audio"
-      });
-      inputIndex++;
-    }
-    const numSegmentBgInputs = segmentBgInputIndices.filter(
-      (i) => i !== null
-    ).length;
-    const numVideoInputs = 1 + numSegmentBgInputs + this.effieData.segments.reduce((sum, seg) => sum + seg.layers.length, 0);
-    let audioCounter = 0;
-    let currentTime = 0;
-    let layerInputOffset = 1 + numSegmentBgInputs;
-    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}`;
-      if (segment.background) {
-        const segBgInputIdx = segmentBgInputIndices[segIdx];
-        const segBgSeek = segment.background.type === "video" ? segment.background.seek ?? 0 : 0;
-        filterParts.push(
-          `[${segBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},trim=start=${segBgSeek}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
-        );
-      } else {
-        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(
-        ...this.buildLayerFilters(
-          segment,
-          bgLabel,
-          `seg${segIdx}_`,
-          layerInputOffset,
-          frameWidth,
-          frameHeight,
-          vidLabel
-        )
-      );
-      layerInputOffset += segment.layers.length;
-      videoSegmentLabels.push(`[${vidLabel}]`);
-      const nextSegment = this.effieData.segments[segIdx + 1];
-      const transitionDuration = nextSegment?.transition?.duration ?? 0;
-      const realDuration = Math.max(
-        1e-3,
-        segment.duration - transitionDuration
-      );
-      if (segment.audio) {
-        const audioInputIndex = numVideoInputs + audioCounter;
-        const audioFilter = this.buildAudioFilter({
-          duration: realDuration,
-          volume: segment.audio.volume,
-          fadeIn: segment.audio.fadeIn,
-          fadeOut: segment.audio.fadeOut
-        });
-        filterParts.push(
-          `[${audioInputIndex}:a]atrim=start=0:duration=${realDuration},${audioFilter},asetpts=PTS-STARTPTS[aud_seg${segIdx}]`
-        );
-        audioCounter++;
-      } else {
-        filterParts.push(
-          `anullsrc=r=44100:cl=stereo,atrim=start=0:duration=${realDuration},asetpts=PTS-STARTPTS[aud_seg${segIdx}]`
-        );
-      }
-      audioSegmentLabels.push(`[aud_seg${segIdx}]`);
-      currentTime += realDuration;
-    }
-    this.applyGeneralAudio(
-      filterParts,
-      audioSegmentLabels,
-      currentTime,
-      numVideoInputs + audioCounter
-    );
-    this.applyTransitions(filterParts, videoSegmentLabels);
-    const filterComplex = filterParts.join(";");
-    const outputArgs = this.buildOutputArgs(outputFilename);
-    return new FFmpegCommand(globalArgs, inputs, filterComplex, outputArgs);
-  }
-  createImageTransformer(scaleFactor) {
-    return async (imageStream) => {
-      if (scaleFactor === 1) return imageStream;
-      const sharpTransformer = sharp();
-      imageStream.on("error", (err) => {
-        if (!sharpTransformer.destroyed) {
-          sharpTransformer.destroy(err);
-        }
-      });
-      sharpTransformer.on("error", (err) => {
-        if (!imageStream.destroyed) {
-          imageStream.destroy(err);
-        }
-      });
-      imageStream.pipe(sharpTransformer);
-      try {
-        const metadata = await sharpTransformer.metadata();
-        const imageWidth = metadata.width ?? this.effieData.width;
-        const imageHeight = metadata.height ?? this.effieData.height;
-        return sharpTransformer.resize({
-          width: Math.floor(imageWidth * scaleFactor),
-          height: Math.floor(imageHeight * scaleFactor)
-        });
-      } catch (error) {
-        if (!sharpTransformer.destroyed) {
-          sharpTransformer.destroy(error);
-        }
-        throw error;
-      }
-    };
-  }
-  /**
-   * 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
-   */
-  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),
-      (src) => this.resolveReference(src),
-      urlTransformer
-    );
-  }
-  close() {
-    if (this.ffmpegRunner) {
-      this.ffmpegRunner.close();
-    }
-  }
-};
-
-// src/handlers/rendering.ts
 import { effieDataSchema as effieDataSchema2 } from "@effing/effie";
-async function createRenderJob(req, res, ctx2) {
+async function createRenderJob(req, res, ctx2, options) {
   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);
+      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}`
@@ -1478,10 +231,10 @@ async function createRenderJob(req, res, ctx2) {
         }
         rawEffieData = await response.json();
       } else {
-        rawEffieData = options.effie;
+        rawEffieData = options2.effie;
       }
-      scale = options.scale ?? 1;
-      upload = options.upload;
+      scale = options2.scale ?? 1;
+      upload = options2.upload;
     } else {
       rawEffieData = req.body;
       scale = parseFloat(req.query.scale?.toString() || "1");
@@ -1513,12 +266,13 @@ async function createRenderJob(req, res, ctx2) {
       effie,
       scale,
       upload,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      metadata: options?.metadata
     };
     await ctx2.transientStore.putJson(
       storeKeys.renderJob(jobId),
       job,
-      ctx2.transientStore.jobMetadataTtlMs
+      ctx2.transientStore.jobDataTtlMs
     );
     res.json({
       id: jobId,
@@ -1533,17 +287,20 @@ async function streamRenderJob(req, res, ctx2) {
   try {
     setupCORSHeaders(res);
     const jobId = req.params.id;
-    if (ctx2.renderBackendBaseUrl) {
-      await proxyRenderFromBackend(res, jobId, ctx2);
-      return;
-    }
-    const jobCacheKey = storeKeys.renderJob(jobId);
-    const job = await ctx2.transientStore.getJson(jobCacheKey);
-    ctx2.transientStore.delete(jobCacheKey);
+    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 {
@@ -1559,6 +316,7 @@ async function streamRenderJob(req, res, ctx2) {
   }
 }
 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
@@ -1623,6 +381,7 @@ async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
     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
@@ -1652,10 +411,10 @@ async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
   timings.uploadTime = Date.now() - uploadStartTime;
   return timings;
 }
-async function proxyRenderFromBackend(res, jobId, ctx2) {
-  const backendUrl = `${ctx2.renderBackendBaseUrl}/render/${jobId}`;
+async function proxyRenderFromBackend(res, jobId, backend) {
+  const backendUrl = `${backend.baseUrl}/render/${jobId}`;
   const response = await ffsFetch(backendUrl, {
-    headers: ctx2.renderBackendApiKey ? { Authorization: `Bearer ${ctx2.renderBackendApiKey}` } : void 0
+    headers: backend.apiKey ? { Authorization: `Bearer ${backend.apiKey}` } : void 0
   });
   if (!response.ok) {
     res.status(response.status).json({ error: "Backend render failed" });
@@ -1712,12 +471,12 @@ async function proxyRenderFromBackend(res, jobId, ctx2) {
 }
 
 // src/handlers/orchestrating.ts
-async function createWarmupAndRenderJob(req, res, ctx2) {
+async function createWarmupAndRenderJob(req, res, ctx2, options) {
   try {
-    const options = req.body;
+    const body = req.body;
     let rawEffieData;
-    if (typeof options.effie === "string") {
-      const response = await ffsFetch(options.effie);
+    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}`
@@ -1725,7 +484,7 @@ async function createWarmupAndRenderJob(req, res, ctx2) {
       }
       rawEffieData = await response.json();
     } else {
-      rawEffieData = options.effie;
+      rawEffieData = body.effie;
     }
     let effie;
     if (!ctx2.skipValidation) {
@@ -1750,8 +509,8 @@ async function createWarmupAndRenderJob(req, res, ctx2) {
       effie = data;
     }
     const sources = extractEffieSourcesWithTypes(effie);
-    const scale = options.scale ?? 1;
-    const upload = options.upload;
+    const scale = body.scale ?? 1;
+    const upload = body.upload;
     const jobId = randomUUID2();
     const warmupJobId = randomUUID2();
     const renderJobId = randomUUID2();
@@ -1762,17 +521,18 @@ async function createWarmupAndRenderJob(req, res, ctx2) {
       upload,
       warmupJobId,
       renderJobId,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      metadata: options?.metadata
     };
     await ctx2.transientStore.putJson(
       storeKeys.warmupAndRenderJob(jobId),
       job,
-      ctx2.transientStore.jobMetadataTtlMs
+      ctx2.transientStore.jobDataTtlMs
     );
     await ctx2.transientStore.putJson(
       storeKeys.warmupJob(warmupJobId),
-      { sources },
-      ctx2.transientStore.jobMetadataTtlMs
+      { sources, metadata: options?.metadata },
+      ctx2.transientStore.jobDataTtlMs
     );
     await ctx2.transientStore.putJson(
       storeKeys.renderJob(renderJobId),
@@ -1780,9 +540,10 @@ async function createWarmupAndRenderJob(req, res, ctx2) {
         effie,
         scale,
         upload,
-        createdAt: Date.now()
+        createdAt: Date.now(),
+        metadata: options?.metadata
       },
-      ctx2.transientStore.jobMetadataTtlMs
+      ctx2.transientStore.jobDataTtlMs
     );
     res.json({
       id: jobId,
@@ -1797,13 +558,15 @@ async function streamWarmupAndRenderJob(req, res, ctx2) {
   try {
     setupCORSHeaders(res);
     const jobId = req.params.id;
-    const jobCacheKey = storeKeys.warmupAndRenderJob(jobId);
-    const job = await ctx2.transientStore.getJson(jobCacheKey);
-    ctx2.transientStore.delete(jobCacheKey);
+    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";
@@ -1811,13 +574,13 @@ async function streamWarmupAndRenderJob(req, res, ctx2) {
       sendEvent("keepalive", { phase: keepalivePhase });
     }, 25e3);
     try {
-      if (ctx2.warmupBackendBaseUrl) {
+      if (warmupBackend) {
         await proxyRemoteSSE(
-          `${ctx2.warmupBackendBaseUrl}/warmup/${job.warmupJobId}`,
+          `${warmupBackend.baseUrl}/warmup/${job.warmupJobId}`,
           sendEvent,
           "warmup:",
           res,
-          ctx2.warmupBackendApiKey ? { Authorization: `Bearer ${ctx2.warmupBackendApiKey}` } : void 0
+          warmupBackend.apiKey ? { Authorization: `Bearer ${warmupBackend.apiKey}` } : void 0
         );
       } else {
         const warmupSender = prefixEventSender(sendEvent, "warmup:");
@@ -1825,13 +588,13 @@ async function streamWarmupAndRenderJob(req, res, ctx2) {
         warmupSender("complete", { status: "ready" });
       }
       keepalivePhase = "render";
-      if (ctx2.renderBackendBaseUrl) {
+      if (renderBackend) {
         await proxyRemoteSSE(
-          `${ctx2.renderBackendBaseUrl}/render/${job.renderJobId}`,
+          `${renderBackend.baseUrl}/render/${job.renderJobId}`,
           sendEvent,
           "render:",
           res,
-          ctx2.renderBackendApiKey ? { Authorization: `Bearer ${ctx2.renderBackendApiKey}` } : void 0
+          renderBackend.apiKey ? { Authorization: `Bearer ${renderBackend.apiKey}` } : void 0
         );
       } else {
         const renderSender = prefixEventSender(sendEvent, "render:");
@@ -1850,7 +613,7 @@ async function streamWarmupAndRenderJob(req, res, ctx2) {
           sendEvent("complete", { status: "ready", videoUrl });
         }
       }
-      if (job.upload && !ctx2.renderBackendBaseUrl) {
+      if (job.upload && !renderBackend) {
         sendEvent("complete", { status: "done" });
       }
     } catch (error) {
@@ -1955,7 +718,7 @@ function shouldSkipWarmup(source) {
   return source.type === "video" || source.type === "audio";
 }
 var inFlightFetches = /* @__PURE__ */ new Map();
-async function createWarmupJob(req, res, ctx2) {
+async function createWarmupJob(req, res, ctx2, options) {
   try {
     const parseResult = parseEffieData(req.body, ctx2.skipValidation);
     if ("error" in parseResult) {
@@ -1964,10 +727,11 @@ async function createWarmupJob(req, res, ctx2) {
     }
     const sources = extractEffieSourcesWithTypes2(parseResult.effie);
     const jobId = randomUUID3();
+    const job = { sources, metadata: options?.metadata };
     await ctx2.transientStore.putJson(
       storeKeys.warmupJob(jobId),
-      { sources },
-      ctx2.transientStore.jobMetadataTtlMs
+      job,
+      ctx2.transientStore.jobDataTtlMs
     );
     res.json({
       id: jobId,
@@ -1982,29 +746,32 @@ async function streamWarmupJob(req, res, ctx2) {
   try {
     setupCORSHeaders(res);
     const jobId = req.params.id;
-    if (ctx2.warmupBackendBaseUrl) {
-      setupSSEResponse(res);
-      const sendEvent2 = createSSEEventSender(res);
-      try {
-        await proxyRemoteSSE(
-          `${ctx2.warmupBackendBaseUrl}/warmup/${jobId}`,
-          sendEvent2,
-          "",
-          res,
-          ctx2.warmupBackendApiKey ? { Authorization: `Bearer ${ctx2.warmupBackendApiKey}` } : void 0
-        );
-      } finally {
-        res.end();
-      }
-      return;
-    }
-    const jobCacheKey = storeKeys.warmupJob(jobId);
-    const job = await ctx2.transientStore.getJson(jobCacheKey);
-    ctx2.transientStore.delete(jobCacheKey);
+    const jobStoreKey = storeKeys.warmupJob(jobId);
+    const job = await ctx2.transientStore.getJson(jobStoreKey);
     if (!job) {
       res.status(404).json({ error: "Job not found" });
       return;
     }
+    if (ctx2.warmupBackendResolver) {
+      const backend = ctx2.warmupBackendResolver(job.sources, job.metadata);
+      if (backend) {
+        setupSSEResponse(res);
+        const sendEvent2 = createSSEEventSender(res);
+        try {
+          await proxyRemoteSSE(
+            `${backend.baseUrl}/warmup/${jobId}`,
+            sendEvent2,
+            "",
+            res,
+            backend.apiKey ? { Authorization: `Bearer ${backend.apiKey}` } : void 0
+          );
+        } finally {
+          res.end();
+        }
+        return;
+      }
+    }
+    ctx2.transientStore.delete(jobStoreKey);
     setupSSEResponse(res);
     const sendEvent = createSSEEventSender(res);
     try {
@@ -2152,7 +919,7 @@ async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
     throw new Error(`${response.status} ${response.statusText}`);
   }
   sendEvent("downloading", { url, status: "started", bytesReceived: 0 });
-  const sourceStream = Readable3.fromWeb(
+  const sourceStream = Readable2.fromWeb(
     response.body
   );
   let totalBytes = 0;
@@ -2182,11 +949,12 @@ async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
 }
 
 // src/server.ts
-console.log("FFS", getFFmpegVersion());
 var app = express5();
 app.use(bodyParser.json({ limit: "50mb" }));
 var ctx = await createServerContext();
-console.log(`FFS HTTP proxy listening on port ${ctx.httpProxy.port}`);
+if (ctx.httpProxy) {
+  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;
@@ -2225,7 +993,7 @@ var server = app.listen(port, () => {
 });
 function shutdown() {
   console.log("Shutting down FFS server...");
-  ctx.httpProxy.close();
+  ctx.httpProxy?.close();
   ctx.transientStore.close();
   server.close(() => {
     console.log("FFS server stopped");