@xibosignage/xibo-layout-renderer 1.0.26 → 1.0.28

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) {
@@ -756,6 +723,7 @@ var initialRegion = {
   options: {},
   playNextMedia: function playNextMedia() {},
   playPreviousMedia: function playPreviousMedia() {},
+  prepareMedia: function prepareMedia(_media) {},
   prepareMediaObjects: function prepareMediaObjects() {},
   prepareRegion: function prepareRegion() {},
   ready: false,
@@ -1061,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({});
   },
@@ -1099,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) {
@@ -14019,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
@@ -14270,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 */
 
@@ -16896,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;
 
@@ -73986,6 +73961,9 @@ var Media = /*#__PURE__*/function () {
     _defineProperty(this, "xml", null);
     _defineProperty(this, "videoHandler", void 0);
     _defineProperty(this, "mediaTimer", void 0);
+    _defineProperty(this, "sspImpressionUrls", undefined);
+    _defineProperty(this, "sspErrorUrls", undefined);
+    _defineProperty(this, "isSspWidget", false);
     _defineProperty(this, "mediaTimeCount", 0);
     _defineProperty(this, "xlr", {});
     _defineProperty(this, "statsBC", new BroadcastChannel('statsBC'));
@@ -74022,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);
       }
@@ -74071,6 +74048,10 @@ var Media = /*#__PURE__*/function () {
         layoutId: media.region.layout.id
       });
       _this.xlr.emitter.emit('widgetEnd', parseInt(media.id));
+      if (_this.isSspWidget) {
+        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();
     });
     this.on('cancelled', function (media) {
@@ -74097,7 +74078,16 @@ var Media = /*#__PURE__*/function () {
         layoutId: media.region.layout.id
       });
       _this.xlr.emitter.emit('widgetEnd', parseInt(media.id));
-      media.region.playNextMedia();
+      if (_this.isSspWidget) {
+        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);
+      }
+      // 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();
@@ -74197,26 +74187,33 @@ var Media = /*#__PURE__*/function () {
       if (this.mediaType === 'image' || this.mediaType === 'video') {
         resourceUrlParams.mediaType = this.mediaType;
       }
-      var tmpUrl = '';
-      if (this.xlr.config.platform === exports.ConsumerPlatform.CMS) {
-        tmpUrl = composeResourceUrlByPlatform(this.xlr.config, resourceUrlParams);
-      } else if (this.xlr.config.platform === exports.ConsumerPlatform.CHROMEOS) {
-        tmpUrl = composeResourceUrl(this.xlr.config, resourceUrlParams);
-        if (this.mediaType === 'image' || this.mediaType === 'video' || this.mediaType === 'audio') {
-          tmpUrl = composeMediaUrl(resourceUrlParams);
+      // SSP widget: URL is not known until the consumer resolves an ad at play-time.
+      // Skip all URL composition and leave url as null.
+      if (this.mediaType === 'ssp') {
+        this.url = null;
+        this.isSspWidget = true;
+      } else {
+        var tmpUrl = '';
+        if (this.xlr.config.platform === exports.ConsumerPlatform.CMS) {
+          tmpUrl = composeResourceUrlByPlatform(this.xlr.config, resourceUrlParams);
+        } else if (this.xlr.config.platform === exports.ConsumerPlatform.CHROMEOS) {
+          tmpUrl = composeResourceUrl(this.xlr.config, resourceUrlParams);
+          if (this.mediaType === 'image' || this.mediaType === 'video' || this.mediaType === 'audio') {
+            tmpUrl = composeMediaUrl(resourceUrlParams);
+            // this is an SSP Layout
+            if (this.region.layout.layoutId === -1) {
+              tmpUrl = this.uri;
+            }
+          }
+        } else if (this.xlr.config.platform === exports.ConsumerPlatform.ELECTRON) {
+          tmpUrl = composeResourceUrlByPlatform(this.xlr.config, resourceUrlParams);
           // this is an SSP Layout
           if (this.region.layout.layoutId === -1) {
             tmpUrl = this.uri;
           }
         }
-      } else if (this.xlr.config.platform === exports.ConsumerPlatform.ELECTRON) {
-        tmpUrl = composeResourceUrlByPlatform(this.xlr.config, resourceUrlParams);
-        // this is an SSP Layout
-        if (this.region.layout.layoutId === -1) {
-          tmpUrl = this.uri;
-        }
+        this.url = tmpUrl;
       }
-      this.url = tmpUrl;
       // Loop if media has loop, or if region has loop and a single media
       this.loop = this.options['loop'] == '1' || this.region.options['loop'] == '1' && this.region.totalMediaObjects == 1;
       this.html = createMediaElement(this);
@@ -74323,18 +74320,49 @@ 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;
         }
         return null;
       };
+      // SSP widget: if the consumer did not resolve an ad during the preload window
+      // (i.e. setSspAdUrl was never called), skip this widget and advance normally.
+      if (this.mediaType === 'ssp') {
+        console.debug('??? XLR.debug >> Media.run() > SSP widget: no ad resolved during preload, skipping');
+        this.emitter.emit('end', this);
+        return;
+      }
       showCurrentMedia();
     }
+  }, {
+    key: "setSspAdUrl",
+    value: function setSspAdUrl(url, adMediaType, impressionUrls, errorUrls) {
+      // Ignore if the media has already been skipped or cancelled before the ad arrived.
+      if (this.state !== MediaState.IDLE) {
+        console.debug('??? XLR.debug >> Media::setSspAdUrl - ignoring, media is no longer idle', {
+          state: this.state
+        });
+        return;
+      }
+      // Remove the placeholder <div> so the correct element type can take its place.
+      if (this.html) {
+        this.html.remove();
+        this.html = null;
+      }
+      this.url = url;
+      this.mediaType = adMediaType;
+      this.sspImpressionUrls = impressionUrls;
+      this.sspErrorUrls = errorUrls;
+      // Re-create the element now that mediaType is known, then prepare and append to region DOM.
+      // Visibility and playback are handled by run() when this media's turn comes.
+      this.html = createMediaElement(this);
+      this.region.prepareMedia(this);
+    }
   }, {
     key: "stop",
     value: function () {
@@ -74562,15 +74590,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));
             }
           });
         }
@@ -74587,6 +74621,13 @@ var Region = /*#__PURE__*/function () {
   }, {
     key: "prepareMedia",
     value: function prepareMedia(media) {
+      // SSP widget: signal the consumer to fetch an ad before this media's turn to play.
+      // The consumer calls media.setSspAdUrl() to resolve it; if it never arrives,
+      // Media.run() skips the widget and advances normally.
+      if (media.mediaType === 'ssp') {
+        this.xlr.emitter.emit('sspWidgetRequest', media);
+        return;
+      }
       if (media.mediaType === 'video') {
         prepareVideoMedia(media, this);
       } else if (media.mediaType === 'image' && media.url !== null) {
@@ -74595,6 +74636,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);
+        }
       }
     }
   }, {
@@ -74803,7 +74849,12 @@ var Region = /*#__PURE__*/function () {
           }
         };
         if (oldMedia) {
-          hideOldMedia();
+          // Skip hiding old media when it is the same object as new media
+          // (single-media loop): removing it would also remove the element
+          // that is about to be shown, leaving the region blank.
+          if (oldMedia !== newMedia) {
+            hideOldMedia();
+          }
           newMedia.run();
         } else {
           newMedia.run();
@@ -74813,7 +74864,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,
@@ -74833,8 +74894,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
@@ -74880,6 +74943,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,
@@ -74900,14 +74982,15 @@ var Region = /*#__PURE__*/function () {
   }, {
     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();
+      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;
       console.debug('region::playPreviousMedia', this);
-      /* Do the transition */
       this.transitionNodes(this.oldMedia, this.currMedia);
     }
   }, {
@@ -75106,6 +75189,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({
@@ -75118,26 +75205,40 @@ 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) */
   }, {
-    key: "nextMediaInRegion",
-    value: function nextMediaInRegion(regionId, actionType) {
+    key: "gotoMediaInRegion",
+    value: function gotoMediaInRegion(regionId, actionType) {
+      console.debug('[ActionController::gotoMediaInRegion] Changing media in region with data', {
+        regionId: regionId,
+        actionType: actionType
+      });
       // Find target region
       this.parent.regions.forEach(function (regionObj) {
         if (regionObj.id === regionId) {
@@ -75152,7 +75253,11 @@ var ActionController = /*#__PURE__*/function () {
   }, {
     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;
@@ -75175,27 +75280,70 @@ 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 current media's duration timer so it doesn't fire and interrupt
+      // the target widget mid-playback (e.g. an Interactive Zone timer still ticking).
+      if ((_targetRegion2 = targetRegion) !== null && _targetRegion2 !== void 0 && (_targetRegion2 = _targetRegion2.currMedia) !== null && _targetRegion2 !== void 0 && _targetRegion2.mediaTimer) {
+        clearInterval(targetRegion.currMedia.mediaTimer);
+        targetRegion.currMedia.mediaTimer = undefined;
+      }
+      // 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) {
+      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') {
@@ -75254,6 +75402,18 @@ 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() {
@@ -76303,6 +76463,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;
@@ -76482,35 +76649,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();
         }
@@ -76559,6 +76719,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) {
@@ -76567,7 +76757,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);
@@ -76595,86 +76785,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);
@@ -76701,22 +76891,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();
         }
@@ -76746,7 +76936,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);
@@ -76759,17 +76949,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;
@@ -76813,7 +77014,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
@@ -76823,7 +77024,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);
@@ -76860,6 +77061,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,
@@ -76871,7 +77078,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 = {};
@@ -76888,7 +77095,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', {
@@ -76905,10 +77118,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;
@@ -76916,71 +77129,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
@@ -76992,8 +77213,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) {
@@ -77027,7 +77254,7 @@ function XiboLayoutRenderer(inputLayouts, overlays, options) {
               return _ref14.apply(this, arguments);
             };
           }()));
-        case 35:
+        case 38:
         case "end":
           return _context14.stop();
       }
@@ -77190,33 +77417,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 () {
@@ -77236,30 +77478,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) {