eb-player 2.5.1 → 2.5.2

package/dist/build/ebplayer.bundle.js

@@ -4,7 +4,7 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EBPlayer = {}));
 })(this, (function (exports) { 'use strict';
 
-    var __EB_PLAYER_VERSION__ = "2.5.1";
+    var __EB_PLAYER_VERSION__ = "2.5.2";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -19,22 +19,28 @@
      * - idle -> loading: initial load or post-stall reload
      * - loading -> playing | error: stream starts or fails
      * - playing -> paused | buffering | ended | error: normal playback events
-     * - paused -> playing | loading | idle | buffering: resume or stop
+     * - paused -> playing | loading | idle | buffering | ended: resume, stop, or reach end
      *   - paused -> buffering is needed when resuming a paused (live) stream where
      *     the browser fires 'waiting' before 'playing' (Safari live segment edge);
      *     without it the FSM strands at 'paused' while the video actually plays
-     * - buffering -> playing | paused | idle | error: buffer recovered, user pause, or stall
+     *   - paused -> ended is needed because the element always fires 'pause' before
+     *     'ended' when a VOD reaches its end
+     * - buffering -> playing | paused | idle | error | ended: buffer recovered, user pause, stall, or end
      *   - buffering -> idle is needed for the stall-watchdog recovery path (kick off reload)
      *   - buffering -> paused is needed for live stream support (user pauses during buffer)
+     *   - buffering -> ended is needed because a tail 'waiting' firing just before the
+     *     end can leave the FSM at 'buffering' at the moment 'ended' fires
      * - error -> loading: retry after error
-     * - ended -> loading | idle: restart playback or reset
+     * - ended -> loading | idle: restart playback or reset. Recovery from 'ended'
+     *   (seek-back, replay) routes explicitly through 'loading' rather than adding
+     *   more direct exits here.
      */
     const TRANSITIONS = {
         idle: ['loading'],
         loading: ['playing', 'buffering', 'paused', 'error', 'idle'],
         playing: ['paused', 'buffering', 'ended', 'error', 'idle'],
-        paused: ['playing', 'loading', 'idle', 'buffering'],
-        buffering: ['playing', 'paused', 'idle', 'error'],
+        paused: ['playing', 'loading', 'idle', 'buffering', 'ended'],
+        buffering: ['playing', 'paused', 'idle', 'error', 'ended'],
         error: ['loading', 'idle'],
         ended: ['loading', 'idle']
     };
@@ -5117,7 +5123,10 @@
             video.addEventListener('pause', () => {
                 if (video.seeking)
                     return;
-                if (state.playbackState === 'buffering') {
+                // Let 'ended' win: when the browser is pausing us because playback
+                // actually reached the end (pause always fires before ended), don't
+                // swallow it into the buffering branch below.
+                if (state.playbackState === 'buffering' && !video.ended) {
                     userRequestedPause = true;
                     return;
                 }
@@ -5130,7 +5139,12 @@
                     state.currentTime = Math.round(video.currentTime);
                     state.isSyncWithLive = video.currentTime + syncMargin > video.duration;
                 }
-                if (userRequestedPause && video.paused) {
+                // Restore 'paused' once a seek settles while the video stays paused.
+                // Covers the existing pause-during-buffering case (userRequestedPause)
+                // and seeking back from 'ended' (routed through 'loading' by the
+                // engine's seek()), where no 'waiting'/'playing' event ever fires
+                // because the video never resumes playing on its own.
+                if ((userRequestedPause || state.playbackState === 'loading') && video.paused) {
                     state.playbackState = 'paused';
                     userRequestedPause = false;
                 }
@@ -5979,6 +5993,33 @@
     const MAX_NON_FATAL_RETRIES = 3;
     /** Error types that cannot be recovered by retrying (platform limitations) */
     const UNRECOVERABLE_TYPES = new Set(['keySystemError']);
+    /**
+     * Margin (seconds) used to detect a VOD tail stall near end-of-stream.
+     * Encoder-produced audio/video rendition length mismatches of a few tens to
+     * ~100ms are common (observed: 27-77ms overhang) and can stall playback for
+     * a second or two right at the end — indistinguishable from a genuinely stuck
+     * stream by currentTime alone. 1s is a safe margin above that overhang.
+     */
+    const NEAR_VOD_END_SECONDS = 1;
+    /**
+     * True when the driver is not live and both the playhead and the buffered
+     * range already reach within NEAR_VOD_END_SECONDS of the media duration —
+     * i.e. a tail stall that hls.js's own nudge/EOS handling can resolve on its
+     * own, where a destructive recoverMediaError()/startLoad() would only race it
+     * (observed: reload lands right as 'ended' would have fired naturally).
+     */
+    function isNearVodEndStall(media, engine) {
+        if (media === null || engine?.isLive === true)
+            return false;
+        const { duration, buffered, currentTime } = media;
+        if (!Number.isFinite(duration) || duration <= 0)
+            return false;
+        if (duration - currentTime > NEAR_VOD_END_SECONDS)
+            return false;
+        if (buffered.length === 0)
+            return false;
+        return buffered.end(buffered.length - 1) >= duration - NEAR_VOD_END_SECONDS;
+    }
     function handleHlsRetry(driver, engine) {
         /** Tracks consecutive non-fatal recovery attempts per error detail */
         const nonFatalRetryCounts = new Map();
@@ -6044,6 +6085,10 @@
             const errorTime = driver.media?.currentTime;
             setTimeout(() => {
                 if (errorTime === driver.media?.currentTime && !engine?.chromecast_casting) {
+                    if (isNearVodEndStall(driver.media, engine)) {
+                        console.info('HLS Retry: near VOD end, letting hls.js finish naturally', event, data);
+                        return;
+                    }
                     console.warn('HLS Retry: Stream is stuck, trying to fix', event, data);
                     if (data.type === 'mediaError')
                         driver.recoverMediaError();
@@ -6467,7 +6512,19 @@
                 cfg.liveMaxLatencyDurationCount = Infinity;
                 this.liveSyncDisabled = true;
             }
+            // hls.js's StreamController parks itself in ENDED once the video reaches
+            // its end and never resumes loading on its own — setting currentTime alone
+            // leaves the seek stuck forever. Route through 'loading' and kick the
+            // driver explicitly (deferred per Pitfall 3: never call startLoad
+            // synchronously from a video event handler).
+            const wasEnded = this.video.ended;
             this.video.currentTime = time;
+            if (wasEnded && this.driver !== null) {
+                if (this.state)
+                    this.state.playbackState = 'loading';
+                const driverRef = this.driver;
+                setTimeout(() => driverRef.startLoad(time), 0);
+            }
         }
         seekToLive() {
             if (this.video === null)
@@ -6633,6 +6690,7 @@
             if (config.retry) {
                 handleHlsRetry(driver, {
                     get chromecast_casting() { return state.isCasting; },
+                    get isLive() { return state.isLive; },
                     onUnrecoverableError: (message) => {
                         this.stopWatchdog();
                         if (this.state) {
@@ -6718,6 +6776,15 @@
                     // Defer startLoad to avoid re-entrancy (Pitfall 3)
                     setTimeout(() => driverRef.startLoad(-1), 0);
                 }
+                else if (this.state?.playbackState === 'ended') {
+                    // Pressing Play at end-of-stream: the browser has already seeked to
+                    // the earliest position by the time this fires (evidenced live), so
+                    // video.currentTime is the correct resume point. Same StreamController
+                    // ENDED trap as seek() above — route through 'loading' and kick the driver.
+                    this.state.playbackState = 'loading';
+                    const resumeTime = this.video?.currentTime ?? 0;
+                    setTimeout(() => driverRef.startLoad(resumeTime), 0);
+                }
             }, { signal });
             // Start stall watchdog
             this.startWatchdog();