avbridge 2.2.1 → 2.5.0

package/dist/element-browser.js

@@ -31,6 +31,51 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/util/transport.ts
+function mergeFetchInit(base, extra) {
+  if (!base && !extra) return void 0;
+  return {
+    ...base,
+    ...extra,
+    headers: {
+      ...base?.headers ?? {},
+      ...extra?.headers ?? {}
+    }
+  };
+}
+function fetchWith(transport) {
+  return transport?.fetchFn ?? globalThis.fetch;
+}
+var init_transport = __esm({
+  "src/util/transport.ts"() {
+  }
+});
+
+// src/errors.ts
+var AvbridgeError, ERR_PROBE_FAILED, ERR_PROBE_UNKNOWN_CONTAINER, ERR_PROBE_FETCH_FAILED, ERR_ALL_STRATEGIES_EXHAUSTED, ERR_PLAYER_NOT_READY, ERR_LIBAV_NOT_REACHABLE, ERR_MSE_NOT_SUPPORTED, ERR_MSE_CODEC_NOT_SUPPORTED;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    AvbridgeError = class extends Error {
+      constructor(code, message, recovery, options) {
+        super(message, options);
+        this.code = code;
+        this.recovery = recovery;
+      }
+      code;
+      recovery;
+      name = "AvbridgeError";
+    };
+    ERR_PROBE_FAILED = "ERR_AVBRIDGE_PROBE_FAILED";
+    ERR_PROBE_UNKNOWN_CONTAINER = "ERR_AVBRIDGE_PROBE_UNKNOWN_CONTAINER";
+    ERR_PROBE_FETCH_FAILED = "ERR_AVBRIDGE_PROBE_FETCH_FAILED";
+    ERR_ALL_STRATEGIES_EXHAUSTED = "ERR_AVBRIDGE_ALL_STRATEGIES_EXHAUSTED";
+    ERR_PLAYER_NOT_READY = "ERR_AVBRIDGE_PLAYER_NOT_READY";
+    ERR_LIBAV_NOT_REACHABLE = "ERR_AVBRIDGE_LIBAV_NOT_REACHABLE";
+    ERR_MSE_NOT_SUPPORTED = "ERR_AVBRIDGE_MSE_NOT_SUPPORTED";
+    ERR_MSE_CODEC_NOT_SUPPORTED = "ERR_AVBRIDGE_MSE_CODEC_NOT_SUPPORTED";
+  }
+});
+
 // src/util/source.ts
 var source_exports = {};
 __export(source_exports, {
@@ -43,7 +88,7 @@ __export(source_exports, {
 function isInMemorySource(source) {
   return source.kind === "blob";
 }
-async function normalizeSource(source) {
+async function normalizeSource(source, transport) {
   if (source instanceof File) {
     return {
       kind: "blob",
@@ -66,22 +111,31 @@ async function normalizeSource(source) {
   }
   if (typeof source === "string" || source instanceof URL) {
     const url2 = source instanceof URL ? source.toString() : source;
-    return await fetchUrlForSniff(url2, source);
+    return await fetchUrlForSniff(url2, source, transport);
   }
   throw new TypeError("unsupported source type");
 }
-async function fetchUrlForSniff(url2, originalSource) {
+async function fetchUrlForSniff(url2, originalSource, transport) {
   const name = url2.split("/").pop()?.split("?")[0] ?? void 0;
+  const doFetch = fetchWith(transport);
   let res;
   try {
-    res = await fetch(url2, {
+    res = await doFetch(url2, mergeFetchInit(transport?.requestInit, {
       headers: { Range: `bytes=0-${URL_SNIFF_RANGE_BYTES - 1}` }
-    });
+    }));
   } catch (err) {
-    throw new Error(`failed to fetch source ${url2}: ${err.message}`);
+    throw new AvbridgeError(
+      ERR_PROBE_FETCH_FAILED,
+      `Failed to fetch source ${url2}: ${err.message}`,
+      "Check that the URL is reachable and CORS is configured. If the source requires authentication, pass requestInit with credentials/headers."
+    );
   }
   if (!res.ok && res.status !== 206) {
-    throw new Error(`failed to fetch source ${url2}: ${res.status} ${res.statusText}`);
+    throw new AvbridgeError(
+      ERR_PROBE_FETCH_FAILED,
+      `Failed to fetch source ${url2}: ${res.status} ${res.statusText}`,
+      res.status === 403 || res.status === 401 ? "The server rejected the request. Pass requestInit with the required Authorization header or credentials." : "Check that the URL is correct and the server is reachable."
+    );
   }
   let byteLength;
   const contentRange = res.headers.get("content-range");
@@ -186,6 +240,8 @@ async function readBlobBytes(blob, limit) {
 var SNIFF_BYTES_NEEDED, URL_SNIFF_RANGE_BYTES;
 var init_source = __esm({
   "src/util/source.ts"() {
+    init_transport();
+    init_errors();
     SNIFF_BYTES_NEEDED = 380;
     URL_SNIFF_RANGE_BYTES = 32 * 1024;
   }
@@ -29453,9 +29509,12 @@ __export(libav_http_reader_exports, {
   attachLibavHttpReader: () => attachLibavHttpReader,
   prepareLibavInput: () => prepareLibavInput
 });
-async function prepareLibavInput(libav, filename, source) {
+async function prepareLibavInput(libav, filename, source, transport) {
   if (source.kind === "url") {
-    const handle = await attachLibavHttpReader(libav, filename, source.url);
+    const handle = await attachLibavHttpReader(libav, filename, source.url, {
+      requestInit: transport?.requestInit,
+      fetchFn: transport?.fetchFn
+    });
     return {
       filename,
       transport: "http-range",
@@ -30009,6 +30068,12 @@ function ffmpegToAvbridgeAudio(name) {
       return "sipr";
     case "atrac3":
       return "atrac3";
+    case "dca":
+    case "dts":
+      return "dts";
+    case "truehd":
+    case "mlp":
+      return "truehd";
     default:
       return name;
   }
@@ -30020,6 +30085,60 @@ var init_avi = __esm({
   }
 });
 
+// src/subtitles/render.ts
+function parseVtt(text) {
+  const cues = [];
+  const blocks = text.replace(/\r\n/g, "\n").split(/\n{2,}/);
+  for (const block of blocks) {
+    const lines = block.split("\n").filter(Boolean);
+    if (lines.length === 0 || lines[0] === "WEBVTT") continue;
+    const timingIdx = lines.findIndex((l) => l.includes("-->"));
+    if (timingIdx < 0) continue;
+    const m = /(\d{2}):(\d{2}):(\d{2})\.(\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})\.(\d{3})/.exec(
+      lines[timingIdx]
+    );
+    if (!m) continue;
+    const t = (h, mm, s, ms) => Number(h) * 3600 + Number(mm) * 60 + Number(s) + Number(ms) / 1e3;
+    cues.push({
+      start: t(m[1], m[2], m[3], m[4]),
+      end: t(m[5], m[6], m[7], m[8]),
+      text: lines.slice(timingIdx + 1).join("\n")
+    });
+  }
+  return cues;
+}
+var SubtitleOverlay;
+var init_render = __esm({
+  "src/subtitles/render.ts"() {
+    SubtitleOverlay = class {
+      el;
+      cues = [];
+      constructor(parent) {
+        this.el = document.createElement("div");
+        this.el.style.cssText = "position:absolute;left:0;right:0;bottom:8%;text-align:center;color:white;text-shadow:0 0 4px black;font-family:sans-serif;font-size:1.4em;pointer-events:none;";
+        parent.appendChild(this.el);
+      }
+      loadVtt(text) {
+        this.cues = parseVtt(text);
+      }
+      update(currentTime) {
+        const active = this.cues.find((c) => currentTime >= c.start && currentTime <= c.end);
+        this.el.textContent = active?.text ?? "";
+      }
+      /** Set the currently-displayed text directly (bypasses loadVtt/update). */
+      setText(text) {
+        if (this.el.textContent !== text) {
+          this.el.textContent = text;
+        }
+      }
+      destroy() {
+        this.el.remove();
+        this.cues = [];
+      }
+    };
+  }
+});
+
 // node_modules/libavjs-webcodecs-bridge/dist/libavjs-webcodecs-bridge.mjs
 var libavjs_webcodecs_bridge_exports = {};
 __export(libavjs_webcodecs_bridge_exports, {
@@ -30937,6 +31056,145 @@ var init_libav_import = __esm({
   }
 });
 
+// src/subtitles/srt.ts
+function srtToVtt(srt) {
+  if (srt.charCodeAt(0) === 65279) srt = srt.slice(1);
+  const normalized = srt.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  const blocks = normalized.split(/\n{2,}/);
+  const out = ["WEBVTT", ""];
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    if (lines.length > 0 && /^\d+$/.test(lines[0].trim())) {
+      lines.shift();
+    }
+    if (lines.length === 0) continue;
+    const timing = lines.shift();
+    const vttTiming = convertTiming(timing);
+    if (!vttTiming) continue;
+    out.push(vttTiming);
+    for (const l of lines) out.push(l);
+    out.push("");
+  }
+  return out.join("\n");
+}
+function convertTiming(line) {
+  const m = /^(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})\s*-->\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})(.*)$/.exec(
+    line.trim()
+  );
+  if (!m) return null;
+  const fmt2 = (h, mm, s, ms) => `${h.padStart(2, "0")}:${mm}:${s}.${ms.padEnd(3, "0").slice(0, 3)}`;
+  return `${fmt2(m[1], m[2], m[3], m[4])} --> ${fmt2(m[5], m[6], m[7], m[8])}${m[9] ?? ""}`;
+}
+var init_srt = __esm({
+  "src/subtitles/srt.ts"() {
+  }
+});
+
+// src/subtitles/vtt.ts
+function isVtt(text) {
+  const trimmed = text.replace(/^\ufeff/, "").trimStart();
+  return trimmed.startsWith("WEBVTT");
+}
+var init_vtt = __esm({
+  "src/subtitles/vtt.ts"() {
+  }
+});
+
+// src/subtitles/index.ts
+var subtitles_exports = {};
+__export(subtitles_exports, {
+  SubtitleOverlay: () => SubtitleOverlay,
+  SubtitleResourceBag: () => SubtitleResourceBag,
+  attachSubtitleTracks: () => attachSubtitleTracks,
+  discoverSidecars: () => discoverSidecars,
+  srtToVtt: () => srtToVtt
+});
+async function discoverSidecars(file, directory) {
+  const baseName = file.name.replace(/\.[^.]+$/, "");
+  const found = [];
+  for await (const [name, handle] of directory) {
+    if (handle.kind !== "file") continue;
+    if (!name.startsWith(baseName)) continue;
+    const lower = name.toLowerCase();
+    let format = null;
+    if (lower.endsWith(".srt")) format = "srt";
+    else if (lower.endsWith(".vtt")) format = "vtt";
+    if (!format) continue;
+    const sidecarFile = await handle.getFile();
+    const url2 = URL.createObjectURL(sidecarFile);
+    const langMatch = name.slice(baseName.length).match(/[._-]([a-z]{2,3})(?:[._-]|\.)/i);
+    found.push({
+      url: url2,
+      format,
+      language: langMatch?.[1]
+    });
+  }
+  return found;
+}
+async function attachSubtitleTracks(video, tracks, bag, onError, transport) {
+  const doFetch = fetchWith(transport);
+  for (const t of Array.from(video.querySelectorAll("track[data-avbridge]"))) {
+    t.remove();
+  }
+  for (const t of tracks) {
+    if (!t.sidecarUrl) continue;
+    try {
+      let url2 = t.sidecarUrl;
+      if (t.format === "srt") {
+        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" });
+        url2 = bag ? bag.createObjectURL(blob) : URL.createObjectURL(blob);
+      } else if (t.format === "vtt") {
+        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);
+        }
+      }
+      const trackEl = document.createElement("track");
+      trackEl.kind = "subtitles";
+      trackEl.src = url2;
+      trackEl.srclang = t.language ?? "und";
+      trackEl.label = t.language ?? `Subtitle ${t.id}`;
+      trackEl.dataset.avbridge = "true";
+      video.appendChild(trackEl);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      onError?.(e, t);
+    }
+  }
+}
+var SubtitleResourceBag;
+var init_subtitles2 = __esm({
+  "src/subtitles/index.ts"() {
+    init_transport();
+    init_srt();
+    init_vtt();
+    init_srt();
+    init_render();
+    SubtitleResourceBag = class {
+      urls = /* @__PURE__ */ new Set();
+      /** Track an externally-created blob URL (e.g. from `discoverSidecars`). */
+      track(url2) {
+        this.urls.add(url2);
+      }
+      /** Convenience: create a blob URL and track it in one call. */
+      createObjectURL(blob) {
+        const url2 = URL.createObjectURL(blob);
+        this.urls.add(url2);
+        return url2;
+      }
+      /** Revoke every tracked URL. Idempotent — safe to call multiple times. */
+      revokeAll() {
+        for (const u of this.urls) URL.revokeObjectURL(u);
+        this.urls.clear();
+      }
+    };
+  }
+});
+
 // src/events.ts
 var TypedEmitter = class {
   listeners = {};
@@ -31152,6 +31410,7 @@ async function safe(fn) {
 }
 
 // src/probe/index.ts
+init_errors();
 var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
   "mov",
@@ -31164,12 +31423,22 @@ var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
   "adts",
   "mpegts"
 ]);
-async function probe(source) {
-  const normalized = await normalizeSource(source);
+async function probe(source, transport) {
+  const normalized = await normalizeSource(source, transport);
   const sniffed = await 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: probeWithLibav2 } = await Promise.resolve().then(() => (init_avi(), avi_exports));
+          return await probeWithLibav2(normalized, sniffed);
+        } catch {
+          return result;
+        }
+      }
+      return result;
     } catch (mediabunnyErr) {
       console.warn(
         `[avbridge] mediabunny rejected ${sniffed} file, falling back to libav:`,
@@ -31181,8 +31450,10 @@ async function probe(source) {
       } 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 AvbridgeError(
+          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."
         );
       }
     }
@@ -31193,8 +31464,17 @@ async function probe(source) {
   } 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 AvbridgeError(
+        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 AvbridgeError(
+      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."
     );
   }
 }
@@ -31295,7 +31575,9 @@ var FALLBACK_AUDIO_CODECS = /* @__PURE__ */ new Set([
   "ra_144",
   "ra_288",
   "sipr",
-  "atrac3"
+  "atrac3",
+  "dts",
+  "truehd"
 ]);
 var NATIVE_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
@@ -31357,7 +31639,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",
@@ -31594,7 +31885,7 @@ async function createNativeSession(context, video) {
     },
     async setAudioTrack(id) {
       const tracks = video.audioTracks;
-      if (!tracks) return;
+      if (!tracks || tracks.length === 0) return;
       for (let i = 0; i < tracks.length; i++) {
         tracks[i].enabled = tracks[i].id === String(id) || i === id;
       }
@@ -31642,14 +31933,23 @@ function sourceToVideoUrl(source) {
 }
 
 // src/strategies/remux/mse.ts
+init_errors();
 var MseSink = class {
   constructor(options) {
     this.options = options;
     if (typeof MediaSource === "undefined") {
-      throw new Error("MSE not supported in this environment");
+      throw new AvbridgeError(
+        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 AvbridgeError(
+        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);
@@ -31834,30 +32134,49 @@ var MseSink = class {
 async function createRemuxPipeline(ctx, video) {
   const mb = await Promise.resolve().then(() => (init_src(), src_exports));
   const videoTrackInfo = ctx.videoTracks[0];
-  const audioTrackInfo = ctx.audioTracks[0];
   if (!videoTrackInfo) throw new Error("remux: source has no video track");
   const mbVideoCodec = avbridgeVideoToMediabunny(videoTrackInfo.codec);
   if (!mbVideoCodec) {
     throw new Error(`remux: video codec "${videoTrackInfo.codec}" is not supported by mediabunny output`);
   }
-  const mbAudioCodec = audioTrackInfo ? avbridgeAudioToMediabunny(audioTrackInfo.codec) : null;
   const input = new mb.Input({
     source: await buildMediabunnySourceFromInput(mb, ctx.source),
     formats: mb.ALL_FORMATS
   });
   const allTracks = await input.getTracks();
   const inputVideo = allTracks.find((t) => t.id === videoTrackInfo.id && t.isVideoTrack());
-  const inputAudio = audioTrackInfo ? allTracks.find((t) => t.id === audioTrackInfo.id && t.isAudioTrack()) : null;
   if (!inputVideo || !inputVideo.isVideoTrack()) {
     throw new Error("remux: video track not found in input");
   }
-  if (audioTrackInfo && (!inputAudio || !inputAudio.isAudioTrack())) {
-    throw new Error("remux: audio track not found in input");
-  }
   const videoConfig = await inputVideo.getDecoderConfig();
-  const audioConfig = inputAudio && inputAudio.isAudioTrack() ? await inputAudio.getDecoderConfig() : null;
   const videoSink = new mb.EncodedPacketSink(inputVideo);
-  const audioSink = inputAudio?.isAudioTrack() ? new mb.EncodedPacketSink(inputAudio) : null;
+  let selectedAudioTrackId = ctx.audioTracks[0]?.id ?? null;
+  let inputAudio = null;
+  let mbAudioCodec = null;
+  let audioSink = null;
+  let audioConfig = null;
+  async function rebuildAudio() {
+    if (selectedAudioTrackId == null) {
+      inputAudio = null;
+      mbAudioCodec = null;
+      audioSink = null;
+      audioConfig = null;
+      return;
+    }
+    const trackInfo = ctx.audioTracks.find((t) => t.id === selectedAudioTrackId);
+    if (!trackInfo) {
+      throw new Error(`remux: no audio track with id ${selectedAudioTrackId}`);
+    }
+    const newInput = allTracks.find((t) => t.id === trackInfo.id && t.isAudioTrack());
+    if (!newInput || !newInput.isAudioTrack()) {
+      throw new Error("remux: audio track not found in input");
+    }
+    inputAudio = newInput;
+    mbAudioCodec = avbridgeAudioToMediabunny(trackInfo.codec);
+    audioSink = new mb.EncodedPacketSink(newInput);
+    audioConfig = await newInput.getDecoderConfig();
+  }
+  await rebuildAudio();
   let sink = null;
   const stats = { videoPackets: 0, audioPackets: 0, bytesWritten: 0, fragments: 0 };
   let destroyed = false;
@@ -31982,6 +32301,30 @@ async function createRemuxPipeline(ctx, video) {
       pendingAutoPlay = autoPlay;
       if (sink) sink.setPlayOnSeek(autoPlay);
     },
+    async setAudioTrack(trackId, time, autoPlay) {
+      if (selectedAudioTrackId === trackId) return;
+      if (!ctx.audioTracks.some((t) => t.id === trackId)) {
+        console.warn("[avbridge] remux: setAudioTrack \u2014 unknown track id", trackId);
+        return;
+      }
+      pumpToken++;
+      selectedAudioTrackId = trackId;
+      await rebuildAudio().catch((err) => {
+        console.warn("[avbridge] remux: rebuildAudio failed:", err.message);
+      });
+      if (sink) {
+        try {
+          sink.destroy();
+        } catch {
+        }
+        sink = null;
+      }
+      pendingAutoPlay = autoPlay;
+      pendingStartTime = time;
+      pumpLoop(++pumpToken, time).catch((err) => {
+        console.error("[avbridge] remux pipeline setAudioTrack pump failed:", err);
+      });
+    },
     async destroy() {
       destroyed = true;
       pumpToken++;
@@ -32041,7 +32384,19 @@ async function createRemuxSession(context, video) {
       const wasPlaying = !video.paused;
       await pipeline.seek(time, wasPlaying || wantPlay);
     },
-    async setAudioTrack(_id) {
+    async setAudioTrack(id) {
+      if (!context.audioTracks.some((t) => t.id === id)) {
+        console.warn("[avbridge] remux: setAudioTrack \u2014 unknown track id", id);
+        return;
+      }
+      const wasPlaying = !video.paused;
+      const time = video.currentTime || 0;
+      if (!started) {
+        started = true;
+        await pipeline.setAudioTrack(id, time, wantPlay || wasPlaying);
+        return;
+      }
+      await pipeline.setAudioTrack(id, time, wasPlaying || wantPlay);
     },
     async setSubtitleTrack(id) {
       const tracks = video.textTracks;
@@ -32065,6 +32420,11 @@ async function createRemuxSession(context, video) {
 }
 
 // src/strategies/fallback/video-renderer.ts
+init_render();
+function isDebug() {
+  return typeof globalThis !== "undefined" && !!globalThis.AVBRIDGE_DEBUG;
+}
+var lastDebugLog = 0;
 var VideoRenderer = class {
   constructor(target, clock, fps = 30) {
     this.target = target;
@@ -32090,6 +32450,9 @@ var VideoRenderer = class {
       document.body.appendChild(this.canvas);
     }
     target.style.visibility = "hidden";
+    const overlayParent = parent instanceof HTMLElement ? parent : document.body;
+    this.subtitleOverlay = new SubtitleOverlay(overlayParent);
+    this.watchTextTracks(target);
     const ctx = this.canvas.getContext("2d");
     if (!ctx) throw new Error("video renderer: failed to acquire 2D context");
     this.ctx = ctx;
@@ -32111,6 +32474,29 @@ 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;
+  /**
+   * Subtitle overlay div attached to the stage wrapper alongside the
+   * canvas. Created lazily when subtitle tracks are attached via the
+   * target's `<track>` children. Canvas strategies (hybrid, fallback)
+   * hide the <video>, so we can't rely on the browser's native cue
+   * rendering; we read TextTrack.cues and render into this overlay.
+   */
+  subtitleOverlay = null;
+  subtitleTrack = null;
+  /**
+   * 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;
@@ -32144,9 +32530,80 @@ var VideoRenderer = class {
       this.framesDroppedOverflow++;
     }
   }
+  /**
+   * Watch the target <video>'s textTracks list. When a track is added,
+   * grab it and start polling cues on each render tick. Existing tracks
+   * (if any) are picked up immediately.
+   */
+  watchTextTracks(target) {
+    const pick = () => {
+      if (this.subtitleTrack) return;
+      const tracks = target.textTracks;
+      if (isDebug()) {
+        console.log(`[avbridge:subs] watchTextTracks pick() \u2014 ${tracks.length} tracks`);
+      }
+      for (let i = 0; i < tracks.length; i++) {
+        const t = tracks[i];
+        if (isDebug()) {
+          console.log(`[avbridge:subs] track ${i}: kind=${t.kind} mode=${t.mode} cues=${t.cues?.length ?? 0}`);
+        }
+        if (t.kind === "subtitles" || t.kind === "captions") {
+          this.subtitleTrack = t;
+          t.mode = "hidden";
+          if (isDebug()) {
+            console.log(`[avbridge:subs] picked track, mode=hidden`);
+          }
+          const trackEl = target.querySelector(`track[srclang="${t.language}"]`);
+          if (trackEl) {
+            trackEl.addEventListener("load", () => {
+              if (isDebug()) {
+                console.log(`[avbridge:subs] track element loaded, cues=${t.cues?.length ?? 0}`);
+              }
+            });
+            trackEl.addEventListener("error", (ev) => {
+              console.warn(`[avbridge:subs] track element error:`, ev);
+            });
+          }
+          break;
+        }
+      }
+    };
+    pick();
+    if (typeof target.textTracks.addEventListener === "function") {
+      target.textTracks.addEventListener("addtrack", (e) => {
+        if (isDebug()) {
+          console.log("[avbridge:subs] addtrack event fired");
+        }
+        pick();
+      });
+    }
+  }
+  _loggedCues = false;
+  /** Find the active cue (if any) for the given media time. */
+  updateSubtitles() {
+    if (!this.subtitleOverlay || !this.subtitleTrack) return;
+    const cues = this.subtitleTrack.cues;
+    if (!cues || cues.length === 0) return;
+    if (isDebug() && !this._loggedCues) {
+      this._loggedCues = true;
+      console.log(`[avbridge:subs] cues available: ${cues.length}, first start=${cues[0].startTime}, last end=${cues[cues.length - 1].endTime}`);
+    }
+    const t = this.clock.now();
+    let activeText = "";
+    for (let i = 0; i < cues.length; i++) {
+      const c = cues[i];
+      if (t >= c.startTime && t <= c.endTime) {
+        const vttCue = c;
+        activeText = vttCue.text ?? "";
+        break;
+      }
+    }
+    this.subtitleOverlay.setText(activeText.replace(/<[^>]+>/g, ""));
+  }
   tick() {
     if (this.destroyed) return;
     this.rafHandle = requestAnimationFrame(this.tick);
+    this.updateSubtitles();
     if (this.queue.length === 0) return;
     const playing = this.clock.isPlaying();
     if (!playing) {
@@ -32159,21 +32616,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();
@@ -32195,8 +32712,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 {
@@ -32210,6 +32732,11 @@ var VideoRenderer = class {
     this.destroyed = true;
     if (this.rafHandle != null) cancelAnimationFrame(this.rafHandle);
     this.flush();
+    if (this.subtitleOverlay) {
+      this.subtitleOverlay.destroy();
+      this.subtitleOverlay = null;
+    }
+    this.subtitleTrack = null;
     this.canvas.remove();
     this.target.style.visibility = "";
   }
@@ -32241,11 +32768,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
@@ -32395,6 +32949,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;
@@ -32423,42 +32978,189 @@ var AudioOutput = class {
 
 // src/strategies/hybrid/decoder.ts
 init_libav_loader();
+init_debug();
 
 // src/strategies/fallback/variant-routing.ts
 var LEGACY_CONTAINERS = /* @__PURE__ */ new Set(["avi", "asf", "flv"]);
-var LEGACY_VIDEO_CODECS = /* @__PURE__ */ new Set([
-  "wmv3",
-  "vc1",
-  "mpeg4",
-  // MPEG-4 Part 2 / DivX / Xvid
-  "rv40",
-  "mpeg2",
-  "mpeg1",
-  "theora"
-]);
-var LEGACY_AUDIO_CODECS = /* @__PURE__ */ new Set(["wmav2", "wmapro", "ac3", "eac3"]);
+var WEBCODECS_AUDIO = /* @__PURE__ */ new Set(["aac", "mp3", "opus", "vorbis", "flac"]);
+var WEBCODECS_VIDEO = /* @__PURE__ */ new Set(["h264", "h265", "vp8", "vp9", "av1"]);
 function pickLibavVariant(ctx) {
   if (LEGACY_CONTAINERS.has(ctx.container)) return "avbridge";
   for (const v of ctx.videoTracks) {
-    if (LEGACY_VIDEO_CODECS.has(v.codec)) return "avbridge";
+    if (!WEBCODECS_VIDEO.has(v.codec)) return "avbridge";
   }
   for (const a of ctx.audioTracks) {
-    if (LEGACY_AUDIO_CODECS.has(a.codec)) return "avbridge";
+    if (!WEBCODECS_AUDIO.has(a.codec)) return "avbridge";
   }
   return "webcodecs";
 }
 
+// src/util/libav-demux.ts
+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;
+  }
+  const fallback = nextUs();
+  pkt.pts = fallback;
+  pkt.ptshi = 0;
+  pkt.time_base_num = 1;
+  pkt.time_base_den = 1e6;
+}
+var AV_SAMPLE_FMT_U8 = 0;
+var AV_SAMPLE_FMT_S16 = 1;
+var AV_SAMPLE_FMT_S32 = 2;
+var AV_SAMPLE_FMT_FLT = 3;
+var AV_SAMPLE_FMT_U8P = 5;
+var AV_SAMPLE_FMT_S16P = 6;
+var AV_SAMPLE_FMT_S32P = 7;
+var AV_SAMPLE_FMT_FLTP = 8;
+function libavFrameToInterleavedFloat32(frame) {
+  const channels = frame.channels ?? frame.ch_layout_nb_channels ?? 1;
+  const sampleRate = frame.sample_rate ?? 44100;
+  const nbSamples = frame.nb_samples ?? 0;
+  if (nbSamples === 0) return null;
+  const out = new Float32Array(nbSamples * channels);
+  switch (frame.format) {
+    case AV_SAMPLE_FMT_FLTP: {
+      const planes = ensurePlanes(frame.data, channels);
+      for (let ch = 0; ch < channels; ch++) {
+        const plane = asFloat32(planes[ch]);
+        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i];
+      }
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_FLT: {
+      const flat = asFloat32(frame.data);
+      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i];
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_S16P: {
+      const planes = ensurePlanes(frame.data, channels);
+      for (let ch = 0; ch < channels; ch++) {
+        const plane = asInt16(planes[ch]);
+        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 32768;
+      }
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_S16: {
+      const flat = asInt16(frame.data);
+      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 32768;
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_S32P: {
+      const planes = ensurePlanes(frame.data, channels);
+      for (let ch = 0; ch < channels; ch++) {
+        const plane = asInt32(planes[ch]);
+        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 2147483648;
+      }
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_S32: {
+      const flat = asInt32(frame.data);
+      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 2147483648;
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_U8P: {
+      const planes = ensurePlanes(frame.data, channels);
+      for (let ch = 0; ch < channels; ch++) {
+        const plane = asUint8(planes[ch]);
+        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = (plane[i] - 128) / 128;
+      }
+      return { data: out, channels, sampleRate };
+    }
+    case AV_SAMPLE_FMT_U8: {
+      const flat = asUint8(frame.data);
+      for (let i = 0; i < nbSamples * channels; i++) out[i] = (flat[i] - 128) / 128;
+      return { data: out, channels, sampleRate };
+    }
+    default:
+      return null;
+  }
+}
+function ensurePlanes(data, channels) {
+  if (Array.isArray(data)) return data;
+  const arr = data;
+  const len = arr.length;
+  const perChannel = Math.floor(len / channels);
+  const planes = [];
+  for (let ch = 0; ch < channels; ch++) {
+    planes.push(arr.subarray ? arr.subarray(ch * perChannel, (ch + 1) * perChannel) : arr);
+  }
+  return planes;
+}
+function asFloat32(x) {
+  if (x instanceof Float32Array) return x;
+  const ta = x;
+  return new Float32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
+}
+function asInt16(x) {
+  if (x instanceof Int16Array) return x;
+  const ta = x;
+  return new Int16Array(ta.buffer, ta.byteOffset, ta.byteLength / 2);
+}
+function asInt32(x) {
+  if (x instanceof Int32Array) return x;
+  const ta = x;
+  return new Int32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
+}
+function asUint8(x) {
+  if (x instanceof Uint8Array) return x;
+  const ta = x;
+  return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
+}
+function sanitizeFrameTimestamp(frame, nextUs, fallbackTimeBase) {
+  const lo = frame.pts ?? 0;
+  const hi = frame.ptshi ?? 0;
+  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
+  if (isInvalid) {
+    const us2 = nextUs();
+    frame.pts = us2;
+    frame.ptshi = 0;
+    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) {
+    frame.pts = us;
+    frame.ptshi = us < 0 ? -1 : 0;
+    return;
+  }
+  const fallback = nextUs();
+  frame.pts = fallback;
+  frame.ptshi = 0;
+}
+
 // src/strategies/hybrid/decoder.ts
 async function startHybridDecoder(opts) {
   const variant = pickLibavVariant(opts.context);
   const libav = await loadLibav(variant);
   const bridge = await loadBridge();
   const { prepareLibavInput: prepareLibavInput2 } = await Promise.resolve().then(() => (init_libav_http_reader(), libav_http_reader_exports));
-  const inputHandle = await prepareLibavInput2(libav, opts.filename, opts.source);
+  const inputHandle = await prepareLibavInput2(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;
-  const audioStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
+  const firstAudioTrackId = opts.context.audioTracks[0]?.id;
+  let audioStream = (firstAudioTrackId != null ? streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO && s.index === firstAudioTrackId) : void 0) ?? streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
   if (!videoStream && !audioStream) {
     throw new Error("hybrid decoder: file has no decodable streams");
   }
@@ -32525,6 +33227,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();
+        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;
@@ -32552,8 +33304,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;
@@ -32573,9 +33332,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));
@@ -32598,20 +33354,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(
@@ -32648,6 +33427,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 {
@@ -32669,6 +33456,71 @@ async function startHybridDecoder(opts) {
       } catch {
       }
     },
+    async setAudioTrack(trackId, timeSec) {
+      if (audioStream && audioStream.index === trackId) return;
+      const newStream = streams.find(
+        (s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO && s.index === trackId
+      );
+      if (!newStream) {
+        console.warn("[avbridge] hybrid: setAudioTrack \u2014 no stream with id", trackId);
+        return;
+      }
+      const newToken = ++pumpToken;
+      if (pumpRunning) {
+        try {
+          await pumpRunning;
+        } catch {
+        }
+      }
+      if (destroyed) return;
+      if (audioDec) {
+        try {
+          await libav.ff_free_decoder?.(audioDec.c, audioDec.pkt, audioDec.frame);
+        } catch {
+        }
+        audioDec = null;
+      }
+      try {
+        const [, c, pkt, frame] = await libav.ff_init_decoder(newStream.codec_id, {
+          codecpar: newStream.codecpar
+        });
+        audioDec = { c, pkt, frame };
+        audioTimeBase = newStream.time_base_num && newStream.time_base_den ? [newStream.time_base_num, newStream.time_base_den] : void 0;
+      } catch (err) {
+        console.warn(
+          "[avbridge] hybrid: setAudioTrack init failed \u2014 switching to no-audio:",
+          err.message
+        );
+        audioDec = null;
+        opts.audio.setNoAudio();
+      }
+      audioStream = newStream;
+      try {
+        const tsUs = Math.floor(timeSec * 1e6);
+        const [tsLo, tsHi] = libav.f64toi64 ? libav.f64toi64(tsUs) : [tsUs | 0, Math.floor(tsUs / 4294967296)];
+        await libav.av_seek_frame(
+          fmt_ctx,
+          -1,
+          tsLo,
+          tsHi,
+          libav.AVSEEK_FLAG_BACKWARD ?? 0
+        );
+      } catch (err) {
+        console.warn("[avbridge] hybrid: setAudioTrack seek failed:", err);
+      }
+      try {
+        if (videoDecoder && videoDecoder.state === "configured") {
+          await videoDecoder.flush();
+        }
+      } catch {
+      }
+      await flushBSF();
+      syntheticVideoUs = Math.round(timeSec * 1e6);
+      syntheticAudioUs = Math.round(timeSec * 1e6);
+      pumpRunning = pumpLoop(newToken).catch(
+        (err) => console.error("[avbridge] hybrid pump failed (post-setAudioTrack):", err)
+      );
+    },
     async seek(timeSec) {
       const newToken = ++pumpToken;
       if (pumpRunning) {
@@ -32701,6 +33553,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(
@@ -32714,6 +33567,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",
@@ -32724,158 +33578,6 @@ async function startHybridDecoder(opts) {
     }
   };
 }
-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;
-  }
-  const fallback = nextUs();
-  pkt.pts = fallback;
-  pkt.ptshi = 0;
-  pkt.time_base_num = 1;
-  pkt.time_base_den = 1e6;
-}
-function sanitizeFrameTimestamp(frame, nextUs, fallbackTimeBase) {
-  const lo = frame.pts ?? 0;
-  const hi = frame.ptshi ?? 0;
-  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
-  if (isInvalid) {
-    const us2 = nextUs();
-    frame.pts = us2;
-    frame.ptshi = 0;
-    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) {
-    frame.pts = us;
-    frame.ptshi = us < 0 ? -1 : 0;
-    return;
-  }
-  const fallback = nextUs();
-  frame.pts = fallback;
-  frame.ptshi = 0;
-}
-var AV_SAMPLE_FMT_U8 = 0;
-var AV_SAMPLE_FMT_S16 = 1;
-var AV_SAMPLE_FMT_S32 = 2;
-var AV_SAMPLE_FMT_FLT = 3;
-var AV_SAMPLE_FMT_U8P = 5;
-var AV_SAMPLE_FMT_S16P = 6;
-var AV_SAMPLE_FMT_S32P = 7;
-var AV_SAMPLE_FMT_FLTP = 8;
-function libavFrameToInterleavedFloat32(frame) {
-  const channels = frame.channels ?? frame.ch_layout_nb_channels ?? 1;
-  const sampleRate = frame.sample_rate ?? 44100;
-  const nbSamples = frame.nb_samples ?? 0;
-  if (nbSamples === 0) return null;
-  const out = new Float32Array(nbSamples * channels);
-  switch (frame.format) {
-    case AV_SAMPLE_FMT_FLTP: {
-      const planes = ensurePlanes(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asFloat32(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i];
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_FLT: {
-      const flat = asFloat32(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i];
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S16P: {
-      const planes = ensurePlanes(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asInt16(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 32768;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S16: {
-      const flat = asInt16(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 32768;
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S32P: {
-      const planes = ensurePlanes(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asInt32(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 2147483648;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S32: {
-      const flat = asInt32(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 2147483648;
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_U8P: {
-      const planes = ensurePlanes(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asUint8(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = (plane[i] - 128) / 128;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_U8: {
-      const flat = asUint8(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = (flat[i] - 128) / 128;
-      return { data: out, channels, sampleRate };
-    }
-    default:
-      return null;
-  }
-}
-function ensurePlanes(data, channels) {
-  if (Array.isArray(data)) return data;
-  const arr = data;
-  const len = arr.length;
-  const perChannel = Math.floor(len / channels);
-  const planes = [];
-  for (let ch = 0; ch < channels; ch++) {
-    planes.push(arr.subarray ? arr.subarray(ch * perChannel, (ch + 1) * perChannel) : arr);
-  }
-  return planes;
-}
-function asFloat32(x) {
-  if (x instanceof Float32Array) return x;
-  const ta = x;
-  return new Float32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
-}
-function asInt16(x) {
-  if (x instanceof Int16Array) return x;
-  const ta = x;
-  return new Int16Array(ta.buffer, ta.byteOffset, ta.byteLength / 2);
-}
-function asInt32(x) {
-  if (x instanceof Int32Array) return x;
-  const ta = x;
-  return new Int32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
-}
-function asUint8(x) {
-  if (x instanceof Uint8Array) return x;
-  const ta = x;
-  return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
-}
 async function loadBridge() {
   try {
     const wrapper = await Promise.resolve().then(() => (init_libav_import(), libav_import_exports));
@@ -32890,7 +33592,7 @@ 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) {
+async function createHybridSession(ctx, target, transport) {
   const { normalizeSource: normalizeSource2 } = await Promise.resolve().then(() => (init_source(), source_exports));
   const source = await normalizeSource2(ctx.source);
   const fps = ctx.videoTracks[0]?.fps ?? 30;
@@ -32903,7 +33605,8 @@ async function createHybridSession(ctx, target) {
       filename: ctx.name ?? "input.bin",
       context: ctx,
       renderer,
-      audio
+      audio,
+      transport
     });
   } catch (err) {
     audio.destroy();
@@ -32921,6 +33624,22 @@ async function createHybridSession(ctx, target) {
     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,
@@ -32960,15 +33679,35 @@ 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);
     },
-    async setAudioTrack(_id) {
+    async setAudioTrack(id) {
+      if (!ctx.audioTracks.some((t) => t.id === id)) {
+        console.warn("[avbridge] hybrid: setAudioTrack \u2014 unknown track id", id);
+        return;
+      }
+      const wasPlaying = audio.isPlaying();
+      const currentTime = audio.now();
+      await audio.pause().catch(() => {
+      });
+      await handles.setAudioTrack(id, currentTime).catch(
+        (err) => console.warn("[avbridge] hybrid: handles.setAudioTrack failed:", err)
+      );
+      await audio.reset(currentTime);
+      renderer.flush();
+      if (wasPlaying) {
+        await waitForBuffer();
+        await audio.start();
+      }
     },
     async setSubtitleTrack(_id) {
     },
@@ -32986,6 +33725,8 @@ async function createHybridSession(ctx, target) {
         delete target.currentTime;
         delete target.duration;
         delete target.paused;
+        delete target.volume;
+        delete target.muted;
       } catch {
       }
     },
@@ -32997,16 +33738,18 @@ async function createHybridSession(ctx, target) {
 
 // src/strategies/fallback/decoder.ts
 init_libav_loader();
+init_debug();
 async function startDecoder(opts) {
   const variant = pickLibavVariant(opts.context);
   const libav = await loadLibav(variant);
   const bridge = await loadBridge2();
   const { prepareLibavInput: prepareLibavInput2 } = await Promise.resolve().then(() => (init_libav_http_reader(), libav_http_reader_exports));
-  const inputHandle = await prepareLibavInput2(libav, opts.filename, opts.source);
+  const inputHandle = await prepareLibavInput2(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;
-  const audioStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
+  const firstAudioTrackId = opts.context.audioTracks[0]?.id;
+  let audioStream = (firstAudioTrackId != null ? streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO && s.index === firstAudioTrackId) : void 0) ?? streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
   if (!videoStream && !audioStream) {
     throw new Error("fallback decoder: file has no decodable streams");
   }
@@ -33058,6 +33801,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();
+        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;
@@ -33093,7 +33886,8 @@ async function startDecoder(opts) {
       }
       if (myToken !== pumpToken || destroyed) return;
       if (videoDec && videoPackets && videoPackets.length > 0) {
-        await decodeVideoBatch(videoPackets, myToken);
+        const processed = await applyBSF(videoPackets);
+        await decodeVideoBatch(processed, myToken);
       }
       packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
       if (videoFramesDecoded > 0) {
@@ -33171,7 +33965,7 @@ async function startDecoder(opts) {
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
-      const bridgeOpts = sanitizeFrameTimestamp2(
+      sanitizeFrameTimestamp(
         f,
         () => {
           const ts = syntheticVideoUs;
@@ -33181,7 +33975,7 @@ async function startDecoder(opts) {
         videoTimeBase
       );
       try {
-        const vf = bridge.laFrameToVideoFrame(f, bridgeOpts);
+        const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
         opts.renderer.enqueue(vf);
         videoFramesDecoded++;
       } catch (err) {
@@ -33209,7 +34003,7 @@ async function startDecoder(opts) {
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
-      sanitizeFrameTimestamp2(
+      sanitizeFrameTimestamp(
         f,
         () => {
           const ts = syntheticAudioUs;
@@ -33220,7 +34014,7 @@ async function startDecoder(opts) {
         },
         audioTimeBase
       );
-      const samples = libavFrameToInterleavedFloat322(f);
+      const samples = libavFrameToInterleavedFloat32(f);
       if (samples) {
         opts.audio.schedule(samples.data, samples.channels, samples.sampleRate);
         audioFramesDecoded++;
@@ -33239,6 +34033,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 {
@@ -33260,6 +34062,69 @@ async function startDecoder(opts) {
       } catch {
       }
     },
+    async setAudioTrack(trackId, timeSec) {
+      if (audioStream && audioStream.index === trackId) return;
+      const newStream = streams.find(
+        (s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO && s.index === trackId
+      );
+      if (!newStream) {
+        console.warn("[avbridge] fallback: setAudioTrack \u2014 no stream with id", trackId);
+        return;
+      }
+      const newToken = ++pumpToken;
+      if (pumpRunning) {
+        try {
+          await pumpRunning;
+        } catch {
+        }
+      }
+      if (destroyed) return;
+      if (audioDec) {
+        try {
+          await libav.ff_free_decoder?.(audioDec.c, audioDec.pkt, audioDec.frame);
+        } catch {
+        }
+        audioDec = null;
+      }
+      try {
+        const [, c, pkt, frame] = await libav.ff_init_decoder(newStream.codec_id, {
+          codecpar: newStream.codecpar
+        });
+        audioDec = { c, pkt, frame };
+        audioTimeBase = newStream.time_base_num && newStream.time_base_den ? [newStream.time_base_num, newStream.time_base_den] : void 0;
+      } catch (err) {
+        console.warn(
+          "[avbridge] fallback: setAudioTrack init failed \u2014 falling back to no-audio mode:",
+          err.message
+        );
+        audioDec = null;
+        opts.audio.setNoAudio();
+      }
+      audioStream = newStream;
+      try {
+        const tsUs = Math.floor(timeSec * 1e6);
+        const [tsLo, tsHi] = libav.f64toi64 ? libav.f64toi64(tsUs) : [tsUs | 0, Math.floor(tsUs / 4294967296)];
+        await libav.av_seek_frame(
+          fmt_ctx,
+          -1,
+          tsLo,
+          tsHi,
+          libav.AVSEEK_FLAG_BACKWARD ?? 0
+        );
+      } catch (err) {
+        console.warn("[avbridge] fallback: setAudioTrack seek failed:", err);
+      }
+      try {
+        if (videoDec) await libav.avcodec_flush_buffers?.(videoDec.c);
+      } catch {
+      }
+      await flushBSF();
+      syntheticVideoUs = Math.round(timeSec * 1e6);
+      syntheticAudioUs = Math.round(timeSec * 1e6);
+      pumpRunning = pumpLoop(newToken).catch(
+        (err) => console.error("[avbridge] fallback pump failed (post-setAudioTrack):", err)
+      );
+    },
     async seek(timeSec) {
       const newToken = ++pumpToken;
       if (pumpRunning) {
@@ -33290,6 +34155,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(
@@ -33302,6 +34168,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
@@ -33314,135 +34181,6 @@ async function startDecoder(opts) {
     }
   };
 }
-function sanitizeFrameTimestamp2(frame, nextUs, fallbackTimeBase) {
-  const lo = frame.pts ?? 0;
-  const hi = frame.ptshi ?? 0;
-  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
-  if (isInvalid) {
-    const us2 = nextUs();
-    frame.pts = us2;
-    frame.ptshi = 0;
-    return { timeBase: [1, 1e6] };
-  }
-  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) {
-    frame.pts = us;
-    frame.ptshi = us < 0 ? -1 : 0;
-    return { timeBase: [1, 1e6] };
-  }
-  const fallback = nextUs();
-  frame.pts = fallback;
-  frame.ptshi = 0;
-  return { timeBase: [1, 1e6] };
-}
-var AV_SAMPLE_FMT_U82 = 0;
-var AV_SAMPLE_FMT_S162 = 1;
-var AV_SAMPLE_FMT_S322 = 2;
-var AV_SAMPLE_FMT_FLT2 = 3;
-var AV_SAMPLE_FMT_U8P2 = 5;
-var AV_SAMPLE_FMT_S16P2 = 6;
-var AV_SAMPLE_FMT_S32P2 = 7;
-var AV_SAMPLE_FMT_FLTP2 = 8;
-function libavFrameToInterleavedFloat322(frame) {
-  const channels = frame.channels ?? frame.ch_layout_nb_channels ?? 1;
-  const sampleRate = frame.sample_rate ?? 44100;
-  const nbSamples = frame.nb_samples ?? 0;
-  if (nbSamples === 0) return null;
-  const out = new Float32Array(nbSamples * channels);
-  switch (frame.format) {
-    case AV_SAMPLE_FMT_FLTP2: {
-      const planes = ensurePlanes2(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asFloat322(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i];
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_FLT2: {
-      const flat = asFloat322(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i];
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S16P2: {
-      const planes = ensurePlanes2(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asInt162(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 32768;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S162: {
-      const flat = asInt162(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 32768;
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S32P2: {
-      const planes = ensurePlanes2(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asInt322(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = plane[i] / 2147483648;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_S322: {
-      const flat = asInt322(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = flat[i] / 2147483648;
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_U8P2: {
-      const planes = ensurePlanes2(frame.data, channels);
-      for (let ch = 0; ch < channels; ch++) {
-        const plane = asUint82(planes[ch]);
-        for (let i = 0; i < nbSamples; i++) out[i * channels + ch] = (plane[i] - 128) / 128;
-      }
-      return { data: out, channels, sampleRate };
-    }
-    case AV_SAMPLE_FMT_U82: {
-      const flat = asUint82(frame.data);
-      for (let i = 0; i < nbSamples * channels; i++) out[i] = (flat[i] - 128) / 128;
-      return { data: out, channels, sampleRate };
-    }
-    default:
-      if (!globalThis.__avbridgeLoggedSampleFmt) {
-        globalThis.__avbridgeLoggedSampleFmt = frame.format;
-        console.warn(`[avbridge] unsupported audio sample format from libav: ${frame.format}`);
-      }
-      return null;
-  }
-}
-function ensurePlanes2(data, channels) {
-  if (Array.isArray(data)) return data;
-  const arr = data;
-  const len = arr.length;
-  const perChannel = Math.floor(len / channels);
-  const planes = [];
-  for (let ch = 0; ch < channels; ch++) {
-    planes.push(arr.subarray ? arr.subarray(ch * perChannel, (ch + 1) * perChannel) : arr);
-  }
-  return planes;
-}
-function asFloat322(x) {
-  if (x instanceof Float32Array) return x;
-  const ta = x;
-  return new Float32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
-}
-function asInt162(x) {
-  if (x instanceof Int16Array) return x;
-  const ta = x;
-  return new Int16Array(ta.buffer, ta.byteOffset, ta.byteLength / 2);
-}
-function asInt322(x) {
-  if (x instanceof Int32Array) return x;
-  const ta = x;
-  return new Int32Array(ta.buffer, ta.byteOffset, ta.byteLength / 4);
-}
-function asUint82(x) {
-  if (x instanceof Uint8Array) return x;
-  const ta = x;
-  return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
-}
 async function loadBridge2() {
   try {
     const wrapper = await Promise.resolve().then(() => (init_libav_import(), libav_import_exports));
@@ -33458,7 +34196,7 @@ async function loadBridge2() {
 init_debug();
 var READY_AUDIO_BUFFER_SECONDS2 = 0.04;
 var READY_TIMEOUT_SECONDS2 = 3;
-async function createFallbackSession(ctx, target) {
+async function createFallbackSession(ctx, target, transport) {
   const { normalizeSource: normalizeSource2 } = await Promise.resolve().then(() => (init_source(), source_exports));
   const source = await normalizeSource2(ctx.source);
   const fps = ctx.videoTracks[0]?.fps ?? 30;
@@ -33471,7 +34209,8 @@ async function createFallbackSession(ctx, target) {
       filename: ctx.name ?? "input.bin",
       context: ctx,
       renderer,
-      audio
+      audio,
+      transport
     });
   } catch (err) {
     audio.destroy();
@@ -33489,6 +34228,22 @@ async function createFallbackSession(ctx, target) {
     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,
@@ -33552,15 +34307,35 @@ 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);
     },
-    async setAudioTrack(_id) {
+    async setAudioTrack(id) {
+      if (!ctx.audioTracks.some((t) => t.id === id)) {
+        console.warn("[avbridge] fallback: setAudioTrack \u2014 unknown track id", id);
+        return;
+      }
+      const wasPlaying = audio.isPlaying();
+      const currentTime = audio.now();
+      await audio.pause().catch(() => {
+      });
+      await handles.setAudioTrack(id, currentTime).catch(
+        (err) => console.warn("[avbridge] fallback: handles.setAudioTrack failed:", err)
+      );
+      await audio.reset(currentTime);
+      renderer.flush();
+      if (wasPlaying) {
+        await waitForBuffer();
+        await audio.start();
+      }
     },
     async setSubtitleTrack(_id) {
     },
@@ -33575,6 +34350,8 @@ async function createFallbackSession(ctx, target) {
         delete target.currentTime;
         delete target.duration;
         delete target.paused;
+        delete target.volume;
+        delete target.muted;
       } catch {
       }
     },
@@ -33598,12 +34375,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);
@@ -33612,120 +34389,10 @@ function registerBuiltins(registry) {
   registry.register(fallbackPlugin);
 }
 
-// src/subtitles/srt.ts
-function srtToVtt(srt) {
-  if (srt.charCodeAt(0) === 65279) srt = srt.slice(1);
-  const normalized = srt.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-  const blocks = normalized.split(/\n{2,}/);
-  const out = ["WEBVTT", ""];
-  for (const block of blocks) {
-    const lines = block.split("\n");
-    if (lines.length > 0 && /^\d+$/.test(lines[0].trim())) {
-      lines.shift();
-    }
-    if (lines.length === 0) continue;
-    const timing = lines.shift();
-    const vttTiming = convertTiming(timing);
-    if (!vttTiming) continue;
-    out.push(vttTiming);
-    for (const l of lines) out.push(l);
-    out.push("");
-  }
-  return out.join("\n");
-}
-function convertTiming(line) {
-  const m = /^(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})\s*-->\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})(.*)$/.exec(
-    line.trim()
-  );
-  if (!m) return null;
-  const fmt2 = (h, mm, s, ms) => `${h.padStart(2, "0")}:${mm}:${s}.${ms.padEnd(3, "0").slice(0, 3)}`;
-  return `${fmt2(m[1], m[2], m[3], m[4])} --> ${fmt2(m[5], m[6], m[7], m[8])}${m[9] ?? ""}`;
-}
-
-// src/subtitles/vtt.ts
-function isVtt(text) {
-  const trimmed = text.replace(/^\ufeff/, "").trimStart();
-  return trimmed.startsWith("WEBVTT");
-}
-
-// src/subtitles/index.ts
-async function discoverSidecars(file, directory) {
-  const baseName = file.name.replace(/\.[^.]+$/, "");
-  const found = [];
-  for await (const [name, handle] of directory) {
-    if (handle.kind !== "file") continue;
-    if (!name.startsWith(baseName)) continue;
-    const lower = name.toLowerCase();
-    let format = null;
-    if (lower.endsWith(".srt")) format = "srt";
-    else if (lower.endsWith(".vtt")) format = "vtt";
-    if (!format) continue;
-    const sidecarFile = await handle.getFile();
-    const url2 = URL.createObjectURL(sidecarFile);
-    const langMatch = name.slice(baseName.length).match(/[._-]([a-z]{2,3})(?:[._-]|\.)/i);
-    found.push({
-      url: url2,
-      format,
-      language: langMatch?.[1]
-    });
-  }
-  return found;
-}
-var SubtitleResourceBag = class {
-  urls = /* @__PURE__ */ new Set();
-  /** Track an externally-created blob URL (e.g. from `discoverSidecars`). */
-  track(url2) {
-    this.urls.add(url2);
-  }
-  /** Convenience: create a blob URL and track it in one call. */
-  createObjectURL(blob) {
-    const url2 = URL.createObjectURL(blob);
-    this.urls.add(url2);
-    return url2;
-  }
-  /** Revoke every tracked URL. Idempotent — safe to call multiple times. */
-  revokeAll() {
-    for (const u of this.urls) URL.revokeObjectURL(u);
-    this.urls.clear();
-  }
-};
-async function attachSubtitleTracks(video, tracks, bag, onError) {
-  for (const t of Array.from(video.querySelectorAll("track[data-avbridge]"))) {
-    t.remove();
-  }
-  for (const t of tracks) {
-    if (!t.sidecarUrl) continue;
-    try {
-      let url2 = t.sidecarUrl;
-      if (t.format === "srt") {
-        const res = await fetch(t.sidecarUrl);
-        const text = await res.text();
-        const vtt = srtToVtt(text);
-        const blob = new Blob([vtt], { type: "text/vtt" });
-        url2 = bag ? bag.createObjectURL(blob) : URL.createObjectURL(blob);
-      } else if (t.format === "vtt") {
-        const res = await fetch(t.sidecarUrl);
-        const text = await res.text();
-        if (!isVtt(text)) {
-          console.warn("[avbridge] subtitle missing WEBVTT header:", t.sidecarUrl);
-        }
-      }
-      const trackEl = document.createElement("track");
-      trackEl.kind = "subtitles";
-      trackEl.src = url2;
-      trackEl.srclang = t.language ?? "und";
-      trackEl.label = t.language ?? `Subtitle ${t.id}`;
-      trackEl.dataset.avbridge = "true";
-      video.appendChild(trackEl);
-    } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      onError?.(e, t);
-    }
-  }
-}
-
 // src/player.ts
+init_subtitles2();
 init_debug();
+init_errors();
 var UnifiedPlayer = class _UnifiedPlayer {
   /**
    * @internal Use {@link createPlayer} or {@link UnifiedPlayer.create} instead.
@@ -33733,6 +34400,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;
@@ -33752,11 +34423,23 @@ var UnifiedPlayer = class _UnifiedPlayer {
   // 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);
@@ -33780,7 +34463,7 @@ var UnifiedPlayer = class _UnifiedPlayer {
     const bootstrapStart = performance.now();
     try {
       dbg.info("bootstrap", "start");
-      const ctx = await dbg.timed("probe", "probe", 3e3, () => probe(this.options.source));
+      const ctx = await dbg.timed("probe", "probe", 3e3, () => probe(this.options.source, this.transport));
       dbg.info(
         "probe",
         `container=${ctx.container} video=${ctx.videoTracks[0]?.codec ?? "-"} audio=${ctx.audioTracks[0]?.codec ?? "-"} probedBy=${ctx.probedBy}`
@@ -33821,16 +34504,15 @@ var UnifiedPlayer = class _UnifiedPlayer {
         reason: decision.reason
       });
       await this.startSession(decision.strategy, decision.reason);
-      if (this.session.strategy !== "fallback" && this.session.strategy !== "hybrid") {
-        await attachSubtitleTracks(
-          this.options.target,
-          ctx.subtitleTracks,
-          this.subtitleResources,
-          (err, track) => {
-            console.warn(`[avbridge] subtitle ${track.id} failed: ${err.message}`);
-          }
-        );
-      }
+      await attachSubtitleTracks(
+        this.options.target,
+        ctx.subtitleTracks,
+        this.subtitleResources,
+        (err, track) => {
+          console.warn(`[avbridge] subtitle ${track.id} failed: ${err.message}`);
+        },
+        this.transport
+      );
       this.emitter.emitSticky("tracks", {
         video: ctx.videoTracks,
         audio: ctx.audioTracks,
@@ -33839,6 +34521,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       this.startTimeupdateLoop();
       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;
       dbg.info("bootstrap", `ready in ${bootstrapElapsed.toFixed(0)}ms`);
@@ -33865,7 +34551,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 chain2 = this.classification?.fallbackChain;
       if (chain2 && chain2.length > 0) {
@@ -33938,7 +34624,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}`);
@@ -33961,8 +34647,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       }
       return;
     }
-    this.emitter.emit("error", new Error(
-      `all fallback strategies failed: ${errors.join("; ")}`
+    this.emitter.emit("error", new AvbridgeError(
+      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 ─────────────────────────────────────────────────
@@ -34014,7 +34702,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 AvbridgeError(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)
@@ -34043,7 +34731,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
@@ -34077,26 +34765,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 AvbridgeError(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;
+      dbg.info("visibility", "tab hidden \u2014 auto-paused");
+      this.session.pause();
+    } else if (action === "resume") {
+      this.autoPausedForVisibility = false;
+      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 AvbridgeError(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 AvbridgeError(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 AvbridgeError(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. */
@@ -34128,6 +34846,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       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;
@@ -34139,6 +34861,14 @@ 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);
@@ -34249,6 +34979,13 @@ var AvbridgeVideoElement = class extends HTMLElementCtor {
   _strategyClass = null;
   _audioTracks = [];
   _subtitleTracks = [];
+  /**
+   * External subtitle list forwarded to `createPlayer()` on the next
+   * bootstrap. Setting this after bootstrap queues it for the next
+   * source change; consumers that need to swap subtitles mid-playback
+   * should set `source` to reload.
+   */
+  _subtitles = null;
   /**
    * Initial strategy preference. `"auto"` means "let the classifier decide";
    * any other value is passed to `createPlayer({ initialStrategy })` and
@@ -34404,7 +35141,8 @@ var AvbridgeVideoElement = class extends HTMLElementCtor {
         // Honor the consumer's preferred initial strategy. "auto" means
         // "let the classifier decide" — the createPlayer call simply doesn't
         // pass initialStrategy in that case.
-        ...this._preferredStrategy !== "auto" ? { initialStrategy: this._preferredStrategy } : {}
+        ...this._preferredStrategy !== "auto" ? { initialStrategy: this._preferredStrategy } : {},
+        ...this._subtitles ? { subtitles: this._subtitles } : {}
       });
     } catch (err) {
       if (id !== this._bootstrapId || this._destroyed) return;
@@ -34695,6 +35433,47 @@ var AvbridgeVideoElement = class extends HTMLElementCtor {
   get subtitleTracks() {
     return this._subtitleTracks;
   }
+  /**
+   * External subtitle files to attach when the source loads. Takes effect
+   * on the next bootstrap — set before assigning `source`, or reload via
+   * `load()` after changing. For dynamic post-bootstrap addition, use
+   * `addSubtitle()` instead.
+   *
+   * @example
+   * el.subtitles = [{ url: "/en.srt", format: "srt", language: "en" }];
+   * el.src = "/movie.mp4";
+   */
+  get subtitles() {
+    return this._subtitles;
+  }
+  set subtitles(value) {
+    this._subtitles = value;
+  }
+  /**
+   * Attach a subtitle track to the current playback without rebuilding
+   * the player. Works while the element is playing — converts SRT to
+   * VTT if needed, adds a `<track>` to the inner `<video>`. Canvas
+   * strategies pick up the new track via their textTracks watcher.
+   */
+  async addSubtitle(subtitle) {
+    const { attachSubtitleTracks: attachSubtitleTracks2 } = await Promise.resolve().then(() => (init_subtitles2(), subtitles_exports));
+    const format = subtitle.format ?? (subtitle.url.endsWith(".srt") ? "srt" : "vtt");
+    const track = {
+      id: this._subtitleTracks.length,
+      format,
+      language: subtitle.language,
+      sidecarUrl: subtitle.url
+    };
+    this._subtitleTracks.push(track);
+    await attachSubtitleTracks2(
+      this._videoEl,
+      this._subtitleTracks,
+      void 0,
+      (err, t) => {
+        console.warn(`[avbridge] subtitle ${t.id} failed: ${err.message}`);
+      }
+    );
+  }
   // ── Public methods ─────────────────────────────────────────────────────
   /** Force a (re-)bootstrap if a source is currently set. */
   async load() {