avbridge 1.0.0

package/dist/chunk-FKM7QBZU.js

@@ -0,0 +1,2957 @@
+import { normalizeSource, sniffNormalizedSource } from './chunk-PQTZS7OA.js';
+import { loadLibav } from './chunk-5ISVAODK.js';
+import { pickLibavVariant } from './chunk-J5MCMN3S.js';
+
+// src/probe/mediabunny.ts
+async function probeWithMediabunny(source, sniffedContainer) {
+  const mb = await import('mediabunny');
+  const input = new mb.Input({
+    source: await buildMediabunnySource(mb, source),
+    formats: mb.ALL_FORMATS
+  });
+  const allTracks = await input.getTracks();
+  const duration = await safeNumber(() => input.computeDuration());
+  const videoTracks = [];
+  const audioTracks = [];
+  for (const track of allTracks) {
+    if (track.isVideoTrack()) {
+      const codecParam = await safe(() => track.getCodecParameterString());
+      videoTracks.push({
+        id: track.id,
+        codec: mediabunnyVideoToAvbridge(track.codec),
+        width: track.displayWidth ?? track.codedWidth ?? 0,
+        height: track.displayHeight ?? track.codedHeight ?? 0,
+        codecString: codecParam ?? void 0
+      });
+    } else if (track.isAudioTrack()) {
+      const codecParam = await safe(() => track.getCodecParameterString());
+      audioTracks.push({
+        id: track.id,
+        codec: mediabunnyAudioToAvbridge(track.codec),
+        channels: track.numberOfChannels ?? 0,
+        sampleRate: track.sampleRate ?? 0,
+        language: track.languageCode,
+        codecString: codecParam ?? void 0
+      });
+    }
+  }
+  const format = await safe(() => input.getFormat());
+  const container = resolveContainer(format?.name, sniffedContainer);
+  return {
+    source: source.original,
+    name: source.name,
+    byteLength: source.byteLength,
+    container,
+    videoTracks,
+    audioTracks,
+    subtitleTracks: [],
+    probedBy: "mediabunny",
+    duration
+  };
+}
+async function buildMediabunnySource(mb, source) {
+  if (source.kind === "url") {
+    return new mb.UrlSource(source.url);
+  }
+  return new mb.BlobSource(source.blob);
+}
+async function buildMediabunnySourceFromInput(mb, source) {
+  if (typeof source === "string") return new mb.UrlSource(source);
+  if (source instanceof URL) return new mb.UrlSource(source.toString());
+  if (source instanceof Blob) return new mb.BlobSource(source);
+  if (source instanceof ArrayBuffer) return new mb.BlobSource(new Blob([source]));
+  if (source instanceof Uint8Array) return new mb.BlobSource(new Blob([source]));
+  throw new TypeError("unsupported source type for mediabunny");
+}
+function resolveContainer(formatName, sniffed) {
+  const name = (formatName ?? "").toLowerCase();
+  if (name.includes("matroska") || name.includes("mkv")) return "mkv";
+  if (name.includes("webm")) return "webm";
+  if (name.includes("mp4") || name.includes("isom")) return "mp4";
+  if (name.includes("mov") || name.includes("quicktime")) return "mov";
+  if (name.includes("ogg")) return "ogg";
+  if (name.includes("wav")) return "wav";
+  if (name.includes("flac")) return "flac";
+  if (name.includes("mp3")) return "mp3";
+  if (name.includes("adts") || name.includes("aac")) return "adts";
+  if (name.includes("mpegts") || name.includes("mpeg-ts") || name.includes("transport")) return "mpegts";
+  return sniffed;
+}
+function mediabunnyVideoToAvbridge(c) {
+  switch (c) {
+    case "avc":
+      return "h264";
+    case "hevc":
+      return "h265";
+    case "vp8":
+      return "vp8";
+    case "vp9":
+      return "vp9";
+    case "av1":
+      return "av1";
+    default:
+      return "h264";
+  }
+}
+function avbridgeVideoToMediabunny(c) {
+  switch (c) {
+    case "h264":
+      return "avc";
+    case "h265":
+      return "hevc";
+    case "vp8":
+      return "vp8";
+    case "vp9":
+      return "vp9";
+    case "av1":
+      return "av1";
+    default:
+      return null;
+  }
+}
+function mediabunnyAudioToAvbridge(c) {
+  switch (c) {
+    case "aac":
+      return "aac";
+    case "mp3":
+      return "mp3";
+    case "opus":
+      return "opus";
+    case "vorbis":
+      return "vorbis";
+    case "flac":
+      return "flac";
+    case "ac3":
+      return "ac3";
+    case "eac3":
+      return "eac3";
+    default:
+      return c ?? "aac";
+  }
+}
+function avbridgeAudioToMediabunny(c) {
+  switch (c) {
+    case "aac":
+      return "aac";
+    case "mp3":
+      return "mp3";
+    case "opus":
+      return "opus";
+    case "vorbis":
+      return "vorbis";
+    case "flac":
+      return "flac";
+    case "ac3":
+      return "ac3";
+    case "eac3":
+      return "eac3";
+    default:
+      return null;
+  }
+}
+async function safeNumber(fn) {
+  try {
+    const v = await fn();
+    return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function safe(fn) {
+  try {
+    return await fn();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/probe/index.ts
+var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
+  "mp4",
+  "mov",
+  "mkv",
+  "webm",
+  "ogg",
+  "wav",
+  "mp3",
+  "flac",
+  "adts",
+  "mpegts"
+]);
+async function probe(source) {
+  const normalized = await normalizeSource(source);
+  const sniffed = await sniffNormalizedSource(normalized);
+  if (MEDIABUNNY_CONTAINERS.has(sniffed)) {
+    try {
+      return await probeWithMediabunny(normalized, sniffed);
+    } catch (err) {
+      throw new Error(
+        `mediabunny failed to probe a ${sniffed} file: ${err.message}`
+      );
+    }
+  }
+  try {
+    const { probeWithLibav } = await import('./avi-POCGZ4JX.js');
+    return await probeWithLibav(normalized, sniffed);
+  } catch (err) {
+    const inner = err instanceof Error ? err.message : String(err);
+    console.error("[avbridge] libav probe failed for", sniffed, "file:", err);
+    throw new Error(
+      sniffed === "unknown" ? `unable to probe source: container could not be identified, and the libav.js fallback also failed: ${inner || "(no message \u2014 see browser console for the original error)"}` : `${sniffed.toUpperCase()} files require libav.js, which failed to load: ${inner || "(no message \u2014 see browser console for the original error)"}`
+    );
+  }
+}
+
+// src/util/codec-strings.ts
+function videoCodecString(track) {
+  if (track.codecString) return track.codecString;
+  switch (track.codec) {
+    case "h264": {
+      const profileHex = profileToHex(track.profile) ?? "64";
+      const constraint = "00";
+      const level = ((track.level ?? 40) & 255).toString(16).padStart(2, "0");
+      return `avc1.${profileHex}${constraint}${level}`;
+    }
+    case "h265":
+      return "hvc1.1.6.L93.B0";
+    case "vp8":
+      return "vp8";
+    case "vp9":
+      return "vp09.00.10.08";
+    case "av1":
+      return "av01.0.04M.08";
+    default:
+      return null;
+  }
+}
+function profileToHex(profile) {
+  if (!profile) return null;
+  const p = profile.toLowerCase();
+  if (p.includes("baseline")) return "42";
+  if (p.includes("main")) return "4d";
+  if (p.includes("high 10")) return "6e";
+  if (p.includes("high 4:2:2")) return "7a";
+  if (p.includes("high 4:4:4")) return "f4";
+  if (p.includes("high")) return "64";
+  return null;
+}
+function audioCodecString(track) {
+  if (track.codecString) return track.codecString;
+  switch (track.codec) {
+    case "aac":
+      return "mp4a.40.2";
+    // AAC-LC
+    case "mp3":
+      return "mp4a.40.34";
+    case "opus":
+      return "opus";
+    case "vorbis":
+      return "vorbis";
+    case "flac":
+      return "flac";
+    default:
+      return null;
+  }
+}
+function mp4MimeFor(video, audio) {
+  const v = videoCodecString(video);
+  if (!v) return null;
+  const codecs = audio ? `${v},${audioCodecString(audio) ?? ""}`.replace(/,$/, "") : v;
+  return `video/mp4; codecs="${codecs}"`;
+}
+function mseSupports(mime) {
+  if (typeof MediaSource === "undefined") return false;
+  try {
+    return MediaSource.isTypeSupported(mime);
+  } catch {
+    return false;
+  }
+}
+
+// src/classify/rules.ts
+var NATIVE_VIDEO_CODECS = /* @__PURE__ */ new Set(["h264", "h265", "vp8", "vp9", "av1"]);
+var NATIVE_AUDIO_CODECS = /* @__PURE__ */ new Set([
+  "aac",
+  "mp3",
+  "opus",
+  "vorbis",
+  "flac"
+]);
+var FALLBACK_VIDEO_CODECS = /* @__PURE__ */ new Set(["wmv3", "vc1", "mpeg4", "rv40", "mpeg2", "mpeg1", "theora"]);
+var FALLBACK_AUDIO_CODECS = /* @__PURE__ */ new Set(["wmav2", "wmapro", "ac3", "eac3"]);
+var NATIVE_CONTAINERS = /* @__PURE__ */ new Set([
+  "mp4",
+  "mov",
+  "webm",
+  "ogg",
+  "wav",
+  "mp3",
+  "flac",
+  "adts"
+]);
+var REMUXABLE_CONTAINERS = /* @__PURE__ */ new Set([
+  "mp4",
+  "mov",
+  "mkv",
+  "webm",
+  "ogg",
+  "wav",
+  "mp3",
+  "flac",
+  "adts",
+  "mpegts"
+]);
+function classifyContext(ctx) {
+  const video = ctx.videoTracks[0];
+  const audio = ctx.audioTracks[0];
+  if (!video) {
+    if (NATIVE_CONTAINERS.has(ctx.container) && (!audio || NATIVE_AUDIO_CODECS.has(audio.codec))) {
+      return {
+        class: "NATIVE",
+        strategy: "native",
+        reason: `audio-only ${ctx.container} with native codec`
+      };
+    }
+    if (audio && FALLBACK_AUDIO_CODECS.has(audio.codec)) {
+      return {
+        class: "FALLBACK_REQUIRED",
+        strategy: "fallback",
+        reason: `audio codec "${audio.codec}" requires WASM decode`
+      };
+    }
+    if (REMUXABLE_CONTAINERS.has(ctx.container)) {
+      return {
+        class: "REMUX_CANDIDATE",
+        strategy: "remux",
+        reason: `audio-only file in non-native container "${ctx.container}"`
+      };
+    }
+    return {
+      class: "FALLBACK_REQUIRED",
+      strategy: "fallback",
+      reason: `audio-only file in "${ctx.container}" (not remuxable by mediabunny)`
+    };
+  }
+  if (FALLBACK_VIDEO_CODECS.has(video.codec)) {
+    return {
+      class: "FALLBACK_REQUIRED",
+      strategy: "fallback",
+      reason: `video codec "${video.codec}" has no browser decoder; WASM fallback required`
+    };
+  }
+  if (audio && FALLBACK_AUDIO_CODECS.has(audio.codec)) {
+    return {
+      class: "FALLBACK_REQUIRED",
+      strategy: "fallback",
+      reason: `audio codec "${audio.codec}" has no browser decoder; WASM fallback required`
+    };
+  }
+  if (!NATIVE_VIDEO_CODECS.has(video.codec)) {
+    return {
+      class: "FALLBACK_REQUIRED",
+      strategy: "fallback",
+      reason: `unknown video codec "${video.codec}", routing to fallback`
+    };
+  }
+  const isNativeContainer = NATIVE_CONTAINERS.has(ctx.container);
+  if (isNativeContainer && isSafeNativeCombo(video, audio)) {
+    const mime = mp4MimeFor(video, audio);
+    if (mime && mseSupports(mime)) {
+      return {
+        class: "NATIVE",
+        strategy: "native",
+        reason: `${ctx.container} + ${video.codec}${audio ? "/" + audio.codec : ""} plays natively`
+      };
+    }
+    if (mime == null || typeof MediaSource === "undefined") {
+      return {
+        class: "NATIVE",
+        strategy: "native",
+        reason: `${ctx.container} + ${video.codec}${audio ? "/" + audio.codec : ""} (heuristic native)`
+      };
+    }
+  }
+  if (isNativeContainer && isRiskyNative(video)) {
+    return {
+      class: "RISKY_NATIVE",
+      strategy: "native",
+      reason: `${video.codec} ${video.profile ?? ""} ${video.bitDepth ?? 8}-bit may stutter on mobile; will escalate to remux on stall`,
+      fallbackChain: ["remux", "hybrid", "fallback"]
+    };
+  }
+  if (REMUXABLE_CONTAINERS.has(ctx.container)) {
+    return {
+      class: "REMUX_CANDIDATE",
+      strategy: "remux",
+      reason: `${ctx.container} container with native-supported codecs \u2014 remux to fragmented MP4 for reliable playback`
+    };
+  }
+  if (webCodecsAvailable()) {
+    return {
+      class: "HYBRID_CANDIDATE",
+      strategy: "hybrid",
+      reason: `${ctx.container} container requires libav demux; codecs (${video.codec}${audio ? "/" + audio.codec : ""}) are hardware-decodable via WebCodecs`,
+      fallbackChain: ["fallback"]
+    };
+  }
+  return {
+    class: "FALLBACK_REQUIRED",
+    strategy: "fallback",
+    reason: `${ctx.container} container cannot be remuxed by mediabunny; falling back to WASM decode (${video.codec}${audio ? "/" + audio.codec : ""})`
+  };
+}
+function webCodecsAvailable() {
+  return typeof globalThis.VideoDecoder !== "undefined";
+}
+function isSafeNativeCombo(video, audio) {
+  if (video.codec === "h264") {
+    if (video.bitDepth && video.bitDepth > 8) return false;
+    if (video.pixelFormat && !/yuv420p$/.test(video.pixelFormat)) return false;
+  }
+  if (audio && !NATIVE_AUDIO_CODECS.has(audio.codec)) return false;
+  return true;
+}
+function isRiskyNative(video) {
+  if (video.bitDepth && video.bitDepth > 8) return true;
+  if (video.pixelFormat && /yuv4(2[24]|44)/.test(video.pixelFormat)) return true;
+  if (video.width > 3840 || video.height > 2160) return true;
+  if (video.fps && video.fps > 60) return true;
+  return false;
+}
+
+// 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 fmt = (h, mm, s, ms) => `${h.padStart(2, "0")}:${mm}:${s}.${ms.padEnd(3, "0").slice(0, 3)}`;
+  return `${fmt(m[1], m[2], m[3], m[4])} --> ${fmt(m[5], m[6], m[7], m[8])}${m[9] ?? ""}`;
+}
+
+// src/events.ts
+var TypedEmitter = class {
+  listeners = {};
+  sticky = {};
+  on(event, fn) {
+    let set = this.listeners[event];
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners[event] = set;
+    }
+    set.add(fn);
+    if (Object.prototype.hasOwnProperty.call(this.sticky, event)) {
+      try {
+        fn(this.sticky[event]);
+      } catch (err) {
+        console.error("[avbridge] listener threw replaying sticky value:", err);
+      }
+    }
+    return () => this.off(event, fn);
+  }
+  off(event, fn) {
+    this.listeners[event]?.delete(fn);
+  }
+  emit(event, payload) {
+    const set = this.listeners[event];
+    if (!set) return;
+    for (const fn of [...set]) {
+      try {
+        fn(payload);
+      } catch (err) {
+        console.error("[avbridge] listener threw:", err);
+      }
+    }
+  }
+  /**
+   * Like {@link emit} but also remembers the value so future subscribers
+   * receive it on `on()`. Use for one-shot state-snapshot events.
+   */
+  emitSticky(event, payload) {
+    this.sticky[event] = payload;
+    this.emit(event, payload);
+  }
+  removeAll() {
+    this.listeners = {};
+    this.sticky = {};
+  }
+};
+
+// src/diagnostics.ts
+var Diagnostics = class {
+  container = "unknown";
+  videoCodec;
+  audioCodec;
+  width;
+  height;
+  fps;
+  duration;
+  strategy = "pending";
+  strategyClass = "pending";
+  reason = "";
+  probedBy;
+  sourceType;
+  transport;
+  rangeSupported;
+  runtime = {};
+  lastError;
+  strategyHistory = [];
+  recordProbe(ctx) {
+    this.container = ctx.container;
+    this.probedBy = ctx.probedBy;
+    this.duration = ctx.duration;
+    const v = ctx.videoTracks[0];
+    if (v) {
+      this.videoCodec = v.codec;
+      this.width = v.width;
+      this.height = v.height;
+      this.fps = v.fps;
+    }
+    const a = ctx.audioTracks[0];
+    if (a) this.audioCodec = a.codec;
+    const src = ctx.source;
+    if (typeof src === "string" || src instanceof URL) {
+      this.sourceType = "url";
+      this.transport = "http-range";
+      this.rangeSupported = true;
+    } else {
+      this.sourceType = "blob";
+      this.transport = "memory";
+    }
+  }
+  recordClassification(c) {
+    this.strategy = c.strategy;
+    this.strategyClass = c.class;
+    this.reason = c.reason;
+  }
+  recordRuntime(stats) {
+    this.runtime = { ...this.runtime, ...stats };
+  }
+  recordStrategySwitch(strategy, reason) {
+    this.strategy = strategy;
+    this.reason = reason;
+    this.strategyHistory.push({ strategy, reason, at: Date.now() });
+  }
+  recordError(err) {
+    this.lastError = err;
+  }
+  snapshot() {
+    const snap = {
+      container: this.container,
+      videoCodec: this.videoCodec,
+      audioCodec: this.audioCodec,
+      width: this.width,
+      height: this.height,
+      fps: this.fps,
+      duration: this.duration,
+      strategy: this.strategy,
+      strategyClass: this.strategyClass,
+      reason: this.reason,
+      probedBy: this.probedBy,
+      sourceType: this.sourceType,
+      transport: this.transport,
+      rangeSupported: this.rangeSupported,
+      runtime: { ...this.runtime, ...this.lastError ? { error: this.lastError.message } : {} },
+      strategyHistory: this.strategyHistory.length > 0 ? [...this.strategyHistory] : void 0
+    };
+    return Object.freeze(snap);
+  }
+};
+
+// src/plugins/registry.ts
+var PluginRegistry = class {
+  plugins = [];
+  register(plugin, prepend = false) {
+    if (prepend) this.plugins.unshift(plugin);
+    else this.plugins.push(plugin);
+  }
+  all() {
+    return this.plugins;
+  }
+  /**
+   * Find the first plugin that claims this context AND its name matches the
+   * strategy. Built-in strategy plugins are named exactly `"native"`,
+   * `"remux"`, `"fallback"`.
+   */
+  findFor(context, strategy) {
+    for (const p of this.plugins) {
+      if (p.name === strategy && p.canHandle(context)) return p;
+    }
+    return null;
+  }
+};
+
+// src/strategies/native.ts
+async function createNativeSession(context, video) {
+  const { url, revoke } = sourceToVideoUrl(context.source);
+  video.src = url;
+  await new Promise((resolve, reject) => {
+    const onMeta = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error(`<video> failed to load: ${video.error?.message ?? "unknown"}`));
+    };
+    const cleanup = () => {
+      video.removeEventListener("loadedmetadata", onMeta);
+      video.removeEventListener("error", onError);
+    };
+    video.addEventListener("loadedmetadata", onMeta);
+    video.addEventListener("error", onError);
+  });
+  let stats = { framesDecoded: 0, framesDropped: 0 };
+  return {
+    strategy: "native",
+    async play() {
+      await video.play();
+    },
+    pause() {
+      video.pause();
+    },
+    async seek(time) {
+      video.currentTime = time;
+    },
+    async setAudioTrack(id) {
+      const tracks = video.audioTracks;
+      if (!tracks) return;
+      for (let i = 0; i < tracks.length; i++) {
+        tracks[i].enabled = tracks[i].id === String(id) || i === id;
+      }
+    },
+    async setSubtitleTrack(id) {
+      const tracks = video.textTracks;
+      for (let i = 0; i < tracks.length; i++) {
+        tracks[i].mode = i === id ? "showing" : "disabled";
+      }
+    },
+    async destroy() {
+      video.pause();
+      video.removeAttribute("src");
+      video.load();
+      revoke?.();
+    },
+    getCurrentTime() {
+      return video.currentTime || 0;
+    },
+    getRuntimeStats() {
+      const q = video.getVideoPlaybackQuality?.();
+      if (q) {
+        stats = {
+          framesDecoded: q.totalVideoFrames,
+          framesDropped: q.droppedVideoFrames
+        };
+      }
+      return { ...stats, decoderType: "native" };
+    }
+  };
+}
+function sourceToVideoUrl(source) {
+  if (source instanceof Blob) {
+    const url = URL.createObjectURL(source);
+    return { url, revoke: () => URL.revokeObjectURL(url) };
+  }
+  if (source instanceof ArrayBuffer || source instanceof Uint8Array) {
+    const blob = new Blob([source]);
+    const url = URL.createObjectURL(blob);
+    return { url, revoke: () => URL.revokeObjectURL(url) };
+  }
+  if (typeof source === "string") return { url: source };
+  if (source instanceof URL) return { url: source.toString() };
+  throw new TypeError("native strategy: unsupported source type");
+}
+
+// src/strategies/remux/mse.ts
+var MseSink = class {
+  constructor(options) {
+    this.options = options;
+    if (typeof MediaSource === "undefined") {
+      throw new Error("MSE not supported in this environment");
+    }
+    if (!MediaSource.isTypeSupported(options.mime)) {
+      throw new Error(`MSE does not support MIME "${options.mime}" \u2014 cannot remux`);
+    }
+    this.mediaSource = new MediaSource();
+    this.objectUrl = URL.createObjectURL(this.mediaSource);
+    options.video.src = this.objectUrl;
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.mediaSource.addEventListener("sourceopen", () => {
+      try {
+        this.sourceBuffer = this.mediaSource.addSourceBuffer(options.mime);
+        this.sourceBuffer.mode = "segments";
+        this.sourceBuffer.addEventListener("updateend", () => this.pump());
+        this.resolveReady();
+        options.onReady?.();
+      } catch (err) {
+        this.rejectReady(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  options;
+  mediaSource;
+  sourceBuffer = null;
+  queue = [];
+  endOfStreamCalled = false;
+  destroyed = false;
+  readyPromise;
+  resolveReady;
+  rejectReady;
+  objectUrl;
+  ready() {
+    return this.readyPromise;
+  }
+  /** Queue a chunk of fMP4 bytes (init segment or media segment). */
+  append(chunk) {
+    if (this.destroyed) return;
+    const ab = chunk instanceof Uint8Array ? chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength) : chunk;
+    this.queue.push(ab);
+    this.pump();
+  }
+  pump() {
+    const sb = this.sourceBuffer;
+    if (!sb || sb.updating) return;
+    if (sb.buffered.length > 0) {
+      if (this.pendingSeekTime !== null) {
+        this.options.video.currentTime = this.pendingSeekTime;
+        this.pendingSeekTime = null;
+      } else if (!this.hasSnappedToFirstBuffered) {
+        const v = this.options.video;
+        const firstStart = sb.buffered.start(0);
+        const firstEnd = sb.buffered.end(0);
+        if (v.currentTime < firstStart || v.currentTime > firstEnd) {
+          v.currentTime = firstStart;
+        }
+        this.hasSnappedToFirstBuffered = true;
+      }
+      if (this.playOnSeek) {
+        this.playOnSeek = false;
+        this.options.video.play().catch(() => {
+        });
+      }
+    }
+    const next = this.queue.shift();
+    if (!next) return;
+    try {
+      sb.appendBuffer(next);
+    } catch (err) {
+      if (err.name === "QuotaExceededError") {
+        this.evict();
+        try {
+          sb.appendBuffer(next);
+          return;
+        } catch {
+        }
+      }
+      this.rejectReady(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  evict() {
+    const sb = this.sourceBuffer;
+    if (!sb || sb.buffered.length === 0) return;
+    const start = sb.buffered.start(0);
+    const current = this.options.video.currentTime;
+    if (current - start > 10) {
+      try {
+        sb.remove(start, current - 10);
+      } catch {
+      }
+    }
+  }
+  /** Indicate the source is finished. Future seeks past the end will fail. */
+  endOfStream() {
+    if (this.endOfStreamCalled || this.destroyed) return;
+    this.endOfStreamCalled = true;
+    const tryEnd = () => {
+      if (this.queue.length > 0 || this.sourceBuffer?.updating) {
+        this.sourceBuffer?.addEventListener("updateend", tryEnd, { once: true });
+        return;
+      }
+      try {
+        if (this.mediaSource.readyState === "open") {
+          this.mediaSource.endOfStream();
+        }
+      } catch {
+      }
+    };
+    tryEnd();
+  }
+  /** Seconds of media buffered ahead of the current playback position. */
+  bufferedAhead() {
+    const sb = this.sourceBuffer;
+    if (!sb || sb.buffered.length === 0) return 0;
+    const current = this.options.video.currentTime;
+    for (let i = 0; i < sb.buffered.length; i++) {
+      if (sb.buffered.start(i) <= current && sb.buffered.end(i) > current) {
+        return sb.buffered.end(i) - current;
+      }
+    }
+    return 0;
+  }
+  /** Total seconds of media buffered across all ranges. */
+  totalBuffered() {
+    const sb = this.sourceBuffer;
+    if (!sb || sb.buffered.length === 0) return 0;
+    let total = 0;
+    for (let i = 0; i < sb.buffered.length; i++) {
+      total += sb.buffered.end(i) - sb.buffered.start(i);
+    }
+    return total;
+  }
+  /** Number of chunks waiting in the append queue. */
+  queueLength() {
+    return this.queue.length;
+  }
+  /** Time to seek to once the SourceBuffer has data at this position. */
+  pendingSeekTime = null;
+  /** Whether to resume playback after the deferred seek completes. */
+  playOnSeek = false;
+  /**
+   * On the very first data arrival, if `currentTime` falls outside the first
+   * buffered range, snap it to the start of that range. MPEG-TS sources
+   * commonly start their PTS at a non-zero value (e.g. ~1.5s); without this
+   * snap, the video element sits at `currentTime=0` waiting forever for
+   * data that doesn't exist.
+   */
+  hasSnappedToFirstBuffered = false;
+  /** Request that playback resumes automatically once the deferred seek fires. */
+  setPlayOnSeek(play) {
+    this.playOnSeek = play;
+  }
+  /**
+   * Discard all buffered media and schedule a deferred seek. The actual
+   * `video.currentTime` assignment happens in `pump()` once the SourceBuffer
+   * has data at the target position — setting it earlier causes the browser
+   * to snap back to the nearest buffered range.
+   */
+  invalidate(seekTime) {
+    const sb = this.sourceBuffer;
+    this.queue = [];
+    this.pendingSeekTime = seekTime;
+    this.hasSnappedToFirstBuffered = true;
+    if (!sb || sb.buffered.length === 0) return;
+    try {
+      const start = sb.buffered.start(0);
+      const end = sb.buffered.end(sb.buffered.length - 1);
+      sb.remove(start, end);
+    } catch {
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.queue = [];
+    try {
+      if (this.mediaSource.readyState === "open") this.mediaSource.endOfStream();
+    } catch {
+    }
+    URL.revokeObjectURL(this.objectUrl);
+  }
+};
+
+// src/strategies/remux/pipeline.ts
+async function createRemuxPipeline(ctx, video) {
+  const mb = await import('mediabunny');
+  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 sink = null;
+  const stats = { videoPackets: 0, audioPackets: 0, bytesWritten: 0, fragments: 0 };
+  let destroyed = false;
+  let pumpToken = 0;
+  let pendingAutoPlay = false;
+  let pendingStartTime = 0;
+  let currentOutput = null;
+  function createOutput() {
+    if (currentOutput) {
+      try {
+        void currentOutput.cancel();
+      } catch {
+      }
+    }
+    let mimePromise = null;
+    const writable = new WritableStream({
+      write: async (chunk) => {
+        if (destroyed) return;
+        if (!sink) {
+          const mime = await (mimePromise ??= output.getMimeType());
+          sink = new MseSink({ mime, video });
+          await sink.ready();
+          if (pendingStartTime > 0) {
+            sink.invalidate(pendingStartTime);
+          }
+          sink.setPlayOnSeek(pendingAutoPlay);
+        }
+        while (sink && !destroyed && (sink.queueLength() > 10 || sink.bufferedAhead() > 60 || sink.totalBuffered() > 120)) {
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        if (destroyed) return;
+        sink.append(chunk.data);
+        stats.bytesWritten += chunk.data.byteLength;
+        stats.fragments++;
+      }
+    });
+    const target = new mb.StreamTarget(writable);
+    const output = new mb.Output({
+      format: new mb.Mp4OutputFormat({ fastStart: "fragmented" }),
+      target
+    });
+    const videoSource = new mb.EncodedVideoPacketSource(mbVideoCodec);
+    output.addVideoTrack(videoSource);
+    let audioSource = null;
+    if (mbAudioCodec && inputAudio?.isAudioTrack()) {
+      audioSource = new mb.EncodedAudioPacketSource(mbAudioCodec);
+      output.addAudioTrack(audioSource);
+    }
+    currentOutput = output;
+    return { output, videoSource, audioSource };
+  }
+  async function pumpLoop(token, fromTime) {
+    const { output, videoSource, audioSource } = createOutput();
+    await output.start();
+    const startVideoPacket = fromTime > 0 ? await videoSink.getKeyPacket(fromTime) ?? await videoSink.getFirstPacket() : await videoSink.getFirstPacket();
+    if (!startVideoPacket) return;
+    const startAudioPacket = audioSink ? audioSink && fromTime > 0 ? await audioSink.getPacket(fromTime) ?? await audioSink.getFirstPacket() : await audioSink.getFirstPacket() : null;
+    const videoIter = videoSink.packets(startVideoPacket);
+    const audioIter = audioSink && startAudioPacket ? audioSink.packets(startAudioPacket) : null;
+    let vNext = await videoIter.next();
+    let aNext = audioIter ? await audioIter.next() : { done: true, value: void 0 };
+    let firstVideo = true;
+    let firstAudio = true;
+    while (!destroyed && pumpToken === token && (!vNext.done || !aNext.done)) {
+      while (!destroyed && pumpToken === token && sink && (sink.bufferedAhead() > 30 || sink.queueLength() > 20 || sink.totalBuffered() > 90)) {
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      if (destroyed || pumpToken !== token) break;
+      const vTs = !vNext.done ? vNext.value.timestamp : Number.POSITIVE_INFINITY;
+      const aTs = !aNext.done ? aNext.value.timestamp : Number.POSITIVE_INFINITY;
+      if (!vNext.done && vTs <= aTs) {
+        await videoSource.add(
+          vNext.value,
+          firstVideo && videoConfig ? { decoderConfig: videoConfig } : void 0
+        );
+        firstVideo = false;
+        stats.videoPackets++;
+        vNext = await videoIter.next();
+      } else if (audioIter && audioSource && !aNext.done) {
+        await audioSource.add(
+          aNext.value,
+          firstAudio && audioConfig ? { decoderConfig: audioConfig } : void 0
+        );
+        firstAudio = false;
+        stats.audioPackets++;
+        aNext = await audioIter.next();
+      } else {
+        break;
+      }
+    }
+    if (!destroyed && pumpToken === token) {
+      await output.finalize();
+      sink?.endOfStream();
+    }
+  }
+  return {
+    async start(fromTime = 0, autoPlay = false) {
+      pendingAutoPlay = autoPlay;
+      pendingStartTime = fromTime;
+      pumpLoop(++pumpToken, fromTime).catch((err) => {
+        console.error("[avbridge] remux pipeline failed:", err);
+        try {
+          sink?.destroy();
+        } catch {
+        }
+      });
+    },
+    async seek(time, autoPlay = false) {
+      if (sink) {
+        sink.setPlayOnSeek(autoPlay);
+        sink.invalidate(time);
+      } else {
+        pendingAutoPlay = autoPlay;
+        pendingStartTime = time;
+      }
+      pumpLoop(++pumpToken, time).catch((err) => {
+        console.error("[avbridge] remux pipeline reseek failed:", err);
+      });
+    },
+    async destroy() {
+      destroyed = true;
+      pumpToken++;
+      try {
+        if (currentOutput) await currentOutput.cancel();
+      } catch {
+      }
+      try {
+        await input.dispose();
+      } catch {
+      }
+      sink?.destroy();
+    },
+    stats() {
+      return { ...stats, decoderType: "remux" };
+    }
+  };
+}
+
+// src/strategies/remux/index.ts
+async function createRemuxSession(context, video) {
+  let pipeline;
+  try {
+    pipeline = await createRemuxPipeline(context, video);
+  } catch (err) {
+    throw new Error(
+      `remux strategy failed to start: ${err.message}. The container or codec combination is not supported by mediabunny + MSE on this browser.`
+    );
+  }
+  let started = false;
+  let wantPlay = false;
+  return {
+    strategy: "remux",
+    async play() {
+      wantPlay = true;
+      if (!started) {
+        started = true;
+        await pipeline.start(video.currentTime || 0, true);
+        return;
+      }
+      await video.play();
+    },
+    pause() {
+      wantPlay = false;
+      video.pause();
+    },
+    async seek(time) {
+      if (!started) {
+        started = true;
+        await pipeline.seek(time, wantPlay);
+        return;
+      }
+      const wasPlaying = !video.paused;
+      await pipeline.seek(time, wasPlaying || wantPlay);
+    },
+    async setAudioTrack(_id) {
+    },
+    async setSubtitleTrack(id) {
+      const tracks = video.textTracks;
+      for (let i = 0; i < tracks.length; i++) {
+        tracks[i].mode = i === id ? "showing" : "disabled";
+      }
+    },
+    getCurrentTime() {
+      return video.currentTime || 0;
+    },
+    async destroy() {
+      video.pause();
+      await pipeline.destroy();
+      video.removeAttribute("src");
+      video.load();
+    },
+    getRuntimeStats() {
+      return pipeline.stats();
+    }
+  };
+}
+
+// src/strategies/fallback/video-renderer.ts
+var VideoRenderer = class {
+  constructor(target, clock, fps = 30) {
+    this.target = target;
+    this.clock = clock;
+    this.paintIntervalMs = Math.max(1, 1e3 / fps);
+    this.firstFrameReady = new Promise((resolve) => {
+      this.resolveFirstFrame = resolve;
+    });
+    this.canvas = document.createElement("canvas");
+    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;";
+    const parent = target.parentElement;
+    if (parent && getComputedStyle(parent).position === "static") {
+      parent.style.position = "relative";
+    }
+    parent?.insertBefore(this.canvas, target);
+    target.style.visibility = "hidden";
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) throw new Error("video renderer: failed to acquire 2D context");
+    this.ctx = ctx;
+    this.tick = this.tick.bind(this);
+    this.rafHandle = requestAnimationFrame(this.tick);
+  }
+  target;
+  clock;
+  canvas;
+  ctx;
+  queue = [];
+  rafHandle = null;
+  destroyed = false;
+  framesPainted = 0;
+  framesDroppedLate = 0;
+  framesDroppedOverflow = 0;
+  prerolled = false;
+  /** Wall-clock time of the last paint, in ms (performance.now()). */
+  lastPaintWall = 0;
+  /** Minimum ms between paints — paces video at roughly source fps. */
+  paintIntervalMs;
+  /** Resolves once the first decoded frame has been enqueued. */
+  firstFrameReady;
+  resolveFirstFrame;
+  /** True once at least one frame has been enqueued. */
+  hasFrames() {
+    return this.queue.length > 0 || this.framesPainted > 0;
+  }
+  /** Current depth of the frame queue. Used by the decoder for backpressure. */
+  queueDepth() {
+    return this.queue.length;
+  }
+  /**
+   * Soft cap for decoder backpressure. The decoder pump throttles when
+   * `queueDepth() >= queueHighWater`. Set high enough that normal decode
+   * bursts don't trigger the renderer's overflow-drop loop (which runs at
+   * every paint), but low enough that the decoder doesn't run unboundedly
+   * ahead. The hard cap in `enqueue()` is 64.
+   */
+  queueHighWater = 30;
+  enqueue(frame) {
+    if (this.destroyed) {
+      frame.close();
+      return;
+    }
+    this.queue.push(frame);
+    if (this.queue.length === 1 && this.framesPainted === 0) {
+      this.resolveFirstFrame();
+    }
+    while (this.queue.length > 60) {
+      this.queue.shift()?.close();
+      this.framesDroppedOverflow++;
+    }
+  }
+  tick() {
+    if (this.destroyed) return;
+    this.rafHandle = requestAnimationFrame(this.tick);
+    if (this.queue.length === 0) return;
+    const playing = this.clock.isPlaying();
+    if (!playing) {
+      if (!this.prerolled) {
+        const head = this.queue.shift();
+        this.paint(head);
+        head.close();
+        this.prerolled = true;
+        this.lastPaintWall = performance.now();
+      }
+      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) {
+        return;
+      }
+    }
+    const frame = this.queue.shift();
+    this.paint(frame);
+    frame.close();
+    this.lastPaintWall = wallNow;
+  }
+  paint(frame) {
+    if (this.canvas.width !== frame.displayWidth || this.canvas.height !== frame.displayHeight) {
+      this.canvas.width = frame.displayWidth;
+      this.canvas.height = frame.displayHeight;
+    }
+    try {
+      this.ctx.drawImage(frame, 0, 0, this.canvas.width, this.canvas.height);
+      this.framesPainted++;
+    } catch (err) {
+      if (this.framesPainted === 0 && this.framesDroppedLate === 0) {
+        console.warn("[avbridge] canvas drawImage failed:", err);
+      }
+    }
+  }
+  /** Discard all queued frames. Used by seek to drop stale buffers. */
+  flush() {
+    while (this.queue.length > 0) this.queue.shift()?.close();
+    this.prerolled = false;
+  }
+  stats() {
+    return {
+      framesPainted: this.framesPainted,
+      framesDroppedLate: this.framesDroppedLate,
+      framesDroppedOverflow: this.framesDroppedOverflow,
+      queueDepth: this.queue.length
+    };
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.rafHandle != null) cancelAnimationFrame(this.rafHandle);
+    this.flush();
+    this.canvas.remove();
+    this.target.style.visibility = "";
+  }
+};
+
+// src/strategies/fallback/audio-output.ts
+var AudioOutput = class {
+  ctx;
+  gain;
+  state = "idle";
+  /**
+   * Wall-clock fallback mode. When true, this output behaves as if audio
+   * is unavailable — `now()` advances from `performance.now()` instead of
+   * the audio context, `schedule()` is a no-op, and `bufferAhead()` returns
+   * Infinity so the session's `waitForBuffer()` doesn't block on audio.
+   *
+   * Set by the decoder via {@link setNoAudio} when audio decode init fails.
+   * This is what lets video play even when the audio codec isn't supported
+   * by the loaded libav variant.
+   */
+  noAudio = false;
+  /** Wall-clock anchor (ms from `performance.now()`) for noAudio mode. */
+  wallAnchorMs = 0;
+  /** Media time at which the next sample will be scheduled. */
+  mediaTimeOfNext = 0;
+  /** Anchor: media time `mediaTimeOfAnchor` corresponds to ctx time `ctxTimeAtAnchor`. */
+  mediaTimeOfAnchor = 0;
+  ctxTimeAtAnchor = 0;
+  pendingQueue = [];
+  framesScheduled = 0;
+  destroyed = false;
+  constructor() {
+    this.ctx = new AudioContext();
+    this.gain = this.ctx.createGain();
+    this.gain.connect(this.ctx.destination);
+  }
+  /**
+   * Switch into wall-clock fallback mode. Called by the decoder when no
+   * audio decoder could be initialized for the source. Once set, this
+   * output drives playback time from `performance.now()` and ignores
+   * any incoming audio samples.
+   */
+  setNoAudio() {
+    this.noAudio = true;
+  }
+  // ── ClockSource ────────────────────────────────────────────────────────
+  now() {
+    if (this.noAudio) {
+      if (this.state === "playing") {
+        return this.mediaTimeOfAnchor + (performance.now() - this.wallAnchorMs) / 1e3;
+      }
+      return this.mediaTimeOfAnchor;
+    }
+    if (this.state === "playing") {
+      return this.mediaTimeOfAnchor + (this.ctx.currentTime - this.ctxTimeAtAnchor);
+    }
+    return this.mediaTimeOfAnchor;
+  }
+  isPlaying() {
+    return this.state === "playing";
+  }
+  // ── Buffering ─────────────────────────────────────────────────────────
+  /**
+   * How many seconds of audio are buffered ahead of the current playback
+   * position. While idle, this counts the pending queue. While playing,
+   * it counts how far `mediaTimeOfNext` is ahead of `now()`.
+   */
+  bufferAhead() {
+    if (this.noAudio) return 0;
+    if (this.state === "idle") {
+      let sec = 0;
+      for (const c of this.pendingQueue) sec += c.durationSec;
+      return sec;
+    }
+    return Math.max(0, this.mediaTimeOfNext - this.now());
+  }
+  /** True if this output is in wall-clock fallback mode (no audio decode). */
+  isNoAudio() {
+    return this.noAudio;
+  }
+  /**
+   * Schedule a chunk of decoded samples. Queues internally while idle (cold
+   * start or post-seek), schedules directly to the audio graph while playing.
+   * In wall-clock mode, samples are silently discarded.
+   */
+  schedule(samples, channels, sampleRate) {
+    if (this.destroyed || this.noAudio) return;
+    const frameCount = samples.length / channels;
+    const durationSec = frameCount / sampleRate;
+    if (this.state === "idle" || this.state === "paused") {
+      this.pendingQueue.push({ samples, channels, sampleRate, frameCount, durationSec });
+      return;
+    }
+    this.scheduleNow(samples, channels, sampleRate, frameCount);
+  }
+  scheduleNow(samples, channels, sampleRate, frameCount) {
+    const buffer = this.ctx.createBuffer(channels, frameCount, sampleRate);
+    for (let ch = 0; ch < channels; ch++) {
+      const channelData = buffer.getChannelData(ch);
+      for (let i = 0; i < frameCount; i++) {
+        channelData[i] = samples[i * channels + ch];
+      }
+    }
+    const node = this.ctx.createBufferSource();
+    node.buffer = buffer;
+    node.connect(this.gain);
+    const ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
+    const safeStart = Math.max(ctxStart, this.ctx.currentTime);
+    node.start(safeStart);
+    this.mediaTimeOfNext += frameCount / sampleRate;
+    this.framesScheduled++;
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  /**
+   * Start (or resume) playback. On a cold start (or after a reset), drains
+   * the pending queue scheduling all queued samples to play starting at
+   * `ctx.currentTime + STARTUP_DELAY`. On resume from pause, just re-anchors
+   * the media↔ctx time mapping and unsuspends the context.
+   */
+  async start() {
+    if (this.destroyed || this.state === "playing") return;
+    if (this.noAudio) {
+      this.wallAnchorMs = performance.now();
+      this.state = "playing";
+      return;
+    }
+    if (this.ctx.state === "suspended") {
+      await this.ctx.resume();
+    }
+    if (this.state === "paused") {
+      this.ctxTimeAtAnchor = this.ctx.currentTime;
+      this.state = "playing";
+      const drain2 = this.pendingQueue;
+      this.pendingQueue = [];
+      for (const c of drain2) {
+        this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount);
+      }
+      return;
+    }
+    const STARTUP_DELAY = 0.05;
+    this.ctxTimeAtAnchor = this.ctx.currentTime + STARTUP_DELAY;
+    this.mediaTimeOfNext = this.mediaTimeOfAnchor;
+    this.state = "playing";
+    const drain = this.pendingQueue;
+    this.pendingQueue = [];
+    for (const c of drain) {
+      this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount);
+    }
+  }
+  /** Pause playback. Suspends the audio context. */
+  async pause() {
+    if (this.state !== "playing") return;
+    this.mediaTimeOfAnchor = this.now();
+    this.state = "paused";
+    if (this.noAudio) return;
+    if (this.ctx.state === "running") {
+      await this.ctx.suspend();
+    }
+  }
+  /**
+   * Reset to a new media time. Discards all queued and scheduled audio,
+   * disconnects the gain node so any in-flight scheduled buffers are cut
+   * off, and returns to the idle state. Used by `seek()`.
+   *
+   * After reset, callers should re-buffer audio (the decoder will start
+   * supplying new samples) and then call `start()` to resume playback.
+   */
+  async reset(newMediaTime) {
+    if (this.noAudio) {
+      this.pendingQueue = [];
+      this.mediaTimeOfAnchor = newMediaTime;
+      this.wallAnchorMs = performance.now();
+      this.state = "idle";
+      return;
+    }
+    try {
+      this.gain.disconnect();
+    } catch {
+    }
+    this.gain = this.ctx.createGain();
+    this.gain.connect(this.ctx.destination);
+    this.pendingQueue = [];
+    this.mediaTimeOfAnchor = newMediaTime;
+    this.mediaTimeOfNext = newMediaTime;
+    this.ctxTimeAtAnchor = this.ctx.currentTime;
+    this.state = "idle";
+    if (this.ctx.state === "running") {
+      await this.ctx.suspend();
+    }
+  }
+  stats() {
+    return {
+      framesScheduled: this.framesScheduled,
+      bufferAhead: this.bufferAhead(),
+      audioState: this.state,
+      clockMode: this.noAudio ? "wall" : "audio"
+    };
+  }
+  destroy() {
+    this.destroyed = true;
+    try {
+      this.ctx.close();
+    } catch {
+    }
+  }
+};
+
+// 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 } = await import('./libav-http-reader-NQJVY273.js');
+  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source);
+  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;
+  if (!videoStream && !audioStream) {
+    throw new Error("hybrid decoder: file has no decodable streams");
+  }
+  let fatalHandler = null;
+  let fatalFired = false;
+  function fireFatal(reason) {
+    if (fatalFired) return;
+    fatalFired = true;
+    fatalHandler?.(reason);
+  }
+  let videoDecoder = null;
+  let videoTimeBase;
+  if (videoStream) {
+    try {
+      const config = await bridge.videoStreamToConfig(libav, videoStream);
+      if (!config) throw new Error("bridge returned null config");
+      const supported = await VideoDecoder.isConfigSupported(config);
+      if (!supported.supported) throw new Error(`VideoDecoder does not support config: ${JSON.stringify(config)}`);
+      videoDecoder = new VideoDecoder({
+        output: (frame) => {
+          opts.renderer.enqueue(frame);
+          videoFramesDecoded++;
+        },
+        error: (err) => {
+          console.error("[avbridge] WebCodecs VideoDecoder error:", err);
+          fireFatal(`WebCodecs VideoDecoder error: ${err.message}`);
+        }
+      });
+      videoDecoder.configure(config);
+      if (videoStream.time_base_num && videoStream.time_base_den) {
+        videoTimeBase = [videoStream.time_base_num, videoStream.time_base_den];
+      }
+    } catch (err) {
+      console.error("[avbridge] hybrid: failed to init WebCodecs VideoDecoder:", err);
+      fireFatal(`WebCodecs VideoDecoder init failed: ${err.message}`);
+      await inputHandle.detach().catch(() => {
+      });
+      throw err;
+    }
+  }
+  let audioDec = null;
+  let audioTimeBase;
+  if (audioStream) {
+    try {
+      const [, c, pkt, frame] = await libav.ff_init_decoder(audioStream.codec_id, {
+        codecpar: audioStream.codecpar
+      });
+      audioDec = { c, pkt, frame };
+      if (audioStream.time_base_num && audioStream.time_base_den) {
+        audioTimeBase = [audioStream.time_base_num, audioStream.time_base_den];
+      }
+    } catch (err) {
+      console.warn(
+        "[avbridge] hybrid: audio decoder unavailable for this codec \u2014 playing video with wall-clock timing:",
+        err.message
+      );
+    }
+  }
+  if (!audioDec) {
+    opts.audio.setNoAudio();
+  }
+  if (!videoDecoder && !audioDec) {
+    await inputHandle.detach().catch(() => {
+    });
+    throw new Error("hybrid decoder: could not initialize any decoders");
+  }
+  let destroyed = false;
+  let pumpToken = 0;
+  let pumpRunning = null;
+  let packetsRead = 0;
+  let videoFramesDecoded = 0;
+  let audioFramesDecoded = 0;
+  let videoChunksFed = 0;
+  let syntheticVideoUs = 0;
+  let syntheticAudioUs = 0;
+  const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
+  const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
+  const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
+  async function pumpLoop(myToken) {
+    while (!destroyed && myToken === pumpToken) {
+      let readErr;
+      let packets;
+      try {
+        [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
+          limit: 16 * 1024
+        });
+      } catch (err) {
+        console.error("[avbridge] hybrid ff_read_frame_multi failed:", err);
+        return;
+      }
+      if (myToken !== pumpToken || destroyed) return;
+      const videoPackets = videoStream ? packets[videoStream.index] : void 0;
+      const audioPackets = audioStream ? packets[audioStream.index] : void 0;
+      if (videoDecoder && videoPackets && videoPackets.length > 0) {
+        for (const pkt of videoPackets) {
+          if (myToken !== pumpToken || destroyed) return;
+          sanitizePacketTimestamp(pkt, () => {
+            const ts = syntheticVideoUs;
+            syntheticVideoUs += videoFrameStepUs;
+            return ts;
+          }, videoTimeBase);
+          try {
+            const chunk = bridge.packetToEncodedVideoChunk(pkt, videoStream);
+            videoDecoder.decode(chunk);
+            videoChunksFed++;
+          } catch (err) {
+            if (videoChunksFed === 0) {
+              console.warn("[avbridge] hybrid: packetToEncodedVideoChunk failed:", err);
+              fireFatal(`WebCodecs chunk creation failed: ${err.message}`);
+              return;
+            }
+          }
+        }
+      }
+      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));
+      }
+      if (readErr === libav.AVERROR_EOF) {
+        if (videoDecoder && videoDecoder.state === "configured") {
+          try {
+            await videoDecoder.flush();
+          } catch {
+          }
+        }
+        if (audioDec) await decodeAudioBatch([], myToken, true);
+        return;
+      }
+      if (readErr && readErr !== 0 && readErr !== -libav.EAGAIN) {
+        console.warn("[avbridge] hybrid ff_read_frame_multi returned", readErr);
+        return;
+      }
+    }
+  }
+  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;
+    }
+    if (myToken !== pumpToken || destroyed) return;
+    for (const f of frames) {
+      if (myToken !== pumpToken || destroyed) return;
+      sanitizeFrameTimestamp(
+        f,
+        () => {
+          const ts = syntheticAudioUs;
+          const samples2 = f.nb_samples ?? 1024;
+          const sampleRate = f.sample_rate ?? 44100;
+          syntheticAudioUs += Math.round(samples2 * 1e6 / sampleRate);
+          return ts;
+        },
+        audioTimeBase
+      );
+      const samples = libavFrameToInterleavedFloat32(f);
+      if (samples) {
+        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate);
+        audioFramesDecoded++;
+      }
+    }
+  }
+  pumpToken = 1;
+  pumpRunning = pumpLoop(pumpToken).catch(
+    (err) => console.error("[avbridge] hybrid pump failed:", err)
+  );
+  return {
+    onFatalError(handler) {
+      fatalHandler = handler;
+      if (fatalFired) handler("WebCodecs decode failed (error occurred before handler attached)");
+    },
+    async destroy() {
+      destroyed = true;
+      pumpToken++;
+      try {
+        await pumpRunning;
+      } catch {
+      }
+      try {
+        if (videoDecoder && videoDecoder.state !== "closed") videoDecoder.close();
+      } catch {
+      }
+      try {
+        if (audioDec) await libav.ff_free_decoder?.(audioDec.c, audioDec.pkt, audioDec.frame);
+      } catch {
+      }
+      try {
+        await libav.av_packet_free?.(readPkt);
+      } catch {
+      }
+      try {
+        await libav.avformat_close_input_js(fmt_ctx);
+      } catch {
+      }
+      try {
+        await inputHandle.detach();
+      } catch {
+      }
+    },
+    async seek(timeSec) {
+      const newToken = ++pumpToken;
+      if (pumpRunning) {
+        try {
+          await pumpRunning;
+        } catch {
+        }
+      }
+      if (destroyed) return;
+      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 av_seek_frame failed:", err);
+      }
+      try {
+        if (videoDecoder && videoDecoder.state === "configured") {
+          await videoDecoder.flush();
+        }
+      } catch {
+      }
+      try {
+        if (audioDec) await libav.avcodec_flush_buffers?.(audioDec.c);
+      } catch {
+      }
+      syntheticVideoUs = Math.round(timeSec * 1e6);
+      syntheticAudioUs = Math.round(timeSec * 1e6);
+      pumpRunning = pumpLoop(newToken).catch(
+        (err) => console.error("[avbridge] hybrid pump failed (post-seek):", err)
+      );
+    },
+    stats() {
+      return {
+        decoderType: "webcodecs-hybrid",
+        packetsRead,
+        videoFramesDecoded,
+        videoChunksFed,
+        audioFramesDecoded,
+        videoDecodeQueueSize: videoDecoder?.decodeQueueSize ?? 0,
+        ...opts.renderer.stats(),
+        ...opts.audio.stats()
+      };
+    }
+  };
+}
+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 import('./libav-import-2JURFHEW.js');
+    return wrapper.libavBridge;
+  } catch (err) {
+    throw new Error(
+      `failed to load libavjs-webcodecs-bridge: ${err.message}`
+    );
+  }
+}
+
+// src/strategies/hybrid/index.ts
+var READY_AUDIO_BUFFER_SECONDS = 0.3;
+var READY_TIMEOUT_SECONDS = 10;
+async function createHybridSession(ctx, target) {
+  const { normalizeSource: normalizeSource2 } = await import('./source-ZFS4H7J3.js');
+  const source = await normalizeSource2(ctx.source);
+  const fps = ctx.videoTracks[0]?.fps ?? 30;
+  const audio = new AudioOutput();
+  const renderer = new VideoRenderer(target, audio, fps);
+  let handles;
+  try {
+    handles = await startHybridDecoder({
+      source,
+      filename: ctx.name ?? "input.bin",
+      context: ctx,
+      renderer,
+      audio
+    });
+  } catch (err) {
+    audio.destroy();
+    renderer.destroy();
+    throw err;
+  }
+  Object.defineProperty(target, "currentTime", {
+    configurable: true,
+    get: () => audio.now(),
+    set: (v) => {
+      void doSeek(v);
+    }
+  });
+  if (ctx.duration && Number.isFinite(ctx.duration)) {
+    Object.defineProperty(target, "duration", {
+      configurable: true,
+      get: () => ctx.duration ?? NaN
+    });
+  }
+  async function waitForBuffer() {
+    const start = performance.now();
+    while (true) {
+      const audioReady = audio.isNoAudio() || audio.bufferAhead() >= READY_AUDIO_BUFFER_SECONDS;
+      if (audioReady && renderer.hasFrames()) {
+        return;
+      }
+      if ((performance.now() - start) / 1e3 > READY_TIMEOUT_SECONDS) return;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  async function doSeek(timeSec) {
+    const wasPlaying = audio.isPlaying();
+    await audio.pause().catch(() => {
+    });
+    await handles.seek(timeSec).catch(
+      (err) => console.warn("[avbridge] hybrid decoder seek failed:", err)
+    );
+    await audio.reset(timeSec);
+    renderer.flush();
+    if (wasPlaying) {
+      await waitForBuffer();
+      await audio.start();
+    }
+  }
+  let fatalErrorHandler = null;
+  handles.onFatalError((reason) => fatalErrorHandler?.(reason));
+  return {
+    strategy: "hybrid",
+    async play() {
+      if (!audio.isPlaying()) {
+        await waitForBuffer();
+        await audio.start();
+      }
+    },
+    pause() {
+      void audio.pause();
+    },
+    async seek(time) {
+      await doSeek(time);
+    },
+    async setAudioTrack(_id) {
+    },
+    async setSubtitleTrack(_id) {
+    },
+    getCurrentTime() {
+      return audio.now();
+    },
+    onFatalError(handler) {
+      fatalErrorHandler = handler;
+    },
+    async destroy() {
+      await handles.destroy();
+      renderer.destroy();
+      audio.destroy();
+      try {
+        delete target.currentTime;
+        delete target.duration;
+      } catch {
+      }
+    },
+    getRuntimeStats() {
+      return handles.stats();
+    }
+  };
+}
+
+// src/strategies/fallback/decoder.ts
+async function startDecoder(opts) {
+  const variant = pickLibavVariant(opts.context);
+  const libav = await loadLibav(variant);
+  const bridge = await loadBridge2();
+  const { prepareLibavInput } = await import('./libav-http-reader-NQJVY273.js');
+  const inputHandle = await prepareLibavInput(libav, opts.filename, opts.source);
+  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;
+  if (!videoStream && !audioStream) {
+    throw new Error("fallback decoder: file has no decodable streams");
+  }
+  let videoDec = null;
+  let audioDec = null;
+  let videoTimeBase;
+  let audioTimeBase;
+  if (videoStream) {
+    try {
+      const [, c, pkt, frame] = await libav.ff_init_decoder(videoStream.codec_id, {
+        codecpar: videoStream.codecpar
+      });
+      videoDec = { c, pkt, frame };
+      if (videoStream.time_base_num && videoStream.time_base_den) {
+        videoTimeBase = [videoStream.time_base_num, videoStream.time_base_den];
+      }
+    } catch (err) {
+      console.error("[avbridge] failed to init video decoder:", err);
+    }
+  }
+  if (audioStream) {
+    try {
+      const [, c, pkt, frame] = await libav.ff_init_decoder(audioStream.codec_id, {
+        codecpar: audioStream.codecpar
+      });
+      audioDec = { c, pkt, frame };
+      if (audioStream.time_base_num && audioStream.time_base_den) {
+        audioTimeBase = [audioStream.time_base_num, audioStream.time_base_den];
+      }
+    } catch (err) {
+      console.warn(
+        "[avbridge] fallback: audio decoder unavailable \u2014 playing video with wall-clock timing:",
+        err.message
+      );
+    }
+  }
+  if (!audioDec) {
+    opts.audio.setNoAudio();
+  }
+  if (!videoDec && !audioDec) {
+    await inputHandle.detach().catch(() => {
+    });
+    const codecs = [
+      videoStream ? `video: ${opts.context.videoTracks[0]?.codec ?? "unknown"}` : null,
+      audioStream ? `audio: ${opts.context.audioTracks[0]?.codec ?? "unknown"}` : null
+    ].filter(Boolean).join(", ");
+    const hint = variant === "webcodecs" ? ` The "${variant}" libav variant does not include software decoders for these codecs. Try the custom "avbridge" variant (scripts/build-libav.sh) for broader codec support, or use a lighter strategy (native, remux, hybrid) instead.` : "";
+    throw new Error(
+      `fallback decoder: could not initialize any libav decoders (${codecs}).${hint}`
+    );
+  }
+  let destroyed = false;
+  let pumpToken = 0;
+  let pumpRunning = null;
+  let packetsRead = 0;
+  let videoFramesDecoded = 0;
+  let audioFramesDecoded = 0;
+  let syntheticVideoUs = 0;
+  let syntheticAudioUs = 0;
+  const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
+  const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
+  const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
+  async function pumpLoop(myToken) {
+    while (!destroyed && myToken === pumpToken) {
+      let readErr;
+      let packets;
+      try {
+        [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
+          limit: 16 * 1024
+        });
+      } catch (err) {
+        console.error("[avbridge] ff_read_frame_multi failed:", err);
+        return;
+      }
+      if (myToken !== pumpToken || destroyed) return;
+      const videoPackets = videoStream ? packets[videoStream.index] : void 0;
+      const audioPackets = audioStream ? packets[audioStream.index] : void 0;
+      if (videoDec && videoPackets && videoPackets.length > 0) {
+        await decodeVideoBatch(videoPackets, myToken);
+      }
+      if (myToken !== pumpToken || destroyed) return;
+      if (audioDec && audioPackets && audioPackets.length > 0) {
+        await decodeAudioBatch(audioPackets, myToken);
+      }
+      packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
+      while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+      if (readErr === libav.AVERROR_EOF) {
+        if (videoDec) await decodeVideoBatch(
+          [],
+          myToken,
+          /*flush*/
+          true
+        );
+        if (audioDec) await decodeAudioBatch(
+          [],
+          myToken,
+          /*flush*/
+          true
+        );
+        return;
+      }
+      if (readErr && readErr !== 0 && readErr !== -libav.EAGAIN) {
+        console.warn("[avbridge] ff_read_frame_multi returned", readErr);
+        return;
+      }
+    }
+  }
+  async function decodeVideoBatch(pkts, myToken, flush = false) {
+    if (!videoDec || destroyed || myToken !== pumpToken) return;
+    let frames;
+    try {
+      frames = await libav.ff_decode_multi(
+        videoDec.c,
+        videoDec.pkt,
+        videoDec.frame,
+        pkts,
+        flush ? { fin: true, ignoreErrors: true } : { ignoreErrors: true }
+      );
+    } catch (err) {
+      console.error("[avbridge] video decode batch failed:", err);
+      return;
+    }
+    if (myToken !== pumpToken || destroyed) return;
+    for (const f of frames) {
+      if (myToken !== pumpToken || destroyed) return;
+      const bridgeOpts = sanitizeFrameTimestamp2(
+        f,
+        () => {
+          const ts = syntheticVideoUs;
+          syntheticVideoUs += videoFrameStepUs;
+          return ts;
+        },
+        videoTimeBase
+      );
+      try {
+        const vf = bridge.laFrameToVideoFrame(f, bridgeOpts);
+        opts.renderer.enqueue(vf);
+        videoFramesDecoded++;
+      } catch (err) {
+        if (videoFramesDecoded === 0) {
+          console.warn("[avbridge] laFrameToVideoFrame failed:", err);
+        }
+      }
+    }
+  }
+  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] audio decode batch failed:", err);
+      return;
+    }
+    if (myToken !== pumpToken || destroyed) return;
+    for (const f of frames) {
+      if (myToken !== pumpToken || destroyed) return;
+      sanitizeFrameTimestamp2(
+        f,
+        () => {
+          const ts = syntheticAudioUs;
+          const samples2 = f.nb_samples ?? 1024;
+          const sampleRate = f.sample_rate ?? 44100;
+          syntheticAudioUs += Math.round(samples2 * 1e6 / sampleRate);
+          return ts;
+        },
+        audioTimeBase
+      );
+      const samples = libavFrameToInterleavedFloat322(f);
+      if (samples) {
+        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate);
+        audioFramesDecoded++;
+      }
+    }
+  }
+  pumpToken = 1;
+  pumpRunning = pumpLoop(pumpToken).catch(
+    (err) => console.error("[avbridge] decoder pump failed:", err)
+  );
+  return {
+    async destroy() {
+      destroyed = true;
+      pumpToken++;
+      try {
+        await pumpRunning;
+      } catch {
+      }
+      try {
+        if (videoDec) await libav.ff_free_decoder?.(videoDec.c, videoDec.pkt, videoDec.frame);
+      } catch {
+      }
+      try {
+        if (audioDec) await libav.ff_free_decoder?.(audioDec.c, audioDec.pkt, audioDec.frame);
+      } catch {
+      }
+      try {
+        await libav.av_packet_free?.(readPkt);
+      } catch {
+      }
+      try {
+        await libav.avformat_close_input_js(fmt_ctx);
+      } catch {
+      }
+      try {
+        await inputHandle.detach();
+      } catch {
+      }
+    },
+    async seek(timeSec) {
+      const newToken = ++pumpToken;
+      if (pumpRunning) {
+        try {
+          await pumpRunning;
+        } catch {
+        }
+      }
+      if (destroyed) return;
+      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] av_seek_frame failed:", err);
+      }
+      try {
+        if (videoDec) await libav.avcodec_flush_buffers?.(videoDec.c);
+      } catch {
+      }
+      try {
+        if (audioDec) await libav.avcodec_flush_buffers?.(audioDec.c);
+      } catch {
+      }
+      syntheticVideoUs = Math.round(timeSec * 1e6);
+      syntheticAudioUs = Math.round(timeSec * 1e6);
+      pumpRunning = pumpLoop(newToken).catch(
+        (err) => console.error("[avbridge] decoder pump failed (post-seek):", err)
+      );
+    },
+    stats() {
+      return {
+        decoderType: "libav-wasm",
+        packetsRead,
+        videoFramesDecoded,
+        audioFramesDecoded,
+        ...opts.renderer.stats(),
+        ...opts.audio.stats()
+      };
+    }
+  };
+}
+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 import('./libav-import-2JURFHEW.js');
+    return wrapper.libavBridge;
+  } catch (err) {
+    throw new Error(
+      `failed to load libavjs-webcodecs-bridge \u2014 install the optional peer deps with: npm i libavjs-webcodecs-bridge @libav.js/variant-webcodecs. (${err.message})`
+    );
+  }
+}
+
+// src/strategies/fallback/index.ts
+var READY_AUDIO_BUFFER_SECONDS2 = 0.3;
+var READY_TIMEOUT_SECONDS2 = 10;
+async function createFallbackSession(ctx, target) {
+  const { normalizeSource: normalizeSource2 } = await import('./source-ZFS4H7J3.js');
+  const source = await normalizeSource2(ctx.source);
+  const fps = ctx.videoTracks[0]?.fps ?? 30;
+  const audio = new AudioOutput();
+  const renderer = new VideoRenderer(target, audio, fps);
+  let handles;
+  try {
+    handles = await startDecoder({
+      source,
+      filename: ctx.name ?? "input.bin",
+      context: ctx,
+      renderer,
+      audio
+    });
+  } catch (err) {
+    audio.destroy();
+    renderer.destroy();
+    throw err;
+  }
+  Object.defineProperty(target, "currentTime", {
+    configurable: true,
+    get: () => audio.now(),
+    set: (v) => {
+      void doSeek(v);
+    }
+  });
+  if (ctx.duration && Number.isFinite(ctx.duration)) {
+    Object.defineProperty(target, "duration", {
+      configurable: true,
+      get: () => ctx.duration ?? NaN
+    });
+  }
+  async function waitForBuffer() {
+    const start = performance.now();
+    while (true) {
+      const audioReady = audio.isNoAudio() || audio.bufferAhead() >= READY_AUDIO_BUFFER_SECONDS2;
+      if (audioReady && renderer.hasFrames()) {
+        return;
+      }
+      if ((performance.now() - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  async function doSeek(timeSec) {
+    const wasPlaying = audio.isPlaying();
+    await audio.pause().catch(() => {
+    });
+    await handles.seek(timeSec).catch(
+      (err) => console.warn("[avbridge] decoder seek failed:", err)
+    );
+    await audio.reset(timeSec);
+    renderer.flush();
+    if (wasPlaying) {
+      await waitForBuffer();
+      await audio.start();
+    }
+  }
+  return {
+    strategy: "fallback",
+    async play() {
+      if (!audio.isPlaying()) {
+        await waitForBuffer();
+        await audio.start();
+      }
+    },
+    pause() {
+      void audio.pause();
+    },
+    async seek(time) {
+      await doSeek(time);
+    },
+    async setAudioTrack(_id) {
+    },
+    async setSubtitleTrack(_id) {
+    },
+    getCurrentTime() {
+      return audio.now();
+    },
+    async destroy() {
+      await handles.destroy();
+      renderer.destroy();
+      audio.destroy();
+      try {
+        delete target.currentTime;
+        delete target.duration;
+      } catch {
+      }
+    },
+    getRuntimeStats() {
+      return handles.stats();
+    }
+  };
+}
+
+// src/plugins/builtin.ts
+var nativePlugin = {
+  name: "native",
+  canHandle: () => true,
+  execute: (ctx, video) => createNativeSession(ctx, video)
+};
+var remuxPlugin = {
+  name: "remux",
+  canHandle: () => true,
+  execute: (ctx, video) => createRemuxSession(ctx, video)
+};
+var hybridPlugin = {
+  name: "hybrid",
+  canHandle: () => typeof VideoDecoder !== "undefined",
+  execute: (ctx, video) => createHybridSession(ctx, video)
+};
+var fallbackPlugin = {
+  name: "fallback",
+  canHandle: () => true,
+  execute: (ctx, video) => createFallbackSession(ctx, video)
+};
+function registerBuiltins(registry) {
+  registry.register(nativePlugin);
+  registry.register(remuxPlugin);
+  registry.register(hybridPlugin);
+  registry.register(fallbackPlugin);
+}
+
+// src/subtitles/vtt.ts
+function isVtt(text) {
+  const trimmed = text.replace(/^\ufeff/, "").trimStart();
+  return trimmed.startsWith("WEBVTT");
+}
+
+// src/subtitles/index.ts
+async function discoverSidecar(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 url = URL.createObjectURL(sidecarFile);
+    const langMatch = name.slice(baseName.length).match(/[._-]([a-z]{2,3})(?:[._-]|\.)/i);
+    found.push({
+      url,
+      format,
+      language: langMatch?.[1]
+    });
+  }
+  return found;
+}
+async function attachSubtitleTracks(video, tracks) {
+  for (const t of Array.from(video.querySelectorAll("track[data-avbridge]"))) {
+    t.remove();
+  }
+  for (const t of tracks) {
+    if (!t.sidecarUrl) continue;
+    let url = 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" });
+      url = 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 track = document.createElement("track");
+    track.kind = "subtitles";
+    track.src = url;
+    track.srclang = t.language ?? "und";
+    track.label = t.language ?? `Subtitle ${t.id}`;
+    track.dataset.avbridge = "true";
+    video.appendChild(track);
+  }
+}
+
+// src/player.ts
+var UnifiedPlayer = class _UnifiedPlayer {
+  /**
+   * @internal Use {@link createPlayer} or {@link UnifiedPlayer.create} instead.
+   */
+  constructor(options, registry) {
+    this.options = options;
+    this.registry = registry;
+  }
+  options;
+  registry;
+  emitter = new TypedEmitter();
+  session = null;
+  diag = new Diagnostics();
+  timeupdateInterval = null;
+  // Saved from bootstrap for strategy switching
+  mediaContext = null;
+  classification = null;
+  // Stall detection
+  stallTimer = null;
+  lastProgressTime = 0;
+  lastProgressPosition = -1;
+  errorListener = null;
+  // Serializes escalation / setStrategy calls
+  switchingPromise = Promise.resolve();
+  static async create(options) {
+    const registry = new PluginRegistry();
+    registerBuiltins(registry);
+    if (options.plugins) {
+      for (const p of options.plugins) registry.register(
+        p,
+        /* prepend */
+        true
+      );
+    }
+    const player = new _UnifiedPlayer(options, registry);
+    try {
+      await player.bootstrap();
+    } catch (err) {
+      err.player = player;
+      throw err;
+    }
+    return player;
+  }
+  async bootstrap() {
+    try {
+      const ctx = await probe(this.options.source);
+      this.diag.recordProbe(ctx);
+      this.mediaContext = ctx;
+      if (this.options.subtitles) {
+        for (const s of this.options.subtitles) {
+          ctx.subtitleTracks.push({
+            id: ctx.subtitleTracks.length,
+            format: s.format ?? (s.url.endsWith(".srt") ? "srt" : "vtt"),
+            language: s.language,
+            sidecarUrl: s.url
+          });
+        }
+      }
+      if (this.options.directory && this.options.source instanceof File) {
+        const found = await discoverSidecar(this.options.source, this.options.directory);
+        for (const s of found) {
+          ctx.subtitleTracks.push({
+            id: ctx.subtitleTracks.length,
+            format: s.format,
+            language: s.language,
+            sidecarUrl: s.url
+          });
+        }
+      }
+      const decision = this.options.forceStrategy ? {
+        class: "NATIVE",
+        strategy: this.options.forceStrategy,
+        reason: `forced via options.forceStrategy=${this.options.forceStrategy}`
+      } : classifyContext(ctx);
+      this.classification = decision;
+      this.diag.recordClassification(decision);
+      this.emitter.emitSticky("strategy", {
+        strategy: decision.strategy,
+        reason: decision.reason
+      });
+      await this.startSession(decision.strategy, decision.reason);
+      if (this.session.strategy !== "fallback" && this.session.strategy !== "hybrid") {
+        attachSubtitleTracks(this.options.target, ctx.subtitleTracks);
+      }
+      this.emitter.emitSticky("tracks", {
+        video: ctx.videoTracks,
+        audio: ctx.audioTracks,
+        subtitle: ctx.subtitleTracks
+      });
+      this.startTimeupdateLoop();
+      this.options.target.addEventListener("ended", () => this.emitter.emit("ended", void 0));
+      this.emitter.emitSticky("ready", void 0);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      this.diag.recordError(e);
+      this.emitter.emit("error", e);
+      throw e;
+    }
+  }
+  /**
+   * Try to start a session with the given strategy. On failure, walk the
+   * fallback chain. Throws only if all strategies are exhausted.
+   */
+  async startSession(strategy, reason) {
+    const plugin = this.registry.findFor(this.mediaContext, strategy);
+    if (!plugin) {
+      throw new Error(`no plugin available for strategy "${strategy}"`);
+    }
+    try {
+      this.session = await plugin.execute(this.mediaContext, this.options.target);
+    } catch (err) {
+      const chain = this.classification?.fallbackChain;
+      if (chain && chain.length > 0) {
+        const next = chain.shift();
+        console.warn(`[avbridge] ${strategy} failed (${err.message}), escalating to ${next}`);
+        this.emitter.emit("strategychange", {
+          from: strategy,
+          to: next,
+          reason: `${strategy} failed: ${err.message}`,
+          currentTime: 0
+        });
+        this.diag.recordStrategySwitch(next, `${strategy} failed: ${err.message}`);
+        return this.startSession(next, `escalated from ${strategy}`);
+      }
+      throw err;
+    }
+    this.session.onFatalError?.((fatalReason) => {
+      void this.escalate(fatalReason);
+    });
+    this.attachSupervisor();
+    if (this.session.strategy !== strategy) {
+      this.emitter.emitSticky("strategy", {
+        strategy: this.session.strategy,
+        reason
+      });
+    }
+  }
+  // ── Escalation ──────────────────────────────────────────────────────────
+  async escalate(reason) {
+    this.switchingPromise = this.switchingPromise.then(
+      () => this.doEscalate(reason)
+    ).catch((err) => {
+      this.emitter.emit("error", err instanceof Error ? err : new Error(String(err)));
+    });
+    await this.switchingPromise;
+  }
+  async doEscalate(reason) {
+    const chain = this.classification?.fallbackChain;
+    if (!chain || chain.length === 0) {
+      this.emitter.emit("error", new Error(
+        `strategy "${this.session?.strategy}" failed: ${reason} (no fallback available)`
+      ));
+      return;
+    }
+    const currentTime = this.session?.getCurrentTime() ?? 0;
+    const wasPlaying = this.session ? !this.options.target.paused : false;
+    const fromStrategy = this.session?.strategy ?? "native";
+    const nextStrategy = chain.shift();
+    console.warn(`[avbridge] escalating from ${fromStrategy} to ${nextStrategy}: ${reason}`);
+    this.emitter.emit("strategychange", {
+      from: fromStrategy,
+      to: nextStrategy,
+      reason,
+      currentTime
+    });
+    this.diag.recordStrategySwitch(nextStrategy, reason);
+    this.clearSupervisor();
+    if (this.session) {
+      try {
+        await this.session.destroy();
+      } catch {
+      }
+      this.session = null;
+    }
+    const plugin = this.registry.findFor(this.mediaContext, nextStrategy);
+    if (!plugin) {
+      this.emitter.emit("error", new Error(`no plugin for fallback strategy "${nextStrategy}"`));
+      return;
+    }
+    try {
+      this.session = await plugin.execute(this.mediaContext, this.options.target);
+    } catch (err) {
+      this.emitter.emit("error", err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    this.emitter.emitSticky("strategy", {
+      strategy: nextStrategy,
+      reason: `escalated: ${reason}`
+    });
+    this.session.onFatalError?.((fatalReason) => {
+      void this.escalate(fatalReason);
+    });
+    this.attachSupervisor();
+    try {
+      await this.session.seek(currentTime);
+      if (wasPlaying) await this.session.play();
+    } catch (err) {
+      console.warn("[avbridge] failed to restore position after escalation:", err);
+    }
+  }
+  // ── Stall supervision ─────────────────────────────────────────────────
+  attachSupervisor() {
+    this.clearSupervisor();
+    if (this.options.autoEscalate === false) return;
+    if (!this.classification?.fallbackChain?.length) return;
+    const strategy = this.session?.strategy;
+    if (strategy === "native" || strategy === "remux") {
+      this.lastProgressPosition = this.options.target.currentTime;
+      this.lastProgressTime = performance.now();
+      this.stallTimer = setInterval(() => {
+        const t = this.options.target;
+        if (t.paused || t.ended || t.readyState < 2) {
+          this.lastProgressPosition = t.currentTime;
+          this.lastProgressTime = performance.now();
+          return;
+        }
+        if (t.currentTime !== this.lastProgressPosition) {
+          this.lastProgressPosition = t.currentTime;
+          this.lastProgressTime = performance.now();
+          return;
+        }
+        if (performance.now() - this.lastProgressTime > 5e3) {
+          void this.escalate(
+            `${strategy} strategy stalled for 5s at ${t.currentTime.toFixed(1)}s`
+          );
+        }
+      }, 1e3);
+      const onError = () => {
+        void this.escalate(
+          `${strategy} strategy error: ${this.options.target.error?.message ?? "unknown"}`
+        );
+      };
+      this.options.target.addEventListener("error", onError, { once: true });
+      this.errorListener = onError;
+    }
+  }
+  clearSupervisor() {
+    if (this.stallTimer) {
+      clearInterval(this.stallTimer);
+      this.stallTimer = null;
+    }
+    if (this.errorListener) {
+      this.options.target.removeEventListener("error", this.errorListener);
+      this.errorListener = null;
+    }
+  }
+  // ── 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.session?.strategy === strategy) return;
+    this.switchingPromise = this.switchingPromise.then(
+      () => this.doSetStrategy(strategy, reason)
+    );
+    await this.switchingPromise;
+  }
+  async doSetStrategy(strategy, reason) {
+    const currentTime = this.session?.getCurrentTime() ?? 0;
+    const wasPlaying = this.session ? !this.options.target.paused : false;
+    const fromStrategy = this.session?.strategy ?? "native";
+    const switchReason = reason ?? `manual switch to ${strategy}`;
+    this.emitter.emit("strategychange", {
+      from: fromStrategy,
+      to: strategy,
+      reason: switchReason,
+      currentTime
+    });
+    this.diag.recordStrategySwitch(strategy, switchReason);
+    this.clearSupervisor();
+    if (this.session) {
+      try {
+        await this.session.destroy();
+      } catch {
+      }
+      this.session = null;
+    }
+    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.emitter.emitSticky("strategy", {
+      strategy,
+      reason: switchReason
+    });
+    this.session.onFatalError?.((fatalReason) => {
+      void this.escalate(fatalReason);
+    });
+    this.attachSupervisor();
+    try {
+      await this.session.seek(currentTime);
+      if (wasPlaying) await this.session.play();
+    } catch (err) {
+      console.warn("[avbridge] failed to restore position after strategy switch:", err);
+    }
+  }
+  // ── Timeupdate loop ───────────────────────────────────────────────────
+  startTimeupdateLoop() {
+    this.timeupdateInterval = setInterval(() => {
+      const t = this.session?.getCurrentTime() ?? this.options.target.currentTime;
+      this.emitter.emit("timeupdate", { currentTime: t });
+    }, 250);
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  /** Subscribe to a player event. Returns an unsubscribe function. Sticky events (strategy, ready, tracks) replay for late subscribers. */
+  on(event, fn) {
+    return this.emitter.on(event, fn);
+  }
+  /** Remove a previously registered event listener. */
+  off(event, fn) {
+    this.emitter.off(event, fn);
+  }
+  /** Begin or resume playback. Throws if the player is not ready. */
+  async play() {
+    if (!this.session) throw new Error("player not ready");
+    await this.session.play();
+  }
+  /** Pause playback. No-op if the player is not ready or already paused. */
+  pause() {
+    this.session?.pause();
+  }
+  /** 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");
+    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");
+    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");
+    await this.session.setSubtitleTrack(id);
+  }
+  /** Return a snapshot of current diagnostics: container, codecs, strategy, runtime stats, and strategy history. */
+  getDiagnostics() {
+    if (this.session) {
+      this.diag.recordRuntime(this.session.getRuntimeStats());
+    }
+    return this.diag.snapshot();
+  }
+  /** Return the total duration in seconds, or `NaN` if unknown. */
+  getDuration() {
+    const fromDiag = this.diag.snapshot().duration;
+    if (typeof fromDiag === "number" && Number.isFinite(fromDiag)) return fromDiag;
+    const fromVideo = this.options.target.duration;
+    return Number.isFinite(fromVideo) ? fromVideo : NaN;
+  }
+  /** Return the current playback position in seconds. */
+  getCurrentTime() {
+    return this.session?.getCurrentTime() ?? this.options.target.currentTime ?? 0;
+  }
+  /** Tear down the player: stop timers, destroy the active session, remove all event listeners. The player is unusable after this call. */
+  async destroy() {
+    if (this.timeupdateInterval) {
+      clearInterval(this.timeupdateInterval);
+      this.timeupdateInterval = null;
+    }
+    this.clearSupervisor();
+    if (this.session) {
+      await this.session.destroy();
+      this.session = null;
+    }
+    this.emitter.removeAll();
+  }
+};
+async function createPlayer(options) {
+  return UnifiedPlayer.create(options);
+}
+
+export { UnifiedPlayer, avbridgeAudioToMediabunny, avbridgeVideoToMediabunny, buildMediabunnySourceFromInput, classifyContext, createPlayer, probe, srtToVtt };
+//# sourceMappingURL=chunk-FKM7QBZU.js.map
+//# sourceMappingURL=chunk-FKM7QBZU.js.map