stormcloud-video-player 0.8.15 → 0.8.17

package/lib/player/AdBreakOrchestrator.cjs

@@ -0,0 +1,2275 @@
+"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_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(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(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread 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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = function __toESM(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+var __toCommonJS = function __toCommonJS(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/player/AdBreakOrchestrator.ts
+var AdBreakOrchestrator_exports = {};
+__export(AdBreakOrchestrator_exports, {
+    AdBreakOrchestrator: function AdBreakOrchestrator1() {
+        return AdBreakOrchestrator;
+    }
+});
+module.exports = __toCommonJS(AdBreakOrchestrator_exports);
+// src/utils/mqttConfig.ts
+var DEFAULT_MQTT_CONFIG = {
+    enabled: true,
+    brokerAddress: "vecbae77.ala.us-east-1.emqxsl.com",
+    brokerPort: 8883,
+    wsPort: 8084,
+    username: "for-sonifi",
+    password: "sonifi-mqtt",
+    topicPrefix: "adstorm/players",
+    qos: 1
+};
+var mqttConfig = _object_spread({}, DEFAULT_MQTT_CONFIG);
+function isMQTTEnabled() {
+    return mqttConfig.enabled;
+}
+function buildMQTTBrokerUrl() {
+    if (mqttConfig.brokerUrl) return mqttConfig.brokerUrl;
+    return "wss://".concat(mqttConfig.brokerAddress, ":").concat(mqttConfig.wsPort, "/mqtt");
+}
+function buildPlayerTopic(licenseKey, channel) {
+    return "".concat(mqttConfig.topicPrefix, "/").concat(licenseKey, "/").concat(channel);
+}
+// src/utils/mqttClient.ts
+var import_mqtt = __toESM(require("mqtt"), 1);
+var LOG = "[StormcloudVideoPlayer][MQTT]";
+var client = null;
+var status = "disconnected";
+function initMQTTClient() {
+    if (client || !isMQTTEnabled()) return;
+    var url = buildMQTTBrokerUrl();
+    status = "connecting";
+    var clientId = "stormcloud-vp-".concat(Math.random().toString(36).slice(2, 9));
+    try {
+        client = import_mqtt.default.connect(url, {
+            clientId: clientId,
+            username: mqttConfig.username,
+            password: mqttConfig.password,
+            keepalive: 60,
+            clean: true,
+            reconnectPeriod: 5e3,
+            connectTimeout: 1e4,
+            queueQoSZero: false
+        });
+    } catch (err) {
+        status = "error";
+        console.warn("".concat(LOG, " connect() threw:"), err);
+        return;
+    }
+    client.on("connect", function() {
+        status = "connected";
+        console.info("".concat(LOG, " connected to ").concat(url));
+    });
+    client.on("reconnect", function() {
+        status = "connecting";
+        console.info("".concat(LOG, " reconnecting…"));
+    });
+    client.on("offline", function() {
+        status = "disconnected";
+        console.warn("".concat(LOG, " offline"));
+    });
+    client.on("error", function(err) {
+        status = "error";
+        console.warn("".concat(LOG, " error:"), err.message);
+    });
+    client.on("close", function() {
+        if (status === "connected") {
+            status = "disconnected";
+        }
+    });
+}
+function ensureMQTTClient() {
+    if (isMQTTEnabled() && !client) {
+        initMQTTClient();
+    }
+}
+function publishMQTT(topic, payload) {
+    if (!isMQTTEnabled()) {
+        return false;
+    }
+    ensureMQTTClient();
+    if (!client) {
+        return false;
+    }
+    try {
+        client.publish(topic, JSON.stringify(payload), {
+            qos: mqttConfig.qos
+        });
+        return true;
+    } catch (err) {
+        console.warn("".concat(LOG, " publish failed on ").concat(topic, ":"), err);
+        return false;
+    }
+}
+// src/utils/tracking.ts
+var cachedBrowserId = null;
+function getClientInfo() {
+    var _screen, _screen1, _screen2, _screen3, _screen_orientation, _screen4, _screen5, _window, _window1, _window_screen_orientation, _window_screen, _navigator_languages;
+    var ua = navigator.userAgent;
+    var platform = navigator.platform;
+    var vendor = navigator.vendor || "";
+    var maxTouchPoints = navigator.maxTouchPoints || 0;
+    var memory = navigator.deviceMemory || null;
+    var hardwareConcurrency = navigator.hardwareConcurrency || 1;
+    var screenInfo = {
+        width: (_screen = screen) === null || _screen === void 0 ? void 0 : _screen.width,
+        height: (_screen1 = screen) === null || _screen1 === void 0 ? void 0 : _screen1.height,
+        availWidth: (_screen2 = screen) === null || _screen2 === void 0 ? void 0 : _screen2.availWidth,
+        availHeight: (_screen3 = screen) === null || _screen3 === void 0 ? void 0 : _screen3.availHeight,
+        orientation: ((_screen4 = screen) === null || _screen4 === void 0 ? void 0 : (_screen_orientation = _screen4.orientation) === null || _screen_orientation === void 0 ? void 0 : _screen_orientation.type) || "",
+        pixelDepth: (_screen5 = screen) === null || _screen5 === void 0 ? void 0 : _screen5.pixelDepth
+    };
+    var deviceType = "desktop";
+    var brand = "Unknown";
+    var os = "Unknown";
+    var model = "";
+    var isSmartTV = false;
+    var isAndroid = false;
+    var isWebView = false;
+    var isWebApp = false;
+    if (ua.includes("Web0S")) {
+        brand = "LG";
+        os = "webOS";
+        isSmartTV = true;
+        deviceType = "tv";
+        var webosMatch = ua.match(/Web0S\/([^\s]+)/);
+        model = webosMatch ? "webOS ".concat(webosMatch[1]) : "webOS TV";
+    } else if (ua.includes("Tizen")) {
+        brand = "Samsung";
+        os = "Tizen";
+        isSmartTV = true;
+        deviceType = "tv";
+        var tizenMatch = ua.match(/Tizen\/([^\s]+)/);
+        var tvMatch = ua.match(/(?:Smart-TV|SMART-TV|TV)/i) ? "Smart TV" : "";
+        model = tizenMatch ? "Tizen ".concat(tizenMatch[1], " ").concat(tvMatch).trim() : "Tizen TV";
+    } else if (ua.includes("Philips")) {
+        brand = "Philips";
+        os = "Saphi";
+        isSmartTV = true;
+        deviceType = "tv";
+    } else if (ua.includes("Sharp") || ua.includes("AQUOS")) {
+        brand = "Sharp";
+        os = "Android TV";
+        isSmartTV = true;
+        deviceType = "tv";
+    } else if (ua.includes("Android") && (ua.includes("Sony") || vendor.includes("Sony"))) {
+        brand = "Sony";
+        os = "Android TV";
+        isSmartTV = true;
+        deviceType = "tv";
+    } else if (ua.includes("Android") && (ua.includes("NetCast") || ua.includes("LG"))) {
+        brand = "LG";
+        os = "Android TV";
+        isSmartTV = true;
+        deviceType = "tv";
+    } else if (ua.includes(" Roku") || ua.includes("Roku/")) {
+        brand = "Roku";
+        os = "Roku OS";
+        isSmartTV = true;
+        deviceType = "tv";
+    } else if (ua.includes("AppleTV")) {
+        brand = "Apple";
+        os = "tvOS";
+        isSmartTV = true;
+        deviceType = "tv";
+    }
+    if (ua.includes("Android")) {
+        isAndroid = true;
+        os = "Android";
+        deviceType = /Mobile/.test(ua) ? "mobile" : "tablet";
+        if (ua.includes("Android") && (maxTouchPoints === 0 || ua.includes("Google TV") || ua.includes("XiaoMi"))) {
+            deviceType = "tv";
+            isSmartTV = true;
+            brand = brand === "Unknown" ? "Android TV" : brand;
+        }
+        var androidModelMatch = ua.match(/\(([^)]*Android[^)]*)\)/);
+        if (androidModelMatch && androidModelMatch[1]) {
+            model = androidModelMatch[1];
+        }
+    }
+    if (/iPad|iPhone|iPod/.test(ua)) {
+        os = "iOS";
+        deviceType = "mobile";
+        brand = "Apple";
+        if (navigator.maxTouchPoints > 1 && /iPad/.test(ua)) {
+            deviceType = "tablet";
+        }
+    }
+    if (!isAndroid && !isSmartTV && !/Mobile/.test(ua)) {
+        if (ua.includes("Windows")) {
+            os = "Windows";
+            deviceType = "desktop";
+        } else if (ua.includes("Mac") && !/iPhone/.test(ua)) {
+            os = "macOS";
+            deviceType = "desktop";
+            if (maxTouchPoints > 1) deviceType = "tablet";
+        } else if (ua.includes("Linux")) {
+            os = "Linux";
+            deviceType = "desktop";
+        }
+    }
+    if (brand === "Unknown") {
+        if (vendor.includes("Google") || ua.includes("Chrome")) brand = "Google";
+        if (vendor.includes("Apple")) brand = "Apple";
+        if (vendor.includes("Samsung") || ua.includes("SM-")) brand = "Samsung";
+    }
+    isWebView = /wv|WebView|Linux; U;/.test(ua);
+    if (((_window = window) === null || _window === void 0 ? void 0 : _window.outerHeight) === 0 && ((_window1 = window) === null || _window1 === void 0 ? void 0 : _window1.outerWidth) === 0) {
+        isWebView = true;
+    }
+    isWebApp = window.matchMedia("(display-mode: standalone)").matches || window.navigator.standalone === true || ((_window_screen = window.screen) === null || _window_screen === void 0 ? void 0 : (_window_screen_orientation = _window_screen.orientation) === null || _window_screen_orientation === void 0 ? void 0 : _window_screen_orientation.angle) !== void 0;
+    return {
+        brand: brand,
+        os: os,
+        model: model || ua.substring(0, 50) + "...",
+        deviceType: deviceType,
+        isSmartTV: isSmartTV,
+        isAndroid: isAndroid,
+        isWebView: isWebView,
+        isWebApp: isWebApp,
+        domain: window.location.hostname,
+        origin: window.location.origin,
+        path: window.location.pathname,
+        userAgent: ua,
+        vendor: vendor,
+        platform: platform,
+        screen: screenInfo,
+        hardwareConcurrency: hardwareConcurrency,
+        deviceMemory: memory,
+        maxTouchPoints: maxTouchPoints,
+        language: navigator.language,
+        languages: ((_navigator_languages = navigator.languages) === null || _navigator_languages === void 0 ? void 0 : _navigator_languages.join(",")) || "",
+        cookieEnabled: navigator.cookieEnabled,
+        doNotTrack: navigator.doNotTrack || "",
+        referrer: document.referrer,
+        visibilityState: document.visibilityState
+    };
+}
+function getBrowserID(clientInfo) {
+    return _async_to_generator(function() {
+        var _crypto_subtle, fingerprintString, encodedData, utf8, buffer, i, hashBuffer, hashHex, unused, hash, i1, char, fallbackHash, timestamp, random;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (cachedBrowserId) {
+                        return [
+                            2,
+                            cachedBrowserId
+                        ];
+                    }
+                    fingerprintString = JSON.stringify(clientInfo);
+                    if (!(typeof crypto !== "undefined" && ((_crypto_subtle = crypto.subtle) === null || _crypto_subtle === void 0 ? void 0 : _crypto_subtle.digest))) return [
+                        3,
+                        5
+                    ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        crypto.subtle.digest("SHA-256", new Uint8Array([
+                            1,
+                            2,
+                            3
+                        ]))
+                    ];
+                case 2:
+                    _state.sent();
+                    if (typeof TextEncoder !== "undefined") {
+                        encodedData = new TextEncoder().encode(fingerprintString);
+                    } else {
+                        utf8 = unescape(encodeURIComponent(fingerprintString));
+                        buffer = new Uint8Array(utf8.length);
+                        for(i = 0; i < utf8.length; i++){
+                            buffer[i] = utf8.charCodeAt(i);
+                        }
+                        encodedData = buffer;
+                    }
+                    return [
+                        4,
+                        crypto.subtle.digest("SHA-256", encodedData)
+                    ];
+                case 3:
+                    hashBuffer = _state.sent();
+                    hashHex = Array.from(new Uint8Array(hashBuffer)).map(function(b) {
+                        return b.toString(16).padStart(2, "0");
+                    }).join("");
+                    cachedBrowserId = hashHex;
+                    return [
+                        2,
+                        hashHex
+                    ];
+                case 4:
+                    unused = _state.sent();
+                    console.warn("[StormcloudVideoPlayer] crypto.subtle not supported, using fallback hash");
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    hash = 0;
+                    for(i1 = 0; i1 < fingerprintString.length; i1++){
+                        char = fingerprintString.charCodeAt(i1);
+                        hash = (hash << 5) - hash + char;
+                        hash = hash & hash;
+                    }
+                    fallbackHash = Math.abs(hash).toString(16).padStart(8, "0");
+                    timestamp = Date.now().toString(16).padStart(12, "0");
+                    random = Math.random().toString(16).substring(2, 14).padStart(12, "0");
+                    cachedBrowserId = (fallbackHash + timestamp + random).padEnd(64, "0");
+                    return [
+                        2,
+                        cachedBrowserId
+                    ];
+            }
+        });
+    })();
+}
+function canPublish(licenseKey) {
+    return Boolean(isMQTTEnabled() && licenseKey);
+}
+function buildPlayerMetricEvent() {
+    return _async_to_generator(function() {
+        var context, flags, _flags_captureAt, _flags_adLoaded, _flags_adDetect, clientInfo, playerId, captureAt;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    context = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : {}, flags = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                    clientInfo = getClientInfo();
+                    return [
+                        4,
+                        getBrowserID(clientInfo)
+                    ];
+                case 1:
+                    playerId = _state.sent();
+                    captureAt = (_flags_captureAt = flags.captureAt) !== null && _flags_captureAt !== void 0 ? _flags_captureAt : /* @__PURE__ */ new Date().toISOString();
+                    return [
+                        2,
+                        _object_spread({
+                            player_id: playerId,
+                            device_type: clientInfo.deviceType,
+                            os: clientInfo.os.toLowerCase(),
+                            ad_loaded: (_flags_adLoaded = flags.adLoaded) !== null && _flags_adLoaded !== void 0 ? _flags_adLoaded : false,
+                            ad_detect: (_flags_adDetect = flags.adDetect) !== null && _flags_adDetect !== void 0 ? _flags_adDetect : false,
+                            capture_at: captureAt
+                        }, context.inputStreamType ? {
+                            input_stream_type: context.inputStreamType
+                        } : {})
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function publishTracking(licenseKey, channel, body) {
+    ensureMQTTClient();
+    publishMQTT(buildPlayerTopic(licenseKey, channel), body);
+}
+function sendAdLoadedTracking(_0, _1) {
+    return _async_to_generator(function(licenseKey, adLoadedInfo) {
+        var context, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    context = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        sendHeartbeat(licenseKey, context, {
+                            adLoaded: true,
+                            captureAt: adLoadedInfo.timestamp
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.error("[StormcloudVideoPlayer] Error sending ad loaded tracking:", error);
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function sendAdImpressionTracking(_0, _1) {
+    return _async_to_generator(function(licenseKey, adImpressionInfo) {
+        var context, metricEvent, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    context = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+                    if (!canPublish(licenseKey)) return [
+                        2
+                    ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        buildPlayerMetricEvent(context, {
+                            captureAt: adImpressionInfo.timestamp
+                        })
+                    ];
+                case 2:
+                    metricEvent = _state.sent();
+                    publishTracking(licenseKey, "heartbeat", metricEvent);
+                    publishTracking(licenseKey, "impressions", {
+                        events: [
+                            {
+                                player_id: metricEvent.player_id,
+                                ad_played_count: 1,
+                                ad_url: adImpressionInfo.adUrl,
+                                capture_at: adImpressionInfo.timestamp
+                            }
+                        ]
+                    });
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.error("[StormcloudVideoPlayer] Error sending ad impression tracking:", error);
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function sendHeartbeat(_0) {
+    return _async_to_generator(function(licenseKey) {
+        var context, flags, heartbeatData, error;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    context = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {}, flags = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+                    if (!canPublish(licenseKey)) return [
+                        2
+                    ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        buildPlayerMetricEvent(context, flags)
+                    ];
+                case 2:
+                    heartbeatData = _state.sent();
+                    publishTracking(licenseKey, "heartbeat", heartbeatData);
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.error("[StormcloudVideoPlayer] Error sending heartbeat:", error);
+                    return [
+                        3,
+                        4
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+// src/player/PlayerControls.ts
+function getAdAudioVolume(adPlayer) {
+    return adPlayer.getOriginalMutedState() ? 0 : adPlayer.getOriginalVolume();
+}
+// src/player/AdBreakOrchestrator.ts
+var AdBreakOrchestrator = /*#__PURE__*/ function() {
+    function AdBreakOrchestrator(host, timing, preloadPool, vmap, cueManager, placeholder) {
+        _class_call_check(this, AdBreakOrchestrator);
+        this.inAdBreak = false;
+        this.showAds = false;
+        this.isShowingPlaceholder = false;
+        this.adDetectSentForCurrentBreak = false;
+        this.continuousFetchingActive = false;
+        this.continuousFetchLoopRunning = false;
+        this.adRequestQueue = [];
+        this.adPodQueue = [];
+        this.maxPlaceholderDurationMs = 5e3;
+        this.pendingAdBreak = null;
+        this.host = host;
+        this.timing = timing;
+        this.preloadPool = preloadPool;
+        this.vmap = vmap;
+        this.cueManager = cueManager;
+        this.placeholder = placeholder;
+    }
+    _create_class(AdBreakOrchestrator, [
+        {
+            key: "debug",
+            get: function get() {
+                return !!this.host.config.debugAdTiming;
+            }
+        },
+        {
+            // ───────────────────────────────────────────────────────────────
+            //  IMA event listeners
+            // ───────────────────────────────────────────────────────────────
+            key: "attachImaEventListeners",
+            value: function attachImaEventListeners() {
+                var _this = this;
+                var adPlayer = this.host.getAdPlayer();
+                adPlayer.on("all_ads_completed", function() {
+                    sendAdImpressionTracking(_this.host.config.licenseKey, {
+                        source: "hls",
+                        adIndex: _this.timing.currentAdIndex,
+                        timestamp: /* @__PURE__ */ new Date().toISOString()
+                    }).catch(function() {});
+                    _this.timing.recordPlayedAdDuration(_this.host.getAdPlayer());
+                    var remaining = _this.timing.getRemainingAdMs();
+                    _this.timing.consecutiveFailures = 0;
+                    if (_this.debug) {
+                        console.log("[StormcloudVideoPlayer] all_ads_completed event received - remaining=".concat(remaining, "ms, queued ads=").concat(_this.adRequestQueue.length), _this.adRequestQueue.length > 0 ? {
+                            queuedUrls: _to_consumable_array(_this.adRequestQueue)
+                        } : {});
+                    }
+                    if (_this.inAdBreak) {
+                        if (_this.timing.hasTimeToStartAnotherAd()) {
+                            _this.tryNextAvailableAdWithRateLimit();
+                        } else {
+                            _this.handleAdPodComplete();
+                        }
+                    }
+                });
+                adPlayer.on("ad_error", function(errorPayload) {
+                    var errorMessage = "Ad playback failed";
+                    if (errorPayload) {
+                        var errorCode = errorPayload.code || errorPayload.errorCode || "unknown";
+                        var vastErrorCode = errorPayload.vastErrorCode;
+                        var message = errorPayload.message || errorPayload.errorMessage || "Unknown error";
+                        var cause = errorPayload.cause || errorPayload.innerError || errorPayload.error;
+                        errorMessage = "Ad error: AdError ".concat(errorCode, ": ").concat(message);
+                        if (vastErrorCode && vastErrorCode !== "N/A" && vastErrorCode !== errorCode) {
+                            errorMessage += " (VAST Error Code: ".concat(vastErrorCode, ")");
+                        }
+                        if (cause) {
+                            var causeMessage = typeof cause === "string" ? cause : cause.message || String(cause);
+                            errorMessage += ". Caused by: ".concat(causeMessage);
+                        }
+                    }
+                    console.error("[AD-ERROR]", errorMessage, errorPayload || "");
+                    _this.handleAdFailure();
+                });
+                adPlayer.on("content_pause", function() {
+                    _this.timing.clearAdFailsafeTimer();
+                    _this.timing.clearAdRequestWatchdog();
+                    _this.timing.activeAdRequestToken = null;
+                    _this.showAds = true;
+                    _this.timing.resetGamNoFillCounter();
+                    if (_this.inAdBreak && _this.timing.expectedAdBreakDurationMs != null && _this.timing.getAdBreakEndWallClockMs() == null) {
+                        _this.timing.scheduleAdStopAtBreakBoundary();
+                        if (_this.debug) {
+                            console.log("[StormcloudVideoPlayer] Starting ad break timer on content_pause (first ad starting)");
+                        }
+                    }
+                    _this.host.getAdPlayer().setAdVolume(getAdAudioVolume(_this.host.getAdPlayer()));
+                    if (_this.isShowingPlaceholder) {
+                        if (_this.debug) {
+                            console.log("[StormcloudVideoPlayer] Hiding placeholder - new ads starting");
+                        }
+                        _this.host.getAdPlayer().hidePlaceholder();
+                        _this.isShowingPlaceholder = false;
+                    }
+                });
+                adPlayer.on("content_resume", function() {
+                    sendAdImpressionTracking(_this.host.config.licenseKey, {
+                        source: "hls",
+                        adIndex: _this.timing.currentAdIndex,
+                        timestamp: /* @__PURE__ */ new Date().toISOString()
+                    }).catch(function() {});
+                    if (!_this.host.video.muted) {
+                        _this.host.video.muted = true;
+                        if (_this.debug) {
+                            console.log("[StormcloudVideoPlayer] Muted video on content_resume (ad ended, gap between ads)");
+                        }
+                    }
+                    _this.timing.clearAdFailsafeTimer();
+                    _this.timing.clearAdRequestWatchdog();
+                    _this.timing.activeAdRequestToken = null;
+                    _this.showAds = false;
+                    if (!_this.inAdBreak) {
+                        return;
+                    }
+                    _this.timing.consecutiveFailures = 0;
+                    _this.timing.recordPlayedAdDuration(_this.host.getAdPlayer());
+                    var remaining = _this.timing.getRemainingAdMs();
+                    if (_this.debug) {
+                        console.log("[CONTINUOUS-FETCH] content_resume event: remaining=".concat(remaining, "ms, queued ads=").concat(_this.adRequestQueue.length), _this.adRequestQueue.length > 0 ? {
+                            queuedUrls: _to_consumable_array(_this.adRequestQueue)
+                        } : {});
+                    }
+                    if (_this.timing.hasTimeToStartAnotherAd()) {
+                        _this.tryNextAvailableAdWithRateLimit();
+                    } else {
+                        _this.handleAdPodComplete();
+                    }
+                });
+            }
+        },
+        {
+            key: "recreateAdController",
+            value: function recreateAdController() {
+                if (this.debug) {
+                    console.log("[StormcloudVideoPlayer] Recreating AdController for new ad");
+                }
+                var shouldShowPlaceholder = this.inAdBreak && this.showAds;
+                var adPlayer = this.host.getAdPlayer();
+                if (shouldShowPlaceholder && adPlayer) {
+                    if (this.debug) {
+                        console.log("[StormcloudVideoPlayer] Showing placeholder before destroying old AdController");
+                    }
+                    this.placeholder.show();
+                    adPlayer.showPlaceholder();
+                    this.isShowingPlaceholder = true;
+                }
+                var preservedMutedState = adPlayer.getOriginalMutedState();
+                var preservedVolumeState = adPlayer.getOriginalVolume();
+                if (adPlayer) {
+                    try {
+                        adPlayer.destroy();
+                        this.host.video.muted = true;
+                    } catch (error) {
+                        if (this.debug) {
+                            console.warn("[StormcloudVideoPlayer] Error destroying old AdController:", error);
+                        }
+                    }
+                }
+                var continueLiveStreamDuringAds = this.host.shouldContinueLiveStreamDuringAds();
+                var newAdPlayer = this.host.createAdPlayer(continueLiveStreamDuringAds);
+                this.host.setAdPlayer(newAdPlayer);
+                newAdPlayer.initialize();
+                newAdPlayer.updateOriginalMutedState(preservedMutedState, preservedVolumeState);
+                this.attachImaEventListeners();
+                if (shouldShowPlaceholder) {
+                    this.placeholder.show();
+                    newAdPlayer.showPlaceholder();
+                    this.isShowingPlaceholder = true;
+                }
+            }
+        },
+        {
+            key: "clearPendingAdBreak",
+            value: function clearPendingAdBreak() {
+                if (this.prefetchTimerId != null) {
+                    clearTimeout(this.prefetchTimerId);
+                    this.prefetchTimerId = void 0;
+                }
+                this.pendingAdBreak = null;
+                this.cueManager.pendingScte35CueKey = void 0;
+                this.vmap.podAssignedByPrefetch = false;
+            }
+        },
+        {
+            key: "handleAdStart",
+            value: // ───────────────────────────────────────────────────────────────
+            //  Ad break start
+            // ───────────────────────────────────────────────────────────────
+            function handleAdStart(_marker) {
+                return _async_to_generator(function() {
+                    var scheduled, tags, baseVastUrl, adBreakDurationMs, mode, currentMuted, currentVolume, firstAdUrl, usePreloadedAd, preloadedController, preloaded, firstAdUrlArray, adPlayer, preservedMuted, preservedVolume, adVolume, adPlayer1, adVolume1, error, fallbackPreloaded, ap, adVolume2, fallbackError;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                scheduled = this.vmap.findCurrentOrNextBreak(this.host.video.currentTime * 1e3);
+                                if (scheduled) {
+                                    this.vmap.consumedVmapBreakIds.add(this.vmap.getAdBreakKey(scheduled));
+                                }
+                                tags = this.vmap.selectVastTagsForBreak(scheduled);
+                                if (tags && tags.length > 0 && tags[0]) {
+                                    baseVastUrl = tags[0];
+                                } else if (this.vmap.apiVastTagUrl) {
+                                    baseVastUrl = this.vmap.apiVastTagUrl;
+                                } else {
+                                    this.clearPendingAdBreak();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                adBreakDurationMs = _marker.durationSeconds != null ? _marker.durationSeconds * 1e3 : scheduled === null || scheduled === void 0 ? void 0 : scheduled.durationMs;
+                                if (this.debug) {
+                                    mode = this.host.config.isLiveStream ? "LIVE" : "VOD";
+                                    console.log("[CONTINUOUS-FETCH] ".concat(mode, " MODE: Target duration=").concat(adBreakDurationMs, "ms"));
+                                }
+                                this.timing.failedVastUrls.clear();
+                                this.timing.temporaryFailureUrls.clear();
+                                this.timing.consecutiveFailures = 0;
+                                this.continuousFetchingActive = true;
+                                this.isShowingPlaceholder = false;
+                                this.timing.totalAdRequestsInBreak = 0;
+                                if (this.vmap.podAssignedByPrefetch) {
+                                    this.vmap.podAssignedByPrefetch = false;
+                                } else {
+                                    this.vmap.beginNewAdPod();
+                                }
+                                currentMuted = this.host.video.muted;
+                                currentVolume = this.host.video.volume;
+                                this.host.getAdPlayer().updateOriginalMutedState(currentMuted, currentVolume);
+                                this.inAdBreak = true;
+                                this.timing.adBreakPlayedDurationMs = 0;
+                                this.timing.currentAdIndex = 0;
+                                this.timing.totalAdsInBreak = 0;
+                                this.adPodQueue = [];
+                                this.showAds = false;
+                                if (this.timing.expectedAdBreakDurationMs == null && adBreakDurationMs != null) {
+                                    this.timing.expectedAdBreakDurationMs = adBreakDurationMs;
+                                }
+                                usePreloadedAd = false;
+                                preloaded = this.preloadPool.getPreloadedAd();
+                                if (preloaded) {
+                                    firstAdUrl = preloaded.vastUrl;
+                                    preloadedController = preloaded.adController;
+                                    usePreloadedAd = true;
+                                    sendAdLoadedTracking(this.host.config.licenseKey, {
+                                        source: "hls",
+                                        vastUrl: firstAdUrl,
+                                        timestamp: /* @__PURE__ */ new Date().toISOString()
+                                    }).catch(function() {});
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Using preloaded ad from pool (preloaded in advance, ready immediately!)");
+                                    }
+                                } else if (this.pendingAdBreak && this.pendingAdBreak.vastUrls.length > 0) {
+                                    this.adRequestQueue = _to_consumable_array(this.pendingAdBreak.vastUrls);
+                                    firstAdUrl = this.adRequestQueue.shift();
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Pool empty, using prefetched URLs (".concat(this.adRequestQueue.length + 1, " available)"));
+                                    }
+                                    this.clearPendingAdBreak();
+                                } else {
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Generating new ad URLs...");
+                                    }
+                                    firstAdUrlArray = this.host.generateVastUrls(baseVastUrl, 1);
+                                    firstAdUrl = firstAdUrlArray[0];
+                                    this.adRequestQueue = [];
+                                }
+                                if (!firstAdUrl) {
+                                    if (this.debug) {
+                                        console.warn("[CONTINUOUS-FETCH] Failed to get first ad URL");
+                                    }
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] First VAST URL:", firstAdUrl);
+                                }
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    12,
+                                    ,
+                                    20
+                                ]);
+                                if (!(usePreloadedAd && preloadedController)) return [
+                                    3,
+                                    5
+                                ];
+                                if (!!this.timing.ensureLoadedAdFitsBudget(preloadedController)) return [
+                                    3,
+                                    3
+                                ];
+                                this.timing.rejectLoadedAdForDuration(preloadedController);
+                                this.startContinuousFetching(baseVastUrl);
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 3:
+                                adPlayer = this.host.getAdPlayer();
+                                preservedMuted = adPlayer.getOriginalMutedState();
+                                preservedVolume = adPlayer.getOriginalVolume();
+                                adPlayer.destroy();
+                                this.host.video.muted = true;
+                                this.host.setAdPlayer(preloadedController);
+                                preloadedController.updateOriginalMutedState(preservedMuted, preservedVolume);
+                                this.attachImaEventListeners();
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Using preloaded ad, resuming and starting playback immediately (no request delay!)");
+                                }
+                                preloadedController.resume();
+                                this.timing.consecutiveFailures = 0;
+                                this.startContinuousFetching(baseVastUrl);
+                                if (!this.preloadPool.active) {
+                                    this.preloadPool.active = true;
+                                }
+                                if (!this.preloadPool.isLoopRunning) {
+                                    this.preloadPool.preloadPoolLoop(baseVastUrl);
+                                }
+                                return [
+                                    4,
+                                    preloadedController.play()
+                                ];
+                            case 4:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                adVolume = currentMuted ? 0 : currentVolume;
+                                preloadedController.setAdVolume(adVolume);
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 5:
+                                adPlayer1 = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    this.timing.enforceGlobalRateLimit()
+                                ];
+                            case 6:
+                                _state.sent();
+                                this.timing.lastAdRequestTime = Date.now();
+                                return [
+                                    4,
+                                    adPlayer1.requestAds(firstAdUrl)
+                                ];
+                            case 7:
+                                _state.sent();
+                                sendAdLoadedTracking(this.host.config.licenseKey, {
+                                    source: "hls",
+                                    vastUrl: firstAdUrl,
+                                    timestamp: /* @__PURE__ */ new Date().toISOString()
+                                }).catch(function() {});
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] First ad request successful, starting playback");
+                                }
+                                if (!!this.timing.ensureLoadedAdFitsBudget(adPlayer1)) return [
+                                    3,
+                                    9
+                                ];
+                                this.timing.rejectLoadedAdForDuration(adPlayer1);
+                                this.recreateAdController();
+                                this.startContinuousFetching(baseVastUrl);
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 8:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 9:
+                                this.timing.consecutiveFailures = 0;
+                                this.startContinuousFetching(baseVastUrl);
+                                if (!this.preloadPool.active) {
+                                    this.preloadPool.startPreloadPool(baseVastUrl, []);
+                                }
+                                return [
+                                    4,
+                                    adPlayer1.play()
+                                ];
+                            case 10:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                adVolume1 = currentMuted ? 0 : currentVolume;
+                                adPlayer1.setAdVolume(adVolume1);
+                                _state.label = 11;
+                            case 11:
+                                return [
+                                    3,
+                                    20
+                                ];
+                            case 12:
+                                error = _state.sent();
+                                if (this.debug) {
+                                    console.warn("[CONTINUOUS-FETCH] First ad request failed:", error);
+                                }
+                                if (!!usePreloadedAd) return [
+                                    3,
+                                    18
+                                ];
+                                fallbackPreloaded = this.preloadPool.getPreloadedAd();
+                                if (!fallbackPreloaded) return [
+                                    3,
+                                    18
+                                ];
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] First ad failed, using preloaded fallback");
+                                }
+                                _state.label = 13;
+                            case 13:
+                                _state.trys.push([
+                                    13,
+                                    17,
+                                    ,
+                                    18
+                                ]);
+                                if (!!this.timing.ensureLoadedAdFitsBudget(fallbackPreloaded.adController)) return [
+                                    3,
+                                    15
+                                ];
+                                this.timing.rejectLoadedAdForDuration(fallbackPreloaded.adController);
+                                this.startContinuousFetching(baseVastUrl);
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 14:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 15:
+                                this.swapToPreloadedAdPlayer(fallbackPreloaded.adController);
+                                this.timing.consecutiveFailures = 0;
+                                this.startContinuousFetching(baseVastUrl);
+                                if (!this.preloadPool.active) {
+                                    this.preloadPool.active = true;
+                                    this.preloadPool.preloadPoolLoop(baseVastUrl);
+                                }
+                                ap = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    ap.play()
+                                ];
+                            case 16:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                adVolume2 = currentMuted ? 0 : currentVolume;
+                                ap.setAdVolume(adVolume2);
+                                return [
+                                    2
+                                ];
+                            case 17:
+                                fallbackError = _state.sent();
+                                if (this.debug) {
+                                    console.warn("[CONTINUOUS-FETCH] Preloaded fallback also failed:", fallbackError);
+                                }
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 18:
+                                if (this.timing.isTemporaryAdError(error)) {
+                                    this.timing.temporaryFailureUrls.set(firstAdUrl, Date.now());
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] First ad had temporary error (no-fill) - will try alternatives");
+                                    }
+                                } else {
+                                    this.timing.failedVastUrls.add(firstAdUrl);
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] First ad had permanent error - URL blacklisted");
+                                    }
+                                }
+                                this.timing.consecutiveFailures++;
+                                this.startContinuousFetching(baseVastUrl);
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 19:
+                                _state.sent();
+                                return [
+                                    3,
+                                    20
+                                ];
+                            case 20:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "swapToPreloadedAdPlayer",
+            value: function swapToPreloadedAdPlayer(preloadedController) {
+                var adPlayer = this.host.getAdPlayer();
+                var preservedMuted = adPlayer.getOriginalMutedState();
+                var preservedVolume = adPlayer.getOriginalVolume();
+                adPlayer.destroy();
+                this.host.video.muted = true;
+                this.host.setAdPlayer(preloadedController);
+                this.attachImaEventListeners();
+                preloadedController.updateOriginalMutedState(preservedMuted, preservedVolume);
+                preloadedController.resume();
+            }
+        },
+        {
+            // ───────────────────────────────────────────────────────────────
+            //  Continuous fetching
+            // ───────────────────────────────────────────────────────────────
+            key: "startContinuousFetching",
+            value: function startContinuousFetching(baseVastUrl) {
+                if (!this.continuousFetchingActive) {
+                    return;
+                }
+                if (this.continuousFetchLoopRunning) {
+                    if (this.debug) {
+                        console.log("[CONTINUOUS-FETCH] Fetch loop already running, skipping duplicate start");
+                    }
+                    return;
+                }
+                if (this.debug) {
+                    console.log("[CONTINUOUS-FETCH] Starting continuous ad fetching loop");
+                }
+                this.continuousFetchLoopRunning = true;
+                this.continuousFetchLoop(baseVastUrl);
+            }
+        },
+        {
+            key: "continuousFetchLoop",
+            value: function continuousFetchLoop(baseVastUrl) {
+                return _async_to_generator(function() {
+                    var _this, _loop, epoch, _ret;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _loop = function() {
+                                    var remaining, maxQueueSize, newAdUrl, queuedUrlsPreview, generationDelay;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                remaining = Math.min(_this.timing.getWallClockRemainingAdMs(), _this.timing.getDurationBudgetRemainingMs());
+                                                if (remaining <= _this.timing.getMinRemainingMsToStartAd()) {
+                                                    if (_this.debug) {
+                                                        console.log("[CONTINUOUS-FETCH] Not enough ad break time left (wall=".concat(_this.timing.getWallClockRemainingAdMs(), "ms, budget=").concat(_this.timing.getDurationBudgetRemainingMs(), "ms), stopping URL generation"));
+                                                    }
+                                                    return [
+                                                        2,
+                                                        "break"
+                                                    ];
+                                                }
+                                                if (_this.timing.isGamInCooldown()) {
+                                                    if (_this.debug) {
+                                                        console.log("[CIRCUIT-BREAKER] GAM in cooldown, stopping URL generation");
+                                                    }
+                                                    return [
+                                                        2,
+                                                        "break"
+                                                    ];
+                                                }
+                                                if (_this.timing.consecutiveFailures >= _this.timing.maxConsecutiveFailures) {
+                                                    if (_this.debug) {
+                                                        console.log("[CONTINUOUS-FETCH] Too many consecutive failures (".concat(_this.timing.consecutiveFailures, "), stopping URL generation"));
+                                                    }
+                                                    return [
+                                                        2,
+                                                        "break"
+                                                    ];
+                                                }
+                                                if (_this.timing.totalAdRequestsInBreak >= _this.timing.maxTotalAdRequestsPerBreak) {
+                                                    if (_this.debug) {
+                                                        console.log("[CONTINUOUS-FETCH] Maximum ad requests reached (".concat(_this.timing.maxTotalAdRequestsPerBreak, "), stopping"));
+                                                    }
+                                                    return [
+                                                        2,
+                                                        "break"
+                                                    ];
+                                                }
+                                                maxQueueSize = 5;
+                                                if (!(_this.adRequestQueue.length >= maxQueueSize)) return [
+                                                    3,
+                                                    2
+                                                ];
+                                                if (_this.debug) {
+                                                    console.log("[CONTINUOUS-FETCH] URL queue full (".concat(_this.adRequestQueue.length, "), waiting..."));
+                                                }
+                                                return [
+                                                    4,
+                                                    new Promise(function(resolve) {
+                                                        return setTimeout(resolve, 1e3);
+                                                    })
+                                                ];
+                                            case 1:
+                                                _state.sent();
+                                                return [
+                                                    2,
+                                                    "continue"
+                                                ];
+                                            case 2:
+                                                newAdUrl = _this.host.generateVastUrls(baseVastUrl, 1)[0];
+                                                if (!(!newAdUrl || _this.timing.failedVastUrls.has(newAdUrl) || _this.timing.isUrlInCooldown(newAdUrl))) return [
+                                                    3,
+                                                    4
+                                                ];
+                                                return [
+                                                    4,
+                                                    new Promise(function(resolve) {
+                                                        return setTimeout(resolve, 500);
+                                                    })
+                                                ];
+                                            case 3:
+                                                _state.sent();
+                                                return [
+                                                    2,
+                                                    "continue"
+                                                ];
+                                            case 4:
+                                                if (_this.debug) {
+                                                    queuedUrlsPreview = _to_consumable_array(_this.adRequestQueue).concat([
+                                                        newAdUrl
+                                                    ]);
+                                                    console.log("[CONTINUOUS-FETCH] Queued VAST URL (queue size: ".concat(queuedUrlsPreview.length, ")"), {
+                                                        queuedUrls: queuedUrlsPreview
+                                                    });
+                                                }
+                                                _this.adRequestQueue.push(newAdUrl);
+                                                generationDelay = _this.timing.consecutiveFailures > 0 ? Math.min(1e3 * Math.pow(2, _this.timing.consecutiveFailures), 5e3) : 500;
+                                                return [
+                                                    4,
+                                                    new Promise(function(resolve) {
+                                                        return setTimeout(resolve, generationDelay);
+                                                    })
+                                                ];
+                                            case 5:
+                                                _state.sent();
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                };
+                                epoch = this.timing.adBreakEpoch;
+                                _state.label = 1;
+                            case 1:
+                                if (!(this.continuousFetchingActive && this.inAdBreak && epoch === this.timing.adBreakEpoch)) return [
+                                    3,
+                                    3
+                                ];
+                                _this = this;
+                                return [
+                                    5,
+                                    _ts_values(_loop())
+                                ];
+                            case 2:
+                                _ret = _state.sent();
+                                if (_ret === "break") return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 3:
+                                this.continuousFetchLoopRunning = false;
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] URL generation loop ended (queued: ".concat(this.adRequestQueue.length, ")"), this.adRequestQueue.length > 0 ? {
+                                        queuedUrls: _to_consumable_array(this.adRequestQueue)
+                                    } : {});
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "stopContinuousFetching",
+            value: function stopContinuousFetching() {
+                this.continuousFetchingActive = false;
+                this.continuousFetchLoopRunning = false;
+                this.placeholder.hide();
+                if (this.debug) {
+                    console.log("[CONTINUOUS-FETCH] Stopping continuous ad fetching");
+                }
+            }
+        },
+        {
+            key: "tryNextAvailableAdWithRateLimit",
+            value: // ───────────────────────────────────────────────────────────────
+            //  Ad iteration
+            // ───────────────────────────────────────────────────────────────
+            function tryNextAvailableAdWithRateLimit() {
+                return _async_to_generator(function() {
+                    var epoch, backoffMultiplier, backoffDelay, effectiveMinInterval, timeSinceLastRequest, waitTime;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!this.inAdBreak) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                epoch = this.timing.adBreakEpoch;
+                                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Too many consecutive failures (".concat(this.timing.consecutiveFailures, "), ending ad break gracefully"));
+                                    }
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                backoffMultiplier = Math.pow(2, this.timing.consecutiveFailures);
+                                backoffDelay = Math.min(this.timing.backoffBaseMs * backoffMultiplier, this.timing.maxBackoffMs);
+                                effectiveMinInterval = this.timing.minAdRequestIntervalMs + (this.timing.consecutiveFailures > 0 ? backoffDelay : 0);
+                                timeSinceLastRequest = Date.now() - this.timing.lastAdRequestTime;
+                                if (!(timeSinceLastRequest < effectiveMinInterval)) return [
+                                    3,
+                                    2
+                                ];
+                                waitTime = effectiveMinInterval - timeSinceLastRequest;
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Rate limiting: waiting ".concat(waitTime, "ms before next request (backoff: ").concat(this.timing.consecutiveFailures, " failures)"));
+                                }
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, waitTime);
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                if (!this.inAdBreak || epoch !== this.timing.adBreakEpoch) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    this.tryNextAvailableAd(0)
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "tryNextAvailableAd",
+            value: function tryNextAvailableAd() {
+                var retryCount = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
+                return _async_to_generator(function() {
+                    var remaining, preloaded, ap, error, nextAdUrl, error1, errorMessage, maxRetries;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!this.inAdBreak) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                remaining = this.timing.getRemainingAdMs();
+                                if (!this.timing.hasTimeToStartAnotherAd()) {
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Not enough time remaining (".concat(remaining, "ms) to start another ad, ending ad break"));
+                                    }
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (this.timing.isGamInCooldown()) {
+                                    if (this.debug) {
+                                        console.log("[CIRCUIT-BREAKER] GAM in cooldown, ending ad break gracefully");
+                                    }
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                                    if (this.debug) {
+                                        console.log("[CONTINUOUS-FETCH] Too many consecutive failures (".concat(this.timing.consecutiveFailures, "), ending ad break"));
+                                    }
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                this.timing.cleanupTemporaryFailures();
+                                preloaded = this.preloadPool.getPreloadedAd();
+                                if (!preloaded) return [
+                                    3,
+                                    6
+                                ];
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Using preloaded ad from pool");
+                                }
+                                sendAdLoadedTracking(this.host.config.licenseKey, {
+                                    source: "hls",
+                                    vastUrl: preloaded.vastUrl,
+                                    timestamp: /* @__PURE__ */ new Date().toISOString()
+                                }).catch(function() {});
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    5,
+                                    ,
+                                    6
+                                ]);
+                                if (!!this.timing.ensureLoadedAdFitsBudget(preloaded.adController)) return [
+                                    3,
+                                    3
+                                ];
+                                this.timing.rejectLoadedAdForDuration(preloaded.adController);
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 3:
+                                this.swapToPreloadedAdPlayer(preloaded.adController);
+                                ap = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    ap.play()
+                                ];
+                            case 4:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                ap.setAdVolume(getAdAudioVolume(ap));
+                                this.timing.consecutiveFailures = 0;
+                                return [
+                                    2
+                                ];
+                            case 5:
+                                error = _state.sent();
+                                if (this.debug) {
+                                    console.warn("[CONTINUOUS-FETCH] Preloaded ad failed to play:", error);
+                                }
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 6:
+                                if (!(this.adRequestQueue.length > 0)) return [
+                                    3,
+                                    14
+                                ];
+                                nextAdUrl = this.adRequestQueue.shift();
+                                if (!nextAdUrl) return [
+                                    3,
+                                    6
+                                ];
+                                if (this.timing.failedVastUrls.has(nextAdUrl)) {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] Skipping permanently-failed URL, trying next...");
+                                    return [
+                                        3,
+                                        6
+                                    ];
+                                }
+                                if (this.timing.isUrlInCooldown(nextAdUrl)) {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] Skipping URL in cooldown (recent no-fill), trying next...");
+                                    return [
+                                        3,
+                                        6
+                                    ];
+                                }
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Requesting next ad via HLS ad player (".concat(this.timing.currentAdIndex + 1, ", ").concat(this.adRequestQueue.length, " remaining in queue)"));
+                                }
+                                _state.label = 7;
+                            case 7:
+                                _state.trys.push([
+                                    7,
+                                    9,
+                                    ,
+                                    13
+                                ]);
+                                return [
+                                    4,
+                                    this.playSingleAd(nextAdUrl)
+                                ];
+                            case 8:
+                                _state.sent();
+                                this.timing.consecutiveFailures = 0;
+                                return [
+                                    3,
+                                    13
+                                ];
+                            case 9:
+                                error1 = _state.sent();
+                                errorMessage = error1.message;
+                                if (this.debug) console.log("[CONTINUOUS-FETCH] Ad request failed:", errorMessage);
+                                if (!errorMessage.includes("ad_duration_exceeds_budget")) return [
+                                    3,
+                                    11
+                                ];
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 10:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 11:
+                                if (!errorMessage.includes("permanently failed") && !errorMessage.includes("in cooldown")) {
+                                    this.timing.consecutiveFailures++;
+                                }
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 12:
+                                _state.sent();
+                                return [
+                                    3,
+                                    13
+                                ];
+                            case 13:
+                                return [
+                                    2
+                                ];
+                            case 14:
+                                maxRetries = 3;
+                                if (!(this.continuousFetchingActive && retryCount < maxRetries && remaining > 2e3)) return [
+                                    3,
+                                    17
+                                ];
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Queue empty, waiting for URLs... (".concat(retryCount + 1, "/").concat(maxRetries, ")"));
+                                }
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, 500);
+                                    })
+                                ];
+                            case 15:
+                                _state.sent();
+                                return [
+                                    4,
+                                    this.tryNextAvailableAd(retryCount + 1)
+                                ];
+                            case 16:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 17:
+                                if (!this.isShowingPlaceholder && remaining > 1e3) {
+                                    this.showPlaceholderAndWaitForAds();
+                                } else {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] No more ads available, ending ad break");
+                                    this.handleAdPodComplete();
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "playSingleAd",
+            value: // ───────────────────────────────────────────────────────────────
+            //  Single ad playback
+            // ───────────────────────────────────────────────────────────────
+            function playSingleAd(vastTagUrl) {
+                return _async_to_generator(function() {
+                    var adPlayer, requestToken, ap, playError, preloadedFallback, fbAp, fallbackError, error, errorMessage, preloadedFallback1, fbAp1, fallbackError1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                adPlayer = this.host.getAdPlayer();
+                                if (adPlayer.isAdPlaying()) return [
+                                    2
+                                ];
+                                if (this.timing.failedVastUrls.has(vastTagUrl)) {
+                                    if (this.debug) console.warn("[AD-ERROR] Skipping permanently-failed VAST URL:", vastTagUrl);
+                                    throw new Error("VAST URL permanently failed");
+                                }
+                                if (this.timing.isUrlInCooldown(vastTagUrl)) {
+                                    if (this.debug) console.warn("[AD-ERROR] Skipping URL in cooldown (recent no-fill):", vastTagUrl);
+                                    throw new Error("VAST URL in cooldown after no-fill");
+                                }
+                                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                                    if (this.debug) console.warn("[AD-ERROR] Too many consecutive failures, not requesting more ads");
+                                    throw new Error("Too many consecutive failures");
+                                }
+                                if (this.timing.isGamInCooldown()) {
+                                    if (this.debug) console.warn("[CIRCUIT-BREAKER] GAM in cooldown, skipping ad request");
+                                    throw new Error("GAM in cooldown");
+                                }
+                                this.recreateAdController();
+                                requestToken = ++this.timing.adRequestTokenCounter;
+                                this.timing.activeAdRequestToken = requestToken;
+                                this.timing.startAdRequestWatchdog(requestToken);
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    12,
+                                    ,
+                                    17
+                                ]);
+                                return [
+                                    4,
+                                    this.timing.enforceGlobalRateLimit()
+                                ];
+                            case 2:
+                                _state.sent();
+                                this.timing.lastAdRequestTime = Date.now();
+                                ap = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    ap.requestAds(vastTagUrl)
+                                ];
+                            case 3:
+                                _state.sent();
+                                sendAdLoadedTracking(this.host.config.licenseKey, {
+                                    source: "hls",
+                                    vastUrl: vastTagUrl,
+                                    timestamp: /* @__PURE__ */ new Date().toISOString()
+                                }).catch(function() {});
+                                this.timing.clearAdRequestWatchdog();
+                                if (this.timing.activeAdRequestToken !== requestToken) return [
+                                    2
+                                ];
+                                if (!this.timing.ensureLoadedAdFitsBudget(ap)) {
+                                    this.timing.rejectLoadedAdForDuration(ap);
+                                    this.recreateAdController();
+                                    throw new Error("ad_duration_exceeds_budget");
+                                }
+                                _state.label = 4;
+                            case 4:
+                                _state.trys.push([
+                                    4,
+                                    6,
+                                    ,
+                                    11
+                                ]);
+                                this.timing.startAdFailsafeTimer(requestToken);
+                                return [
+                                    4,
+                                    ap.play()
+                                ];
+                            case 5:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                ap.setAdVolume(getAdAudioVolume(ap));
+                                this.timing.consecutiveFailures = 0;
+                                this.timing.temporaryFailureUrls.delete(vastTagUrl);
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 6:
+                                playError = _state.sent();
+                                if (this.debug) console.error("[AD-ERROR] Failed to play ad:", playError);
+                                preloadedFallback = this.preloadPool.getPreloadedAd();
+                                if (!preloadedFallback) return [
+                                    3,
+                                    10
+                                ];
+                                if (this.debug) console.log("[AD-ERROR] Play failed, trying preloaded fallback ad");
+                                _state.label = 7;
+                            case 7:
+                                _state.trys.push([
+                                    7,
+                                    9,
+                                    ,
+                                    10
+                                ]);
+                                if (!this.timing.ensureLoadedAdFitsBudget(preloadedFallback.adController)) {
+                                    this.timing.rejectLoadedAdForDuration(preloadedFallback.adController);
+                                    throw playError;
+                                }
+                                this.timing.clearAdFailsafeTimer();
+                                this.swapToPreloadedAdPlayer(preloadedFallback.adController);
+                                this.timing.consecutiveFailures = 0;
+                                fbAp = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    fbAp.play()
+                                ];
+                            case 8:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                fbAp.setAdVolume(getAdAudioVolume(fbAp));
+                                return [
+                                    2
+                                ];
+                            case 9:
+                                fallbackError = _state.sent();
+                                if (this.debug) console.warn("[AD-ERROR] Preloaded fallback also failed:", fallbackError);
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case 10:
+                                if (this.timing.isTemporaryAdError(playError)) {
+                                    this.timing.temporaryFailureUrls.set(vastTagUrl, Date.now());
+                                    if (this.debug) console.log("[AD-ERROR] Temporary play error - URL can be retried after cooldown");
+                                } else {
+                                    this.timing.failedVastUrls.add(vastTagUrl);
+                                    if (this.debug) console.log("[AD-ERROR] Permanent play error - URL blacklisted");
+                                }
+                                this.timing.clearAdFailsafeTimer();
+                                if (this.timing.activeAdRequestToken === requestToken) {
+                                    this.timing.activeAdRequestToken = null;
+                                }
+                                throw playError;
+                            case 11:
+                                return [
+                                    3,
+                                    17
+                                ];
+                            case 12:
+                                error = _state.sent();
+                                errorMessage = (error === null || error === void 0 ? void 0 : error.message) || "";
+                                if (this.debug) console.error("[AD-ERROR] Ad request failed:", errorMessage);
+                                preloadedFallback1 = this.preloadPool.getPreloadedAd();
+                                if (!preloadedFallback1) return [
+                                    3,
+                                    16
+                                ];
+                                if (this.debug) console.log("[AD-ERROR] Request failed, trying preloaded fallback ad");
+                                _state.label = 13;
+                            case 13:
+                                _state.trys.push([
+                                    13,
+                                    15,
+                                    ,
+                                    16
+                                ]);
+                                if (!this.timing.ensureLoadedAdFitsBudget(preloadedFallback1.adController)) {
+                                    this.timing.rejectLoadedAdForDuration(preloadedFallback1.adController);
+                                    throw error;
+                                }
+                                this.timing.clearAdRequestWatchdog();
+                                this.timing.clearAdFailsafeTimer();
+                                this.swapToPreloadedAdPlayer(preloadedFallback1.adController);
+                                this.timing.consecutiveFailures = 0;
+                                fbAp1 = this.host.getAdPlayer();
+                                return [
+                                    4,
+                                    fbAp1.play()
+                                ];
+                            case 14:
+                                _state.sent();
+                                this.timing.markAdStarted();
+                                fbAp1.setAdVolume(getAdAudioVolume(fbAp1));
+                                return [
+                                    2
+                                ];
+                            case 15:
+                                fallbackError1 = _state.sent();
+                                if (this.debug) console.warn("[AD-ERROR] Preloaded fallback also failed:", fallbackError1);
+                                return [
+                                    3,
+                                    16
+                                ];
+                            case 16:
+                                if (this.timing.isTemporaryAdError(error)) {
+                                    this.timing.temporaryFailureUrls.set(vastTagUrl, Date.now());
+                                    if (this.debug) console.log("[AD-ERROR] Temporary error (no-fill/timeout) - URL can be retried after cooldown");
+                                } else {
+                                    this.timing.failedVastUrls.add(vastTagUrl);
+                                    if (this.debug) console.log("[AD-ERROR] Permanent error - URL blacklisted:", errorMessage);
+                                }
+                                this.timing.clearAdRequestWatchdog();
+                                this.timing.clearAdFailsafeTimer();
+                                if (this.timing.activeAdRequestToken === requestToken) {
+                                    this.timing.activeAdRequestToken = null;
+                                }
+                                throw error;
+                            case 17:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "showPlaceholderAndWaitForAds",
+            value: // ───────────────────────────────────────────────────────────────
+            //  Placeholder wait
+            // ───────────────────────────────────────────────────────────────
+            function showPlaceholderAndWaitForAds() {
+                return _async_to_generator(function() {
+                    var remaining, waitTime, checkInterval, maxChecks, i, nextAdUrl, error, errorMessage;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                remaining = this.timing.getRemainingAdMs();
+                                waitTime = Math.min(this.maxPlaceholderDurationMs, remaining);
+                                if (this.timing.isGamInCooldown()) {
+                                    if (this.debug) console.log("[CIRCUIT-BREAKER] GAM in cooldown, skipping placeholder wait");
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] Skipping placeholder - too many consecutive failures");
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (waitTime < 1e3) {
+                                    this.handleAdPodComplete();
+                                    return [
+                                        2
+                                    ];
+                                }
+                                if (this.debug) {
+                                    console.log("[CONTINUOUS-FETCH] Showing placeholder for ".concat(waitTime, "ms while waiting for ad URLs"));
+                                }
+                                this.isShowingPlaceholder = true;
+                                this.host.getAdPlayer().showPlaceholder();
+                                checkInterval = 300;
+                                maxChecks = Math.floor(waitTime / checkInterval);
+                                i = 0;
+                                _state.label = 1;
+                            case 1:
+                                if (!(i < maxChecks)) return [
+                                    3,
+                                    12
+                                ];
+                                return [
+                                    4,
+                                    new Promise(function(resolve) {
+                                        return setTimeout(resolve, checkInterval);
+                                    })
+                                ];
+                            case 2:
+                                _state.sent();
+                                if (!this.inAdBreak) return [
+                                    2
+                                ];
+                                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] Too many failures during placeholder wait");
+                                    return [
+                                        3,
+                                        12
+                                    ];
+                                }
+                                if (!this.timing.hasTimeToStartAnotherAd()) {
+                                    if (this.debug) console.log("[CONTINUOUS-FETCH] Not enough time remaining during placeholder wait, ending ad break");
+                                    return [
+                                        3,
+                                        12
+                                    ];
+                                }
+                                _state.label = 3;
+                            case 3:
+                                if (!(this.adRequestQueue.length > 0)) return [
+                                    3,
+                                    11
+                                ];
+                                if (!this.timing.hasTimeToStartAnotherAd()) return [
+                                    3,
+                                    11
+                                ];
+                                nextAdUrl = this.adRequestQueue.shift();
+                                if (!nextAdUrl) return [
+                                    3,
+                                    3
+                                ];
+                                if (this.timing.failedVastUrls.has(nextAdUrl)) return [
+                                    3,
+                                    3
+                                ];
+                                if (this.timing.isUrlInCooldown(nextAdUrl)) return [
+                                    3,
+                                    3
+                                ];
+                                if (this.debug) console.log("[CONTINUOUS-FETCH] Ad URL available, requesting via HLS ad player");
+                                this.isShowingPlaceholder = false;
+                                this.host.getAdPlayer().hidePlaceholder();
+                                _state.label = 4;
+                            case 4:
+                                _state.trys.push([
+                                    4,
+                                    6,
+                                    ,
+                                    10
+                                ]);
+                                return [
+                                    4,
+                                    this.playSingleAd(nextAdUrl)
+                                ];
+                            case 5:
+                                _state.sent();
+                                this.timing.consecutiveFailures = 0;
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case 6:
+                                error = _state.sent();
+                                errorMessage = error.message;
+                                if (!errorMessage.includes("ad_duration_exceeds_budget")) return [
+                                    3,
+                                    8
+                                ];
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 7:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 8:
+                                if (!errorMessage.includes("permanently failed") && !errorMessage.includes("in cooldown")) {
+                                    this.timing.consecutiveFailures++;
+                                }
+                                return [
+                                    4,
+                                    this.tryNextAvailableAdWithRateLimit()
+                                ];
+                            case 9:
+                                _state.sent();
+                                return [
+                                    3,
+                                    10
+                                ];
+                            case 10:
+                                return [
+                                    2
+                                ];
+                            case 11:
+                                i++;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 12:
+                                if (this.debug) console.log("[CONTINUOUS-FETCH] Placeholder timeout, ending ad break");
+                                this.isShowingPlaceholder = false;
+                                this.host.getAdPlayer().hidePlaceholder();
+                                this.handleAdPodComplete();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            // ───────────────────────────────────────────────────────────────
+            //  Ad break completion
+            // ───────────────────────────────────────────────────────────────
+            key: "handleAdPodComplete",
+            value: function handleAdPodComplete() {
+                if (this.debug) {
+                    console.log("[StormcloudVideoPlayer] Ad pod complete - cleaning up");
+                }
+                this.timing.resetForBreakEnd();
+                this.stopContinuousFetching();
+                this.preloadPool.stop();
+                this.clearPendingAdBreak();
+                if (this.isShowingPlaceholder) {
+                    this.host.getAdPlayer().hidePlaceholder();
+                    this.isShowingPlaceholder = false;
+                }
+                this.adRequestQueue = [];
+                this.inAdBreak = false;
+                this.adDetectSentForCurrentBreak = false;
+                this.cueManager.activeScte35BreakKey = void 0;
+                this.cueManager.scheduledScte35BreakKey = void 0;
+                this.adPodQueue = [];
+                this.showAds = false;
+                this.host.getAdPlayer().stop().catch(function() {});
+                var restoredMuted = this.host.getAdPlayer().getOriginalMutedState();
+                var restoredVolume = this.host.getAdPlayer().getOriginalVolume();
+                if (this.host.video.muted !== restoredMuted) {
+                    this.host.video.muted = restoredMuted;
+                }
+                if (Math.abs(this.host.video.volume - restoredVolume) > 0.01) {
+                    this.host.video.volume = restoredVolume;
+                }
+                if (this.host.shouldContinueLiveStreamDuringAds()) {
+                    if (this.host.video.paused) {
+                        var _this_host_video_play;
+                        if (this.debug) console.log("[StormcloudVideoPlayer] Content video paused in live mode after ads, resuming playback");
+                        (_this_host_video_play = this.host.video.play()) === null || _this_host_video_play === void 0 ? void 0 : _this_host_video_play.catch(function() {});
+                    } else {
+                        if (this.debug) console.log("[StormcloudVideoPlayer] Content video already playing in live mode after ads");
+                    }
+                } else if (this.host.video.paused) {
+                    var _this_host_video_play1;
+                    (_this_host_video_play1 = this.host.video.play()) === null || _this_host_video_play1 === void 0 ? void 0 : _this_host_video_play1.catch(function() {});
+                }
+            }
+        },
+        {
+            key: "handleAdFailure",
+            value: function handleAdFailure() {
+                this.timing.consecutiveFailures++;
+                this.timing.recordGamNoFill();
+                var remaining = this.timing.getRemainingAdMs();
+                if (this.debug) {
+                    console.log("[CONTINUOUS-FETCH] Ad failure: remaining=".concat(remaining, "ms, queued ads=").concat(this.adRequestQueue.length, ", consecutiveFailures=").concat(this.timing.consecutiveFailures), this.adRequestQueue.length > 0 ? {
+                        queuedUrls: _to_consumable_array(this.adRequestQueue)
+                    } : {});
+                }
+                if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
+                    if (this.debug) console.log("[CONTINUOUS-FETCH] Max consecutive failures reached (".concat(this.timing.consecutiveFailures, "), ending ad break gracefully"));
+                    this.handleAdPodComplete();
+                    return;
+                }
+                if (this.timing.hasTimeToStartAnotherAd()) {
+                    this.tryNextAvailableAdWithRateLimit();
+                } else {
+                    if (this.debug) console.log("[AD-ERROR] Ad failed and not enough time remaining for another ad. Failed URLs:", this.timing.failedVastUrls.size);
+                    this.handleAdPodComplete();
+                }
+            }
+        }
+    ]);
+    return AdBreakOrchestrator;
+}();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    AdBreakOrchestrator: AdBreakOrchestrator
+});
+//# sourceMappingURL=AdBreakOrchestrator.cjs.map