@effing/ffs 0.1.1 → 0.2.0

package/dist/handlers/index.d.ts

@@ -1,5 +1,5 @@
-import { C as CacheStorage } from '../cache-BUVFfGZF.js';
-import { EffieData, EffieSources } from '@effing/effie';
+import { C as CacheStorage, H as HttpProxy } from '../proxy-BI8OMQl0.js';
+import { EffieSourceWithType, EffieData, EffieSources } from '@effing/effie';
 import express from 'express';
 import 'stream';
 
@@ -8,7 +8,7 @@ type UploadOptions = {
     coverUrl?: string;
 };
 type WarmupJob = {
-    sources: string[];
+    sources: EffieSourceWithType[];
 };
 type RenderJob = {
     effie: EffieData<EffieSources>;
@@ -18,6 +18,7 @@ type RenderJob = {
 };
 type ServerContext = {
     cacheStorage: CacheStorage;
+    httpProxy: HttpProxy;
     baseUrl: string;
     skipValidation: boolean;
     cacheConcurrency: number;
@@ -26,7 +27,7 @@ type SSEEventSender = (event: string, data: object) => void;
 /**
  * Create the server context with configuration from environment variables
  */
-declare function createServerContext(): ServerContext;
+declare function createServerContext(): Promise<ServerContext>;
 
 /**
  * POST /warmup - Create a warmup job

package/dist/handlers/index.js

@@ -5,8 +5,8 @@ import {
   purgeCache,
   streamRenderJob,
   streamWarmupJob
-} from "../chunk-LK5K4SQV.js";
-import "../chunk-RNE6TKMF.js";
+} from "../chunk-6YHSYHDY.js";
+import "../chunk-A7BAW24L.js";
 export {
   createRenderJob,
   createServerContext,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
-import { EffieWebUrl, EffieData, EffieSources, EffieMotion, EffieEffect, EffieTransition } from '@effing/effie';
-import { C as CacheStorage } from './cache-BUVFfGZF.js';
+import { EffieWebUrl, EffieData, EffieSources } from '@effing/effie';
+import { C as CacheStorage, H as HttpProxy } from './proxy-BI8OMQl0.js';
 
 type EffieRendererOptions = {
     /**
@@ -15,12 +15,20 @@ type EffieRendererOptions = {
      * If not provided, a shared lazy-initialized cache will be used.
      */
     cacheStorage?: CacheStorage;
+    /**
+     * HTTP proxy for video/audio URLs.
+     * When provided, HTTP(S) URLs for video/audio inputs will be routed
+     * through this proxy, allowing Node.js to handle DNS resolution
+     * instead of FFmpeg (useful for Alpine Linux with musl libc).
+     */
+    httpProxy?: HttpProxy;
 };
 declare class EffieRenderer<U extends string = EffieWebUrl> {
     private effieData;
     private ffmpegRunner?;
     private allowLocalFiles;
     private cacheStorage?;
+    private httpProxy?;
     constructor(effieData: EffieData<EffieSources<U>, U>, options?: EffieRendererOptions);
     private fetchSource;
     private buildAudioFilter;
@@ -60,6 +68,12 @@ declare class EffieRenderer<U extends string = EffieWebUrl> {
     private applyGeneralAudio;
     private buildFFmpegCommand;
     private createImageTransformer;
+    /**
+     * Resolves a source reference to its actual URL.
+     * If the source is a #reference, returns the resolved URL.
+     * Otherwise, returns the source as-is.
+     */
+    private resolveReference;
     /**
      * Renders the effie data to a video stream.
      * @param scaleFactor - Scale factor for output dimensions
@@ -90,17 +104,11 @@ declare class FFmpegRunner {
     private command;
     private ffmpegProc?;
     constructor(command: FFmpegCommand);
-    run(sourceResolver: (input: {
+    run(sourceFetcher: (input: {
         type: FFmpegInput["type"];
         src: string;
-    }) => Promise<Readable>, imageTransformer?: (imageStream: Readable) => Promise<Readable>): Promise<Readable>;
+    }) => Promise<Readable>, imageTransformer?: (imageStream: Readable) => Promise<Readable>, referenceResolver?: (src: string) => string, urlTransformer?: (url: string) => string): Promise<Readable>;
     close(): void;
 }
 
-declare function processMotion(delay: number, motion?: EffieMotion): string;
-
-declare function processEffects(effects: EffieEffect[] | undefined, frameRate: number, frameWidth: number, frameHeight: number): string;
-
-declare function processTransition(transition: EffieTransition): string;
-
-export { EffieRenderer, type EffieRendererOptions, FFmpegCommand, type FFmpegInput, FFmpegRunner, processEffects, processMotion, processTransition };
+export { EffieRenderer, type EffieRendererOptions, FFmpegCommand, type FFmpegInput, FFmpegRunner };

package/dist/index.js

@@ -1,17 +1,11 @@
 import {
   EffieRenderer,
   FFmpegCommand,
-  FFmpegRunner,
-  processEffects,
-  processMotion,
-  processTransition
-} from "./chunk-RNE6TKMF.js";
+  FFmpegRunner
+} from "./chunk-A7BAW24L.js";
 export {
   EffieRenderer,
   FFmpegCommand,
-  FFmpegRunner,
-  processEffects,
-  processMotion,
-  processTransition
+  FFmpegRunner
 };
 //# sourceMappingURL=index.js.map

package/dist/proxy-BI8OMQl0.d.ts

@@ -0,0 +1,68 @@
+import { Readable } from 'stream';
+
+/**
+ * Cache storage interface
+ */
+interface CacheStorage {
+    /** Store a stream with the given key */
+    put(key: string, stream: Readable): Promise<void>;
+    /** Get a stream for the given key, or null if not found */
+    getStream(key: string): Promise<Readable | null>;
+    /** Check if a key exists */
+    exists(key: string): Promise<boolean>;
+    /** Check if multiple keys exist (batch operation) */
+    existsMany(keys: string[]): Promise<Map<string, boolean>>;
+    /** Delete a key */
+    delete(key: string): Promise<void>;
+    /** Store JSON data */
+    putJson(key: string, data: object): Promise<void>;
+    /** Get JSON data, or null if not found */
+    getJson<T>(key: string): Promise<T | null>;
+    /** Close and cleanup resources */
+    close(): void;
+}
+
+/**
+ * HTTP proxy for FFmpeg URL handling.
+ *
+ * Static FFmpeg binaries can have DNS resolution issues on Alpine Linux (musl libc).
+ * This proxy lets Node.js handle DNS lookups instead of FFmpeg by proxying HTTP
+ * requests through localhost.
+ *
+ * URL scheme (M3U8-compatible):
+ * - Original:  https://cdn.example.com/path/to/stream.m3u8
+ * - Proxy:     http://127.0.0.1:{port}/https://cdn.example.com/path/to/stream.m3u8
+ * - Relative:  segment-0.ts → http://127.0.0.1:{port}/https://cdn.example.com/path/to/segment-0.ts
+ */
+declare class HttpProxy {
+    private server;
+    private _port;
+    private startPromise;
+    get port(): number | null;
+    /**
+     * Transform a URL to go through the proxy.
+     * @throws Error if proxy not started
+     */
+    transformUrl(url: string): string;
+    /**
+     * Start the proxy server. Safe to call multiple times.
+     */
+    start(): Promise<void>;
+    private doStart;
+    /**
+     * Parse the proxy path to extract the original URL.
+     * Path format: /{originalUrl}
+     */
+    private parseProxyPath;
+    /**
+     * Filter headers to forward to the upstream server.
+     * Removes hop-by-hop headers that shouldn't be forwarded.
+     */
+    private filterHeaders;
+    /**
+     * Close the proxy server and reset state.
+     */
+    close(): void;
+}
+
+export { type CacheStorage as C, HttpProxy as H };