stormcloud-video-player 0.8.42 → 0.8.44

package/lib/sdk/hlsAdPlayer.d.cts

@@ -1,4 +1,4 @@
-import { A as AdController } from '../types-cTqIKw_D.cjs';
+import { A as AdController } from '../types-iDjS8f_7.cjs';
 import Hls from 'hls.js';
 
 declare function createHlsAdPlayer(contentVideo: HTMLVideoElement, options?: {

package/lib/types-iDjS8f_7.d.cts

@@ -0,0 +1,133 @@
+interface AdBreak {
+    id?: string;
+    startTimeMs: number;
+    durationMs?: number;
+    vastTagUrl?: string;
+}
+interface StormcloudVideoPlayerConfig {
+    videoElement: HTMLVideoElement;
+    src: string;
+    autoplay?: boolean;
+    muted?: boolean;
+    allowNativeHls?: boolean;
+    lowLatencyMode?: boolean;
+    isLiveStream?: boolean;
+    pauseContentDuringAds?: boolean;
+    driftToleranceMs?: number;
+    immediateManifestAds?: boolean;
+    debugAdTiming?: boolean;
+    adFailsafeTimeoutMs?: number;
+    adBreakCheckIntervalMs?: number;
+    maxAdBreakExtensionMs?: number;
+    minRemainingMsToStartAd?: number;
+    showCustomControls?: boolean;
+    hideLoadingIndicator?: boolean;
+    onVolumeToggle?: () => void;
+    onFullscreenToggle?: () => void;
+    onControlClick?: () => void;
+    licenseKey?: string;
+    vastTagUrl?: string;
+    isVmap?: boolean;
+    vmapUrl?: string;
+    vastMode?: 'adstorm' | 'default';
+    minSegmentsBeforePlay?: number;
+    ctvAdRequest?: boolean;
+    adTest?: boolean;
+    podMaxAds?: number;
+    podMaxDurationMs?: number;
+    podExactDuration?: boolean;
+}
+interface Scte35Marker {
+    type: "start" | "end" | "progress";
+    ptsSeconds?: number;
+    durationSeconds?: number;
+    raw?: unknown;
+}
+interface Id3TagInfo {
+    key: string;
+    value: string | Uint8Array;
+    ptsSeconds?: number;
+}
+interface AdController {
+    initialize: () => void;
+    requestAds: (vastTagUrl: string) => Promise<void>;
+    play: () => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    stop: () => Promise<void>;
+    destroy: () => void;
+    isAdPlaying: () => boolean;
+    resize: (width: number, height: number) => void;
+    on: (event: string, listener: (payload?: any) => void) => void;
+    off: (event: string, listener: (payload?: any) => void) => void;
+    updateOriginalMutedState: (muted: boolean, volume?: number) => void;
+    getOriginalMutedState: () => boolean;
+    getOriginalVolume: () => number;
+    setAdVolume: (volume: number) => void;
+    getAdVolume: () => number;
+    showPlaceholder: () => void;
+    hidePlaceholder: () => void;
+    getLoadedAdDuration?: () => number | undefined;
+    getLoadedAdId?: () => string | undefined;
+    getPodAdCount?: () => number;
+    getPodTotalDurationMs?: () => number;
+}
+interface ClientInfo {
+    brand: string;
+    os: string;
+    model: string;
+    deviceType: "tv" | "mobile" | "tablet" | "desktop";
+    isSmartTV: boolean;
+    isAndroid: boolean;
+    isWebView: boolean;
+    isWebApp: boolean;
+    domain: string;
+    origin: string;
+    path: string;
+    userAgent: string;
+    vendor: string;
+    platform: string;
+    screen: {
+        width?: number;
+        height?: number;
+        availWidth?: number;
+        availHeight?: number;
+        orientation?: string;
+        pixelDepth?: number;
+    };
+    hardwareConcurrency: number;
+    deviceMemory: number | null;
+    maxTouchPoints: number;
+    language: string;
+    languages: string;
+    cookieEnabled: boolean;
+    doNotTrack: string;
+    referrer: string;
+    visibilityState: string;
+}
+interface PlayerAnalyticsContext {
+    inputStreamType?: string;
+    debugAdTiming?: boolean;
+}
+interface AdDetectInfo {
+    source: "scte35";
+    durationSeconds?: number;
+    ptsSeconds?: number;
+    detectedAtFragmentSn?: number;
+    timestamp: string;
+}
+interface AdLoadedInfo {
+    source: "vast" | "hls";
+    vastUrl?: string;
+    durationSeconds?: number;
+    timestamp: string;
+}
+interface AdImpressionInfo {
+    source: "vast" | "hls";
+    adIndex: number;
+    adUrl?: string;
+    durationSeconds?: number;
+    timestamp: string;
+}
+
+export type { AdController as A, ClientInfo as C, Id3TagInfo as I, PlayerAnalyticsContext as P, StormcloudVideoPlayerConfig as S, Scte35Marker as a, AdBreak as b, AdDetectInfo as c, AdImpressionInfo as d, AdLoadedInfo as e };

package/lib/ui/StormcloudVideoPlayer.cjs

@@ -6238,6 +6238,7 @@ var HlsEngine = /*#__PURE__*/ function() {
         this.isLiveStream = false;
         this.nativeHlsMode = false;
         this.videoSrcProtection = null;
+        this.reloadingLiveStream = false;
         this.bufferedSegmentsCount = 0;
         this.shouldAutoplayAfterBuffering = false;
         this.hasInitialBufferCompleted = false;
@@ -6371,6 +6372,7 @@ var HlsEngine = /*#__PURE__*/ function() {
                                     _state.sent();
                                     _state.label = 3;
                                 case 3:
+                                    this.reloadingLiveStream = false;
                                     return [
                                         2
                                     ];
@@ -6715,6 +6717,33 @@ var HlsEngine = /*#__PURE__*/ function() {
                 }
             }
         },
+        {
+            key: "reloadLiveStream",
+            value: function reloadLiveStream() {
+                var hls = this.hls;
+                if (!hls) {
+                    return;
+                }
+                if (this.debug) {
+                    console.log("[StormcloudVideoPlayer] Hard-reloading live stream (detach \u2192 reset video \u2192 re-attach)");
+                }
+                try {
+                    this.reloadingLiveStream = true;
+                    hls.stopLoad();
+                    hls.detachMedia();
+                    try {
+                        this.video.removeAttribute("src");
+                        this.video.load();
+                    } catch (unused) {}
+                    hls.attachMedia(this.video);
+                } catch (error) {
+                    this.reloadingLiveStream = false;
+                    if (this.debug) {
+                        console.warn("[StormcloudVideoPlayer] Failed to hard-reload live stream:", error);
+                    }
+                }
+            }
+        },
         {
             key: "destroy",
             value: function destroy() {
@@ -8054,31 +8083,134 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 return 0;
             }
         },
+        {
+            key: "describeVideoState",
+            value: function describeVideoState() {
+                var _networkStates_v_networkState, _readyStates_v_readyState;
+                var v = this.host.video;
+                var networkStates = [
+                    "EMPTY",
+                    "IDLE",
+                    "LOADING",
+                    "NO_SOURCE"
+                ];
+                var readyStates = [
+                    "HAVE_NOTHING",
+                    "HAVE_METADATA",
+                    "HAVE_CURRENT_DATA",
+                    "HAVE_FUTURE_DATA",
+                    "HAVE_ENOUGH_DATA"
+                ];
+                var net = (_networkStates_v_networkState = networkStates[v.networkState]) !== null && _networkStates_v_networkState !== void 0 ? _networkStates_v_networkState : String(v.networkState);
+                var ready = (_readyStates_v_readyState = readyStates[v.readyState]) !== null && _readyStates_v_readyState !== void 0 ? _readyStates_v_readyState : String(v.readyState);
+                var err = v.error ? "code=".concat(v.error.code).concat(v.error.message ? " (".concat(v.error.message, ")") : "") : "none";
+                var ranges = [];
+                for(var i = 0; i < v.buffered.length; i++){
+                    ranges.push("[".concat(v.buffered.start(i).toFixed(2), "–").concat(v.buffered.end(i).toFixed(2), "]"));
+                }
+                return "t=".concat(v.currentTime.toFixed(2), "s paused=").concat(v.paused, " ended=").concat(v.ended, " seeking=").concat(v.seeking, " readyState=").concat(ready, " networkState=").concat(net, " error=").concat(err, " buffered=").concat(ranges.length ? ranges.join(",") : "none");
+            }
+        },
         {
             key: "monitorLiveResumeStall",
             value: function monitorLiveResumeStall(resumeBaseline) {
                 var _this = this;
                 var pollIntervalMs = 1e3;
                 var graceMs = 5e3;
-                var reloadCooldownMs = 5e3;
-                var maxHardReloads = 2;
-                var maxMonitorMs = 25e3;
+                var recoveryCooldownMs = 5e3;
+                var maxRecoveries = 2;
+                var maxMonitorMs = 3e4;
                 var startTime = Date.now();
                 var baseline = resumeBaseline;
-                var hardReloads = 0;
-                var lastReloadAt = 0;
+                var recoveries = 0;
+                var lastRecoveryAt = 0;
+                var video = this.host.video;
+                var listenersAttached = false;
+                var onMediaEvent;
+                var diagEvents = [
+                    "loadstart",
+                    "loadedmetadata",
+                    "loadeddata",
+                    "canplay",
+                    "canplaythrough",
+                    "play",
+                    "playing",
+                    "pause",
+                    "waiting",
+                    "stalled",
+                    "suspend",
+                    "seeking",
+                    "seeked",
+                    "emptied",
+                    "error",
+                    "ended"
+                ];
+                if (this.debug) {
+                    onMediaEvent = function onMediaEvent(e) {
+                        var dt = ((Date.now() - startTime) / 1e3).toFixed(1);
+                        console.log("[ResumeDiag] +".concat(dt, "s event=").concat(e.type, " — ").concat(_this.describeVideoState()));
+                    };
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = diagEvents[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var name = _step.value;
+                            video.addEventListener(name, onMediaEvent);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    listenersAttached = true;
+                    console.log("[ResumeDiag] +0.0s monitor start — ".concat(this.describeVideoState()));
+                }
+                var cleanup = function cleanup() {
+                    if (listenersAttached && onMediaEvent) {
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = diagEvents[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var name = _step.value;
+                                video.removeEventListener(name, onMediaEvent);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        listenersAttached = false;
+                    }
+                };
                 var poll = function poll1() {
                     if (_this.inAdBreak) {
+                        cleanup();
                         return;
                     }
-                    var video = _this.host.video;
                     var currentTime = video.currentTime;
                     var advanced = currentTime > baseline + 0.5;
                     var playing = !video.paused && video.readyState >= 3;
                     if (advanced && playing) {
                         if (_this.debug) {
-                            console.log("[StormcloudVideoPlayer] Live stream resumed successfully after ad break");
+                            console.log("[StormcloudVideoPlayer] Live stream resumed successfully after ad break — ".concat(_this.describeVideoState()));
                         }
+                        cleanup();
                         return;
                     }
                     if (video.paused) {
@@ -8090,23 +8222,32 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     var wedged = bufferedAhead < 0.5 && !advanced;
                     if (elapsed >= maxMonitorMs) {
                         if (_this.debug && !advanced) {
-                            console.warn("[StormcloudVideoPlayer] Live stream failed to resume after ".concat((maxMonitorMs / 1e3).toFixed(0), "s (t=").concat(currentTime.toFixed(2), "s, buffered=").concat(bufferedAhead.toFixed(2), "s)"));
+                            console.warn("[StormcloudVideoPlayer] Live stream failed to resume after ".concat((maxMonitorMs / 1e3).toFixed(0), "s — ").concat(_this.describeVideoState()));
                         }
+                        cleanup();
                         return;
                     }
-                    var canHardReload = wedged && elapsed >= graceMs && Date.now() - lastReloadAt >= reloadCooldownMs && hardReloads < maxHardReloads;
-                    if (canHardReload) {
-                        hardReloads++;
-                        lastReloadAt = Date.now();
-                        var liveSyncPos = _this.host.getLiveSyncPosition();
-                        var reloadPos = liveSyncPos != null && liveSyncPos > currentTime ? liveSyncPos : currentTime;
-                        if (_this.debug) {
-                            console.warn("[StormcloudVideoPlayer] Content wedged after ad break (t=".concat(currentTime.toFixed(2), "s, buffered=").concat(bufferedAhead.toFixed(2), "s) — forcing HLS reload at ").concat(reloadPos.toFixed(2), "s (hard reload ").concat(hardReloads, "/").concat(maxHardReloads, ")"));
-                        }
-                        if (liveSyncPos != null && liveSyncPos > currentTime) {
-                            video.currentTime = liveSyncPos;
+                    var canRecover = wedged && elapsed >= graceMs && Date.now() - lastRecoveryAt >= recoveryCooldownMs && recoveries < maxRecoveries;
+                    if (canRecover) {
+                        recoveries++;
+                        lastRecoveryAt = Date.now();
+                        var isFinalAttempt = recoveries >= maxRecoveries;
+                        if (!isFinalAttempt) {
+                            var liveSyncPos = _this.host.getLiveSyncPosition();
+                            var reloadPos = liveSyncPos != null && liveSyncPos > currentTime ? liveSyncPos : currentTime;
+                            if (_this.debug) {
+                                console.warn("[StormcloudVideoPlayer] Content wedged after ad break — restarting HLS load at ".concat(reloadPos.toFixed(2), "s (recovery ").concat(recoveries, "/").concat(maxRecoveries, ") — ").concat(_this.describeVideoState()));
+                            }
+                            if (liveSyncPos != null && liveSyncPos > currentTime) {
+                                video.currentTime = liveSyncPos;
+                            }
+                            _this.host.restartHlsLoad(reloadPos);
+                        } else {
+                            if (_this.debug) {
+                                console.warn("[StormcloudVideoPlayer] Content still wedged after ad break — hard-reloading live stream (recovery ".concat(recoveries, "/").concat(maxRecoveries, ") — ").concat(_this.describeVideoState()));
+                            }
+                            _this.host.reloadLiveStream();
                         }
-                        _this.host.restartHlsLoad(reloadPos);
                         baseline = video.currentTime;
                         if (video.paused) {
                             var _video_play1;
@@ -8269,6 +8410,9 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
             restartHlsLoad: function restartHlsLoad(position) {
                 return _this.hlsEngine.restartLoadAt(position);
             },
+            reloadLiveStream: function reloadLiveStream() {
+                return _this.hlsEngine.reloadLiveStream();
+            },
             generatePodVastUrl: function generatePodVastUrl(base, breakDurationMs) {
                 return _this.generatePodVastUrl(base, breakDurationMs);
             }
@@ -8400,6 +8544,14 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
                 return _async_to_generator(function() {
                     var prerollKey, adBehavior;
                     return _ts_generator(this, function(_state) {
+                        if (this.hlsEngine.reloadingLiveStream) {
+                            if (this.debug) {
+                                console.log("[StormcloudVideoPlayer] Manifest re-parsed after hard reload \u2014 skipping ad-player setup");
+                            }
+                            return [
+                                2
+                            ];
+                        }
                         if (!this.adConfig.isVmapEnabled() && !isLive && this.adConfig.vmapBreaks.length === 0 && this.adConfig.apiVastTagUrl) {
                             prerollKey = "synthetic-vod-preroll";
                             if (!this.adConfig.consumedVmapBreakIds.has(prerollKey)) {