avbridge 2.8.4 → 2.9.0

package/dist/{remux-WBYIZBBX.js → remux-56V7LDAD.js}

@@ -1,10 +1,10 @@
-export { createOutputFormat, generateFilename, mimeForFormat, remux, validateRemuxEligibility } from './chunk-SMH6IOP2.js';
-import './chunk-SR3MPV4D.js';
+export { createOutputFormat, generateFilename, mimeForFormat, remux, validateRemuxEligibility } from './chunk-CL6UEUQF.js';
+import './chunk-GYIJU44C.js';
 import './chunk-CPJLFFCC.js';
 import './chunk-LUFA47FP.js';
-import './chunk-X2K3GIWE.js';
+import './chunk-2NSOOMXW.js';
 import './chunk-DCSOQH2N.js';
 import './chunk-5DMTJVIU.js';
 import './chunk-5YAWWKA3.js';
-//# sourceMappingURL=remux-WBYIZBBX.js.map
-//# sourceMappingURL=remux-WBYIZBBX.js.map
+//# sourceMappingURL=remux-56V7LDAD.js.map
+//# sourceMappingURL=remux-56V7LDAD.js.map

package/dist/{remux-WBYIZBBX.js.map → remux-56V7LDAD.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"remux-WBYIZBBX.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"remux-56V7LDAD.js"}

package/dist/{remux-OBSMIENG.cjs → remux-KUS5GIL6.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkQ2VUO52Z_cjs = require('./chunk-Q2VUO52Z.cjs');
-require('./chunk-ZCUXHW55.cjs');
+var chunkOTFS7DC4_cjs = require('./chunk-OTFS7DC4.cjs');
+require('./chunk-BYGZN4Z5.cjs');
 require('./chunk-2IJ66NTD.cjs');
 require('./chunk-QDJLQR53.cjs');
-require('./chunk-CPZ7PXAM.cjs');
+require('./chunk-L7A3ECI2.cjs');
 require('./chunk-Z33SBWL5.cjs');
 require('./chunk-G4APZMCP.cjs');
 require('./chunk-F3LQJKXK.cjs');
@@ -13,23 +13,23 @@ require('./chunk-F3LQJKXK.cjs');
 
 Object.defineProperty(exports, "createOutputFormat", {
   enumerable: true,
-  get: function () { return chunkQ2VUO52Z_cjs.createOutputFormat; }
+  get: function () { return chunkOTFS7DC4_cjs.createOutputFormat; }
 });
 Object.defineProperty(exports, "generateFilename", {
   enumerable: true,
-  get: function () { return chunkQ2VUO52Z_cjs.generateFilename; }
+  get: function () { return chunkOTFS7DC4_cjs.generateFilename; }
 });
 Object.defineProperty(exports, "mimeForFormat", {
   enumerable: true,
-  get: function () { return chunkQ2VUO52Z_cjs.mimeForFormat; }
+  get: function () { return chunkOTFS7DC4_cjs.mimeForFormat; }
 });
 Object.defineProperty(exports, "remux", {
   enumerable: true,
-  get: function () { return chunkQ2VUO52Z_cjs.remux; }
+  get: function () { return chunkOTFS7DC4_cjs.remux; }
 });
 Object.defineProperty(exports, "validateRemuxEligibility", {
   enumerable: true,
-  get: function () { return chunkQ2VUO52Z_cjs.validateRemuxEligibility; }
+  get: function () { return chunkOTFS7DC4_cjs.validateRemuxEligibility; }
 });
-//# sourceMappingURL=remux-OBSMIENG.cjs.map
-//# sourceMappingURL=remux-OBSMIENG.cjs.map
+//# sourceMappingURL=remux-KUS5GIL6.cjs.map
+//# sourceMappingURL=remux-KUS5GIL6.cjs.map

package/dist/{remux-OBSMIENG.cjs.map → remux-KUS5GIL6.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"remux-OBSMIENG.cjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"remux-KUS5GIL6.cjs"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avbridge",
-  "version": "2.8.4",
+  "version": "2.9.0",
   "description": "Play and convert arbitrary video files in the browser. Native, remux, hybrid, fallback, and transcode — one API.",
   "license": "MIT",
   "author": "Keishi Hattori",

package/src/classify/rules.ts

@@ -31,6 +31,8 @@ export const FALLBACK_VIDEO_CODECS = new Set<VideoCodec>([
   "wmv3", "vc1", "mpeg4",
   "rv10", "rv20", "rv30", "rv40",
   "mpeg2", "mpeg1", "theora",
+  "dv", "hq_hqa",
+  "rawvideo", "qtrle", "png", "vp6f",
 ]);
 export const FALLBACK_AUDIO_CODECS = new Set<AudioCodec>([
   "wmav2", "wmapro", "ac3", "eac3",

package/src/element/avbridge-player.ts

@@ -167,6 +167,7 @@ export class AvbridgePlayerElement extends HTMLElement {
     <div part="toolbar-top-left" class="avp-toolbar-top-left"><slot name="top-left"></slot></div>
     <div part="toolbar-top-right" class="avp-toolbar-top-right"><slot name="top-right"></slot></div>
   </div>
+  <div part="content-overlay" class="avp-content-overlay"><slot name="content-overlay"></slot></div>
   <div part="overlay" class="avp-overlay">
     <button class="avp-overlay-btn" aria-label="Play">${ICON_PLAY}</button>
     <div class="avp-spinner"></div>
@@ -441,21 +442,25 @@ export class AvbridgePlayerElement extends HTMLElement {
     this._userSeeking = true;
     const seekBar = this.shadowRoot!.querySelector(".avp-seek") as HTMLElement;
     seekBar.setPointerCapture(e.pointerId);
+    seekBar.setAttribute("data-seeking", "");
 
     const initial = this._timeFromSeekPointer(e.clientX);
     this._seekInput.value = String(initial);
     this._onSeekInput();
+    this._updateSeekTooltip(e.clientX);
 
     const onMove = (ev: PointerEvent) => {
       const t = this._timeFromSeekPointer(ev.clientX);
       this._seekInput.value = String(t);
       this._onSeekInput();
+      this._updateSeekTooltip(ev.clientX);
     };
     const onUp = (ev: PointerEvent) => {
       const t = this._timeFromSeekPointer(ev.clientX);
       this._seekInput.value = String(t);
       this._onSeekCommit();
-      this._seekInput.focus(); // keep keyboard nav responsive
+      this._seekInput.focus();
+      seekBar.removeAttribute("data-seeking");
       seekBar.removeEventListener("pointermove", onMove);
       seekBar.removeEventListener("pointerup", onUp);
       seekBar.removeEventListener("pointercancel", onUp);
@@ -467,8 +472,12 @@ export class AvbridgePlayerElement extends HTMLElement {
   }
 
   private _onSeekHover(e: PointerEvent): void {
+    this._updateSeekTooltip(e.clientX);
+  }
+
+  private _updateSeekTooltip(clientX: number): void {
     const rect = this._seekInput.getBoundingClientRect();
-    const frac = Math.max(0, Math.min(1, (e.clientX - rect.left) / rect.width));
+    const frac = Math.max(0, Math.min(1, (clientX - rect.left) / rect.width));
     const t = frac * (this._video.duration || 0);
     this._seekTooltip.textContent = formatTime(t);
     this._seekTooltip.style.left = `${frac * 100}%`;
@@ -727,13 +736,15 @@ export class AvbridgePlayerElement extends HTMLElement {
   /** Track whether the last interaction was touch so click handler can skip. */
   private _lastPointerTypeWasTouch = false;
 
-  /** True if the event's composed path passes through consumer-slotted toolbar
-   *  content. Slotted content lives in the light DOM so `.closest(".avp-toolbar-top")`
-   *  on the event target won't find the shadow-DOM wrapper — `composedPath()`
-   *  does. */
-  private _isToolbarEvent(e: Event): boolean {
+  /** True if the event's composed path passes through consumer-slotted
+   *  content (toolbar or content-overlay). Slotted content lives in the
+   *  light DOM so `.closest(".avp-toolbar-top")` on the event target won't
+   *  find the shadow-DOM wrapper — `composedPath()` does. */
+  private _isSlottedContentEvent(e: Event): boolean {
     for (const node of e.composedPath()) {
-      if (node instanceof HTMLElement && node.classList.contains("avp-toolbar-top")) return true;
+      if (node instanceof HTMLElement &&
+        (node.classList.contains("avp-toolbar-top") ||
+         node.classList.contains("avp-content-overlay"))) return true;
     }
     return false;
   }
@@ -741,7 +752,7 @@ export class AvbridgePlayerElement extends HTMLElement {
   private _onContainerClick(e: MouseEvent): void {
     // Ignore clicks on controls
     if ((e.target as HTMLElement).closest?.(".avp-controls, .avp-settings, .avp-overlay-btn")) return;
-    if (this._isToolbarEvent(e)) return;
+    if (this._isSlottedContentEvent(e)) return;
 
     // Touch taps are handled by _onPointerUp (show/hide controls + double-tap).
     // The browser fires a synthetic click after touchend — skip it.
@@ -760,7 +771,7 @@ export class AvbridgePlayerElement extends HTMLElement {
 
   private _onContainerDblClick(e: MouseEvent): void {
     if ((e.target as HTMLElement).closest?.(".avp-controls, .avp-settings")) return;
-    if (this._isToolbarEvent(e)) return;
+    if (this._isSlottedContentEvent(e)) return;
     // Cancel the pending single-click play/pause
     if (this._tapTimer) { clearTimeout(this._tapTimer); this._tapTimer = null; }
     this._toggleFullscreen();
@@ -786,7 +797,7 @@ export class AvbridgePlayerElement extends HTMLElement {
 
     // Ignore touches on controls — buttons have their own handlers
     if ((e.target as HTMLElement).closest?.(".avp-controls, .avp-settings, .avp-overlay-btn")) return;
-    if (this._isToolbarEvent(e)) return;
+    if (this._isSlottedContentEvent(e)) return;
 
     // Double-tap detection
     const now = Date.now();

package/src/element/avbridge-video.ts

@@ -598,10 +598,21 @@ export class AvbridgeVideoElement extends HTMLElementCtor {
   }
 
   get muted(): boolean {
-    return this.hasAttribute("muted");
+    // Read through to the inner <video>'s IDL property — on canvas
+    // strategies the property is patched via Object.defineProperty to
+    // mirror AudioOutput state, and consumers need the truthful value.
+    return this._videoEl.muted;
   }
 
   set muted(value: boolean) {
+    // Drive the IDL property (fires volumechange per HTML spec) rather
+    // than toggling the attribute (which on most browsers is parse-time
+    // only and does NOT fire volumechange when toggled runtime). On
+    // canvas strategies, the property is patched via Object.defineProperty
+    // which also dispatches volumechange; one code path, both worlds.
+    this._videoEl.muted = value;
+    // Keep the attribute in sync so CSS selectors like [muted] and
+    // re-queries via getAttribute reflect current state.
     if (value) this.setAttribute("muted", "");
     else this.removeAttribute("muted");
   }
@@ -683,11 +694,16 @@ export class AvbridgeVideoElement extends HTMLElementCtor {
 
   /**
    * Buffered time ranges for the active source. Mirrors the standard
-   * `<video>.buffered` `TimeRanges` API. For the native and remux strategies
-   * this reflects the underlying SourceBuffer / progressive download state.
-   * For the hybrid and fallback (canvas-rendered) strategies it currently
-   * returns an empty TimeRanges; a future release will synthesize a coarse
-   * range from the decoder's read position.
+   * `<video>.buffered` `TimeRanges` API.
+   *
+   * - **Native / remux:** pass-through to the real `<video>.buffered`
+   *   (reflects the browser's SourceBuffer / progressive-download state).
+   * - **Hybrid / fallback:** a single `[0, frontier]` range synthesized
+   *   from the demuxer's read progress — "how far libav has ever pumped
+   *   packets through." Monotonic; does not shrink on seek. This is an
+   *   approximation, not MSE-fidelity: decoded frames on canvas strategies
+   *   are consumed in flight, so we can't report per-range availability
+   *   the way MSE does. Enough for a seek-bar buffered indicator.
    */
   get buffered(): TimeRanges {
     return this._videoEl.buffered;

package/src/element/player-styles.ts

@@ -25,11 +25,18 @@ export const PLAYER_STYLES = /* css */ `
 
 /* ── Container ────────────────────────────────────────────────────────── */
 
+:host {
+  -webkit-tap-highlight-color: transparent;
+  outline: none;
+}
+
 .avp {
   position: relative;
   width: 100%;
   height: 100%;
   cursor: pointer;
+  -webkit-tap-highlight-color: transparent;
+  user-select: none;
 }
 
 .avp avbridge-video {
@@ -228,7 +235,14 @@ export const PLAYER_STYLES = /* css */ `
   pointer-events: auto;
 }
 
-.avp-toolbar-top-right { margin-left: auto; }
+/* Left slot fills remaining space so slotted text/content can grow.
+   min-width: 0 prevents flex children from overflowing the toolbar. */
+.avp-toolbar-top-left {
+  flex: 1;
+  min-width: 0;
+}
+
+.avp-toolbar-top-right { margin-left: auto; flex-shrink: 0; }
 
 /* Hide the gradient band when no consumer has slotted anything — we
    toggle data-toolbar-empty from JS via slotchange. */
@@ -241,6 +255,30 @@ export const PLAYER_STYLES = /* css */ `
   pointer-events: none;
 }
 
+/* ── Content overlay ─────────────────────────────────────────────────── */
+/* Consumer-provided rich content (tweet cards, media info, annotations).
+   Sits above the video, below the play-button overlay and controls in
+   z-order. Auto-hides with the chrome. The wrapper is pointer-events:none
+   so taps fall through to the video; consumers opt in on their content
+   with pointer-events:auto. */
+
+.avp-content-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 1;
+  pointer-events: none;
+  opacity: 1;
+  transition: opacity 0.25s;
+}
+
+.avp-content-overlay ::slotted(*) {
+  pointer-events: auto;
+}
+
+:host([data-controls-hidden]) .avp-content-overlay {
+  opacity: 0;
+}
+
 /* ── Seek bar ─────────────────────────────────────────────────────────── */
 
 .avp-seek {
@@ -327,6 +365,15 @@ export const PLAYER_STYLES = /* css */ `
 
 .avp-seek:hover .avp-seek-tooltip { display: block; }
 
+/* Show tooltip during active drag (touch or mouse). The JS side sets
+   data-seeking on .avp-seek while the user is scrubbing. */
+.avp-seek[data-seeking] .avp-seek-tooltip { display: block; }
+
+/* Enlarge thumb while scrubbing. */
+.avp-seek[data-seeking] .avp-seek-thumb {
+  transform: translate(-50%, -50%) scale(1.4);
+}
+
 /* ── Bottom row ───────────────────────────────────────────────────────── */
 
 .avp-bottom {
@@ -446,7 +493,10 @@ export const PLAYER_STYLES = /* css */ `
   background: rgba(28, 28, 28, 0.95);
   border-radius: 8px;
   min-width: 220px;
-  max-height: 300px;
+  /* Fit within the player: leave room for the controls bar (52px bottom)
+     and a small top margin (8px). On tall players this caps at 300px;
+     on short players it shrinks to whatever fits. */
+  max-height: min(300px, calc(100% - 52px - 8px));
   overflow-y: auto;
   display: none;
   z-index: 10;
@@ -518,9 +568,24 @@ export const PLAYER_STYLES = /* css */ `
 @media (pointer: coarse) {
   .avp-btn svg { width: 28px; height: 28px; }
   .avp-btn { padding: 8px; }
+
+  /* Taller touch target on mobile (44px, matching YouTube Mobile)
+     while keeping the visual track thin. Negative margin collapses
+     the extra space so the controls layout doesn't shift. */
+  .avp-seek { height: 44px; margin-top: -12px; margin-bottom: -12px; }
   .avp-seek-track { height: 4px; }
   .avp-seek:hover .avp-seek-track { height: 4px; }
-  .avp-seek-thumb { transform: translate(-50%, -50%) scale(1); }
+  .avp-seek-thumb {
+    transform: translate(-50%, -50%) scale(1);
+    width: 16px;
+    height: 16px;
+  }
+  .avp-seek[data-seeking] .avp-seek-thumb {
+    transform: translate(-50%, -50%) scale(1.5);
+  }
+  /* Move tooltip above the taller touch zone. */
+  .avp-seek-tooltip { bottom: 32px; }
+
   .avp-volume:hover .avp-volume-slider { width: 0; }
   .avp-overlay-btn { width: 56px; height: 56px; }
   .avp-overlay-btn svg { width: 30px; height: 30px; }

package/src/probe/avi.ts

@@ -181,6 +181,8 @@ function ffmpegToAvbridgeVideo(name: string): VideoCodec {
     case "rv20":   return "rv20";
     case "rv30":   return "rv30";
     case "rv40":   return "rv40";
+    case "dvvideo": return "dv";       // DV / DVCPRO (camcorder, MiniDV)
+    case "hq_hqa": return "hq_hqa";    // Canopus HQ / HQA (Grass Valley)
     default:       return name as VideoCodec;
   }
 }

package/src/strategies/fallback/decoder.ts

@@ -32,6 +32,7 @@ import { dbg } from "../../util/debug.js";
 import {
   sanitizeFrameTimestamp,
   libavFrameToInterleavedFloat32,
+  packetPtsSec,
 } from "../../util/libav-demux.js";
 
 export interface DecoderHandles {
@@ -46,6 +47,13 @@ export interface DecoderHandles {
    */
   setAudioTrack(trackId: number, timeSec: number): Promise<void>;
   stats(): Record<string, unknown>;
+  /**
+   * The demuxer's read-ahead frontier in seconds. See
+   * `HybridDecoderHandles.bufferedUntilSec` for the full contract —
+   * same semantics, same consumer (`<video>.buffered` on canvas
+   * strategies).
+   */
+  bufferedUntilSec(): number;
 }
 
 export interface StartDecoderOptions {
@@ -222,6 +230,7 @@ export async function startDecoder(opts: StartDecoderOptions): Promise<DecoderHa
 
   let packetsRead = 0;
   let videoFramesDecoded = 0;
+  let bufferedUntilSec = 0;
   let audioFramesDecoded = 0;
 
   // Decode-rate watchdog. Samples framesDecoded every second and
@@ -278,6 +287,23 @@ export async function startDecoder(opts: StartDecoderOptions): Promise<DecoderHa
       const videoPackets = videoStream ? packets[videoStream.index] : undefined;
       const audioPackets = audioStream ? packets[audioStream.index] : undefined;
 
+      // Track demuxer read-ahead for <video>.buffered on this strategy.
+      // Peek raw pts before sanitizePacketTimestamp (which would
+      // clobber to µs and lose the source-native scale). Monotonic;
+      // seeks don't reset.
+      if (videoPackets && videoTimeBase) {
+        for (const pkt of videoPackets) {
+          const sec = packetPtsSec(pkt, videoTimeBase);
+          if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
+        }
+      }
+      if (audioPackets && audioTimeBase) {
+        for (const pkt of audioPackets) {
+          const sec = packetPtsSec(pkt, audioTimeBase);
+          if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
+        }
+      }
+
       // Decode audio BEFORE video. On software-decode-bound content
       // (rv40/mpeg4/wmv3 @ 720p+) a single video batch can take
       // 200-400 ms of wall time; if the scheduler hasn't been fed
@@ -617,6 +643,10 @@ export async function startDecoder(opts: StartDecoderOptions): Promise<DecoderHa
       );
     },
 
+    bufferedUntilSec() {
+      return bufferedUntilSec;
+    },
+
     stats() {
       return {
         decoderType: "libav-wasm",

package/src/strategies/fallback/index.ts

@@ -152,6 +152,18 @@ export async function createFallbackSession(
       ? [[0, ctx.duration]]
       : []),
   });
+  // buffered: demuxer's read-ahead frontier (highest pts pumped from
+  // libav). Single [0, end] range — approximation of "how far we've
+  // read through the source," the signal the seek-bar buffered
+  // indicator wants. Real MSE-style per-range tracking isn't
+  // meaningful here since decoded frames are consumed in flight.
+  Object.defineProperty(target, "buffered", {
+    configurable: true,
+    get: () => {
+      const end = handles.bufferedUntilSec();
+      return makeTimeRanges(end > 0 ? [[0, end]] : []);
+    },
+  });
 
   /**
    * Wait until the decoder has produced enough buffered output to start
@@ -240,6 +252,11 @@ export async function createFallbackSession(
 
   async function doSeek(timeSec: number): Promise<void> {
     const wasPlaying = audio.isPlaying();
+    // HTMLMediaElement contract: dispatch `seeking` once the seek
+    // operation begins. The inner <video> never fires this itself on
+    // canvas strategies (no src), so we dispatch manually to preserve
+    // the contract for consumers listening via `<avbridge-video>`.
+    target.dispatchEvent(new Event("seeking"));
     // 1. Stop audio (suspend ctx + capture media time).
     await audio.pause().catch(() => {});
     // 2. Tell the decoder to cancel its pump and seek the demuxer.
@@ -256,8 +273,21 @@ export async function createFallbackSession(
       await waitForBuffer();
       await audio.start();
     }
+    // HTMLMediaElement contract: dispatch `seeked` after the seek has
+    // completed (demuxer + renderer reset + optional buffer refill).
+    target.dispatchEvent(new Event("seeked"));
   }
 
+  // HTMLMediaElement contract: dispatch `loadedmetadata` once the
+  // session is ready (duration, dimensions, tracks known via the
+  // MediaContext). Dispatched on a microtask so it lands after the
+  // session promise resolves and consumers have a chance to attach
+  // listeners. The inner <video> never fires this itself here — it
+  // has no src.
+  queueMicrotask(() => {
+    try { target.dispatchEvent(new Event("loadedmetadata")); } catch { /* element torn down */ }
+  });
+
   return {
     strategy: "fallback",
 

package/src/strategies/hybrid/decoder.ts

@@ -24,6 +24,7 @@ import {
   sanitizePacketTimestamp,
   sanitizeFrameTimestamp,
   libavFrameToInterleavedFloat32,
+  packetPtsSec,
 } from "../../util/libav-demux.js";
 
 export interface HybridDecoderHandles {
@@ -33,6 +34,17 @@ export interface HybridDecoderHandles {
   setAudioTrack(trackId: number, timeSec: number): Promise<void>;
   stats(): Record<string, unknown>;
   onFatalError(handler: (reason: string) => void): void;
+  /**
+   * The demuxer's read-ahead frontier in seconds — the highest pts
+   * observed on any packet handed back from `ff_read_frame_multi`.
+   * Monotonically non-decreasing: seeks don't reset it, since the
+   * frontier represents "how far we've ever demuxed through this
+   * source," which matches what a seek-bar buffered indicator should
+   * show. Backs `<video>.buffered` on canvas strategies. Returns 0
+   * before any valid pts have been seen (some AVI/FLV sources may
+   * never reach this — their `buffered` stays empty).
+   */
+  bufferedUntilSec(): number;
 }
 
 export interface StartHybridDecoderOptions {
@@ -211,6 +223,7 @@ export async function startHybridDecoder(opts: StartHybridDecoderOptions): Promi
   let videoFramesDecoded = 0;
   let audioFramesDecoded = 0;
   let videoChunksFed = 0;
+  let bufferedUntilSec = 0;
 
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
@@ -239,6 +252,24 @@ export async function startHybridDecoder(opts: StartHybridDecoderOptions): Promi
       const videoPackets = videoStream ? packets[videoStream.index] : undefined;
       const audioPackets = audioStream ? packets[audioStream.index] : undefined;
 
+      // Track how far the demuxer has read through the source — the
+      // signal behind `<video>.buffered` on this strategy. Peek at raw
+      // packet pts using each stream's native time_base (before the
+      // sanitizePacketTimestamp call later in the loop, which
+      // overwrites to µs). Monotonic: we never walk it backward.
+      if (videoPackets && videoTimeBase) {
+        for (const pkt of videoPackets) {
+          const sec = packetPtsSec(pkt, videoTimeBase);
+          if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
+        }
+      }
+      if (audioPackets && audioTimeBase) {
+        for (const pkt of audioPackets) {
+          const sec = packetPtsSec(pkt, audioTimeBase);
+          if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
+        }
+      }
+
       // Decode audio BEFORE video. Same rationale as fallback decoder
       // (POSTMORTEMS.md entry 1, fix #2): audio decode via libav's
       // ff_decode_multi is a blocking WASM call that prevents rAF from
@@ -519,6 +550,10 @@ export async function startHybridDecoder(opts: StartHybridDecoderOptions): Promi
       );
     },
 
+    bufferedUntilSec() {
+      return bufferedUntilSec;
+    },
+
     stats() {
       return {
         decoderType: "webcodecs-hybrid",

package/src/strategies/hybrid/index.ts

@@ -99,6 +99,13 @@ export async function createHybridSession(
       ? [[0, ctx.duration]]
       : []),
   });
+  Object.defineProperty(target, "buffered", {
+    configurable: true,
+    get: () => {
+      const end = handles.bufferedUntilSec();
+      return makeTimeRanges(end > 0 ? [[0, end]] : []);
+    },
+  });
 
   async function waitForBuffer(): Promise<void> {
     const start = performance.now();
@@ -114,6 +121,8 @@ export async function createHybridSession(
 
   async function doSeek(timeSec: number): Promise<void> {
     const wasPlaying = audio.isPlaying();
+    // HTMLMediaElement contract — see fallback/index.ts for the why.
+    target.dispatchEvent(new Event("seeking"));
     await audio.pause().catch(() => {});
     await handles.seek(timeSec).catch((err) =>
       console.warn("[avbridge] hybrid decoder seek failed:", err),
@@ -124,8 +133,16 @@ export async function createHybridSession(
       await waitForBuffer();
       await audio.start();
     }
+    target.dispatchEvent(new Event("seeked"));
   }
 
+  // HTMLMediaElement contract: `loadedmetadata` once the session is
+  // ready. The inner <video> never fires this itself on the hybrid
+  // path — it has no src.
+  queueMicrotask(() => {
+    try { target.dispatchEvent(new Event("loadedmetadata")); } catch { /* element torn down */ }
+  });
+
   // Store the fatal error handler so the player can wire escalation
   let fatalErrorHandler: ((reason: string) => void) | null = null;
   handles.onFatalError((reason) => fatalErrorHandler?.(reason));

package/src/strategies/remux/index.ts

@@ -65,6 +65,14 @@ export async function createRemuxSession(
       }
       const wasPlaying = !video.paused;
       await pipeline.seek(time, wasPlaying || wantPlay);
+      // HTMLMediaElement contract: Firefox + WebKit's MSE doesn't
+      // reliably fire `seeked` after a SourceBuffer remove+refill
+      // cycle (Chromium does). Dispatch manually so consumers get a
+      // consistent signal across browsers. Duplicating a native
+      // `seeked` is harmless per spec.
+      queueMicrotask(() => {
+        try { video.dispatchEvent(new Event("seeked")); } catch { /* ignore */ }
+      });
     },
     async setAudioTrack(id) {
       if (!context.audioTracks.some((t) => t.id === id)) {

package/src/types.ts

@@ -49,6 +49,12 @@ export type VideoCodec =
   | "mpeg2"
   | "mpeg1"
   | "theora"
+  | "dv" // DV / DVCPRO (camcorder, MiniDV)
+  | "hq_hqa" // Canopus HQ / HQA (Grass Valley intermediate)
+  | "rawvideo" // uncompressed frames
+  | "qtrle" // QuickTime Animation (Apple RLE)
+  | "png" // PNG sequence in MOV
+  | "vp6f" // VP6 Flash variant
   | (string & {});
 
 /** Audio codec families. */

package/src/util/libav-demux.ts

@@ -248,6 +248,32 @@ export function sanitizePacketTimestamp(
   pkt.time_base_den = 1_000_000;
 }
 
+/**
+ * Convert a raw libav packet's pts to seconds using the given stream
+ * time_base, or return `null` if the packet lacks a valid pts. Used by
+ * the hybrid + fallback strategies to track the demuxer's read-ahead
+ * progress (the signal behind `<video>.buffered` on canvas strategies).
+ *
+ * Separate from `sanitizePacketTimestamp` — sanitization mutates the
+ * packet and happens right before decoder feed; this peeks at the
+ * timestamp earlier in the pump so we can track buffered extent without
+ * perturbing the decode path.
+ */
+export function packetPtsSec(
+  pkt: Pick<LibavPacket, "pts" | "ptshi">,
+  timeBase: [number, number] | undefined,
+): number | null {
+  const lo = pkt.pts ?? 0;
+  const hi = pkt.ptshi ?? 0;
+  const isInvalid = (hi === -2147483648 && lo === 0) || !Number.isFinite(lo);
+  if (isInvalid) return null;
+  const tb = timeBase ?? [1, 1_000_000];
+  if (!tb[0] || !tb[1]) return null;
+  const pts64 = hi * 0x100000000 + lo;
+  const sec = (pts64 * tb[0]) / tb[1];
+  return Number.isFinite(sec) ? sec : null;
+}
+
 // ─────────────────────────────────────────────────────────────────────────
 // Audio frame → interleaved Float32 (extracted from
 // strategies/hybrid/decoder.ts + strategies/fallback/decoder.ts).