avbridge 2.11.0 → 2.12.0

package/dist/remux-7TA4FKTY.js

@@ -0,0 +1,10 @@
+export { createOutputFormat, generateFilename, mimeForFormat, remux, validateRemuxEligibility } from './chunk-5Y5BTB5D.js';
+import './chunk-2LNXMGT6.js';
+import './chunk-CPJLFFCC.js';
+import './chunk-LUFA47FP.js';
+import './chunk-3YKWU4FM.js';
+import './chunk-3AI5WFFN.js';
+import './chunk-5DMTJVIU.js';
+import './chunk-5YAWWKA3.js';
+//# sourceMappingURL=remux-7TA4FKTY.js.map
+//# sourceMappingURL=remux-7TA4FKTY.js.map

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

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

package/dist/remux-VPKCLHHM.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var chunkGJBNLPGI_cjs = require('./chunk-GJBNLPGI.cjs');
+require('./chunk-HBHSUGNI.cjs');
+require('./chunk-2IJ66NTD.cjs');
+require('./chunk-QDJLQR53.cjs');
+require('./chunk-HZUVMXBN.cjs');
+require('./chunk-YPZFGJV3.cjs');
+require('./chunk-G4APZMCP.cjs');
+require('./chunk-F3LQJKXK.cjs');
+
+
+
+Object.defineProperty(exports, "createOutputFormat", {
+  enumerable: true,
+  get: function () { return chunkGJBNLPGI_cjs.createOutputFormat; }
+});
+Object.defineProperty(exports, "generateFilename", {
+  enumerable: true,
+  get: function () { return chunkGJBNLPGI_cjs.generateFilename; }
+});
+Object.defineProperty(exports, "mimeForFormat", {
+  enumerable: true,
+  get: function () { return chunkGJBNLPGI_cjs.mimeForFormat; }
+});
+Object.defineProperty(exports, "remux", {
+  enumerable: true,
+  get: function () { return chunkGJBNLPGI_cjs.remux; }
+});
+Object.defineProperty(exports, "validateRemuxEligibility", {
+  enumerable: true,
+  get: function () { return chunkGJBNLPGI_cjs.validateRemuxEligibility; }
+});
+//# sourceMappingURL=remux-VPKCLHHM.cjs.map
+//# sourceMappingURL=remux-VPKCLHHM.cjs.map

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avbridge",
-  "version": "2.11.0",
+  "version": "2.12.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/element/avbridge-player.ts

@@ -247,6 +247,11 @@ export class AvbridgePlayerElement extends HTMLElement {
     on(this._video, "ended", () => this._setState("ended"));
     on(this._video, "error", () => this._setState("error"));
     on(this._video, "timeupdate", () => this._updateTime());
+    // `progress` fires as the inner element's buffered ranges grow — keep the
+    // seek bar's buffered indicator fresh even when paused or filling ahead
+    // without timeupdate advancing. `<avbridge-video>` dispatches this on
+    // all strategies (including the synthesized ranges for canvas strategies).
+    on(this._video, "progress", () => this._updateBuffered());
     on(this._video, "volumechange", () => this._updateVolume());
     // Strategy changes are visible in Stats for Nerds.
     on(this._video, "trackschange", () => this._buildSettingsMenu());
@@ -524,15 +529,38 @@ export class AvbridgePlayerElement extends HTMLElement {
     this._seekInput.value = String(t);
     this._updateSeekVisuals(t);
     this._timeDisplay.textContent = `${formatTime(t)} / ${formatTime(d)}`;
+    this._updateBuffered();
+  }
 
-    // Buffered ranges
-    try {
-      const buf = this._video.buffered;
-      if (buf && buf.length > 0 && d > 0) {
-        const end = buf.end(buf.length - 1);
-        this._seekBuffered.style.width = `${(end / d) * 100}%`;
-      }
-    } catch { /* ignore */ }
+  /**
+   * Render every buffered range as its own segment so gaps (common on MSE
+   * after seeks) are visible. Not gated by `_userSeeking` — ranges should
+   * keep updating while the user scrubs, and runs cheaply on `progress`.
+   */
+  private _updateBuffered(): void {
+    const d = this._video.duration;
+    if (!(d > 0)) return;
+    let buf: TimeRanges;
+    try { buf = this._video.buffered; } catch { return; }
+    const count = buf ? buf.length : 0;
+    const host = this._seekBuffered;
+    // Reconcile child count. Segment divs are styled via .avp-seek-buffered-range.
+    while (host.childElementCount > count) host.lastElementChild!.remove();
+    while (host.childElementCount < count) {
+      const seg = document.createElement("div");
+      seg.className = "avp-seek-buffered-range";
+      host.appendChild(seg);
+    }
+    for (let i = 0; i < count; i++) {
+      let start: number; let end: number;
+      try { start = buf.start(i); end = buf.end(i); } catch { continue; }
+      const s = Math.max(0, start);
+      const e = Math.min(d, end);
+      if (e <= s) continue;
+      const seg = host.children[i] as HTMLElement;
+      seg.style.left = `${(s / d) * 100}%`;
+      seg.style.width = `${((e - s) / d) * 100}%`;
+    }
   }
 
   // ── Controls: volume ───────────────────────────────────────────────────

package/src/element/player-styles.ts

@@ -286,6 +286,12 @@ export const PLAYER_STYLES = /* css */ `
   display: flex;
   align-items: center;
   cursor: pointer;
+  /* Claim all touch gestures on the seek bar. Without this, Android
+   * browsers (Chrome, Samsung Internet) treat horizontal drags as
+   * scroll candidates and cancel pointermove once the gesture
+   * resolves, breaking scrub. touch-action must be set in CSS —
+   * preventDefault() on pointerdown is too late. */
+  touch-action: none;
 }
 
 .avp-seek-track {
@@ -303,7 +309,13 @@ export const PLAYER_STYLES = /* css */ `
 
 .avp-seek-buffered {
   position: absolute;
-  left: 0;
+  inset: 0;
+  pointer-events: none;
+}
+
+.avp-seek-buffered-range {
+  position: absolute;
+  top: 0;
   height: 100%;
   background: rgba(255, 255, 255, 0.35);
   border-radius: inherit;

package/src/player.ts

@@ -132,9 +132,9 @@ export class UnifiedPlayer {
     private readonly options: CreatePlayerOptions,
     private readonly registry: PluginRegistry,
   ) {
-    const { requestInit, fetchFn } = options;
-    if (requestInit || fetchFn) {
-      this.transport = { requestInit, fetchFn };
+    const { requestInit, fetchFn, cacheBytes } = options;
+    if (requestInit || fetchFn || cacheBytes !== undefined) {
+      this.transport = { requestInit, fetchFn, cacheBytes };
     }
   }
 

package/src/types.ts

@@ -287,6 +287,14 @@ export interface CreatePlayerOptions {
    * for interceptors, logging, or environments without a global fetch.
    */
   fetchFn?: FetchFn;
+  /**
+   * Byte budget for the libav HTTP reader's LRU cache of fetched ranges.
+   * Defaults to 8 MB. Set to `0` to disable caching. Raise this when the
+   * app plays seek-heavy legacy-container media from URLs — hot regions
+   * (header/moov, tail index, current window) stay resident instead of
+   * being re-fetched on every bounce.
+   */
+  cacheBytes?: number;
 }
 
 /** Signature-compatible with `globalThis.fetch`. */
@@ -296,6 +304,13 @@ export type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<
 export interface TransportConfig {
   requestInit?: RequestInit;
   fetchFn?: FetchFn;
+  /**
+   * Byte budget for the libav HTTP reader's LRU cache of fetched ranges.
+   * Defaults to 8 MB. Set to `0` to disable caching entirely. Higher
+   * values help seek-heavy network playback keep hot regions
+   * (header/moov, tail index, current read) resident.
+   */
+  cacheBytes?: number;
 }
 
 /** Events emitted by {@link UnifiedPlayer}. Strongly typed. */

package/src/util/libav-http-reader.ts

@@ -32,8 +32,13 @@
  *   clamped to `[256 KB, 1 MB]`. Small reads get amortized; pathological
  *   large requests don't OOM us.
  *
- * - **Last-block cache.** Only the most-recent fetched block is kept.
- *   Re-fetches via Range are cheap; an LRU cache is post-1.0.
+ * - **LRU block cache.** Fetched blocks are kept in a Map keyed by start
+ *   position, bounded by a byte budget (default 8 MB, configurable via
+ *   `cacheBytes`). Map insertion order doubles as recency; re-accessing
+ *   a block promotes it via delete+set. Eviction walks oldest-first
+ *   until total bytes fit the budget. Typical seek pattern has three
+ *   hot regions — header/moov at the front, index at the tail, current
+ *   read position — all of which fit comfortably under the default.
  *
  * - **Safe detach.** `detach()` clears `libav.onblockread`, sets a
  *   destroyed flag, and ignores any in-flight fetch resolutions so we
@@ -42,6 +47,7 @@
 
 const MIN_READ = 256 * 1024;
 const MAX_READ = 1 * 1024 * 1024;
+const DEFAULT_CACHE_BYTES = 8 * 1024 * 1024;
 
 interface LibavLike {
   mkblockreaderdev(name: string, size: number): Promise<void>;
@@ -69,6 +75,12 @@ export interface AttachLibavHttpReaderOptions {
   requestInit?: RequestInit;
   /** Override fetch (for testing). Defaults to globalThis.fetch. */
   fetchFn?: typeof fetch;
+  /**
+   * Byte budget for the LRU block cache. Defaults to 8 MB. Set to `0`
+   * to disable caching. Raise this (e.g. 32 MB) for apps that play
+   * seek-heavy legacy-container media over the network.
+   */
+  cacheBytes?: number;
 }
 
 /**
@@ -108,6 +120,7 @@ export async function prepareLibavInput(
     const handle = await attachLibavHttpReader(libav, filename, source.url, {
       requestInit: transport?.requestInit,
       fetchFn: transport?.fetchFn,
+      cacheBytes: transport?.cacheBytes,
     });
     return {
       filename,
@@ -192,9 +205,12 @@ export async function attachLibavHttpReader(
   // ── State ───────────────────────────────────────────────────────────────
 
   let detached = false;
-  // Most-recently fetched block. Cached so re-reads of the same region
-  // (e.g. demuxer re-walks the header) don't issue another HTTP request.
-  let cached: { pos: number; bytes: Uint8Array } | null = null;
+  // LRU cache of fetched blocks, keyed by start position. Map insertion
+  // order = recency. Bounded by `cacheBudget` bytes; evicts oldest-first
+  // on overflow. Set budget to 0 to disable caching.
+  const cache = new Map<number, Uint8Array>();
+  let cacheBytes = 0;
+  const cacheBudget = Math.max(0, options.cacheBytes ?? DEFAULT_CACHE_BYTES);
   // The currently in-flight fetch, if any. Used both for serialization
   // (we await this before starting another) and for in-flight dedup.
   let inflight: Promise<void> | null = null;
@@ -206,17 +222,39 @@ export async function attachLibavHttpReader(
     return doubled;
   }
 
-  /** True if the cached block fully covers `[pos, pos+length)`. */
-  function cacheCovers(pos: number, length: number): boolean {
-    if (!cached) return false;
-    return pos >= cached.pos && pos + length <= cached.pos + cached.bytes.byteLength;
+  /**
+   * Look up a cached block that fully covers `[pos, pos+length)`. On hit,
+   * promote the block to most-recent and return the slice. On miss, null.
+   */
+  function cacheLookup(pos: number, length: number): Uint8Array | null {
+    for (const [blockPos, bytes] of cache) {
+      if (pos >= blockPos && pos + length <= blockPos + bytes.byteLength) {
+        cache.delete(blockPos);
+        cache.set(blockPos, bytes);
+        const offset = pos - blockPos;
+        return bytes.subarray(offset, offset + length);
+      }
+    }
+    return null;
   }
 
-  /** Slice the requested window out of the cached block. */
-  function sliceFromCache(pos: number, length: number): Uint8Array {
-    if (!cached) throw new Error("sliceFromCache called with no cache");
-    const offset = pos - cached.pos;
-    return cached.bytes.subarray(offset, offset + length);
+  /** Insert a fetched block; evict least-recently-used until under budget. */
+  function cacheInsert(pos: number, bytes: Uint8Array): void {
+    const existing = cache.get(pos);
+    if (existing) {
+      cacheBytes -= existing.byteLength;
+      cache.delete(pos);
+    }
+    cache.set(pos, bytes);
+    cacheBytes += bytes.byteLength;
+    while (cacheBytes > cacheBudget && cache.size > 0) {
+      const oldestKey = cache.keys().next().value as number | undefined;
+      if (oldestKey === undefined) break;
+      const oldest = cache.get(oldestKey);
+      if (!oldest) break;
+      cache.delete(oldestKey);
+      cacheBytes -= oldest.byteLength;
+    }
   }
 
   /** Fetch one Range and update the cache. */
@@ -235,7 +273,7 @@ export async function attachLibavHttpReader(
       );
     }
     const buf = new Uint8Array(await res.arrayBuffer());
-    cached = { pos, bytes: buf };
+    cacheInsert(pos, buf);
     return buf;
   }
 
@@ -252,9 +290,9 @@ export async function attachLibavHttpReader(
     if (detached) return;
 
     // Cache hit — reply directly without a network round-trip.
-    if (cacheCovers(pos, length)) {
-      const data = sliceFromCache(pos, length);
-      try { await libav.ff_block_reader_dev_send(name, pos, data); } catch { /* ignore — libav may have torn down */ }
+    const hit = cacheLookup(pos, length);
+    if (hit) {
+      try { await libav.ff_block_reader_dev_send(name, pos, hit); } catch { /* ignore — libav may have torn down */ }
       return;
     }
 
@@ -312,7 +350,8 @@ export async function attachLibavHttpReader(
         try { await inflight; } catch { /* ignore */ }
       }
       // Drop the cache and unlink the virtual file.
-      cached = null;
+      cache.clear();
+      cacheBytes = 0;
       try { await libav.unlinkreadaheadfile(filename); } catch { /* ignore */ }
     },
   };