avbridge 2.2.0 → 2.3.0

package/dist/{chunk-OE66B34H.cjs → chunk-7RGG6ME7.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkHZLQNKFN_cjs = require('./chunk-HZLQNKFN.cjs');
+var chunk6UUT4BEA_cjs = require('./chunk-6UUT4BEA.cjs');
 var chunkG4APZMCP_cjs = require('./chunk-G4APZMCP.cjs');
-var chunkNZU7W256_cjs = require('./chunk-NZU7W256.cjs');
+var chunkF3LQJKXK_cjs = require('./chunk-F3LQJKXK.cjs');
 
 // src/probe/mediabunny.ts
 async function probeWithMediabunny(source, sniffedContainer) {
@@ -180,37 +180,58 @@ var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
   "adts",
   "mpegts"
 ]);
-async function probe(source) {
-  const normalized = await chunkHZLQNKFN_cjs.normalizeSource(source);
-  const sniffed = await chunkHZLQNKFN_cjs.sniffNormalizedSource(normalized);
+async function probe(source, transport) {
+  const normalized = await chunk6UUT4BEA_cjs.normalizeSource(source, transport);
+  const sniffed = await chunk6UUT4BEA_cjs.sniffNormalizedSource(normalized);
   if (MEDIABUNNY_CONTAINERS.has(sniffed)) {
     try {
-      return await probeWithMediabunny(normalized, sniffed);
+      const result = await probeWithMediabunny(normalized, sniffed);
+      const hasUnknownCodec = result.videoTracks.some((t) => t.codec === "unknown") || result.audioTracks.some((t) => t.codec === "unknown");
+      if (hasUnknownCodec) {
+        try {
+          const { probeWithLibav } = await import('./avi-W6L3BTWU.cjs');
+          return await probeWithLibav(normalized, sniffed);
+        } catch {
+          return result;
+        }
+      }
+      return result;
     } catch (mediabunnyErr) {
       console.warn(
         `[avbridge] mediabunny rejected ${sniffed} file, falling back to libav:`,
         mediabunnyErr.message
       );
       try {
-        const { probeWithLibav } = await import('./avi-6SJLWIWW.cjs');
+        const { probeWithLibav } = await import('./avi-W6L3BTWU.cjs');
         return await probeWithLibav(normalized, sniffed);
       } catch (libavErr) {
         const mbMsg = mediabunnyErr.message || String(mediabunnyErr);
         const lvMsg = libavErr instanceof Error ? libavErr.message : String(libavErr);
-        throw new Error(
-          `failed to probe ${sniffed} file. mediabunny: ${mbMsg}. libav fallback: ${lvMsg}.`
+        throw new chunk6UUT4BEA_cjs.AvbridgeError(
+          chunk6UUT4BEA_cjs.ERR_PROBE_FAILED,
+          `Failed to probe ${sniffed.toUpperCase()} file. mediabunny: ${mbMsg}. libav: ${lvMsg}.`,
+          "The file may be corrupt, truncated, or in an unsupported format. Enable AVBRIDGE_DEBUG for detailed logs."
         );
       }
     }
   }
   try {
-    const { probeWithLibav } = await import('./avi-6SJLWIWW.cjs');
+    const { probeWithLibav } = await import('./avi-W6L3BTWU.cjs');
     return await probeWithLibav(normalized, sniffed);
   } catch (err) {
     const inner = err instanceof Error ? err.message : String(err);
     console.error("[avbridge] libav probe failed for", sniffed, "file:", err);
-    throw new Error(
-      sniffed === "unknown" ? `unable to probe source: container could not be identified, and the libav.js fallback also failed: ${inner || "(no message \u2014 see browser console for the original error)"}` : `${sniffed.toUpperCase()} files require libav.js, which failed to load: ${inner || "(no message \u2014 see browser console for the original error)"}`
+    if (sniffed === "unknown") {
+      throw new chunk6UUT4BEA_cjs.AvbridgeError(
+        chunk6UUT4BEA_cjs.ERR_PROBE_UNKNOWN_CONTAINER,
+        `Unable to probe source: container format could not be identified. libav fallback: ${inner || "(no details)"}`,
+        "The file may be corrupt or in a format avbridge doesn't recognize. Check the file plays in VLC or ffprobe."
+      );
+    }
+    throw new chunk6UUT4BEA_cjs.AvbridgeError(
+      chunk6UUT4BEA_cjs.ERR_LIBAV_NOT_REACHABLE,
+      `${sniffed.toUpperCase()} files require libav.js, which failed to load: ${inner || "(no details)"}`,
+      "Install @libav.js/variant-webcodecs, or check that AVBRIDGE_LIBAV_BASE points to the correct path."
     );
   }
 }
@@ -311,7 +332,9 @@ var FALLBACK_AUDIO_CODECS = /* @__PURE__ */ new Set([
   "ra_144",
   "ra_288",
   "sipr",
-  "atrac3"
+  "atrac3",
+  "dts",
+  "truehd"
 ]);
 var NATIVE_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
@@ -373,7 +396,16 @@ function classifyContext(ctx) {
       reason: `video codec "${video.codec}" has no browser decoder; WASM fallback required`
     };
   }
-  if (audio && FALLBACK_AUDIO_CODECS.has(audio.codec)) {
+  const audioNeedsFallback = audio && (FALLBACK_AUDIO_CODECS.has(audio.codec) || !NATIVE_AUDIO_CODECS.has(audio.codec));
+  if (audioNeedsFallback) {
+    if (NATIVE_VIDEO_CODECS.has(video.codec) && webCodecsAvailable()) {
+      return {
+        class: "HYBRID_CANDIDATE",
+        strategy: "hybrid",
+        reason: `video "${video.codec}" is hardware-decodable via WebCodecs; audio "${audio.codec}" decoded in software by libav`,
+        fallbackChain: ["fallback"]
+      };
+    }
     return {
       class: "FALLBACK_REQUIRED",
       strategy: "fallback",
@@ -740,10 +772,18 @@ var MseSink = class {
   constructor(options) {
     this.options = options;
     if (typeof MediaSource === "undefined") {
-      throw new Error("MSE not supported in this environment");
+      throw new chunk6UUT4BEA_cjs.AvbridgeError(
+        chunk6UUT4BEA_cjs.ERR_MSE_NOT_SUPPORTED,
+        "MediaSource Extensions (MSE) are not supported in this environment.",
+        "MSE is required for the remux strategy. Use a browser that supports MSE, or try the fallback strategy."
+      );
     }
     if (!MediaSource.isTypeSupported(options.mime)) {
-      throw new Error(`MSE does not support MIME "${options.mime}" \u2014 cannot remux`);
+      throw new chunk6UUT4BEA_cjs.AvbridgeError(
+        chunk6UUT4BEA_cjs.ERR_MSE_CODEC_NOT_SUPPORTED,
+        `This browser's MSE does not support "${options.mime}".`,
+        "The codec combination can't be played via remux in this browser. The player will try the next strategy automatically."
+      );
     }
     this.mediaSource = new MediaSource();
     this.objectUrl = URL.createObjectURL(this.mediaSource);
@@ -1072,6 +1112,10 @@ async function createRemuxPipeline(ctx, video) {
         console.error("[avbridge] remux pipeline reseek failed:", err);
       });
     },
+    setAutoPlay(autoPlay) {
+      pendingAutoPlay = autoPlay;
+      if (sink) sink.setPlayOnSeek(autoPlay);
+    },
     async destroy() {
       destroyed = true;
       pumpToken++;
@@ -1112,7 +1156,11 @@ async function createRemuxSession(context, video) {
         await pipeline.start(video.currentTime || 0, true);
         return;
       }
-      await video.play();
+      pipeline.setAutoPlay(true);
+      try {
+        await video.play();
+      } catch {
+      }
     },
     pause() {
       wantPlay = false;
@@ -1151,6 +1199,10 @@ async function createRemuxSession(context, video) {
 }
 
 // src/strategies/fallback/video-renderer.ts
+function isDebug() {
+  return typeof globalThis !== "undefined" && !!globalThis.AVBRIDGE_DEBUG;
+}
+var lastDebugLog = 0;
 var VideoRenderer = class {
   constructor(target, clock, fps = 30) {
     this.target = target;
@@ -1160,7 +1212,7 @@ var VideoRenderer = class {
       this.resolveFirstFrame = resolve;
     });
     this.canvas = document.createElement("canvas");
-    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;";
+    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;object-fit:contain;";
     const parent = target.parentElement ?? target.parentNode;
     if (parent && parent instanceof HTMLElement) {
       if (getComputedStyle(parent).position === "static") {
@@ -1197,6 +1249,20 @@ var VideoRenderer = class {
   lastPaintWall = 0;
   /** Minimum ms between paints — paces video at roughly source fps. */
   paintIntervalMs;
+  /** Cumulative count of frames skipped because all PTS are in the future. */
+  ticksWaiting = 0;
+  /** Cumulative count of ticks where PTS mode painted a frame. */
+  ticksPainted = 0;
+  /**
+   * Calibration offset (microseconds) between video PTS and audio clock.
+   * Video PTS and AudioContext.currentTime can drift ~0.1% relative to
+   * each other (different clock domains). Over 45 minutes that's 2.6s.
+   * We measure the offset on the first painted frame and update it
+   * periodically so the PTS comparison stays calibrated.
+   */
+  ptsCalibrationUs = 0;
+  ptsCalibrated = false;
+  lastCalibrationWall = 0;
   /** Resolves once the first decoded frame has been enqueued. */
   firstFrameReady;
   resolveFirstFrame;
@@ -1245,21 +1311,81 @@ var VideoRenderer = class {
       }
       return;
     }
-    const wallNow = performance.now();
-    if (wallNow - this.lastPaintWall < this.paintIntervalMs - 2) return;
-    if (this.queue.length === 0) return;
-    if (this.framesPainted > 0 && this.framesPainted % 30 === 0) {
-      const audioNowUs = this.clock.now() * 1e6;
-      const headTs = this.queue[0].timestamp ?? 0;
-      const driftUs = headTs - audioNowUs;
-      if (driftUs < -15e4) {
-        this.queue.shift()?.close();
-        this.framesDroppedLate++;
-        if (this.queue.length === 0) return;
-      } else if (driftUs > 15e4) {
+    const rawAudioNowUs = this.clock.now() * 1e6;
+    const headTs = this.queue[0].timestamp ?? 0;
+    const hasPts = headTs > 0 || this.queue.length > 1;
+    if (hasPts) {
+      const wallNow2 = performance.now();
+      if (!this.ptsCalibrated || wallNow2 - this.lastCalibrationWall > 1e4) {
+        this.ptsCalibrationUs = headTs - rawAudioNowUs;
+        this.ptsCalibrated = true;
+        this.lastCalibrationWall = wallNow2;
+      }
+      const audioNowUs = rawAudioNowUs + this.ptsCalibrationUs;
+      const frameDurationUs = this.paintIntervalMs * 1e3;
+      const deadlineUs = audioNowUs + frameDurationUs;
+      let bestIdx = -1;
+      for (let i = 0; i < this.queue.length; i++) {
+        const ts = this.queue[i].timestamp ?? 0;
+        if (ts <= deadlineUs) {
+          bestIdx = i;
+        } else {
+          break;
+        }
+      }
+      if (bestIdx < 0) {
+        this.ticksWaiting++;
+        if (isDebug()) {
+          const now = performance.now();
+          if (now - lastDebugLog > 1e3) {
+            const headPtsMs = (headTs / 1e3).toFixed(1);
+            const audioMs = (audioNowUs / 1e3).toFixed(1);
+            const rawDriftMs = ((headTs - rawAudioNowUs) / 1e3).toFixed(1);
+            const calibMs = (this.ptsCalibrationUs / 1e3).toFixed(1);
+            console.log(
+              `[avbridge:renderer] WAIT q=${this.queue.length} headPTS=${headPtsMs}ms calibAudio=${audioMs}ms rawDrift=${rawDriftMs}ms calib=${calibMs}ms painted=${this.framesPainted} dropped=${this.framesDroppedLate}`
+            );
+            lastDebugLog = now;
+          }
+        }
         return;
       }
+      const dropThresholdUs = audioNowUs - frameDurationUs * 2;
+      let dropped = 0;
+      while (bestIdx > 0) {
+        const ts = this.queue[0].timestamp ?? 0;
+        if (ts < dropThresholdUs) {
+          this.queue.shift()?.close();
+          this.framesDroppedLate++;
+          bestIdx--;
+          dropped++;
+        } else {
+          break;
+        }
+      }
+      this.ticksPainted++;
+      if (isDebug()) {
+        const now = performance.now();
+        if (now - lastDebugLog > 1e3) {
+          const paintedTs = this.queue[0]?.timestamp ?? 0;
+          const audioMs = (audioNowUs / 1e3).toFixed(1);
+          const ptsMs = (paintedTs / 1e3).toFixed(1);
+          const rawDriftMs = ((paintedTs - rawAudioNowUs) / 1e3).toFixed(1);
+          const calibMs = (this.ptsCalibrationUs / 1e3).toFixed(1);
+          console.log(
+            `[avbridge:renderer] PAINT q=${this.queue.length} calibAudio=${audioMs}ms nextPTS=${ptsMs}ms rawDrift=${rawDriftMs}ms calib=${calibMs}ms dropped=${dropped} total_drops=${this.framesDroppedLate} painted=${this.framesPainted}`
+          );
+          lastDebugLog = now;
+        }
+      }
+      const frame2 = this.queue.shift();
+      this.paint(frame2);
+      frame2.close();
+      this.lastPaintWall = performance.now();
+      return;
     }
+    const wallNow = performance.now();
+    if (wallNow - this.lastPaintWall < this.paintIntervalMs - 2) return;
     const frame = this.queue.shift();
     this.paint(frame);
     frame.close();
@@ -1281,8 +1407,13 @@ var VideoRenderer = class {
   }
   /** Discard all queued frames. Used by seek to drop stale buffers. */
   flush() {
+    const count = this.queue.length;
     while (this.queue.length > 0) this.queue.shift()?.close();
     this.prerolled = false;
+    this.ptsCalibrated = false;
+    if (isDebug() && count > 0) {
+      console.log(`[avbridge:renderer] FLUSH discarded=${count} painted=${this.framesPainted} drops=${this.framesDroppedLate}`);
+    }
   }
   stats() {
     return {
@@ -1327,11 +1458,38 @@ var AudioOutput = class {
   pendingQueue = [];
   framesScheduled = 0;
   destroyed = false;
+  /** User-set volume (0..1). Applied to the gain node. */
+  _volume = 1;
+  /** User-set muted flag. When true, gain is forced to 0. */
+  _muted = false;
   constructor() {
     this.ctx = new AudioContext();
     this.gain = this.ctx.createGain();
     this.gain.connect(this.ctx.destination);
   }
+  /** Set volume (0..1). Applied immediately to the gain node. */
+  setVolume(v) {
+    this._volume = Math.max(0, Math.min(1, v));
+    this.applyGain();
+  }
+  getVolume() {
+    return this._volume;
+  }
+  /** Set muted. When true, output is silenced regardless of volume. */
+  setMuted(m) {
+    this._muted = m;
+    this.applyGain();
+  }
+  getMuted() {
+    return this._muted;
+  }
+  applyGain() {
+    const target = this._muted ? 0 : this._volume;
+    try {
+      this.gain.gain.value = target;
+    } catch {
+    }
+  }
   /**
    * Switch into wall-clock fallback mode. Called by the decoder when no
    * audio decoder could be initialized for the source. Once set, this
@@ -1402,9 +1560,13 @@ var AudioOutput = class {
     const node = this.ctx.createBufferSource();
     node.buffer = buffer;
     node.connect(this.gain);
-    const ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
-    const safeStart = Math.max(ctxStart, this.ctx.currentTime);
-    node.start(safeStart);
+    let ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
+    if (ctxStart < this.ctx.currentTime) {
+      this.ctxTimeAtAnchor = this.ctx.currentTime;
+      this.mediaTimeOfAnchor = this.mediaTimeOfNext;
+      ctxStart = this.ctx.currentTime;
+    }
+    node.start(ctxStart);
     this.mediaTimeOfNext += frameCount / sampleRate;
     this.framesScheduled++;
   }
@@ -1477,6 +1639,7 @@ var AudioOutput = class {
     }
     this.gain = this.ctx.createGain();
     this.gain.connect(this.ctx.destination);
+    this.applyGain();
     this.pendingQueue = [];
     this.mediaTimeOfAnchor = newMediaTime;
     this.mediaTimeOfNext = newMediaTime;
@@ -1505,11 +1668,11 @@ var AudioOutput = class {
 
 // src/strategies/hybrid/decoder.ts
 async function startHybridDecoder(opts) {
-  const variant = chunkNZU7W256_cjs.pickLibavVariant(opts.context);
+  const variant = chunkF3LQJKXK_cjs.pickLibavVariant(opts.context);
   const libav = await chunkG4APZMCP_cjs.loadLibav(variant);
   const bridge = await loadBridge();
-  const { prepareLibavInput } = await import('./libav-http-reader-FPYDBMYK.cjs');
-  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source);
+  const { prepareLibavInput } = await import('./libav-http-reader-AZLE7YFS.cjs');
+  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source, opts.transport);
   const readPkt = await libav.av_packet_alloc();
   const [fmt_ctx, streams] = await libav.ff_init_demuxer_file(opts.filename);
   const videoStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_VIDEO) ?? null;
@@ -1580,6 +1743,56 @@ async function startHybridDecoder(opts) {
     });
     throw new Error("hybrid decoder: could not initialize any decoders");
   }
+  let bsfCtx = null;
+  let bsfPkt = null;
+  if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
+    try {
+      bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
+      if (bsfCtx != null && bsfCtx >= 0) {
+        const parIn = await libav.AVBSFContext_par_in(bsfCtx);
+        await libav.avcodec_parameters_copy(parIn, videoStream.codecpar);
+        await libav.av_bsf_init(bsfCtx);
+        bsfPkt = await libav.av_packet_alloc();
+        chunkG4APZMCP_cjs.dbg.info("bsf", "mpeg4_unpack_bframes BSF active (hybrid)");
+      } else {
+        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available in hybrid decoder");
+        bsfCtx = null;
+      }
+    } catch (err) {
+      console.warn("[avbridge] hybrid: failed to init BSF:", err.message);
+      bsfCtx = null;
+      bsfPkt = null;
+    }
+  }
+  async function applyBSF(packets) {
+    if (!bsfCtx || !bsfPkt) return packets;
+    const out = [];
+    for (const pkt of packets) {
+      await libav.ff_copyin_packet(bsfPkt, pkt);
+      const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
+      if (sendErr < 0) {
+        out.push(pkt);
+        continue;
+      }
+      while (true) {
+        const recvErr = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+        if (recvErr < 0) break;
+        out.push(await libav.ff_copyout_packet(bsfPkt));
+      }
+    }
+    return out;
+  }
+  async function flushBSF() {
+    if (!bsfCtx || !bsfPkt) return;
+    try {
+      await libav.av_bsf_send_packet(bsfCtx, 0);
+      while (true) {
+        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+        if (err < 0) break;
+      }
+    } catch {
+    }
+  }
   let destroyed = false;
   let pumpToken = 0;
   let pumpRunning = null;
@@ -1607,8 +1820,15 @@ async function startHybridDecoder(opts) {
       if (myToken !== pumpToken || destroyed) return;
       const videoPackets = videoStream ? packets[videoStream.index] : void 0;
       const audioPackets = audioStream ? packets[audioStream.index] : void 0;
+      if (audioDec && audioPackets && audioPackets.length > 0) {
+        await decodeAudioBatch(audioPackets, myToken);
+      }
+      if (myToken !== pumpToken || destroyed) return;
+      await new Promise((r) => setTimeout(r, 0));
+      if (myToken !== pumpToken || destroyed) return;
       if (videoDecoder && videoPackets && videoPackets.length > 0) {
-        for (const pkt of videoPackets) {
+        const processed = await applyBSF(videoPackets);
+        for (const pkt of processed) {
           if (myToken !== pumpToken || destroyed) return;
           sanitizePacketTimestamp(pkt, () => {
             const ts = syntheticVideoUs;
@@ -1628,9 +1848,6 @@ async function startHybridDecoder(opts) {
           }
         }
       }
-      if (audioDec && audioPackets && audioPackets.length > 0) {
-        await decodeAudioBatch(audioPackets, myToken);
-      }
       packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
       while (!destroyed && myToken === pumpToken && (videoDecoder && videoDecoder.decodeQueueSize > 10 || opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
         await new Promise((r) => setTimeout(r, 50));
@@ -1653,20 +1870,43 @@ async function startHybridDecoder(opts) {
   }
   async function decodeAudioBatch(pkts, myToken, flush = false) {
     if (!audioDec || destroyed || myToken !== pumpToken) return;
-    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) {
-      console.error("[avbridge] hybrid audio decode failed:", err);
-      return;
+    const AUDIO_SUB_BATCH = 4;
+    let allFrames = [];
+    for (let i = 0; i < pkts.length; i += AUDIO_SUB_BATCH) {
+      if (myToken !== pumpToken || destroyed) return;
+      const slice = pkts.slice(i, i + AUDIO_SUB_BATCH);
+      const isLast = i + AUDIO_SUB_BATCH >= pkts.length;
+      try {
+        const frames2 = await libav.ff_decode_multi(
+          audioDec.c,
+          audioDec.pkt,
+          audioDec.frame,
+          slice,
+          isLast && flush ? { fin: true, ignoreErrors: true } : { ignoreErrors: true }
+        );
+        allFrames = allFrames.concat(frames2);
+      } catch (err) {
+        console.error("[avbridge] hybrid audio decode failed:", err);
+        return;
+      }
+      if (!isLast) await new Promise((r) => setTimeout(r, 0));
+    }
+    if (pkts.length === 0 && flush) {
+      try {
+        allFrames = await libav.ff_decode_multi(
+          audioDec.c,
+          audioDec.pkt,
+          audioDec.frame,
+          [],
+          { fin: true, ignoreErrors: true }
+        );
+      } catch (err) {
+        console.error("[avbridge] hybrid audio flush failed:", err);
+        return;
+      }
     }
     if (myToken !== pumpToken || destroyed) return;
+    const frames = allFrames;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
       sanitizeFrameTimestamp(
@@ -1703,6 +1943,14 @@ async function startHybridDecoder(opts) {
         await pumpRunning;
       } catch {
       }
+      try {
+        if (bsfCtx) await libav.av_bsf_free(bsfCtx);
+      } catch {
+      }
+      try {
+        if (bsfPkt) await libav.av_packet_free?.(bsfPkt);
+      } catch {
+      }
       try {
         if (videoDecoder && videoDecoder.state !== "closed") videoDecoder.close();
       } catch {
@@ -1756,6 +2004,7 @@ async function startHybridDecoder(opts) {
         if (audioDec) await libav.avcodec_flush_buffers?.(audioDec.c);
       } catch {
       }
+      await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
       pumpRunning = pumpLoop(newToken).catch(
@@ -1769,6 +2018,7 @@ async function startHybridDecoder(opts) {
         videoFramesDecoded,
         videoChunksFed,
         audioFramesDecoded,
+        bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
         videoDecodeQueueSize: videoDecoder?.decodeQueueSize ?? 0,
         // Confirmed transport info — see fallback decoder for the pattern.
         _transport: inputHandle.transport === "http-range" ? "http-range" : "memory",
@@ -1945,8 +2195,8 @@ async function loadBridge() {
 // src/strategies/hybrid/index.ts
 var READY_AUDIO_BUFFER_SECONDS = 0.3;
 var READY_TIMEOUT_SECONDS = 10;
-async function createHybridSession(ctx, target) {
-  const { normalizeSource: normalizeSource2 } = await import('./source-CN43EI7Z.cjs');
+async function createHybridSession(ctx, target, transport) {
+  const { normalizeSource: normalizeSource2 } = await import('./source-73CAH6HW.cjs');
   const source = await normalizeSource2(ctx.source);
   const fps = ctx.videoTracks[0]?.fps ?? 30;
   const audio = new AudioOutput();
@@ -1958,7 +2208,8 @@ async function createHybridSession(ctx, target) {
       filename: ctx.name ?? "input.bin",
       context: ctx,
       renderer,
-      audio
+      audio,
+      transport
     });
   } catch (err) {
     audio.destroy();
@@ -1972,6 +2223,26 @@ async function createHybridSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
+  Object.defineProperty(target, "volume", {
+    configurable: true,
+    get: () => audio.getVolume(),
+    set: (v) => {
+      audio.setVolume(v);
+      target.dispatchEvent(new Event("volumechange"));
+    }
+  });
+  Object.defineProperty(target, "muted", {
+    configurable: true,
+    get: () => audio.getMuted(),
+    set: (m) => {
+      audio.setMuted(m);
+      target.dispatchEvent(new Event("volumechange"));
+    }
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -2011,10 +2282,13 @@ async function createHybridSession(ctx, target) {
       if (!audio.isPlaying()) {
         await waitForBuffer();
         await audio.start();
+        target.dispatchEvent(new Event("play"));
+        target.dispatchEvent(new Event("playing"));
       }
     },
     pause() {
       void audio.pause();
+      target.dispatchEvent(new Event("pause"));
     },
     async seek(time) {
       await doSeek(time);
@@ -2036,6 +2310,9 @@ async function createHybridSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
+        delete target.volume;
+        delete target.muted;
       } catch {
       }
     },
@@ -2047,11 +2324,11 @@ async function createHybridSession(ctx, target) {
 
 // src/strategies/fallback/decoder.ts
 async function startDecoder(opts) {
-  const variant = chunkNZU7W256_cjs.pickLibavVariant(opts.context);
+  const variant = chunkF3LQJKXK_cjs.pickLibavVariant(opts.context);
   const libav = await chunkG4APZMCP_cjs.loadLibav(variant);
   const bridge = await loadBridge2();
-  const { prepareLibavInput } = await import('./libav-http-reader-FPYDBMYK.cjs');
-  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source);
+  const { prepareLibavInput } = await import('./libav-http-reader-AZLE7YFS.cjs');
+  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source, opts.transport);
   const readPkt = await libav.av_packet_alloc();
   const [fmt_ctx, streams] = await libav.ff_init_demuxer_file(opts.filename);
   const videoStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_VIDEO) ?? null;
@@ -2107,6 +2384,56 @@ async function startDecoder(opts) {
       `fallback decoder: could not initialize any libav decoders (${codecs}).${hint}`
     );
   }
+  let bsfCtx = null;
+  let bsfPkt = null;
+  if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
+    try {
+      bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
+      if (bsfCtx != null && bsfCtx >= 0) {
+        const parIn = await libav.AVBSFContext_par_in(bsfCtx);
+        await libav.avcodec_parameters_copy(parIn, videoStream.codecpar);
+        await libav.av_bsf_init(bsfCtx);
+        bsfPkt = await libav.av_packet_alloc();
+        chunkG4APZMCP_cjs.dbg.info("bsf", "mpeg4_unpack_bframes BSF active");
+      } else {
+        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available \u2014 decoding without it");
+        bsfCtx = null;
+      }
+    } catch (err) {
+      console.warn("[avbridge] failed to init mpeg4_unpack_bframes BSF:", err.message);
+      bsfCtx = null;
+      bsfPkt = null;
+    }
+  }
+  async function applyBSF(packets) {
+    if (!bsfCtx || !bsfPkt) return packets;
+    const out = [];
+    for (const pkt of packets) {
+      await libav.ff_copyin_packet(bsfPkt, pkt);
+      const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
+      if (sendErr < 0) {
+        out.push(pkt);
+        continue;
+      }
+      while (true) {
+        const recvErr = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+        if (recvErr < 0) break;
+        out.push(await libav.ff_copyout_packet(bsfPkt));
+      }
+    }
+    return out;
+  }
+  async function flushBSF() {
+    if (!bsfCtx || !bsfPkt) return;
+    try {
+      await libav.av_bsf_send_packet(bsfCtx, 0);
+      while (true) {
+        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+        if (err < 0) break;
+      }
+    } catch {
+    }
+  }
   let destroyed = false;
   let pumpToken = 0;
   let pumpRunning = null;
@@ -2115,7 +2442,8 @@ async function startDecoder(opts) {
   let audioFramesDecoded = 0;
   let watchdogFirstFrameMs = 0;
   let watchdogSlowSinceMs = 0;
-  let watchdogWarned = false;
+  let watchdogSlowWarned = false;
+  let watchdogOverflowWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
@@ -2127,7 +2455,7 @@ async function startDecoder(opts) {
       let packets;
       try {
         [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
-          limit: 64 * 1024
+          limit: 16 * 1024
         });
       } catch (err) {
         console.error("[avbridge] ff_read_frame_multi failed:", err);
@@ -2136,26 +2464,27 @@ async function startDecoder(opts) {
       if (myToken !== pumpToken || destroyed) return;
       const videoPackets = videoStream ? packets[videoStream.index] : void 0;
       const audioPackets = audioStream ? packets[audioStream.index] : void 0;
-      if (videoDec && videoPackets && videoPackets.length > 0) {
-        await decodeVideoBatch(videoPackets, myToken);
-      }
-      if (myToken !== pumpToken || destroyed) return;
       if (audioDec && audioPackets && audioPackets.length > 0) {
         await decodeAudioBatch(audioPackets, myToken);
       }
+      if (myToken !== pumpToken || destroyed) return;
+      if (videoDec && videoPackets && videoPackets.length > 0) {
+        const processed = await applyBSF(videoPackets);
+        await decodeVideoBatch(processed, myToken);
+      }
       packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
       if (videoFramesDecoded > 0) {
         if (watchdogFirstFrameMs === 0) {
           watchdogFirstFrameMs = performance.now();
         }
         const elapsedSinceFirst = (performance.now() - watchdogFirstFrameMs) / 1e3;
-        if (elapsedSinceFirst > 1 && !watchdogWarned) {
+        if (elapsedSinceFirst > 1 && !watchdogSlowWarned) {
           const expectedFrames = elapsedSinceFirst * videoFps;
           const ratio = videoFramesDecoded / expectedFrames;
           if (ratio < 0.6) {
             if (watchdogSlowSinceMs === 0) watchdogSlowSinceMs = performance.now();
             if ((performance.now() - watchdogSlowSinceMs) / 1e3 > 5) {
-              watchdogWarned = true;
+              watchdogSlowWarned = true;
               console.warn(
                 "[avbridge:decode-rate]",
                 `decoder is running slower than realtime: ${videoFramesDecoded} frames in ${elapsedSinceFirst.toFixed(1)}s (${(videoFramesDecoded / elapsedSinceFirst).toFixed(1)} fps vs ${videoFps} fps source \u2014 ${(ratio * 100).toFixed(0)}% of realtime). Playback will stutter. Typical causes: software decode of a codec with no WebCodecs support (rv40, mpeg4 @ 720p+, wmv3), or a resolution too large for single-threaded WASM to keep up with.`
@@ -2165,6 +2494,17 @@ async function startDecoder(opts) {
             watchdogSlowSinceMs = 0;
           }
         }
+        if (!watchdogOverflowWarned && videoFramesDecoded > 100) {
+          const rendererStats = opts.renderer.stats();
+          const overflow = rendererStats.framesDroppedOverflow ?? 0;
+          if (overflow / videoFramesDecoded > 0.1) {
+            watchdogOverflowWarned = true;
+            console.warn(
+              "[avbridge:overflow-drop]",
+              `renderer is dropping ${overflow}/${videoFramesDecoded} frames (${(overflow / videoFramesDecoded * 100).toFixed(0)}%) because the decoder is producing bursts faster than the canvas can drain. Symptom: choppy playback despite decoder keeping up on average. Fix would be smaller read batches in the pump loop or a lower queueHighWater cap \u2014 see src/strategies/fallback/decoder.ts.`
+            );
+          }
+        }
       }
       while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
         await new Promise((r) => setTimeout(r, 50));
@@ -2276,6 +2616,14 @@ async function startDecoder(opts) {
         await pumpRunning;
       } catch {
       }
+      try {
+        if (bsfCtx) await libav.av_bsf_free(bsfCtx);
+      } catch {
+      }
+      try {
+        if (bsfPkt) await libav.av_packet_free?.(bsfPkt);
+      } catch {
+      }
       try {
         if (videoDec) await libav.ff_free_decoder?.(videoDec.c, videoDec.pkt, videoDec.frame);
       } catch {
@@ -2327,6 +2675,7 @@ async function startDecoder(opts) {
         if (audioDec) await libav.avcodec_flush_buffers?.(audioDec.c);
       } catch {
       }
+      await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
       pumpRunning = pumpLoop(newToken).catch(
@@ -2339,6 +2688,7 @@ async function startDecoder(opts) {
         packetsRead,
         videoFramesDecoded,
         audioFramesDecoded,
+        bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
         // Confirmed transport info: once prepareLibavInput returns
         // successfully, we *know* whether the source is http-range (probe
         // succeeded and returned 206) or in-memory blob. Diagnostics hoists
@@ -2494,8 +2844,8 @@ async function loadBridge2() {
 // src/strategies/fallback/index.ts
 var READY_AUDIO_BUFFER_SECONDS2 = 0.04;
 var READY_TIMEOUT_SECONDS2 = 3;
-async function createFallbackSession(ctx, target) {
-  const { normalizeSource: normalizeSource2 } = await import('./source-CN43EI7Z.cjs');
+async function createFallbackSession(ctx, target, transport) {
+  const { normalizeSource: normalizeSource2 } = await import('./source-73CAH6HW.cjs');
   const source = await normalizeSource2(ctx.source);
   const fps = ctx.videoTracks[0]?.fps ?? 30;
   const audio = new AudioOutput();
@@ -2507,7 +2857,8 @@ async function createFallbackSession(ctx, target) {
       filename: ctx.name ?? "input.bin",
       context: ctx,
       renderer,
-      audio
+      audio,
+      transport
     });
   } catch (err) {
     audio.destroy();
@@ -2521,6 +2872,26 @@ async function createFallbackSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
+  Object.defineProperty(target, "volume", {
+    configurable: true,
+    get: () => audio.getVolume(),
+    set: (v) => {
+      audio.setVolume(v);
+      target.dispatchEvent(new Event("volumechange"));
+    }
+  });
+  Object.defineProperty(target, "muted", {
+    configurable: true,
+    get: () => audio.getMuted(),
+    set: (m) => {
+      audio.setMuted(m);
+      target.dispatchEvent(new Event("volumechange"));
+    }
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -2529,25 +2900,35 @@ async function createFallbackSession(ctx, target) {
   }
   async function waitForBuffer() {
     const start = performance.now();
+    let firstFrameAtMs = 0;
     chunkG4APZMCP_cjs.dbg.info(
       "cold-start",
-      `gate entry: need audio >= ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms + 1 frame`
+      `gate entry: want audio \u2265 ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms + 1 frame`
     );
     while (true) {
       const audioAhead = audio.isNoAudio() ? Infinity : audio.bufferAhead();
       const audioReady = audio.isNoAudio() || audioAhead >= READY_AUDIO_BUFFER_SECONDS2;
       const hasFrames = renderer.hasFrames();
+      const nowMs = performance.now();
+      if (hasFrames && firstFrameAtMs === 0) firstFrameAtMs = nowMs;
       if (audioReady && hasFrames) {
         chunkG4APZMCP_cjs.dbg.info(
           "cold-start",
-          `gate satisfied in ${(performance.now() - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
+          `gate satisfied in ${(nowMs - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
+        );
+        return;
+      }
+      if (hasFrames && firstFrameAtMs > 0 && nowMs - firstFrameAtMs >= 500) {
+        chunkG4APZMCP_cjs.dbg.info(
+          "cold-start",
+          `gate released on video-only grace at ${(nowMs - start).toFixed(0)}ms (frames=${renderer.queueDepth()}, audio=${(audioAhead * 1e3).toFixed(0)}ms \u2014 demuxer hasn't delivered audio packets yet, starting anyway and letting the audio scheduler catch up at its media-time anchor)`
         );
         return;
       }
-      if ((performance.now() - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
+      if ((nowMs - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
         chunkG4APZMCP_cjs.dbg.diag(
           "cold-start",
-          `gate TIMEOUT after ${READY_TIMEOUT_SECONDS2}s \u2014 audio=${(audioAhead * 1e3).toFixed(0)}ms (needed ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms), frames=${renderer.queueDepth()} (needed \u22651). Software decoder is producing output slower than realtime \u2014 playback will stutter. Check getDiagnostics().runtime for the decode rate.`
+          `gate TIMEOUT after ${READY_TIMEOUT_SECONDS2}s \u2014 audio=${(audioAhead * 1e3).toFixed(0)}ms (needed ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms), frames=${renderer.queueDepth()} (needed \u22651). Decoder produced nothing in ${READY_TIMEOUT_SECONDS2}s \u2014 either a corrupt source, a missing codec, or WASM is catastrophically slow on this file. Check getDiagnostics().runtime for decode counters.`
         );
         return;
       }
@@ -2574,10 +2955,13 @@ async function createFallbackSession(ctx, target) {
       if (!audio.isPlaying()) {
         await waitForBuffer();
         await audio.start();
+        target.dispatchEvent(new Event("play"));
+        target.dispatchEvent(new Event("playing"));
       }
     },
     pause() {
       void audio.pause();
+      target.dispatchEvent(new Event("pause"));
     },
     async seek(time) {
       await doSeek(time);
@@ -2596,6 +2980,9 @@ async function createFallbackSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
+        delete target.volume;
+        delete target.muted;
       } catch {
       }
     },
@@ -2619,12 +3006,12 @@ var remuxPlugin = {
 var hybridPlugin = {
   name: "hybrid",
   canHandle: () => typeof VideoDecoder !== "undefined",
-  execute: (ctx, video) => createHybridSession(ctx, video)
+  execute: (ctx, video, transport) => createHybridSession(ctx, video, transport)
 };
 var fallbackPlugin = {
   name: "fallback",
   canHandle: () => true,
-  execute: (ctx, video) => createFallbackSession(ctx, video)
+  execute: (ctx, video, transport) => createFallbackSession(ctx, video, transport)
 };
 function registerBuiltins(registry) {
   registry.register(nativePlugin);
@@ -2680,7 +3067,8 @@ var SubtitleResourceBag = class {
     this.urls.clear();
   }
 };
-async function attachSubtitleTracks(video, tracks, bag, onError) {
+async function attachSubtitleTracks(video, tracks, bag, onError, transport) {
+  const doFetch = chunk6UUT4BEA_cjs.fetchWith(transport);
   for (const t of Array.from(video.querySelectorAll("track[data-avbridge]"))) {
     t.remove();
   }
@@ -2689,13 +3077,13 @@ async function attachSubtitleTracks(video, tracks, bag, onError) {
     try {
       let url = t.sidecarUrl;
       if (t.format === "srt") {
-        const res = await fetch(t.sidecarUrl);
+        const res = await doFetch(t.sidecarUrl, transport?.requestInit);
         const text = await res.text();
         const vtt = srtToVtt(text);
         const blob = new Blob([vtt], { type: "text/vtt" });
         url = bag ? bag.createObjectURL(blob) : URL.createObjectURL(blob);
       } else if (t.format === "vtt") {
-        const res = await fetch(t.sidecarUrl);
+        const res = await doFetch(t.sidecarUrl, transport?.requestInit);
         const text = await res.text();
         if (!isVtt(text)) {
           console.warn("[avbridge] subtitle missing WEBVTT header:", t.sidecarUrl);
@@ -2723,6 +3111,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
   constructor(options, registry) {
     this.options = options;
     this.registry = registry;
+    const { requestInit, fetchFn } = options;
+    if (requestInit || fetchFn) {
+      this.transport = { requestInit, fetchFn };
+    }
   }
   options;
   registry;
@@ -2738,11 +3130,27 @@ var UnifiedPlayer = class _UnifiedPlayer {
   lastProgressTime = 0;
   lastProgressPosition = -1;
   errorListener = null;
+  // Bound so we can removeEventListener in destroy(); without this the
+  // listener outlives the player and accumulates on elements that swap
+  // source (e.g. <avbridge-video>).
+  endedListener = null;
+  // Background tab handling. userIntent is what the user last asked for
+  // (play vs pause) — used to decide whether to auto-resume on visibility
+  // return. autoPausedForVisibility tracks whether we paused because the
+  // tab was hidden, so we don't resume playback the user deliberately
+  // paused (e.g. via media keys while hidden).
+  userIntent = "pause";
+  autoPausedForVisibility = false;
+  visibilityListener = null;
   // Serializes escalation / setStrategy calls
   switchingPromise = Promise.resolve();
   // Owns blob URLs created during sidecar discovery + SRT->VTT conversion.
   // Revoked at destroy() so repeated source swaps don't leak.
   subtitleResources = new SubtitleResourceBag();
+  // Transport config extracted from CreatePlayerOptions. Threaded to probe,
+  // subtitle fetches, and strategy session creators. Not stored on MediaContext
+  // because it's runtime config, not media analysis.
+  transport;
   static async create(options) {
     const registry = new PluginRegistry();
     registerBuiltins(registry);
@@ -2766,7 +3174,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
     const bootstrapStart = performance.now();
     try {
       chunkG4APZMCP_cjs.dbg.info("bootstrap", "start");
-      const ctx = await chunkG4APZMCP_cjs.dbg.timed("probe", "probe", 3e3, () => probe(this.options.source));
+      const ctx = await chunkG4APZMCP_cjs.dbg.timed("probe", "probe", 3e3, () => probe(this.options.source, this.transport));
       chunkG4APZMCP_cjs.dbg.info(
         "probe",
         `container=${ctx.container} video=${ctx.videoTracks[0]?.codec ?? "-"} audio=${ctx.audioTracks[0]?.codec ?? "-"} probedBy=${ctx.probedBy}`
@@ -2814,7 +3222,8 @@ var UnifiedPlayer = class _UnifiedPlayer {
           this.subtitleResources,
           (err, track) => {
             console.warn(`[avbridge] subtitle ${track.id} failed: ${err.message}`);
-          }
+          },
+          this.transport
         );
       }
       this.emitter.emitSticky("tracks", {
@@ -2823,7 +3232,12 @@ var UnifiedPlayer = class _UnifiedPlayer {
         subtitle: ctx.subtitleTracks
       });
       this.startTimeupdateLoop();
-      this.options.target.addEventListener("ended", () => this.emitter.emit("ended", void 0));
+      this.endedListener = () => this.emitter.emit("ended", void 0);
+      this.options.target.addEventListener("ended", this.endedListener);
+      if (this.options.backgroundBehavior !== "continue" && typeof document !== "undefined") {
+        this.visibilityListener = () => this.onVisibilityChange();
+        document.addEventListener("visibilitychange", this.visibilityListener);
+      }
       this.emitter.emitSticky("ready", void 0);
       const bootstrapElapsed = performance.now() - bootstrapStart;
       chunkG4APZMCP_cjs.dbg.info("bootstrap", `ready in ${bootstrapElapsed.toFixed(0)}ms`);
@@ -2850,7 +3264,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
       throw new Error(`no plugin available for strategy "${strategy}"`);
     }
     try {
-      this.session = await plugin.execute(this.mediaContext, this.options.target);
+      this.session = await plugin.execute(this.mediaContext, this.options.target, this.transport);
     } catch (err) {
       const chain = this.classification?.fallbackChain;
       if (chain && chain.length > 0) {
@@ -2923,7 +3337,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
         continue;
       }
       try {
-        this.session = await plugin.execute(this.mediaContext, this.options.target);
+        this.session = await plugin.execute(this.mediaContext, this.options.target, this.transport);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         errors.push(`${nextStrategy}: ${msg}`);
@@ -2946,8 +3360,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       }
       return;
     }
-    this.emitter.emit("error", new Error(
-      `all fallback strategies failed: ${errors.join("; ")}`
+    this.emitter.emit("error", new chunk6UUT4BEA_cjs.AvbridgeError(
+      chunk6UUT4BEA_cjs.ERR_ALL_STRATEGIES_EXHAUSTED,
+      `All playback strategies failed: ${errors.join("; ")}`,
+      "This file may require a codec or container that isn't available in this browser. Try the fallback strategy or check browser codec support."
     ));
   }
   // ── Stall supervision ─────────────────────────────────────────────────
@@ -2999,7 +3415,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
   // ── Public: manual strategy switch ────────────────────────────────────
   /** Manually switch to a different playback strategy. Preserves current position and play/pause state. Concurrent calls are serialized. */
   async setStrategy(strategy, reason) {
-    if (!this.mediaContext) throw new Error("player not ready");
+    if (!this.mediaContext) throw new chunk6UUT4BEA_cjs.AvbridgeError(chunk6UUT4BEA_cjs.ERR_PLAYER_NOT_READY, "Player not ready \u2014 wait for the 'ready' event before calling playback methods.", "Await the 'ready' event or check player.readyState before calling play/pause/seek.");
     if (this.session?.strategy === strategy) return;
     this.switchingPromise = this.switchingPromise.then(
       () => this.doSetStrategy(strategy, reason)
@@ -3028,7 +3444,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
     }
     const plugin = this.registry.findFor(this.mediaContext, strategy);
     if (!plugin) throw new Error(`no plugin available for strategy "${strategy}"`);
-    this.session = await plugin.execute(this.mediaContext, this.options.target);
+    this.session = await plugin.execute(this.mediaContext, this.options.target, this.transport);
     this.emitter.emitSticky("strategy", {
       strategy,
       reason: switchReason
@@ -3062,26 +3478,56 @@ var UnifiedPlayer = class _UnifiedPlayer {
   }
   /** Begin or resume playback. Throws if the player is not ready. */
   async play() {
-    if (!this.session) throw new Error("player not ready");
+    if (!this.session) throw new chunk6UUT4BEA_cjs.AvbridgeError(chunk6UUT4BEA_cjs.ERR_PLAYER_NOT_READY, "Player not ready \u2014 wait for the 'ready' event before calling playback methods.", "Await the 'ready' event or check player.readyState before calling play/pause/seek.");
+    this.userIntent = "play";
+    this.autoPausedForVisibility = false;
     await this.session.play();
   }
   /** Pause playback. No-op if the player is not ready or already paused. */
   pause() {
+    this.userIntent = "pause";
+    this.autoPausedForVisibility = false;
     this.session?.pause();
   }
+  /**
+   * Handle browser tab visibility changes. On hide: pause if the user
+   * had been playing. On show: resume if we were the one who paused.
+   * Skips when `backgroundBehavior: "continue"` is set (listener isn't
+   * installed in that case).
+   */
+  onVisibilityChange() {
+    if (!this.session) return;
+    const action = decideVisibilityAction({
+      hidden: document.hidden,
+      userIntent: this.userIntent,
+      sessionIsPlaying: !this.options.target.paused,
+      autoPausedForVisibility: this.autoPausedForVisibility
+    });
+    if (action === "pause") {
+      this.autoPausedForVisibility = true;
+      chunkG4APZMCP_cjs.dbg.info("visibility", "tab hidden \u2014 auto-paused");
+      this.session.pause();
+    } else if (action === "resume") {
+      this.autoPausedForVisibility = false;
+      chunkG4APZMCP_cjs.dbg.info("visibility", "tab visible \u2014 auto-resuming");
+      void this.session.play().catch((err) => {
+        console.warn("[avbridge] auto-resume after tab return failed:", err);
+      });
+    }
+  }
   /** Seek to the given time in seconds. Throws if the player is not ready. */
   async seek(time) {
-    if (!this.session) throw new Error("player not ready");
+    if (!this.session) throw new chunk6UUT4BEA_cjs.AvbridgeError(chunk6UUT4BEA_cjs.ERR_PLAYER_NOT_READY, "Player not ready \u2014 wait for the 'ready' event before calling playback methods.", "Await the 'ready' event or check player.readyState before calling play/pause/seek.");
     await this.session.seek(time);
   }
   /** Switch the active audio track by track ID. Throws if the player is not ready. */
   async setAudioTrack(id) {
-    if (!this.session) throw new Error("player not ready");
+    if (!this.session) throw new chunk6UUT4BEA_cjs.AvbridgeError(chunk6UUT4BEA_cjs.ERR_PLAYER_NOT_READY, "Player not ready \u2014 wait for the 'ready' event before calling playback methods.", "Await the 'ready' event or check player.readyState before calling play/pause/seek.");
     await this.session.setAudioTrack(id);
   }
   /** Switch the active subtitle track by track ID, or pass `null` to disable subtitles. */
   async setSubtitleTrack(id) {
-    if (!this.session) throw new Error("player not ready");
+    if (!this.session) throw new chunk6UUT4BEA_cjs.AvbridgeError(chunk6UUT4BEA_cjs.ERR_PLAYER_NOT_READY, "Player not ready \u2014 wait for the 'ready' event before calling playback methods.", "Await the 'ready' event or check player.readyState before calling play/pause/seek.");
     await this.session.setSubtitleTrack(id);
   }
   /** Return a snapshot of current diagnostics: container, codecs, strategy, runtime stats, and strategy history. */
@@ -3109,6 +3555,14 @@ var UnifiedPlayer = class _UnifiedPlayer {
       this.timeupdateInterval = null;
     }
     this.clearSupervisor();
+    if (this.endedListener) {
+      this.options.target.removeEventListener("ended", this.endedListener);
+      this.endedListener = null;
+    }
+    if (this.visibilityListener) {
+      document.removeEventListener("visibilitychange", this.visibilityListener);
+      this.visibilityListener = null;
+    }
     if (this.session) {
       await this.session.destroy();
       this.session = null;
@@ -3120,14 +3574,24 @@ var UnifiedPlayer = class _UnifiedPlayer {
 async function createPlayer(options) {
   return UnifiedPlayer.create(options);
 }
+function decideVisibilityAction(state) {
+  if (state.hidden) {
+    if (state.userIntent === "play" && state.sessionIsPlaying) return "pause";
+    return "noop";
+  }
+  if (state.autoPausedForVisibility) return "resume";
+  return "noop";
+}
 function buildInitialDecision(initial, ctx) {
   const natural = classifyContext(ctx);
   const cls = strategyToClass(initial, natural);
+  const inherited = natural.fallbackChain ?? defaultFallbackChain(initial);
+  const fallbackChain = inherited.filter((s) => s !== initial);
   return {
     class: cls,
     strategy: initial,
     reason: `initial strategy "${initial}" requested via options.initialStrategy`,
-    fallbackChain: natural.fallbackChain ?? defaultFallbackChain(initial)
+    fallbackChain
   };
 }
 function strategyToClass(strategy, natural) {
@@ -3156,6 +3620,10 @@ function defaultFallbackChain(strategy) {
   }
 }
 
+exports.FALLBACK_AUDIO_CODECS = FALLBACK_AUDIO_CODECS;
+exports.FALLBACK_VIDEO_CODECS = FALLBACK_VIDEO_CODECS;
+exports.NATIVE_AUDIO_CODECS = NATIVE_AUDIO_CODECS;
+exports.NATIVE_VIDEO_CODECS = NATIVE_VIDEO_CODECS;
 exports.UnifiedPlayer = UnifiedPlayer;
 exports.avbridgeAudioToMediabunny = avbridgeAudioToMediabunny;
 exports.avbridgeVideoToMediabunny = avbridgeVideoToMediabunny;
@@ -3164,5 +3632,5 @@ exports.classifyContext = classifyContext;
 exports.createPlayer = createPlayer;
 exports.probe = probe;
 exports.srtToVtt = srtToVtt;
-//# sourceMappingURL=chunk-OE66B34H.cjs.map
-//# sourceMappingURL=chunk-OE66B34H.cjs.map
+//# sourceMappingURL=chunk-7RGG6ME7.cjs.map
+//# sourceMappingURL=chunk-7RGG6ME7.cjs.map