@effing/ffs 0.1.2 → 0.3.0

package/dist/{chunk-RNE6TKMF.js → chunk-J64HSZNQ.js}

@@ -1,3 +1,162 @@
+// 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(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(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/render.ts
+import { Readable } from "stream";
+import { createReadStream as createReadStream2 } from "fs";
+
 // src/motion.ts
 function getEasingExpression(tNormExpr, easingType) {
   switch (easingType) {
@@ -189,151 +348,6 @@ function processEffects(effects, frameRate, frameWidth, frameHeight) {
   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) {
@@ -390,8 +404,6 @@ function processTransition(transition) {
 }
 
 // src/render.ts
-import { Readable } from "stream";
-import { createReadStream as createReadStream2 } from "fs";
 import sharp from "sharp";
 
 // src/fetch.ts
@@ -418,7 +430,7 @@ async function ffsFetch(url, options) {
 // src/render.ts
 import { fileURLToPath } from "url";
 
-// src/cache.ts
+// src/storage.ts
 import {
   S3Client,
   PutObjectCommand,
@@ -433,11 +445,14 @@ import { pipeline as pipeline2 } from "stream/promises";
 import path2 from "path";
 import os2 from "os";
 import crypto from "crypto";
-var S3CacheStorage = class {
+var DEFAULT_SOURCE_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_JOB_METADATA_TTL_MS = 8 * 60 * 60 * 1e3;
+var S3TransientStore = class {
   client;
   bucket;
   prefix;
-  ttlMs;
+  sourceTtlMs;
+  jobMetadataTtlMs;
   constructor(options) {
     this.client = new S3Client({
       endpoint: options.endpoint,
@@ -450,22 +465,23 @@ var S3CacheStorage = class {
     });
     this.bucket = options.bucket;
     this.prefix = options.prefix ?? "";
-    this.ttlMs = options.ttlMs ?? 60 * 60 * 1e3;
+    this.sourceTtlMs = options.sourceTtlMs ?? DEFAULT_SOURCE_TTL_MS;
+    this.jobMetadataTtlMs = options.jobMetadataTtlMs ?? DEFAULT_JOB_METADATA_TTL_MS;
   }
-  getExpires() {
-    return new Date(Date.now() + this.ttlMs);
+  getExpires(ttlMs) {
+    return new Date(Date.now() + ttlMs);
   }
   getFullKey(key) {
     return `${this.prefix}${key}`;
   }
-  async put(key, stream) {
+  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()
+        Expires: this.getExpires(ttlMs ?? this.sourceTtlMs)
       }
     });
     await upload.done();
@@ -526,14 +542,14 @@ var S3CacheStorage = class {
       throw err;
     }
   }
-  async putJson(key, data) {
+  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()
+        Expires: this.getExpires(ttlMs ?? this.jobMetadataTtlMs)
       })
     );
   }
@@ -559,20 +575,25 @@ var S3CacheStorage = class {
   close() {
   }
 };
-var LocalCacheStorage = class {
+var LocalTransientStore = class {
   baseDir;
   initialized = false;
   cleanupInterval;
-  ttlMs;
-  constructor(baseDir, ttlMs = 60 * 60 * 1e3) {
-    this.baseDir = baseDir ?? path2.join(os2.tmpdir(), "ffs-cache");
-    this.ttlMs = ttlMs;
+  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 TTL
+   * Remove files older than max TTL
    */
   async cleanupExpired() {
     if (!this.initialized) return;
@@ -597,7 +618,7 @@ var LocalCacheStorage = class {
       } else if (entry.isFile()) {
         try {
           const stat = await fs2.stat(fullPath);
-          if (now - stat.mtimeMs > this.ttlMs) {
+          if (now - stat.mtimeMs > this.maxTtlMs) {
             await fs2.rm(fullPath, { force: true });
           }
         } catch {
@@ -616,7 +637,7 @@ var LocalCacheStorage = class {
     const rand = crypto.randomBytes(8).toString("hex");
     return `${finalPath}.tmp-${process.pid}-${rand}`;
   }
-  async put(key, stream) {
+  async put(key, stream, _ttlMs) {
     const fp = this.filePath(key);
     await this.ensureDir(fp);
     const tmpPath = this.tmpPathFor(fp);
@@ -652,7 +673,7 @@ var LocalCacheStorage = class {
   async delete(key) {
     await fs2.rm(this.filePath(key), { force: true });
   }
-  async putJson(key, data) {
+  async putJson(key, data, _ttlMs) {
     const fp = this.filePath(key);
     await this.ensureDir(fp);
     const tmpPath = this.tmpPathFor(fp);
@@ -680,37 +701,47 @@ var LocalCacheStorage = class {
     }
   }
 };
-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
+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 LocalCacheStorage(process.env.FFS_CACHE_LOCAL_DIR, ttlMs);
+  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 sourceCacheKey(url) {
+function sourceStoreKey(url) {
   return `sources/${hashUrl(url)}`;
 }
-function warmupJobCacheKey(jobId) {
+function warmupJobStoreKey(jobId) {
   return `jobs/warmup/${jobId}.json`;
 }
-function renderJobCacheKey(jobId) {
+function renderJobStoreKey(jobId) {
   return `jobs/render/${jobId}.json`;
 }
-var cacheKeys = {
-  source: sourceCacheKey,
-  warmupJob: warmupJobCacheKey,
-  renderJob: renderJobCacheKey
+function warmupAndRenderJobStoreKey(jobId) {
+  return `jobs/warmup-and-render/${jobId}.json`;
+}
+var storeKeys = {
+  source: sourceStoreKey,
+  warmupJob: warmupJobStoreKey,
+  renderJob: renderJobStoreKey,
+  warmupAndRenderJob: warmupAndRenderJobStoreKey
 };
 
 // src/render.ts
@@ -718,20 +749,15 @@ var EffieRenderer = class {
   effieData;
   ffmpegRunner;
   allowLocalFiles;
-  cacheStorage;
+  transientStore;
+  httpProxy;
   constructor(effieData, options) {
     this.effieData = effieData;
     this.allowLocalFiles = options?.allowLocalFiles ?? false;
-    this.cacheStorage = options?.cacheStorage;
+    this.transientStore = options?.transientStore;
+    this.httpProxy = options?.httpProxy;
   }
   async fetchSource(src) {
-    if (src.startsWith("#")) {
-      const sourceName = src.slice(1);
-      if (!(sourceName in this.effieData.sources)) {
-        throw new Error(`Named source "${sourceName}" not found`);
-      }
-      src = this.effieData.sources[sourceName];
-    }
     if (src.startsWith("data:")) {
       const commaIndex = src.indexOf(",");
       if (commaIndex === -1) {
@@ -751,9 +777,9 @@ var EffieRenderer = class {
       }
       return createReadStream2(fileURLToPath(src));
     }
-    if (this.cacheStorage) {
-      const cachedStream = await this.cacheStorage.getStream(
-        cacheKeys.source(src)
+    if (this.transientStore) {
+      const cachedStream = await this.transientStore.getStream(
+        storeKeys.source(src)
       );
       if (cachedStream) {
         return cachedStream;
@@ -1025,6 +1051,12 @@ var EffieRenderer = class {
         segmentBgInputIndices.push(null);
       }
     }
+    const globalBgSegmentIndices = [];
+    for (let i = 0; i < this.effieData.segments.length; i++) {
+      if (segmentBgInputIndices[i] === null) {
+        globalBgSegmentIndices.push(i);
+      }
+    }
     for (const segment of this.effieData.segments) {
       for (const layer of segment.layers) {
         inputs.push(this.buildLayerInput(layer, segment.duration, inputIndex));
@@ -1061,6 +1093,26 @@ var EffieRenderer = class {
     const filterParts = [];
     const videoSegmentLabels = [];
     const audioSegmentLabels = [];
+    const globalBgFifoLabels = /* @__PURE__ */ new Map();
+    const bgFilter = `fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight}:force_original_aspect_ratio=increase,crop=${frameWidth}:${frameHeight}`;
+    if (globalBgSegmentIndices.length === 1) {
+      const fifoLabel = `bg_fifo_0`;
+      filterParts.push(`[${globalBgInputIdx}:v]${bgFilter},fifo[${fifoLabel}]`);
+      globalBgFifoLabels.set(globalBgSegmentIndices[0], fifoLabel);
+    } else if (globalBgSegmentIndices.length > 1) {
+      const splitCount = globalBgSegmentIndices.length;
+      const splitOutputLabels = globalBgSegmentIndices.map(
+        (_, i) => `bg_split_${i}`
+      );
+      filterParts.push(
+        `[${globalBgInputIdx}:v]${bgFilter},split=${splitCount}${splitOutputLabels.map((l) => `[${l}]`).join("")}`
+      );
+      for (let i = 0; i < splitCount; i++) {
+        const fifoLabel = `bg_fifo_${i}`;
+        filterParts.push(`[${splitOutputLabels[i]}]fifo[${fifoLabel}]`);
+        globalBgFifoLabels.set(globalBgSegmentIndices[i], fifoLabel);
+      }
+    }
     for (let segIdx = 0; segIdx < this.effieData.segments.length; segIdx++) {
       const segment = this.effieData.segments[segIdx];
       const bgLabel = `bg_seg${segIdx}`;
@@ -1071,9 +1123,12 @@ var EffieRenderer = class {
           `[${segBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},trim=start=${segBgSeek}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
         );
       } else {
-        filterParts.push(
-          `[${globalBgInputIdx}:v]fps=${this.effieData.fps},scale=${frameWidth}x${frameHeight},trim=start=${backgroundSeek + currentTime}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
-        );
+        const fifoLabel = globalBgFifoLabels.get(segIdx);
+        if (fifoLabel) {
+          filterParts.push(
+            `[${fifoLabel}]trim=start=${backgroundSeek + currentTime}:duration=${segment.duration},setpts=PTS-STARTPTS[${bgLabel}]`
+          );
+        }
       }
       const vidLabel = `vid_seg${segIdx}`;
       filterParts.push(
@@ -1157,6 +1212,20 @@ var EffieRenderer = class {
       }
     };
   }
+  /**
+   * Resolves a source reference to its actual URL.
+   * If the source is a #reference, returns the resolved URL.
+   * Otherwise, returns the source as-is.
+   */
+  resolveReference(src) {
+    if (src.startsWith("#")) {
+      const sourceName = src.slice(1);
+      if (sourceName in this.effieData.sources) {
+        return this.effieData.sources[sourceName];
+      }
+    }
+    return src;
+  }
   /**
    * Renders the effie data to a video stream.
    * @param scaleFactor - Scale factor for output dimensions
@@ -1164,9 +1233,12 @@ var EffieRenderer = class {
   async render(scaleFactor = 1) {
     const ffmpegCommand = this.buildFFmpegCommand("-", scaleFactor);
     this.ffmpegRunner = new FFmpegRunner(ffmpegCommand);
+    const urlTransformer = this.httpProxy ? (url) => this.httpProxy.transformUrl(url) : void 0;
     return this.ffmpegRunner.run(
       async ({ src }) => this.fetchSource(src),
-      this.createImageTransformer(scaleFactor)
+      this.createImageTransformer(scaleFactor),
+      (src) => this.resolveReference(src),
+      urlTransformer
     );
   }
   close() {
@@ -1177,14 +1249,11 @@ var EffieRenderer = class {
 };
 
 export {
-  processMotion,
-  processEffects,
   FFmpegCommand,
   FFmpegRunner,
-  processTransition,
   ffsFetch,
-  createCacheStorage,
-  cacheKeys,
+  createTransientStore,
+  storeKeys,
   EffieRenderer
 };
-//# sourceMappingURL=chunk-RNE6TKMF.js.map
+//# sourceMappingURL=chunk-J64HSZNQ.js.map