stormcloud-video-player 0.8.69 → 0.8.70

package/lib/players/index.cjs

@@ -2565,7 +2565,7 @@ function createHlsAdPlayer(contentVideo, options) {
                     img.onload = null;
                     img.onerror = null;
                     inFlightBeacons.delete(img);
-                    console.log("[HlsAdPlayer] Tracking pixel settled (".concat(outcome, "): ").concat(trackingUrl));
+                    console.log("[HlsAdPlayer] Tracking pixel settled (".concat(outcome, "): ").concat(trackingHost));
                     if (outcome !== "load") {
                         logFunnel("tracking_request_settled", {
                             reason: outcome,
@@ -2583,7 +2583,7 @@ function createHlsAdPlayer(contentVideo, options) {
                     return release("timeout");
                 }, BEACON_TIMEOUT_MS);
                 img.src = trackingUrl;
-                console.log("[HlsAdPlayer] Fired tracking pixel: ".concat(trackingUrl));
+                console.log("[HlsAdPlayer] Fired tracking pixel: ".concat(trackingHost));
                 logFunnel("tracking_request_created", {
                     trackingHost: trackingHost,
                     errorCode: options2 === null || options2 === void 0 ? void 0 : options2.errorCode
@@ -3037,7 +3037,7 @@ function createHlsAdPlayer(contentVideo, options) {
                         });
                     }
                     if (parsed.type === "wrapper") {
-                        console.log("[HlsAdPlayer] VAST wrapper detected, following VASTAdTagURI: ".concat(parsed.vastAdTagUri));
+                        console.log("[HlsAdPlayer] VAST wrapper detected, following VASTAdTagURI: ".concat(redactUrl(parsed.vastAdTagUri)));
                     }
                     return parsed;
                 }
@@ -3229,8 +3229,8 @@ function createHlsAdPlayer(contentVideo, options) {
                                     switch(_state.label){
                                         case 0:
                                             attempt++;
-                                            if (kind === "gam") {
-                                                logFunnel("gam_http_request_sent", {
+                                            if (kind !== "wrapper") {
+                                                logFunnel("".concat(kind, "_http_request_sent"), {
                                                     attempt: attempt,
                                                     credentials: creds
                                                 });
@@ -3250,8 +3250,8 @@ function createHlsAdPlayer(contentVideo, options) {
                                             ];
                                         case 1:
                                             response = _state.sent();
-                                            if (kind === "gam") {
-                                                logFunnel("gam_response_received", {
+                                            if (kind !== "wrapper") {
+                                                logFunnel("".concat(kind, "_response_received"), {
                                                     attempt: attempt,
                                                     httpStatus: response.status,
                                                     ok: response.ok,
@@ -3421,8 +3421,7 @@ function createHlsAdPlayer(contentVideo, options) {
                                 elapsedMs: Date.now() - fetchStartedAt
                             });
                         }
-                        console.log("[HlsAdPlayer] VAST XML received");
-                        console.log("[HlsAdPlayer] VAST XML content (first 2000 chars):", vastXml.substring(0, 2e3));
+                        console.log("[HlsAdPlayer] VAST XML received (length=".concat(vastXml.length, ")"));
                         parsed = parseVastXml(vastXml);
                         if (parsed.type === "empty") {
                             ;
@@ -3463,16 +3462,35 @@ function createHlsAdPlayer(contentVideo, options) {
             });
         }).apply(this, arguments);
     }
+    function isEdgeEmptySentinelAd(adElement) {
+        var _textOf;
+        if ((adElement.getAttribute("id") || "").trim().toLowerCase() === "empty") {
+            return true;
+        }
+        var inLine = adElement.querySelector(":scope > InLine");
+        if (!inLine) return false;
+        if (/^no ad available$/i.test((_textOf = textOf(inLine.querySelector(":scope > AdTitle"))) !== null && _textOf !== void 0 ? _textOf : "")) {
+            return true;
+        }
+        var durations = Array.from(inLine.querySelectorAll(":scope > Creatives > Creative > Linear > Duration")).map(function(el) {
+            return parseVastTime(textOf(el));
+        });
+        return durations.length > 0 && durations.every(function(seconds) {
+            return seconds === 0;
+        });
+    }
     function fetchAndParsePod(vastTagUrl) {
+        var source = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "gam";
         return _async_to_generator(function() {
-            var _root_getAttribute, _root_getAttribute1, vastXml, trimmedXml, xmlDoc, root, adElements, _root_getAttribute2, _empty_errorUrls, empty, _empty_errorCode, resolveAd, podElements, buffet, resolveAll, ads, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ad, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, ad1, err;
+            var _root_getAttribute, _root_getAttribute1, isEdge, vastXml, trimmedXml, xmlDoc, root, adElements, _root_getAttribute2, _empty_errorUrls, empty, _empty_errorCode, resolveAd, candidates, podElements, buffet, resolveAll, ads, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ad, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, ad1, err;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         lastPodAdElementCount = 0;
+                        isEdge = source === "edge";
                         return [
                             4,
-                            fetchVastXml(vastTagUrl)
+                            fetchVastXml(vastTagUrl, isEdge ? "omit" : "include", source)
                         ];
                     case 1:
                         vastXml = _state.sent();
@@ -3495,7 +3513,6 @@ function createHlsAdPlayer(contentVideo, options) {
                         }
                         xmlDoc = parseXml(vastXml);
                         if (!xmlDoc) {
-                            console.error("[HlsAdPlayer] Pod VAST XML content (first 2000 chars):", vastXml.substring(0, 2e3));
                             logFunnel("vast_parsed", {
                                 adElementCount: 0,
                                 reason: "xml_parse_error"
@@ -3567,12 +3584,24 @@ function createHlsAdPlayer(contentVideo, options) {
                                 });
                             })();
                         };
-                        podElements = adElements.filter(function(el) {
+                        candidates = adElements;
+                        if (isEdge) {
+                            candidates = adElements.filter(function(el) {
+                                return !isEdgeEmptySentinelAd(el);
+                            });
+                            if (candidates.length < adElements.length) {
+                                logFunnel("edge_empty_sentinel", {
+                                    sentinelCount: adElements.length - candidates.length,
+                                    adElementCount: adElements.length
+                                });
+                            }
+                        }
+                        podElements = candidates.filter(function(el) {
                             return getAdSequence(el) !== void 0;
                         }).sort(function(a, b) {
                             return getAdSequence(a) - getAdSequence(b);
                         });
-                        buffet = adElements.filter(function(el) {
+                        buffet = candidates.filter(function(el) {
                             return getAdSequence(el) === void 0;
                         });
                         resolveAll = function resolveAll(elements) {
@@ -3729,7 +3758,9 @@ function createHlsAdPlayer(contentVideo, options) {
                         lastPodAdElementCount = adElements.length;
                         return [
                             2,
-                            ads
+                            isEdge ? ads.filter(function(ad) {
+                                return ad.duration > 0;
+                            }) : ads
                         ];
                 }
             });
@@ -4730,13 +4761,14 @@ function createHlsAdPlayer(contentVideo, options) {
             contentVideo[AD_CONTAINER_PROP] = adContainerEl;
             attachContainerHandlers();
         },
-        requestAds: function requestAds(vastTagUrl) {
+        requestAds: function requestAds(vastTagUrl, requestOptions) {
             return _async_to_generator(function() {
-                var ads, preloaded, error;
+                var _ref, source, ads, preloaded, error;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
-                            console.log("[HlsAdPlayer] Requesting ads:", vastTagUrl);
+                            source = (_ref = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.source) !== null && _ref !== void 0 ? _ref : "gam";
+                            console.log("[HlsAdPlayer] Requesting ads (".concat(source, "):"), redactUrl(vastTagUrl));
                             if (adPlaying) {
                                 console.warn("[HlsAdPlayer] Cannot request new ads while an ad is playing");
                                 return [
@@ -4781,7 +4813,7 @@ function createHlsAdPlayer(contentVideo, options) {
                         case 2:
                             return [
                                 4,
-                                fetchAndParsePod(vastTagUrl)
+                                fetchAndParsePod(vastTagUrl, source)
                             ];
                         case 3:
                             ads = _state.sent();
@@ -5191,6 +5223,75 @@ function createHlsAdPlayer(contentVideo, options) {
             return podAds.reduce(function(total, ad) {
                 return total + (ad.duration > 0 ? ad.duration * 1e3 : 0);
             }, 0);
+        },
+        limitPodToBudget: function limitPodToBudget(maxDurationMs, maxAds) {
+            if (adPlaying) return podAds.length;
+            var kept = [];
+            var dropped = [];
+            var totalMs = 0;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = podAds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var ad = _step.value;
+                    var durationMs = Math.round(ad.duration * 1e3);
+                    if (kept.length < maxAds && totalMs + durationMs <= maxDurationMs) {
+                        kept.push(ad);
+                        totalMs += durationMs;
+                    } else {
+                        dropped.push(ad);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            if (dropped.length > 0) {
+                logFunnel("pod_trimmed_to_budget", {
+                    keptCount: kept.length,
+                    droppedCount: dropped.length,
+                    keptDurationMs: totalMs,
+                    maxDurationMs: maxDurationMs,
+                    maxAds: maxAds
+                });
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = dropped[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var ad1 = _step1.value;
+                        resolvedAds.add(ad1);
+                        fireTrackingPixels(ad1.trackingUrls.notUsed, {
+                            ad: ad1
+                        });
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+            podAds = kept;
+            podIndex = 0;
+            currentAd = kept[0];
+            currentAdMediaFile = void 0;
+            return kept.length;
         }
     };
 }
@@ -9189,6 +9290,59 @@ var HlsEngine = /*#__PURE__*/ function() {
     ]);
     return HlsEngine;
 }();
+// src/player/EdgePodRequest.ts
+var EDGE_POD_MAX_ADS = 10;
+var EDGE_POD_EXCEEDS_BUDGET = "edge_pod_exceeds_budget";
+function resolveEdgePodBaseUrl(config) {
+    var _config_edgePodUrl;
+    if (config.enableEdgePodRequest !== true) return void 0;
+    var raw = (_config_edgePodUrl = config.edgePodUrl) === null || _config_edgePodUrl === void 0 ? void 0 : _config_edgePodUrl.trim();
+    if (!raw) {
+        console.warn("[AdBreak][EDGE] enableEdgePodRequest is true but edgePodUrl is missing; using GAM only");
+        return void 0;
+    }
+    try {
+        var url = new URL(raw);
+        if (url.protocol !== "https:" && url.protocol !== "http:") {
+            throw new Error("unsupported protocol ".concat(url.protocol));
+        }
+        return url.toString();
+    } catch (unused) {
+        console.warn("[AdBreak][EDGE] edgePodUrl is not a valid http(s) URL; using GAM only");
+        return void 0;
+    }
+}
+function buildEdgePodUrl(baseUrl, remainingMs, remainingAdLimit) {
+    var url = new URL(baseUrl);
+    var maxMs = Math.max(0, Math.floor(remainingMs));
+    var maxAds = Math.max(1, Math.min(EDGE_POD_MAX_ADS, Math.floor(remainingAdLimit)));
+    url.searchParams.set("pmxd", String(maxMs));
+    url.searchParams.set("pmad", String(maxAds));
+    url.searchParams.set("duration", String(Math.floor(maxMs / 1e3)));
+    url.searchParams.set("count", String(maxAds));
+    return url.toString();
+}
+function classifyEdgeVastResponse(result) {
+    var _ref;
+    var _result_error;
+    if (result.error == null) {
+        return result.podAdCount > 0 ? "fill" : "no_fill";
+    }
+    var message = (_ref = (_result_error = result.error) === null || _result_error === void 0 ? void 0 : _result_error.message) !== null && _ref !== void 0 ? _ref : String(result.error);
+    if (/no ads available|fill rejected|no media file|no ad loaded/i.test(message) || message.includes(EDGE_POD_EXCEEDS_BUDGET)) {
+        return "no_fill";
+    }
+    return "invalid";
+}
+function describeEdgeUrl(url) {
+    try {
+        var parsed = new URL(url);
+        return "".concat(parsed.origin).concat(parsed.pathname);
+    } catch (unused) {
+        var _url_split_;
+        return (_url_split_ = url.split("?")[0]) !== null && _url_split_ !== void 0 ? _url_split_ : "";
+    }
+}
 // src/player/PlayerControls.ts
 function getAdAudioVolume(adPlayer) {
     return adPlayer.getOriginalMutedState() ? 0 : adPlayer.getOriginalVolume();
@@ -9347,6 +9501,8 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
         this.controllerCallInFlight = false;
         this.playbackStartedForCurrentRequest = false;
         this.opportunityEpoch = -1;
+        this.edgeExhaustedForBreak = false;
+        this.edgeRequestsInBreak = 0;
         this.adPodQueue = [];
         this.defaultMinRemainingMsToRequestAd = 1e4;
         this.defaultMaxNoFillsPerBreak = 2;
@@ -9497,7 +9653,9 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     _this.timing.clearAdRequestWatchdog();
                     _this.timing.activeAdRequestToken = null;
                     _this.showAds = true;
-                    _this.timing.resetGamNoFillCounter();
+                    if (_this.currentPodSource !== "edge") {
+                        _this.timing.resetGamNoFillCounter();
+                    }
                     if (_this.inAdBreak && _this.timing.expectedAdBreakDurationMs != null && _this.timing.getAdBreakEndWallClockMs() == null) {
                         _this.timing.scheduleAdStopAtBreakBoundary();
                         if (_this.debug) {
@@ -9629,6 +9787,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             key: "beginVmapBreak",
             value: function beginVmapBreak(breakKey, position) {
                 this.breakSource = "vmap";
+                this.resetEdgeStateForBreak();
                 this.followUpBaseVastUrl = void 0;
                 this.unusableResponsesInBreak = 0;
                 this.timing.totalAdRequestsInBreak = 0;
@@ -9640,7 +9799,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             key: "handleAdStart",
             value: function handleAdStart(marker) {
                 return _async_to_generator(function() {
-                    var baseVastUrl, adBreakDurationMs, currentMuted, currentVolume, epoch, hasPrefetchedUrl, mode, podPlayed;
+                    var baseVastUrl, edgeConfigured, adBreakDurationMs, currentMuted, currentVolume, epoch, hasPrefetchedUrl, mode, edgeUrl, outcome, podPlayed;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -9654,7 +9813,8 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                     ];
                                 }
                                 baseVastUrl = this.adConfig.apiVastTagUrl;
-                                if (!baseVastUrl) {
+                                edgeConfigured = !!this.host.getEdgePodBaseUrl();
+                                if (!baseVastUrl && !edgeConfigured) {
                                     console.warn("[AdBreak] SCTE-35 break started but no direct VAST tag is configured");
                                     this.clearPendingAdBreak();
                                     return [
@@ -9670,6 +9830,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 this.breakSource = "scte35";
                                 this.followUpBaseVastUrl = baseVastUrl;
                                 this.unusableResponsesInBreak = 0;
+                                this.resetEdgeStateForBreak();
                                 this.setSlotState("NEEDS_NEXT_AD", "scte35_break_start");
                                 if (this.adConfig.podAssignedByPrefetch) {
                                     this.adConfig.podAssignedByPrefetch = false;
@@ -9691,7 +9852,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 this.noteOpportunity("scte35", this.cueManager.activeScte35BreakKey, "midroll");
                                 epoch = this.timing.adBreakEpoch;
                                 hasPrefetchedUrl = !!(this.pendingAdBreak && this.pendingAdBreak.vastUrls.length > 0);
-                                if (!(adBreakDurationMs == null && !hasPrefetchedUrl)) return [
+                                if (!(adBreakDurationMs == null && (!hasPrefetchedUrl || edgeConfigured))) return [
                                     3,
                                     2
                                 ];
@@ -9710,11 +9871,46 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                     mode = this.host.config.isLiveStream ? "LIVE" : "VOD";
                                     console.log("[AdBreak] ".concat(mode, " break start: target duration=").concat(adBreakDurationMs != null ? "".concat(adBreakDurationMs, "ms") : "unknown"));
                                 }
+                                if (!edgeConfigured) return [
+                                    3,
+                                    5
+                                ];
+                                edgeUrl = this.canRequestEdge() ? this.prepareEdgePodRequest() : void 0;
+                                if (!edgeUrl) return [
+                                    3,
+                                    4
+                                ];
+                                this.clearPendingAdBreak();
                                 return [
                                     4,
-                                    this.startOptimizedPod(baseVastUrl, adBreakDurationMs)
+                                    this.runEdgePod(edgeUrl, "edge_break_start")
                                 ];
                             case 3:
+                                outcome = _state.sent();
+                                this.continueAfterEdgeOutcome(outcome, epoch);
+                                return [
+                                    2
+                                ];
+                            case 4:
+                                if (!this.edgeExhaustedForBreak) {
+                                    this.markEdgeExhausted("not_eligible_at_break_start", {
+                                        isLive: this.isLiveBreak(),
+                                        durationMs: this.timing.expectedAdBreakDurationMs
+                                    });
+                                }
+                                _state.label = 5;
+                            case 5:
+                                if (!baseVastUrl) {
+                                    this.requestNextAd("no_gam_source");
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    this.startOptimizedPod(baseVastUrl, adBreakDurationMs)
+                                ];
+                            case 6:
                                 podPlayed = _state.sent();
                                 if (!podPlayed && this.inAdBreak && epoch === this.timing.adBreakEpoch) {
                                     this.setSlotState("NEEDS_NEXT_AD", "initial_request_failed");
@@ -9806,6 +10002,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 adPlayer = this.host.getAdPlayer();
                                 requestToken = ++this.timing.adRequestTokenCounter;
                                 this.timing.activeAdRequestToken = requestToken;
+                                this.currentPodSource = "gam";
                                 this.setSlotState("REQUESTING", "initial_pod");
                                 this.beginFunnelRequest(adPlayer, requestToken, "initial_pod");
                                 requestUrl = this.applyOpportunityFloor(podUrl);
@@ -9922,6 +10119,224 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            // ───────────────────────────────────────────────────────────────
+            //  Edge-first pods (live SCTE-35 only, GAM fallback)
+            // ───────────────────────────────────────────────────────────────
+            key: "resetEdgeStateForBreak",
+            value: function resetEdgeStateForBreak() {
+                this.edgeExhaustedForBreak = false;
+                this.edgeRequestsInBreak = 0;
+                this.currentPodSource = void 0;
+            }
+        },
+        {
+            key: "isLiveBreak",
+            value: function isLiveBreak() {
+                return this.host.isLiveStream() || this.host.config.isLiveStream === true;
+            }
+        },
+        {
+            key: "canRequestEdge",
+            value: function canRequestEdge() {
+                return this.breakSource === "scte35" && !this.edgeExhaustedForBreak && !!this.host.getEdgePodBaseUrl() && this.isLiveBreak() && this.timing.expectedAdBreakDurationMs != null && this.edgeRequestsInBreak < this.timing.maxTotalAdRequestsPerBreak;
+            }
+        },
+        {
+            key: "markEdgeExhausted",
+            value: function markEdgeExhausted(reason) {
+                var extra = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                this.edgeExhaustedForBreak = true;
+                this.countFunnelStage("edge_fallback:".concat(reason));
+                this.logOrchestratorFunnel("edge_exhausted", _object_spread({
+                    reason: reason,
+                    edgeRequests: this.edgeRequestsInBreak,
+                    remainingMs: this.timing.getRemainingAdMs()
+                }, extra));
+            }
+        },
+        {
+            /**
+   * Builds the next Edge request from the budget left right now, or marks Edge
+   * exhausted for this break. Synchronous on purpose: callers must reach the
+   * REQUESTING state in the same tick so a second completion event cannot race
+   * in a parallel request.
+   */ key: "prepareEdgePodRequest",
+            value: function prepareEdgePodRequest() {
+                var baseUrl = this.host.getEdgePodBaseUrl();
+                if (!baseUrl) return void 0;
+                var remainingMs = this.timing.getRemainingAdMs();
+                var remainingAds = Math.min(EDGE_POD_MAX_ADS, this.adConfig.resolvePodParams().maxAds - this.timing.totalAdsInBreak);
+                if (remainingAds < 1) {
+                    this.markEdgeExhausted("ad_capacity_reached", {
+                        adsInBreak: this.timing.totalAdsInBreak
+                    });
+                    return void 0;
+                }
+                if (remainingMs < this.getMinRemainingMsToRequestAd()) {
+                    this.markEdgeExhausted("insufficient_break_time", {
+                        remainingMs: remainingMs
+                    });
+                    return void 0;
+                }
+                try {
+                    return buildEdgePodUrl(baseUrl, remainingMs, remainingAds);
+                } catch (unused) {
+                    this.markEdgeExhausted("invalid_edge_url");
+                    return void 0;
+                }
+            }
+        },
+        {
+            key: "runEdgePod",
+            value: function runEdgePod(requestUrl, trigger) {
+                return _async_to_generator(function() {
+                    var _params_get, _params_get1, epoch, generation, adPlayer, requestToken, params, _ref, _adPlayer_getPodAdCount, _adPlayer_getPodTotalDurationMs, remainingMs, remainingAds, podCount, error, errorMessage, classification, diag;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                epoch = this.timing.adBreakEpoch;
+                                this.recreateAdController("new_request");
+                                generation = this.controllerGeneration;
+                                adPlayer = this.host.getAdPlayer();
+                                requestToken = ++this.timing.adRequestTokenCounter;
+                                this.timing.activeAdRequestToken = requestToken;
+                                this.currentPodSource = "edge";
+                                this.edgeRequestsInBreak++;
+                                this.setSlotState("REQUESTING", trigger);
+                                this.beginFunnelRequest(adPlayer, requestToken, trigger, "edge");
+                                this.currentVastUrl = requestUrl;
+                                params = new URL(requestUrl).searchParams;
+                                this.logOrchestratorFunnel("edge_request_sent", {
+                                    trigger: trigger,
+                                    attempt: this.edgeRequestsInBreak,
+                                    endpoint: describeEdgeUrl(requestUrl),
+                                    pmxd: (_params_get = params.get("pmxd")) !== null && _params_get !== void 0 ? _params_get : void 0,
+                                    pmad: (_params_get1 = params.get("pmad")) !== null && _params_get1 !== void 0 ? _params_get1 : void 0
+                                });
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                this.timing.startAdRequestWatchdog(requestToken);
+                                return [
+                                    4,
+                                    this.callController(function() {
+                                        return adPlayer.requestAds(requestUrl, {
+                                            source: "edge"
+                                        });
+                                    })
+                                ];
+                            case 2:
+                                _state.sent();
+                                this.timing.clearAdRequestWatchdog();
+                                if (this.isStale(epoch, generation)) {
+                                    this.logOrchestratorFunnel("stale_request_result_ignored", {
+                                        requestId: requestToken,
+                                        source: "edge"
+                                    });
+                                    return [
+                                        2,
+                                        "stale"
+                                    ];
+                                }
+                                remainingMs = this.timing.getRemainingAdMs();
+                                remainingAds = Math.max(1, Math.min(EDGE_POD_MAX_ADS, this.adConfig.resolvePodParams().maxAds - this.timing.totalAdsInBreak));
+                                podCount = adPlayer.limitPodToBudget ? adPlayer.limitPodToBudget(remainingMs, remainingAds) : (_ref = (_adPlayer_getPodAdCount = adPlayer.getPodAdCount) === null || _adPlayer_getPodAdCount === void 0 ? void 0 : _adPlayer_getPodAdCount.call(adPlayer)) !== null && _ref !== void 0 ? _ref : 0;
+                                if (classifyEdgeVastResponse({
+                                    podAdCount: podCount
+                                }) !== "fill") {
+                                    throw new Error("".concat(EDGE_POD_EXCEEDS_BUDGET, ": no Edge ad fits ").concat(remainingMs, "ms"));
+                                }
+                                this.setSlotState("READY", "edge_vast_ready");
+                                this.logOrchestratorFunnel("edge_fill", {
+                                    podAdCount: podCount,
+                                    podDurationMs: (_adPlayer_getPodTotalDurationMs = adPlayer.getPodTotalDurationMs) === null || _adPlayer_getPodTotalDurationMs === void 0 ? void 0 : _adPlayer_getPodTotalDurationMs.call(adPlayer),
+                                    remainingMs: remainingMs
+                                });
+                                sendAdLoadedTracking(this.host.config.licenseKey, {
+                                    source: "hls",
+                                    vastUrl: requestUrl,
+                                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                }, this.analyticsContext).catch(function() {});
+                                this.timing.startAdFailsafeTimer(requestToken);
+                                return [
+                                    4,
+                                    this.callController(function() {
+                                        return adPlayer.play();
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                if (this.isStale(epoch, generation)) return [
+                                    2,
+                                    "stale"
+                                ];
+                                if (this.timing.expectedAdBreakDurationMs != null && this.timing.getAdBreakEndWallClockMs() == null) {
+                                    this.timing.scheduleAdStopAtBreakBoundary();
+                                }
+                                adPlayer.setAdVolume(getAdAudioVolume(adPlayer));
+                                return [
+                                    2,
+                                    "fill"
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                this.timing.clearAdRequestWatchdog();
+                                this.timing.clearAdFailsafeTimer();
+                                if (this.timing.activeAdRequestToken === requestToken) {
+                                    this.timing.activeAdRequestToken = null;
+                                }
+                                errorMessage = error === null || error === void 0 ? void 0 : error.message;
+                                if (this.isStale(epoch, generation)) {
+                                    this.logOrchestratorFunnel("stale_request_result_ignored", {
+                                        requestId: requestToken,
+                                        source: "edge",
+                                        errorMessage: errorMessage
+                                    });
+                                    return [
+                                        2,
+                                        "stale"
+                                    ];
+                                }
+                                classification = classifyEdgeVastResponse({
+                                    podAdCount: 0,
+                                    error: error
+                                });
+                                diag = this.requestDiagnostics.get(requestToken);
+                                if (diag && !diag.failureReason) diag.failureReason = "edge_".concat(classification, ": ").concat(errorMessage);
+                                this.markEdgeExhausted("edge_".concat(classification), {
+                                    errorMessage: errorMessage
+                                });
+                                return [
+                                    2,
+                                    "fallback"
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "continueAfterEdgeOutcome",
+            value: function continueAfterEdgeOutcome(outcome, epoch) {
+                if (outcome !== "fallback") return;
+                if (!this.inAdBreak || epoch !== this.timing.adBreakEpoch) return;
+                if (this.debug) {
+                    console.log("[AdBreak][EDGE] No usable Edge pod; checking with GAM for the remaining break");
+                }
+                this.setSlotState("NEEDS_NEXT_AD", "edge_fallback");
+                this.requestNextAd("edge_fallback");
+            }
+        },
         {
             // ───────────────────────────────────────────────────────────────
             //  Next-ad scheduling (single flight)
@@ -9977,7 +10392,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             value: function getStopRequestingReason(remainingMs) {
                 if (this.breakSource === "vmap") {
                     if (this.adPodQueue.length === 0) return "vmap_queue_empty";
-                } else if (this.breakSource !== "scte35" || !this.followUpBaseVastUrl) {
+                } else if (this.breakSource !== "scte35" || !this.followUpBaseVastUrl && !this.canRequestEdge()) {
                     return "no_follow_up_source";
                 }
                 if (this.timing.consecutiveFailures >= this.timing.maxConsecutiveFailures) {
@@ -9989,7 +10404,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 if (this.timing.totalAdRequestsInBreak >= this.timing.maxTotalAdRequestsPerBreak) {
                     return "request_cap";
                 }
-                if (this.timing.isGamInCooldown()) {
+                if (!this.canRequestEdge() && this.timing.isGamInCooldown()) {
                     return "gam_cooldown";
                 }
                 if (this.isBreakTimeBounded() && remainingMs < this.getMinRemainingMsToRequestAd()) {
@@ -10083,10 +10498,33 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             key: "requestFollowUpAd",
             value: function requestFollowUpAd(trigger) {
                 return _async_to_generator(function() {
-                    var url, epoch, unused;
+                    var edgeUrl, epoch2, outcome, url, epoch, unused;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
+                                if (!this.canRequestEdge()) return [
+                                    3,
+                                    2
+                                ];
+                                edgeUrl = this.prepareEdgePodRequest();
+                                if (!edgeUrl) {
+                                    this.requestNextAd("".concat(trigger, ":edge_unavailable"));
+                                    return [
+                                        2
+                                    ];
+                                }
+                                epoch2 = this.timing.adBreakEpoch;
+                                return [
+                                    4,
+                                    this.runEdgePod(edgeUrl, "edge_".concat(trigger))
+                                ];
+                            case 1:
+                                outcome = _state.sent();
+                                this.continueAfterEdgeOutcome(outcome, epoch2);
+                                return [
+                                    2
+                                ];
+                            case 2:
                                 if (this.breakSource === "vmap") {
                                     url = this.adPodQueue.shift();
                                 } else if (this.followUpBaseVastUrl) {
@@ -10097,32 +10535,32 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 ];
                                 this.noteVastUrlGenerated(ensureVideoAdType(url), trigger);
                                 epoch = this.timing.adBreakEpoch;
-                                _state.label = 1;
-                            case 1:
+                                _state.label = 3;
+                            case 3:
                                 _state.trys.push([
-                                    1,
                                     3,
+                                    5,
                                     ,
-                                    4
+                                    6
                                 ]);
                                 return [
                                     4,
                                     this.playSingleAd(url, trigger)
                                 ];
-                            case 2:
+                            case 4:
                                 _state.sent();
                                 return [
                                     3,
-                                    4
+                                    6
                                 ];
-                            case 3:
+                            case 5:
                                 unused = _state.sent();
                                 this.continueAfterRequestFailure(epoch);
                                 return [
                                     3,
-                                    4
+                                    6
                                 ];
-                            case 4:
+                            case 6:
                                 return [
                                     2
                                 ];
@@ -10235,7 +10673,11 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     case "gam_http_request_sent":
                         diag.gamRequestSent++;
                         break;
+                    case "edge_http_request_sent":
+                        diag.edgeRequestSent++;
+                        break;
                     case "gam_response_received":
+                    case "edge_response_received":
                         diag.vastHttpStatus = payload.httpStatus;
                         break;
                     case "vast_parsed":
@@ -10422,6 +10864,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
         {
             key: "beginFunnelRequest",
             value: function beginFunnelRequest(adPlayer, requestToken, trigger) {
+                var source = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "gam";
                 var _adPlayer_setFunnelContext;
                 if (this.controllerCallInFlight) {
                     this.logOrchestratorFunnel("duplicate_request_detected", {
@@ -10436,7 +10879,9 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     requestId: requestToken,
                     controllerId: this.controllerGeneration,
                     trigger: trigger,
+                    source: source,
                     gamRequestSent: 0,
+                    edgeRequestSent: 0,
                     wrapperDepth: 0,
                     inlineResolved: false,
                     mediaCandidateCount: 0,
@@ -10567,6 +11012,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 this.timing.activeAdRequestToken = requestToken;
                                 ap = this.host.getAdPlayer();
                                 budgetedUrl = this.withCurrentPodBudget(vastTagUrl);
+                                this.currentPodSource = "gam";
                                 this.setSlotState("REQUESTING", trigger);
                                 this.beginFunnelRequest(ap, requestToken, trigger);
                                 requestUrl = this.applyOpportunityFloor(budgetedUrl);
@@ -10714,6 +11160,10 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     requests: requests,
                     requestRetries: requestRetries,
                     gamResponses: count("gam_response_received"),
+                    edgeRequests: count("edge_request_sent"),
+                    edgeFills: count("edge_fill"),
+                    edgeEmptySentinels: count("edge_empty_sentinel"),
+                    edgeFallbacks: countPrefix("edge_fallback:"),
                     requestsSuppressed: count("request_suppressed"),
                     duplicates: count("duplicate_request_detected") + count("duplicate_break_start"),
                     filled: count("vast_received"),
@@ -10810,6 +11260,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 this.breakSource = void 0;
                 this.followUpBaseVastUrl = void 0;
                 this.unusableResponsesInBreak = 0;
+                this.resetEdgeStateForBreak();
                 adPlayer.stop().catch(function() {});
                 if (!alreadyEnded) this.logBreakFunnel(reason);
                 this.opportunityFloor = void 0;
@@ -11123,7 +11574,13 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     });
                     return;
                 }
-                this.timing.consecutiveFailures++;
+                if (this.currentPodSource === "edge") {
+                    this.markEdgeExhausted("edge_playback_failed", {
+                        reason: reason
+                    });
+                } else {
+                    this.timing.consecutiveFailures++;
+                }
                 var diag = this.currentRequestId != null ? this.requestDiagnostics.get(this.currentRequestId) : void 0;
                 if (diag && !diag.failureReason) diag.failureReason = reason;
                 if (this.debug) {
@@ -11153,7 +11610,9 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
         if (this.config.adFloorMaxCents != null) floorBounds.maxCents = this.config.adFloorMaxCents;
         if (this.config.adFloorStepCents != null) floorBounds.stepCents = this.config.adFloorStepCents;
         this.floorLadder = new FloorLadderController(this.config.adFloorLadder, floorBounds);
+        this.floorLadderEnabled = this.config.adFloorLadderEnabled === true;
         this.warnOnInvalidFloorLadder(this.floorLadder.validate());
+        this.edgePodBaseUrl = resolveEdgePodBaseUrl(this.config);
         this.adPlayer = this.createAdPlayer(false);
         this.palNonce = createPalNonceManager();
         this.cueManager = new Scte35CueManager(!!this.config.debugAdTiming, {
@@ -11253,11 +11712,14 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
             generatePodVastUrl: function generatePodVastUrl(base, breakDurationMs) {
                 return _this.generatePodVastUrl(base, breakDurationMs);
             },
+            getEdgePodBaseUrl: function getEdgePodBaseUrl() {
+                return _this.edgePodBaseUrl;
+            },
             getFloorSnapshot: function getFloorSnapshot(position) {
-                return _this.floorLadder.snapshotFor({
+                return _this.floorLadderEnabled ? _this.floorLadder.snapshotFor({
                     position: position,
                     isCtv: _this.isCtvEnvironment()
-                });
+                }) : void 0;
             },
             onAdClick: function onAdClick() {
                 return _this.palNonce.sendAdClick();
@@ -11308,11 +11770,24 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
                 return report;
             }
         },
+        {
+            key: "setAdFloorLadderEnabled",
+            value: function setAdFloorLadderEnabled(enabled) {
+                this.floorLadderEnabled = enabled;
+                if (enabled) this.warnOnInvalidFloorLadder(this.floorLadder.validate());
+            }
+        },
+        {
+            key: "isAdFloorLadderEnabled",
+            value: function isAdFloorLadderEnabled() {
+                return this.floorLadderEnabled;
+            }
+        },
         {
             key: "warnOnInvalidFloorLadder",
             value: function warnOnInvalidFloorLadder(report) {
                 var config = this.floorLadder.get();
-                if (report.ok || !config.enabled) return;
+                if (report.ok || !this.floorLadderEnabled || !config.enabled) return;
                 console.warn("[AdBreak][FLOOR] configuration has issues; invalid floors will not be sent", {
                     errors: report.errors,
                     configurationVersion: config.configurationVersion,
@@ -12045,6 +12520,7 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
                 this.timing.destroy();
                 this.adBreak.clearPendingAdBreak();
                 this.placeholder.destroy();
+                0;
                 if (this.timeUpdateHandler) {
                     this.video.removeEventListener("timeupdate", this.timeUpdateHandler);
                     delete this.timeUpdateHandler;