avbridge 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -4,6 +4,51 @@ All notable changes to **avbridge** are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.2.1]
+
+### Fixed
+
+- **Canvas renderer no longer stretches non-stage-aspect video.** The
+  fallback + hybrid renderer's canvas sat at `width:100%;height:100%`
+  with no `object-fit`, so portrait or otherwise non-matching content
+  was stretched to fill the stage. Now uses `object-fit: contain` to
+  letterbox the bitmap inside the stage.
+- **Strategy switch to `remux` while playing now resumes playback.**
+  `doSetStrategy` calls `session.seek()` before `session.play()`, so
+  the remux pipeline used to start with `pendingAutoPlay=false`; the
+  subsequent `video.play()` would then hit an element whose `src`
+  wasn't yet assigned (the MseSink constructs lazily on first write)
+  and silently reject. `RemuxPipeline` gained `setAutoPlay()` so
+  `session.play()` can flip `pendingAutoPlay=true` mid-flight; the
+  MseSink fires `video.play()` as soon as buffered data lands.
+- **Strategy switch from `hybrid` / `fallback` to another backend now
+  preserves play state.** Those strategies hide the `<video>` and
+  drive playback from their own Web Audio clock, so the underlying
+  element's native `paused` was always `true`. `doSetStrategy` read
+  `!target.paused` and captured `wasPlaying=false`, skipping the
+  restore on the new session. Both strategies now patch a
+  configurable `paused` getter on the target that mirrors
+  `audio.isPlaying()`, and clean it up on `destroy()`.
+- **`initialStrategy` no longer retries the same failing strategy.**
+  `buildInitialDecision` inherited `natural.fallbackChain` verbatim,
+  so for a `RISKY_NATIVE` file with `initialStrategy: "remux"` the
+  chain still contained `"remux"` — on failure, `startSession` would
+  shift it off and retry `remux` before escalating. The synthetic
+  decision now filters `initial` out of the inherited chain.
+- **`UnifiedPlayer.destroy()` removes the `ended` listener it
+  attached during `bootstrap()`.** Previously the anonymous handler
+  leaked across player lifecycles on long-lived target elements
+  (e.g. `<avbridge-video>` swapping source), causing gradual
+  accumulation and duplicate `ended` events after source reloads.
+
+### Changed
+
+- Bundle audit ceiling for the `element-only` scenario raised to
+  20 KB eager gzip. The budget's purpose is catching
+  order-of-magnitude regressions (e.g. libav accidentally eager-
+  imported), not policing ±200 bytes; realistic first-play cost is
+  dominated by the multi-megabyte lazy wasm load.
+
 ## [2.2.0]
 
 ### Added

package/README.md

@@ -8,9 +8,10 @@
 > **Play and convert arbitrary video files in the browser. Local files or remote URLs.**
 
 A media compatibility layer for the web. Drop in any file — MP4, MKV, AVI,
-WMV, FLV, MPEG-TS, DivX — and avbridge picks the best path: native `<video>`
-playback, mediabunny remux to fragmented MP4, libav.js demux + WebCodecs
-hardware decode, or full WASM software decode. Same API for all of them.
+WMV, FLV, MPEG-TS, DivX, RMVB — and avbridge picks the best path: native
+`<video>` playback, mediabunny remux to fragmented MP4, libav.js demux +
+WebCodecs hardware decode, or full WASM software decode. Same API for all
+of them.
 
 **Streaming-first.** Remote URLs are read via HTTP Range requests across all
 strategies — even AVI/WMV/FLV — so a 4 GB file plays without buffering 4 GB
@@ -46,6 +47,7 @@ MKV (H.264/AAC)  → remux     → fragmented MP4 via MSE
 MPEG-TS (H.264)  → remux     → fragmented MP4 via MSE
 AVI (H.264)      → hybrid    → libav demux + hardware decode
 AVI (DivX)       → fallback  → smooth software decode
+RMVB (rv40/cook) → fallback  → libav software decode
 ```
 
 ## Quick start
@@ -246,107 +248,132 @@ player.getDiagnostics();
 //   reason: "avi container requires libav demux; codecs are hardware-decodable",
 //   width: 1920, height: 1080, duration: 5400,
 //   probedBy: "libav",
+//   transport: "http-range",
+//   rangeSupported: true,
+//   runtime: { decoderType: "webcodecs-hybrid", videoFramesDecoded: 5432, ... },
 //   strategyHistory: [{ strategy: "hybrid", reason: "...", at: 1712764800000 }]
 // }
 ```
 
+### Debug logging
+
+Enable verbose per-stage logging for hard-to-diagnose issues:
+
+```js
+// In the browser console, or before avbridge loads:
+globalThis.AVBRIDGE_DEBUG = true;
+```
+
+The demo pages also accept `?avbridge_debug` in the URL. When enabled,
+every decision point emits a `[avbridge:<tag>]` log covering probe,
+classify, libav load, bootstrap, strategy execute, and cold-start gate
+timings.
+
+The following **unconditional diagnostics** also fire — even without the
+flag — when something smells off:
+
+- `[avbridge:bootstrap]` — bootstrap chain took >5 s end-to-end
+- `[avbridge:probe]` — probe took >3 s
+- `[avbridge:libav-load]` — libav variant load took >5 s (usually a
+  misconfigured base path or server MIME type)
+- `[avbridge:cold-start]` — fallback cold-start gate timed out or
+  released on video-only grace after waiting for audio
+- `[avbridge:decode-rate]` — fallback decoder is running under 60% of
+  realtime fps for more than 5 seconds (one-shot per session)
+- `[avbridge:overflow-drop]` — renderer is dropping more than 10% of
+  decoded frames because the decoder is bursting faster than the
+  canvas can drain (one-shot per session)
+
+These are designed so "it works on my machine but stutters on your
+file" surfaces the specific reason in the console instead of requiring
+a live debug session.
+
 ## Install
 
 ```bash
 npm install avbridge
 ```
 
-This gives you the **core package**: probe, classify, native playback, remux,
-transcode, and subtitles. No WASM. The full library is ~17 KB gzipped, but
-tree-shaking is aggressive — what you actually pay for depends on which
-exports you import:
+That's it. **No optional peers to install, no binaries to build, no static
+file path to configure.** Both libav.js variants (the 5 MB webcodecs build
+and the 6.5 MB custom avbridge build with AVI/WMV/DivX/rv40 decoders) ship
+inside the tarball under `node_modules/avbridge/vendor/libav/` and are
+lazy-loaded at runtime only if a file actually needs them.
 
-| Import | Eager (gzip) |
-|---|---|
-| `srtToVtt` | **0.5 KB** |
-| `probe`, `classify` | **3 KB** |
-| `transcode` | **3.3 KB** |
-| `remux` | **4.1 KB** |
-| `createPlayer` | **14 KB** |
-| `*` (everything) | **17 KB** |
+Packed tarball is **~4 MB**, unpacked **~15 MB** (mostly the two WASM
+binaries). If you only ever play native MP4, you never download a single
+byte of the libav WASM — the loader is behind a dynamic `import()` that
+never fires.
 
-The libav-loader path is split into a lazy chunk (~5 KB extra) that only
-loads when a consumer actually invokes the AVI/ASF/FLV remux path.
+### Two ways to consume
 
-Run `npm run audit:bundle` to verify these numbers in your fork.
+**Bundler (Vite, webpack, Rollup, esbuild):**
 
-### Optional: fallback / hybrid strategies
+```ts
+import { createPlayer, remux, transcode, probe, classify } from "avbridge";
+// or
+import "avbridge/element";  // registers <avbridge-video> custom element
+```
 
-For files that need software decode or libav.js demux (AVI, WMV, FLV,
-legacy codecs):
+The tree-shaking budgets below apply to this path. Your bundler resolves
+`mediabunny` and `libavjs-webcodecs-bridge` through normal dependency
+resolution. libav.js binaries live at
+`node_modules/avbridge/vendor/libav/` — the loader finds them
+automatically via `import.meta.url` in the generated chunk.
 
-```bash
-npm install @libav.js/variant-webcodecs libavjs-webcodecs-bridge
-```
+**Plain `<script type="module">` (no bundler):**
 
-This handles MKV/WebM/MP4 containers via the hybrid/fallback strategies.
+```html
+<script type="module"
+        src="/node_modules/avbridge/dist/element-browser.js"></script>
 
-### Optional: AVI, WMV3, DivX, and other legacy formats
+<avbridge-video src="/video.mkv" autoplay playsinline></avbridge-video>
+```
 
-For **AVI, WMV3, MPEG-4 Part 2, DivX**, and other legacy formats, you need
-a custom libav.js build — see [`vendor/libav/README.md`](./vendor/libav/README.md)
-for the build recipe.
+This is a second tsup entry (`dist/element-browser.js`) that inlines
+mediabunny + libavjs-webcodecs-bridge into a single ~1.3 MB file with
+zero bare specifiers at runtime. Perfect for self-hosted tools or static
+sites that don't want a build step. It loads libav.js from the same
+co-located `vendor/libav/` tree.
 
-### Package boundary summary
+### Bundle sizes (bundler path)
 
-| What you need | What to install |
+| Import | Eager (gzip) |
 |---|---|
-| Playback of MP4/MKV/WebM/**MPEG-TS** + remux/transcode export | `avbridge` (core, no WASM) |
-| Fallback/hybrid decode for modern codecs in legacy containers (AVI/ASF/FLV) | + `@libav.js/variant-webcodecs` + `libavjs-webcodecs-bridge` |
-| AVI, WMV3, DivX, MPEG-4 Part 2, VC-1 | + custom libav build (`scripts/build-libav.sh`) |
-
-### Serving the libav.js binaries
+| `srtToVtt` | **0.5 KB** |
+| `probe`, `classify` | **2.5 KB** |
+| `transcode` | **3 KB** |
+| `remux` | **3.7 KB** |
+| `createPlayer` | **15 KB** |
+| `*` (everything) | **17.5 KB** |
+| `avbridge/element` | **17 KB** |
 
-The optional libav variants ship as `.wasm` + `.mjs` files that need to be
-served by your app at a known URL. avbridge looks for them at
-`/libav/<variant>/libav-<variant>.mjs` (where `<variant>` is `webcodecs` or
-`avbridge`). You can override the base URL with
-`globalThis.AVBRIDGE_LIBAV_BASE = "/my-static-path"` before any avbridge
-code runs.
+Run `npm run audit:bundle` to verify in your fork.
 
-#### Vite
+### Overriding the libav path (advanced)
 
-Copy the variant binaries into your `public/libav/` directory at build
-time. The avbridge demo does this via `scripts/copy-libav.mjs`:
+If you want to host the libav binaries somewhere other than
+`node_modules/avbridge/vendor/libav/` — for example a CDN, a custom
+libav build, or a patched version — set `AVBRIDGE_LIBAV_BASE` **before**
+any avbridge code runs:
 
-```bash
-# In your project, after npm install:
-mkdir -p public/libav/webcodecs
-cp node_modules/@libav.js/variant-webcodecs/dist/* public/libav/webcodecs/
+```html
+<script>globalThis.AVBRIDGE_LIBAV_BASE = "https://cdn.example.com/libav";</script>
+<script type="module" src="..."></script>
 ```
 
-For the custom `avbridge` variant, after running `./scripts/build-libav.sh`
-in the avbridge repo, copy `vendor/libav/*` into `public/libav/avbridge/`.
-
-#### Webpack
-
-Use `copy-webpack-plugin` to ship the binaries to your output directory at
-the same `libav/<variant>/` path.
-
-#### Plain `<script>` / no bundler
-
-Drop the variant directory anywhere on your origin and set
-`globalThis.AVBRIDGE_LIBAV_BASE` to the matching URL before importing
-avbridge.
-
-If a libav-backed strategy is selected and the binary isn't reachable,
-avbridge throws a clear error mentioning the URL it tried to load. The
-core (native + remux for modern containers) doesn't need any of this.
+The loader will then fetch `<base>/<variant>/libav-<variant>.mjs` and its
+sibling `.wasm` files. This is the documented replaceability hook for
+LGPL compliance — see [`NOTICE.md`](./NOTICE.md) and
+[`THIRD_PARTY_LICENSES.md`](./THIRD_PARTY_LICENSES.md).
 
 ## Known limitations
 
-- The **fallback strategy** uses WASM software decoding and is CPU-intensive, especially for HD video on mobile devices.
-- **Remux of AVI/ASF/FLV** requires libav.js — the core package cannot demux these containers.
+- The **fallback strategy** uses WASM software decoding and is CPU-intensive, especially for HD video on mobile devices. The `[avbridge:decode-rate]` diagnostic fires if the decoder falls below 60% of realtime so you know that's what's happening. Codecs with no WebCodecs support (rv40, mpeg4 @ 720p+, wmv3, vc1 at high resolutions) are the usual suspects.
 - **Remote URL playback requires HTTP Range requests.** Servers that don't support `Range: bytes=...` will fail fast with a clear error rather than silently downloading the whole file. This applies to all strategies.
 - **H.264 + MP3 in MP4** is a best-effort combination that may produce playback issues in some browsers. Use `strict: true` to reject it, or re-encode audio to AAC via `transcode()`.
-- AVI files with **packed B-frames** (some DivX encodes) may have timing issues until the `mpeg4_unpack_bframes` BSF is wired in.
-- libav.js **threading is disabled** due to bugs in v6.8.8 — decode runs single-threaded with SIMD acceleration.
-- `transcode()` v1 only accepts mediabunny-readable inputs (MP4/MKV/WebM/OGG/MOV/MP3/FLAC/WAV). AVI/ASF/FLV transcoding is planned for v1.1.
+- libav.js **threading is disabled** due to known runtime bugs in the v6.8.8 pthreads build — decode runs single-threaded with WASM SIMD acceleration.
+- `transcode()` only accepts mediabunny-readable inputs (MP4/MKV/WebM/OGG/MOV/MP3/FLAC/WAV). AVI/ASF/FLV/RM transcoding means "play it first, record the output" — not yet plumbed.
 - `transcode()` uses **WebCodecs encoders only** — codec availability depends on the browser. AV1 encoding is not yet universal.
 - For the **hybrid and fallback strategies**, `<avbridge-video>.buffered` returns an empty `TimeRanges` because the canvas-based renderers don't track buffered ranges yet. Native and remux strategies expose the full `<video>.buffered` set as expected.
 

package/dist/{chunk-C5VA5U5O.js → chunk-DMWARSEF.js}

@@ -1070,6 +1070,10 @@ async function createRemuxPipeline(ctx, video) {
         console.error("[avbridge] remux pipeline reseek failed:", err);
       });
     },
+    setAutoPlay(autoPlay) {
+      pendingAutoPlay = autoPlay;
+      if (sink) sink.setPlayOnSeek(autoPlay);
+    },
     async destroy() {
       destroyed = true;
       pumpToken++;
@@ -1110,7 +1114,11 @@ async function createRemuxSession(context, video) {
         await pipeline.start(video.currentTime || 0, true);
         return;
       }
-      await video.play();
+      pipeline.setAutoPlay(true);
+      try {
+        await video.play();
+      } catch {
+      }
     },
     pause() {
       wantPlay = false;
@@ -1158,7 +1166,7 @@ var VideoRenderer = class {
       this.resolveFirstFrame = resolve;
     });
     this.canvas = document.createElement("canvas");
-    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;";
+    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;object-fit:contain;";
     const parent = target.parentElement ?? target.parentNode;
     if (parent && parent instanceof HTMLElement) {
       if (getComputedStyle(parent).position === "static") {
@@ -1400,9 +1408,13 @@ var AudioOutput = class {
     const node = this.ctx.createBufferSource();
     node.buffer = buffer;
     node.connect(this.gain);
-    const ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
-    const safeStart = Math.max(ctxStart, this.ctx.currentTime);
-    node.start(safeStart);
+    let ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
+    if (ctxStart < this.ctx.currentTime) {
+      this.ctxTimeAtAnchor = this.ctx.currentTime;
+      this.mediaTimeOfAnchor = this.mediaTimeOfNext;
+      ctxStart = this.ctx.currentTime;
+    }
+    node.start(ctxStart);
     this.mediaTimeOfNext += frameCount / sampleRate;
     this.framesScheduled++;
   }
@@ -1970,6 +1982,10 @@ async function createHybridSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -2034,6 +2050,7 @@ async function createHybridSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
       } catch {
       }
     },
@@ -2113,7 +2130,8 @@ async function startDecoder(opts) {
   let audioFramesDecoded = 0;
   let watchdogFirstFrameMs = 0;
   let watchdogSlowSinceMs = 0;
-  let watchdogWarned = false;
+  let watchdogSlowWarned = false;
+  let watchdogOverflowWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
@@ -2125,7 +2143,7 @@ async function startDecoder(opts) {
       let packets;
       try {
         [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
-          limit: 64 * 1024
+          limit: 16 * 1024
         });
       } catch (err) {
         console.error("[avbridge] ff_read_frame_multi failed:", err);
@@ -2134,26 +2152,26 @@ async function startDecoder(opts) {
       if (myToken !== pumpToken || destroyed) return;
       const videoPackets = videoStream ? packets[videoStream.index] : void 0;
       const audioPackets = audioStream ? packets[audioStream.index] : void 0;
-      if (videoDec && videoPackets && videoPackets.length > 0) {
-        await decodeVideoBatch(videoPackets, myToken);
-      }
-      if (myToken !== pumpToken || destroyed) return;
       if (audioDec && audioPackets && audioPackets.length > 0) {
         await decodeAudioBatch(audioPackets, myToken);
       }
+      if (myToken !== pumpToken || destroyed) return;
+      if (videoDec && videoPackets && videoPackets.length > 0) {
+        await decodeVideoBatch(videoPackets, myToken);
+      }
       packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
       if (videoFramesDecoded > 0) {
         if (watchdogFirstFrameMs === 0) {
           watchdogFirstFrameMs = performance.now();
         }
         const elapsedSinceFirst = (performance.now() - watchdogFirstFrameMs) / 1e3;
-        if (elapsedSinceFirst > 1 && !watchdogWarned) {
+        if (elapsedSinceFirst > 1 && !watchdogSlowWarned) {
           const expectedFrames = elapsedSinceFirst * videoFps;
           const ratio = videoFramesDecoded / expectedFrames;
           if (ratio < 0.6) {
             if (watchdogSlowSinceMs === 0) watchdogSlowSinceMs = performance.now();
             if ((performance.now() - watchdogSlowSinceMs) / 1e3 > 5) {
-              watchdogWarned = true;
+              watchdogSlowWarned = true;
               console.warn(
                 "[avbridge:decode-rate]",
                 `decoder is running slower than realtime: ${videoFramesDecoded} frames in ${elapsedSinceFirst.toFixed(1)}s (${(videoFramesDecoded / elapsedSinceFirst).toFixed(1)} fps vs ${videoFps} fps source \u2014 ${(ratio * 100).toFixed(0)}% of realtime). Playback will stutter. Typical causes: software decode of a codec with no WebCodecs support (rv40, mpeg4 @ 720p+, wmv3), or a resolution too large for single-threaded WASM to keep up with.`
@@ -2163,6 +2181,17 @@ async function startDecoder(opts) {
             watchdogSlowSinceMs = 0;
           }
         }
+        if (!watchdogOverflowWarned && videoFramesDecoded > 100) {
+          const rendererStats = opts.renderer.stats();
+          const overflow = rendererStats.framesDroppedOverflow ?? 0;
+          if (overflow / videoFramesDecoded > 0.1) {
+            watchdogOverflowWarned = true;
+            console.warn(
+              "[avbridge:overflow-drop]",
+              `renderer is dropping ${overflow}/${videoFramesDecoded} frames (${(overflow / videoFramesDecoded * 100).toFixed(0)}%) because the decoder is producing bursts faster than the canvas can drain. Symptom: choppy playback despite decoder keeping up on average. Fix would be smaller read batches in the pump loop or a lower queueHighWater cap \u2014 see src/strategies/fallback/decoder.ts.`
+            );
+          }
+        }
       }
       while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
         await new Promise((r) => setTimeout(r, 50));
@@ -2519,6 +2548,10 @@ async function createFallbackSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -2527,25 +2560,35 @@ async function createFallbackSession(ctx, target) {
   }
   async function waitForBuffer() {
     const start = performance.now();
+    let firstFrameAtMs = 0;
     dbg.info(
       "cold-start",
-      `gate entry: need audio >= ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms + 1 frame`
+      `gate entry: want audio \u2265 ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms + 1 frame`
     );
     while (true) {
       const audioAhead = audio.isNoAudio() ? Infinity : audio.bufferAhead();
       const audioReady = audio.isNoAudio() || audioAhead >= READY_AUDIO_BUFFER_SECONDS2;
       const hasFrames = renderer.hasFrames();
+      const nowMs = performance.now();
+      if (hasFrames && firstFrameAtMs === 0) firstFrameAtMs = nowMs;
       if (audioReady && hasFrames) {
         dbg.info(
           "cold-start",
-          `gate satisfied in ${(performance.now() - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
+          `gate satisfied in ${(nowMs - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
         );
         return;
       }
-      if ((performance.now() - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
+      if (hasFrames && firstFrameAtMs > 0 && nowMs - firstFrameAtMs >= 500) {
+        dbg.info(
+          "cold-start",
+          `gate released on video-only grace at ${(nowMs - start).toFixed(0)}ms (frames=${renderer.queueDepth()}, audio=${(audioAhead * 1e3).toFixed(0)}ms \u2014 demuxer hasn't delivered audio packets yet, starting anyway and letting the audio scheduler catch up at its media-time anchor)`
+        );
+        return;
+      }
+      if ((nowMs - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
         dbg.diag(
           "cold-start",
-          `gate TIMEOUT after ${READY_TIMEOUT_SECONDS2}s \u2014 audio=${(audioAhead * 1e3).toFixed(0)}ms (needed ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms), frames=${renderer.queueDepth()} (needed \u22651). Software decoder is producing output slower than realtime \u2014 playback will stutter. Check getDiagnostics().runtime for the decode rate.`
+          `gate TIMEOUT after ${READY_TIMEOUT_SECONDS2}s \u2014 audio=${(audioAhead * 1e3).toFixed(0)}ms (needed ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms), frames=${renderer.queueDepth()} (needed \u22651). Decoder produced nothing in ${READY_TIMEOUT_SECONDS2}s \u2014 either a corrupt source, a missing codec, or WASM is catastrophically slow on this file. Check getDiagnostics().runtime for decode counters.`
         );
         return;
       }
@@ -2594,6 +2637,7 @@ async function createFallbackSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
       } catch {
       }
     },
@@ -2736,6 +2780,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
   lastProgressTime = 0;
   lastProgressPosition = -1;
   errorListener = null;
+  // Bound so we can removeEventListener in destroy(); without this the
+  // listener outlives the player and accumulates on elements that swap
+  // source (e.g. <avbridge-video>).
+  endedListener = null;
   // Serializes escalation / setStrategy calls
   switchingPromise = Promise.resolve();
   // Owns blob URLs created during sidecar discovery + SRT->VTT conversion.
@@ -2821,7 +2869,8 @@ var UnifiedPlayer = class _UnifiedPlayer {
         subtitle: ctx.subtitleTracks
       });
       this.startTimeupdateLoop();
-      this.options.target.addEventListener("ended", () => this.emitter.emit("ended", void 0));
+      this.endedListener = () => this.emitter.emit("ended", void 0);
+      this.options.target.addEventListener("ended", this.endedListener);
       this.emitter.emitSticky("ready", void 0);
       const bootstrapElapsed = performance.now() - bootstrapStart;
       dbg.info("bootstrap", `ready in ${bootstrapElapsed.toFixed(0)}ms`);
@@ -3107,6 +3156,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       this.timeupdateInterval = null;
     }
     this.clearSupervisor();
+    if (this.endedListener) {
+      this.options.target.removeEventListener("ended", this.endedListener);
+      this.endedListener = null;
+    }
     if (this.session) {
       await this.session.destroy();
       this.session = null;
@@ -3121,11 +3174,13 @@ async function createPlayer(options) {
 function buildInitialDecision(initial, ctx) {
   const natural = classifyContext(ctx);
   const cls = strategyToClass(initial, natural);
+  const inherited = natural.fallbackChain ?? defaultFallbackChain(initial);
+  const fallbackChain = inherited.filter((s) => s !== initial);
   return {
     class: cls,
     strategy: initial,
     reason: `initial strategy "${initial}" requested via options.initialStrategy`,
-    fallbackChain: natural.fallbackChain ?? defaultFallbackChain(initial)
+    fallbackChain
   };
 }
 function strategyToClass(strategy, natural) {
@@ -3155,5 +3210,5 @@ function defaultFallbackChain(strategy) {
 }
 
 export { UnifiedPlayer, avbridgeAudioToMediabunny, avbridgeVideoToMediabunny, buildMediabunnySourceFromInput, classifyContext, createPlayer, probe, srtToVtt };
-//# sourceMappingURL=chunk-C5VA5U5O.js.map
-//# sourceMappingURL=chunk-C5VA5U5O.js.map
+//# sourceMappingURL=chunk-DMWARSEF.js.map
+//# sourceMappingURL=chunk-DMWARSEF.js.map