avbridge 2.2.1 → 2.5.0

package/dist/index.cjs

@@ -1,346 +1,523 @@
 'use strict';
 
-var chunkUF2N5L63_cjs = require('./chunk-UF2N5L63.cjs');
-var chunkHZLQNKFN_cjs = require('./chunk-HZLQNKFN.cjs');
-var chunkL4NPOJ36_cjs = require('./chunk-L4NPOJ36.cjs');
+var chunkQ2VUO52Z_cjs = require('./chunk-Q2VUO52Z.cjs');
+var chunkTBW26OPP_cjs = require('./chunk-TBW26OPP.cjs');
+var chunkS4WAZC2T_cjs = require('./chunk-S4WAZC2T.cjs');
+var chunkZCUXHW55_cjs = require('./chunk-ZCUXHW55.cjs');
+var chunk2IJ66NTD_cjs = require('./chunk-2IJ66NTD.cjs');
+require('./chunk-QDJLQR53.cjs');
+require('./chunk-CPZ7PXAM.cjs');
+require('./chunk-Z33SBWL5.cjs');
 require('./chunk-G4APZMCP.cjs');
-require('./chunk-NZU7W256.cjs');
+require('./chunk-F3LQJKXK.cjs');
 
-// src/convert/remux.ts
-var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
-  "mp4",
-  "mov",
-  "mkv",
-  "webm",
-  "ogg",
-  "wav",
-  "mp3",
-  "flac",
-  "adts"
-]);
-async function remux(source, options = {}) {
-  const outputFormat = options.outputFormat ?? "mp4";
-  options.signal?.throwIfAborted();
-  const ctx = await chunkUF2N5L63_cjs.probe(source);
-  options.signal?.throwIfAborted();
-  validateRemuxEligibility(ctx, options.strict ?? false);
-  if (MEDIABUNNY_CONTAINERS.has(ctx.container)) {
-    return remuxViaMediAbunny(ctx, outputFormat, options);
-  }
-  return remuxViaLibav(ctx, outputFormat, options);
+// src/convert/transcode-libav.ts
+function isLibavTranscodeContainer(container) {
+  return container === "avi" || container === "asf" || container === "flv" || container === "rm";
 }
-function validateRemuxEligibility(ctx, strict) {
-  const video = ctx.videoTracks[0];
-  const audio = ctx.audioTracks[0];
-  if (video) {
-    const mbCodec = chunkUF2N5L63_cjs.avbridgeVideoToMediabunny(video.codec);
-    if (!mbCodec) {
-      throw new Error(
-        `Cannot remux: video codec "${video.codec}" is not supported for remuxing. Use transcode() to re-encode to a modern codec.`
-      );
-    }
-  }
-  if (audio) {
-    const mbCodec = chunkUF2N5L63_cjs.avbridgeAudioToMediabunny(audio.codec);
-    if (!mbCodec) {
-      throw new Error(
-        `Cannot remux: audio codec "${audio.codec}" is not supported for remuxing. Use transcode() to re-encode to a modern codec.`
-      );
-    }
-  }
-  if (strict && video?.codec === "h264" && audio?.codec === "mp3") {
-    throw new Error(
-      `Cannot remux in strict mode: H.264 + MP3 is a best-effort combination that may produce playback issues in some browsers. Set strict: false to allow, or use transcode() to re-encode audio to AAC.`
+async function transcodeViaLibav(ctx, options) {
+  const outputFormat = options.outputFormat ?? "mp4";
+  if (outputFormat !== "mp4" && outputFormat !== "webm" && outputFormat !== "mkv") {
+    throw new chunk2IJ66NTD_cjs.AvbridgeError(
+      chunk2IJ66NTD_cjs.ERR_TRANSCODE_UNSUPPORTED_COMBO,
+      `legacy-container transcode supports MP4, WebM, and MKV output (got "${outputFormat}").`,
+      `Use outputFormat: "mp4", "webm", or "mkv".`
     );
   }
-  if (!video && !audio) {
-    throw new Error("Cannot remux: source has no video or audio tracks.");
-  }
-}
-async function remuxViaMediAbunny(ctx, outputFormat, options) {
-  const mb = await import('mediabunny');
-  const input = new mb.Input({
-    source: await chunkUF2N5L63_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
-    formats: mb.ALL_FORMATS
-  });
-  const target = new mb.BufferTarget();
-  const output = new mb.Output({
-    format: createOutputFormat(mb, outputFormat),
-    target
-  });
-  const conversion = await mb.Conversion.init({
-    input,
-    output,
-    showWarnings: false
+  const videoCodec = options.videoCodec ?? (outputFormat === "webm" ? "vp9" : "h264");
+  const audioCodec = options.audioCodec ?? (outputFormat === "webm" ? "opus" : "aac");
+  const quality = options.quality ?? "medium";
+  options.signal?.throwIfAborted();
+  const [
+    mb,
+    { openLibavDemux, sanitizePacketTimestamp, sanitizeFrameTimestamp, libavFrameToInterleavedFloat32 },
+    { normalizeSource },
+    { createOutputFormat: createOutputFormat2, mimeForFormat: mimeForFormat2, generateFilename: generateFilename2 }
+  ] = await Promise.all([
+    import('mediabunny'),
+    import('./libav-demux-H2GS46GH.cjs'),
+    import('./source-VFLXLOCN.cjs'),
+    import('./remux-OBSMIENG.cjs')
+  ]);
+  const normalized = await normalizeSource(ctx.source);
+  const demux = await openLibavDemux({
+    source: normalized,
+    filename: ctx.name ?? "input.bin",
+    context: ctx
+    // transport config is not yet threaded through ConvertOptions; add
+    // later if URL-source transcode with signed URLs becomes a need.
   });
-  if (!conversion.isValid) {
-    const reasons = conversion.discardedTracks.map((d) => `${d.track.type} track discarded: ${d.reason}`).join("; ");
-    throw new Error(`Cannot remux: mediabunny rejected the conversion. ${reasons}`);
-  }
-  if (options.onProgress) {
-    const onProgress = options.onProgress;
-    conversion.onProgress = (p) => {
-      onProgress({ percent: p * 100, bytesWritten: 0 });
-    };
-  }
-  let abortHandler;
-  if (options.signal) {
-    options.signal.throwIfAborted();
-    abortHandler = () => void conversion.cancel();
-    options.signal.addEventListener("abort", abortHandler, { once: true });
-  }
   try {
-    await conversion.execute();
-  } finally {
-    if (abortHandler && options.signal) {
-      options.signal.removeEventListener("abort", abortHandler);
+    let throwIfAborted2 = function() {
+      if (ac?.aborted) {
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_TRANSCODE_ABORTED,
+          "transcode: aborted by caller.",
+          void 0
+        );
+      }
+    }, throwIfDrainError2 = function() {
+      if (drainError) {
+        const msg = drainError.message;
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_TRANSCODE_DECODE,
+          `transcode: video decoder error: ${msg}`,
+          "This usually indicates the WebCodecs decoder rejected a malformed packet."
+        );
+      }
+    };
+    var throwIfAborted = throwIfAborted2, throwIfDrainError = throwIfDrainError2;
+    options.signal?.throwIfAborted();
+    if (!demux.videoStream && !demux.audioStream) {
+      throw new Error("transcode: source has no decodable tracks");
     }
-  }
-  if (!target.buffer) {
-    throw new Error("Remux failed: mediabunny produced no output buffer.");
-  }
-  const mimeType = mimeForFormat(outputFormat);
-  const blob = new Blob([target.buffer], { type: mimeType });
-  const filename = generateFilename(ctx.name, outputFormat);
-  options.onProgress?.({ percent: 100, bytesWritten: blob.size });
-  return {
-    blob,
-    mimeType,
-    container: outputFormat,
-    videoCodec: ctx.videoTracks[0]?.codec,
-    audioCodec: ctx.audioTracks[0]?.codec,
-    duration: ctx.duration,
-    filename
-  };
-}
-async function remuxViaLibav(ctx, outputFormat, options) {
-  let loadLibav;
-  let pickLibavVariant;
-  try {
-    const loader = await import('./libav-loader-IV4AJ2HW.cjs');
-    const routing = await import('./variant-routing-GOHB2RZN.cjs');
-    loadLibav = loader.loadLibav;
-    pickLibavVariant = routing.pickLibavVariant;
-  } catch {
-    throw new Error(
-      `Cannot remux ${ctx.container.toUpperCase()} source: libav.js is not available. Install @libav.js/variant-webcodecs and libavjs-webcodecs-bridge, or build the custom avbridge variant with scripts/build-libav.sh.`
-    );
-  }
-  const variant = pickLibavVariant(ctx);
-  const libav = await loadLibav(variant);
-  const normalized = await chunkHZLQNKFN_cjs.normalizeSource(ctx.source);
-  const filename = ctx.name ?? `remux-input-${Date.now()}`;
-  const handle = await chunkL4NPOJ36_cjs.prepareLibavInput(libav, filename, normalized);
-  try {
-    return await doLibavRemux(libav, filename, ctx, outputFormat, options);
-  } finally {
-    await handle.detach().catch(() => {
+    if (options.outputStream) {
+      throw new chunk2IJ66NTD_cjs.AvbridgeError(
+        chunk2IJ66NTD_cjs.ERR_TRANSCODE_UNSUPPORTED_COMBO,
+        "outputStream is not yet supported for the libav-backed transcode path.",
+        "Remove the outputStream option to receive the transcoded blob in memory. Streaming output for this path is on the roadmap."
+      );
+    }
+    const bufferTarget = new mb.BufferTarget();
+    const output = new mb.Output({
+      format: createOutputFormat2(mb, outputFormat),
+      target: bufferTarget
     });
-  }
-}
-async function doLibavRemux(libav, filename, ctx, outputFormat, options) {
-  const mb = await import('mediabunny');
-  const readPkt = await libav.av_packet_alloc();
-  const [fmt_ctx, streams] = await libav.ff_init_demuxer_file(filename);
-  const videoStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_VIDEO) ?? null;
-  const audioStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
-  const videoTrackInfo = ctx.videoTracks[0];
-  const audioTrackInfo = ctx.audioTracks[0];
-  const mbVideoCodec = videoTrackInfo ? chunkUF2N5L63_cjs.avbridgeVideoToMediabunny(videoTrackInfo.codec) : null;
-  const mbAudioCodec = audioTrackInfo ? chunkUF2N5L63_cjs.avbridgeAudioToMediabunny(audioTrackInfo.codec) : null;
-  const target = new mb.BufferTarget();
-  const output = new mb.Output({
-    format: createOutputFormat(mb, outputFormat),
-    target
-  });
-  let videoSource = null;
-  let audioSource = null;
-  if (mbVideoCodec && videoStream) {
-    videoSource = new mb.EncodedVideoPacketSource(mbVideoCodec);
-    output.addVideoTrack(videoSource);
-  }
-  if (mbAudioCodec && audioStream) {
-    audioSource = new mb.EncodedAudioPacketSource(mbAudioCodec);
-    output.addAudioTrack(audioSource);
-  }
-  await output.start();
-  const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
-  const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
-  let syntheticVideoUs = 0;
-  let syntheticAudioUs = 0;
-  const videoTimeBase = videoStream?.time_base_num && videoStream?.time_base_den ? [videoStream.time_base_num, videoStream.time_base_den] : void 0;
-  const audioTimeBase = audioStream?.time_base_num && audioStream?.time_base_den ? [audioStream.time_base_num, audioStream.time_base_den] : void 0;
-  let totalPackets = 0;
-  const durationUs = ctx.duration ? ctx.duration * 1e6 : 0;
-  let firstVideoMeta = true;
-  let firstAudioMeta = true;
-  while (true) {
-    options.signal?.throwIfAborted();
-    let readErr;
-    let packets;
-    try {
-      [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
-        limit: 64 * 1024
-      });
-    } catch (err) {
-      throw new Error(`libav demux failed: ${err.message}`);
+    const bridge = await loadBridge();
+    let videoDecoder = null;
+    let videoSoftDec = null;
+    let videoSource = null;
+    let videoBsfCtx = null;
+    let videoBsfPkt = null;
+    let videoWidth = 0;
+    let videoHeight = 0;
+    let videoTimeBase;
+    const frameQueue = [];
+    const MAX_QUEUE = 16;
+    let draining = false;
+    let drainError = null;
+    let activeDrain = null;
+    const drain = () => {
+      if (draining) return activeDrain ?? Promise.resolve();
+      draining = true;
+      const run = (async () => {
+        try {
+          while (frameQueue.length > 0 && !drainError) {
+            const frame = frameQueue.shift();
+            try {
+              const sample = new mb.VideoSample(frame, {
+                timestamp: (frame.timestamp ?? 0) / 1e6
+                // µs → s
+              });
+              await videoSource.add(sample);
+            } finally {
+              frame.close();
+            }
+          }
+        } catch (err) {
+          drainError = err;
+          while (frameQueue.length > 0) {
+            try {
+              frameQueue.shift().close();
+            } catch {
+            }
+          }
+        } finally {
+          draining = false;
+          activeDrain = null;
+        }
+      })();
+      activeDrain = run;
+      return run;
+    };
+    if (demux.videoStream && !options.dropVideo) {
+      try {
+        const bitDepth = ctx.videoTracks[0]?.bitDepth ?? 8;
+        if (bitDepth > 8) {
+          throw new chunk2IJ66NTD_cjs.AvbridgeError(
+            chunk2IJ66NTD_cjs.ERR_TRANSCODE_UNSUPPORTED_COMBO,
+            `transcode: 10-bit video is not supported in this release (source bit depth: ${bitDepth}).`,
+            `Phase 1 transcode handles 8-bit video only. 10-bit support is on the roadmap.`
+          );
+        }
+        if (demux.videoStream.time_base_num && demux.videoStream.time_base_den) {
+          videoTimeBase = [demux.videoStream.time_base_num, demux.videoStream.time_base_den];
+        }
+        let config = null;
+        try {
+          config = await bridge.videoStreamToConfig(demux.libav, demux.videoStream);
+        } catch {
+          config = null;
+        }
+        const supported = config ? await VideoDecoder.isConfigSupported(config).catch(() => ({ supported: false })) : { supported: false };
+        videoWidth = config?.codedWidth ?? ctx.videoTracks[0]?.width ?? 0;
+        videoHeight = config?.codedHeight ?? ctx.videoTracks[0]?.height ?? 0;
+        if (config && supported.supported) {
+          videoDecoder = new VideoDecoder({
+            output: (frame) => {
+              if (frameQueue.length >= MAX_QUEUE) {
+                frame.close();
+                return;
+              }
+              frameQueue.push(frame);
+              void drain();
+            },
+            error: (err) => {
+              drainError = err;
+            }
+          });
+          videoDecoder.configure(config);
+        } else {
+          const libavSoft = demux.libav;
+          const [, c, pkt, frame] = await libavSoft.ff_init_decoder(
+            demux.videoStream.codec_id,
+            { codecpar: demux.videoStream.codecpar }
+          );
+          videoSoftDec = { c, pkt, frame };
+        }
+        videoSource = new mb.VideoSampleSource({
+          codec: avbridgeVideoToMediabunny(videoCodec),
+          bitrate: qualityToMediabunny(mb, quality, options.videoBitrate),
+          ...options.frameRate !== void 0 ? { frameRate: options.frameRate } : {},
+          ...options.hardwareAcceleration !== void 0 ? { hardwareAcceleration: options.hardwareAcceleration } : {},
+          // Progress reporting: media-time-based via each encoded packet.
+          onEncodedPacket: options.onProgress ? (packet) => {
+            const t = packet.timestamp;
+            if (Number.isFinite(t) && ctx.duration && ctx.duration > 0) {
+              const pct = Math.min(100, t / ctx.duration * 100);
+              options.onProgress({ percent: pct, bytesWritten: 0 });
+            }
+          } : void 0
+        });
+        const videoMeta = {};
+        if (options.width !== void 0) videoMeta.width = options.width;
+        else if (videoWidth > 0) videoMeta.width = videoWidth;
+        if (options.height !== void 0) videoMeta.height = options.height;
+        else if (videoHeight > 0) videoMeta.height = videoHeight;
+        if (options.frameRate !== void 0) videoMeta.frameRate = options.frameRate;
+        output.addVideoTrack(videoSource, videoMeta);
+        if (ctx.videoTracks[0]?.codec === "mpeg4") {
+          const runtime = demux.libav;
+          try {
+            videoBsfCtx = await runtime.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
+            if (videoBsfCtx != null && videoBsfCtx >= 0) {
+              const parIn = await runtime.AVBSFContext_par_in(videoBsfCtx);
+              await runtime.avcodec_parameters_copy(parIn, demux.videoStream.codecpar);
+              await runtime.av_bsf_init(videoBsfCtx);
+              videoBsfPkt = await demux.libav.av_packet_alloc();
+            } else {
+              videoBsfCtx = null;
+            }
+          } catch {
+            videoBsfCtx = null;
+          }
+        }
+      } catch (err) {
+        if (err instanceof chunk2IJ66NTD_cjs.AvbridgeError) throw err;
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_CODEC_NOT_SUPPORTED,
+          `transcode: video decoder init failed: ${err.message}`,
+          `The source's video codec may not be supported by this browser's WebCodecs implementation.`
+        );
+      }
+    }
+    let audioDec = null;
+    let audioSource = null;
+    let audioTimeBase;
+    const includeAudio = demux.audioStream && !options.dropAudio;
+    if (includeAudio) {
+      try {
+        const libav = demux.libav;
+        const [, c, pkt, frame] = await libav.ff_init_decoder(
+          demux.audioStream.codec_id,
+          { codecpar: demux.audioStream.codecpar }
+        );
+        audioDec = { c, pkt, frame };
+        if (demux.audioStream.time_base_num && demux.audioStream.time_base_den) {
+          audioTimeBase = [
+            demux.audioStream.time_base_num,
+            demux.audioStream.time_base_den
+          ];
+        }
+        audioSource = new mb.AudioSampleSource({
+          codec: avbridgeAudioToMediabunny(audioCodec),
+          bitrate: qualityToMediabunny(mb, quality, options.audioBitrate)
+        });
+        output.addAudioTrack(audioSource);
+      } catch (err) {
+        const codecName = ctx.audioTracks[0]?.codec ?? "unknown";
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_CODEC_NOT_SUPPORTED,
+          `transcode: no decoder available for audio codec "${codecName}" in this libav variant (${err.message}).`,
+          `The file may still play via createPlayer() (fallback strategy). Pass { dropAudio: true } to transcode video-only.`
+        );
+      }
+    } else if (options.dropAudio) {
+    }
+    if (!videoSource && !audioSource) {
+      throw new chunk2IJ66NTD_cjs.AvbridgeError(
+        chunk2IJ66NTD_cjs.ERR_TRANSCODE_UNSUPPORTED_COMBO,
+        "transcode: no video or audio track to encode (did you set both dropVideo and dropAudio?).",
+        "Remove dropVideo or dropAudio to include at least one track."
+      );
     }
-    const videoPackets = videoStream ? packets[videoStream.index] ?? [] : [];
-    const audioPackets = audioStream ? packets[audioStream.index] ?? [] : [];
-    if (videoSource) {
-      for (const pkt of videoPackets) {
+    await output.start();
+    const videoFps = ctx.videoTracks[0]?.fps && ctx.videoTracks[0].fps > 0 ? ctx.videoTracks[0].fps : 30;
+    const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
+    let syntheticVideoUs = 0;
+    let syntheticAudioUs = 0;
+    const libavFull = demux.libav;
+    async function applyBSF(packets) {
+      if (!videoBsfCtx || !videoBsfPkt) return packets;
+      const out = [];
+      for (const pkt of packets) {
+        await libavFull.ff_copyin_packet(videoBsfPkt, pkt);
+        const sendErr = await libavFull.av_bsf_send_packet(videoBsfCtx, videoBsfPkt);
+        if (sendErr < 0) {
+          out.push(pkt);
+          continue;
+        }
+        while (true) {
+          const recvErr = await libavFull.av_bsf_receive_packet(videoBsfCtx, videoBsfPkt);
+          if (recvErr < 0) break;
+          out.push(await libavFull.ff_copyout_packet(videoBsfPkt));
+        }
+      }
+      return out;
+    }
+    const ac = options.signal;
+    const onVideoPacketsWebCodecs = videoDecoder ? async (pkts) => {
+      throwIfAborted2();
+      throwIfDrainError2();
+      while (!ac?.aborted && (videoDecoder.decodeQueueSize > 16 || frameQueue.length >= MAX_QUEUE - 2)) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+      throwIfAborted2();
+      const processed = await applyBSF(pkts);
+      const bridgeAny = bridge;
+      for (const pkt of processed) {
         sanitizePacketTimestamp(pkt, () => {
           const ts = syntheticVideoUs;
           syntheticVideoUs += videoFrameStepUs;
           return ts;
         }, videoTimeBase);
-        const mbPacket = libavPacketToMediAbunny(mb, pkt);
-        await videoSource.add(
-          mbPacket,
-          firstVideoMeta ? { decoderConfig: buildVideoDecoderConfig(videoTrackInfo) } : void 0
+        try {
+          const chunk = bridgeAny.packetToEncodedVideoChunk(pkt, demux.videoStream);
+          videoDecoder.decode(chunk);
+        } catch (err) {
+          throw new chunk2IJ66NTD_cjs.AvbridgeError(
+            chunk2IJ66NTD_cjs.ERR_TRANSCODE_DECODE,
+            `transcode: packet \u2192 EncodedVideoChunk failed: ${err.message}`,
+            void 0
+          );
+        }
+      }
+    } : void 0;
+    const onVideoPacketsSoftware = videoSoftDec ? async (pkts) => {
+      throwIfAborted2();
+      throwIfDrainError2();
+      while (!ac?.aborted && frameQueue.length >= MAX_QUEUE - 2) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+      throwIfAborted2();
+      const libavSoft = demux.libav;
+      let frames;
+      try {
+        frames = await libavSoft.ff_decode_multi(
+          videoSoftDec.c,
+          videoSoftDec.pkt,
+          videoSoftDec.frame,
+          pkts,
+          { ignoreErrors: true }
+        );
+      } catch (err) {
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_TRANSCODE_DECODE,
+          `transcode: software video decode failed: ${err.message}`,
+          void 0
         );
-        firstVideoMeta = false;
       }
+      for (const f of frames) {
+        sanitizeFrameTimestamp(f, () => {
+          const ts = syntheticVideoUs;
+          syntheticVideoUs += videoFrameStepUs;
+          return ts;
+        }, videoTimeBase);
+        try {
+          const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
+          if (frameQueue.length >= MAX_QUEUE) {
+            vf.close();
+          } else {
+            frameQueue.push(vf);
+            void drain();
+          }
+        } catch (err) {
+          throw new chunk2IJ66NTD_cjs.AvbridgeError(
+            chunk2IJ66NTD_cjs.ERR_TRANSCODE_DECODE,
+            `transcode: laFrameToVideoFrame failed: ${err.message}`,
+            void 0
+          );
+        }
+      }
+    } : void 0;
+    await demux.pump({
+      signal: ac,
+      onVideoPackets: onVideoPacketsWebCodecs ?? onVideoPacketsSoftware,
+      onAudioPackets: audioDec ? async (pkts) => {
+        throwIfAborted2();
+        await decodeAudioBatch(pkts, false);
+      } : void 0,
+      onEof: async () => {
+        if (videoDecoder && videoDecoder.state === "configured") {
+          try {
+            await videoDecoder.flush();
+          } catch {
+          }
+        }
+        if (videoSoftDec) {
+          const libavSoft = demux.libav;
+          try {
+            const tail = await libavSoft.ff_decode_multi(
+              videoSoftDec.c,
+              videoSoftDec.pkt,
+              videoSoftDec.frame,
+              [],
+              { fin: true, ignoreErrors: true }
+            );
+            for (const f of tail) {
+              sanitizeFrameTimestamp(f, () => {
+                const ts = syntheticVideoUs;
+                syntheticVideoUs += videoFrameStepUs;
+                return ts;
+              }, videoTimeBase);
+              try {
+                const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
+                frameQueue.push(vf);
+                void drain();
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        await drain();
+        if (audioDec) {
+          await decodeAudioBatch([], true);
+        }
+      }
+    });
+    throwIfAborted2();
+    throwIfDrainError2();
+    videoSource?.close();
+    audioSource?.close();
+    await output.finalize();
+    if (!bufferTarget.buffer) {
+      throw new Error("transcode: mediabunny produced no output buffer");
     }
-    if (audioSource) {
-      for (const pkt of audioPackets) {
-        sanitizePacketTimestamp(pkt, () => {
+    const mimeType = mimeForFormat2(outputFormat);
+    const blob = new Blob([bufferTarget.buffer], { type: mimeType });
+    options.onProgress?.({ percent: 100, bytesWritten: blob.size });
+    return {
+      blob,
+      mimeType,
+      container: outputFormat,
+      videoCodec: videoSource ? videoCodec : void 0,
+      audioCodec: audioSource ? audioCodec : void 0,
+      duration: ctx.duration,
+      filename: generateFilename2(ctx.name, outputFormat)
+    };
+    async function decodeAudioBatch(pkts, flush) {
+      if (!audioDec || !audioSource) return;
+      const libav = demux.libav;
+      let frames;
+      try {
+        frames = await libav.ff_decode_multi(
+          audioDec.c,
+          audioDec.pkt,
+          audioDec.frame,
+          pkts,
+          flush ? { fin: true, ignoreErrors: true } : { ignoreErrors: true }
+        );
+      } catch (err) {
+        throw new chunk2IJ66NTD_cjs.AvbridgeError(
+          chunk2IJ66NTD_cjs.ERR_TRANSCODE_DECODE,
+          `transcode: audio decode failed: ${err.message}`,
+          void 0
+        );
+      }
+      for (const f of frames) {
+        sanitizeFrameTimestamp(f, () => {
           const ts = syntheticAudioUs;
-          const sampleRate = audioTrackInfo?.sampleRate ?? 44100;
-          syntheticAudioUs += Math.round(1024 * 1e6 / sampleRate);
+          const samples = f.nb_samples ?? 1024;
+          const sampleRate = f.sample_rate ?? 44100;
+          syntheticAudioUs += Math.round(samples * 1e6 / sampleRate);
           return ts;
         }, audioTimeBase);
-        const mbPacket = libavPacketToMediAbunny(mb, pkt);
-        await audioSource.add(
-          mbPacket,
-          firstAudioMeta ? { decoderConfig: buildAudioDecoderConfig(audioTrackInfo) } : void 0
-        );
-        firstAudioMeta = false;
+        const pcm = libavFrameToInterleavedFloat32(f);
+        if (!pcm) continue;
+        const sample = new mb.AudioSample({
+          data: pcm.data,
+          format: "f32",
+          numberOfChannels: pcm.channels,
+          sampleRate: pcm.sampleRate,
+          timestamp: (f.pts ?? 0) / 1e6
+        });
+        await audioSource.add(sample);
       }
     }
-    totalPackets += videoPackets.length + audioPackets.length;
-    if (options.onProgress && durationUs > 0) {
-      const lastVideoTs = videoPackets.length > 0 ? videoPackets[videoPackets.length - 1].pts ?? 0 : 0;
-      const lastAudioTs = audioPackets.length > 0 ? audioPackets[audioPackets.length - 1].pts ?? 0 : 0;
-      const currentUs = Math.max(lastVideoTs, lastAudioTs);
-      const percent = Math.min(99, currentUs / durationUs * 100);
-      options.onProgress({ percent, bytesWritten: 0 });
-    }
-    if (readErr === libav.AVERROR_EOF) break;
-    if (readErr && readErr !== 0 && readErr !== -libav.EAGAIN) {
-      console.warn("[avbridge] remux: ff_read_frame_multi returned", readErr);
-      break;
+  } finally {
+    try {
+      await demux.destroy();
+    } catch {
     }
   }
-  await output.finalize();
-  try {
-    await libav.av_packet_free?.(readPkt);
-  } catch {
-  }
+}
+async function loadBridge() {
   try {
-    await libav.avformat_close_input_js(fmt_ctx);
-  } catch {
-  }
-  if (!target.buffer) {
-    throw new Error("Remux failed: mediabunny produced no output buffer.");
+    const wrapper = await import('./libav-import-2ZVKV2E7.cjs');
+    return wrapper.libavBridge;
+  } catch (err) {
+    throw new Error(`failed to load libavjs-webcodecs-bridge: ${err.message}`);
   }
-  const mimeType = mimeForFormat(outputFormat);
-  const blob = new Blob([target.buffer], { type: mimeType });
-  const outputFilename = generateFilename(ctx.name, outputFormat);
-  options.onProgress?.({ percent: 100, bytesWritten: blob.size });
-  return {
-    blob,
-    mimeType,
-    container: outputFormat,
-    videoCodec: videoTrackInfo?.codec,
-    audioCodec: audioTrackInfo?.codec,
-    duration: ctx.duration,
-    filename: outputFilename
-  };
 }
-function sanitizePacketTimestamp(pkt, nextUs, fallbackTimeBase) {
-  const lo = pkt.pts ?? 0;
-  const hi = pkt.ptshi ?? 0;
-  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
-  if (isInvalid) {
-    const us2 = nextUs();
-    pkt.pts = us2;
-    pkt.ptshi = 0;
-    pkt.time_base_num = 1;
-    pkt.time_base_den = 1e6;
-    return;
-  }
-  const tb = fallbackTimeBase ?? [1, 1e6];
-  const pts64 = hi * 4294967296 + lo;
-  const us = Math.round(pts64 * 1e6 * tb[0] / tb[1]);
-  if (Number.isFinite(us) && Math.abs(us) <= Number.MAX_SAFE_INTEGER) {
-    pkt.pts = us;
-    pkt.ptshi = us < 0 ? -1 : 0;
-    pkt.time_base_num = 1;
-    pkt.time_base_den = 1e6;
-    return;
+function avbridgeVideoToMediabunny(c) {
+  switch (c) {
+    case "h264":
+      return "avc";
+    case "h265":
+      return "hevc";
+    case "vp9":
+      return "vp9";
+    case "av1":
+      return "av1";
   }
-  const fallback = nextUs();
-  pkt.pts = fallback;
-  pkt.ptshi = 0;
-  pkt.time_base_num = 1;
-  pkt.time_base_den = 1e6;
 }
-function createOutputFormat(mb, format) {
-  switch (format) {
-    case "mp4":
-      return new mb.Mp4OutputFormat({ fastStart: "in-memory" });
-    case "webm":
-      return new mb.WebMOutputFormat();
-    case "mkv":
-      return new mb.MkvOutputFormat();
-    default:
-      return new mb.Mp4OutputFormat({ fastStart: "in-memory" });
+function avbridgeAudioToMediabunny(c) {
+  switch (c) {
+    case "aac":
+      return "aac";
+    case "opus":
+      return "opus";
+    case "flac":
+      return "flac";
   }
 }
-function mimeForFormat(format) {
-  switch (format) {
-    case "mp4":
-      return "video/mp4";
-    case "webm":
-      return "video/webm";
-    case "mkv":
-      return "video/x-matroska";
-    default:
-      return "application/octet-stream";
+function qualityToMediabunny(mb, quality, override) {
+  if (override !== void 0) return override;
+  switch (quality) {
+    case "low":
+      return mb.QUALITY_LOW;
+    case "medium":
+      return mb.QUALITY_MEDIUM;
+    case "high":
+      return mb.QUALITY_HIGH;
+    case "very-high":
+      return mb.QUALITY_VERY_HIGH;
   }
 }
-function generateFilename(originalName, format) {
-  const ext = format === "mkv" ? "mkv" : format;
-  if (!originalName) return `output.${ext}`;
-  const base = originalName.replace(/\.[^.]+$/, "");
-  return `${base}.${ext}`;
-}
-var _seqCounter = 0;
-function libavPacketToMediAbunny(mb, pkt) {
-  const KEY_FRAME_FLAG = 1;
-  const timestampSec = (pkt.pts ?? 0) / 1e6;
-  const durationSec = (pkt.duration ?? 0) / 1e6;
-  const type = pkt.flags & KEY_FRAME_FLAG ? "key" : "delta";
-  return new mb.EncodedPacket(pkt.data, type, timestampSec, durationSec, _seqCounter++);
-}
-function buildVideoDecoderConfig(track) {
-  return {
-    codec: track.codecString ?? track.codec,
-    codedWidth: track.width,
-    codedHeight: track.height
-  };
-}
-function buildAudioDecoderConfig(track) {
-  return {
-    codec: track.codecString ?? track.codec,
-    numberOfChannels: track.channels,
-    sampleRate: track.sampleRate
-  };
-}
 
 // src/convert/transcode.ts
-var MEDIABUNNY_CONTAINERS2 = /* @__PURE__ */ new Set([
+var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
   "mov",
   "mkv",
@@ -358,11 +535,16 @@ async function transcode(source, options = {}) {
   const quality = options.quality ?? "medium";
   validateCodecCompatibility(outputFormat, videoCodec, audioCodec);
   options.signal?.throwIfAborted();
-  const ctx = await chunkUF2N5L63_cjs.probe(source);
+  const ctx = await chunkZCUXHW55_cjs.probe(source);
   options.signal?.throwIfAborted();
-  if (!MEDIABUNNY_CONTAINERS2.has(ctx.container)) {
-    throw new Error(
-      `Cannot transcode "${ctx.container}" sources in v1. transcode() only supports inputs that mediabunny can read (MP4, MKV, WebM, OGG, MP3, FLAC, WAV, MOV). For AVI/ASF/FLV sources, use the player's playback strategies instead.`
+  if (isLibavTranscodeContainer(ctx.container)) {
+    return transcodeViaLibav(ctx, options);
+  }
+  if (!MEDIABUNNY_CONTAINERS.has(ctx.container)) {
+    throw new chunk2IJ66NTD_cjs.AvbridgeError(
+      chunk2IJ66NTD_cjs.ERR_CONTAINER_NOT_SUPPORTED,
+      `Cannot transcode "${ctx.container}" sources. transcode() supports mediabunny-readable containers (MP4, MKV, WebM, OGG, MP3, FLAC, WAV, MOV) and legacy containers via the libav path (AVI, ASF, FLV).`,
+      `If this is a legacy container we don't yet support, use createPlayer() to play it. Transcode support for more containers is on the roadmap.`
     );
   }
   return doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options);
@@ -370,17 +552,26 @@ async function transcode(source, options = {}) {
 async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options) {
   const mb = await import('mediabunny');
   const input = new mb.Input({
-    source: await chunkUF2N5L63_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
+    source: await chunkZCUXHW55_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
     formats: mb.ALL_FORMATS
   });
-  const target = new mb.BufferTarget();
+  let bytesWritten = 0;
+  const useStream = !!options.outputStream;
+  const bufferTarget = useStream ? null : new mb.BufferTarget();
+  const streamTarget = useStream ? new mb.StreamTarget(new WritableStream({
+    write(chunk) {
+      bytesWritten += chunk.data.byteLength;
+      const writer = options.outputStream.getWriter();
+      return writer.write(chunk.data).then(() => writer.releaseLock());
+    }
+  })) : null;
   const output = new mb.Output({
-    format: createOutputFormat(mb, outputFormat),
-    target
+    format: chunkQ2VUO52Z_cjs.createOutputFormat(mb, outputFormat),
+    target: streamTarget ?? bufferTarget
   });
   const videoOptions = options.dropVideo ? { discard: true } : {
     codec: avbridgeVideoToMediabunny2(videoCodec),
-    bitrate: options.videoBitrate ?? qualityToMediabunny(mb, quality),
+    bitrate: options.videoBitrate ?? qualityToMediabunny2(mb, quality),
     forceTranscode: true,
     ...options.width !== void 0 ? { width: options.width } : {},
     ...options.height !== void 0 ? { height: options.height } : {},
@@ -390,7 +581,7 @@ async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quali
   };
   const audioOptions = options.dropAudio ? { discard: true } : {
     codec: avbridgeAudioToMediabunny2(audioCodec),
-    bitrate: options.audioBitrate ?? qualityToMediabunny(mb, quality),
+    bitrate: options.audioBitrate ?? qualityToMediabunny2(mb, quality),
     forceTranscode: true
   };
   const conversion = await mb.Conversion.init({
@@ -425,10 +616,13 @@ async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quali
       options.signal.removeEventListener("abort", abortHandler);
     }
   }
-  if (!target.buffer) {
+  if (useStream) {
+    return null;
+  }
+  if (!bufferTarget.buffer) {
     throw new Error("Transcode failed: mediabunny produced no output buffer.");
   }
-  return target.buffer;
+  return bufferTarget.buffer;
 }
 function isLikelyEncoderInitError(err) {
   if (!err) return false;
@@ -463,12 +657,25 @@ async function doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, o
       await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
     }
   }
+  const mimeType = chunkQ2VUO52Z_cjs.mimeForFormat(outputFormat);
+  const filename = chunkQ2VUO52Z_cjs.generateFilename(ctx.name, outputFormat);
+  if (options.outputStream) {
+    options.onProgress?.({ percent: 100, bytesWritten: 0 });
+    return {
+      blob: new Blob([], { type: mimeType }),
+      mimeType,
+      container: outputFormat,
+      videoCodec: options.dropVideo ? void 0 : videoCodec,
+      audioCodec: options.dropAudio ? void 0 : audioCodec,
+      duration: ctx.duration,
+      filename,
+      ...notes.length > 0 ? { notes } : {}
+    };
+  }
   if (!buffer) {
     throw new Error("Transcode failed: no buffer produced (this should be unreachable).");
   }
-  const mimeType = mimeForFormat(outputFormat);
   const blob = new Blob([buffer], { type: mimeType });
-  const filename = generateFilename(ctx.name, outputFormat);
   options.onProgress?.({ percent: 100, bytesWritten: blob.size });
   return {
     blob,
@@ -537,7 +744,7 @@ function avbridgeAudioToMediabunny2(c) {
       return "flac";
   }
 }
-function qualityToMediabunny(mb, quality) {
+function qualityToMediabunny2(mb, quality) {
   switch (quality) {
     case "low":
       return mb.QUALITY_LOW;
@@ -550,27 +757,98 @@ function qualityToMediabunny(mb, quality) {
   }
 }
 
+Object.defineProperty(exports, "remux", {
+  enumerable: true,
+  get: function () { return chunkQ2VUO52Z_cjs.remux; }
+});
+Object.defineProperty(exports, "FALLBACK_AUDIO_CODECS", {
+  enumerable: true,
+  get: function () { return chunkTBW26OPP_cjs.FALLBACK_AUDIO_CODECS; }
+});
+Object.defineProperty(exports, "FALLBACK_VIDEO_CODECS", {
+  enumerable: true,
+  get: function () { return chunkTBW26OPP_cjs.FALLBACK_VIDEO_CODECS; }
+});
+Object.defineProperty(exports, "NATIVE_AUDIO_CODECS", {
+  enumerable: true,
+  get: function () { return chunkTBW26OPP_cjs.NATIVE_AUDIO_CODECS; }
+});
+Object.defineProperty(exports, "NATIVE_VIDEO_CODECS", {
+  enumerable: true,
+  get: function () { return chunkTBW26OPP_cjs.NATIVE_VIDEO_CODECS; }
+});
 Object.defineProperty(exports, "UnifiedPlayer", {
   enumerable: true,
-  get: function () { return chunkUF2N5L63_cjs.UnifiedPlayer; }
+  get: function () { return chunkTBW26OPP_cjs.UnifiedPlayer; }
 });
 Object.defineProperty(exports, "classify", {
   enumerable: true,
-  get: function () { return chunkUF2N5L63_cjs.classifyContext; }
+  get: function () { return chunkTBW26OPP_cjs.classifyContext; }
 });
 Object.defineProperty(exports, "createPlayer", {
   enumerable: true,
-  get: function () { return chunkUF2N5L63_cjs.createPlayer; }
+  get: function () { return chunkTBW26OPP_cjs.createPlayer; }
+});
+Object.defineProperty(exports, "srtToVtt", {
+  enumerable: true,
+  get: function () { return chunkS4WAZC2T_cjs.srtToVtt; }
 });
 Object.defineProperty(exports, "probe", {
   enumerable: true,
-  get: function () { return chunkUF2N5L63_cjs.probe; }
+  get: function () { return chunkZCUXHW55_cjs.probe; }
 });
-Object.defineProperty(exports, "srtToVtt", {
+Object.defineProperty(exports, "AvbridgeError", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.AvbridgeError; }
+});
+Object.defineProperty(exports, "ERR_ALL_STRATEGIES_EXHAUSTED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_ALL_STRATEGIES_EXHAUSTED; }
+});
+Object.defineProperty(exports, "ERR_CODEC_NOT_SUPPORTED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_CODEC_NOT_SUPPORTED; }
+});
+Object.defineProperty(exports, "ERR_FETCH_FAILED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_FETCH_FAILED; }
+});
+Object.defineProperty(exports, "ERR_LIBAV_NOT_REACHABLE", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_LIBAV_NOT_REACHABLE; }
+});
+Object.defineProperty(exports, "ERR_MSE_CODEC_NOT_SUPPORTED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_MSE_CODEC_NOT_SUPPORTED; }
+});
+Object.defineProperty(exports, "ERR_MSE_NOT_SUPPORTED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_MSE_NOT_SUPPORTED; }
+});
+Object.defineProperty(exports, "ERR_PLAYER_NOT_READY", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_PLAYER_NOT_READY; }
+});
+Object.defineProperty(exports, "ERR_PROBE_FAILED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_PROBE_FAILED; }
+});
+Object.defineProperty(exports, "ERR_PROBE_FETCH_FAILED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_PROBE_FETCH_FAILED; }
+});
+Object.defineProperty(exports, "ERR_PROBE_UNKNOWN_CONTAINER", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_PROBE_UNKNOWN_CONTAINER; }
+});
+Object.defineProperty(exports, "ERR_RANGE_NOT_SUPPORTED", {
+  enumerable: true,
+  get: function () { return chunk2IJ66NTD_cjs.ERR_RANGE_NOT_SUPPORTED; }
+});
+Object.defineProperty(exports, "ERR_STRATEGY_FAILED", {
   enumerable: true,
-  get: function () { return chunkUF2N5L63_cjs.srtToVtt; }
+  get: function () { return chunk2IJ66NTD_cjs.ERR_STRATEGY_FAILED; }
 });
-exports.remux = remux;
 exports.transcode = transcode;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map