eb-player 2.1.0 → 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.0";
+    var __EB_PLAYER_VERSION__ = "2.1.2";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -5852,9 +5852,22 @@
         }
     }
     /**
-     * Returns a loader class extending `BaseLoader`, built exactly like the
-     * existing playlist loader: call `super()`, bind the inherited `load`, then
-     * assign an own `load` property that reads `context.frag?.baseurl`.
+     * Returns a loader constructor extending `BaseLoader`: construct the base,
+     * bind the inherited `load`, then assign an own `load` property that reads
+     * `context.frag?.baseurl`.
+     *
+     * NOT a native `class`: this constructor is registered in the base
+     * `config.loader` slot, which the EasyBroadcast P2P SDK's hls adapter
+     * subclasses with transpiled ES5 inheritance — its wrapper constructor
+     * invokes the parent as `Parent.apply(this, arguments)`, which throws
+     * "Class constructor ... cannot be invoked without 'new'" on a native
+     * class (hls.js's own dist loaders are function-based for the same
+     * reason). The function below therefore supports both invocation modes:
+     * under `new` (hls.js pLoader/fLoader/loader slots) it defers to
+     * `Reflect.construct` so a native-class base still works; under an
+     * `.apply()`-style super call it initializes the wrapper's `this` in
+     * place, which requires the base to be function-based — true of every
+     * hls.js dist build this player loads.
      *
      * `tokenSource` is captured by closure — never stored on `this` and never
      * used to acquire or refresh a token.
@@ -5868,37 +5881,46 @@
         // hls.js needs the error signal each time to drive its own retry/fatal
         // escalation; only the console spam is deduplicated.
         let unsupportedTokenTypeLogged = false;
-        class SegmentTokenLoader extends BaseLoader {
-            constructor(loaderConfig) {
-                super(loaderConfig);
-                const originalLoad = this.load.bind(this);
-                this.load = function (context, loadConfig, callbacks) {
-                    // D-03/D-04: a token type outside the query-param family (akamai, or
-                    // none configured) must fail visibly rather than emit an unsigned
-                    // request. A silent passthrough here is the same undiagnosable 403
-                    // from the edge that D-04 forbids, so it gets the same treatment as
-                    // the akamai case: no delegation to the base loader, and a named
-                    // error surfaced through hls.js's own error callback.
-                    const tokenType = tokenSource.tokenType;
-                    if (!tokenType || !SEGMENT_SIGNING_TOKEN_TYPES.includes(tokenType)) {
-                        const message = segmentSigningUnsupportedMessage(tokenType);
-                        if (!unsupportedTokenTypeLogged) {
-                            unsupportedTokenTypeLogged = true;
-                            console.error(message);
-                        }
-                        callbacks.onError({ code: 0, text: message }, context, null, createEmptySegmentLoaderStats());
-                        return;
-                    }
-                    const baseUrl = context.frag?.baseurl;
-                    if (!baseUrl || !context.url) {
-                        originalLoad(context, loadConfig, callbacks);
-                        return;
+        function attachSigningLoad(instance) {
+            const originalLoad = instance.load.bind(instance);
+            instance.load = function (context, loadConfig, callbacks) {
+                // D-03/D-04: a token type outside the query-param family (akamai, or
+                // none configured) must fail visibly rather than emit an unsigned
+                // request. A silent passthrough here is the same undiagnosable 403
+                // from the edge that D-04 forbids, so it gets the same treatment as
+                // the akamai case: no delegation to the base loader, and a named
+                // error surfaced through hls.js's own error callback.
+                const tokenType = tokenSource.tokenType;
+                if (!tokenType || !SEGMENT_SIGNING_TOKEN_TYPES.includes(tokenType)) {
+                    const message = segmentSigningUnsupportedMessage(tokenType);
+                    if (!unsupportedTokenTypeLogged) {
+                        unsupportedTokenTypeLogged = true;
+                        console.error(message);
                     }
-                    context.url = signSegmentUrlFromPlaylist(context.url, baseUrl);
+                    callbacks.onError({ code: 0, text: message }, context, null, createEmptySegmentLoaderStats());
+                    return;
+                }
+                const baseUrl = context.frag?.baseurl;
+                if (!baseUrl || !context.url) {
                     originalLoad(context, loadConfig, callbacks);
-                };
+                    return;
+                }
+                context.url = signSegmentUrlFromPlaylist(context.url, baseUrl);
+                originalLoad(context, loadConfig, callbacks);
+            };
+        }
+        function SegmentTokenLoader(loaderConfig) {
+            if (new.target) {
+                const instance = Reflect.construct(BaseLoader, [loaderConfig], new.target);
+                attachSigningLoad(instance);
+                return instance;
             }
+            BaseLoader.call(this, loaderConfig);
+            attachSigningLoad(this);
+            return undefined;
         }
+        SegmentTokenLoader.prototype = Object.create(BaseLoader.prototype);
+        SegmentTokenLoader.prototype.constructor = SegmentTokenLoader;
         return SegmentTokenLoader;
     }
 
@@ -5915,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
     // ---------------------------------------------------------------------------
@@ -5927,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() {
@@ -5960,6 +5996,7 @@
         }
         onDetach() {
             this.stopWatchdog();
+            this.clearLoadNeverStartedWatchdog();
             if (this.driver !== null) {
                 try {
                     this.driver.detachMedia();
@@ -6086,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,
@@ -6133,7 +6179,19 @@
                 // own parent playlist. Off by default so segment request shapes stay
                 // byte-identical to today's when the flag is unset.
                 if (config.engineSettings.signSegmentsWithCdnToken === true) {
-                    driverConfig.fLoader = createSegmentTokenLoaderClass(Hls.DefaultConfig.loader, tm);
+                    const SegmentTokenLoader = createSegmentTokenLoaderClass(Hls.DefaultConfig.loader, tm);
+                    driverConfig.fLoader = SegmentTokenLoader;
+                    // The base `loader` slot must sign too: the EasyBroadcast P2P SDK's
+                    // hls adapter replaces `config.fLoader` at integrate() time with a
+                    // wrapper class that extends `config.loader` and overrides only
+                    // loadInternal(), routing segment fetches through its own
+                    // resource manager (V2V + CDN-fallback fetch of context.url
+                    // verbatim). Signing lives in load(), which the wrapper inherits,
+                    // so every URL entering that path — and hls.js's key loader, which
+                    // also instantiates `config.loader` — is signed before any request
+                    // is issued. Without this, V2V CDN fallbacks go out unsigned (403
+                    // on token-protected origins).
+                    driverConfig.loader = SegmentTokenLoader;
                 }
             }
             // Inject custom ABR controller unless disabled
@@ -6157,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
@@ -6165,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) => {
@@ -6232,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.
@@ -6300,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;
@@ -7404,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
@@ -7629,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
@@ -7777,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