@effing/ffs 0.1.0

package/dist/chunk-RNE6TKMF.js

@@ -0,0 +1,1190 @@
+// 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 } 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 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(sourceResolver, imageTransformer) {
+    const tempDir = await fs.mkdtemp(path.join(os.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 = 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 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 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/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 { Readable } from "stream";
+import { createReadStream as createReadStream2 } from "fs";
+import sharp from "sharp";
+
+// 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/render.ts
+import { fileURLToPath } from "url";
+
+// src/cache.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 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 ?? path2.join(os2.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 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.ttlMs) {
+            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) {
+    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) {
+    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 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/render.ts
+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 Readable.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 Readable.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();
+    }
+  }
+};
+
+export {
+  processMotion,
+  processEffects,
+  FFmpegCommand,
+  FFmpegRunner,
+  processTransition,
+  ffsFetch,
+  createCacheStorage,
+  cacheKeys,
+  EffieRenderer
+};
+//# sourceMappingURL=chunk-RNE6TKMF.js.map