@xibosignage/xibo-layout-renderer 1.0.27 → 1.0.29

package/dist/xibo-layout-renderer.cjs.js

@@ -20,30 +20,6 @@ function _isNativeReflectConstruct() {
     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) {
@@ -522,18 +498,12 @@ function _possibleConstructorReturn(self, call) {
   }
   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);
 }
@@ -553,9 +523,6 @@ function _arrayLikeToArray$1(arr, len) {
 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) {
@@ -1062,6 +1029,13 @@ var initialXlr = {
   },
   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({});
   },
@@ -1100,7 +1074,7 @@ var initialXlr = {
   renderOverlayLayouts: function renderOverlayLayouts() {
     return Promise.resolve();
   },
-  uniqueLayouts: {},
+  uniqueLayouts: new Map(),
   updateInputLayout: function updateInputLayout(layoutIndex, layout) {},
   updateLayouts: function updateLayouts(inputLayouts) {},
   updateLoop: function updateLoop(inputLayouts) {
@@ -14020,11 +13994,11 @@ function normalizeLineEndings(input) {
  * @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
@@ -14271,9 +14245,9 @@ function appendElement (hander,node) {
 
 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 */
 
@@ -16897,7 +16871,7 @@ const stringToMpdXml = manifestString => {
     throw new Error(errors.DASH_EMPTY_MANIFEST);
   }
 
-  const parser = new DOMParser();
+  const parser = new DOMParser$1();
   let xml;
   let mpd;
 
@@ -73602,7 +73576,7 @@ function createMediaElement(mediaObject) {
     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") {
@@ -73750,8 +73724,6 @@ function prepareAudioMedia(media, region) {
   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
@@ -73763,14 +73735,16 @@ function prepareHtmlMedia(media, region) {
       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;
@@ -74026,14 +74000,13 @@ var Media = /*#__PURE__*/function () {
           _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);
       }
@@ -74079,7 +74052,12 @@ var Media = /*#__PURE__*/function () {
         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;
@@ -74109,7 +74087,12 @@ var Media = /*#__PURE__*/function () {
         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();
@@ -74118,6 +74101,10 @@ var Media = /*#__PURE__*/function () {
     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;
@@ -74342,11 +74329,11 @@ var Media = /*#__PURE__*/function () {
       };
       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;
         }
@@ -74612,15 +74599,21 @@ var Region = /*#__PURE__*/function () {
       });
       // 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));
             }
           });
         }
@@ -74652,6 +74645,11 @@ var Region = /*#__PURE__*/function () {
         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);
+        }
       }
     }
   }, {
@@ -74875,7 +74873,17 @@ var Region = /*#__PURE__*/function () {
   }, {
     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,
@@ -74895,8 +74903,10 @@ var Region = /*#__PURE__*/function () {
       // 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
@@ -74942,6 +74952,25 @@ var Region = /*#__PURE__*/function () {
           }
         });
       }
+      // 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,
@@ -74951,25 +74980,41 @@ var Region = /*#__PURE__*/function () {
         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);
     }
   }, {
@@ -75046,6 +75091,7 @@ var ActionController = /*#__PURE__*/function () {
     _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;
@@ -75168,6 +75214,10 @@ var ActionController = /*#__PURE__*/function () {
     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({
@@ -75180,41 +75230,78 @@ var ActionController = /*#__PURE__*/function () {
     }
   }, {
     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;
@@ -75237,27 +75324,84 @@ var ActionController = /*#__PURE__*/function () {
         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') {
@@ -75316,35 +75460,53 @@ var ActionController = /*#__PURE__*/function () {
         }
       });
     }
+    /** 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;
+      }
     }
   }]);
 }();
@@ -75579,6 +75741,7 @@ var Layout = /*#__PURE__*/function () {
     });
     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) {
@@ -75637,9 +75800,10 @@ var Layout = /*#__PURE__*/function () {
               }
               // 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 () {
@@ -75669,7 +75833,7 @@ var Layout = /*#__PURE__*/function () {
                   };
                 }());
               }
-            case 14:
+            case 15:
             case "end":
               return _context2.stop();
           }
@@ -75680,9 +75844,11 @@ var Layout = /*#__PURE__*/function () {
       };
     }());
     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),
@@ -75841,7 +76007,8 @@ var Layout = /*#__PURE__*/function () {
         _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",
@@ -75860,6 +76027,7 @@ var Layout = /*#__PURE__*/function () {
         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');
@@ -75868,6 +76036,9 @@ var Layout = /*#__PURE__*/function () {
           // 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
@@ -76365,6 +76536,13 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
       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;
@@ -76544,35 +76722,28 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
   }));
   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();
         }
@@ -76621,6 +76792,36 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
           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) {
@@ -76629,7 +76830,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
             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);
@@ -76657,86 +76858,86 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
               };
             }();
             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);
@@ -76763,22 +76964,22 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
             // 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();
         }
@@ -76808,7 +77009,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
     };
   }();
   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);
@@ -76821,17 +77022,28 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
     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;
@@ -76875,7 +77087,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
               _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
@@ -76885,7 +77097,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
             // 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);
@@ -76922,6 +77134,12 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
       _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,
@@ -76933,7 +77151,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
   };
   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 = {};
@@ -76950,7 +77168,13 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
             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', {
@@ -76967,10 +77191,10 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
     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;
@@ -76978,71 +77202,79 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
     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
@@ -77054,8 +77286,14 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
             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) {
@@ -77089,7 +77327,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
               return _ref14.apply(this, arguments);
             };
           }()));
-        case 35:
+        case 38:
         case "end":
           return _context14.stop();
       }
@@ -77252,33 +77490,48 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
       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 () {
@@ -77298,30 +77551,366 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
               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) {