@banou/media-player 0.10.10 → 0.10.12

package/dist/engine/index.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "../engine-C6PdWBah.js";
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "../engine-DKjUYAmJ.js";
 export { i as DEFAULT_BUFFER_SIZE, e as MediaElementError, a as SUBTITLES_OFF, u as createPictureInPicture, d as createSubtitleRenderer, c as createThumbnailGenerator, n as getTimeRanges, s as isMediaElementError, o as pictureInPictureMode, l as startPlayback, t as terminateRemuxer, r as updateSourceBuffer };

package/dist/{engine-C6PdWBah.js → engine-DKjUYAmJ.js}

@@ -244,8 +244,9 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 			t && r || (console.error(e), (!K || n) && (K = !0, ne?.(r ? Error("Reading the video file failed", { cause: e }) : e)));
 		}, fe = async (e = !1) => {
 			if (R > 0 && !e) return;
-			let t = n.currentTime, r = e ? x : v, a = e ? S : y;
-			for (let { start: e, end: n } of i(A)) e < t + r && await se(e, t + r), n > t + a && await se(t + a, n);
+			let t = n.currentTime, r = e ? x : v, a = e ? S : y, o = i(A);
+			o.length && o[0].start < t + r && await se(0, t + r);
+			for (let { end: e } of o) e > t + a && await se(t + a, e);
 		}, pe = () => {
 			let e = i(A);
 			if (!e.length) return !0;
@@ -305,11 +306,11 @@ var i = (e) => Array(e.buffered.length).fill(void 0).map((t, n) => ({
 			} finally {
 				e === H && (I = !1);
 			}
-		}, ye = (e) => e >= de && !!me(), be = (e) => i(A).some((t) => t.start <= e + T && e < t.end), Y = (e) => {
+		}, ye = (e) => e >= de && be(e), be = (e) => i(A).some((t) => t.start <= e && e < t.end), Y = (e) => {
 			let t = i(A).find((t) => t.start <= e + T && e < t.end);
 			return t ? t.end - e : 0;
 		}, xe = async (e) => {
-			if (!N && !(Y(e) >= E)) {
+			if (!N && !(be(e) && Y(e) >= E)) {
 				V = !1, R++, z = e;
 				try {
 					be(e) || await J(e);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { l as e, n as t, o as n, r, s as i, t as a, u as o } from "./engine-C6PdWBah.js";
+import { l as e, n as t, o as n, r, s as i, t as a, u as o } from "./engine-DKjUYAmJ.js";
 import { Children as s, Fragment as c, isValidElement as l, useCallback as u, useEffect as d, useMemo as f, useRef as p, useState as m, useSyncExternalStore as h } from "react";
 import { css as g, keyframes as _ } from "@emotion/react";
 import { createPlayer as v, useContainerAttach as y, useMediaAttach as b } from "@videojs/react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@banou/media-player",
-  "version": "0.10.10",
+  "version": "0.10.12",
   "description": "A video player for containers and codecs the browser cannot play natively, remuxed on the fly",
   "type": "module",
   "main": "dist/index.js",

package/src/lib/engine/playback.ts

@@ -102,7 +102,15 @@ const PRE_EVICT_TIGHT = -5
 const POST_EVICT_TIGHT = 20
 const MAX_APPEND_ATTEMPTS = 5
 const SOURCE_OPEN_TIMEOUT = 15_000
-// how far past the playhead a range may start and still count as the one holding it
+/*
+ * How far past the playhead a range may start and still count as the one holding it, which decides how
+ * much to read and never whether to fetch.
+ *
+ * Firefox 151 reports a range from its first presented frame, the reorder delay past its keyframe: 82 ms
+ * on most fixtures and 166 ms on anime-chapters, at load and after every remuxer seek, where Chrome 153
+ * reports the keyframe itself. Without the slack a playhead paused at 0 reads the whole file, and a
+ * prepared seek to a keyframe builds no runway (measured 2026-10-11).
+ */
 const BOUNDARY_SLACK = 1
 /*
  * Seconds of data a seek target needs behind it before the playhead is allowed to move there.
@@ -304,8 +312,12 @@ export const startPlayback = async (options: PlaybackOptions): Promise<PlaybackC
       const ct = videoElement.currentTime
       const pre = tight ? PRE_EVICT_TIGHT : PRE_EVICT
       const post = tight ? POST_EVICT_TIGHT : POST_EVICT
-      for (const { start, end } of getTimeRanges(sourceBuffer)) {
-        if (start < ct + pre) await unbufferRange(start, ct + pre)
+      const ranges = getTimeRanges(sourceBuffer)
+      // From 0, never from the reported start: once a group is removed, Firefox 151 reports the start
+      // 1 ms after the keyframe it still holds, so a remove from there keeps that frame for good
+      // (measured 2026-10-11).
+      if (ranges.length && ranges[0].start < ct + pre) await unbufferRange(0, ct + pre)
+      for (const { end } of ranges) {
         if (end > ct + post) await unbufferRange(ct + post, end)
       }
     }
@@ -447,11 +459,17 @@ export const startPlayback = async (options: PlaybackOptions): Promise<PlaybackC
      * seek, and playback would stall at the end of this range instead. At or after it, the bytes from
      * here to the read cursor are contiguous and reading simply carries on.
      */
-    const alreadyPlayable = (time: number) => time >= lastSeekPosition && !!playheadRange()
+    const alreadyPlayable = (time: number) => time >= lastSeekPosition && playableAt(time)
 
-    /** Whether a GIVEN time has data behind it, as opposed to whether the playhead does. */
+    /**
+     * Whether the element can play from a GIVEN time without a fetch.
+     *
+     * Exact. A seek that lands before a range waits there for good once the gap passes 60 to 90 ms in
+     * Chrome 153, or 250 to 300 ms in Firefox 151, so Firefox's reorder delay cannot be allowed for here
+     * and a target inside it costs a remuxer seek (24 fps fixtures, measured 2026-10-11).
+     */
     const playableAt = (time: number) =>
-      getTimeRanges(sourceBuffer).some((r) => r.start <= time + BOUNDARY_SLACK && time < r.end)
+      getTimeRanges(sourceBuffer).some((r) => r.start <= time && time < r.end)
 
     /**
      * Put the data in place for a position the playhead has NOT moved to yet.
@@ -478,7 +496,7 @@ export const startPlayback = async (options: PlaybackOptions): Promise<PlaybackC
 
     const prepareSeek = async (time: number) => {
       if (destroyed) return
-      if (runwayFrom(time) >= SEEK_RUNWAY) return
+      if (playableAt(time) && runwayFrom(time) >= SEEK_RUNWAY) return
       finished = false
       preparing++
       prepareTarget = time