@effing/ffs 0.1.0

package/dist/server.js

@@ -0,0 +1,1656 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import express4 from "express";
+import bodyParser from "body-parser";
+
+// src/handlers/shared.ts
+import "express";
+
+// src/cache.ts
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  DeleteObjectCommand
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import fs from "fs/promises";
+import { createReadStream, createWriteStream, existsSync } from "fs";
+import { pipeline } from "stream/promises";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var S3CacheStorage = class {
+  client;
+  bucket;
+  prefix;
+  ttlMs;
+  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.ttlMs = options.ttlMs ?? 60 * 60 * 1e3;
+  }
+  getExpires() {
+    return new Date(Date.now() + this.ttlMs);
+  }
+  getFullKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  async put(key, stream) {
+    const upload = new Upload({
+      client: this.client,
+      params: {
+        Bucket: this.bucket,
+        Key: this.getFullKey(key),
+        Body: stream,
+        Expires: this.getExpires()
+      }
+    });
+    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) {
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: this.getFullKey(key),
+        Body: JSON.stringify(data),
+        ContentType: "application/json",
+        Expires: this.getExpires()
+      })
+    );
+  }
+  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 LocalCacheStorage = class {
+  baseDir;
+  initialized = false;
+  cleanupInterval;
+  ttlMs;
+  constructor(baseDir, ttlMs = 60 * 60 * 1e3) {
+    this.baseDir = baseDir ?? path.join(os.tmpdir(), "ffs-cache");
+    this.ttlMs = ttlMs;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpired().catch(console.error);
+    }, 3e5);
+  }
+  /**
+   * Remove files older than 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 fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.cleanupDir(fullPath, now);
+        try {
+          await fs.rmdir(fullPath);
+        } catch {
+        }
+      } else if (entry.isFile()) {
+        try {
+          const stat = await fs.stat(fullPath);
+          if (now - stat.mtimeMs > this.ttlMs) {
+            await fs.rm(fullPath, { force: true });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  async ensureDir(filePath) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    this.initialized = true;
+  }
+  filePath(key) {
+    return path.join(this.baseDir, key);
+  }
+  tmpPathFor(finalPath) {
+    const rand = crypto.randomBytes(8).toString("hex");
+    return `${finalPath}.tmp-${process.pid}-${rand}`;
+  }
+  async put(key, stream) {
+    const fp = this.filePath(key);
+    await this.ensureDir(fp);
+    const tmpPath = this.tmpPathFor(fp);
+    try {
+      const writeStream = createWriteStream(tmpPath);
+      await pipeline(stream, writeStream);
+      await fs.rename(tmpPath, fp);
+    } catch (err) {
+      await fs.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 fs.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 fs.rm(this.filePath(key), { force: true });
+  }
+  async putJson(key, data) {
+    const fp = this.filePath(key);
+    await this.ensureDir(fp);
+    const tmpPath = this.tmpPathFor(fp);
+    try {
+      await fs.writeFile(tmpPath, JSON.stringify(data));
+      await fs.rename(tmpPath, fp);
+    } catch (err) {
+      await fs.rm(tmpPath, { force: true }).catch(() => {
+      });
+      throw err;
+    }
+  }
+  async getJson(key) {
+    try {
+      const content = await fs.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 createCacheStorage() {
+  const ttlMs = process.env.FFS_CACHE_TTL_MS ? parseInt(process.env.FFS_CACHE_TTL_MS, 10) : 60 * 60 * 1e3;
+  if (process.env.FFS_CACHE_BUCKET) {
+    return new S3CacheStorage({
+      endpoint: process.env.FFS_CACHE_ENDPOINT,
+      region: process.env.FFS_CACHE_REGION ?? "auto",
+      bucket: process.env.FFS_CACHE_BUCKET,
+      prefix: process.env.FFS_CACHE_PREFIX,
+      accessKeyId: process.env.FFS_CACHE_ACCESS_KEY,
+      secretAccessKey: process.env.FFS_CACHE_SECRET_KEY,
+      ttlMs
+    });
+  }
+  return new LocalCacheStorage(process.env.FFS_CACHE_LOCAL_DIR, ttlMs);
+}
+function hashUrl(url) {
+  return crypto.createHash("sha256").update(url).digest("hex").slice(0, 16);
+}
+function sourceCacheKey(url) {
+  return `sources/${hashUrl(url)}`;
+}
+function warmupJobCacheKey(jobId) {
+  return `jobs/warmup/${jobId}.json`;
+}
+function renderJobCacheKey(jobId) {
+  return `jobs/render/${jobId}.json`;
+}
+var cacheKeys = {
+  source: sourceCacheKey,
+  warmupJob: warmupJobCacheKey,
+  renderJob: renderJobCacheKey
+};
+
+// src/handlers/shared.ts
+import { effieDataSchema } from "@effing/effie";
+function createServerContext() {
+  const port2 = process.env.FFS_PORT || 2e3;
+  return {
+    cacheStorage: createCacheStorage(),
+    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)
+  };
+}
+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, 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
+  });
+}
+
+// src/handlers/caching.ts
+import { extractEffieSources } from "@effing/effie";
+var inFlightFetches = /* @__PURE__ */ new Map();
+async function createWarmupJob(req, res, ctx2) {
+  try {
+    const parseResult = parseEffieData(req.body, ctx2.skipValidation);
+    if ("error" in parseResult) {
+      res.status(400).json(parseResult);
+      return;
+    }
+    const sources = extractEffieSources(parseResult.effie);
+    const jobId = randomUUID();
+    await ctx2.cacheStorage.putJson(cacheKeys.warmupJob(jobId), { sources });
+    res.json({
+      id: jobId,
+      url: `${ctx2.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, ctx2) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    const jobCacheKey = cacheKeys.warmupJob(jobId);
+    const job = await ctx2.cacheStorage.getJson(jobCacheKey);
+    ctx2.cacheStorage.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, ctx2);
+      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, ctx2) {
+  try {
+    const parseResult = parseEffieData(req.body, ctx2.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 = cacheKeys.source(url);
+      if (await ctx2.cacheStorage.exists(ck)) {
+        await ctx2.cacheStorage.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, 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++) {
+    if (existsMap.get(sourceCacheKeys[i])) {
+      cached++;
+      sendEvent("progress", {
+        url: sources[i],
+        status: "hit",
+        cached,
+        failed,
+        total
+      });
+    }
+  }
+  const uncached = sources.filter((_, i) => !existsMap.get(sourceCacheKeys[i]));
+  if (uncached.length === 0) {
+    sendEvent("summary", { cached, failed, total });
+    return;
+  }
+  const keepalive = setInterval(() => {
+    sendEvent("keepalive", { cached, failed, 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 startTime = Date.now();
+        try {
+          let fetchPromise = inFlightFetches.get(cacheKey);
+          if (!fetchPromise) {
+            fetchPromise = fetchAndCache(url, cacheKey, sendEvent, ctx2);
+            inFlightFetches.set(cacheKey, fetchPromise);
+          }
+          await fetchPromise;
+          inFlightFetches.delete(cacheKey);
+          cached++;
+          sendEvent("progress", {
+            url,
+            status: "cached",
+            cached,
+            failed,
+            total,
+            ms: Date.now() - startTime
+          });
+        } catch (error) {
+          inFlightFetches.delete(cacheKey);
+          failed++;
+          sendEvent("progress", {
+            url,
+            status: "error",
+            error: String(error),
+            cached,
+            failed,
+            total,
+            ms: Date.now() - startTime
+          });
+        }
+      }
+    }
+  );
+  await Promise.all(workers);
+  clearInterval(keepalive);
+  sendEvent("summary", { cached, failed, total });
+}
+async function fetchAndCache(url, cacheKey, sendEvent, ctx2) {
+  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 = Readable.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 ctx2.cacheStorage.put(cacheKey, trackedStream);
+}
+
+// src/handlers/rendering.ts
+import "express";
+import { randomUUID as randomUUID2 } 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/ffmpeg.ts
+import { spawn } from "child_process";
+import { pipeline as pipeline2 } from "stream";
+import fs2 from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+import pathToFFmpeg from "ffmpeg-static";
+import tar from "tar-stream";
+import { createWriteStream as createWriteStream2 } from "fs";
+import { promisify } from "util";
+var pump = promisify(pipeline2);
+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",
+          path2.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(sourceResolver, imageTransformer) {
+    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({
+        type: input.type,
+        src: input.source
+      });
+      if (input.type === "animation") {
+        const extractionDir = path2.join(tempDir, inputName);
+        await fs2.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 = path2.join(extractionDir, header.name);
+              const writeStream = createWriteStream2(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 = path2.join(tempDir, inputName);
+        const transformedStream = await imageTransformer(stream);
+        const writeStream = createWriteStream2(tempFile);
+        transformedStream.on("error", (e) => writeStream.destroy(e));
+        await pump(transformedStream, writeStream);
+        return tempFile;
+      } else {
+        const tempFile = path2.join(tempDir, inputName);
+        const writeStream = createWriteStream2(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 shouldCache = input.source.startsWith("#");
+        if (shouldCache) {
+          let fetchPromise = sourceCache.get(input.source);
+          if (!fetchPromise) {
+            fetchPromise = fetchAndSaveSource(input, inputName);
+            sourceCache.set(input.source, fetchPromise);
+          }
+          const filePath = await fetchPromise;
+          fileMapping.set(input.index, filePath);
+        } else {
+          const filePath = await fetchAndSaveSource(input, 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(process.env.FFMPEG ?? pathToFFmpeg, finalArgs);
+    ffmpegProc.stderr.on("data", (data) => {
+      console.error(data.toString());
+    });
+    ffmpegProc.on("close", async () => {
+      try {
+        await fs2.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/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;
+  cacheStorage;
+  constructor(effieData, options) {
+    this.effieData = effieData;
+    this.allowLocalFiles = options?.allowLocalFiles ?? false;
+    this.cacheStorage = options?.cacheStorage;
+  }
+  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) {
+        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.cacheStorage) {
+      const cachedStream = await this.cacheStorage.getStream(
+        cacheKeys.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);
+      }
+    }
+    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 = [];
+    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 {
+        filterParts.push(
+          `[${globalBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},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;
+      }
+    };
+  }
+  /**
+   * 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);
+    return this.ffmpegRunner.run(
+      async ({ src }) => this.fetchSource(src),
+      this.createImageTransformer(scaleFactor)
+    );
+  }
+  close() {
+    if (this.ffmpegRunner) {
+      this.ffmpegRunner.close();
+    }
+  }
+};
+
+// src/handlers/rendering.ts
+import { effieDataSchema as effieDataSchema2 } from "@effing/effie";
+async function createRenderJob(req, res, ctx2) {
+  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 (!ctx2.skipValidation) {
+      const result = effieDataSchema2.safeParse(rawEffieData);
+      if (!result.success) {
+        res.status(400).json({
+          error: "Invalid effie data",
+          issues: result.error.issues.map((issue) => ({
+            path: issue.path.join("."),
+            message: issue.message
+          }))
+        });
+        return;
+      }
+      effie = result.data;
+    } else {
+      const data = rawEffieData;
+      if (!data?.segments) {
+        res.status(400).json({ error: "Invalid effie data: missing segments" });
+        return;
+      }
+      effie = data;
+    }
+    const jobId = randomUUID2();
+    const job = {
+      effie,
+      scale,
+      upload,
+      createdAt: Date.now()
+    };
+    await ctx2.cacheStorage.putJson(cacheKeys.renderJob(jobId), job);
+    res.json({
+      id: jobId,
+      url: `${ctx2.baseUrl}/render/${jobId}`
+    });
+  } catch (error) {
+    console.error("Error creating render job:", error);
+    res.status(500).json({ error: "Failed to create render job" });
+  }
+}
+async function streamRenderJob(req, res, ctx2) {
+  try {
+    setupCORSHeaders(res);
+    const jobId = req.params.id;
+    const jobCacheKey = cacheKeys.renderJob(jobId);
+    const job = await ctx2.cacheStorage.getJson(jobCacheKey);
+    ctx2.cacheStorage.delete(jobCacheKey);
+    if (!job) {
+      res.status(404).json({ error: "Job not found or expired" });
+      return;
+    }
+    if (job.upload) {
+      await streamRenderWithUpload(res, job, ctx2);
+    } else {
+      await streamRenderDirect(res, job, ctx2);
+    }
+  } catch (error) {
+    console.error("Error in render:", error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Rendering failed" });
+    } else {
+      res.end();
+    }
+  }
+}
+async function streamRenderDirect(res, job, ctx2) {
+  const renderer = new EffieRenderer(job.effie, {
+    cacheStorage: ctx2.cacheStorage
+  });
+  const videoStream = await renderer.render(job.scale);
+  res.on("close", () => {
+    videoStream.destroy();
+    renderer.close();
+  });
+  res.set("Content-Type", "video/mp4");
+  videoStream.pipe(res);
+}
+async function streamRenderWithUpload(res, job, ctx2) {
+  setupSSEResponse(res);
+  const sendEvent = createSSEEventSender(res);
+  const keepalive = setInterval(() => {
+    sendEvent("keepalive", { status: "rendering" });
+  }, 25e3);
+  try {
+    sendEvent("started", { status: "rendering" });
+    const timings = await renderAndUploadInternal(
+      job.effie,
+      job.scale,
+      job.upload,
+      sendEvent,
+      ctx2
+    );
+    sendEvent("complete", { status: "uploaded", timings });
+  } catch (error) {
+    sendEvent("error", { message: String(error) });
+  } finally {
+    clearInterval(keepalive);
+    res.end();
+  }
+}
+async function renderAndUploadInternal(effie, scale, upload, sendEvent, ctx2) {
+  const timings = {};
+  if (upload.coverUrl) {
+    const fetchCoverStartTime = Date.now();
+    const coverFetchResponse = await ffsFetch(effie.cover);
+    if (!coverFetchResponse.ok) {
+      throw new Error(
+        `Failed to fetch cover image: ${coverFetchResponse.status} ${coverFetchResponse.statusText}`
+      );
+    }
+    const coverBuffer = Buffer.from(await coverFetchResponse.arrayBuffer());
+    timings.fetchCoverTime = Date.now() - fetchCoverStartTime;
+    const uploadCoverStartTime = Date.now();
+    const uploadCoverResponse = await ffsFetch(upload.coverUrl, {
+      method: "PUT",
+      body: coverBuffer,
+      headers: {
+        "Content-Type": "image/png",
+        "Content-Length": coverBuffer.length.toString()
+      }
+    });
+    if (!uploadCoverResponse.ok) {
+      throw new Error(
+        `Failed to upload cover: ${uploadCoverResponse.status} ${uploadCoverResponse.statusText}`
+      );
+    }
+    timings.uploadCoverTime = Date.now() - uploadCoverStartTime;
+  }
+  const renderStartTime = Date.now();
+  const renderer = new EffieRenderer(effie, { cacheStorage: ctx2.cacheStorage });
+  const videoStream = await renderer.render(scale);
+  const chunks = [];
+  for await (const chunk of videoStream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const videoBuffer = Buffer.concat(chunks);
+  timings.renderTime = Date.now() - renderStartTime;
+  sendEvent("keepalive", { status: "uploading" });
+  const uploadStartTime = Date.now();
+  const uploadResponse = await ffsFetch(upload.videoUrl, {
+    method: "PUT",
+    body: videoBuffer,
+    headers: {
+      "Content-Type": "video/mp4",
+      "Content-Length": videoBuffer.length.toString()
+    }
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Failed to upload rendered video: ${uploadResponse.status} ${uploadResponse.statusText}`
+    );
+  }
+  timings.uploadTime = Date.now() - uploadStartTime;
+  return timings;
+}
+
+// src/server.ts
+var app = express4();
+app.use(bodyParser.json({ limit: "50mb" }));
+var ctx = createServerContext();
+function validateAuth(req, res) {
+  const apiKey = process.env.FFS_API_KEY;
+  if (!apiKey) return true;
+  const authHeader = req.headers.authorization;
+  if (!authHeader || authHeader !== `Bearer ${apiKey}`) {
+    res.status(401).json({ error: "Unauthorized" });
+    return false;
+  }
+  return true;
+}
+app.post("/warmup", (req, res) => {
+  if (!validateAuth(req, res)) return;
+  createWarmupJob(req, res, ctx);
+});
+app.post("/purge", (req, res) => {
+  if (!validateAuth(req, res)) return;
+  purgeCache(req, res, ctx);
+});
+app.post("/render", (req, res) => {
+  if (!validateAuth(req, res)) return;
+  createRenderJob(req, res, ctx);
+});
+app.get("/warmup/:id", (req, res) => streamWarmupJob(req, res, ctx));
+app.get("/render/:id", (req, res) => streamRenderJob(req, res, ctx));
+var port = process.env.FFS_PORT || 2e3;
+var server = app.listen(port, () => {
+  console.log(`FFS server listening on port ${port}`);
+});
+function shutdown() {
+  console.log("Shutting down FFS server...");
+  ctx.cacheStorage.close();
+  server.close(() => {
+    console.log("FFS server stopped");
+    process.exit(0);
+  });
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+export {
+  app
+};