stormcloud-video-player 0.8.68 → 0.8.70

package/lib/player/AdBreakOrchestrator.cjs

@@ -284,84 +284,6 @@ __export(AdBreakOrchestrator_exports, {
     }
 });
 module.exports = __toCommonJS(AdBreakOrchestrator_exports);
-// src/utils/trackingIngest.ts
-var DEFAULT_TRACKING_INGEST_CONFIG = {
-    enabled: true,
-    baseUrl: "https://player-analytics-ingest-api-760490581852.us-central1.run.app/api/adstorm/player-tracking"
-};
-var trackingIngestConfig = _object_spread({}, DEFAULT_TRACKING_INGEST_CONFIG);
-function isTrackingIngestEnabled() {
-    return trackingIngestConfig.enabled === true;
-}
-function normalizeIngestBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/+$/, "");
-}
-function buildTrackingIngestUrl(channel) {
-    var base = normalizeIngestBaseUrl(trackingIngestConfig.baseUrl);
-    if (channel === "impressions") {
-        return "".concat(base, "/impressions/ingest");
-    }
-    return "".concat(base, "/metrics/ingest");
-}
-function ingestPlayerTracking(licenseKey, channel, body) {
-    return _async_to_generator(function() {
-        var response, error;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    if (!isTrackingIngestEnabled() || !licenseKey) {
-                        return [
-                            2,
-                            false
-                        ];
-                    }
-                    _state.label = 1;
-                case 1:
-                    _state.trys.push([
-                        1,
-                        3,
-                        ,
-                        4
-                    ]);
-                    return [
-                        4,
-                        fetch(buildTrackingIngestUrl(channel), {
-                            method: "POST",
-                            headers: {
-                                "Content-Type": "application/json",
-                                Authorization: "License-Key ".concat(licenseKey)
-                            },
-                            body: JSON.stringify(body)
-                        })
-                    ];
-                case 2:
-                    response = _state.sent();
-                    if (!response.ok) {
-                        console.warn("[StormcloudVideoPlayer] Tracking ingest failed (".concat(response.status, ") for ").concat(channel));
-                        return [
-                            2,
-                            false
-                        ];
-                    }
-                    return [
-                        2,
-                        true
-                    ];
-                case 3:
-                    error = _state.sent();
-                    console.warn("[StormcloudVideoPlayer] Tracking ingest error for ".concat(channel, ":"), error);
-                    return [
-                        2,
-                        false
-                    ];
-                case 4:
-                    return [
-                        2
-                    ];
-            }
-        });
-    })();
-}
 // src/utils/vastEnvironmentSignals.ts
 var PLAYER_ID_STORAGE_KEY = "stormcloud.player.id";
 var DEVICE_ID_STORAGE_KEYS = [
@@ -807,6 +729,259 @@ function normalizeBoolean(value) {
     }
     return void 0;
 }
+// src/utils/vastMacros.ts
+var GAM_AD_HOSTS = /* @__PURE__ */ new Set([
+    "pubads.g.doubleclick.net",
+    "securepubads.g.doubleclick.net"
+]);
+function ensureVideoAdType(rawUrl) {
+    try {
+        var url = new URL(rawUrl);
+        if (!GAM_AD_HOSTS.has(url.hostname)) return rawUrl;
+        if (url.searchParams.has("ad_type")) return rawUrl;
+        url.searchParams.set("ad_type", "video");
+        return url.toString();
+    } catch (unused) {
+        return rawUrl;
+    }
+}
+// src/player/FloorLadder.ts
+var DEFAULT_WEB_FLOOR_LADDER_CONFIG = Object.freeze({
+    enabled: false,
+    targetingKey: "airytv_web_floor",
+    minFloorCents: 25,
+    maxFloorCents: 300,
+    stepCents: 25,
+    selectedFloorCents: 25,
+    fallbackFloorCents: 25,
+    readyFloorCents: [],
+    mode: "fixed",
+    allowedPositions: [
+        "midroll"
+    ],
+    targetAdUnitPath: "/21821455290/airytvadx/airytv-web",
+    configurationVersion: "2026-09-29.1"
+});
+var DEFAULT_FLOOR_LADDER_BOUNDS = Object.freeze({
+    minCents: 25,
+    maxCents: 300,
+    stepCents: 25
+});
+function decodeQueryComponent(value) {
+    try {
+        return decodeURIComponent(value.replace(/\+/g, " "));
+    } catch (unused) {
+        return void 0;
+    }
+}
+function mergeCustParams(decoded, key, cents) {
+    var prefix = "".concat(key, "=");
+    var kept = decoded.split("&").filter(function(pair) {
+        return pair !== "" && pair !== key && pair.indexOf(prefix) !== 0;
+    });
+    kept.push("".concat(prefix).concat(cents));
+    return kept.join("&");
+}
+function applyFloorToVastUrl(url, floor) {
+    if (floor.status !== "armed" || floor.floorCents == null) {
+        return {
+            url: url,
+            applied: false,
+            reason: floor.reason
+        };
+    }
+    var parsed;
+    try {
+        parsed = new URL(url);
+    } catch (unused) {
+        return {
+            url: url,
+            applied: false,
+            reason: "invalid_url"
+        };
+    }
+    if (!GAM_AD_HOSTS.has(parsed.hostname)) {
+        return {
+            url: url,
+            applied: false,
+            reason: "not_gam_host"
+        };
+    }
+    if (parsed.searchParams.get("iu") !== floor.targetAdUnitPath) {
+        return {
+            url: url,
+            applied: false,
+            reason: "ad_unit_mismatch"
+        };
+    }
+    var hashIndex = url.indexOf("#");
+    var beforeHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    var hash = hashIndex === -1 ? "" : url.slice(hashIndex);
+    var queryIndex = beforeHash.indexOf("?");
+    var base = beforeHash.slice(0, queryIndex);
+    var segments = beforeHash.slice(queryIndex + 1).split("&");
+    var existing = [];
+    var insertAt = -1;
+    var rest = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = segments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var segment = _step.value;
+            var eq = segment.indexOf("=");
+            var rawKey = eq === -1 ? segment : segment.slice(0, eq);
+            if (decodeQueryComponent(rawKey) === "cust_params") {
+                if (insertAt === -1) insertAt = rest.length;
+                var value = eq === -1 ? "" : decodeQueryComponent(segment.slice(eq + 1));
+                if (value === void 0) {
+                    return {
+                        url: url,
+                        applied: false,
+                        reason: "malformed_cust_params"
+                    };
+                }
+                if (value) existing.push(value);
+                continue;
+            }
+            rest.push(segment);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (insertAt === -1) insertAt = rest.length;
+    var merged = mergeCustParams(existing.join("&"), floor.targetingKey, floor.floorCents);
+    rest.splice(insertAt, 0, "cust_params=".concat(encodeURIComponent(merged)));
+    var query = rest.filter(function(segment) {
+        return segment !== "";
+    }).join("&");
+    return {
+        url: "".concat(base, "?").concat(query).concat(hash),
+        applied: true,
+        reason: void 0
+    };
+}
+// src/player/EdgePodRequest.ts
+var EDGE_POD_MAX_ADS = 10;
+var EDGE_POD_EXCEEDS_BUDGET = "edge_pod_exceeds_budget";
+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/utils/trackingIngest.ts
+var DEFAULT_TRACKING_INGEST_CONFIG = {
+    enabled: true,
+    baseUrl: "https://player-analytics-ingest-api-760490581852.us-central1.run.app/api/adstorm/player-tracking"
+};
+var trackingIngestConfig = _object_spread({}, DEFAULT_TRACKING_INGEST_CONFIG);
+function isTrackingIngestEnabled() {
+    return trackingIngestConfig.enabled === true;
+}
+function normalizeIngestBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "");
+}
+function buildTrackingIngestUrl(channel) {
+    var base = normalizeIngestBaseUrl(trackingIngestConfig.baseUrl);
+    if (channel === "impressions") {
+        return "".concat(base, "/impressions/ingest");
+    }
+    return "".concat(base, "/metrics/ingest");
+}
+function ingestPlayerTracking(licenseKey, channel, body) {
+    return _async_to_generator(function() {
+        var response, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!isTrackingIngestEnabled() || !licenseKey) {
+                        return [
+                            2,
+                            false
+                        ];
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        fetch(buildTrackingIngestUrl(channel), {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                                Authorization: "License-Key ".concat(licenseKey)
+                            },
+                            body: JSON.stringify(body)
+                        })
+                    ];
+                case 2:
+                    response = _state.sent();
+                    if (!response.ok) {
+                        console.warn("[StormcloudVideoPlayer] Tracking ingest failed (".concat(response.status, ") for ").concat(channel));
+                        return [
+                            2,
+                            false
+                        ];
+                    }
+                    return [
+                        2,
+                        true
+                    ];
+                case 3:
+                    error = _state.sent();
+                    console.warn("[StormcloudVideoPlayer] Tracking ingest error for ".concat(channel, ":"), error);
+                    return [
+                        2,
+                        false
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 // src/utils/tracking.ts
 var cachedBrowserId = null;
 function buildAnalyticsContext(config) {
@@ -1288,22 +1463,6 @@ function sendHeartbeat(_0) {
 function getAdAudioVolume(adPlayer) {
     return adPlayer.getOriginalMutedState() ? 0 : adPlayer.getOriginalVolume();
 }
-// src/utils/vastMacros.ts
-var GAM_AD_HOSTS = /* @__PURE__ */ new Set([
-    "pubads.g.doubleclick.net",
-    "securepubads.g.doubleclick.net"
-]);
-function ensureVideoAdType(rawUrl) {
-    try {
-        var url = new URL(rawUrl);
-        if (!GAM_AD_HOSTS.has(url.hostname)) return rawUrl;
-        if (url.searchParams.has("ad_type")) return rawUrl;
-        url.searchParams.set("ad_type", "video");
-        return url.toString();
-    } catch (unused) {
-        return rawUrl;
-    }
-}
 // src/player/AdBreakOrchestrator.ts
 var REQUEST_FAILURE_STAGES = /* @__PURE__ */ new Set([
     "no_fill",
@@ -1332,6 +1491,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;
@@ -1482,7 +1643,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) {
@@ -1612,20 +1775,21 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
         },
         {
             key: "beginVmapBreak",
-            value: function beginVmapBreak(breakKey) {
+            value: function beginVmapBreak(breakKey, position) {
                 this.breakSource = "vmap";
+                this.resetEdgeStateForBreak();
                 this.followUpBaseVastUrl = void 0;
                 this.unusableResponsesInBreak = 0;
                 this.timing.totalAdRequestsInBreak = 0;
                 this.setSlotState("NEEDS_NEXT_AD", "vmap_break_start");
-                this.noteOpportunity("vmap", breakKey);
+                this.noteOpportunity("vmap", breakKey, position);
             }
         },
         {
             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:
@@ -1639,7 +1803,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 [
@@ -1655,6 +1820,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;
@@ -1673,10 +1839,10 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 if (this.timing.expectedAdBreakDurationMs == null && adBreakDurationMs != null) {
                                     this.timing.expectedAdBreakDurationMs = adBreakDurationMs;
                                 }
-                                this.noteOpportunity("scte35", this.cueManager.activeScte35BreakKey);
+                                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
                                 ];
@@ -1695,11 +1861,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");
@@ -1767,7 +1968,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             // ───────────────────────────────────────────────────────────────
             function startOptimizedPod(baseVastUrl, breakDurationMs) {
                 return _async_to_generator(function() {
-                    var podUrl, prefetched, epoch, generation, adPlayer, requestToken, _ref, _adPlayer_getPodAdCount, podCount, error;
+                    var podUrl, prefetched, epoch, generation, adPlayer, requestToken, requestUrl, _ref, _adPlayer_getPodAdCount, podCount, error;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -1791,9 +1992,11 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 adPlayer = this.host.getAdPlayer();
                                 requestToken = ++this.timing.adRequestTokenCounter;
                                 this.timing.activeAdRequestToken = requestToken;
-                                this.currentVastUrl = podUrl;
+                                this.currentPodSource = "gam";
                                 this.setSlotState("REQUESTING", "initial_pod");
                                 this.beginFunnelRequest(adPlayer, requestToken, "initial_pod");
+                                requestUrl = this.applyOpportunityFloor(podUrl);
+                                this.currentVastUrl = requestUrl;
                                 _state.label = 1;
                             case 1:
                                 _state.trys.push([
@@ -1816,7 +2019,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 return [
                                     4,
                                     this.callController(function() {
-                                        return adPlayer.requestAds(podUrl);
+                                        return adPlayer.requestAds(requestUrl);
                                     })
                                 ];
                             case 3:
@@ -1848,7 +2051,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 }
                                 sendAdLoadedTracking(this.host.config.licenseKey, {
                                     source: "hls",
-                                    vastUrl: podUrl,
+                                    vastUrl: requestUrl,
                                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                                 }, this.analyticsContext).catch(function() {});
                                 this.timing.startAdFailsafeTimer(requestToken);
@@ -1906,6 +2109,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)
@@ -1961,7 +2382,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) {
@@ -1973,7 +2394,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()) {
@@ -2067,10 +2488,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) {
@@ -2081,32 +2525,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
                                 ];
@@ -2195,12 +2639,14 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     this.timing.failedVastUrls.add(vastTagUrl);
                 }
                 this.countFunnelStage("request_outcome:".concat(outcome));
-                this.logOrchestratorFunnel("request_outcome", {
+                this.logOrchestratorFunnel("request_outcome", _object_spread({
                     outcome: outcome,
                     errorMessage: message,
                     consecutiveFailures: this.timing.consecutiveFailures,
-                    unusableResponsesInBreak: this.unusableResponsesInBreak
-                });
+                    unusableResponsesInBreak: this.unusableResponsesInBreak,
+                    vastAdCount: diag === null || diag === void 0 ? void 0 : diag.vastAdCount,
+                    impressionCount: diag === null || diag === void 0 ? void 0 : diag.impressionCount
+                }, this.requestFloorFields(diag)));
             }
         },
         {
@@ -2217,7 +2663,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":
@@ -2239,6 +2689,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                         break;
                     case "impression_fired":
                         diag.impressionFired = true;
+                        diag.impressionCount++;
                         break;
                     default:
                         if (REQUEST_FAILURE_STAGES.has(payload.stage) && !diag.failureReason) {
@@ -2295,6 +2746,67 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 }
             }
         },
+        {
+            key: "opportunityFloorFields",
+            value: function opportunityFloorFields() {
+                var floor = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.opportunityFloor;
+                if (!floor) return {};
+                return {
+                    floorStatus: floor.status,
+                    floorCents: floor.floorCents,
+                    floorSource: floor.source,
+                    floorReason: floor.reason,
+                    floorSelector: floor.selector,
+                    floorConfigVersion: floor.configurationVersion,
+                    adPosition: floor.position
+                };
+            }
+        },
+        {
+            key: "requestFloorFields",
+            value: function requestFloorFields(diag) {
+                if (!diag || diag.floorApplied === void 0) return {};
+                return {
+                    floorApplied: diag.floorApplied,
+                    floorCents: diag.floorCents,
+                    floorSource: diag.floorSource,
+                    floorReason: diag.floorReason,
+                    floorConfigVersion: diag.floorConfigVersion
+                };
+            }
+        },
+        {
+            key: "applyOpportunityFloor",
+            value: function applyOpportunityFloor(url) {
+                var floor = this.opportunityFloor;
+                if (!floor) return url;
+                var result = applyFloorToVastUrl(url, floor);
+                var diag = this.currentRequestId != null ? this.requestDiagnostics.get(this.currentRequestId) : void 0;
+                if (diag) {
+                    diag.floorApplied = result.applied;
+                    if (result.applied && floor.floorCents != null) diag.floorCents = floor.floorCents;
+                    diag.floorSource = result.applied ? floor.source : "none";
+                    if (result.reason) diag.floorReason = result.reason;
+                    diag.floorConfigVersion = floor.configurationVersion;
+                }
+                if (floor.status === "skipped" && floor.reason === "disabled") {
+                    this.countFunnelStage("floor_skipped:disabled");
+                    return result.url;
+                }
+                this.logOrchestratorFunnel(result.applied ? "floor_applied" : "floor_skipped", {
+                    reason: result.reason,
+                    floorCents: result.applied ? floor.floorCents : void 0,
+                    floorSource: result.applied ? floor.source : "none",
+                    floorSelector: floor.selector,
+                    floorConfigVersion: floor.configurationVersion,
+                    adPosition: floor.position
+                });
+                if (!result.applied && result.reason) {
+                    this.countFunnelStage("floor_skipped:".concat(result.reason));
+                }
+                return result.url;
+            }
+        },
         {
             key: "countFunnelStage",
             value: function countFunnelStage(stage) {
@@ -2317,7 +2829,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
         },
         {
             key: "noteOpportunity",
-            value: function noteOpportunity(source, breakKey) {
+            value: function noteOpportunity(source, breakKey, position) {
                 if (breakKey && breakKey === this.opportunityBreakKey && this.opportunityEpoch === this.timing.adBreakEpoch) {
                     this.logOrchestratorFunnel("duplicate_break_start", {
                         source: source,
@@ -2327,16 +2839,22 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                 }
                 this.opportunityBreakKey = breakKey;
                 this.opportunityEpoch = this.timing.adBreakEpoch;
-                this.logOrchestratorFunnel("opportunity_created", {
+                try {
+                    this.opportunityFloor = this.host.getFloorSnapshot(position);
+                } catch (unused) {
+                    this.opportunityFloor = void 0;
+                }
+                this.logOrchestratorFunnel("opportunity_created", _object_spread({
                     source: source,
                     breakKey: breakKey,
                     expectedDurationMs: this.timing.expectedAdBreakDurationMs
-                });
+                }, this.opportunityFloorFields()));
             }
         },
         {
             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", {
@@ -2351,13 +2869,16 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     requestId: requestToken,
                     controllerId: this.controllerGeneration,
                     trigger: trigger,
+                    source: source,
                     gamRequestSent: 0,
+                    edgeRequestSent: 0,
                     wrapperDepth: 0,
                     inlineResolved: false,
                     mediaCandidateCount: 0,
                     supportedMediaCount: 0,
                     playStarted: false,
                     impressionFired: false,
+                    impressionCount: 0,
                     startedAt: Date.now()
                 });
                 (_adPlayer_setFunnelContext = adPlayer.setFunnelContext) === null || _adPlayer_setFunnelContext === void 0 ? void 0 : _adPlayer_setFunnelContext.call(adPlayer, {
@@ -2442,7 +2963,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
             value: function playSingleAd(vastTagUrl) {
                 var trigger = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "vmap";
                 return _async_to_generator(function() {
-                    var epoch, generation, requestToken, ap, requestUrl, _ap_getLoadedAdDuration, adDurationS, remainingMs, error;
+                    var epoch, generation, requestToken, ap, budgetedUrl, requestUrl, _ap_getLoadedAdDuration, adDurationS, remainingMs, error;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -2480,10 +3001,12 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                                 requestToken = ++this.timing.adRequestTokenCounter;
                                 this.timing.activeAdRequestToken = requestToken;
                                 ap = this.host.getAdPlayer();
-                                requestUrl = this.withCurrentPodBudget(vastTagUrl);
-                                this.currentVastUrl = requestUrl;
+                                budgetedUrl = this.withCurrentPodBudget(vastTagUrl);
+                                this.currentPodSource = "gam";
                                 this.setSlotState("REQUESTING", trigger);
                                 this.beginFunnelRequest(ap, requestToken, trigger);
+                                requestUrl = this.applyOpportunityFloor(budgetedUrl);
+                                this.currentVastUrl = requestUrl;
                                 _state.label = 1;
                             case 1:
                                 _state.trys.push([
@@ -2616,14 +3139,21 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                         endReason: endReason
                     });
                 }
-                console.log("[AdBreak][FUNNEL] Break summary", {
+                console.log("[AdBreak][FUNNEL] Break summary", _object_spread_props(_object_spread({
                     breakId: breakId,
                     endReason: endReason,
-                    opportunities: count("opportunity_created"),
+                    opportunities: count("opportunity_created")
+                }, this.opportunityFloorFields()), {
+                    floorAppliedRequests: count("floor_applied"),
+                    floorSkippedRequests: count("floor_skipped") + count("floor_skipped:disabled"),
                     vastUrlsGenerated: count("vast_url_generated"),
                     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"),
@@ -2671,7 +3201,7 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
                     visibilityHidden: count("while_hidden"),
                     playbackFailures: count("play_failed") + count("media_error") + count("hls_fatal") + count("stall") + count("decode_failure") + count("media_unsupported"),
                     stages: funnel
-                });
+                }));
             }
         },
         {
@@ -2720,8 +3250,10 @@ 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;
                 this.setSlotState("IDLE", "break_complete");
                 var restoredMuted = this.host.getAdPlayer().getOriginalMutedState();
                 var restoredVolume = this.host.getAdPlayer().getOriginalVolume();
@@ -3032,7 +3564,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) {