node-av 3.1.3 → 5.0.0

package/dist/api/pipeline.js

@@ -1,8 +1,55 @@
-/**
- * @module pipeline
- * High-level media processing pipeline for FFmpeg operations.
- * Provides a fluent API for building transcoding, filtering, and stream processing pipelines.
- */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 // ============================================================================
 // Implementation
 // ============================================================================
@@ -43,6 +90,26 @@
 export function pipeline(...args) {
     // Detect pipeline type based on first argument
     const firstArg = args[0];
+    const secondArg = args[1];
+    // Check for shared Demuxer + NamedStages pattern
+    if (isDemuxer(firstArg) && isNamedStages(secondArg)) {
+        // Convert shared input to NamedInputs based on stages keys
+        const sharedInput = firstArg;
+        const stages = secondArg;
+        const namedInputs = {};
+        // Create NamedInputs with shared input for all streams in stages
+        for (const streamName of Object.keys(stages)) {
+            namedInputs[streamName] = sharedInput;
+        }
+        if (args.length === 3) {
+            // Full named pipeline with output(s)
+            return runNamedPipeline(namedInputs, stages, args[2]);
+        }
+        else {
+            // Partial named pipeline
+            return runNamedPartialPipeline(namedInputs, stages);
+        }
+    }
     if (isNamedInputs(firstArg)) {
         // Named pipeline (2 or 3 arguments)
         if (args.length === 2) {
@@ -54,14 +121,14 @@ export function pipeline(...args) {
             return runNamedPipeline(args[0], args[1], args[2]);
         }
     }
-    else if (isMediaInput(firstArg)) {
-        // Check if this is a stream copy (MediaInput → MediaOutput)
-        if (args.length === 2 && isMediaOutput(args[1])) {
+    else if (isDemuxer(firstArg)) {
+        // Check if this is a stream copy (Demuxer → Muxer)
+        if (args.length === 2 && isMuxer(args[1])) {
             // Stream copy all streams
-            return runMediaInputPipeline(args[0], args[1]);
+            return runDemuxerPipeline(args[0], args[1]);
         }
         else {
-            // Simple pipeline starting with MediaInput
+            // Simple pipeline starting with Demuxer
             return runSimplePipeline(args);
         }
     }
@@ -128,10 +195,10 @@ class PipelineControlImpl {
     }
 }
 // ============================================================================
-// MediaInput Pipeline Implementation
+// Demuxer Pipeline Implementation
 // ============================================================================
 /**
- * Run a media input pipeline for stream copy.
+ * Run a demuxer pipeline for stream copy.
  *
  * @param input - Media input source
  *
@@ -141,14 +208,14 @@ class PipelineControlImpl {
  *
  * @internal
  */
-function runMediaInputPipeline(input, output) {
+function runDemuxerPipeline(input, output) {
     let control;
     // eslint-disable-next-line prefer-const
-    control = new PipelineControlImpl(runMediaInputPipelineAsync(input, output, () => control.isStopped()));
+    control = new PipelineControlImpl(runDemuxerPipelineAsync(input, output, () => control?.isStopped() ?? false));
     return control;
 }
 /**
- * Run media input pipeline asynchronously.
+ * Run demuxer pipeline asynchronously.
  *
  * @param input - Media input source
  *
@@ -158,7 +225,7 @@ function runMediaInputPipeline(input, output) {
  *
  * @internal
  */
-async function runMediaInputPipelineAsync(input, output, shouldStop) {
+async function runDemuxerPipelineAsync(input, output, shouldStop) {
     // Get all streams from input
     const videoStream = input.video();
     const audioStream = input.audio();
@@ -183,18 +250,35 @@ async function runMediaInputPipelineAsync(input, output, shouldStop) {
         }
     }
     // Copy all packets
-    for await (const packet of input.packets()) {
-        // Check if we should stop
-        if (shouldStop()) {
-            packet.free();
-            break;
+    for await (const packet_1 of input.packets()) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const packet = __addDisposableResource(env_1, packet_1, false);
+            // Check if we should stop
+            if (shouldStop()) {
+                break;
+            }
+            // Handle EOF signal (null packet from input means all streams are done)
+            if (packet === null) {
+                // Signal EOF for all streams
+                for (const mapping of streams) {
+                    await output.writePacket(null, mapping.index);
+                }
+                break;
+            }
+            // Find the corresponding output stream index
+            const mapping = streams.find((s) => s.stream.index === packet.streamIndex);
+            if (mapping) {
+                await output.writePacket(packet, mapping.index);
+            }
         }
-        // Find the corresponding output stream index
-        const mapping = streams.find((s) => s.stream.index === packet.streamIndex);
-        if (mapping) {
-            await output.writePacket(packet, mapping.index);
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
         }
-        packet.free(); // Free packet after processing
     }
     await output.close();
 }
@@ -212,14 +296,14 @@ async function runMediaInputPipelineAsync(input, output, shouldStop) {
  */
 function runSimplePipeline(args) {
     const [source, ...stages] = args;
-    // Check if last stage is MediaOutput (consumes stream)
+    // Check if last stage is Muxer (consumes stream)
     const lastStage = stages[stages.length - 1];
-    const isOutput = isMediaOutput(lastStage);
+    const isOutput = isMuxer(lastStage);
     // Track metadata through pipeline
     const metadata = {};
-    // Store MediaInput reference if we have one
-    if (isMediaInput(source)) {
-        metadata.mediaInput = source;
+    // Store Demuxer reference if we have one
+    if (isDemuxer(source)) {
+        metadata.demuxer = source;
     }
     // Build the pipeline generator
     // If output is present, exclude it from stages for processing
@@ -236,10 +320,10 @@ function runSimplePipeline(args) {
             metadata.bitStreamFilter = stage;
         }
     }
-    // Convert MediaInput to packet stream if needed
+    // Convert Demuxer to packet stream if needed
     // If we have a decoder or BSF, filter packets by stream index
     let actualSource;
-    if (isMediaInput(source)) {
+    if (isDemuxer(source)) {
         if (metadata.decoder) {
             // Filter packets for the decoder's stream
             const streamIndex = metadata.decoder.getStream().index;
@@ -263,7 +347,7 @@ function runSimplePipeline(args) {
     if (isOutput) {
         let control;
         // eslint-disable-next-line prefer-const
-        control = new PipelineControlImpl(consumeSimplePipeline(generator, lastStage, metadata, () => control.isStopped()));
+        control = new PipelineControlImpl(consumeSimplePipeline(generator, lastStage, metadata, () => control?.isStopped() ?? false));
         return control;
     }
     // Otherwise return the generator for further processing
@@ -284,25 +368,25 @@ async function* buildSimplePipeline(source, stages) {
     let stream = source;
     for (const stage of stages) {
         if (isDecoder(stage)) {
-            stream = decodeStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isEncoder(stage)) {
-            stream = encodeStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (isFilterAPI(stage)) {
-            stream = filterStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isBitStreamFilterAPI(stage)) {
-            stream = bitStreamFilterStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (Array.isArray(stage)) {
             // Chain multiple filters or BSFs
             for (const filter of stage) {
                 if (isFilterAPI(filter)) {
-                    stream = filterStream(stream, filter);
+                    stream = filter.frames(stream);
                 }
                 else if (isBitStreamFilterAPI(filter)) {
-                    stream = bitStreamFilterStream(stream, filter);
+                    stream = filter.packets(stream);
                 }
             }
         }
@@ -326,7 +410,16 @@ async function consumeSimplePipeline(stream, output, metadata, shouldStop) {
     // Add stream to output if we have encoder or decoder info
     let streamIndex = 0;
     if (metadata.encoder) {
-        streamIndex = output.addStream(metadata.encoder);
+        // Encoding path
+        if (metadata.decoder) {
+            // Have decoder - use its stream for metadata/properties
+            const originalStream = metadata.decoder.getStream();
+            streamIndex = output.addStream(originalStream, { encoder: metadata.encoder });
+        }
+        else {
+            // Encoder-only mode (e.g., frame generator) - no input stream
+            streamIndex = output.addStream(metadata.encoder);
+        }
     }
     else if (metadata.decoder) {
         // Stream copy - use decoder's original stream
@@ -339,29 +432,37 @@ async function consumeSimplePipeline(stream, output, metadata, shouldStop) {
         streamIndex = output.addStream(originalStream);
     }
     else {
-        // For direct MediaInput → MediaOutput, we redirect to runMediaInputPipeline
+        // For direct Demuxer → Muxer, we redirect to runDemuxerPipeline
         // This case shouldn't happen in simple pipeline
         throw new Error('Cannot determine stream configuration. This is likely a bug in the pipeline.');
     }
     // Process stream
-    for await (const item of stream) {
-        // Check if we should stop
-        if (shouldStop()) {
-            if (isPacket(item)) {
-                item.free();
+    for await (const item_1 of stream) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const item = __addDisposableResource(env_2, item_1, false);
+            // Check if we should stop
+            if (shouldStop()) {
+                break;
+            }
+            // Handle EOF signal
+            if (item === null) {
+                await output.writePacket(null, streamIndex);
+                break;
+            }
+            if (isPacket(item) || item === null) {
+                await output.writePacket(item, streamIndex);
             }
             else {
-                item.free();
+                throw new Error('Cannot write frames directly to Muxer. Use an encoder first.');
             }
-            break;
         }
-        if (isPacket(item)) {
-            await output.writePacket(item, streamIndex);
-            // Free the packet after writing
-            item.free();
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
-        else {
-            throw new Error('Cannot write frames directly to MediaOutput. Use an encoder first.');
+        finally {
+            __disposeResources(env_2);
         }
     }
     await output.close();
@@ -403,7 +504,19 @@ function runNamedPartialPipeline(inputs, stages) {
         if (!stream) {
             throw new Error(`No ${streamName} stream found in input.`);
         }
-        if (streamStages === 'passthrough') {
+        // Normalize stages: if array contains only undefined, treat as passthrough
+        // Also filter out undefined entries from the array
+        let normalizedStages = streamStages;
+        if (Array.isArray(streamStages)) {
+            const definedStages = streamStages.filter((stage) => stage !== undefined);
+            if (definedStages.length === 0) {
+                normalizedStages = 'passthrough';
+            }
+            else {
+                normalizedStages = definedStages;
+            }
+        }
+        if (normalizedStages === 'passthrough') {
             // Direct passthrough - return input packets for this specific stream
             result[streamName] = (async function* () {
                 for await (const packet of input.packets(stream.index)) {
@@ -415,7 +528,8 @@ function runNamedPartialPipeline(inputs, stages) {
             // Process the stream - pass packets for this specific stream only
             // Build pipeline for this stream (can return frames or packets)
             const metadata = {};
-            result[streamName] = buildFlexibleNamedStreamPipeline(input.packets(stream.index), streamStages, metadata);
+            const stages = normalizedStages;
+            result[streamName] = buildFlexibleNamedStreamPipeline(input.packets(stream.index), stages, metadata);
         }
     }
     return result;
@@ -436,7 +550,7 @@ function runNamedPartialPipeline(inputs, stages) {
 function runNamedPipeline(inputs, stages, output) {
     let control;
     // eslint-disable-next-line prefer-const
-    control = new PipelineControlImpl(runNamedPipelineAsync(inputs, stages, output, () => control.isStopped()));
+    control = new PipelineControlImpl(runNamedPipelineAsync(inputs, stages, output, () => control?.isStopped() ?? false));
     return control;
 }
 /**
@@ -453,84 +567,210 @@ function runNamedPipeline(inputs, stages, output) {
  * @internal
  */
 async function runNamedPipelineAsync(inputs, stages, output, shouldStop) {
+    // Check if all inputs reference the same Demuxer instance
+    const inputValues = Object.values(inputs);
+    const allSameInput = inputValues.length > 1 && inputValues.every((input) => input === inputValues[0]);
     // Track metadata for each stream
     const streamMetadata = {};
     // Process each named stream into generators
     const processedStreams = {};
-    for (const [streamName, streamStages] of Object.entries(stages)) {
-        const metadata = {};
-        streamMetadata[streamName] = metadata;
-        const input = inputs[streamName];
-        if (!input) {
-            throw new Error(`No input found for stream: ${streamName}`);
-        }
-        if (streamStages === 'passthrough') {
-            // Direct passthrough - no processing
-            let stream = null;
-            switch (streamName) {
-                case 'video':
-                    stream = input.video() ?? null;
-                    metadata.type = 'video';
-                    break;
-                case 'audio':
-                    stream = input.audio() ?? null;
-                    metadata.type = 'audio';
-                    break;
-            }
-            if (!stream) {
-                throw new Error(`No ${streamName} stream found in input for passthrough.`);
+    // If all inputs are the same instance, use Demuxer's built-in parallel packet generators
+    if (allSameInput) {
+        const sharedInput = inputValues[0];
+        // Single pass: collect metadata and build pipelines directly using input.packets(streamIndex)
+        for (const [streamName, streamStages] of Object.entries(stages)) {
+            const metadata = {};
+            streamMetadata[streamName] = metadata;
+            // Normalize stages
+            let normalizedStages = streamStages;
+            if (Array.isArray(streamStages)) {
+                const definedStages = streamStages.filter((stage) => stage !== undefined);
+                if (definedStages.length === 0) {
+                    normalizedStages = 'passthrough';
+                }
+                else {
+                    normalizedStages = definedStages;
+                }
             }
-            processedStreams[streamName] = input.packets(stream.index);
-            metadata.mediaInput = input; // Track MediaInput for passthrough
-        }
-        else {
-            // Process the stream
-            // Pre-populate metadata by walking through stages
-            for (const stage of streamStages) {
-                if (isDecoder(stage)) {
-                    metadata.decoder = stage;
+            // Determine stream index and build pipeline
+            let streamIndex;
+            if (normalizedStages !== 'passthrough') {
+                const stages = normalizedStages;
+                // Set stream type
+                metadata.type = streamName;
+                // Populate metadata by walking through ALL stages
+                for (const stage of stages) {
+                    if (isDecoder(stage)) {
+                        metadata.decoder = stage;
+                        streamIndex ??= stage.getStream().index;
+                    }
+                    else if (isBitStreamFilterAPI(stage)) {
+                        metadata.bitStreamFilter = stage;
+                        streamIndex ??= stage.getStream().index;
+                    }
+                    else if (isEncoder(stage)) {
+                        metadata.encoder = stage;
+                    }
                 }
-                else if (isEncoder(stage)) {
-                    metadata.encoder = stage;
+                // If no decoder/BSF, use stream name to determine index
+                if (streamIndex === undefined) {
+                    const stream = streamName === 'video' ? sharedInput.video() : sharedInput.audio();
+                    if (!stream) {
+                        throw new Error(`No ${streamName} stream found in input.`);
+                    }
+                    streamIndex = stream.index;
                 }
-                else if (isBitStreamFilterAPI(stage)) {
-                    metadata.bitStreamFilter = stage;
+                // Build pipeline with packets from this specific stream
+                processedStreams[streamName] = buildNamedStreamPipeline(sharedInput.packets(streamIndex), stages, metadata);
+            }
+            else {
+                // Passthrough - use Demuxer's built-in stream filtering
+                metadata.type = streamName;
+                metadata.demuxer = sharedInput;
+                const stream = streamName === 'video' ? sharedInput.video() : sharedInput.audio();
+                if (!stream) {
+                    throw new Error(`No ${streamName} stream found in input for passthrough.`);
                 }
+                streamIndex = stream.index;
+                // Direct passthrough using input.packets(streamIndex)
+                processedStreams[streamName] = sharedInput.packets(streamIndex);
             }
-            // Get packets - filter by stream index based on decoder, BSF, or stream type
-            let packets;
-            if (metadata.decoder) {
-                const streamIndex = metadata.decoder.getStream().index;
-                packets = input.packets(streamIndex);
+        }
+    }
+    else {
+        // Original logic: separate inputs or single input
+        for (const [streamName, streamStages] of Object.entries(stages)) {
+            const metadata = {};
+            streamMetadata[streamName] = metadata;
+            const input = inputs[streamName];
+            if (!input) {
+                throw new Error(`No input found for stream: ${streamName}`);
             }
-            else if (metadata.bitStreamFilter) {
-                const streamIndex = metadata.bitStreamFilter.getStream().index;
-                packets = input.packets(streamIndex);
+            // Normalize stages: if array contains only undefined, treat as passthrough
+            // Also filter out undefined entries from the array
+            let normalizedStages = streamStages;
+            if (Array.isArray(streamStages)) {
+                const definedStages = streamStages.filter((stage) => stage !== undefined);
+                if (definedStages.length === 0) {
+                    normalizedStages = 'passthrough';
+                }
+                else {
+                    normalizedStages = definedStages;
+                }
             }
-            else {
-                // No decoder or BSF - determine stream by name
+            if (normalizedStages === 'passthrough') {
+                // Direct passthrough - no processing
                 let stream = null;
                 switch (streamName) {
                     case 'video':
                         stream = input.video() ?? null;
+                        metadata.type = 'video';
                         break;
                     case 'audio':
                         stream = input.audio() ?? null;
+                        metadata.type = 'audio';
                         break;
                 }
                 if (!stream) {
-                    throw new Error(`No ${streamName} stream found in input.`);
+                    throw new Error(`No ${streamName} stream found in input for passthrough.`);
                 }
-                packets = input.packets(stream.index);
+                processedStreams[streamName] = input.packets(stream.index);
+                metadata.demuxer = input; // Track Demuxer for passthrough
+            }
+            else {
+                // Process the stream - normalizedStages is guaranteed to be an array here
+                const stages = normalizedStages;
+                // Pre-populate metadata by walking through stages
+                for (const stage of stages) {
+                    if (isDecoder(stage)) {
+                        metadata.decoder = stage;
+                    }
+                    else if (isEncoder(stage)) {
+                        metadata.encoder = stage;
+                    }
+                    else if (isBitStreamFilterAPI(stage)) {
+                        metadata.bitStreamFilter = stage;
+                    }
+                }
+                // Get packets - filter by stream index based on decoder, BSF, or stream type
+                let packets;
+                if (metadata.decoder) {
+                    const streamIndex = metadata.decoder.getStream().index;
+                    packets = input.packets(streamIndex);
+                }
+                else if (metadata.bitStreamFilter) {
+                    const streamIndex = metadata.bitStreamFilter.getStream().index;
+                    packets = input.packets(streamIndex);
+                }
+                else {
+                    // No decoder or BSF - determine stream by name
+                    let stream = null;
+                    switch (streamName) {
+                        case 'video':
+                            stream = input.video() ?? null;
+                            break;
+                        case 'audio':
+                            stream = input.audio() ?? null;
+                            break;
+                    }
+                    if (!stream) {
+                        throw new Error(`No ${streamName} stream found in input.`);
+                    }
+                    packets = input.packets(stream.index);
+                }
+                // Build pipeline for this stream
+                processedStreams[streamName] = buildNamedStreamPipeline(packets, stages, metadata);
             }
-            // Build pipeline for this stream
-            processedStreams[streamName] = buildNamedStreamPipeline(packets, streamStages, metadata);
         }
     }
     // Write to output(s)
-    if (isMediaOutput(output)) {
-        // Single output - properly interleave all streams
-        await interleaveToOutput(processedStreams, output, streamMetadata, shouldStop);
+    if (isMuxer(output)) {
+        // Always write streams in parallel - Muxer's SyncQueue handles interleaving internally
+        const streamIndices = {};
+        // Add all streams to output first
+        for (const [name, meta] of Object.entries(streamMetadata)) {
+            if (meta.encoder) {
+                // Encoding path
+                if (meta.decoder) {
+                    // Have decoder - use its stream for metadata/properties
+                    const originalStream = meta.decoder.getStream();
+                    streamIndices[name] = output.addStream(originalStream, { encoder: meta.encoder });
+                }
+                else {
+                    // Encoder-only mode (e.g., frame generator) - no input stream
+                    streamIndices[name] = output.addStream(meta.encoder);
+                }
+            }
+            else if (meta.decoder) {
+                // Stream copy - use decoder's original stream
+                const originalStream = meta.decoder.getStream();
+                streamIndices[name] = output.addStream(originalStream);
+            }
+            else if (meta.bitStreamFilter) {
+                // BSF - use BSF's original stream
+                const originalStream = meta.bitStreamFilter.getStream();
+                streamIndices[name] = output.addStream(originalStream);
+            }
+            else if (meta.demuxer) {
+                // Passthrough from Demuxer
+                const stream = name.includes('video') ? meta.demuxer.video() : meta.demuxer.audio();
+                if (!stream) {
+                    throw new Error(`No matching stream found in Demuxer for ${name}`);
+                }
+                streamIndices[name] = output.addStream(stream);
+            }
+            else {
+                throw new Error(`Cannot determine stream configuration for ${name}. This is likely a bug in the pipeline.`);
+            }
+        }
+        // Write all streams in parallel - Muxer's SyncQueue handles interleaving
+        const promises = [];
+        for (const [name, stream] of Object.entries(processedStreams)) {
+            const streamIndex = streamIndices[name];
+            promises.push(consumeStreamInParallel(stream, output, streamIndex, shouldStop));
+        }
+        await Promise.all(promises);
+        await output.close();
     }
     else {
         // Multiple outputs - write each stream to its output
@@ -564,27 +804,27 @@ async function* buildFlexibleNamedStreamPipeline(source, stages, metadata) {
     for (const stage of stages) {
         if (isDecoder(stage)) {
             metadata.decoder = stage;
-            stream = decodeStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isEncoder(stage)) {
             metadata.encoder = stage;
-            stream = encodeStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (isFilterAPI(stage)) {
-            stream = filterStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isBitStreamFilterAPI(stage)) {
             metadata.bitStreamFilter = stage;
-            stream = bitStreamFilterStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (Array.isArray(stage)) {
             // Chain multiple filters or BSFs
             for (const filter of stage) {
                 if (isFilterAPI(filter)) {
-                    stream = filterStream(stream, filter);
+                    stream = filter.frames(stream);
                 }
                 else if (isBitStreamFilterAPI(filter)) {
-                    stream = bitStreamFilterStream(stream, filter);
+                    stream = filter.packets(stream);
                 }
             }
         }
@@ -610,34 +850,34 @@ async function* buildNamedStreamPipeline(source, stages, metadata) {
     for (const stage of stages) {
         if (isDecoder(stage)) {
             metadata.decoder = stage;
-            stream = decodeStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isEncoder(stage)) {
             metadata.encoder = stage;
-            stream = encodeStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (isFilterAPI(stage)) {
-            stream = filterStream(stream, stage);
+            stream = stage.frames(stream);
         }
         else if (isBitStreamFilterAPI(stage)) {
             metadata.bitStreamFilter = stage;
-            stream = bitStreamFilterStream(stream, stage);
+            stream = stage.packets(stream);
         }
         else if (Array.isArray(stage)) {
             // Chain multiple filters or BSFs
             for (const filter of stage) {
                 if (isFilterAPI(filter)) {
-                    stream = filterStream(stream, filter);
+                    stream = filter.frames(stream);
                 }
                 else if (isBitStreamFilterAPI(filter)) {
-                    stream = bitStreamFilterStream(stream, filter);
+                    stream = filter.packets(stream);
                 }
             }
         }
     }
     // Ensure we're yielding packets
     for await (const item of stream) {
-        if (isPacket(item)) {
+        if (isPacket(item) || item === null) {
             yield item;
         }
         else {
@@ -645,6 +885,42 @@ async function* buildNamedStreamPipeline(source, stages, metadata) {
         }
     }
 }
+/**
+ * Consume a stream in parallel (for passthrough pipelines).
+ * Stream index is already added to output.
+ *
+ * @param stream - Stream of packets
+ *
+ * @param output - Media output destination
+ *
+ * @param streamIndex - Pre-allocated stream index in output
+ *
+ * @param shouldStop - Function to check if pipeline should stop
+ *
+ * @internal
+ */
+async function consumeStreamInParallel(stream, output, streamIndex, shouldStop) {
+    // Write all packets (including EOF null)
+    for await (const packet_2 of stream) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const packet = __addDisposableResource(env_3, packet_2, false);
+            // Check if we should stop
+            if (shouldStop()) {
+                break;
+            }
+            await output.writePacket(packet, streamIndex);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    // Note: Don't close output here - it will be closed by the caller after all streams finish
+}
 /**
  * Consume a named stream and write to output.
  *
@@ -662,7 +938,16 @@ async function consumeNamedStream(stream, output, metadata, shouldStop) {
     // Add stream to output
     let streamIndex = 0;
     if (metadata.encoder) {
-        streamIndex = output.addStream(metadata.encoder);
+        // Encoding path
+        if (metadata.decoder) {
+            // Have decoder - use its stream for metadata/properties
+            const originalStream = metadata.decoder.getStream();
+            streamIndex = output.addStream(originalStream, { encoder: metadata.encoder });
+        }
+        else {
+            // Encoder-only mode (e.g., frame generator) - no input stream
+            streamIndex = output.addStream(metadata.encoder);
+        }
     }
     else if (metadata.decoder) {
         // Stream copy - use decoder's original stream
@@ -674,11 +959,11 @@ async function consumeNamedStream(stream, output, metadata, shouldStop) {
         const originalStream = metadata.bitStreamFilter.getStream();
         streamIndex = output.addStream(originalStream);
     }
-    else if (metadata.mediaInput) {
-        // Passthrough from MediaInput - use type hint from metadata
-        const inputStream = metadata.type === 'video' ? metadata.mediaInput.video() : metadata.mediaInput.audio();
+    else if (metadata.demuxer) {
+        // Passthrough from Demuxer - use type hint from metadata
+        const inputStream = metadata.type === 'video' ? metadata.demuxer.video() : metadata.demuxer.audio();
         if (!inputStream) {
-            throw new Error(`No ${metadata.type} stream found in MediaInput`);
+            throw new Error(`No ${metadata.type} stream found in Demuxer`);
         }
         streamIndex = output.addStream(inputStream);
     }
@@ -688,333 +973,58 @@ async function consumeNamedStream(stream, output, metadata, shouldStop) {
     }
     // Store for later use
     metadata.streamIndex = streamIndex;
-    // Write all packets
-    for await (const packet of stream) {
-        // Check if we should stop
-        if (shouldStop()) {
-            packet.free();
-            break;
-        }
+    // Write all packets (including EOF null)
+    for await (const packet_3 of stream) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            await output.writePacket(packet, streamIndex);
-        }
-        finally {
-            packet.free(); // Free packet after writing
-        }
-    }
-    // Note: Trailer will be written by interleaveToOutput
-}
-/**
- * Interleave multiple streams to a single output.
- *
- * @param streams - Record of packet streams
- *
- * @param output - Media output destination
- *
- * @param metadata - Stream metadata for each stream
- *
- * @param shouldStop - Function to check if pipeline should stop
- *
- * @internal
- */
-async function interleaveToOutput(streams, output, metadata, shouldStop) {
-    // Add all streams to output first
-    const streamIndices = {};
-    for (const [name, meta] of Object.entries(metadata)) {
-        if (meta.encoder) {
-            streamIndices[name] = output.addStream(meta.encoder);
-        }
-        else if (meta.decoder) {
-            // Stream copy - use decoder's original stream
-            const originalStream = meta.decoder.getStream();
-            streamIndices[name] = output.addStream(originalStream);
-        }
-        else if (meta.bitStreamFilter) {
-            // BSF - use BSF's original stream
-            const originalStream = meta.bitStreamFilter.getStream();
-            streamIndices[name] = output.addStream(originalStream);
-        }
-        else if (meta.mediaInput) {
-            // Passthrough from MediaInput - use stream name to determine which stream
-            const stream = name.includes('video') ? meta.mediaInput.video() : meta.mediaInput.audio();
-            if (!stream) {
-                throw new Error(`No matching stream found in MediaInput for ${name}`);
-            }
-            streamIndices[name] = output.addStream(stream);
-        }
-        else {
-            // This should not happen
-            throw new Error(`Cannot determine stream configuration for ${name}. This is likely a bug in the pipeline.`);
-        }
-    }
-    const queues = new Map();
-    const iterators = new Map();
-    const done = new Set();
-    // Initialize iterators
-    for (const [name, stream] of Object.entries(streams)) {
-        queues.set(name, []);
-        iterators.set(name, stream[Symbol.asyncIterator]());
-    }
-    // Read initial packet from each stream
-    for (const [name, iterator] of iterators) {
-        const result = await iterator.next();
-        if (!result.done && result.value) {
-            const packet = result.value;
-            packet._streamName = name;
-            queues.get(name).push(packet);
-        }
-        else {
-            done.add(name);
-        }
-    }
-    // Interleave packets based on DTS/PTS
-    while (done.size < Object.keys(streams).length && !shouldStop()) {
-        // Find packet with smallest DTS/PTS
-        let minPacket = null;
-        let minStreamName = null;
-        let minTime = BigInt(Number.MAX_SAFE_INTEGER);
-        for (const [name, queue] of queues) {
-            if (queue.length > 0) {
-                const packet = queue[0];
-                const time = packet.dts ?? packet.pts ?? BigInt(0);
-                if (time < minTime) {
-                    minTime = time;
-                    minPacket = packet;
-                    minStreamName = name;
-                }
-            }
-        }
-        if (!minPacket || !minStreamName) {
-            // All queues empty, read more
-            for (const [name, iterator] of iterators) {
-                if (!done.has(name)) {
-                    const result = await iterator.next();
-                    if (!result.done && result.value) {
-                        const packet = result.value;
-                        packet._streamName = name;
-                        queues.get(name).push(packet);
-                    }
-                    else {
-                        done.add(name);
-                    }
-                }
+            const packet = __addDisposableResource(env_4, packet_3, false);
+            // Check if we should stop
+            if (shouldStop()) {
+                break;
             }
-            continue;
-        }
-        // Write the packet with smallest timestamp
-        const streamIndex = streamIndices[minStreamName];
-        await output.writePacket(minPacket, streamIndex);
-        // Free the packet after writing
-        minPacket.free();
-        // Remove from queue
-        queues.get(minStreamName).shift();
-        // Read next packet from that stream
-        const iterator = iterators.get(minStreamName);
-        const result = await iterator.next();
-        if (!result.done && result.value) {
-            const packet = result.value;
-            packet._streamName = minStreamName;
-            queues.get(minStreamName).push(packet);
-        }
-        else {
-            done.add(minStreamName);
+            await output.writePacket(packet, streamIndex);
         }
-    }
-    // If stopped, free all remaining packets in queues
-    if (shouldStop()) {
-        for (const [, queue] of queues) {
-            for (const packet of queue) {
-                packet.free();
-            }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
         }
-    }
-    else {
-        // Write any remaining packets
-        for (const [name, queue] of queues) {
-            const streamIndex = streamIndices[name];
-            for (const packet of queue) {
-                await output.writePacket(packet, streamIndex);
-                packet.free(); // Free packet after writing
-            }
+        finally {
+            __disposeResources(env_4);
         }
     }
-    await output.close();
+    // Note: Output is closed by the caller after all streams finish
 }
 // ============================================================================
-// Stream Processing Functions
+// Type Guards
 // ============================================================================
 /**
- * Decode a stream of packets to frames.
- *
- * @param packets - Input packets
- *
- * @param decoder - Decoder instance
- *
- * @yields {Frame} Decoded frames
- *
- * @internal
- */
-async function* decodeStream(packets, decoder) {
-    // Process all packets
-    for await (const packet of packets) {
-        try {
-            const frame = await decoder.decode(packet);
-            if (frame) {
-                yield frame;
-            }
-        }
-        finally {
-            // Free packet after decoding
-            packet.free();
-        }
-    }
-    // Flush decoder
-    if ('flushFrames' in decoder && typeof decoder.flushFrames === 'function') {
-        // Use generator method if available
-        for await (const frame of decoder.flushFrames()) {
-            yield frame;
-        }
-    }
-    else {
-        // Fallback to manual flush + receive
-        await decoder.flush();
-        let packet;
-        while ((packet = await decoder.receive()) !== null) {
-            yield packet;
-        }
-    }
-}
-/**
- * Encode a stream of frames to packets.
- *
- * @param frames - Input frames
- *
- * @param encoder - Encoder instance
- *
- * @yields {Packet} Encoded packets
- *
- * @internal
- */
-async function* encodeStream(frames, encoder) {
-    // Process all frames
-    for await (const frame of frames) {
-        try {
-            const packet = await encoder.encode(frame);
-            if (packet) {
-                yield packet;
-            }
-        }
-        finally {
-            // Free the input frame after encoding
-            frame.free();
-        }
-    }
-    // Flush encoder
-    if ('flushPackets' in encoder && typeof encoder.flushPackets === 'function') {
-        // Use generator method if available
-        for await (const packet of encoder.flushPackets()) {
-            yield packet;
-        }
-    }
-    else {
-        // Fallback to manual flush + receive
-        await encoder.flush();
-        let packet;
-        while ((packet = await encoder.receive()) !== null) {
-            yield packet;
-        }
-    }
-}
-/**
- * Filter a stream of frames.
- *
- * @param frames - Input frames
- *
- * @param filter - Filter instance
- *
- * @yields {Frame} Filtered frames
- *
- * @internal
- */
-async function* filterStream(frames, filter) {
-    // Process all frames
-    for await (const frame of frames) {
-        try {
-            const filtered = await filter.process(frame);
-            if (filtered) {
-                yield filtered;
-            }
-            // Check for buffered frames
-            let buffered;
-            while ((buffered = await filter.receive()) !== null) {
-                yield buffered;
-            }
-        }
-        finally {
-            // Free the input frame after filtering
-            frame.free();
-        }
-    }
-    // Flush filter
-    if ('flushFrames' in filter && typeof filter.flushFrames === 'function') {
-        // Use generator method if available
-        for await (const frame of filter.flushFrames()) {
-            yield frame;
-        }
-    }
-    else {
-        // Fallback to manual flush + receive
-        await filter.flush();
-        let frame;
-        while ((frame = await filter.receive()) !== null) {
-            yield frame;
-        }
-    }
-}
-/**
- * Process packets through a bitstream filter.
- *
- * @param packets - Input packets
+ * Check if object is named inputs.
  *
- * @param bsf - Bitstream filter instance
+ * @param obj - Object to check
  *
- * @yields {Packet} Filtered packets
+ * @returns True if object is NamedInputs
  *
  * @internal
  */
-async function* bitStreamFilterStream(packets, bsf) {
-    // Process all packets through bitstream filter
-    for await (const packet of packets) {
-        try {
-            const filtered = await bsf.process(packet);
-            for (const outPacket of filtered) {
-                yield outPacket;
-            }
-        }
-        finally {
-            // Free the input packet after filtering
-            packet.free();
-        }
-    }
-    // Flush bitstream filter
-    for await (const packet of bsf.flushPackets()) {
-        yield packet;
-    }
+function isNamedInputs(obj) {
+    return obj && typeof obj === 'object' && !Array.isArray(obj) && !isAsyncIterable(obj) && !isDemuxer(obj);
 }
-// ============================================================================
-// Type Guards
-// ============================================================================
 /**
- * Check if object is named inputs.
+ * Check if object is named stages.
  *
  * @param obj - Object to check
  *
- * @returns True if object is NamedInputs
+ * @returns True if object is NamedStages
  *
  * @internal
  */
-function isNamedInputs(obj) {
-    return obj && typeof obj === 'object' && !Array.isArray(obj) && !isAsyncIterable(obj) && !isMediaInput(obj);
+function isNamedStages(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        return false;
+    }
+    // Check if object has at least one stream name key (video or audio)
+    const keys = Object.keys(obj);
+    return keys.length > 0 && keys.every((key) => key === 'video' || key === 'audio');
 }
 /**
  * Check if object is async iterable.
@@ -1029,15 +1039,15 @@ function isAsyncIterable(obj) {
     return obj && typeof obj[Symbol.asyncIterator] === 'function';
 }
 /**
- * Check if object is MediaInput.
+ * Check if object is Demuxer.
  *
  * @param obj - Object to check
  *
- * @returns True if object is MediaInput
+ * @returns True if object is Demuxer
  *
  * @internal
  */
-function isMediaInput(obj) {
+function isDemuxer(obj) {
     return obj && typeof obj.packets === 'function' && typeof obj.video === 'function' && typeof obj.audio === 'function';
 }
 /**
@@ -1086,18 +1096,18 @@ function isFilterAPI(obj) {
  * @internal
  */
 function isBitStreamFilterAPI(obj) {
-    return obj && typeof obj.process === 'function' && typeof obj.flushPackets === 'function' && typeof obj.reset === 'function';
+    return obj && typeof obj.filter === 'function' && typeof obj.flushPackets === 'function' && typeof obj.reset === 'function';
 }
 /**
- * Check if object is MediaOutput.
+ * Check if object is Muxer.
  *
  * @param obj - Object to check
  *
- * @returns True if object is MediaOutput
+ * @returns True if object is Muxer
  *
  * @internal
  */
-function isMediaOutput(obj) {
+function isMuxer(obj) {
     return obj && typeof obj.writePacket === 'function' && typeof obj.addStream === 'function';
 }
 /**