@effing/ffs 0.4.1 → 0.6.0

package/dist/{chunk-3SM6XYCZ.js → chunk-O7Z6DV2I.js}

@@ -1,165 +1,11 @@
-// src/ffmpeg.ts
-import { execFileSync, spawn } from "child_process";
-import { pipeline } from "stream";
-import fs from "fs/promises";
-import os from "os";
-import path from "path";
-import pathToFFmpeg from "ffmpeg-static";
-import tar from "tar-stream";
-import { createWriteStream } from "fs";
-import { promisify } from "util";
-var pump = promisify(pipeline);
-var ffmpegBin = process.env.FFMPEG ?? pathToFFmpeg;
-function getFFmpegVersion() {
-  return execFileSync(ffmpegBin, ["-version"], { encoding: "utf8" }).split("\n")[0].trim();
-}
-var FFmpegCommand = class {
-  globalArgs;
-  inputs;
-  filterComplex;
-  outputArgs;
-  constructor(globalArgs, inputs, filterComplex, outputArgs) {
-    this.globalArgs = globalArgs;
-    this.inputs = inputs;
-    this.filterComplex = filterComplex;
-    this.outputArgs = outputArgs;
-  }
-  buildArgs(inputResolver) {
-    const inputArgs = [];
-    for (const input of this.inputs) {
-      if (input.type === "color") {
-        inputArgs.push(...input.preArgs);
-      } else if (input.type === "animation") {
-        inputArgs.push(
-          ...input.preArgs,
-          "-i",
-          path.join(inputResolver(input), "frame_%05d")
-        );
-      } else {
-        inputArgs.push(...input.preArgs, "-i", inputResolver(input));
-      }
-    }
-    const args = [
-      ...this.globalArgs,
-      ...inputArgs,
-      "-filter_complex",
-      this.filterComplex,
-      ...this.outputArgs
-    ];
-    return args;
-  }
-};
-var FFmpegRunner = class {
-  command;
-  ffmpegProc;
-  constructor(command) {
-    this.command = command;
-  }
-  async run(sourceFetcher, imageTransformer, referenceResolver, urlTransformer) {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "ffs-"));
-    const fileMapping = /* @__PURE__ */ new Map();
-    const fetchCache = /* @__PURE__ */ new Map();
-    const fetchAndSaveSource = async (input, sourceUrl, inputName) => {
-      const stream = await sourceFetcher({
-        type: input.type,
-        src: sourceUrl
-      });
-      if (input.type === "animation") {
-        const extractionDir = path.join(tempDir, inputName);
-        await fs.mkdir(extractionDir, { recursive: true });
-        const extract = tar.extract();
-        const extractPromise = new Promise((resolve, reject) => {
-          extract.on("entry", async (header, stream2, next) => {
-            if (header.name.startsWith("frame_")) {
-              const transformedStream = imageTransformer ? await imageTransformer(stream2) : stream2;
-              const outputPath = path.join(extractionDir, header.name);
-              const writeStream = createWriteStream(outputPath);
-              transformedStream.pipe(writeStream);
-              writeStream.on("finish", next);
-              writeStream.on("error", reject);
-            }
-          });
-          extract.on("finish", resolve);
-          extract.on("error", reject);
-        });
-        stream.pipe(extract);
-        await extractPromise;
-        return extractionDir;
-      } else if (input.type === "image" && imageTransformer) {
-        const tempFile = path.join(tempDir, inputName);
-        const transformedStream = await imageTransformer(stream);
-        const writeStream = createWriteStream(tempFile);
-        transformedStream.on("error", (e) => writeStream.destroy(e));
-        await pump(transformedStream, writeStream);
-        return tempFile;
-      } else {
-        const tempFile = path.join(tempDir, inputName);
-        const writeStream = createWriteStream(tempFile);
-        stream.on("error", (e) => writeStream.destroy(e));
-        await pump(stream, writeStream);
-        return tempFile;
-      }
-    };
-    await Promise.all(
-      this.command.inputs.map(async (input) => {
-        if (input.type === "color") return;
-        const inputName = `ffmpeg_input_${input.index.toString().padStart(3, "0")}`;
-        const sourceUrl = referenceResolver ? referenceResolver(input.source) : input.source;
-        if ((input.type === "video" || input.type === "audio") && (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://"))) {
-          const finalUrl = urlTransformer ? urlTransformer(sourceUrl) : sourceUrl;
-          fileMapping.set(input.index, finalUrl);
-          return;
-        }
-        const shouldCache = input.source.startsWith("#");
-        if (shouldCache) {
-          let fetchPromise = fetchCache.get(input.source);
-          if (!fetchPromise) {
-            fetchPromise = fetchAndSaveSource(input, sourceUrl, inputName);
-            fetchCache.set(input.source, fetchPromise);
-          }
-          const filePath = await fetchPromise;
-          fileMapping.set(input.index, filePath);
-        } else {
-          const filePath = await fetchAndSaveSource(
-            input,
-            sourceUrl,
-            inputName
-          );
-          fileMapping.set(input.index, filePath);
-        }
-      })
-    );
-    const finalArgs = this.command.buildArgs((input) => {
-      const filePath = fileMapping.get(input.index);
-      if (!filePath)
-        throw new Error(`File for input index ${input.index} not found`);
-      return filePath;
-    });
-    const ffmpegProc = spawn(ffmpegBin, finalArgs);
-    ffmpegProc.stderr.on("data", (data) => {
-      console.error(data.toString());
-    });
-    ffmpegProc.on("close", async () => {
-      try {
-        await fs.rm(tempDir, { recursive: true, force: true });
-      } catch (err) {
-        console.error("Error removing temp directory:", err);
-      }
-    });
-    this.ffmpegProc = ffmpegProc;
-    return ffmpegProc.stdout;
-  }
-  close() {
-    if (this.ffmpegProc) {
-      this.ffmpegProc.kill("SIGTERM");
-      this.ffmpegProc = void 0;
-    }
-  }
-};
+import {
+  ffsFetch,
+  storeKeys
+} from "./chunk-4N2GLGC5.js";
 
 // src/render.ts
 import { Readable } from "stream";
-import { createReadStream as createReadStream2 } from "fs";
+import { createReadStream } from "fs";
 
 // src/motion.ts
 function getEasingExpression(tNormExpr, easingType) {
@@ -352,6 +198,178 @@ 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 tar from "tar-stream";
+import { createWriteStream } from "fs";
+import { promisify } from "util";
+var pump = promisify(pipeline);
+var resolvedBin;
+async function getFFmpegBin() {
+  if (resolvedBin) return resolvedBin;
+  if (process.env.FFMPEG) {
+    resolvedBin = process.env.FFMPEG;
+    return resolvedBin;
+  }
+  try {
+    const { pathToFFmpeg } = await import("@effing/ffmpeg");
+    if (pathToFFmpeg) {
+      resolvedBin = pathToFFmpeg;
+      return resolvedBin;
+    }
+  } catch {
+  }
+  resolvedBin = "ffmpeg";
+  return resolvedBin;
+}
+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(await getFFmpegBin(), 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) {
@@ -409,346 +427,7 @@ function processTransition(transition) {
 
 // src/render.ts
 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/storage.ts
-import {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand,
-  HeadObjectCommand,
-  DeleteObjectCommand
-} from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import fs2 from "fs/promises";
-import { createReadStream, createWriteStream as createWriteStream2, existsSync } from "fs";
-import { pipeline as pipeline2 } from "stream/promises";
-import path2 from "path";
-import os2 from "os";
-import crypto from "crypto";
-var DEFAULT_SOURCE_TTL_MS = 60 * 60 * 1e3;
-var DEFAULT_JOB_METADATA_TTL_MS = 8 * 60 * 60 * 1e3;
-var S3TransientStore = class {
-  client;
-  bucket;
-  prefix;
-  sourceTtlMs;
-  jobMetadataTtlMs;
-  constructor(options) {
-    this.client = new S3Client({
-      endpoint: options.endpoint,
-      region: options.region ?? "auto",
-      credentials: options.accessKeyId ? {
-        accessKeyId: options.accessKeyId,
-        secretAccessKey: options.secretAccessKey
-      } : void 0,
-      forcePathStyle: !!options.endpoint
-    });
-    this.bucket = options.bucket;
-    this.prefix = options.prefix ?? "";
-    this.sourceTtlMs = options.sourceTtlMs ?? DEFAULT_SOURCE_TTL_MS;
-    this.jobMetadataTtlMs = options.jobMetadataTtlMs ?? DEFAULT_JOB_METADATA_TTL_MS;
-  }
-  getExpires(ttlMs) {
-    return new Date(Date.now() + ttlMs);
-  }
-  getFullKey(key) {
-    return `${this.prefix}${key}`;
-  }
-  async put(key, stream, ttlMs) {
-    const upload = new Upload({
-      client: this.client,
-      params: {
-        Bucket: this.bucket,
-        Key: this.getFullKey(key),
-        Body: stream,
-        Expires: this.getExpires(ttlMs ?? this.sourceTtlMs)
-      }
-    });
-    await upload.done();
-  }
-  async getStream(key) {
-    try {
-      const response = await this.client.send(
-        new GetObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      return response.Body;
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return null;
-      }
-      throw err;
-    }
-  }
-  async exists(key) {
-    try {
-      await this.client.send(
-        new HeadObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      return true;
-    } catch (err) {
-      const error = err;
-      if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) {
-        return false;
-      }
-      throw err;
-    }
-  }
-  async existsMany(keys) {
-    const results = await Promise.all(
-      keys.map(async (key) => [key, await this.exists(key)])
-    );
-    return new Map(results);
-  }
-  async delete(key) {
-    try {
-      await this.client.send(
-        new DeleteObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return;
-      }
-      throw err;
-    }
-  }
-  async putJson(key, data, ttlMs) {
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: this.getFullKey(key),
-        Body: JSON.stringify(data),
-        ContentType: "application/json",
-        Expires: this.getExpires(ttlMs ?? this.jobMetadataTtlMs)
-      })
-    );
-  }
-  async getJson(key) {
-    try {
-      const response = await this.client.send(
-        new GetObjectCommand({
-          Bucket: this.bucket,
-          Key: this.getFullKey(key)
-        })
-      );
-      const body = await response.Body?.transformToString();
-      if (!body) return null;
-      return JSON.parse(body);
-    } catch (err) {
-      const error = err;
-      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
-        return null;
-      }
-      throw err;
-    }
-  }
-  close() {
-  }
-};
-var LocalTransientStore = class {
-  baseDir;
-  initialized = false;
-  cleanupInterval;
-  sourceTtlMs;
-  jobMetadataTtlMs;
-  /** For cleanup, use the longer of the two TTLs */
-  maxTtlMs;
-  constructor(options) {
-    this.baseDir = options?.baseDir ?? path2.join(os2.tmpdir(), "ffs-transient");
-    this.sourceTtlMs = options?.sourceTtlMs ?? DEFAULT_SOURCE_TTL_MS;
-    this.jobMetadataTtlMs = options?.jobMetadataTtlMs ?? DEFAULT_JOB_METADATA_TTL_MS;
-    this.maxTtlMs = Math.max(this.sourceTtlMs, this.jobMetadataTtlMs);
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupExpired().catch(console.error);
-    }, 3e5);
-  }
-  /**
-   * Remove files older than max TTL
-   */
-  async cleanupExpired() {
-    if (!this.initialized) return;
-    const now = Date.now();
-    await this.cleanupDir(this.baseDir, now);
-  }
-  async cleanupDir(dir, now) {
-    let entries;
-    try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await this.cleanupDir(fullPath, now);
-        try {
-          await fs2.rmdir(fullPath);
-        } catch {
-        }
-      } else if (entry.isFile()) {
-        try {
-          const stat = await fs2.stat(fullPath);
-          if (now - stat.mtimeMs > this.maxTtlMs) {
-            await fs2.rm(fullPath, { force: true });
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  async ensureDir(filePath) {
-    await fs2.mkdir(path2.dirname(filePath), { recursive: true });
-    this.initialized = true;
-  }
-  filePath(key) {
-    return path2.join(this.baseDir, key);
-  }
-  tmpPathFor(finalPath) {
-    const rand = crypto.randomBytes(8).toString("hex");
-    return `${finalPath}.tmp-${process.pid}-${rand}`;
-  }
-  async put(key, stream, _ttlMs) {
-    const fp = this.filePath(key);
-    await this.ensureDir(fp);
-    const tmpPath = this.tmpPathFor(fp);
-    try {
-      const writeStream = createWriteStream2(tmpPath);
-      await pipeline2(stream, writeStream);
-      await fs2.rename(tmpPath, fp);
-    } catch (err) {
-      await fs2.rm(tmpPath, { force: true }).catch(() => {
-      });
-      throw err;
-    }
-  }
-  async getStream(key) {
-    const fp = this.filePath(key);
-    if (!existsSync(fp)) return null;
-    return createReadStream(fp);
-  }
-  async exists(key) {
-    try {
-      await fs2.access(this.filePath(key));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async existsMany(keys) {
-    const results = await Promise.all(
-      keys.map(async (key) => [key, await this.exists(key)])
-    );
-    return new Map(results);
-  }
-  async delete(key) {
-    await fs2.rm(this.filePath(key), { force: true });
-  }
-  async putJson(key, data, _ttlMs) {
-    const fp = this.filePath(key);
-    await this.ensureDir(fp);
-    const tmpPath = this.tmpPathFor(fp);
-    try {
-      await fs2.writeFile(tmpPath, JSON.stringify(data));
-      await fs2.rename(tmpPath, fp);
-    } catch (err) {
-      await fs2.rm(tmpPath, { force: true }).catch(() => {
-      });
-      throw err;
-    }
-  }
-  async getJson(key) {
-    try {
-      const content = await fs2.readFile(this.filePath(key), "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = void 0;
-    }
-  }
-};
-function createTransientStore() {
-  const sourceTtlMs = process.env.FFS_SOURCE_CACHE_TTL_MS ? parseInt(process.env.FFS_SOURCE_CACHE_TTL_MS, 10) : DEFAULT_SOURCE_TTL_MS;
-  const jobMetadataTtlMs = process.env.FFS_JOB_METADATA_TTL_MS ? parseInt(process.env.FFS_JOB_METADATA_TTL_MS, 10) : DEFAULT_JOB_METADATA_TTL_MS;
-  if (process.env.FFS_TRANSIENT_STORE_BUCKET) {
-    return new S3TransientStore({
-      endpoint: process.env.FFS_TRANSIENT_STORE_ENDPOINT,
-      region: process.env.FFS_TRANSIENT_STORE_REGION ?? "auto",
-      bucket: process.env.FFS_TRANSIENT_STORE_BUCKET,
-      prefix: process.env.FFS_TRANSIENT_STORE_PREFIX,
-      accessKeyId: process.env.FFS_TRANSIENT_STORE_ACCESS_KEY,
-      secretAccessKey: process.env.FFS_TRANSIENT_STORE_SECRET_KEY,
-      sourceTtlMs,
-      jobMetadataTtlMs
-    });
-  }
-  return new LocalTransientStore({
-    baseDir: process.env.FFS_TRANSIENT_STORE_LOCAL_DIR,
-    sourceTtlMs,
-    jobMetadataTtlMs
-  });
-}
-function hashUrl(url) {
-  return crypto.createHash("sha256").update(url).digest("hex").slice(0, 16);
-}
-function sourceStoreKey(url) {
-  return `sources/${hashUrl(url)}`;
-}
-function warmupJobStoreKey(jobId) {
-  return `jobs/warmup/${jobId}.json`;
-}
-function renderJobStoreKey(jobId) {
-  return `jobs/render/${jobId}.json`;
-}
-function warmupAndRenderJobStoreKey(jobId) {
-  return `jobs/warmup-and-render/${jobId}.json`;
-}
-var storeKeys = {
-  source: sourceStoreKey,
-  warmupJob: warmupJobStoreKey,
-  renderJob: renderJobStoreKey,
-  warmupAndRenderJob: warmupAndRenderJobStoreKey
-};
-
-// src/render.ts
 var EffieRenderer = class {
   effieData;
   ffmpegRunner;
@@ -779,7 +458,7 @@ var EffieRenderer = class {
           "Local file paths are not allowed. Use allowLocalFiles option for trusted operations."
         );
       }
-      return createReadStream2(fileURLToPath(src));
+      return createReadStream(fileURLToPath(src));
     }
     if (this.transientStore) {
       const cachedStream = await this.transientStore.getStream(
@@ -1253,12 +932,8 @@ var EffieRenderer = class {
 };
 
 export {
-  getFFmpegVersion,
   FFmpegCommand,
   FFmpegRunner,
-  ffsFetch,
-  createTransientStore,
-  storeKeys,
   EffieRenderer
 };
-//# sourceMappingURL=chunk-3SM6XYCZ.js.map
+//# sourceMappingURL=chunk-O7Z6DV2I.js.map