stormcloud-video-player 0.8.16 → 0.8.18

package/lib/player/AdTimingService.cjs

@@ -0,0 +1,841 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function __export(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function __copyProps(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function get() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function __toCommonJS(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/player/AdTimingService.ts
+var AdTimingService_exports = {};
+__export(AdTimingService_exports, {
+    AdTimingService: function AdTimingService1() {
+        return AdTimingService;
+    }
+});
+module.exports = __toCommonJS(AdTimingService_exports);
+var AdTimingService = /*#__PURE__*/ function() {
+    function AdTimingService(config, video, callbacks) {
+        _class_call_check(this, AdTimingService);
+        this.adRequestWatchdogToken = null;
+        this.adFailsafeToken = null;
+        this.ptsDriftEmaMs = 0;
+        this.adBreakPlayedDurationMs = 0;
+        this.adBreakEpoch = 0;
+        this.adRequestTokenCounter = 0;
+        this.activeAdRequestToken = null;
+        this.currentAdIndex = 0;
+        this.totalAdsInBreak = 0;
+        this.totalAdRequestsInBreak = 0;
+        this.maxTotalAdRequestsPerBreak = 10;
+        this.lastAdRequestTime = 0;
+        this.consecutiveFailures = 0;
+        this.maxConsecutiveFailures = 5;
+        this.minAdRequestIntervalMs = 3e3;
+        this.backoffBaseMs = 1e3;
+        this.maxBackoffMs = 15e3;
+        this.defaultMinRemainingMsToStartAd = 4e3;
+        this.failedVastUrls = /* @__PURE__ */ new Set();
+        this.temporaryFailureUrls = /* @__PURE__ */ new Map();
+        this.temporaryFailureCooldownMs = 3e4;
+        this.globalConsecutiveNoFills = 0;
+        this.globalNoFillThreshold = 3;
+        this.globalNoFillCooldownUntil = 0;
+        this.globalNoFillBackoffBaseMs = 5e3;
+        this.globalNoFillBackoffMaxMs = 6e4;
+        this.globalLastGamRequestTime = 0;
+        this.globalMinGamIntervalMs = 3e3;
+        this.config = config;
+        this.video = video;
+        this.callbacks = callbacks;
+    }
+    _create_class(AdTimingService, [
+        {
+            key: "debug",
+            get: function get() {
+                return !!this.config.debugAdTiming;
+            }
+        },
+        {
+            // --- Ad stop timer ---
+            key: "scheduleAdStopCountdown",
+            value: function scheduleAdStopCountdown(remainingMs) {
+                var _this = this;
+                this.clearAdStopTimer();
+                var ms = Math.max(0, Math.floor(remainingMs));
+                if (ms === 0) {
+                    this.ensureAdStoppedByTimer();
+                    return;
+                }
+                this.adStopTimerId = window.setTimeout(function() {
+                    _this.ensureAdStoppedByTimer();
+                }, ms);
+            }
+        },
+        {
+            key: "clearAdStopTimer",
+            value: function clearAdStopTimer() {
+                if (this.adStopTimerId != null) {
+                    clearTimeout(this.adStopTimerId);
+                    this.adStopTimerId = void 0;
+                }
+            }
+        },
+        {
+            key: "ensureAdStoppedByTimer",
+            value: function ensureAdStoppedByTimer() {
+                this.adStopTimerId = void 0;
+                this.callbacks.onAdStopTimerFired();
+            }
+        },
+        {
+            // --- Ad start timer ---
+            key: "scheduleAdStartIn",
+            value: function scheduleAdStartIn(delayMs) {
+                var _this = this;
+                var marker = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                    type: "start"
+                }, cueKey = arguments.length > 2 ? arguments[2] : void 0;
+                this.clearAdStartTimer();
+                var ms = Math.max(0, Math.floor(delayMs));
+                if (ms === 0) {
+                    this.callbacks.onAdStartTimerFired(marker, cueKey);
+                    return;
+                }
+                this.adStartTimerId = window.setTimeout(function() {
+                    _this.callbacks.onAdStartTimerFired(marker, cueKey);
+                }, ms);
+            }
+        },
+        {
+            key: "clearAdStartTimer",
+            value: function clearAdStartTimer() {
+                if (this.adStartTimerId != null) {
+                    clearTimeout(this.adStartTimerId);
+                    this.adStartTimerId = void 0;
+                }
+            }
+        },
+        {
+            // --- PTS drift ---
+            key: "updatePtsDrift",
+            value: function updatePtsDrift(ptsSecondsSample) {
+                var sampleMs = (this.video.currentTime - ptsSecondsSample) * 1e3;
+                if (!Number.isFinite(sampleMs) || Math.abs(sampleMs) > 6e4) return;
+                var alpha = 0.1;
+                this.ptsDriftEmaMs = this.ptsDriftEmaMs * (1 - alpha) + sampleMs * alpha;
+            }
+        },
+        {
+            key: "resolveScteBreakStartWallClockMs",
+            value: function resolveScteBreakStartWallClockMs(marker) {
+                var nowWallClockMs = Date.now();
+                if (typeof marker.ptsSeconds !== "number") {
+                    return nowWallClockMs;
+                }
+                var nowMs = this.video.currentTime * 1e3;
+                var estimatedCurrentPtsMs = nowMs - this.ptsDriftEmaMs;
+                var deltaMs = marker.ptsSeconds * 1e3 - estimatedCurrentPtsMs;
+                if (!Number.isFinite(deltaMs)) {
+                    return nowWallClockMs;
+                }
+                return nowWallClockMs + Math.floor(deltaMs);
+            }
+        },
+        {
+            // --- Duration boundary ---
+            key: "setAdBreakDurationBoundary",
+            value: function setAdBreakDurationBoundary(durationMs) {
+                this.expectedAdBreakDurationMs = durationMs;
+                if (durationMs != null && this.currentAdBreakStartWallClockMs != null) {
+                    this.scteAdBreakEndWallClockMs = this.currentAdBreakStartWallClockMs + durationMs;
+                } else {
+                    this.scteAdBreakEndWallClockMs = void 0;
+                }
+            }
+        },
+        {
+            key: "scheduleAdStopAtBreakBoundary",
+            value: function scheduleAdStopAtBreakBoundary() {
+                if (this.expectedAdBreakDurationMs == null) {
+                    return;
+                }
+                this.scheduleAdStopCountdown(this.getWallClockRemainingAdMs());
+            }
+        },
+        {
+            // --- Duration budget ---
+            key: "getWallClockRemainingAdMs",
+            value: function getWallClockRemainingAdMs() {
+                var endWallClockMs = this.getAdBreakEndWallClockMs();
+                if (endWallClockMs != null) {
+                    return Math.max(0, endWallClockMs - Date.now());
+                }
+                return 0;
+            }
+        },
+        {
+            key: "getAdBreakEndWallClockMs",
+            value: function getAdBreakEndWallClockMs() {
+                if (this.scteAdBreakEndWallClockMs != null) {
+                    return this.scteAdBreakEndWallClockMs;
+                }
+                if (this.expectedAdBreakDurationMs == null || this.currentAdBreakStartWallClockMs == null) {
+                    return void 0;
+                }
+                return this.currentAdBreakStartWallClockMs + this.expectedAdBreakDurationMs;
+            }
+        },
+        {
+            key: "getDurationBudgetRemainingMs",
+            value: function getDurationBudgetRemainingMs() {
+                if (this.expectedAdBreakDurationMs == null) {
+                    return 0;
+                }
+                return Math.max(0, this.expectedAdBreakDurationMs - this.adBreakPlayedDurationMs);
+            }
+        },
+        {
+            key: "getLoadedAdDurationMs",
+            value: function getLoadedAdDurationMs(adController) {
+                var _adController_getLoadedAdDuration;
+                var durationSec = (_adController_getLoadedAdDuration = adController.getLoadedAdDuration) === null || _adController_getLoadedAdDuration === void 0 ? void 0 : _adController_getLoadedAdDuration.call(adController);
+                if (durationSec == null || durationSec <= 0) {
+                    return 0;
+                }
+                return Math.round(durationSec * 1e3);
+            }
+        },
+        {
+            key: "adFitsRemainingBudget",
+            value: function adFitsRemainingBudget(durationMs) {
+                if (durationMs <= 0) {
+                    return true;
+                }
+                return durationMs <= this.getDurationBudgetRemainingMs();
+            }
+        },
+        {
+            key: "logAdDurationDecision",
+            value: function logAdDurationDecision(accepted, durationMs, adController) {
+                var _ref;
+                var _adController_getLoadedAdId;
+                if (!this.debug) {
+                    return;
+                }
+                var remainingBudget = this.getDurationBudgetRemainingMs();
+                var adId = (_ref = (_adController_getLoadedAdId = adController.getLoadedAdId) === null || _adController_getLoadedAdId === void 0 ? void 0 : _adController_getLoadedAdId.call(adController)) !== null && _ref !== void 0 ? _ref : "unknown";
+                if (accepted) {
+                    console.log("[AD-DURATION] Accepted ad id=".concat(adId, ", duration=").concat(durationMs, "ms, budget remaining after play=").concat(Math.max(0, remainingBudget - durationMs), "ms"));
+                } else {
+                    console.log("[AD-DURATION] Rejected ad id=".concat(adId, ", duration=").concat(durationMs, "ms exceeds remaining budget=").concat(remainingBudget, "ms — requesting another ad"));
+                }
+            }
+        },
+        {
+            key: "recordPlayedAdDuration",
+            value: function recordPlayedAdDuration(adController) {
+                var durationMs = this.getLoadedAdDurationMs(adController);
+                if (durationMs <= 0) {
+                    return;
+                }
+                this.adBreakPlayedDurationMs += durationMs;
+                if (this.debug) {
+                    var _this_expectedAdBreakDurationMs;
+                    console.log("[AD-DURATION] Played ".concat(durationMs, "ms — total played=").concat(this.adBreakPlayedDurationMs, "ms / ").concat((_this_expectedAdBreakDurationMs = this.expectedAdBreakDurationMs) !== null && _this_expectedAdBreakDurationMs !== void 0 ? _this_expectedAdBreakDurationMs : "?", "ms"));
+                }
+            }
+        },
+        {
+            key: "ensureLoadedAdFitsBudget",
+            value: function ensureLoadedAdFitsBudget(adController) {
+                var durationMs = this.getLoadedAdDurationMs(adController);
+                var fits = this.adFitsRemainingBudget(durationMs);
+                this.logAdDurationDecision(fits, durationMs, adController);
+                return fits;
+            }
+        },
+        {
+            key: "rejectLoadedAdForDuration",
+            value: function rejectLoadedAdForDuration(adController) {
+                try {
+                    adController.destroy();
+                } catch (unused) {}
+            }
+        },
+        {
+            key: "markAdStarted",
+            value: function markAdStarted() {
+                this.currentAdIndex++;
+                this.totalAdsInBreak = this.currentAdIndex;
+                this.totalAdRequestsInBreak++;
+                this.lastAdRequestTime = Date.now();
+            }
+        },
+        {
+            key: "getRemainingAdMs",
+            value: function getRemainingAdMs() {
+                var wallClockRemaining = this.getWallClockRemainingAdMs();
+                var budgetRemaining = this.getDurationBudgetRemainingMs();
+                if (this.expectedAdBreakDurationMs == null) {
+                    return wallClockRemaining;
+                }
+                return Math.min(wallClockRemaining, budgetRemaining);
+            }
+        },
+        {
+            key: "getMinRemainingMsToStartAd",
+            value: function getMinRemainingMsToStartAd() {
+                var configured = this.config.minRemainingMsToStartAd;
+                if (typeof configured === "number" && configured >= 0) {
+                    return configured;
+                }
+                return this.defaultMinRemainingMsToStartAd;
+            }
+        },
+        {
+            key: "hasTimeToStartAnotherAd",
+            value: function hasTimeToStartAnotherAd() {
+                var minRemaining = this.getMinRemainingMsToStartAd();
+                return this.getWallClockRemainingAdMs() > minRemaining && this.getDurationBudgetRemainingMs() > minRemaining;
+            }
+        },
+        {
+            // --- Circuit breaker ---
+            key: "isTemporaryAdError",
+            value: function isTemporaryAdError(error) {
+                var _error_message;
+                var message = (error === null || error === void 0 ? void 0 : (_error_message = error.message) === null || _error_message === void 0 ? void 0 : _error_message.toLowerCase()) || "";
+                if (message.includes("no ads available") || message.includes("no fill") || message.includes("nofill")) {
+                    return true;
+                }
+                if (message.includes("timeout")) {
+                    return true;
+                }
+                if (message.includes("rate limit") || message.includes("too many requests")) {
+                    return true;
+                }
+                if (message.includes("ad playback error")) {
+                    return true;
+                }
+                return false;
+            }
+        },
+        {
+            key: "isUrlInCooldown",
+            value: function isUrlInCooldown(vastTagUrl) {
+                var failureTime = this.temporaryFailureUrls.get(vastTagUrl);
+                if (failureTime == null) {
+                    return false;
+                }
+                var elapsed = Date.now() - failureTime;
+                if (elapsed >= this.temporaryFailureCooldownMs) {
+                    this.temporaryFailureUrls.delete(vastTagUrl);
+                    return false;
+                }
+                return true;
+            }
+        },
+        {
+            key: "cleanupTemporaryFailures",
+            value: function cleanupTemporaryFailures() {
+                var now = Date.now();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this.temporaryFailureUrls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), url = _step_value[0], timestamp = _step_value[1];
+                        if (now - timestamp >= this.temporaryFailureCooldownMs) {
+                            this.temporaryFailureUrls.delete(url);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "isGamInCooldown",
+            value: function isGamInCooldown() {
+                return Date.now() < this.globalNoFillCooldownUntil;
+            }
+        },
+        {
+            key: "recordGamNoFill",
+            value: function recordGamNoFill() {
+                this.globalConsecutiveNoFills++;
+                if (this.globalConsecutiveNoFills >= this.globalNoFillThreshold) {
+                    var exponent = this.globalConsecutiveNoFills - this.globalNoFillThreshold;
+                    var backoff = Math.min(this.globalNoFillBackoffBaseMs * Math.pow(2, exponent), this.globalNoFillBackoffMaxMs);
+                    this.globalNoFillCooldownUntil = Date.now() + backoff;
+                    if (this.debug) {
+                        console.log("[CIRCUIT-BREAKER] GAM cooldown activated: ".concat(backoff, "ms (").concat(this.globalConsecutiveNoFills, " consecutive no-fills)"));
+                    }
+                }
+            }
+        },
+        {
+            key: "resetGamNoFillCounter",
+            value: function resetGamNoFillCounter() {
+                if (this.globalConsecutiveNoFills > 0 && this.debug) {
+                    console.log("[CIRCUIT-BREAKER] Resetting no-fill counter (was ".concat(this.globalConsecutiveNoFills, ")"));
+                }
+                this.globalConsecutiveNoFills = 0;
+                this.globalNoFillCooldownUntil = 0;
+            }
+        },
+        {
+            key: "enforceGlobalRateLimit",
+            value: function enforceGlobalRateLimit() {
+                return _async_to_generator(function() {
+                    var now, elapsed, waitMs;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                now = Date.now();
+                                elapsed = now - this.globalLastGamRequestTime;
+                                if (!(elapsed < this.globalMinGamIntervalMs)) return [
+                                    3,
+                                    2
+                                ];
+                                waitMs = this.globalMinGamIntervalMs - elapsed;
+                                if (this.debug) {
+                                    console.log("[RATE-LIMIT] Waiting ".concat(waitMs, "ms before next GAM request"));
+                                }
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, waitMs);
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                this.globalLastGamRequestTime = Date.now();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            // --- Watchdog ---
+            key: "startAdRequestWatchdog",
+            value: function startAdRequestWatchdog(token) {
+                var _this = this;
+                var _this_config_adFailsafeTimeoutMs;
+                this.clearAdRequestWatchdog();
+                var timeoutMs = (_this_config_adFailsafeTimeoutMs = this.config.adFailsafeTimeoutMs) !== null && _this_config_adFailsafeTimeoutMs !== void 0 ? _this_config_adFailsafeTimeoutMs : 1e4;
+                this.adRequestWatchdogToken = token;
+                this.adRequestWatchdogId = window.setTimeout(function() {
+                    if (_this.adRequestWatchdogToken !== token) {
+                        return;
+                    }
+                    _this.adRequestWatchdogId = void 0;
+                    _this.adRequestWatchdogToken = null;
+                    if (_this.activeAdRequestToken === token) {
+                        _this.activeAdRequestToken = null;
+                    }
+                    _this.logAdState("ad_request_timeout", {
+                        token: token,
+                        timeoutMs: timeoutMs
+                    });
+                    _this.callbacks.onWatchdogTimeout();
+                }, timeoutMs);
+                this.logAdState("ad_request_watchdog_started", {
+                    token: token,
+                    timeoutMs: timeoutMs
+                });
+            }
+        },
+        {
+            key: "clearAdRequestWatchdog",
+            value: function clearAdRequestWatchdog() {
+                if (this.adRequestWatchdogId != null) {
+                    clearTimeout(this.adRequestWatchdogId);
+                    this.adRequestWatchdogId = void 0;
+                }
+                if (this.adRequestWatchdogToken != null) {
+                    this.logAdState("ad_request_watchdog_cleared", {
+                        token: this.adRequestWatchdogToken
+                    });
+                    this.adRequestWatchdogToken = null;
+                }
+            }
+        },
+        {
+            // --- Failsafe ---
+            key: "startAdFailsafeTimer",
+            value: function startAdFailsafeTimer(token) {
+                var _this = this;
+                var _this_config_adFailsafeTimeoutMs;
+                this.clearAdFailsafeTimer();
+                var failsafeMs = (_this_config_adFailsafeTimeoutMs = this.config.adFailsafeTimeoutMs) !== null && _this_config_adFailsafeTimeoutMs !== void 0 ? _this_config_adFailsafeTimeoutMs : 1e4;
+                this.adFailsafeToken = token;
+                this.adFailsafeTimerId = window.setTimeout(function() {
+                    if (_this.adFailsafeToken !== token) {
+                        return;
+                    }
+                    _this.adFailsafeTimerId = void 0;
+                    _this.adFailsafeToken = null;
+                    if (_this.activeAdRequestToken === token) {
+                        _this.activeAdRequestToken = null;
+                    }
+                    _this.logAdState("ad_failsafe_triggered", {
+                        token: token,
+                        failsafeMs: failsafeMs,
+                        videoPaused: _this.video.paused
+                    });
+                    _this.callbacks.onFailsafeTimeout();
+                }, failsafeMs);
+                this.logAdState("ad_failsafe_started", {
+                    token: token,
+                    failsafeMs: failsafeMs
+                });
+            }
+        },
+        {
+            key: "clearAdFailsafeTimer",
+            value: function clearAdFailsafeTimer() {
+                if (this.adFailsafeTimerId != null) {
+                    clearTimeout(this.adFailsafeTimerId);
+                    this.logAdState("ad_failsafe_cleared", {
+                        token: this.adFailsafeToken
+                    });
+                    this.adFailsafeTimerId = void 0;
+                }
+                this.adFailsafeToken = null;
+            }
+        },
+        {
+            key: "logAdState",
+            value: function logAdState(event) {
+                var extra = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, adPlayer = arguments.length > 2 ? arguments[2] : void 0, inAdBreak = arguments.length > 3 ? arguments[3] : void 0, showAds = arguments.length > 4 ? arguments[4] : void 0;
+                var _ref;
+                if (!this.debug) {
+                    return;
+                }
+                console.log("[StormcloudVideoPlayer][AdState]", _object_spread({
+                    event: event,
+                    timestamp: /* @__PURE__ */ new Date().toISOString(),
+                    showAds: showAds !== null && showAds !== void 0 ? showAds : false,
+                    adPlaying: (_ref = adPlayer === null || adPlayer === void 0 ? void 0 : adPlayer.isAdPlaying()) !== null && _ref !== void 0 ? _ref : false,
+                    inAdBreak: inAdBreak !== null && inAdBreak !== void 0 ? inAdBreak : false,
+                    activeAdRequestToken: this.activeAdRequestToken
+                }, extra));
+            }
+        },
+        {
+            // --- Reset for ad break end ---
+            key: "resetForBreakEnd",
+            value: function resetForBreakEnd() {
+                this.clearAdStopTimer();
+                this.clearAdStartTimer();
+                this.clearAdRequestWatchdog();
+                this.clearAdFailsafeTimer();
+                this.activeAdRequestToken = null;
+                this.expectedAdBreakDurationMs = void 0;
+                this.currentAdBreakStartWallClockMs = void 0;
+                this.scteAdBreakEndWallClockMs = void 0;
+                this.adBreakPlayedDurationMs = 0;
+                this.currentAdIndex = 0;
+                this.totalAdsInBreak = 0;
+                this.consecutiveFailures = 0;
+                this.globalConsecutiveNoFills = 0;
+                this.adBreakEpoch++;
+            }
+        },
+        {
+            key: "destroy",
+            value: function destroy() {
+                this.clearAdStopTimer();
+                this.clearAdStartTimer();
+                this.clearAdFailsafeTimer();
+                this.clearAdRequestWatchdog();
+            }
+        }
+    ]);
+    return AdTimingService;
+}();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    AdTimingService: AdTimingService
+});
+//# sourceMappingURL=AdTimingService.cjs.map