eb-player 2.1.1 → 2.1.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.1.1";
+    var __EB_PLAYER_VERSION__ = "2.1.2";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -5937,6 +5937,17 @@
      * CRITICAL: Call applyDiscontinuityWorkaround BEFORE driver.attachMedia/loadSource (Pitfall 4).
      * CRITICAL: Never call driver.startLoad() from video 'play' event handler (Pitfall 3).
      */
+    /**
+     * Bound for the "load never started" watchdog: hls.js's own manifest-loading
+     * budget (default manifestLoadingTimeOut 10 000 ms with one retry plus
+     * backoff) tops out around 21s before hls.js surfaces its own fatal network
+     * error, so 30s guarantees hls.js's own error path always wins first and
+     * this watchdog only ever sees the case hls.js is silent about — a
+     * StreamController parked in STOPPED with no error and no event. 30s also
+     * matches the existing MAIN_OPEN_FALLBACK_MS precedent in src/eb-player.ts
+     * and sits well below INTRO_MAX_DURATION_MS (90 000).
+     */
+    const LOAD_NEVER_STARTED_TIMEOUT_MS = 30000;
     // ---------------------------------------------------------------------------
     // HlsEngine
     // ---------------------------------------------------------------------------
@@ -5949,6 +5960,9 @@
             this.autoQuality = true;
             // Holds state reference for named driver event handlers
             this.eventState = null;
+            // Bound "load never started" watchdog timer — 0-initialized (not null) so
+            // clearTimeout(0) is a no-op, eliminating a null-guard phantom V8 branch.
+            this.loadNeverStartedTimer = 0;
             this.liveSyncDisabled = false;
         }
         getDriver() {
@@ -5982,6 +5996,7 @@
         }
         onDetach() {
             this.stopWatchdog();
+            this.clearLoadNeverStartedWatchdog();
             if (this.driver !== null) {
                 try {
                     this.driver.detachMedia();
@@ -6108,8 +6123,17 @@
             delete hlsSafeSettings['extraParamsCallback'];
             delete hlsSafeSettings['onCDNTokenError'];
             delete hlsSafeSettings['signSegmentsWithCdnToken'];
+            // Do NOT set an explicit auto-start disable here. hls.js starts loading
+            // segments on its own by default, and the resume position is already
+            // carried by startPosition below — hls.js honours it without any help.
+            // Nothing on the VOD path would ever restart a stopped loader: the only
+            // two startLoad() call sites in this file are recoverFromStall() (only
+            // reachable after playback has started) and the video 'play' listener
+            // (gated on state.isLive, so VOD never reaches it). Disabling auto-start
+            // here parks the StreamController in STOPPED forever for any non-zero
+            // resume position — no variant playlist, no segments, no error, no bus
+            // event, spinner forever.
             const driverConfig = {
-                autoStartLoad: !config.startAt,
                 enableWorker: true,
                 backBufferLength: 30,
                 ...hlsSafeSettings,
@@ -6191,6 +6215,11 @@
             this.driver = driver;
             // Pitfall 4: apply discontinuity workaround BEFORE attachMedia/loadSource
             applyDiscontinuityWorkaround(driver, Hls.Events);
+            // Hoisted once, used both for the retry wiring below and for gating the
+            // "load never started" watchdog — the intro pass already has its own
+            // bounds (INTRO_MAX_DURATION_MS, D-04 silent fall-through) and a second
+            // overlapping bound would only race them.
+            const isIntroPass = Boolean(config.preroll) && this.loadSourceUrl === config.preroll;
             // Wire retry handler — pass engine context so unrecoverable DRM errors
             // stop the stall watchdog (prevents useless reload loops) and surface to UI.
             // For the intro pass (loadSourceUrl matches config.preroll), also wire
@@ -6199,7 +6228,6 @@
             // This callback is intentionally NOT set for the main stream so transient
             // network blips still trigger the normal startLoad() recovery.
             if (config.retry) {
-                const isIntroPass = Boolean(config.preroll) && this.loadSourceUrl === config.preroll;
                 handleHlsRetry(driver, {
                     get chromecast_casting() { return state.isCasting; },
                     onUnrecoverableError: (message) => {
@@ -6266,6 +6294,8 @@
             this.resolveDriverReady();
             // Register driver event handlers
             this.registerDriverEvents(Hls, state);
+            // Arm the "load never started" watchdog — see LOAD_NEVER_STARTED_TIMEOUT_MS.
+            this.armLoadNeverStartedWatchdog(driver, Hls, src, isIntroPass);
             // Pause/resume loading on video pause/play to stop manifest refreshes
             // (and thus CDN token requests) while the player is paused.
             // Only applies to live streams where hls.js continuously refreshes the manifest.
@@ -6334,6 +6364,43 @@
             driver.on(Events.SUBTITLE_TRACKS_UPDATED, this._onSubtitleTracksUpdated.bind(this));
             driver.on(Events.SUBTITLE_TRACK_SWITCH, this._onSubtitleTrackSwitch.bind(this));
         }
+        // -------------------------------------------------------------------------
+        // "Load never started" watchdog
+        // -------------------------------------------------------------------------
+        /**
+         * Arms a one-shot bound that turns an unobservable hang into `state.error`
+         * + a typed bus event: hls.js emits neither when its StreamController
+         * never leaves STOPPED. Disarmed by the first FRAG_LOADING (proof that a
+         * fragment request was actually issued, whether or not playback was
+         * allowed to start — so autoplay-blocked playback never false-positives).
+         * Never armed for the intro pass — it already has its own bounds.
+         */
+        armLoadNeverStartedWatchdog(driver, Hls, src, isIntroPass) {
+            if (isIntroPass)
+                return;
+            driver.on(Hls.Events.FRAG_LOADING, this._onFragLoading.bind(this));
+            this.loadNeverStartedTimer = setTimeout(this._onLoadNeverStartedTimeout.bind(this, src), LOAD_NEVER_STARTED_TIMEOUT_MS);
+        }
+        clearLoadNeverStartedWatchdog() {
+            clearTimeout(this.loadNeverStartedTimer);
+            this.loadNeverStartedTimer = 0;
+        }
+        _onFragLoading() {
+            this.clearLoadNeverStartedWatchdog();
+        }
+        _onLoadNeverStartedTimeout(src) {
+            if (this.detached)
+                return;
+            // Two-signal live gate (mirrors _onLevelLoaded): a stream that never
+            // loaded a level detail never got its isLive set from the driver, so
+            // the config-level signal must also be checked.
+            if (this.state?.isLive === true || this.config?.isLive === true)
+                return;
+            if (this.state) {
+                this.state.error = 'HlsEngine: load never started — no fragment request was issued within the bound';
+            }
+            this.bus?.emit('load-never-started', { src });
+        }
         _onManifestLoaded(_event, data) {
             const state = this.eventState;
             const driver = this.driver;
@@ -7438,6 +7505,7 @@
         // skin-root.ts:141/318 and is a no-op for runtime mute.
         const originalMuted = mergedConfig.muted ?? false;
         const originalManager = mergedConfig.manager;
+        const originalStartAt = mergedConfig.startAt;
         const controller = new PlayerController(runtimeConfig);
         controller.mount(container);
         // Video element is available after mount() creates the skin DOM
@@ -7663,6 +7731,10 @@
             // during the intro pass. Synchronize both objects on every swap.
             mergedConfig.manager = originalManager;
             controller.config.manager = originalManager;
+            // Restore the viewer's resume position for the main asset — see the
+            // rationale comment at the intro-side swap below (CR-05 sync applies here too).
+            mergedConfig.startAt = originalStartAt;
+            controller.config.startAt = originalStartAt;
             // CR-03: clear any stale error that leaked from the intro/ad pass.
             // IntroStreamManager's silent fall-through (D-04) treats error-fatal as a
             // normal completion but leaves state.error populated with the intro
@@ -7811,6 +7883,13 @@
             // CR-05: keep the dual-merged configs in sync (see openMainStream).
             mergedConfig.manager = false;
             controller.config.manager = false;
+            // A viewer resume position belongs to the main asset only — applying it
+            // to a short intro clip seeks past the whole clip. This defect survives
+            // the startAt/autoStartLoad fix: after that fix, startPosition: 300 is
+            // still applied to the intro, which is still wrong, just differently
+            // wrong. Cleared here and restored in openMainStream() (CR-05 sync).
+            mergedConfig.startAt = undefined;
+            controller.config.startAt = undefined;
             reference.open(mergedConfig.preroll);
         }
         // D-02/D-08-02 (Phase 8): ad-only configuration — no intro stream, so this