@xibosignage/xibo-layout-renderer 1.0.27 → 1.0.29

package/dist/xibo-layout-renderer.js

@@ -19,30 +19,6 @@ var XiboLayoutRenderer = (function (exports) {
       return !!t;
     })();
   }
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = !0,
-        o = !1;
-      try {
-        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = !0, n = r;
-      } finally {
-        try {
-          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
-        }
-      }
-      return a;
-    }
-  }
   function ownKeys(e, r) {
     var t = Object.keys(e);
     if (Object.getOwnPropertySymbols) {
@@ -521,18 +497,12 @@ var XiboLayoutRenderer = (function (exports) {
     }
     return _assertThisInitialized(self);
   }
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
-  }
   function _toConsumableArray(arr) {
     return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
   }
   function _arrayWithoutHoles(arr) {
     if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
   }
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
   function _iterableToArray(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
   }
@@ -552,9 +522,6 @@ var XiboLayoutRenderer = (function (exports) {
   function _nonIterableSpread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
   function _createForOfIteratorHelper(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
     if (!it) {
@@ -1061,6 +1028,13 @@ var XiboLayoutRenderer = (function (exports) {
     },
     gotoNextLayout: function gotoNextLayout() {},
     gotoPrevLayout: function gotoPrevLayout() {},
+    gotoLayoutByCode: function gotoLayoutByCode(_layoutCode) {
+      return Promise.resolve();
+    },
+    playInterruptLayout: function playInterruptLayout(_inputLayout) {
+      return Promise.resolve();
+    },
+    triggerAction: function triggerAction(_triggerCode, _widgetId) {},
     init: function init() {
       return Promise.resolve({});
     },
@@ -1099,7 +1073,7 @@ var XiboLayoutRenderer = (function (exports) {
     renderOverlayLayouts: function renderOverlayLayouts() {
       return Promise.resolve();
     },
-    uniqueLayouts: {},
+    uniqueLayouts: new Map(),
     updateInputLayout: function updateInputLayout(layoutIndex, layout) {},
     updateLayouts: function updateLayouts(inputLayouts) {},
     updateLoop: function updateLoop(inputLayouts) {
@@ -14019,11 +13993,11 @@ var XiboLayoutRenderer = (function (exports) {
    * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
    * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization
    */
-  function DOMParser$1(options){
+  function DOMParser$2(options){
   	this.options = options ||{locator:{}};
   }
 
-  DOMParser$1.prototype.parseFromString = function(source,mimeType){
+  DOMParser$2.prototype.parseFromString = function(source,mimeType){
   	var options = this.options;
   	var sax =  new XMLReader();
   	var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
@@ -14270,9 +14244,9 @@ var XiboLayoutRenderer = (function (exports) {
 
   domParser.__DOMHandler = DOMHandler;
   domParser.normalizeLineEndings = normalizeLineEndings;
-  domParser.DOMParser = DOMParser$1;
+  domParser.DOMParser = DOMParser$2;
 
-  var DOMParser = domParser.DOMParser;
+  var DOMParser$1 = domParser.DOMParser;
 
   /*! @name mpd-parser @version 1.3.1 @license Apache-2.0 */
 
@@ -16896,7 +16870,7 @@ var XiboLayoutRenderer = (function (exports) {
       throw new Error(errors.DASH_EMPTY_MANIFEST);
     }
 
-    const parser = new DOMParser();
+    const parser = new DOMParser$1();
     let xml;
     let mpd;
 
@@ -73601,7 +73575,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       cssText += "\n            visibility: hidden;\n            opacity: 0;\n            z-index: 0;\n        ";
     }
     $media.style.cssText = cssText;
-    if (self.render === 'html' || self.mediaType === 'ticker' || self.mediaType === 'webpage') {
+    if (self.mediaType !== 'spacer' && (self.render === 'html' || self.mediaType === 'ticker' || self.mediaType === 'webpage')) {
       self.checkIframeStatus = true;
       self.iframe = prepareIframe(self);
     } else if (self.mediaType === "image") {
@@ -73749,8 +73723,6 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
     region.html.appendChild(media.html);
   }
   function prepareHtmlMedia(media, region) {
-    // Set state as false ( for now )
-    media.ready = false;
     if (media.html) {
       var mediaId = getMediaId(media);
       // Clean up old copy of the media
@@ -73762,14 +73734,16 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         mediaId: mediaId,
         mediaInRegion: mediaInRegion
       });
-      // Append iframe
-      media.html.innerHTML = '';
-      media.html.appendChild(media.iframe);
       if (!mediaInRegion) {
-        // Add fresh copy of the media into the region using the direct reference
+        // Append iframe and insert into region only when not already in the DOM.
+        // Calling innerHTML = '' when the element is already present detaches the
+        // iframe, causing the browser to reload its src unnecessarily (e.g. when
+        // a media was preloaded then skipped by a navigation action).
+        media.html.innerHTML = '';
+        media.html.appendChild(media.iframe);
         region.html.appendChild(media.html);
-        media.ready = true;
       }
+      media.ready = true;
     }
   }
   exports.FaultCodes = void 0;
@@ -74025,14 +73999,13 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
             _this.startMediaTimer(media);
           }
         } else if (media.mediaType === 'shellcommand') {
-          if (_this.hasCommandExecuted && !_this.loop) {
-            return;
-          }
-          _this.hasCommandExecuted = true;
-          _this.emitCommand(media);
-          if (media.duration > 0) {
-            _this.startMediaTimer(media);
+          // Fire once per cycle unless loop is enabled, in which case re-fire every play.
+          if (!_this.hasCommandExecuted || _this.loop) {
+            _this.hasCommandExecuted = true;
+            _this.emitCommand(media);
           }
+          // Always run the timer so the layout advances and stats are recorded correctly.
+          _this.startMediaTimer(media);
         } else {
           _this.startMediaTimer(media);
         }
@@ -74078,7 +74051,12 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           var _this$sspImpressionUr, _this$sspErrorUrls;
           _this.xlr.emitter.emit('sspWidgetEnd', (_this$sspImpressionUr = _this.sspImpressionUrls) !== null && _this$sspImpressionUr !== void 0 ? _this$sspImpressionUr : [], (_this$sspErrorUrls = _this.sspErrorUrls) !== null && _this$sspErrorUrls !== void 0 ? _this$sspErrorUrls : [], _this.sspImpressionUrls ? _this.duration : 0);
         }
-        media.region.playNextMedia();
+        // Only advance the region if this media is still the active one.
+        // A user-triggered next/prev action may have already moved currMedia
+        // on, in which case the timer firing here would cause a double-advance.
+        if (media === media.region.currMedia) {
+          media.region.playNextMedia();
+        }
       });
       this.on('cancelled', function (media) {
         if (media.state === MediaState.CANCELLED) return;
@@ -74108,7 +74086,12 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           var _this$sspImpressionUr2, _this$sspErrorUrls2;
           _this.xlr.emitter.emit('sspWidgetEnd', (_this$sspImpressionUr2 = _this.sspImpressionUrls) !== null && _this$sspImpressionUr2 !== void 0 ? _this$sspImpressionUr2 : [], (_this$sspErrorUrls2 = _this.sspErrorUrls) !== null && _this$sspErrorUrls2 !== void 0 ? _this$sspErrorUrls2 : [], _this.sspImpressionUrls ? _this.duration : 0);
         }
-        media.region.playNextMedia();
+        // Only advance the region if this media is still the active one.
+        // A user-triggered next/prev action may have already moved currMedia
+        // on, in which case the timer firing here would cause a double-advance.
+        if (media === media.region.currMedia) {
+          media.region.playNextMedia();
+        }
       });
       // Initialize Media object
       this.init();
@@ -74117,6 +74100,10 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       key: "startMediaTimer",
       value: function startMediaTimer(media) {
         var _this2 = this;
+        // Always reset the counter so a media replayed after cancellation runs
+        // for its full duration rather than the residual time left from the
+        // previous play.
+        this.mediaTimeCount = 0;
         var preloadTimeMs = 2000;
         var preloadTimeBufferMs = media.duration * 1000 / 2 - preloadTimeMs;
         var isPreparingNextMedia = false;
@@ -74341,11 +74328,11 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         };
         var getNewMedia = function getNewMedia() {
           var $region = _this3.region.html;
-          // This function is for checking whether
-          // the region still has to show a media item
-          // when another region is not finished yet
-          if (_this3.region.complete && !_this3.region.layout.allEnded) {
-            // Add currentMedia to the region
+          // Re-insert the element whenever it is missing from the DOM. This covers:
+          //   1. Region completed early but the layout is still running (freeze last frame).
+          //   2. Backward navigation — the previous media's element was removed by the
+          //      removeOldMedia setTimeout in transitionNodes.
+          if (_this3.html) {
             $region.insertBefore(_this3.html, $region.lastElementChild);
             return _this3.html;
           }
@@ -74611,15 +74598,21 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         });
         // Add media to region for targeted actions
         (_this$layout$actionCo = this.layout.actionController) === null || _this$layout$actionCo === void 0 || _this$layout$actionCo.actions.forEach(function (action) {
+          var _ref2, _attributes$actionTyp, _ref3, _attributes$targetId, _ref4, _attributes$widgetId, _attributes$target;
           var attributes = getAllAttributes(action.xml);
-          if (attributes.target.value === 'region' && attributes.actionType.value === 'navWidget' && attributes.targetId.value == _this.id) {
+          // getAllAttributes preserves the XML attribute case. Xibo CMS may export
+          // attributes in camelCase (actionType, targetId, widgetId) or lowercase.
+          // Read both variants so we work with either XLF format.
+          var actionType = (_ref2 = (_attributes$actionTyp = attributes['actionType']) !== null && _attributes$actionTyp !== void 0 ? _attributes$actionTyp : attributes['actiontype']) === null || _ref2 === void 0 ? void 0 : _ref2.value;
+          var targetId = (_ref3 = (_attributes$targetId = attributes['targetId']) !== null && _attributes$targetId !== void 0 ? _attributes$targetId : attributes['targetid']) === null || _ref3 === void 0 ? void 0 : _ref3.value;
+          var widgetId = (_ref4 = (_attributes$widgetId = attributes['widgetId']) !== null && _attributes$widgetId !== void 0 ? _attributes$widgetId : attributes['widgetid']) === null || _ref4 === void 0 ? void 0 : _ref4.value;
+          if (((_attributes$target = attributes['target']) === null || _attributes$target === void 0 ? void 0 : _attributes$target.value) === 'region' && actionType === 'navWidget' && targetId == _this.id) {
             var _this$layout$drawer;
             var drawerMediaItems = Array.from(((_this$layout$drawer = _this.layout.drawer) === null || _this$layout$drawer === void 0 ? void 0 : _this$layout$drawer.getElementsByTagName('media')) || []);
             drawerMediaItems.forEach(function (drawerMedia) {
-              var _attributes$widgetId;
-              if (drawerMedia.id === ((_attributes$widgetId = attributes.widgetId) === null || _attributes$widgetId === void 0 ? void 0 : _attributes$widgetId.value)) {
+              if (drawerMedia.getAttribute('id') === widgetId) {
                 // Add drawer media to the region
-                _this.mediaObjectsActions.push(new Media(_this, (drawerMedia === null || drawerMedia === void 0 ? void 0 : drawerMedia.getAttribute('id')) || '', drawerMedia, _this.options, _this.xlr));
+                _this.mediaObjectsActions.push(new Media(_this, drawerMedia.getAttribute('id') || '', drawerMedia, _this.options, _this.xlr));
               }
             });
           }
@@ -74651,6 +74644,11 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           prepareAudioMedia(media, this);
         } else if ((media.render === 'html' || media.mediaType === 'webpage') && media.iframe && media.checkIframeStatus) {
           prepareHtmlMedia(media, this);
+        } else if (media.mediaType === 'shellcommand') {
+          // Shell command widgets are invisible but must be in the DOM to trigger playback.
+          if (media.html) {
+            this.html.appendChild(media.html);
+          }
         }
       }
     }, {
@@ -74874,7 +74872,17 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
     }, {
       key: "playNextMedia",
       value: function playNextMedia() {
-        var _this$oldMedia3, _this$currMedia2, _this$nxtMedia, _this$currMedia3, _this$currMedia4, _this$currMedia5, _this$currMedia6, _this$oldMedia4, _this$currMedia7, _this$nxtMedia2;
+        var _this$oldMedia3,
+          _this$currMedia2,
+          _this$nxtMedia,
+          _this$currMedia3,
+          _this$currMedia4,
+          _this$currMedia5,
+          _this$currMedia6,
+          _this3 = this,
+          _this$oldMedia4,
+          _this$currMedia7,
+          _this$nxtMedia2;
         console.debug('??? XLR.debug Region playing next media', {
           regionId: this.id,
           currentMediaIndex: this.currentMediaIndex,
@@ -74894,8 +74902,10 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         // cycle completion after the skip loop runs.
         var origIndex = this.currentMediaIndex;
         // When the region has completed and when currentMedia is html
-        // Then, preserve the currentMedia state
-        if (this.complete && ((_this$currMedia3 = this.currMedia) === null || _this$currMedia3 === void 0 ? void 0 : _this$currMedia3.render) === 'html') {
+        // and there is only one media object, preserve the currentMedia state.
+        // Guard is limited to single-media regions so navWidget injections
+        // (which splice a second media in) are not blocked.
+        if (this.complete && ((_this$currMedia3 = this.currMedia) === null || _this$currMedia3 === void 0 ? void 0 : _this$currMedia3.render) === 'html' && this.totalMediaObjects === 1) {
           return;
         }
         // When the region has completed and mediaObjects.length = 1
@@ -74941,6 +74951,25 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
             }
           });
         }
+        // Remove single-play media injected via navWidget actions at the end of each cycle
+        if (crossedEnd && this.mediaObjects.some(function (m) {
+          return m.singlePlay;
+        })) {
+          this.mediaObjects = this.mediaObjects.filter(function (m) {
+            return !m.singlePlay;
+          });
+          this.totalMediaObjects = this.mediaObjects.length;
+          if (this.totalMediaObjects === 0) {
+            this.finished();
+            return;
+          }
+          var newIndex = this.mediaObjects.findIndex(function (m) {
+            return m === _this3.currMedia;
+          });
+          this.currentMediaIndex = newIndex >= 0 ? newIndex : 0;
+          this.currMedia = this.mediaObjects[this.currentMediaIndex];
+          this.nxtMedia = this.mediaObjects[(this.currentMediaIndex + 1) % this.totalMediaObjects];
+        }
         console.debug('??? XLR.debug >> End Region::playNextMedia > execute transitionNodes', {
           regionId: this.id,
           currentMediaIndex: this.currentMediaIndex,
@@ -74950,25 +74979,41 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           nxtMedia: (_this$nxtMedia2 = this.nxtMedia) === null || _this$nxtMedia2 === void 0 ? void 0 : _this$nxtMedia2.containerName
         });
         if (!this.layout.isOverlay && crossedEnd) {
+          var _this$currMedia8;
           this.finished();
           if (this.layout.allEnded) {
             console.debug('??? XLR.debug >> Region - playNextMedia - layout all ended');
             return;
           }
+          // Freeze single-media HTML at its last state while waiting for other
+          // regions to complete. The guard at the top only catches the second
+          // call; this one catches the first completion when complete was just
+          // set by finished() above.
+          if (((_this$currMedia8 = this.currMedia) === null || _this$currMedia8 === void 0 ? void 0 : _this$currMedia8.render) === 'html' && this.totalMediaObjects === 1 && this.oldMedia === this.currMedia) {
+            return;
+          }
         }
         this.transitionNodes(this.oldMedia, this.currMedia);
       }
     }, {
       key: "playPreviousMedia",
       value: function playPreviousMedia() {
-        this.currentMediaIndex = this.currentMediaIndex - 1;
-        if (this.currentMediaIndex < 0 || this.ended) {
-          this.currentMediaIndex = 0;
+        if (this.currentMediaIndex <= 0 || this.ended) {
           return;
         }
-        this.prepareMediaObjects();
+        var interruptedMedia = this.currMedia;
+        this.oldMedia = this.currMedia;
+        this.currentMediaIndex -= 1;
+        this.currMedia = this.mediaObjects[this.currentMediaIndex];
+        this.nxtMedia = this.mediaObjects[(this.currentMediaIndex + 1) % this.totalMediaObjects];
+        this.complete = false;
+        // Cancel the interrupted media after advancing currMedia, using the same
+        // pattern as gotoMediaInRegion — emitting after the update ensures the
+        // handler's (media === currMedia) guard correctly skips playNextMedia.
+        if ((interruptedMedia === null || interruptedMedia === void 0 ? void 0 : interruptedMedia.state) === MediaState.PLAYING) {
+          interruptedMedia.emitter.emit('cancelled', interruptedMedia);
+        }
         console.debug('region::playPreviousMedia', this);
-        /* Do the transition */
         this.transitionNodes(this.oldMedia, this.currMedia);
       }
     }, {
@@ -75045,6 +75090,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       _defineProperty(this, "$actionControllerTitle", void 0);
       _defineProperty(this, "$actionsContainer", void 0);
       _defineProperty(this, "translations", {});
+      _defineProperty(this, "keyboardHandler", null);
       this.parent = parent;
       this.actions = actions;
       this.options = options;
@@ -75167,6 +75213,10 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       key: "openLayoutInNewTab",
       value: function openLayoutInNewTab(layoutCode, options) {
         var url = options.layoutPreviewUrl.replace('[layoutCode]', layoutCode) + '?findByCode=1';
+        console.debug('[ActionController::openLayoutInNewTab] Navigating to layout in new tab with code', {
+          layoutCode: layoutCode,
+          url: url
+        });
         // Send a postMessage to the parent frame so the CMS can handle the confirmation
         // and navigation (confirm() is blocked in sandboxed iframes without allow-modals).
         window.parent.postMessage({
@@ -75179,41 +75229,78 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       }
     }, {
       key: "openLayoutInPlayer",
-      value: function openLayoutInPlayer(layoutCode, options) {
-        // this.parent.xlr.updateLoop([]);
+      value: function openLayoutInPlayer(layoutCode, _options) {
+        console.debug('[ActionController::openLayoutInPlayer] Navigating to layout in player with code', {
+          layoutCode: layoutCode,
+          options: _options
+        });
+        this.parent.xlr.emitter.emit('navLayout', layoutCode, '');
       }
     }, {
       key: "prevOrNextLayout",
       value: function prevOrNextLayout(targetId, actionType) {
         var _this$parent$xlr$curr;
-        // Check if currentLayout is the targetId
-        if (((_this$parent$xlr$curr = this.parent.xlr.currentLayout) === null || _this$parent$xlr$curr === void 0 ? void 0 : _this$parent$xlr$curr.layoutId) === parseInt(targetId)) {
-          if (actionType === 'next') {
-            this.parent.xlr.gotoNextLayout();
-          } else if (actionType === 'previous') {
-            this.parent.xlr.gotoPrevLayout();
-          }
+        console.debug('[ActionController::prevOrNextLayout] Changing layout with data', {
+          targetId: targetId,
+          actionType: actionType
+        });
+        // For screen-level actions targetId may be "0" (the screen has no numeric ID).
+        // Guard using this.parent.layoutId instead so the check always works.
+        if (((_this$parent$xlr$curr = this.parent.xlr.currentLayout) === null || _this$parent$xlr$curr === void 0 ? void 0 : _this$parent$xlr$curr.layoutId) !== this.parent.layoutId) {
+          return;
+        }
+        if (actionType === 'next') {
+          this.parent.xlr.gotoNextLayout();
+        } else if (actionType === 'previous') {
+          this.parent.xlr.gotoPrevLayout();
         }
       }
-      /** Change media in region (next/previous) */
+      /** Change media in region (next/previous) with wrap-around at boundaries. */
     }, {
-      key: "nextMediaInRegion",
-      value: function nextMediaInRegion(regionId, actionType) {
-        // Find target region
+      key: "gotoMediaInRegion",
+      value: function gotoMediaInRegion(regionId, actionType) {
+        console.debug('[ActionController::gotoMediaInRegion] Changing media in region with data', {
+          regionId: regionId,
+          actionType: actionType
+        });
         this.parent.regions.forEach(function (regionObj) {
-          if (regionObj.id === regionId) {
-            if (actionType === 'next') {
-              regionObj.playNextMedia();
-            } else {
-              regionObj.playPreviousMedia();
-            }
+          if (regionObj.id !== regionId || regionObj.ended) return;
+          var total = regionObj.totalMediaObjects;
+          if (total === 0) return;
+          // Snapshot the currently-playing media before updating currMedia so
+          // we can cancel it cleanly after the region state is advanced.
+          var interruptedMedia = regionObj.currMedia;
+          // Compute new index with wrap-around. We do NOT delegate to
+          // playNextMedia() / playPreviousMedia() here because those carry
+          // normal playlist-cycle semantics (finished(), regionExpired()) that
+          // must not fire during user-driven navigation.
+          var newIndex = actionType === 'next' ? (regionObj.currentMediaIndex + 1) % total : (regionObj.currentMediaIndex - 1 + total) % total;
+          regionObj.oldMedia = regionObj.currMedia;
+          regionObj.currentMediaIndex = newIndex;
+          regionObj.currMedia = regionObj.mediaObjects[newIndex];
+          regionObj.nxtMedia = regionObj.mediaObjects[(newIndex + 1) % total];
+          regionObj.complete = false;
+          // Properly cancel the interrupted media AFTER updating currMedia.
+          // Using 'cancelled' rather than bare clearInterval ensures state is
+          // reset from PLAYING and mediaTimeCount is zeroed — without this,
+          // returning to a cancelled media causes run() → 'start' to bail on
+          // the state === PLAYING guard, leaving the region stuck indefinitely.
+          // currMedia is already updated so the handler's guard
+          // (media === media.region.currMedia) correctly skips playNextMedia.
+          if ((interruptedMedia === null || interruptedMedia === void 0 ? void 0 : interruptedMedia.state) === MediaState.PLAYING) {
+            interruptedMedia.emitter.emit('cancelled', interruptedMedia);
           }
+          regionObj.transitionNodes(regionObj.oldMedia, regionObj.currMedia);
         });
       }
     }, {
       key: "loadMediaInRegion",
       value: function loadMediaInRegion(regionId, widgetId) {
-        var _targetRegion, _targetRegion2, _targetRegion3;
+        var _targetRegion, _targetRegion2, _targetRegion3, _targetRegion4;
+        console.debug('[ActionController::loadMediaInRegion] Loading media in region with data', {
+          regionId: regionId,
+          widgetId: widgetId
+        });
         var self = this;
         // Find target region
         var targetRegion;
@@ -75236,27 +75323,84 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           targetMedia.singlePlay = true;
         }
         // If region is empty, remove the background color and empty message
-        if (((_targetRegion = targetRegion) === null || _targetRegion === void 0 ? void 0 : _targetRegion.mediaObjects.length) === 0) {
+        if (((_targetRegion = targetRegion) === null || _targetRegion === void 0 ? void 0 : _targetRegion.totalMediaObjects) === 0) {
+          targetRegion.complete = false;
+        }
+        // Bail out early when the target widget was not found in the drawer
+        if (!targetMedia) {
+          console.debug('[ActionController::loadMediaInRegion] Target media not found in mediaObjectsActions', {
+            regionId: regionId,
+            widgetId: widgetId
+          });
+          return;
+        }
+        // Guard against duplicate insertion if the action fires multiple times before the widget plays
+        if (targetRegion && targetRegion.mediaObjects.some(function (m) {
+          return m.id === targetMedia.id;
+        })) {
+          console.debug('[ActionController::loadMediaInRegion] Target media already queued, skipping duplicate insertion');
+          return;
+        }
+        // Cancel the interrupted media so it doesn't double-advance when the playlist
+        // returns to it. currMedia has not been advanced yet at this point (playNextMedia
+        // does that below), so we cannot use emitter.emit('cancelled') — the handler's
+        // currMedia guard would fire and call playNextMedia a second time. Instead we
+        // cancel directly: clear the timer and reset state so the 'start' handler does
+        // not bail on the state === PLAYING guard when this media is replayed.
+        if (((_targetRegion2 = targetRegion) === null || _targetRegion2 === void 0 || (_targetRegion2 = _targetRegion2.currMedia) === null || _targetRegion2 === void 0 ? void 0 : _targetRegion2.state) === MediaState.PLAYING) {
+          var interruptedMedia = targetRegion.currMedia;
+          if (interruptedMedia.mediaTimer) {
+            clearInterval(interruptedMedia.mediaTimer);
+            interruptedMedia.mediaTimer = undefined;
+          }
+          interruptedMedia.state = MediaState.CANCELLED;
+        }
+        // Reset complete so the HTML-media guard in playNextMedia() doesn't block
+        // the transition (that guard is for single-media loops, not navWidget injections).
+        if (targetRegion) {
           targetRegion.complete = false;
         }
         // Create media in region and play it next
-        (_targetRegion2 = targetRegion) === null || _targetRegion2 === void 0 || _targetRegion2.mediaObjects.splice(targetRegion.currentMediaIndex + 1, 0, targetMedia);
-        (_targetRegion3 = targetRegion) === null || _targetRegion3 === void 0 || _targetRegion3.playNextMedia();
+        (_targetRegion3 = targetRegion) === null || _targetRegion3 === void 0 || _targetRegion3.mediaObjects.splice(targetRegion.currentMediaIndex + 1, 0, targetMedia);
+        // Keep totalMediaObjects in sync with the actual array length
+        if (targetRegion) {
+          targetRegion.totalMediaObjects = targetRegion.mediaObjects.length;
+        }
+        // Drawer media items are never run through the normal prepareMedia pipeline,
+        // so their DOM element has no background-image / src set and is not yet in the
+        // region DOM. Prepare it now so Media.run() finds a ready element to show.
+        if (targetRegion) {
+          targetRegion.prepareMedia(targetMedia);
+        }
+        console.debug('[ActionController::loadMediaInRegion] Target media loaded, playing next', {
+          regionId: regionId,
+          widgetId: widgetId
+        });
+        (_targetRegion4 = targetRegion) === null || _targetRegion4 === void 0 || _targetRegion4.playNextMedia();
       }
       /** Run action based on action data */
     }, {
       key: "runAction",
       value: function runAction(actionData, options) {
+        // If this layout is no longer active (being cancelled or navigated away from),
+        // discard the action so it doesn't interfere with the outgoing transition.
+        // inLoop is set to false synchronously before finishAllRegions() in all nav paths.
+        if (!this.parent.inLoop) {
+          return;
+        }
+        console.debug('[ActionController::runAction] Triggering action', {
+          actionData: actionData
+        });
         if (actionData.actiontype == 'navLayout') {
           if (this.parent.xlr.config.platform === exports.ConsumerPlatform.CMS) {
-            // Open layout preview in a new tab
+            // Open layout preview in a new tab (CMS preview only)
             this.openLayoutInNewTab(actionData.layoutcode, options);
-          } else if (this.parent.xlr.config.platform === exports.ConsumerPlatform.CHROMEOS) {
-            // Set target layout as active layout
+          } else {
+            // All player platforms (Electron, ChromeOS, Android, etc.)
             this.openLayoutInPlayer(actionData.layoutcode, options);
           }
         } else if ((actionData.actiontype == 'previous' || actionData.actiontype == 'next') && actionData.target == 'region') {
-          this.nextMediaInRegion(actionData.targetid, actionData.actiontype);
+          this.gotoMediaInRegion(actionData.targetid, actionData.actiontype);
         } else if (actionData.actiontype == 'navWidget' && actionData.target == 'region') {
           this.loadMediaInRegion(actionData.targetid, actionData.widgetid);
         } else if (actionData.target === 'screen') {
@@ -75315,35 +75459,53 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           }
         });
       }
+      /** Dispatch an incoming webhook trigger to any matching actions on this layout. */
+    }, {
+      key: "handleWebhookTrigger",
+      value: function handleWebhookTrigger(triggerCode, widgetId) {
+        var _this3 = this;
+        this.$actionController.querySelectorAll('.action[triggertype="webhook"]').forEach(function ($el) {
+          var ds = $el.dataset;
+          if (ds.triggercode !== triggerCode) return;
+          if (widgetId && ds.sourceid !== widgetId) return;
+          _this3.runAction(ds, _this3.options);
+        });
+      }
     }, {
       key: "initKeyboardActions",
       value: function initKeyboardActions() {
         var self = this;
-        // Store actions in a map
         var keyActions = new Map();
-        this.$actionController.querySelectorAll('.action[triggerType="keyPress"]').forEach(function ($el) {
+        this.$actionController.querySelectorAll('.action[triggertype="keyPress"]').forEach(function ($el) {
           var dataset = $el.dataset;
           var code = dataset.triggercode;
           if (code) {
-            // Create an empty array, if not yet set
             if (!keyActions.get(code)) {
               keyActions.set(code, []);
             }
-            // Add new action to array
             keyActions.get(code).push(dataset);
           }
         });
-        // Keyboard listener
-        document.addEventListener('keydown', function (ev) {
+        // Nothing to do if this layout has no keyboard-triggered actions.
+        if (keyActions.size === 0) return;
+        this.keyboardHandler = function (ev) {
           var actions = keyActions.get(ev.code);
-          // Are there action for this key code?
           if (actions) {
-            // Run all actions associated with it
             actions.forEach(function (dataset) {
               self.runAction(dataset, self.options);
             });
           }
-        });
+        };
+        document.addEventListener('keydown', this.keyboardHandler);
+      }
+      /** Remove the keydown listener registered by initKeyboardActions. Call when the layout ends or is cancelled. */
+    }, {
+      key: "removeKeyboardActions",
+      value: function removeKeyboardActions() {
+        if (this.keyboardHandler) {
+          document.removeEventListener('keydown', this.keyboardHandler);
+          this.keyboardHandler = null;
+        }
       }
     }]);
   }();
@@ -75578,6 +75740,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       });
       this.on('end', /*#__PURE__*/function () {
         var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(layout) {
+          var _layout$actionControl;
           var $layout, _$layout$parentElemen;
           return _regeneratorRuntime().wrap(function _callee2$(_context2) {
             while (1) switch (_context2.prev = _context2.next) {
@@ -75636,9 +75799,10 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                 }
                 // Emit layout end event
                 console.debug('>>>>> XLR.debug Awaited XLR::emitSync > End - Calling layoutEnd event');
-                _context2.next = 13;
+                (_layout$actionControl = layout.actionController) === null || _layout$actionControl === void 0 || _layout$actionControl.removeKeyboardActions();
+                _context2.next = 14;
                 return layout.xlr.emitSync('layoutEnd', layout);
-              case 13:
+              case 14:
                 if (_this.xlr.config.platform !== exports.ConsumerPlatform.CMS && layout.inLoop) {
                   // Transition next layout to current layout and prepare next layout if exist
                   _this.xlr.prepareLayouts().then( /*#__PURE__*/function () {
@@ -75668,7 +75832,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                     };
                   }());
                 }
-              case 14:
+              case 15:
               case "end":
                 return _context2.stop();
             }
@@ -75679,9 +75843,11 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         };
       }());
       this.on('cancelled', function (layout) {
+        var _layout$actionControl2;
         console.debug('>>>>> XLR.debug / Layout cancelled > Layout ID > ', layout.id);
         layout.state = exports.ELayoutState.CANCELLED;
         layout.inLoop = false;
+        (_layout$actionControl2 = layout.actionController) === null || _layout$actionControl2 === void 0 || _layout$actionControl2.removeKeyboardActions();
         // Dispose video handlers immediately so their stall watchdogs and error
         // callbacks can't fire against a layout whose DOM is about to be removed.
         var _iterator = _createForOfIteratorHelper(layout.regions),
@@ -75840,7 +76006,8 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           _this2.regions.push(regionObj);
         });
         this.actionController.initTouchActions();
-        this.actionController.initKeyboardActions();
+        // Keyboard actions are registered in run() so the global document listener
+        // is only active while the layout is actually playing, not during background preparation.
       }
     }, {
       key: "run",
@@ -75859,6 +76026,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           shouldParse: false
         });
         if ($layoutContainer) {
+          var _this$actionControlle;
           $layoutContainer.style.setProperty('visibility', 'visible');
           $layoutContainer.style.setProperty('opacity', '1');
           $layoutContainer.style.setProperty('z-index', this.zIndex !== null ? "".concat(this.zIndex) : '1');
@@ -75867,6 +76035,9 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
             // Also set the background color of the player window > body
             document.body.style.setProperty('background-color', "".concat(this.bgColor));
           }
+          // Register keyboard actions now that the layout is active.
+          // Done here (not in parseXlf) so the global listener is scoped to playback time.
+          (_this$actionControlle = this.actionController) === null || _this$actionControlle === void 0 || _this$actionControlle.initKeyboardActions();
           // Emit start event
           this.emitter.emit('start', this);
           // Play regions
@@ -76364,6 +76535,13 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         return _ref4.apply(this, arguments);
       };
     }());
+    xlrObject.on('navLayout', function (layoutCode) {
+      // Non-CMS platforms handle navLayout in their renderer via playInterruptLayout.
+      // CMS navLayout is handled by ActionController (opens layout in a new tab).
+      console.debug('[navLayout] XLR::on("navLayout") - received', {
+        layoutCode: layoutCode
+      });
+    });
     xlrObject.emitSync = /*#__PURE__*/function () {
       var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(eventName) {
         var _xlrObject$emitter$ev;
@@ -76543,35 +76721,28 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
     }));
     xlrObject.updateScheduleLayouts = /*#__PURE__*/function () {
       var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(scheduleLayouts) {
-        var inputLayoutIds, _iterator, _step, _step$value, layoutIndex, _layout, uniqueLayout, _i, _Object$keys, layoutId;
+        var next;
         return _regeneratorRuntime().wrap(function _callee9$(_context9) {
           while (1) switch (_context9.prev = _context9.next) {
             case 0:
-              console.debug('XLR::updateScheduleLayouts > Updating schedule layouts . . .');
-              inputLayoutIds = [];
-              _iterator = _createForOfIteratorHelper(scheduleLayouts.entries());
-              try {
-                for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                  _step$value = _slicedToArray(_step.value, 2), layoutIndex = _step$value[0], _layout = _step$value[1];
-                  uniqueLayout = _layout;
-                  uniqueLayout.index = layoutIndex;
-                  uniqueLayout.id = _layout.layoutId;
-                  this.uniqueLayouts[_layout.layoutId] = uniqueLayout;
-                  inputLayoutIds.push(_layout.layoutId);
-                }
-                // Cross-check if we need to remove non-existing layouts based on inputLayouts
-              } catch (err) {
-                _iterator.e(err);
-              } finally {
-                _iterator.f();
-              }
-              for (_i = 0, _Object$keys = Object.keys(this.uniqueLayouts); _i < _Object$keys.length; _i++) {
-                layoutId = _Object$keys[_i];
-                if (!inputLayoutIds.includes(parseInt(layoutId))) {
-                  delete this.uniqueLayouts[layoutId];
-                }
+              console.debug('XLR::updateScheduleLayouts > Updating schedule layouts . . .', scheduleLayouts);
+              next = new Map();
+              if (!(scheduleLayouts.length === 0)) {
+                _context9.next = 5;
+                break;
               }
+              this.uniqueLayouts = next;
+              return _context9.abrupt("return");
             case 5:
+              scheduleLayouts.forEach(function (_layout, layoutIndex) {
+                next.set(String(_layout.layoutId), _objectSpread2(_objectSpread2({}, _layout), {}, {
+                  index: layoutIndex,
+                  id: _layout.layoutId
+                }));
+              });
+              console.debug('XLR::updateScheduleLayouts > next unique layouts', Array.from(next).values());
+              this.uniqueLayouts = next;
+            case 8:
             case "end":
               return _context9.stop();
           }
@@ -76620,6 +76791,36 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
             case 0:
               console.debug('>>>> XLR.debug XLR::updateLoop > Updating schedule loop . . .');
               this.inputLayouts = inputLayouts;
+              // Guard against a splash-only update: uniqueLayouts has no entry for layoutId 0,
+              // so parseLayouts() would return undefined current/next and prepareLayoutXlf()
+              // would be called with undefined. Clean up any playing layouts and show splash directly.
+              if (!(inputLayouts.length === 1 && inputLayouts[0].layoutId === 0)) {
+                _context11.next = 14;
+                break;
+              }
+              if (!(this.currentLayout && this.isLayoutInDOM(this.currentLayout.containerName, this.currentLayout.index))) {
+                _context11.next = 8;
+                break;
+              }
+              // Force all regions to complete immediately
+              this.currentLayout.inLoop = false;
+              _context11.next = 7;
+              return this.currentLayout.finishAllRegions();
+            case 7:
+              this.currentLayout.removeLayout();
+            case 8:
+              if (this.nextLayout) {
+                // Discard regardless of DOM presence: nextLayout may be preloaded with
+                // DOM elements and video.js players but not yet attached to the screen container.
+                this.nextLayout.discardLayout(exports.LayoutPlaybackType.NEXT);
+              }
+              this.currentLayout = undefined;
+              this.nextLayout = undefined;
+              _context11.next = 13;
+              return this.playSchedules(this);
+            case 13:
+              return _context11.abrupt("return");
+            case 14:
               playback = this.parseLayouts(true);
               isCurrentLayoutValid = isLayoutValid(this.inputLayouts, (_this$currentLayout = this.currentLayout) === null || _this$currentLayout === void 0 ? void 0 : _this$currentLayout.layoutId);
               if (this.isSspEnabled && this.currentLayoutId === -1) {
@@ -76628,7 +76829,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
               if (!isCurrentLayoutValid && this.currentLayout) {
                 this.currentLayout.emitter.emit('cancelled', this.currentLayout);
               }
-              console.debug('>>>>> XLR.debug XLR::updateLoop > uniqueLayouts', this.uniqueLayouts);
+              console.debug('>>>>> XLR.debug XLR::updateLoop > uniqueLayouts', Array.from(this.uniqueLayouts.values()));
               console.debug('>>>>> XLR.debug XLR::updateLoop > inputLayouts', this.inputLayouts);
               console.debug('>>>>> XLR.debug XLR::updateLoop > isCurrentLayoutValid', isCurrentLayoutValid);
               console.debug('>>>>> XLR.debug XLR::updateLoop > currentLayout', this.currentLayout);
@@ -76656,86 +76857,86 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                 };
               }();
               if (isCurrentLayoutValid) {
-                _context11.next = 55;
+                _context11.next = 67;
                 break;
               }
               if (!playback.hasDefaultOnly) {
-                _context11.next = 34;
+                _context11.next = 46;
                 break;
               }
               if (!(this.currentLayout && playback.currentLayout && this.currentLayout.layoutId !== playback.currentLayout.layoutId)) {
-                _context11.next = 20;
+                _context11.next = 32;
                 break;
               }
               this.currentLayout.inLoop = false;
-              _context11.next = 19;
+              _context11.next = 31;
               return this.currentLayout.finishAllRegions();
-            case 19:
+            case 31:
               this.currentLayout.removeLayout();
-            case 20:
+            case 32:
               // Discard old nextLayout before replacing it — same as the
               // other two branches do, otherwise the prepared DOM element
               // and any video.js players are orphaned.
               if (this.nextLayout && this.isLayoutInDOM(this.nextLayout.containerName, this.nextLayout.index)) {
                 this.nextLayout.discardLayout(exports.LayoutPlaybackType.NEXT);
               }
-              _context11.next = 23;
+              _context11.next = 35;
               return this.prepareLayoutXlf(playback.currentLayout);
-            case 23:
+            case 35:
               this.currentLayout = _context11.sent;
               this.currentLayoutId = this.currentLayout.layoutId;
               _context11.t0 = this;
-              _context11.next = 28;
+              _context11.next = 40;
               return this.prepareLayoutXlf(playback.nextLayout);
-            case 28:
+            case 40:
               _context11.t1 = _context11.sent;
-              _context11.next = 31;
+              _context11.next = 43;
               return _context11.t0.prepareForSsp.call(_context11.t0, _context11.t1);
-            case 31:
+            case 43:
               this.nextLayout = _context11.sent;
-              _context11.next = 51;
+              _context11.next = 63;
               break;
-            case 34:
+            case 46:
               if (!(this.currentLayout && this.isLayoutInDOM(this.currentLayout.containerName, this.currentLayout.index))) {
-                _context11.next = 39;
+                _context11.next = 51;
                 break;
               }
               this.currentLayout.inLoop = false;
-              _context11.next = 38;
+              _context11.next = 50;
               return this.currentLayout.finishAllRegions();
-            case 38:
+            case 50:
               this.currentLayout.removeLayout();
-            case 39:
+            case 51:
               if (this.nextLayout && this.isLayoutInDOM(this.nextLayout.containerName, this.nextLayout.index)) {
                 this.nextLayout.discardLayout(exports.LayoutPlaybackType.NEXT);
               }
               if (!playback.currentLayout) {
-                _context11.next = 43;
+                _context11.next = 55;
                 break;
               }
-              _context11.next = 43;
+              _context11.next = 55;
               return prepareNewCurrentLayout();
-            case 43:
+            case 55:
               if (!playback.nextLayout) {
-                _context11.next = 51;
+                _context11.next = 63;
                 break;
               }
               _context11.t2 = this;
-              _context11.next = 47;
+              _context11.next = 59;
               return this.prepareLayoutXlf(playback.nextLayout);
-            case 47:
+            case 59:
               _context11.t3 = _context11.sent;
-              _context11.next = 50;
+              _context11.next = 62;
               return _context11.t2.prepareForSsp.call(_context11.t2, _context11.t3);
-            case 50:
+            case 62:
               this.nextLayout = _context11.sent;
-            case 51:
-              _context11.next = 53;
+            case 63:
+              _context11.next = 65;
               return this.playSchedules(this);
-            case 53:
-              _context11.next = 67;
+            case 65:
+              _context11.next = 79;
               break;
-            case 55:
+            case 67:
               // Remove next layout if it is in the DOM
               if (this.nextLayout && this.isLayoutInDOM(this.nextLayout.containerName, this.nextLayout.index)) {
                 this.nextLayout.discardLayout(exports.LayoutPlaybackType.NEXT);
@@ -76762,22 +76963,22 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
               // nextLayout keeps the cycle in order; the slot after that will be
               // prepared by the normal prepareLayouts() call at transition time.
               if (!playback.currentLayout) {
-                _context11.next = 66;
+                _context11.next = 78;
                 break;
               }
               this.currentLayoutIndex = playback.currentLayoutIndex;
               _context11.t4 = this;
-              _context11.next = 62;
+              _context11.next = 74;
               return this.prepareLayoutXlf(playback.currentLayout);
-            case 62:
+            case 74:
               _context11.t5 = _context11.sent;
-              _context11.next = 65;
+              _context11.next = 77;
               return _context11.t4.prepareForSsp.call(_context11.t4, _context11.t5);
-            case 65:
+            case 77:
               this.nextLayout = _context11.sent;
-            case 66:
+            case 78:
               console.debug('>>>> XLR.debug XLR::updateLoop > updated nextLayout', this.nextLayout);
-            case 67:
+            case 79:
             case "end":
               return _context11.stop();
           }
@@ -76807,7 +77008,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       };
     }();
     xlrObject.parseLayouts = function (hasChanged) {
-      var _this$currentLayout2, _this$currentLayout3;
+      var _this$currentLayout2, _this$currentLayout3, _this$currentLayout4, _this$nextLayout, _currentLayout2, _nextLayout2;
       var _currentLayout;
       var _nextLayout;
       var _hasDefaultOnly = hasDefaultOnly(this.inputLayouts);
@@ -76820,17 +77021,28 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       if (this.isSspEnabled && ((_this$currentLayout3 = this.currentLayout) === null || _this$currentLayout3 === void 0 ? void 0 : _this$currentLayout3.layoutId) === -1) {
         isCurrentLayoutValid = true;
       }
+      console.debug('XLR::parseLayouts', {
+        currentLayoutId: (_this$currentLayout4 = this.currentLayout) === null || _this$currentLayout4 === void 0 ? void 0 : _this$currentLayout4.layoutId,
+        currentLayoutIndex: this.currentLayoutIndex,
+        nextLayoutId: (_this$nextLayout = this.nextLayout) === null || _this$nextLayout === void 0 ? void 0 : _this$nextLayout.layoutId,
+        isCurrentLayoutValid: isCurrentLayoutValid,
+        hasChanged: !!hasChanged,
+        inputLayoutsCount: this.inputLayouts.length,
+        inputLayoutIds: this.inputLayouts.map(function (l) {
+          return l.layoutId;
+        }).join(', ')
+      });
       _currentLayout = this.currentLayout;
       if (this.currentLayout && this.nextLayout) {
         // Both currentLayout and nextLayout has values
         if (hasLayout) {
           if (!isCurrentLayoutValid) {
-            var _this$nextLayout;
+            var _this$nextLayout2;
             // Check if currentLayout.state is PLAYED,
             // then, validate nextLayout and if valid,
             // proceed to nextLayout as new currentLayout
             // Else, go back to first layout in the loop
-            if (this.currentLayout.state === exports.ELayoutState.PLAYED && isLayoutValid(this.inputLayouts, (_this$nextLayout = this.nextLayout) === null || _this$nextLayout === void 0 ? void 0 : _this$nextLayout.layoutId)) {
+            if (this.currentLayout.state === exports.ELayoutState.PLAYED && isLayoutValid(this.inputLayouts, (_this$nextLayout2 = this.nextLayout) === null || _this$nextLayout2 === void 0 ? void 0 : _this$nextLayout2.layoutId)) {
               // Get nextLayout from updated loop
               var tempNextLayoutIndex = getLayoutIndexByLayoutId(this.inputLayouts, this.nextLayout.layoutId);
               _currentLayoutIndex = tempNextLayoutIndex !== null && tempNextLayoutIndex !== void 0 ? tempNextLayoutIndex : 0;
@@ -76874,7 +77086,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                 _nextLayout = setLayoutIndex(_nextLayout, _nextLayoutIndex);
               }
             } else {
-              var _this$currentLayout4, _this$currentLayout5;
+              var _this$currentLayout5, _this$currentLayout6;
               _currentLayout = this.nextLayout;
               _currentLayoutIndex = _currentLayout.index;
               // updateLoop can re-queue the same index that is currently
@@ -76884,7 +77096,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
               // whether the queued next-to-current is at the same index as the
               // layout that just finished, and advance past it so the following
               // slot (e.g. an SSP that now has an ad) becomes current instead.
-              if (this.inputLayouts.length > 1 && (_this$currentLayout4 = this.currentLayout) !== null && _this$currentLayout4 !== void 0 && _this$currentLayout4.done && _currentLayoutIndex === ((_this$currentLayout5 = this.currentLayout) === null || _this$currentLayout5 === void 0 ? void 0 : _this$currentLayout5.index)) {
+              if (this.inputLayouts.length > 1 && (_this$currentLayout5 = this.currentLayout) !== null && _this$currentLayout5 !== void 0 && _this$currentLayout5.done && _currentLayoutIndex === ((_this$currentLayout6 = this.currentLayout) === null || _this$currentLayout6 === void 0 ? void 0 : _this$currentLayout6.index)) {
                 _currentLayoutIndex = (_currentLayoutIndex + 1) % this.inputLayouts.length;
                 _currentLayout = this.getLayout(this.inputLayouts[_currentLayoutIndex]);
                 _currentLayout = setLayoutIndex(_currentLayout, _currentLayoutIndex);
@@ -76921,6 +77133,12 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         _currentLayout.xlr = this;
         _nextLayout.xlr = this;
       }
+      console.debug('XLR::parseLayouts result', {
+        currentLayoutId: (_currentLayout2 = _currentLayout) === null || _currentLayout2 === void 0 ? void 0 : _currentLayout2.layoutId,
+        currentLayoutIndex: _currentLayoutIndex,
+        nextLayoutId: (_nextLayout2 = _nextLayout) === null || _nextLayout2 === void 0 ? void 0 : _nextLayout2.layoutId,
+        nextLayoutIndex: _nextLayoutIndex
+      });
       return {
         currentLayout: _currentLayout,
         nextLayout: _nextLayout,
@@ -76932,7 +77150,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
     };
     xlrObject.getLayout = function (inputLayout) {
       var isCMS = this.config.platform === exports.ConsumerPlatform.CMS;
-      if (!isCMS && Object.keys(this.uniqueLayouts).length === 0) {
+      if (!isCMS && this.uniqueLayouts.size === 0) {
         return;
       }
       var _layout = {};
@@ -76949,7 +77167,13 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
               activeLayout.id = activeLayout.layoutId;
             }
           } else {
-            activeLayout = _objectSpread2({}, this.uniqueLayouts[inputLayout.layoutId]);
+            var layoutFromUniqueLayouts = this.uniqueLayouts.get(String(inputLayout.layoutId));
+            console.debug('XLR::getLayout > layoutFromUniqueLayouts', {
+              layoutFromUniqueLayouts: layoutFromUniqueLayouts,
+              inputLayout: inputLayout,
+              uniqueLayouts: this.uniqueLayouts
+            });
+            activeLayout = layoutFromUniqueLayouts ? _objectSpread2({}, layoutFromUniqueLayouts) : _objectSpread2({}, inputLayout);
           }
           _layout = _objectSpread2(_objectSpread2({}, _layout), activeLayout);
           console.debug('XLR::getLayout > activeLayout from uniqueLayouts', {
@@ -76966,10 +77190,10 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       return iLayout;
     };
     xlrObject.getLayoutById = function (layoutId, layoutIndex) {
-      if (!layoutId || Object.keys(this.uniqueLayouts).length === 0) {
+      if (!layoutId || this.uniqueLayouts.size === 0 || !this.uniqueLayouts.has(String(layoutId))) {
         return undefined;
       }
-      var _layout = _objectSpread2(_objectSpread2({}, initialLayout), this.uniqueLayouts[layoutId]);
+      var _layout = _objectSpread2(_objectSpread2({}, initialLayout), this.uniqueLayouts.get(String(layoutId)));
       // Set layout index if available
       if (layoutIndex) {
         _layout.index = layoutIndex;
@@ -76977,71 +77201,79 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
       return _layout;
     };
     xlrObject.prepareLayouts = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
-      var _layoutPlayback$curre, _layoutPlayback$curre2;
+      var _layoutPlayback$curre, _layoutPlayback$nextL, _layoutPlayback$curre2, _layoutPlayback$curre3, _layouts$, _layouts$2, _layouts$3, _layouts$4;
       var self, layoutPlayback, currentLayoutXlf, wasCurrentReused, nextLayoutXlf, layouts;
       return _regeneratorRuntime().wrap(function _callee14$(_context14) {
         while (1) switch (_context14.prev = _context14.next) {
           case 0:
             self = xlrObject;
             if (!this.isUpdatingLoop) {
-              _context14.next = 3;
+              _context14.next = 4;
               break;
             }
+            console.debug('XLR::prepareLayouts - skipped (isUpdatingLoop)');
             return _context14.abrupt("return", Promise.resolve(self));
-          case 3:
+          case 4:
             layoutPlayback = self.parseLayouts(); // Don't prepare layout if it's just the splash screen
             if (!(self.inputLayouts.length === 1 && self.inputLayouts[0].layoutId === 0)) {
-              _context14.next = 6;
+              _context14.next = 8;
               break;
             }
+            console.debug('XLR::prepareLayouts - skipped (splash screen only)');
             return _context14.abrupt("return", Promise.resolve(self));
-          case 6:
-            console.debug('??? XLR.debug prepareLayouts::playback', {
-              layoutPlayback: layoutPlayback,
-              shouldParse: false
+          case 8:
+            console.debug('XLR::prepareLayouts', {
+              currentLayoutId: (_layoutPlayback$curre = layoutPlayback.currentLayout) === null || _layoutPlayback$curre === void 0 ? void 0 : _layoutPlayback$curre.layoutId,
+              currentLayoutIndex: layoutPlayback.currentLayoutIndex,
+              nextLayoutId: (_layoutPlayback$nextL = layoutPlayback.nextLayout) === null || _layoutPlayback$nextL === void 0 ? void 0 : _layoutPlayback$nextL.layoutId,
+              nextLayoutIndex: layoutPlayback.nextLayoutIndex
             });
-            self.currentLayoutId = (_layoutPlayback$curre = layoutPlayback.currentLayout) === null || _layoutPlayback$curre === void 0 ? void 0 : _layoutPlayback$curre.layoutId;
+            self.currentLayoutId = (_layoutPlayback$curre2 = layoutPlayback.currentLayout) === null || _layoutPlayback$curre2 === void 0 ? void 0 : _layoutPlayback$curre2.layoutId;
             // Only reuse the existing Layout instance if it is fully healthy —
             // a done=true instance was removed from the DOM (e.g. an SSP slot that
             // had no ad), and an empty-XLF instance has no regions so it can never
             // advance the cycle.  In either case re-prepare from scratch so we get
             // a fresh request (which may now have a valid ad / XLF).
-            if (!((_layoutPlayback$curre2 = layoutPlayback.currentLayout) !== null && _layoutPlayback$curre2 !== void 0 && _layoutPlayback$curre2.layoutNode && !layoutPlayback.currentLayout.done && layoutPlayback.currentLayout.xlfString !== '')) {
-              _context14.next = 12;
+            if (!((_layoutPlayback$curre3 = layoutPlayback.currentLayout) !== null && _layoutPlayback$curre3 !== void 0 && _layoutPlayback$curre3.layoutNode && !layoutPlayback.currentLayout.done && layoutPlayback.currentLayout.xlfString !== '')) {
+              _context14.next = 14;
               break;
             }
             _context14.t0 = layoutPlayback.currentLayout;
-            _context14.next = 15;
+            _context14.next = 17;
             break;
-          case 12:
-            _context14.next = 14;
-            return self.prepareLayoutXlf(layoutPlayback.currentLayout);
           case 14:
+            _context14.next = 16;
+            return self.prepareLayoutXlf(layoutPlayback.currentLayout);
+          case 16:
             _context14.t0 = _context14.sent;
-          case 15:
+          case 17:
             currentLayoutXlf = _context14.t0;
             // True when the same object was returned (reused); false when a fresh
             // Layout was constructed by prepareLayoutXlf above.
             wasCurrentReused = currentLayoutXlf === layoutPlayback.currentLayout;
-            _context14.next = 19;
+            _context14.next = 21;
             return self.prepareLayoutXlf(layoutPlayback.nextLayout);
-          case 19:
+          case 21:
             nextLayoutXlf = _context14.sent;
             _context14.t1 = Promise;
             _context14.t2 = currentLayoutXlf;
-            _context14.next = 24;
+            _context14.next = 26;
             return self.prepareForSsp(nextLayoutXlf);
-          case 24:
+          case 26:
             _context14.t3 = _context14.sent;
             _context14.t4 = [_context14.t2, _context14.t3];
-            _context14.next = 28;
+            _context14.next = 30;
             return _context14.t1.all.call(_context14.t1, _context14.t4);
-          case 28:
+          case 30:
             layouts = _context14.sent;
             if (!(self.isUpdatingLoop || layouts[0].done)) {
-              _context14.next = 33;
+              _context14.next = 36;
               break;
             }
+            console.debug('XLR::prepareLayouts - aborted (concurrent updateLoop)', {
+              isUpdatingLoop: self.isUpdatingLoop,
+              currentLayoutDone: layouts[0].done
+            });
             // If currentLayout was freshly prepared (not reused from nextLayout),
             // its DOM element was just appended — discard it now so it does not
             // accumulate in screen_container. Also disposes any video.js players
@@ -77053,8 +77285,14 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
               nextLayoutXlf.discardLayout(exports.LayoutPlaybackType.NEXT);
             }
             return _context14.abrupt("return", Promise.resolve(self));
-          case 33:
-            console.debug('>>>>> XLR.debug prepared layout XLF', layouts);
+          case 36:
+            console.debug('XLR::prepareLayouts - layouts prepared', {
+              currentLayoutId: (_layouts$ = layouts[0]) === null || _layouts$ === void 0 ? void 0 : _layouts$.layoutId,
+              currentLayoutIndex: (_layouts$2 = layouts[0]) === null || _layouts$2 === void 0 ? void 0 : _layouts$2.index,
+              nextLayoutId: (_layouts$3 = layouts[1]) === null || _layouts$3 === void 0 ? void 0 : _layouts$3.layoutId,
+              nextLayoutIndex: (_layouts$4 = layouts[1]) === null || _layouts$4 === void 0 ? void 0 : _layouts$4.index,
+              currentReused: wasCurrentReused
+            });
             return _context14.abrupt("return", new Promise( /*#__PURE__*/function () {
               var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(resolve) {
                 return _regeneratorRuntime().wrap(function _callee13$(_context13) {
@@ -77088,7 +77326,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                 return _ref14.apply(this, arguments);
               };
             }()));
-          case 35:
+          case 38:
           case "end":
             return _context14.stop();
         }
@@ -77251,33 +77489,48 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
         return _ref16.apply(this, arguments);
       };
     }();
+    // Shared re-entry guard for all layout navigation methods.
+    // Prevents a double-tap from advancing two layouts at once.
+    var isNavigatingLayout = false;
     xlrObject.gotoPrevLayout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
       var _this4 = this;
-      var _currentLayoutIndex, _assumedPrevIndex, _this$currentLayout6;
+      var _currentLayoutIndex, _assumedPrevIndex, _this$currentLayout7;
       return _regeneratorRuntime().wrap(function _callee18$(_context18) {
         while (1) switch (_context18.prev = _context18.next) {
           case 0:
+            if (!isNavigatingLayout) {
+              _context18.next = 2;
+              break;
+            }
+            return _context18.abrupt("return");
+          case 2:
+            isNavigatingLayout = true;
+            _context18.prev = 3;
             _currentLayoutIndex = this.currentLayoutIndex;
             _assumedPrevIndex = _currentLayoutIndex - 1; // If previous layout is same as current layout or
             // if there's only one layout, do nothing
             if (!(_assumedPrevIndex < 0)) {
-              _context18.next = 4;
+              _context18.next = 8;
               break;
             }
             return _context18.abrupt("return");
-          case 4:
+          case 8:
             console.debug('XLR::gotoPrevLayout', {
-              previousLayoutIndex: _assumedPrevIndex,
-              method: 'XLR::gotoPrevLayout',
-              shouldParse: false
+              previousLayoutIndex: _assumedPrevIndex
             });
             if (!Boolean(this.inputLayouts[_assumedPrevIndex])) {
-              _context18.next = 10;
+              _context18.next = 15;
               break;
             }
-            _context18.next = 8;
-            return (_this$currentLayout6 = this.currentLayout) === null || _this$currentLayout6 === void 0 ? void 0 : _this$currentLayout6.finishAllRegions();
-          case 8:
+            // Prevent the natural layout-end handler from also calling
+            // prepareLayouts() when finishAllRegions() causes the layout
+            // 'end' event to fire.
+            if (this.currentLayout) {
+              this.currentLayout.inLoop = false;
+            }
+            _context18.next = 13;
+            return (_this$currentLayout7 = this.currentLayout) === null || _this$currentLayout7 === void 0 ? void 0 : _this$currentLayout7.finishAllRegions();
+          case 13:
             // and set the previous layout as current layout
             this.currentLayoutIndex = _assumedPrevIndex;
             this.prepareLayouts().then( /*#__PURE__*/function () {
@@ -77297,30 +77550,366 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
                 return _ref18.apply(this, arguments);
               };
             }());
-          case 10:
+          case 15:
+            _context18.prev = 15;
+            isNavigatingLayout = false;
+            return _context18.finish(15);
+          case 18:
           case "end":
             return _context18.stop();
         }
-      }, _callee18, this);
+      }, _callee18, this, [[3,, 15, 18]]);
     }));
-    xlrObject.gotoNextLayout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
-      var _xlrObject$currentLay2;
-      return _regeneratorRuntime().wrap(function _callee19$(_context19) {
-        while (1) switch (_context19.prev = _context19.next) {
+    xlrObject.gotoNextLayout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20() {
+      var _this5 = this;
+      var _this$currentLayout8, nextIndex;
+      return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
           case 0:
+            if (!isNavigatingLayout) {
+              _context20.next = 2;
+              break;
+            }
+            return _context20.abrupt("return");
+          case 2:
+            isNavigatingLayout = true;
+            _context20.prev = 3;
+            nextIndex = this.currentLayoutIndex + 1;
+            if (Boolean(this.inputLayouts[nextIndex])) {
+              _context20.next = 7;
+              break;
+            }
+            return _context20.abrupt("return");
+          case 7:
             console.debug('XLR::gotoNextLayout', {
-              nextLayoutIndex: this.currentLayoutIndex + 1,
-              method: 'XLR::gotoNextLayout',
-              shouldParse: false
+              nextLayoutIndex: nextIndex
             });
-            _context19.next = 3;
-            return (_xlrObject$currentLay2 = xlrObject.currentLayout) === null || _xlrObject$currentLay2 === void 0 ? void 0 : _xlrObject$currentLay2.finishAllRegions();
-          case 3:
+            if (this.currentLayout) {
+              this.currentLayout.inLoop = false;
+            }
+            _context20.next = 11;
+            return (_this$currentLayout8 = this.currentLayout) === null || _this$currentLayout8 === void 0 ? void 0 : _this$currentLayout8.finishAllRegions();
+          case 11:
+            this.currentLayoutIndex = nextIndex;
+            this.prepareLayouts().then( /*#__PURE__*/function () {
+              var _ref20 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(xlr) {
+                return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+                  while (1) switch (_context19.prev = _context19.next) {
+                    case 0:
+                      _context19.next = 2;
+                      return _this5.playSchedules(xlr);
+                    case 2:
+                    case "end":
+                      return _context19.stop();
+                  }
+                }, _callee19);
+              }));
+              return function (_x14) {
+                return _ref20.apply(this, arguments);
+              };
+            }());
+          case 13:
+            _context20.prev = 13;
+            isNavigatingLayout = false;
+            return _context20.finish(13);
+          case 16:
           case "end":
-            return _context19.stop();
+            return _context20.stop();
         }
-      }, _callee19, this);
+      }, _callee20, this, [[3,, 13, 16]]);
     }));
+    xlrObject.gotoLayoutByCode = /*#__PURE__*/function () {
+      var _ref21 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(layoutCode) {
+        var _this6 = this;
+        var _this$currentLayout9, targetIndex, parsedLayouts, _loop, _ret, _i, _parsedLayouts, parser, i, _inputLayout$getXlf, _doc$documentElement, inputLayout, xlfString, url, res, doc, foundCode;
+        return _regeneratorRuntime().wrap(function _callee22$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              if (!isNavigatingLayout) {
+                _context23.next = 2;
+                break;
+              }
+              return _context23.abrupt("return");
+            case 2:
+              isNavigatingLayout = true;
+              _context23.prev = 3;
+              targetIndex = -1; // 1. Check the two already-parsed layouts first (zero fetch cost)
+              parsedLayouts = [this.layouts['current'], this.layouts['next']];
+              _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+                var _layout$layoutNode;
+                var layout, code;
+                return _regeneratorRuntime().wrap(function _loop$(_context21) {
+                  while (1) switch (_context21.prev = _context21.next) {
+                    case 0:
+                      layout = _parsedLayouts[_i];
+                      if (layout) {
+                        _context21.next = 3;
+                        break;
+                      }
+                      return _context21.abrupt("return", 0);
+                    case 3:
+                      code = (_layout$layoutNode = layout.layoutNode) === null || _layout$layoutNode === void 0 || (_layout$layoutNode = _layout$layoutNode.documentElement) === null || _layout$layoutNode === void 0 ? void 0 : _layout$layoutNode.getAttribute('code');
+                      if (!(code === layoutCode)) {
+                        _context21.next = 7;
+                        break;
+                      }
+                      targetIndex = _this6.inputLayouts.findIndex(function (i) {
+                        return i.layoutId === layout.layoutId;
+                      });
+                      return _context21.abrupt("return", 1);
+                    case 7:
+                    case "end":
+                      return _context21.stop();
+                  }
+                }, _loop);
+              });
+              _i = 0, _parsedLayouts = parsedLayouts;
+            case 8:
+              if (!(_i < _parsedLayouts.length)) {
+                _context23.next = 18;
+                break;
+              }
+              return _context23.delegateYield(_loop(), "t0", 10);
+            case 10:
+              _ret = _context23.t0;
+              if (!(_ret === 0)) {
+                _context23.next = 13;
+                break;
+              }
+              return _context23.abrupt("continue", 15);
+            case 13:
+              if (!(_ret === 1)) {
+                _context23.next = 15;
+                break;
+              }
+              return _context23.abrupt("break", 18);
+            case 15:
+              _i++;
+              _context23.next = 8;
+              break;
+            case 18:
+              if (!(targetIndex === -1)) {
+                _context23.next = 60;
+                break;
+              }
+              parser = new DOMParser();
+              i = 0;
+            case 21:
+              if (!(i < this.inputLayouts.length)) {
+                _context23.next = 60;
+                break;
+              }
+              inputLayout = this.inputLayouts[i]; // Fast check: code pre-populated by the player (no fetch needed)
+              if (!(inputLayout.code !== undefined)) {
+                _context23.next = 28;
+                break;
+              }
+              if (!(inputLayout.code === layoutCode)) {
+                _context23.next = 27;
+                break;
+              }
+              targetIndex = i;
+              return _context23.abrupt("break", 60);
+            case 27:
+              return _context23.abrupt("continue", 57);
+            case 28:
+              xlfString = void 0; // Prefer getXlf() when available (e.g. CMS platform)
+              xlfString = (_inputLayout$getXlf = inputLayout.getXlf) === null || _inputLayout$getXlf === void 0 ? void 0 : _inputLayout$getXlf.call(inputLayout);
+              // Otherwise fetch from the local file server (Electron / ChromeOS)
+              if (!(!xlfString && this.config.appHost && inputLayout.path)) {
+                _context23.next = 49;
+                break;
+              }
+              url = this.config.appHost + inputLayout.path;
+              console.debug('[gotoLayoutByCode] Fetching XLF for layoutId', inputLayout.layoutId, url);
+              _context23.prev = 33;
+              _context23.next = 36;
+              return fetch(url);
+            case 36:
+              res = _context23.sent;
+              if (res.ok) {
+                _context23.next = 40;
+                break;
+              }
+              console.debug('[gotoLayoutByCode] Fetch non-OK', res.status, url);
+              return _context23.abrupt("continue", 57);
+            case 40:
+              _context23.next = 42;
+              return res.text();
+            case 42:
+              xlfString = _context23.sent;
+              _context23.next = 49;
+              break;
+            case 45:
+              _context23.prev = 45;
+              _context23.t1 = _context23["catch"](33);
+              console.debug('[gotoLayoutByCode] Fetch error for', url, _context23.t1);
+              return _context23.abrupt("continue", 57);
+            case 49:
+              if (xlfString) {
+                _context23.next = 52;
+                break;
+              }
+              console.debug('[gotoLayoutByCode] No XLF for layoutId', inputLayout.layoutId, 'path:', inputLayout.path);
+              return _context23.abrupt("continue", 57);
+            case 52:
+              doc = parser.parseFromString(xlfString, 'text/xml');
+              foundCode = (_doc$documentElement = doc.documentElement) === null || _doc$documentElement === void 0 ? void 0 : _doc$documentElement.getAttribute('code');
+              if (!(foundCode === layoutCode)) {
+                _context23.next = 57;
+                break;
+              }
+              targetIndex = i;
+              return _context23.abrupt("break", 60);
+            case 57:
+              i++;
+              _context23.next = 21;
+              break;
+            case 60:
+              if (!(targetIndex === -1)) {
+                _context23.next = 63;
+                break;
+              }
+              console.warn('XLR::gotoLayoutByCode - layout not found for code:', layoutCode);
+              return _context23.abrupt("return");
+            case 63:
+              console.debug('XLR::gotoLayoutByCode', {
+                layoutCode: layoutCode,
+                targetIndex: targetIndex
+              });
+              // Prevent the natural layout-end handler from racing with our own
+              // prepareLayouts() call (same pattern as gotoPrevLayout/gotoNextLayout).
+              if (this.currentLayout) {
+                this.currentLayout.inLoop = false;
+              }
+              _context23.next = 67;
+              return (_this$currentLayout9 = this.currentLayout) === null || _this$currentLayout9 === void 0 ? void 0 : _this$currentLayout9.finishAllRegions();
+            case 67:
+              this.currentLayoutIndex = targetIndex;
+              this.prepareLayouts().then( /*#__PURE__*/function () {
+                var _ref22 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(xlr) {
+                  return _regeneratorRuntime().wrap(function _callee21$(_context22) {
+                    while (1) switch (_context22.prev = _context22.next) {
+                      case 0:
+                        _context22.next = 2;
+                        return _this6.playSchedules(xlr);
+                      case 2:
+                      case "end":
+                        return _context22.stop();
+                    }
+                  }, _callee21);
+                }));
+                return function (_x16) {
+                  return _ref22.apply(this, arguments);
+                };
+              }());
+            case 69:
+              _context23.prev = 69;
+              isNavigatingLayout = false;
+              return _context23.finish(69);
+            case 72:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee22, this, [[3,, 69, 72], [33, 45]]);
+      }));
+      return function (_x15) {
+        return _ref21.apply(this, arguments);
+      };
+    }();
+    xlrObject.playInterruptLayout = /*#__PURE__*/function () {
+      var _ref23 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(inputLayout) {
+        var _this7 = this;
+        var _this$currentLayout10, _this$currentLayout11, resumeIndex, savedNextLayout, interruptKey, wasInUniqueLayouts, interruptILayout, cleanup;
+        return _regeneratorRuntime().wrap(function _callee23$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              if (!isNavigatingLayout) {
+                _context24.next = 2;
+                break;
+              }
+              return _context24.abrupt("return");
+            case 2:
+              isNavigatingLayout = true;
+              _context24.prev = 3;
+              resumeIndex = this.currentLayoutIndex; // Save B (the layout that was queued to play after A) before stopping A.
+              // After the interrupt ends, parseLayouts() will use this to resume the loop.
+              savedNextLayout = this.nextLayout;
+              console.debug('[navLayout] XLR::playInterruptLayout - Starting interrupt', {
+                interruptLayoutId: inputLayout.layoutId,
+                resumeIndex: resumeIndex,
+                currentLayoutId: (_this$currentLayout10 = this.currentLayout) === null || _this$currentLayout10 === void 0 ? void 0 : _this$currentLayout10.layoutId,
+                resumeNextLayoutId: savedNextLayout === null || savedNextLayout === void 0 ? void 0 : savedNextLayout.layoutId
+              });
+              // Prevent A's end handler from calling prepareLayouts (we take over).
+              if (this.currentLayout) {
+                this.currentLayout.inLoop = false;
+              }
+              _context24.next = 10;
+              return (_this$currentLayout11 = this.currentLayout) === null || _this$currentLayout11 === void 0 ? void 0 : _this$currentLayout11.finishAllRegions();
+            case 10:
+              // Register interrupt in uniqueLayouts so getLayout()/prepareLayoutXlf() resolve it.
+              // Do NOT splice into inputLayouts — keeping the original loop intact means
+              // parseLayouts() will see the interrupt as "not in loop" (isCurrentLayoutValid=false)
+              // after it ends, and will correctly advance to savedNextLayout (B).
+              interruptKey = String(inputLayout.layoutId);
+              wasInUniqueLayouts = this.uniqueLayouts.has(interruptKey);
+              if (!wasInUniqueLayouts) {
+                this.uniqueLayouts.set(interruptKey, _objectSpread2(_objectSpread2({}, inputLayout), {}, {
+                  index: resumeIndex,
+                  id: inputLayout.layoutId
+                }));
+              }
+              // Prepare the interrupt ILayout (fetches XLF, builds regions).
+              _context24.next = 15;
+              return this.prepareLayoutXlf(this.getLayout(inputLayout));
+            case 15:
+              interruptILayout = _context24.sent;
+              // Wire into XLR so playLayouts picks up the interrupt as current.
+              // inLoop=true lets the interrupt's own end handler call prepareLayouts normally.
+              interruptILayout.inLoop = true;
+              this.layouts.current = interruptILayout;
+              this.currentLayout = interruptILayout;
+              this.currentLayoutId = interruptILayout.layoutId;
+              // Restore nextLayout to B so after the interrupt ends, parseLayouts() resumes
+              // the original loop from B (since interrupt.layoutId is not in inputLayouts,
+              // parseLayouts sees it as invalid and advances to nextLayout).
+              if (savedNextLayout) {
+                this.layouts.next = savedNextLayout;
+                this.nextLayout = savedNextLayout;
+              }
+              // Remove interrupt from uniqueLayouts once it ends.
+              cleanup = this.emitter.on('layoutEnd', function (endedLayout) {
+                if (endedLayout !== interruptILayout) return;
+                cleanup();
+                if (!wasInUniqueLayouts) {
+                  _this7.uniqueLayouts["delete"](interruptKey);
+                }
+                console.debug('[navLayout] XLR::playInterruptLayout - Interrupt ended, resuming loop', {
+                  interruptLayoutId: inputLayout.layoutId,
+                  resumeNextLayoutId: savedNextLayout === null || savedNextLayout === void 0 ? void 0 : savedNextLayout.layoutId
+                });
+              });
+              _context24.next = 24;
+              return this.playSchedules(xlrObject);
+            case 24:
+              _context24.prev = 24;
+              isNavigatingLayout = false;
+              return _context24.finish(24);
+            case 27:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee23, this, [[3,, 24, 27]]);
+      }));
+      return function (_x17) {
+        return _ref23.apply(this, arguments);
+      };
+    }();
+    xlrObject.triggerAction = function (triggerCode, widgetId) {
+      var _this$currentLayout12;
+      (_this$currentLayout12 = this.currentLayout) === null || _this$currentLayout12 === void 0 || (_this$currentLayout12 = _this$currentLayout12.actionController) === null || _this$currentLayout12 === void 0 || _this$currentLayout12.handleWebhookTrigger(triggerCode, widgetId);
+    };
     xlrObject.updateInputLayout = function (layoutIndex, layout) {
       var xlrInputLayout = this.inputLayouts[layoutIndex];
       if (layout !== null) {