@pendo/agent 2.338.2 → 2.339.1

package/dist/pendo.module.js

@@ -4046,8 +4046,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.338.2_';
-let PACKAGE_VERSION = '2.338.2';
+let VERSION = '2.339.1_';
+let PACKAGE_VERSION = '2.339.1';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4528,7 +4528,7 @@ function createStorageShim(storageAccessor) {
         return fake;
     }
 }
-var pendoLocalStorage$4 = createStorageShim(function () { return window.localStorage; });
+var pendoLocalStorage$3 = createStorageShim(function () { return window.localStorage; });
 var pendoSessionStorage$2 = createStorageShim(function () { return window.sessionStorage; });
 
 /**
@@ -4916,7 +4916,7 @@ var agentStorage = (function () {
     }
     const wrappedPendoSessionStorage = _.extend({}, pendoSessionStorage$2);
     wrappedPendoSessionStorage.setItem = wrapStorageWriteMethod(wrappedPendoSessionStorage.setItem, 'hasSession');
-    const wrappedPendoLocalStorage = _.extend({}, pendoLocalStorage$4);
+    const wrappedPendoLocalStorage = _.extend({}, pendoLocalStorage$3);
     wrappedPendoLocalStorage.setItem = wrapStorageWriteMethod(wrappedPendoLocalStorage.setItem, 'hasLocal');
     return {
         /* API */
@@ -11826,7 +11826,7 @@ _.extend(dom.prototype, DomEvent.$, DomQuery.$);
 
 // Domains that Pendo owns, will be swapped in by build patches
 const pendoDomainPatterns = [
-        /^https:\/\/((adopt|oem)\.)?((us1)\.)?(app|via|adopt|cdn|oem|novus-api|novus)(\.(au|eu|gov|hsbc|jpn|tv))?\.pendo\.io$/,
+        /^https:\/\/((adopt|oem)\.)?((us1)\.)?(app|via|adopt|cdn|oem|novus-api|novus|portal)(\.(au|eu|gov|hsbc|jpn|tv))?\.pendo\.io$/,
         /^https:\/\/([0-9]{8}t[0-9]{4}-dot-)(pendo-au|pendo-eu|pendo-govramp|pendo-hsbc|pendo-io|pendo-jp-prod|pendo-tv|pendo-us1)\.appspot\.com$/,
         /^https:\/\/hotfix-(ops|app)-([0-9]+-dot-)(pendo-au|pendo-eu|pendo-govramp|pendo-hsbc|pendo-io|pendo-jp-prod|pendo-tv|pendo-us1)\.appspot\.com$/,
         /^https:\/\/(pendo-au|pendo-eu|pendo-govramp|pendo-hsbc|pendo-io|pendo-jp-prod|pendo-tv|pendo-us1)-static\.storage\.googleapis\.com$/
@@ -20548,6 +20548,23 @@ var GuideStateModule = (function () {
     };
 })();
 
+function prioritizeAdoptOrCoreGuides(guides, shouldPrioritizeAdopt) {
+    var adoptGuides = [];
+    var coreGuides = [];
+    _.each(guides, function (guide) {
+        if (guide.isTraining) {
+            adoptGuides.push(guide);
+        }
+        else {
+            coreGuides.push(guide);
+        }
+    });
+    if (shouldPrioritizeAdopt) {
+        return adoptGuides.concat(coreGuides);
+    }
+    return coreGuides.concat(adoptGuides);
+}
+
 var AutoDisplay = (function () {
     return {
         canDisplay,
@@ -20631,24 +20648,6 @@ var AutoDisplay = (function () {
         var prioritizeAdopt = ConfigReader.get('adoptPrioritizeAdoptGuides');
         return prioritizeAdoptOrCoreGuides(sortedGuides, prioritizeAdopt);
     }
-    function prioritizeAdoptOrCoreGuides(guides, shouldPrioritizeAdopt) {
-        var adoptGuides = [];
-        var coreGuides = [];
-        _.each(guides, function (guide) {
-            if (guide.isTraining) {
-                adoptGuides.push(guide);
-            }
-            else {
-                coreGuides.push(guide);
-            }
-        });
-        if (shouldPrioritizeAdopt) {
-            return adoptGuides.concat(coreGuides);
-        }
-        else {
-            return coreGuides.concat(adoptGuides);
-        }
-    }
     function lastDismissedTime(pendo) {
         return Math.max(pendo.latestDismissedAutoAt || -Infinity, pendo.finalAdvancedAutoAt || -Infinity, pendo.latestSnoozedAutoAt || -Infinity);
     }
@@ -20858,642 +20857,6 @@ class AutoDisplayPhase {
     }
 }
 
-/*
-* Guide Loop
-*
-* The function that gets called to process and handle the ever
-* changing landscape of a web app to best handle showing / hiding of
-* guides as needed.
-*/
-/*
- * Holds the timeout handle for the startGuides process.
- * This should work as a simple monitor on that process
- * to prevent it from being run too often.
- */
-var guidesProcessingThreadHandle = null;
-var DEFAULT_TIMER_LENGTH = 500;
-var waitThenLoop = function (delayAmount) {
-    delayAmount = delayAmount || DEFAULT_TIMER_LENGTH;
-    guidesProcessingThreadHandle = _.delay(function () {
-        guidesProcessingThreadHandle = null;
-        startGuides();
-    }, delayAmount);
-    pendo$1.guidesProcessingThreadHandle = guidesProcessingThreadHandle;
-};
-var clearLoopTimer = function () {
-    if (guidesProcessingThreadHandle) {
-        clearTimeout(guidesProcessingThreadHandle);
-        guidesProcessingThreadHandle = null;
-        pendo$1.guidesProcessingThreadHandle = guidesProcessingThreadHandle;
-    }
-    store.dispatch('guideUpdate/stopScheduledUpdate');
-};
-/**
- * Clears any showing guides and prevents any loaded guides from rendering.
- * Loaded guides remain in memory, so calling startGuides will work just fine
- * after a stopGuides call.
- *
- * @access public
- * @category Guides
- * @example
- * pendo.stopGuides()
- */
-var stopGuides = function () {
-    hideGuides();
-    updateRunner.cancel();
-    // Remove other stuff.
-    for (var i = 0; i < activeElements.length; i++) {
-        var elem = activeElements[i];
-        elem.parentNode.removeChild(elem);
-    }
-    activeElements.length = 0;
-    store.dispatch('guideUpdate/stopObserver');
-    Events.guideLoopStopped.trigger();
-};
-/**
- * Starts the process that loops over all currently loaded guides and
- * determines what to show. Checks multi-step guide continuation,
- * auto-display guides, launcher guides, and badges.
- *
- * @access public
- * @category Guides
- * @example
- * pendo.startGuides()
- */
-var startGuides = function () {
-    clearLoopTimer();
-    if (isGuideRequestPending()) {
-        log.info('guides are loading.', { contexts: ['guides', 'loading'] });
-        return;
-    }
-    if (areGuidesDisabled()) {
-        log.info('guides are disabled.', { contexts: ['guides', 'disabled'] });
-        return;
-    }
-    if (areGuidesDelayed()) {
-        log.info('guides are delayed.', { contexts: ['guides', 'delayed'] });
-        return;
-    }
-    if (store.getters['guideState/tabLostFocus']())
-        return;
-    try {
-        const activeGuides = getActiveGuides();
-        if (!activeGuides || activeGuides.length === 0)
-            return;
-        store.dispatch('guideUpdate/startObserverIfNeeded');
-        if (updateRunner.isComplete()) {
-            updateRunner.markDirty();
-        }
-        if (leaderExists()) {
-            updateRunner.process();
-        }
-    }
-    catch (e) {
-        updateRunner.cancel();
-        log.critical('ERROR in guide-loop', { error: e });
-    }
-    finally {
-        if (!updateRunner.paused) {
-            continueOrCompleteUpdate();
-        }
-    }
-};
-function continueOrCompleteUpdate() {
-    if (!updateRunner.isComplete()) {
-        waitThenLoop(50);
-    }
-    else {
-        if (!store.state.guideUpdate.useObserver || store.state.guideUpdate.needsUpdate) {
-            waitThenLoop();
-        }
-        Events.guideUpdateComplete.trigger();
-    }
-}
-/*
- * If delayGuides is true, removes the delay and starts guides.
- * Otherwise, it is the same as calling startGuides.
- */
-var manuallyStartGuides = function () {
-    setGuidesDelayed(false);
-    startGuides();
-};
-var manuallyStopGuides = function () {
-    if (!areGuidesDisabled()) {
-        setGuidesDelayed(true);
-    }
-    resetPendoUI();
-};
-// a phase that only has one unit of work per update
-class SimplePhase {
-    constructor(name, processFn) {
-        this.dirty = false;
-        this.name = name;
-        this.processFn = _.isFunction(processFn) ? processFn : _.noop;
-    }
-    markDirty() {
-        this.dirty = true;
-    }
-    process() {
-        this.processFn();
-        this.dirty = false;
-    }
-    cancel() {
-        this.dirty = false;
-    }
-    isComplete() {
-        return !this.dirty;
-    }
-}
-/**
- * Runs on a timer whenever a guide is displayed.
- *
- * @access private
- * @param  {Guide} guide The currently visible guide
- * @param  {GuideStep} step The currently visible step
- */
-function guideShowingProc() {
-    const shownGuides = _.compact(_.map(_.filter(frameLocalGuides(getActiveGuides()), (guide) => guide.isShown()), (guide) => {
-        if (BuildingBlockResourceCenter.isModule(guide)) {
-            return BuildingBlockResourceCenter.getResourceCenter();
-        }
-        else {
-            return guide;
-        }
-    }));
-    _.each(shownGuides, function (guide) {
-        _.each(guide.steps, function (step) {
-            if (step.isShown()) {
-                stepShowingProc(guide, step);
-            }
-        });
-        guide.checkForHiddenGroupSteps();
-    });
-}
-function stepShowingProc(guide, step) {
-    if (step.isLocked()) {
-        return;
-    }
-    if (store.getters['frames/isShownInAnotherFrame']()(step)) {
-        return;
-    }
-    var element = step.element;
-    var targetElement = step.targetElement;
-    var guideElement = step.guideElement;
-    var guideElm = dom('.' + GUIDE_CSS_NAME);
-    // As part of the guides accessibility work, we need to make sure that all
-    // guide content remain visible and/or accessible during text-only (font) zoom.
-    // Since text zoom does NOT trigger our existing resize listener, the
-    // alternative is to track text zoom via font-size changes.
-    var guideContainer = guideElement.find('#pendo-guide-container')[0];
-    var guideHasTextContent = guideContainer && guideContainer.textContent;
-    if (guideHasTextContent) {
-        var currentBrowserFontSize = getComputedStyle_safe(guideContainer).fontSize;
-        var hasBrowserFontSizeChanged = step.attributes.currentTextZoomFontSize !== currentBrowserFontSize;
-        if (hasBrowserFontSizeChanged) {
-            if (step.attributes.currentTextZoomFontSize) {
-                step.redraw();
-            }
-            step.attributes.currentTextZoomFontSize = currentBrowserFontSize;
-        }
-    }
-    syncColorMode(step, true);
-    if (step.elementPathRule && targetElement && !SizzleProxy.matchesSelector(targetElement, step.elementPathRule)) {
-        step.hide();
-        return;
-    }
-    const embedSelector = _.get(guide, 'attributes.embedConfig.selector');
-    if (embedSelector && !dom(embedSelector).length) {
-        step.hide();
-        return;
-    }
-    var elementIsStillValidTarget = isElementVisible(element);
-    var elementMatchesContainsRules = true;
-    // targetElement is specifically the elementPathRule dom node
-    // element is either the element path rule OR the badge element
-    // we can rely on the isElementVisible check as a shortcut for having to call isElementVisible twice
-    if (targetElement && elementIsStillValidTarget && step.elementContainsRulesList) {
-        // Only bother trying to check element contains rules if the element is still visible
-        elementMatchesContainsRules = doesElementMatchContainsRules(targetElement, step.elementContainsRulesList);
-        elementIsStillValidTarget = elementMatchesContainsRules;
-    }
-    if (element && (elementIsStillValidTarget || guideElm.hasClass('mouseover'))) {
-        step.checkPlacement();
-        return;
-    }
-    var isTooltip = (step.type === 'tooltip' || step.attributes.calculatedType === 'tooltip');
-    if (isTooltip && wouldBeVisibleAfterAutoScroll(element) && elementMatchesContainsRules) {
-        // the element was scrolled out of view, the guide should be invisible for now, but still "active"
-        return;
-    }
-    step.hide();
-}
-class BadgePhase {
-    constructor() {
-        this.name = 'badge';
-        this.queue = [];
-    }
-    markDirty() {
-        this.queue.push.apply(this.queue, _.filter(frameLocalGuides(getActiveGuides()), isBadge));
-    }
-    process(monitor) {
-        var badge = this.queue.shift();
-        monitor.saveContext(badge);
-        if (badge) {
-            badge.placeBadge();
-        }
-    }
-    handleProcessTimeExceeded(monitor) {
-        const badge = monitor.getContext();
-        log.warn('Badge (' + badge.id + ') timeout exceeded');
-    }
-    cancel() {
-        this.queue.length = 0;
-    }
-    isComplete() {
-        return !this.queue.length;
-    }
-}
-function resourceCenterShowingProc(resourceCenter, resourceCenterBadgeProc) {
-    var reEvaluateModuleContent = false;
-    // Find eligible modules
-    var controlGuidesInAllModules = [];
-    var eligibleModules = _.filter(resourceCenter.modules, function (module) {
-        if (!module)
-            return false;
-        // Iframe modules can not dynamically show/hide.
-        if (BuildingBlockResourceCenter.isIframeModule(module))
-            return true;
-        // Sandbox modules can not dynamically show/hide.
-        if (BuildingBlockResourceCenter.isSandboxModule(module))
-            return true;
-        if (BuildingBlockResourceCenter.isIntegrationModule(module)) {
-            if (!BuildingBlockResourceCenter.integrationModuleHasContent(module)) {
-                module.hasResourceCenterContent = false;
-                return false;
-            }
-            else {
-                return true;
-            }
-        }
-        var eligibleGuidesInModule = _.filter(module.guidesInModule, function (guide) {
-            if (!guide.shouldBeAddedToResourceCenter()) {
-                guide.ineligibleForRC = true;
-                if (guide.control) {
-                    controlGuidesInAllModules.push(guide);
-                }
-                return false;
-            }
-            guide.ineligibleForRC = false;
-            return true;
-        });
-        var isEligible = eligibleGuidesInModule.length;
-        module.hasResourceCenterContent = !!isEligible;
-        // We only need to hash the active module, no other module has content rendered
-        if (resourceCenter.activeModule && module.id === resourceCenter.activeModule.id) {
-            var moduleContentHash = crc32(_.map(eligibleGuidesInModule, function (guide) {
-                // don't change content hash when announcements update their seen state, as that will cause
-                // the RC to re-render (and lose scroll position)
-                var isAnnouncementOrWhatsNew = guide.isAnnouncement() || guide.isWhatsNew();
-                var seenState = isAnnouncementOrWhatsNew ? null : _.pluck(guide.steps, 'seenState');
-                return {
-                    id: guide.id,
-                    seenState
-                };
-            }));
-            if (module.eligibleGuidesInModuleHash && moduleContentHash !== module.eligibleGuidesInModuleHash)
-                reEvaluateModuleContent = true;
-            module.eligibleGuidesInModuleHash = moduleContentHash;
-        }
-        return isEligible;
-    });
-    // If we are rendering the home view and its modules change re-render it
-    var reEvaluateHomeViewContent = false;
-    if (!resourceCenter.activeModule) {
-        var eligibleModulesHash = crc32(_.map(eligibleModules, function (module) {
-            return {
-                id: module.id
-            };
-        }));
-        if (resourceCenter.eligibleModulesHash && resourceCenter.eligibleModulesHash !== eligibleModulesHash) {
-            reEvaluateHomeViewContent = true;
-            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.id, undefined, true);
-        }
-        resourceCenter.eligibleModulesHash = eligibleModulesHash;
-    }
-    resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules);
-    // Skip directly to the one eligible module
-    if (eligibleModules.length === 1) {
-        resourceCenter.skipResourceCenterHomeView = true;
-        resourceCenter.moduleIdToReplaceHomeViewWith = eligibleModules[0].id;
-        var noActiveModule = !resourceCenter.activeModule && reEvaluateHomeViewContent;
-        var differentActiveModule = resourceCenter.activeModule && resourceCenter.activeModule.id !== eligibleModules[0].id;
-        // If the one module is different or content needs to be reevaluated, reload
-        // or if we are on the home view and the modules on the home view have changed
-        if (noActiveModule || differentActiveModule || reEvaluateModuleContent) {
-            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.moduleIdToReplaceHomeViewWith, undefined, true);
-        }
-    }
-    if (eligibleModules) {
-        // find the in-progress native integration module and set continueToNativeModule on both the
-        // RC container and the module since both will try to render
-        var continuedModule = _.find(eligibleModules, function (module) {
-            return module.isContinuation(getLastGuideStepSeen());
-        });
-        var shouldNotResume = _.get(continuedModule, 'attributes.doNotResume');
-        var integrationProvider = _.get(continuedModule, 'attributes.resourceCenter.integrationProvider');
-        var isNativeModule = BuildingBlockResourceCenter.isSupportedNativeIntegration(integrationProvider);
-        if (isNativeModule && !shouldNotResume && resourceCenter) {
-            resourceCenter.continueToNativeModule = true;
-            continuedModule.continueToNativeModule = true;
-        }
-    }
-    // Ensure the active module is still eligible and re-evaluate its content if need be.
-    // Go to Home View if active module is no longer eligible
-    var activeModuleisEligible;
-    if (resourceCenter.activeModule) {
-        activeModuleisEligible = _.find(eligibleModules, function (module) {
-            return module.id === resourceCenter.activeModule.id;
-        });
-        if (activeModuleisEligible && reEvaluateModuleContent) {
-            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.activeModule.id, undefined, true);
-        }
-        if (!activeModuleisEligible) {
-            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.id);
-        }
-    }
-    BuildingBlockResourceCenter.repositionResourceCenter();
-}
-function resourceCenterNotShowingProc(resourceCenter, resourceCenterBadgeProc) {
-    var eligibleModules = [];
-    var controlGuidesInAllModules = [];
-    var staticModule = _.find(resourceCenter.modules, function (module) {
-        if (BuildingBlockResourceCenter.isIframeModule(module))
-            return true;
-        if (BuildingBlockResourceCenter.isSandboxModule(module))
-            return true;
-        if (BuildingBlockResourceCenter.isIntegrationModule(module)) {
-            if (!BuildingBlockResourceCenter.integrationModuleHasContent(module)) {
-                module.hasResourceCenterContent = false;
-                return false;
-            }
-            else {
-                return true;
-            }
-        }
-        return false;
-    });
-    if (staticModule) {
-        eligibleModules.push(staticModule);
-    }
-    var allGuidesInModules = _.flatten(_.pluck(resourceCenter.modules, 'guidesInModule'));
-    controlGuidesInAllModules = _.filter(_.compact(allGuidesInModules), function (guide) {
-        return guide.control;
-    });
-    if (!eligibleModules.length) {
-        var moduleLookup = _.reduce(resourceCenter.modules, function (lookup, module) {
-            _.each(module.guidesInModule, function (guide) {
-                lookup[guide.id] = module;
-            });
-            return lookup;
-        }, {});
-        var guidesWithSteps = _.filter(allGuidesInModules, function (guide) {
-            return guide && guide.steps && guide.steps.length;
-        });
-        // Sort guides so that untargeted guides are first
-        var sortedGuides = _.sortBy(guidesWithSteps, function (guide) {
-            return guide.steps[0].elementPathRule ? 1 : 0;
-        });
-        var firstEligibleGuide = _.find(sortedGuides, function (guide) {
-            return guide.shouldBeAddedToResourceCenter();
-        });
-        var firstEligibleModule = moduleLookup[firstEligibleGuide && firstEligibleGuide.id];
-        if (firstEligibleModule) {
-            eligibleModules.push(firstEligibleModule);
-        }
-    }
-    resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules);
-}
-function resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules) {
-    var RCBadge = badgesShown[resourceCenter.id];
-    // If we get no modules back, hide the RC and RC Badge, clear active module
-    if (!eligibleModules || !eligibleModules.length) {
-        var isBadgeActivated = resourceCenter.launchMethod.indexOf('badge') !== -1;
-        var isElementActivated = resourceCenter.launchMethod.indexOf('dom') !== -1;
-        resourceCenter.hasResourceCenterContent = false;
-        // If the RC is badge activated, hide it from the dom completely. Otherwise, leave it alone
-        // This is important for element-activated RC, which should still display with an empty state
-        // even if it has no content
-        if (isBadgeActivated) {
-            if (resourceCenter.isShown())
-                resourceCenter.hide();
-            if (RCBadge) {
-                BuildingBlockResourceCenter.hideRCBadge(RCBadge, resourceCenter);
-            }
-            // If all modules are not eligible because of control group guides
-            // Send guideNotSeen events where appropriate
-            _.each(controlGuidesInAllModules, function (guide) {
-                if (!guide.hasGuideBeenControlled()) {
-                    guide.steps[0].onControlGuide('control');
-                }
-            });
-            resourceCenter.badgeHidden = true;
-            delete resourceCenter.activeModule;
-        }
-        else if (isElementActivated) {
-            resourceCenter.showEmptyState = true;
-            resourceCenter.controlGuidesInAllModules = controlGuidesInAllModules;
-        }
-    }
-    // Show the badge if it was hidden but now has content
-    if (resourceCenter.badgeHidden && resourceCenter.hasResourceCenterContent && !resourceCenter.isNativeModuleActive) {
-        if (!RCBadge) {
-            if (_.isFunction(resourceCenter.placeBadge))
-                resourceCenter.placeBadge();
-            RCBadge = badgesShown[resourceCenter.id];
-        }
-        if (RCBadge)
-            RCBadge.show();
-        resourceCenter.badgeHidden = false;
-    }
-}
-function resourceCenterProc(resourceCenter) {
-    if (!resourceCenter || !resourceCenter.launchMethod)
-        return;
-    // Reset state to start each loop
-    resourceCenter.skipResourceCenterHomeView = false;
-    resourceCenter.hasResourceCenterContent = true;
-    delete resourceCenter.moduleIdToReplaceHomeViewWith;
-    var activeModule = resourceCenter.activeModule;
-    var activeIntegrationProvider = _.get(activeModule, 'attributes.resourceCenter.integrationProvider');
-    resourceCenter.isNativeModuleActive = activeModule && BuildingBlockResourceCenter.isSupportedNativeIntegration(activeIntegrationProvider);
-    if (resourceCenter.isShown() || !store.getters['frames/isLeader']()) {
-        resourceCenterShowingProc(resourceCenter, resourceCenterBadgeProc);
-    }
-    else {
-        resourceCenterNotShowingProc(resourceCenter, resourceCenterBadgeProc);
-    }
-    // Hide the badge if we're displaying a native integration module
-    if (resourceCenter.isNativeModuleActive) {
-        if (resourceCenter.isShown())
-            resourceCenter.hide();
-        var RCBadge = badgesShown[resourceCenter.id];
-        if (RCBadge) {
-            BuildingBlockResourceCenter.hideRCBadge(RCBadge, resourceCenter);
-        }
-    }
-    // Place Element Activated Notification Badge
-    if (resourceCenter.launchMethod === 'dom' && resourceCenter.canShowOnDevice()) {
-        BuildingBlockResourceCenter.updateNotificationBubbles();
-        BuildingBlockResourceCenter.adjustNotificationBubbleForResize();
-    }
-}
-class PhaseProcessTimeMonitor {
-    constructor(timeLimit = 50) {
-        this.startTime = -1;
-        this.timeLimit = timeLimit;
-        this.context = null;
-    }
-    start() {
-        this.context = null;
-        this.startTime = getNow();
-    }
-    isTimeExceeded() {
-        const currTime = getNow();
-        return (currTime - this.startTime) > this.timeLimit;
-    }
-    saveContext(context) {
-        this.context = context;
-    }
-    getContext() {
-        return this.context;
-    }
-}
-class UpdateRunner {
-    constructor(phases) {
-        this.phases = phases;
-        this.queue = [];
-        this.paused = false;
-    }
-    markDirty() {
-        for (let phase of this.phases) {
-            phase.markDirty();
-        }
-        this.queue = this.phases.slice();
-    }
-    runGuidePhase() {
-        const currentPhase = this.queue[0];
-        var promise;
-        const monitor = new PhaseProcessTimeMonitor(50);
-        while (!this.timedOut() && !currentPhase.isComplete() && !promise) {
-            monitor.start();
-            promise = currentPhase.process(monitor);
-            if (!promise && monitor.isTimeExceeded()) {
-                performanceMonitor.count(GUIDE_LOOP_TIMEOUT);
-                if (currentPhase.handleProcessTimeExceeded) {
-                    currentPhase.handleProcessTimeExceeded(monitor);
-                }
-                this.ejectGuide(monitor.getContext());
-            }
-        }
-        if (isPromise(promise)) {
-            var id = this.updateId;
-            var resume = _.bind(function () {
-                if (this.updateId === id) {
-                    this.paused = false;
-                    startGuides();
-                }
-            }, this);
-            this.paused = true;
-            promise.then(resume).catch(resume);
-        }
-        else if (currentPhase.isComplete()) {
-            this.queue.shift();
-        }
-    }
-    addPhase(phaseFn, phaseName) {
-        phaseName = phaseName || phaseFn.name || this.phases.length;
-        if (_.isFunction(phaseFn)) {
-            phaseFn = new SimplePhase(phaseName, phaseFn);
-        }
-        this.phases.push(phaseFn);
-    }
-    removePhase(phaseName) {
-        var i = _.findIndex(this.phases, function (phase) {
-            return phase.name === phaseName;
-        });
-        if (i >= 0) {
-            this.phases.splice(i, 1);
-        }
-    }
-    timedOut() {
-        if (!this.iterationStartTime)
-            return false;
-        var elapsed = getNow() - this.iterationStartTime;
-        return elapsed > store.state.guideUpdate.iterationTimeLimit;
-    }
-    ejectGuide(guide) {
-        if (this.ejectOnTimeout === undefined) {
-            this.ejectOnTimeout = ConfigReader.get('guides.ejectOnTimeout');
-        }
-        if (this.ejectOnTimeout && guide && !guide.isShown()) {
-            Tombstone.addGuide(guide);
-        }
-    }
-    process() {
-        var now = getNow();
-        if (!this.updateId) {
-            this.updateId = now;
-            this.updateTotalTime = 0;
-            store.commit('guideUpdate/startUpdate', now);
-        }
-        this.iterationStartTime = now;
-        while (!this.paused &&
-            this.queue.length &&
-            !this.timedOut()) {
-            this.runGuidePhase();
-        }
-        now = getNow();
-        this.updateTotalTime += now - this.iterationStartTime;
-        if (this.isComplete()) {
-            this.complete(now);
-        }
-    }
-    complete(time) {
-        store.commit('guideUpdate/completeUpdate', time);
-        this.cancel();
-    }
-    cancel() {
-        this.updateId = null;
-        this.paused = false;
-        this.queue.length = 0;
-        for (let phase of this.phases) {
-            if (_.isFunction(phase.cancel)) {
-                phase.cancel();
-            }
-        }
-    }
-    isComplete() {
-        return !this.queue.length;
-    }
-}
-var updateRunner = new UpdateRunner([
-    new SimplePhase('guideShowing', guideShowingProc),
-    new AutoDisplayPhase(),
-    new BadgePhase(),
-    new SimplePhase('resourceCenter', function () {
-        resourceCenterProc(BuildingBlockResourceCenter.getResourceCenter());
-    }),
-    new SimplePhase('frameVisibility', function () {
-        store.dispatch('frames/checkFrameVisibility');
-    })
-]);
-function addUpdatePhase() {
-    updateRunner.addPhase(...arguments);
-}
-function removeUpdatePhase() {
-    updateRunner.removePhase(...arguments);
-}
-
 function Wrappable() {
     var wrappers = {};
     var wrap = function (wrappedMethod, before, after) {
@@ -22690,119 +22053,810 @@ function ShowOnHover() {
                 attached = true;
                 mouseout();
             }
-        });
-        badge.after('hide', function () {
-            if (attached) {
-                detachEvent(target, 'mouseover', mouseover);
-                attached = false;
+        });
+        badge.after('hide', function () {
+            if (attached) {
+                detachEvent(target, 'mouseover', mouseover);
+                attached = false;
+            }
+            mouseout();
+        });
+    }
+    return badge;
+}
+var BADGE_CLAIM_PROP = '_pendoBadgeClaimIsTraining';
+var badgeClaimTargets = [];
+function resetBadgeTargetClaims() {
+    _.each(badgeClaimTargets, function (target) {
+        target[BADGE_CLAIM_PROP] = undefined;
+    });
+    badgeClaimTargets.length = 0;
+}
+function isBadgeTargetClaimedByOppositeTraining(guide, target) {
+    if (!target)
+        return false;
+    var claimedIsTraining = target[BADGE_CLAIM_PROP];
+    if (claimedIsTraining === undefined)
+        return false;
+    return claimedIsTraining !== !!guide.isTraining;
+}
+function claimBadgeTarget(guide, target) {
+    if (!target)
+        return;
+    target[BADGE_CLAIM_PROP] = !!guide.isTraining;
+    if (!_.contains(badgeClaimTargets, target)) {
+        badgeClaimTargets.push(target);
+    }
+}
+function hideBadgeForGuideInMap(guide, badgesShownObj) {
+    var existingBadge = badgesShownObj[guide.id];
+    if (!existingBadge)
+        return;
+    var badgeStep = existingBadge.step();
+    if (badgeStep && badgeStep.isShown && badgeStep.isShown())
+        return;
+    delete badgesShownObj[guide.id];
+    if (_.isFunction(existingBadge.hide)) {
+        existingBadge.hide();
+    }
+}
+/*
+ * Maintains the DOM presence of the badge for the specified guide
+ * where in the badge is either added or removed depending on if
+ * the appropiate DOM element is found.
+ *
+ * For this reason, when Badges are in the play the setTimeout to
+ * keep showing the startGuides needs to also continue running.
+ *
+ * input: guide obj, and Map of ids to badges being shown currently
+ */
+var placeBadge = function (guide, badgesShownObj) {
+    badgesShownObj = badgesShownObj || badgesShown;
+    var badge = badgesShownObj[guide.id];
+    var step = badge ? badge.step() : Badge.findStep(guide);
+    if (!step)
+        return;
+    var target = badge ? badge.target() : getElementForTargeting(step);
+    var isRcBadge = _.get(guide, 'attributes.resourceCenter');
+    if (isRcBadge && !store.getters['frames/canShowRCBadge']()) {
+        if (badge && _.isFunction(badge.hide)) {
+            // If top frame comes in late and RC badge showing in inner frame bc of delay, hide it here
+            delete badgesShownObj[guide.id];
+            badge.hide();
+        }
+        return;
+    }
+    // Don't render the resource center badge if the resource center itself has nothing to show
+    if (isRcBadge && !guide.hasResourceCenterContent)
+        return;
+    BuildingBlockResourceCenter.updateNotificationBubbles();
+    var passesElementContainsRules = true;
+    if (step.elementContainsRulesList) {
+        passesElementContainsRules = target && doesElementMatchContainsRules(target, step.elementContainsRulesList);
+    }
+    const badgeCanShow = step.elementPathRule &&
+        isElementVisible(target) &&
+        SizzleProxy.matchesSelector(target, step.elementPathRule) &&
+        passesElementContainsRules;
+    if (badgeCanShow) {
+        if (isBadgeTargetClaimedByOppositeTraining(guide, target)) {
+            if (isDebuggingEnabled()) {
+                Events.stepEligibility.trigger({
+                    stepId: step.id,
+                    guideId: guide.id,
+                    eligible: false,
+                    reason: 'adopt_badge_priority'
+                });
+            }
+            hideBadgeForGuideInMap(guide, badgesShownObj);
+            return;
+        }
+        claimBadgeTarget(guide, target);
+        if (!badge) {
+            badge = Badge.create(guide);
+        }
+        badge.show();
+        badgesShownObj[guide.id] = badge;
+    }
+    else if (badge) {
+        // if the step is being show for this badge then
+        // don't remove it.
+        if (!step.isShown()) {
+            // 3. If the element is not found, remove it if it's currently shown.
+            delete badgesShownObj[guide.id];
+            badge.hide();
+        }
+    }
+    if (isDebuggingEnabled()) {
+        Events.stepEligibility.trigger({
+            stepId: step.id,
+            guideId: guide.id,
+            eligible: badgeCanShow,
+            reason: 'target_element_badge'
+        });
+    }
+    BuildingBlockResourceCenter.repositionDoubleResourceCenterBadge();
+};
+var removeAllBadges = function () {
+    _.map(badgesShown, removeBadge);
+    setBadgesShown({});
+};
+var removeBadge = function (badge, guide) {
+    if (!badge)
+        return;
+    if (_.isFunction(badge.hide)) {
+        badge.hide();
+    }
+    if (_.isFunction(badge.shouldShow) && !badge.shouldShow() && guide) {
+        delete badgesShown[guide.id];
+    }
+};
+var removeBadgeForGuide = function (guideGroup) {
+    var badge = badgesShown[guideGroup.id];
+    if (badge) {
+        removeBadge(badge, guideGroup);
+    }
+};
+function _adjustBadgesForResize() {
+    _.map(badgesShown, function (badge) {
+        if (badge && badge.show) {
+            badge.show();
+        }
+    });
+}
+var adjustBadgesForResize = _.throttle(_adjustBadgesForResize, 10);
+function pruneBadges(activeGuideIds) {
+    if (!activeGuideIds || !activeGuideIds.length)
+        return;
+    const lookup = _.indexBy(activeGuideIds);
+    _.each(badgesShown, function (badge, guideId) {
+        if (!lookup[guideId] && badge) {
+            badge.hide();
+            delete badgesShown[guideId];
+        }
+    });
+}
+
+/*
+* Guide Loop
+*
+* The function that gets called to process and handle the ever
+* changing landscape of a web app to best handle showing / hiding of
+* guides as needed.
+*/
+/*
+ * Holds the timeout handle for the startGuides process.
+ * This should work as a simple monitor on that process
+ * to prevent it from being run too often.
+ */
+var guidesProcessingThreadHandle = null;
+var DEFAULT_TIMER_LENGTH = 500;
+var waitThenLoop = function (delayAmount) {
+    delayAmount = delayAmount || DEFAULT_TIMER_LENGTH;
+    guidesProcessingThreadHandle = _.delay(function () {
+        guidesProcessingThreadHandle = null;
+        startGuides();
+    }, delayAmount);
+    pendo$1.guidesProcessingThreadHandle = guidesProcessingThreadHandle;
+};
+var clearLoopTimer = function () {
+    if (guidesProcessingThreadHandle) {
+        clearTimeout(guidesProcessingThreadHandle);
+        guidesProcessingThreadHandle = null;
+        pendo$1.guidesProcessingThreadHandle = guidesProcessingThreadHandle;
+    }
+    store.dispatch('guideUpdate/stopScheduledUpdate');
+};
+/**
+ * Clears any showing guides and prevents any loaded guides from rendering.
+ * Loaded guides remain in memory, so calling startGuides will work just fine
+ * after a stopGuides call.
+ *
+ * @access public
+ * @category Guides
+ * @example
+ * pendo.stopGuides()
+ */
+var stopGuides = function () {
+    hideGuides();
+    updateRunner.cancel();
+    // Remove other stuff.
+    for (var i = 0; i < activeElements.length; i++) {
+        var elem = activeElements[i];
+        elem.parentNode.removeChild(elem);
+    }
+    activeElements.length = 0;
+    store.dispatch('guideUpdate/stopObserver');
+    Events.guideLoopStopped.trigger();
+};
+/**
+ * Starts the process that loops over all currently loaded guides and
+ * determines what to show. Checks multi-step guide continuation,
+ * auto-display guides, launcher guides, and badges.
+ *
+ * @access public
+ * @category Guides
+ * @example
+ * pendo.startGuides()
+ */
+var startGuides = function () {
+    clearLoopTimer();
+    if (isGuideRequestPending()) {
+        log.info('guides are loading.', { contexts: ['guides', 'loading'] });
+        return;
+    }
+    if (areGuidesDisabled()) {
+        log.info('guides are disabled.', { contexts: ['guides', 'disabled'] });
+        return;
+    }
+    if (areGuidesDelayed()) {
+        log.info('guides are delayed.', { contexts: ['guides', 'delayed'] });
+        return;
+    }
+    if (store.getters['guideState/tabLostFocus']())
+        return;
+    try {
+        const activeGuides = getActiveGuides();
+        if (!activeGuides || activeGuides.length === 0)
+            return;
+        store.dispatch('guideUpdate/startObserverIfNeeded');
+        if (updateRunner.isComplete()) {
+            updateRunner.markDirty();
+        }
+        if (leaderExists()) {
+            updateRunner.process();
+        }
+    }
+    catch (e) {
+        updateRunner.cancel();
+        log.critical('ERROR in guide-loop', { error: e });
+    }
+    finally {
+        if (!updateRunner.paused) {
+            continueOrCompleteUpdate();
+        }
+    }
+};
+function continueOrCompleteUpdate() {
+    if (!updateRunner.isComplete()) {
+        waitThenLoop(50);
+    }
+    else {
+        if (!store.state.guideUpdate.useObserver || store.state.guideUpdate.needsUpdate) {
+            waitThenLoop();
+        }
+        Events.guideUpdateComplete.trigger();
+    }
+}
+/*
+ * If delayGuides is true, removes the delay and starts guides.
+ * Otherwise, it is the same as calling startGuides.
+ */
+var manuallyStartGuides = function () {
+    setGuidesDelayed(false);
+    startGuides();
+};
+var manuallyStopGuides = function () {
+    if (!areGuidesDisabled()) {
+        setGuidesDelayed(true);
+    }
+    resetPendoUI();
+};
+// a phase that only has one unit of work per update
+class SimplePhase {
+    constructor(name, processFn) {
+        this.dirty = false;
+        this.name = name;
+        this.processFn = _.isFunction(processFn) ? processFn : _.noop;
+    }
+    markDirty() {
+        this.dirty = true;
+    }
+    process() {
+        this.processFn();
+        this.dirty = false;
+    }
+    cancel() {
+        this.dirty = false;
+    }
+    isComplete() {
+        return !this.dirty;
+    }
+}
+/**
+ * Runs on a timer whenever a guide is displayed.
+ *
+ * @access private
+ * @param  {Guide} guide The currently visible guide
+ * @param  {GuideStep} step The currently visible step
+ */
+function guideShowingProc() {
+    const shownGuides = _.compact(_.map(_.filter(frameLocalGuides(getActiveGuides()), (guide) => guide.isShown()), (guide) => {
+        if (BuildingBlockResourceCenter.isModule(guide)) {
+            return BuildingBlockResourceCenter.getResourceCenter();
+        }
+        else {
+            return guide;
+        }
+    }));
+    _.each(shownGuides, function (guide) {
+        _.each(guide.steps, function (step) {
+            if (step.isShown()) {
+                stepShowingProc(guide, step);
+            }
+        });
+        guide.checkForHiddenGroupSteps();
+    });
+}
+function stepShowingProc(guide, step) {
+    if (step.isLocked()) {
+        return;
+    }
+    if (store.getters['frames/isShownInAnotherFrame']()(step)) {
+        return;
+    }
+    var element = step.element;
+    var targetElement = step.targetElement;
+    var guideElement = step.guideElement;
+    var guideElm = dom('.' + GUIDE_CSS_NAME);
+    // As part of the guides accessibility work, we need to make sure that all
+    // guide content remain visible and/or accessible during text-only (font) zoom.
+    // Since text zoom does NOT trigger our existing resize listener, the
+    // alternative is to track text zoom via font-size changes.
+    var guideContainer = guideElement.find('#pendo-guide-container')[0];
+    var guideHasTextContent = guideContainer && guideContainer.textContent;
+    if (guideHasTextContent) {
+        var currentBrowserFontSize = getComputedStyle_safe(guideContainer).fontSize;
+        var hasBrowserFontSizeChanged = step.attributes.currentTextZoomFontSize !== currentBrowserFontSize;
+        if (hasBrowserFontSizeChanged) {
+            if (step.attributes.currentTextZoomFontSize) {
+                step.redraw();
+            }
+            step.attributes.currentTextZoomFontSize = currentBrowserFontSize;
+        }
+    }
+    syncColorMode(step, true);
+    if (step.elementPathRule && targetElement && !SizzleProxy.matchesSelector(targetElement, step.elementPathRule)) {
+        step.hide();
+        return;
+    }
+    const embedSelector = _.get(guide, 'attributes.embedConfig.selector');
+    if (embedSelector && !dom(embedSelector).length) {
+        step.hide();
+        return;
+    }
+    var elementIsStillValidTarget = isElementVisible(element);
+    var elementMatchesContainsRules = true;
+    // targetElement is specifically the elementPathRule dom node
+    // element is either the element path rule OR the badge element
+    // we can rely on the isElementVisible check as a shortcut for having to call isElementVisible twice
+    if (targetElement && elementIsStillValidTarget && step.elementContainsRulesList) {
+        // Only bother trying to check element contains rules if the element is still visible
+        elementMatchesContainsRules = doesElementMatchContainsRules(targetElement, step.elementContainsRulesList);
+        elementIsStillValidTarget = elementMatchesContainsRules;
+    }
+    if (element && (elementIsStillValidTarget || guideElm.hasClass('mouseover'))) {
+        step.checkPlacement();
+        return;
+    }
+    var isTooltip = (step.type === 'tooltip' || step.attributes.calculatedType === 'tooltip');
+    if (isTooltip && wouldBeVisibleAfterAutoScroll(element) && elementMatchesContainsRules) {
+        // the element was scrolled out of view, the guide should be invisible for now, but still "active"
+        return;
+    }
+    step.hide();
+}
+class BadgePhase {
+    constructor() {
+        this.name = 'badge';
+        this.queue = [];
+    }
+    markDirty() {
+        var badgeGuides = _.filter(frameLocalGuides(getActiveGuides()), isBadge);
+        var hasAdoptGuides = _.find(badgeGuides, function (guide) { return guide.isTraining; });
+        if (hasAdoptGuides) {
+            badgeGuides = prioritizeAdoptOrCoreGuides(badgeGuides, ConfigReader.get('adoptPrioritizeAdoptGuides'));
+        }
+        resetBadgeTargetClaims();
+        this.queue.push.apply(this.queue, badgeGuides);
+    }
+    process(monitor) {
+        var badge = this.queue.shift();
+        monitor.saveContext(badge);
+        if (badge) {
+            badge.placeBadge();
+        }
+    }
+    handleProcessTimeExceeded(monitor) {
+        const badge = monitor.getContext();
+        log.warn('Badge (' + badge.id + ') timeout exceeded');
+    }
+    cancel() {
+        this.queue.length = 0;
+    }
+    isComplete() {
+        return !this.queue.length;
+    }
+}
+function resourceCenterShowingProc(resourceCenter, resourceCenterBadgeProc) {
+    var reEvaluateModuleContent = false;
+    // Find eligible modules
+    var controlGuidesInAllModules = [];
+    var eligibleModules = _.filter(resourceCenter.modules, function (module) {
+        if (!module)
+            return false;
+        // Iframe modules can not dynamically show/hide.
+        if (BuildingBlockResourceCenter.isIframeModule(module))
+            return true;
+        // Sandbox modules can not dynamically show/hide.
+        if (BuildingBlockResourceCenter.isSandboxModule(module))
+            return true;
+        if (BuildingBlockResourceCenter.isIntegrationModule(module)) {
+            if (!BuildingBlockResourceCenter.integrationModuleHasContent(module)) {
+                module.hasResourceCenterContent = false;
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        var eligibleGuidesInModule = _.filter(module.guidesInModule, function (guide) {
+            if (!guide.shouldBeAddedToResourceCenter()) {
+                guide.ineligibleForRC = true;
+                if (guide.control) {
+                    controlGuidesInAllModules.push(guide);
+                }
+                return false;
+            }
+            guide.ineligibleForRC = false;
+            return true;
+        });
+        var isEligible = eligibleGuidesInModule.length;
+        module.hasResourceCenterContent = !!isEligible;
+        // We only need to hash the active module, no other module has content rendered
+        if (resourceCenter.activeModule && module.id === resourceCenter.activeModule.id) {
+            var moduleContentHash = crc32(_.map(eligibleGuidesInModule, function (guide) {
+                // don't change content hash when announcements update their seen state, as that will cause
+                // the RC to re-render (and lose scroll position)
+                var isAnnouncementOrWhatsNew = guide.isAnnouncement() || guide.isWhatsNew();
+                var seenState = isAnnouncementOrWhatsNew ? null : _.pluck(guide.steps, 'seenState');
+                return {
+                    id: guide.id,
+                    seenState
+                };
+            }));
+            if (module.eligibleGuidesInModuleHash && moduleContentHash !== module.eligibleGuidesInModuleHash)
+                reEvaluateModuleContent = true;
+            module.eligibleGuidesInModuleHash = moduleContentHash;
+        }
+        return isEligible;
+    });
+    // If we are rendering the home view and its modules change re-render it
+    var reEvaluateHomeViewContent = false;
+    if (!resourceCenter.activeModule) {
+        var eligibleModulesHash = crc32(_.map(eligibleModules, function (module) {
+            return {
+                id: module.id
+            };
+        }));
+        if (resourceCenter.eligibleModulesHash && resourceCenter.eligibleModulesHash !== eligibleModulesHash) {
+            reEvaluateHomeViewContent = true;
+            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.id, undefined, true);
+        }
+        resourceCenter.eligibleModulesHash = eligibleModulesHash;
+    }
+    resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules);
+    // Skip directly to the one eligible module
+    if (eligibleModules.length === 1) {
+        resourceCenter.skipResourceCenterHomeView = true;
+        resourceCenter.moduleIdToReplaceHomeViewWith = eligibleModules[0].id;
+        var noActiveModule = !resourceCenter.activeModule && reEvaluateHomeViewContent;
+        var differentActiveModule = resourceCenter.activeModule && resourceCenter.activeModule.id !== eligibleModules[0].id;
+        // If the one module is different or content needs to be reevaluated, reload
+        // or if we are on the home view and the modules on the home view have changed
+        if (noActiveModule || differentActiveModule || reEvaluateModuleContent) {
+            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.moduleIdToReplaceHomeViewWith, undefined, true);
+        }
+    }
+    if (eligibleModules) {
+        // find the in-progress native integration module and set continueToNativeModule on both the
+        // RC container and the module since both will try to render
+        var continuedModule = _.find(eligibleModules, function (module) {
+            return module.isContinuation(getLastGuideStepSeen());
+        });
+        var shouldNotResume = _.get(continuedModule, 'attributes.doNotResume');
+        var integrationProvider = _.get(continuedModule, 'attributes.resourceCenter.integrationProvider');
+        var isNativeModule = BuildingBlockResourceCenter.isSupportedNativeIntegration(integrationProvider);
+        if (isNativeModule && !shouldNotResume && resourceCenter) {
+            resourceCenter.continueToNativeModule = true;
+            continuedModule.continueToNativeModule = true;
+        }
+    }
+    // Ensure the active module is still eligible and re-evaluate its content if need be.
+    // Go to Home View if active module is no longer eligible
+    var activeModuleisEligible;
+    if (resourceCenter.activeModule) {
+        activeModuleisEligible = _.find(eligibleModules, function (module) {
+            return module.id === resourceCenter.activeModule.id;
+        });
+        if (activeModuleisEligible && reEvaluateModuleContent) {
+            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.activeModule.id, undefined, true);
+        }
+        if (!activeModuleisEligible) {
+            BuildingBlockResourceCenter.replaceResourceCenterContent(resourceCenter.id);
+        }
+    }
+    BuildingBlockResourceCenter.repositionResourceCenter();
+}
+function resourceCenterNotShowingProc(resourceCenter, resourceCenterBadgeProc) {
+    var eligibleModules = [];
+    var controlGuidesInAllModules = [];
+    var staticModule = _.find(resourceCenter.modules, function (module) {
+        if (BuildingBlockResourceCenter.isIframeModule(module))
+            return true;
+        if (BuildingBlockResourceCenter.isSandboxModule(module))
+            return true;
+        if (BuildingBlockResourceCenter.isIntegrationModule(module)) {
+            if (!BuildingBlockResourceCenter.integrationModuleHasContent(module)) {
+                module.hasResourceCenterContent = false;
+                return false;
+            }
+            else {
+                return true;
             }
-            mouseout();
+        }
+        return false;
+    });
+    if (staticModule) {
+        eligibleModules.push(staticModule);
+    }
+    var allGuidesInModules = _.flatten(_.pluck(resourceCenter.modules, 'guidesInModule'));
+    controlGuidesInAllModules = _.filter(_.compact(allGuidesInModules), function (guide) {
+        return guide.control;
+    });
+    if (!eligibleModules.length) {
+        var moduleLookup = _.reduce(resourceCenter.modules, function (lookup, module) {
+            _.each(module.guidesInModule, function (guide) {
+                lookup[guide.id] = module;
+            });
+            return lookup;
+        }, {});
+        var guidesWithSteps = _.filter(allGuidesInModules, function (guide) {
+            return guide && guide.steps && guide.steps.length;
+        });
+        // Sort guides so that untargeted guides are first
+        var sortedGuides = _.sortBy(guidesWithSteps, function (guide) {
+            return guide.steps[0].elementPathRule ? 1 : 0;
+        });
+        var firstEligibleGuide = _.find(sortedGuides, function (guide) {
+            return guide.shouldBeAddedToResourceCenter();
         });
+        var firstEligibleModule = moduleLookup[firstEligibleGuide && firstEligibleGuide.id];
+        if (firstEligibleModule) {
+            eligibleModules.push(firstEligibleModule);
+        }
     }
-    return badge;
+    resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules);
 }
-/*
- * Maintains the DOM presence of the badge for the specified guide
- * where in the badge is either added or removed depending on if
- * the appropiate DOM element is found.
- *
- * For this reason, when Badges are in the play the setTimeout to
- * keep showing the startGuides needs to also continue running.
- *
- * input: guide obj, and Map of ids to badges being shown currently
- */
-var placeBadge = function (guide, badgesShownObj) {
-    badgesShownObj = badgesShownObj || badgesShown;
-    var badge = badgesShownObj[guide.id];
-    var step = badge ? badge.step() : Badge.findStep(guide);
-    if (!step)
-        return;
-    var target = badge ? badge.target() : getElementForTargeting(step);
-    var isRcBadge = _.get(guide, 'attributes.resourceCenter');
-    if (isRcBadge && !store.getters['frames/canShowRCBadge']()) {
-        if (badge && _.isFunction(badge.hide)) {
-            // If top frame comes in late and RC badge showing in inner frame bc of delay, hide it here
-            badgesShownObj[guide.id] = undefined;
-            badge.hide();
+function resourceCenterBadgeProc(resourceCenter, eligibleModules, controlGuidesInAllModules) {
+    var RCBadge = badgesShown[resourceCenter.id];
+    // If we get no modules back, hide the RC and RC Badge, clear active module
+    if (!eligibleModules || !eligibleModules.length) {
+        var isBadgeActivated = resourceCenter.launchMethod.indexOf('badge') !== -1;
+        var isElementActivated = resourceCenter.launchMethod.indexOf('dom') !== -1;
+        resourceCenter.hasResourceCenterContent = false;
+        // If the RC is badge activated, hide it from the dom completely. Otherwise, leave it alone
+        // This is important for element-activated RC, which should still display with an empty state
+        // even if it has no content
+        if (isBadgeActivated) {
+            if (resourceCenter.isShown())
+                resourceCenter.hide();
+            if (RCBadge) {
+                BuildingBlockResourceCenter.hideRCBadge(RCBadge, resourceCenter);
+            }
+            // If all modules are not eligible because of control group guides
+            // Send guideNotSeen events where appropriate
+            _.each(controlGuidesInAllModules, function (guide) {
+                if (!guide.hasGuideBeenControlled()) {
+                    guide.steps[0].onControlGuide('control');
+                }
+            });
+            resourceCenter.badgeHidden = true;
+            delete resourceCenter.activeModule;
+        }
+        else if (isElementActivated) {
+            resourceCenter.showEmptyState = true;
+            resourceCenter.controlGuidesInAllModules = controlGuidesInAllModules;
         }
-        return;
     }
-    // Don't render the resource center badge if the resource center itself has nothing to show
-    if (isRcBadge && !guide.hasResourceCenterContent)
+    // Show the badge if it was hidden but now has content
+    if (resourceCenter.badgeHidden && resourceCenter.hasResourceCenterContent && !resourceCenter.isNativeModuleActive) {
+        if (!RCBadge) {
+            if (_.isFunction(resourceCenter.placeBadge))
+                resourceCenter.placeBadge();
+            RCBadge = badgesShown[resourceCenter.id];
+        }
+        if (RCBadge)
+            RCBadge.show();
+        resourceCenter.badgeHidden = false;
+    }
+}
+function resourceCenterProc(resourceCenter) {
+    if (!resourceCenter || !resourceCenter.launchMethod)
         return;
-    BuildingBlockResourceCenter.updateNotificationBubbles();
-    var passesElementContainsRules = true;
-    if (step.elementContainsRulesList) {
-        passesElementContainsRules = target && doesElementMatchContainsRules(target, step.elementContainsRulesList);
+    // Reset state to start each loop
+    resourceCenter.skipResourceCenterHomeView = false;
+    resourceCenter.hasResourceCenterContent = true;
+    delete resourceCenter.moduleIdToReplaceHomeViewWith;
+    var activeModule = resourceCenter.activeModule;
+    var activeIntegrationProvider = _.get(activeModule, 'attributes.resourceCenter.integrationProvider');
+    resourceCenter.isNativeModuleActive = activeModule && BuildingBlockResourceCenter.isSupportedNativeIntegration(activeIntegrationProvider);
+    if (resourceCenter.isShown() || !store.getters['frames/isLeader']()) {
+        resourceCenterShowingProc(resourceCenter, resourceCenterBadgeProc);
     }
-    const badgeCanShow = step.elementPathRule &&
-        isElementVisible(target) &&
-        SizzleProxy.matchesSelector(target, step.elementPathRule) &&
-        passesElementContainsRules;
-    if (badgeCanShow) {
-        if (!badge) {
-            badge = Badge.create(guide);
+    else {
+        resourceCenterNotShowingProc(resourceCenter, resourceCenterBadgeProc);
+    }
+    // Hide the badge if we're displaying a native integration module
+    if (resourceCenter.isNativeModuleActive) {
+        if (resourceCenter.isShown())
+            resourceCenter.hide();
+        var RCBadge = badgesShown[resourceCenter.id];
+        if (RCBadge) {
+            BuildingBlockResourceCenter.hideRCBadge(RCBadge, resourceCenter);
         }
-        badge.show();
-        badgesShownObj[guide.id] = badge;
     }
-    else if (badge) {
-        // if the step is being show for this badge then
-        // don't remove it.
-        if (!step.isShown()) {
-            // 3. If the element is not found, remove it if it's currently shown.
-            badgesShownObj[guide.id] = undefined;
-            badge.hide();
+    // Place Element Activated Notification Badge
+    if (resourceCenter.launchMethod === 'dom' && resourceCenter.canShowOnDevice()) {
+        BuildingBlockResourceCenter.updateNotificationBubbles();
+        BuildingBlockResourceCenter.adjustNotificationBubbleForResize();
+    }
+}
+class PhaseProcessTimeMonitor {
+    constructor(timeLimit = 50) {
+        this.startTime = -1;
+        this.timeLimit = timeLimit;
+        this.context = null;
+    }
+    start() {
+        this.context = null;
+        this.startTime = getNow();
+    }
+    isTimeExceeded() {
+        const currTime = getNow();
+        return (currTime - this.startTime) > this.timeLimit;
+    }
+    saveContext(context) {
+        this.context = context;
+    }
+    getContext() {
+        return this.context;
+    }
+}
+class UpdateRunner {
+    constructor(phases) {
+        this.phases = phases;
+        this.queue = [];
+        this.paused = false;
+    }
+    markDirty() {
+        for (let phase of this.phases) {
+            phase.markDirty();
         }
+        this.queue = this.phases.slice();
     }
-    if (isDebuggingEnabled()) {
-        Events.stepEligibility.trigger({
-            stepId: step.id,
-            guideId: guide.id,
-            eligible: badgeCanShow,
-            reason: 'target_element_badge'
+    runGuidePhase() {
+        const currentPhase = this.queue[0];
+        var promise;
+        const monitor = new PhaseProcessTimeMonitor(50);
+        while (!this.timedOut() && !currentPhase.isComplete() && !promise) {
+            monitor.start();
+            promise = currentPhase.process(monitor);
+            if (!promise && monitor.isTimeExceeded()) {
+                performanceMonitor.count(GUIDE_LOOP_TIMEOUT);
+                if (currentPhase.handleProcessTimeExceeded) {
+                    currentPhase.handleProcessTimeExceeded(monitor);
+                }
+                this.ejectGuide(monitor.getContext());
+            }
+        }
+        if (isPromise(promise)) {
+            var id = this.updateId;
+            var resume = _.bind(function () {
+                if (this.updateId === id) {
+                    this.paused = false;
+                    startGuides();
+                }
+            }, this);
+            this.paused = true;
+            promise.then(resume).catch(resume);
+        }
+        else if (currentPhase.isComplete()) {
+            this.queue.shift();
+        }
+    }
+    addPhase(phaseFn, phaseName) {
+        phaseName = phaseName || phaseFn.name || this.phases.length;
+        if (_.isFunction(phaseFn)) {
+            phaseFn = new SimplePhase(phaseName, phaseFn);
+        }
+        this.phases.push(phaseFn);
+    }
+    removePhase(phaseName) {
+        var i = _.findIndex(this.phases, function (phase) {
+            return phase.name === phaseName;
         });
+        if (i >= 0) {
+            this.phases.splice(i, 1);
+        }
     }
-    BuildingBlockResourceCenter.repositionDoubleResourceCenterBadge();
-};
-var removeAllBadges = function () {
-    _.map(badgesShown, removeBadge);
-    setBadgesShown({});
-};
-var removeBadge = function (badge, guide) {
-    if (!badge)
-        return;
-    if (_.isFunction(badge.hide)) {
-        badge.hide();
+    timedOut() {
+        if (!this.iterationStartTime)
+            return false;
+        var elapsed = getNow() - this.iterationStartTime;
+        return elapsed > store.state.guideUpdate.iterationTimeLimit;
     }
-    if (_.isFunction(badge.shouldShow) && !badge.shouldShow() && guide) {
-        delete badgesShown[guide.id];
+    ejectGuide(guide) {
+        if (this.ejectOnTimeout === undefined) {
+            this.ejectOnTimeout = ConfigReader.get('guides.ejectOnTimeout');
+        }
+        if (this.ejectOnTimeout && guide && !guide.isShown()) {
+            Tombstone.addGuide(guide);
+        }
     }
-};
-var removeBadgeForGuide = function (guideGroup) {
-    var badge = badgesShown[guideGroup.id];
-    if (badge) {
-        removeBadge(badge, guideGroup);
+    process() {
+        var now = getNow();
+        if (!this.updateId) {
+            this.updateId = now;
+            this.updateTotalTime = 0;
+            store.commit('guideUpdate/startUpdate', now);
+        }
+        this.iterationStartTime = now;
+        while (!this.paused &&
+            this.queue.length &&
+            !this.timedOut()) {
+            this.runGuidePhase();
+        }
+        now = getNow();
+        this.updateTotalTime += now - this.iterationStartTime;
+        if (this.isComplete()) {
+            this.complete(now);
+        }
     }
-};
-function _adjustBadgesForResize() {
-    _.map(badgesShown, function (badge) {
-        if (badge && badge.show) {
-            badge.show();
+    complete(time) {
+        store.commit('guideUpdate/completeUpdate', time);
+        this.cancel();
+    }
+    cancel() {
+        this.updateId = null;
+        this.paused = false;
+        this.queue.length = 0;
+        for (let phase of this.phases) {
+            if (_.isFunction(phase.cancel)) {
+                phase.cancel();
+            }
         }
-    });
+    }
+    isComplete() {
+        return !this.queue.length;
+    }
 }
-var adjustBadgesForResize = _.throttle(_adjustBadgesForResize, 10);
-function pruneBadges(activeGuideIds) {
-    if (!activeGuideIds || !activeGuideIds.length)
-        return;
-    const lookup = _.indexBy(activeGuideIds);
-    _.each(badgesShown, function (badge, guideId) {
-        if (!lookup[guideId]) {
-            badge.hide();
-            delete badgesShown[guideId];
-        }
-    });
+var updateRunner = new UpdateRunner([
+    new SimplePhase('guideShowing', guideShowingProc),
+    new AutoDisplayPhase(),
+    new BadgePhase(),
+    new SimplePhase('resourceCenter', function () {
+        resourceCenterProc(BuildingBlockResourceCenter.getResourceCenter());
+    }),
+    new SimplePhase('frameVisibility', function () {
+        store.dispatch('frames/checkFrameVisibility');
+    })
+]);
+function addUpdatePhase() {
+    updateRunner.addPhase(...arguments);
+}
+function removeUpdatePhase() {
+    updateRunner.removePhase(...arguments);
 }
 
 /**
@@ -23517,7 +23571,7 @@ function registerPostrenderScripts(runtime) {
     });
 }
 
-const pendoLocalStorage$3 = agentStorage.getLocal();
+const pendoLocalStorage$2 = agentStorage.getLocal();
 var guideEvtCache = [];
 var controlGuideLogMessage = 'Guide was not shown because this visitor is in a control group of an active experiment for the guide';
 /**
@@ -25315,7 +25369,7 @@ var handleResizeOnVideoFullScreenChange = function (event) {
 function shouldReloadGuides(url, visitorId, accountId, metadataHash) {
     if (!url || !pendo$1.apiKey)
         return false;
-    if (areGuidesDisabled() && !(pendoLocalStorage$3.getItem('pendo-designer-mode') === 'true'))
+    if (areGuidesDisabled() && !(pendoLocalStorage$2.getItem('pendo-designer-mode') === 'true'))
         return false;
     return (url !== reloadGuides.lastUrl ||
         visitorId !== reloadGuides.lastVisitorId ||
@@ -25399,6 +25453,180 @@ function getActiveGuide(options) {
     };
 }
 
+var RELAY_FRAME_ID = 'pendo-live-preview-relay';
+var RELAY_FILE = 'live-preview.html';
+var MESSAGE_CONFIG = 'pendo-live-preview::config';
+var MESSAGE_READY = 'pendo-live-preview::ready';
+var MESSAGE_UPDATE = 'pendo-live-preview::update';
+var MESSAGE_END = 'pendo-live-preview::end';
+var MESSAGE_ENDED = 'pendo-live-preview::ended';
+var MESSAGE_END_ACK = 'pendo-live-preview::end-ack';
+var RELAY_END_MESSAGE_TIMEOUT = 2000;
+var activeRelay = null;
+function isRelayMessage(event, relay) {
+    return event.source === relay.frame.contentWindow && !!event.data;
+}
+function sendConfig(relay) {
+    if (!relay.frame.contentWindow)
+        return;
+    relay.frame.contentWindow.postMessage({
+        type: MESSAGE_CONFIG,
+        livePreview: relay.payload
+    }, relay.origin);
+}
+function teardownRelay(relay) {
+    window.removeEventListener('message', relay.listener, false);
+    dom(relay.frame).remove();
+}
+function waitForRelayEndMessage(relay, onStopped) {
+    var timer = setTimeout$1(finish, RELAY_END_MESSAGE_TIMEOUT);
+    function finish() {
+        clearTimeout(timer);
+        window.removeEventListener('message', onMessage, false);
+        onStopped();
+    }
+    function onMessage(event) {
+        if (!isRelayMessage(event, relay))
+            return;
+        if (event.data.type === MESSAGE_END_ACK || event.data.type === MESSAGE_ENDED) {
+            finish();
+        }
+    }
+    window.addEventListener('message', onMessage, false);
+}
+function getRelayUrl() {
+    // TODO: Support fetching the relay URL from designer lookasides
+    var host = DESIGNER_SERVER || SERVER;
+    var url = host + '/in-app-designer/latest/' + RELAY_FILE;
+    var separator = url.indexOf('?') === -1 ? '?' : '&';
+    return url + separator + 'parentOrigin=' + encodeURIComponent(window.location.origin);
+}
+function getRelayOrigin(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch (err) {
+        return '*';
+    }
+}
+function resolveSurvivingPreviewPosition(previousGuide, updatedGuide, savedPosition) {
+    if (!savedPosition || !updatedGuide)
+        return savedPosition;
+    var updatedSteps = updatedGuide.steps || [];
+    var updatedGuideId = updatedGuide.id;
+    if (!updatedSteps.length || savedPosition.guideId !== updatedGuideId)
+        return savedPosition;
+    if (savedPosition.state !== 'active' && savedPosition.state !== 'advanced')
+        return savedPosition;
+    var targetStepId = savedPosition.state === 'advanced' && savedPosition.destinationStepId;
+    if (!targetStepId)
+        targetStepId = savedPosition.guideStepId;
+    var savedGuideStepSurvives = _.some(updatedSteps, { id: savedPosition.guideStepId });
+    var targetStepSurvives = _.some(updatedSteps, { id: targetStepId });
+    if (savedGuideStepSurvives && targetStepSurvives)
+        return savedPosition;
+    var survivingStepId;
+    if (targetStepSurvives) {
+        survivingStepId = targetStepId;
+    }
+    else {
+        const previousSteps = previousGuide && previousGuide.id === updatedGuideId
+            ? previousGuide.steps || []
+            : [];
+        const targetStepIndex = _.findIndex(previousSteps, { id: targetStepId });
+        const clampedStepIndex = Math.min(Math.max(targetStepIndex, 0), updatedSteps.length - 1);
+        survivingStepId = updatedSteps[clampedStepIndex].id;
+    }
+    return {
+        guideId: updatedGuideId,
+        guideStepId: survivingStepId,
+        state: 'active'
+    };
+}
+function createRelayFrame(url) {
+    var frame = document.createElement('iframe');
+    frame.id = RELAY_FRAME_ID;
+    frame.setAttribute('aria-hidden', 'true');
+    frame.setAttribute('sandbox', 'allow-scripts allow-same-origin allow-storage-access-by-user-activation');
+    frame.style.display = 'none';
+    frame.src = url;
+    return frame;
+}
+function hasLivePreviewRelay() {
+    return !!activeRelay;
+}
+function applyRelayUpdate(payload) {
+    var previousGuide = _.get(store.state, 'preview.designerPreview.guide');
+    var updatedGuide = payload.guide;
+    var savedPosition = _.get(store.state, 'preview.preview.state') || getLastGuideStepSeen();
+    var survivingPosition = resolveSurvivingPreviewPosition(previousGuide, updatedGuide, savedPosition);
+    store.commit('preview/setDesignerPreview', payload);
+    if (survivingPosition !== savedPosition) {
+        survivingPosition.time = getNow();
+        writeLastStepSeenCache(survivingPosition);
+        store.dispatch('preview/update', survivingPosition);
+    }
+    forceGuideReload();
+}
+function startLivePreviewRelay(livePreview, onEnded) {
+    if (!livePreview || activeRelay)
+        return;
+    var url = getRelayUrl();
+    var frame = createRelayFrame(url);
+    var relay = {
+        frame,
+        origin: getRelayOrigin(url),
+        payload: livePreview,
+        listener: onMessage
+    };
+    function onMessage(event) {
+        if (!isRelayMessage(event, relay))
+            return;
+        if (event.data.type === MESSAGE_READY) {
+            sendConfig(relay);
+            return;
+        }
+        if (event.data.type === MESSAGE_ENDED) {
+            teardownRelay(relay);
+            activeRelay = null;
+            if (onEnded)
+                onEnded();
+            return;
+        }
+        if (event.data.type !== MESSAGE_UPDATE)
+            return;
+        applyRelayUpdate(event.data.payload);
+    }
+    activeRelay = relay;
+    window.addEventListener('message', onMessage, false);
+    getBody().appendChild(frame);
+}
+function stopLivePreviewRelay(onStopped) {
+    var relay = activeRelay;
+    activeRelay = null;
+    if (!relay) {
+        if (onStopped)
+            onStopped();
+        return;
+    }
+    if (!relay.frame.contentWindow) {
+        teardownRelay(relay);
+        if (onStopped)
+            onStopped();
+        return;
+    }
+    window.removeEventListener('message', relay.listener, false);
+    // Removing the frame now would destroy the ::end below, so the callback removes it once the relay answers
+    waitForRelayEndMessage(relay, function () {
+        dom(relay.frame).remove();
+        if (onStopped)
+            onStopped();
+    });
+    relay.frame.contentWindow.postMessage({
+        type: MESSAGE_END
+    }, relay.origin);
+}
+
 var REMOVE_FRAME_ACTION = 'frames/removeFrame';
 function tryParseJson(messageData) {
     if (!_.isString(messageData)) {
@@ -25913,7 +26141,8 @@ function initializeCrossFrameChannel(store) {
     return () => crossFrameChannel.close();
 }
 
-const pendoLocalStorage$2 = agentStorage.getLocal();
+const pendoLocalStorage$1 = agentStorage.getLocal();
+var pendoLivePreview$1 = 'pendo-live-preview';
 var pendoPreview$1 = 'pendo-preview';
 var designerPreview$1 = 'current-guide-preview';
 var previewFrame;
@@ -25927,6 +26156,11 @@ function startPreviewMode(window) {
         return;
     addPreviewUI(window);
     store.dispatch('preview/start', _.extend(config));
+    if (config.livePreview) {
+        startLivePreviewRelay(config.livePreview, function () {
+            exitPreviewMode({ preventWindowClose: false });
+        });
+    }
     agentStorage.clear(LAST_STEP_ADVANCED_COOKIE);
     enableCookies(false);
     buffers.lock();
@@ -25990,7 +26224,7 @@ function restartPreview(activeGuides, lastGuideStepSeen, language) {
     var config = findStoredPreviewConfig();
     // Go back to 1st step of walkthrough on explicit restart
     if (config) {
-        var previewGuide = _.findWhere(activeGuides, { id: config.guideId });
+        var previewGuide = _.findWhere(activeGuides, { id: getPreviewGuideId(config) });
         if (previewGuide) {
             var restartConfig = { stepId: previewGuide.steps[0].id };
             // language is used in `previewGuideRequest` to generate the proper urls for rendering translations
@@ -26114,6 +26348,7 @@ function prepareDesignerPreviewGuide() {
         currentPreviewGuideConfig.guide.expiresAfter = null;
         return [currentPreviewGuideConfig.guide];
     }
+    return [];
 }
 function preparePreviewGuides(activeGuides) {
     var config = findStoredPreviewConfig();
@@ -26192,7 +26427,8 @@ function preparePreviewLastGuideStepSeen(activeGuides, lastGuideStepSeen) {
     var config = findStoredPreviewConfig();
     if (!config)
         return lastGuideStepSeen;
-    var previewGuide = _.findWhere(activeGuides, { id: config.guideId });
+    var guideId = getPreviewGuideId(config);
+    var previewGuide = _.findWhere(activeGuides, { id: guideId });
     if (!previewGuide)
         return lastGuideStepSeen;
     if (config.state)
@@ -26205,7 +26441,7 @@ function preparePreviewLastGuideStepSeen(activeGuides, lastGuideStepSeen) {
         return {};
     }
     return {
-        guideId: config.guideId,
+        guideId,
         guideStepId: config.stepId,
         state: 'active'
     };
@@ -26253,9 +26489,13 @@ function updatePreview(document, activeGuides, lastGuideStepSeen) {
             }
         }, location.origin);
     }
+    var previewGuideId = getPreviewGuideId(config);
     var guide = _.find(activeGuides, function (guide) {
-        return guide.id === config.guideId;
+        return guide.id === previewGuideId;
     });
+    // In live preview the guide may not have been relayed yet; skip this tick and retry on the next.
+    if (!guide && config.livePreview)
+        return;
     var currentStepIndex = 0;
     var stepCount = guide.steps.length;
     var lastSeen = lastGuideStepSeen || {};
@@ -26417,7 +26657,7 @@ function exitPreviewMode(designerConfig) {
     if (currentPreviewGuideConfig) {
         wasInDesignerSameTabPreview = currentPreviewGuideConfig.previewModeType === 'SAME_TAB';
     }
-    var storedNavigationMode = pendoLocalStorage$2.getItem('pendo-navigation-state');
+    var storedNavigationMode = pendoLocalStorage$1.getItem('pendo-navigation-state');
     store.dispatch('preview/exit');
     hideGuides({ stayHidden: true });
     agentStorage.clear(LAST_STEP_ADVANCED_COOKIE);
@@ -26426,30 +26666,37 @@ function exitPreviewMode(designerConfig) {
     restoreGuideLoader();
     removeUpdatePhase(updatePreviewUI);
     enableCookies(true);
-    // Try to launch back into designer
-    if (wasInDesignerSameTabPreview && storedNavigationMode) {
-        pendoLocalStorage$2.setItem(designerPreview$1, JSON.stringify(_.extend(currentPreviewGuideConfig, { isExitBackToDesigner: true })));
-        try {
-            var message = JSON.parse(storedNavigationMode);
-            var launchOptions = {
-                target: message.baseUrl,
-                gcsBucket: message.gcsBucket,
-                preloader: true,
-                DADesigner: message.isDADesigner,
-                host: message.host,
-                forceNativeDesigner: currentPreviewGuideConfig.guide.appPlatform === 'web'
-            };
-            store.dispatch('preview/launchInAppDesigner', launchOptions);
-        }
-        catch (err) {
-            store.dispatch('preview/exitDesignerPreview');
+    function finishExit() {
+        // Try to launch back into designer
+        if (wasInDesignerSameTabPreview && storedNavigationMode) {
+            pendoLocalStorage$1.setItem(designerPreview$1, JSON.stringify(_.extend(currentPreviewGuideConfig, { isExitBackToDesigner: true })));
+            try {
+                var message = JSON.parse(storedNavigationMode);
+                var launchOptions = {
+                    target: message.baseUrl,
+                    gcsBucket: message.gcsBucket,
+                    preloader: true,
+                    DADesigner: message.isDADesigner,
+                    host: message.host,
+                    forceNativeDesigner: currentPreviewGuideConfig.guide.appPlatform === 'web'
+                };
+                store.dispatch('preview/launchInAppDesigner', launchOptions);
+            }
+            catch (err) {
+                store.dispatch('preview/exitDesignerPreview');
+            }
+            return;
         }
+        if (designerConfig && !designerConfig.preventWindowClose)
+            window.close();
+        // For cases when window.close() does not work, as when exiting restored preview sessions in newly opened windows, resume normal guide display
+        forceGuideReload();
+    }
+    if (hasLivePreviewRelay()) {
+        stopLivePreviewRelay(finishExit);
         return;
     }
-    if (designerConfig && !designerConfig.preventWindowClose)
-        window.close();
-    // For cases when window.close() does not work, as when exiting restored preview sessions in newly opened windows, resume normal guide display
-    forceGuideReload();
+    finishExit();
 }
 function clonePreviewConfig(getStore, path) {
     var previewConfig = _.get(getStore(), path);
@@ -26462,6 +26709,14 @@ function getStore() {
 }
 var findStoredPreviewConfig = _.partial(clonePreviewConfig, getStore, 'state.preview.preview');
 var findStoredDesignerPreviewConfig = _.partial(clonePreviewConfig, getStore, 'state.preview.designerPreview');
+function getPreviewGuideId(config) {
+    if (config.guideId)
+        return config.guideId;
+    // config.guideId is empty for unsaved guides in live preview
+    // Live preview relies on guide id from the websocket relay instead
+    if (config.livePreview)
+        return _.get(findStoredDesignerPreviewConfig(), 'guide.id');
+}
 function getGuideUrl(config) {
     if (!config.subscriptionId || !config.guideId)
         return;
@@ -26510,6 +26765,35 @@ function previewGuideRequest(config, id) {
         log.info('Invalid origin, exiting preview');
         return q.reject('invalid origin');
     }
+    // In live preview, the guide comes from the websocket relay (see live-preview-relay.js) and
+    // stored on state.preview.designerPreview.  We render it directly and skip the backend fetch.
+    if (config.livePreview) {
+        var livePreviewConfig = findStoredDesignerPreviewConfig();
+        var liveGuides = prepareDesignerPreviewGuide();
+        if (!livePreviewConfig || !liveGuides.length || !liveGuides[0].steps.length) {
+            pendo$1.guidesPayload({
+                id,
+                lastGuideStepSeen: {},
+                guides: []
+            });
+            return q.resolve();
+        }
+        var liveGuide = liveGuides[0];
+        coerceGuideForPreview(liveGuide);
+        formatGuideSeenStateForPreviewGuide(liveGuide, config.stepId);
+        pendo$1.guideWidget = {
+            enabled: false,
+            data: { guideCssUrl: livePreviewConfig.guideCssUrl }
+        };
+        pendo$1.guideCssUrl = livePreviewConfig.guideCssUrl;
+        pendo$1.throttling = undefined;
+        pendo$1.guidesPayload({
+            id,
+            lastGuideStepSeen: preparePreviewLastGuideStepSeen(liveGuides, pendo$1.lastGuideStepSeen),
+            guides: liveGuides
+        });
+        return q.resolve();
+    }
     var guideURL = getGuideUrl(config);
     if (!guideURL) {
         log.info('Invalid guide url, exiting preview');
@@ -26599,9 +26883,16 @@ function previewGuideRequest(config, id) {
 }
 function previewLoadGuideJs(url, callback) {
     var config = findStoredPreviewConfig();
-    if (!config || !getGuideUrl(config))
+    if (!config)
         return q.reject();
     var match = /[?&]id=(\d+)/.exec(url);
+    // Live preview has no backend guide URL, but the url still carries the internal guide-request id
+    // that guidesPayload matches against; render the relayed guide directly.
+    if (config.livePreview) {
+        return previewGuideRequest(config, match && match[1]).then(callback);
+    }
+    if (!getGuideUrl(config))
+        return q.reject();
     if (!match || match.length < 1)
         return q.reject();
     return previewGuideRequest(config, match[1]).then(callback);
@@ -26725,7 +27016,7 @@ const Keys = (function () {
     };
 })();
 
-const pendoLocalStorage$1 = agentStorage.getLocal();
+const pendoLocalStorage = agentStorage.getLocal();
 var DesignerV2 = (function () {
     // Always use the production server for CNAME customers
     var host = DESIGNER_SERVER || SERVER;
@@ -26739,7 +27030,7 @@ var DesignerV2 = (function () {
     function localStorageNavigation(options) {
         if (options.ignoreLocalStorageNavigation)
             return;
-        var storedNavigationMode = pendoLocalStorage$1.getItem('pendo-navigation-state');
+        var storedNavigationMode = pendoLocalStorage.getItem('pendo-navigation-state');
         if (!storedNavigationMode)
             return;
         // only launch from local storage if you are the leader frame
@@ -27456,6 +27747,16 @@ function launchDesignerOrPreview(options) {
     * @label designerPreview
     */
     agentStorage.registry.addLocal(designerPreview$1, { localStorageOnly: true });
+    /**
+    * Ephemeral live-preview session handoff. Scoped to the tab so it survives reloads
+    * but is never restored in a freshly opened preview tab.
+    *
+    * @name pendo-live-preview
+    * @category Cookies/sessionStorage
+    * @access public
+    * @label pendoLivePreview
+    */
+    agentStorage.registry.addSession(pendoLivePreview$1);
     // in order, try to launch:
     // 1) designer
     // 2) preview
@@ -28704,6 +29005,7 @@ const PluginAPI = {
         SERVER,
         DESIGNER_SERVER
     },
+    isTrustedOrigin,
     NodeSerializer,
     q,
     SendQueue,
@@ -34447,7 +34749,16 @@ var FramesModule = (function () {
         testSelector(context, payload) {
             const { selector, sourceFrame, promiseId } = payload;
             const startTime = performance.now();
-            const count = pendo$1.dom(selector).length;
+            let count = 0;
+            // Sizzle only ever matches selectors. pendo.dom would parse a payload that
+            // starts with '<' as HTML, through innerHTML on the live document (APP-165872).
+            // It also swallowed invalid selectors, which Sizzle throws on.
+            try {
+                count = SizzleProxy(selector).length;
+            }
+            catch (e) {
+                count = 0;
+            }
             const timing = performance.now() - startTime;
             if (promiseId && sourceFrame) {
                 crossFrameChannel.postMessage({
@@ -35035,7 +35346,7 @@ var MetadataModule = (function () {
     };
 })();
 
-const pendoLocalStorage = agentStorage.getLocal();
+var pendoLivePreview = 'pendo-live-preview';
 var pendoPreview = 'pendo-preview';
 var designerPreview = 'current-guide-preview';
 var PreviewModule = (function () {
@@ -35059,11 +35370,15 @@ var PreviewModule = (function () {
         load(context) {
             try {
                 var storage = context.getters.storage();
-                var config = JSON.parse(storage.getItem(pendoPreview));
+                var config = JSON.parse(storage.getLocal().getItem(pendoPreview));
                 if (config.apiKey === pendo$1.apiKey) {
+                    var livePreviewConfig = JSON.parse(storage.getSession().getItem(pendoLivePreview));
+                    if (livePreviewConfig) {
+                        config.livePreview = livePreviewConfig;
+                    }
                     context.commit('setPreview', config);
                 }
-                var designerPreviewConfig = storage.getItem(designerPreview);
+                var designerPreviewConfig = storage.getLocal().getItem(designerPreview);
                 if (designerPreviewConfig) {
                     context.commit('setDesignerPreview', JSON.parse(designerPreviewConfig));
                 }
@@ -35074,11 +35389,19 @@ var PreviewModule = (function () {
         write(context) {
             try {
                 var storage = context.getters.storage();
-                if (context.state.preview) {
-                    storage.setItem(pendoPreview, JSON.stringify(context.state.preview));
+                var preview = context.state.preview;
+                var livePreview = preview && preview.livePreview;
+                if (preview) {
+                    storage.getLocal().setItem(pendoPreview, JSON.stringify(_.omit(preview, 'livePreview')));
+                }
+                else {
+                    storage.getLocal().removeItem(pendoPreview);
+                }
+                if (livePreview) {
+                    storage.getSession().setItem(pendoLivePreview, JSON.stringify(livePreview));
                 }
                 else {
-                    storage.removeItem(pendoPreview);
+                    storage.getSession().removeItem(pendoLivePreview);
                 }
             }
             catch (e) {
@@ -35090,8 +35413,7 @@ var PreviewModule = (function () {
         },
         exitDesignerPreview(context) {
             context.commit('setDesignerPreview', null);
-            var storage = context.getters.storage();
-            storage.removeItem(designerPreview);
+            context.getters.storage().getLocal().removeItem(designerPreview);
         },
         launchInAppDesigner(context, launchOptions) {
             DesignerV2.launchInAppDesigner(launchOptions);
@@ -35118,7 +35440,7 @@ var PreviewModule = (function () {
             return !!state.designerPreview && getters.isInPreviewMode();
         },
         storage() {
-            return pendoLocalStorage;
+            return agentStorage;
         }
     };
     return {
@@ -35274,13 +35596,10 @@ function highlight(dom, elements) {
 }
 function highlightElements(dom, selector) {
     try {
-        const query = dom(selector);
-        const total = query ? query.length : 0;
-        const elements = [];
-        for (let i = 0; i < total; i++) {
-            elements.push(query[i]);
-        }
-        return highlight(dom, elements);
+        // Sizzle rather than dom() so a selector arriving over the cross-frame channel
+        // can't reach dom()'s innerHTML branch (APP-165872). dom is still needed below
+        // for the overlay elements it builds.
+        return highlight(dom, SizzleProxy(selector));
     }
     catch (e) {
         clearHighlights();
@@ -40919,6 +41238,14 @@ class DOMPrompt {
         });
     }
     setupObserver() {
+        if (!document.body) {
+            this.observerReadyListener = () => {
+                document.removeEventListener('DOMContentLoaded', this.observerReadyListener);
+                this.setupObserver();
+            };
+            document.addEventListener('DOMContentLoaded', this.observerReadyListener);
+            return;
+        }
         this.promptContainer = new this.dom.Observer();
         const validInputEls = this._.filter(this.inputEls, el => el);
         const validSubmitEls = this._.filter(this.submitEls, el => el);
@@ -40994,6 +41321,9 @@ class DOMPrompt {
         });
     }
     teardown() {
+        if (this.observerReadyListener) {
+            document.removeEventListener('DOMContentLoaded', this.observerReadyListener);
+        }
         if (this.promptContainer) {
             this.promptContainer.teardown();
         }
@@ -41038,7 +41368,8 @@ class PromptPlugin {
         // register config schema
         this.api.ConfigReader.addOption(this.configName, ['pendoconfig', 'snippet']);
         this.loadConfig(this.configName)
-            .then(config => this.onConfigLoaded(config)).catch(() => { });
+            .then(config => this.onConfigLoaded(config))
+            .catch(err => this.api.log.error('[PromptPlugin] Failed to load config:', err));
         // Listen for URL changes to re-evaluate page rules
         // guidesLoaded: normalizedUrl comes back from the guides payload
         // urlChanged: handles SPA navigation where guides may already be cached and guidesLoaded won't re-fire
@@ -41104,7 +41435,12 @@ class PromptPlugin {
             const isCurrentlyActive = this._.contains(currentlyActiveIds, aiAgent.id);
             const shouldBeActive = this.testPageRule(aiAgent.pageRule, currentUrl, aiAgent.id);
             if (shouldBeActive && !isCurrentlyActive) {
-                this.observePrompt(aiAgent);
+                try {
+                    this.observePrompt(aiAgent);
+                }
+                catch (err) {
+                    this.api.log.error('[PromptPlugin] Failed to set up agent:', aiAgent.id, err);
+                }
             }
         });
     }
@@ -41153,7 +41489,12 @@ class PromptPlugin {
         this._.each(domAgents, aiAgent => {
             const currentUrl = getNormalizedUrl();
             if (this.testPageRule(aiAgent.pageRule, currentUrl, aiAgent.id)) {
-                this.observePrompt(aiAgent);
+                try {
+                    this.observePrompt(aiAgent);
+                }
+                catch (err) {
+                    this.api.log.error('[PromptPlugin] Failed to set up agent:', aiAgent.id, err);
+                }
             }
         });
     }
@@ -43468,6 +43809,7 @@ const MESSAGE_PROMISE = 'promise';
  * @property {*} requestId  - The id of the request. This is used to match responses to requests.
  * @property {*} sender - The name of the sender. This is used to determine if the message is from a trusted source.
  * @property {*} destination - The destination of the message. This is used to determine where to send the message.
+ * @property {*} origin - The origin a received message arrived from. Responses are targeted back at it.
  */
 function Message(name, type, data) {
     this.name = name;
@@ -43496,6 +43838,7 @@ const fromEvent = (event) => {
         message.requestId = requestId;
         message.sender = sender;
         message.destination = event.source;
+        message.origin = event.origin;
         message.isResponse = isResponse;
 
         return message;
@@ -43505,7 +43848,7 @@ const fromEvent = (event) => {
 };
 
 const serialize = (message) => {
-    const redacted = omit(message, ['destination', 'toString', 'data']);
+    const redacted = omit(message, ['destination', 'origin', 'toString', 'data']);
     redacted.data = JSON.stringify(message.data, (key, value) => {
         if (typeof value === 'function' || value instanceof RegExp) {
             return value.toString ? value.toString() : undefined; // return undefined to omit
@@ -43621,14 +43964,24 @@ const state = {
     topics: {},
     senderIds: {},
     originProvider: undefined,
+    isOriginAllowed: undefined,
     destinationProvider: undefined
 };
 
 const getListener = () => `${state.appName}${state.connectionName}(${state.frameId})`;
 
+// An opaque origin (sandboxed frame, file://) serializes to the string "null",
+// which postMessage rejects as a targetOrigin, so those fall back to the provider.
+const getTargetOrigin = (message) => {
+    if (message.origin && message.origin !== 'null') return message.origin;
+
+    return state.originProvider();
+};
+
 const _send = (message) => {
     if (!message.sender) message.sender = getListener();
     const win = message.destination || state.destinationProvider();
+    const targetOrigin = getTargetOrigin(message);
     const redactedMessage = serialize(message);
 
     const port = getPortForSender(message.sender);
@@ -43638,11 +43991,11 @@ const _send = (message) => {
         // XXX Need to handle the scenario where MessageChannel is unavailable
         const channel = new MessageChannel();
         addPort(channel.port1, message.sender);
-        win.postMessage(redactedMessage, state.originProvider(), [channel.port2]);
+        win.postMessage(redactedMessage, targetOrigin, [channel.port2]);
     } else if (port) {
         port.postMessage(redactedMessage);
     } else {
-        win.postMessage(redactedMessage, state.originProvider());
+        win.postMessage(redactedMessage, targetOrigin);
     }
 };
 
@@ -43772,6 +44125,8 @@ const commonFns = pipe(
 );
 
 const filterWrongOrigin = (event) => {
+    if (state.isOriginAllowed) return state.isOriginAllowed(event.origin) ? event : false;
+
     if (state.originProvider() === '*') return event;
 
     return event.origin === state.originProvider() ? event : false;
@@ -43836,7 +44191,8 @@ const startListening = (
         originProvider,
         destinationProvider,
         usePingAutoReconnect = false,
-        connectionName
+        connectionName,
+        isOriginAllowed
     ) => {
     if (!window.addEventListener) return;
     state.appName = appName;
@@ -43845,6 +44201,7 @@ const startListening = (
     state.usePingAutoReconnect = usePingAutoReconnect;
     state.connectionName = connectionName || '';
 
+    state.isOriginAllowed = typeof isOriginAllowed === 'function' ? isOriginAllowed : undefined;
     state.originProvider = originProvider || (() => window.location.origin || '*');
     state.destinationProvider = destinationProvider || (() => window.parent || window.top);
 
@@ -43920,7 +44277,11 @@ function VocPortal() {
         pluginAPI = PluginAPI;
         const { frameId } = PluginAPI.EventTracer.addTracerIds({});
         this.removeResizeEvent = pendoGlobal.attachEvent(window, 'resize', resizePortalIframe);
-        startListening('VocPortal', frameId, routeHandlerLookup, () => '*');
+        startListening('VocPortal', frameId, routeHandlerLookup, undefined, // originProvider, unused: replies target the origin that asked
+        undefined, // destinationProvider
+        undefined, // usePingAutoReconnect
+        undefined, // connectionName
+        pluginAPI.isTrustedOrigin);
         try {
             observePortalContainer();
         }
@@ -50646,6 +51007,113 @@ class Transport {
     }
 }
 
+const CATCHALL_TYPES = ['load', 'click', 'track'];
+const EVENT_KINDS = {
+    catchall: 'catchall',
+    devlog: 'devlog',
+    recording: 'recording'
+};
+class LiveReplayClient {
+    constructor(pendo, api) {
+        this.pendo = pendo;
+        this.api = api;
+        this.ws = null;
+        this.sequence = 0;
+        this.unsubscribeEventCaptured = null;
+    }
+    buildWsUrl() {
+        const url = new URL$1(`${this.pendo.HOST}/data/live-replay/${this.pendo.apiKey}`);
+        if (url.protocol === 'http:') {
+            url.protocol = 'ws:';
+        }
+        else if (url.protocol === 'https:') {
+            url.protocol = 'wss:';
+        }
+        return url.href;
+    }
+    start(visitorId, onOpen) {
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED)
+            return;
+        this.sequence = 0;
+        this.unsubscribeEventCaptured = this.api.attachEvent(this.api.Events, 'eventCaptured', this.pendo._.bind(this.forwardEvent, this));
+        this.ws = new WebSocket(this.buildWsUrl());
+        this.ws.onopen = this.pendo._.bind(this.handleOpen, this, visitorId, onOpen);
+        const boundHandleClose = this.pendo._.bind(this.handleClose, this);
+        this.ws.onclose = boundHandleClose;
+        this.ws.onerror = boundHandleClose;
+    }
+    handleOpen(visitorId, onOpen) {
+        this.sendAuth(visitorId);
+        if (onOpen)
+            onOpen();
+    }
+    handleClose() {
+        this.unsubscribeFromEvents();
+    }
+    unsubscribeFromEvents() {
+        if (!this.unsubscribeEventCaptured)
+            return;
+        this.unsubscribeEventCaptured();
+        this.unsubscribeEventCaptured = null;
+    }
+    sendAuth(visitorId) {
+        if (!this.isOpen())
+            return;
+        const jwtOptions = this.api.agent.getJwtInfoCopy();
+        this.ws.send(JSON.stringify(this.pendo._.extend({
+            type: 'auth',
+            visitorId
+        }, jwtOptions)));
+    }
+    stop() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.unsubscribeFromEvents();
+    }
+    isOpen() {
+        return !!this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+    onLiveFlag(live, visitorId, onOpen) {
+        if (live) {
+            this.start(visitorId, onOpen);
+        }
+        else {
+            this.stop();
+        }
+    }
+    send(payload) {
+        if (!this.isOpen())
+            return;
+        try {
+            this.ws.send(this.pendo.compress(payload, 'binary'));
+        }
+        catch (_a) { }
+    }
+    sendRecordingEvent(fields) {
+        this.send(Object.assign(Object.assign({}, fields), { kind: EVENT_KINDS.recording, sequence: this.sequence++ }));
+    }
+    forwardEvent(event) {
+        if (!event || !event.data || !event.data.length)
+            return;
+        const capturedEvent = event.data[0];
+        const config = { event: capturedEvent };
+        if (this.pendo._.contains(CATCHALL_TYPES, capturedEvent.type)) {
+            config.kind = EVENT_KINDS.catchall;
+        }
+        if (capturedEvent.type === EVENT_KINDS.devlog) {
+            config.kind = EVENT_KINDS.devlog;
+        }
+        if (!config.kind)
+            return;
+        // other eventCaptured listeners still mutate capturedEvent in place; defer until they're done
+        this.pendo._.defer(() => {
+            this.send(config);
+        });
+    }
+}
+
 const ELEMENT_NODE = 1;
 const INPUT_MASK = '*'.repeat(10);
 const NUMBER_INPUT_MASK = '0'.repeat(10);
@@ -50891,6 +51359,7 @@ class SessionRecorder {
         this.transport = new Transport(this.WorkerClass, this.pendo, this.api);
         this.transport.onError = bind(this.sendFailure, this, 'WORKER_ERROR');
         this.transport.onWorkerMessage = bind(this.onWorkerMessage, this);
+        this.liveReplayClient = new LiveReplayClient(this.pendo, this.api);
         this.sendQueue = new this.api.SendQueue(bind(this.transport.send, this.transport));
         this.sendQueue.onTimeout = bind(this.sendFailure, this, 'SEND_TIMEOUT');
         this.errorHandler = this.pendo._.throttle(bind(this.logStopReason, this, 'RRWEB_ERROR'), ONE_MINUTE_IN_MILLISECONDS, { trailing: false });
@@ -50981,6 +51450,7 @@ class SessionRecorder {
         this.subscriptions.length = 0;
         this.stop();
         this.transport.stop();
+        this.liveReplayClient.stop();
     }
     ready() {
         if (this.api.ConfigReader.get(RECORDING_CONFIG_AUTO_START) !== false) {
@@ -51055,6 +51525,7 @@ class SessionRecorder {
                 this.stop();
             }
             if (visitorConfig && visitorConfig.enable && this.isRecording()) {
+                this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId, () => this.snapshot());
                 if (continuationCallback) {
                     continuationCallback.call(this);
                 }
@@ -51197,6 +51668,7 @@ class SessionRecorder {
             var bind = this.pendo._.bind;
             this.visitorConfig = visitorConfig;
             this.clearOldSessionId();
+            this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId);
             this.sendQueue.start();
             this.interval = setInterval(() => {
                 if (!this.sendQueue.failed()) {
@@ -51395,9 +51867,11 @@ class SessionRecorder {
             this.sessionId(this.recordingId);
             this.restartPtm();
             this._sendIds();
+            this.pendo._.each(this.buffer.data, (bufferedEvent) => this._sendLiveReplayEvent(bufferedEvent));
             this.send({ keyframe: true });
         }
         else if (!isMeta) {
+            this._sendLiveReplayEvent(event);
             this.eventsSinceLastKeyFrame += 1;
             const timeSinceLastKeyFrame = event.timestamp - this.lastKeyFrameTime;
             const exceeds24Hours = timeSinceLastKeyFrame >= ONE_DAY_IN_MILLISECONDS;
@@ -51421,6 +51895,23 @@ class SessionRecorder {
     updateCurrentRecordingSize(recordingPayloadSize) {
         this.currentRecordingSize += recordingPayloadSize;
     }
+    _sendLiveReplayEvent(event) {
+        if (!this.recordingId || !this.liveReplayClient.isOpen())
+            return;
+        this.liveReplayClient.sendRecordingEvent({
+            type: 'recording',
+            visitorId: this.visitorId,
+            accountId: this.accountId,
+            recordingId: this.recordingId,
+            recordingSessionId: this.sessionId(this.recordingId),
+            url: this.pendo.url.get(),
+            keyFrame: event.type === EVENT_TYPES.FULL_SNAPSHOT,
+            lastKeyFrame: this.lastKeyFrameTime,
+            recordingPayload: [event],
+            recordingPayloadCount: 1,
+            browserTime: event.timestamp
+        });
+    }
     onWorkerMessage(messageData) {
         switch (messageData.type) {
             case 'workerDied': {
@@ -51455,6 +51946,13 @@ class SessionRecorder {
                 this.logStopReason(`MISSING_${messageData.missingData}`);
                 break;
             }
+            case 'liveFlag': {
+                // ignore stale responses from a since-changed identity
+                if (messageData.visitorId !== this.visitorId)
+                    break;
+                this.liveReplayClient.onLiveFlag(messageData.live, this.visitorId, () => this.snapshot());
+                break;
+            }
         }
     }
     addRecordingId(event) {
@@ -51493,6 +51991,7 @@ class SessionRecorder {
         }
         // send existing events
         this.send();
+        this.liveReplayClient.stop();
         // now, finish stopping any more collection or sending
         this.sendQueue.stop();
         this.recordingId = null;
@@ -51562,7 +52061,8 @@ class SessionRecorder {
         this.api.Events.eventCaptured.trigger(payload);
         const params = {
             v: this.pendo.VERSION,
-            recordingId: this.recordingId
+            recordingId: this.recordingId,
+            vis: this.api.util.base64EncodeString(this.visitorId)
         };
         if (payload.keyFrame) {
             params.kf = 1;
@@ -51955,19 +52455,27 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
                     method: 'POST',
                     body
                 }).then(function (response) {
-                    cancelResponseBody(response);
                     if (response.status < 200 || response.status >= 300) {
+                        cancelResponseBody(response);
                         postMessage({
                             error: new Error(`received status code ${response.status}: ${response.statusText}`),
                             status: response.status,
                             sequence
                         });
+                        return;
                     }
-                    else {
-                        postMessage({
-                            sequence
-                        });
-                    }
+                    postMessage({
+                        sequence
+                    });
+                    response.json().then(function (responseBody) {
+                        if (responseBody && responseBody.live !== undefined) {
+                            postMessage({
+                                type: 'liveFlag',
+                                live: responseBody.live,
+                                visitorId: payload.visitorId
+                            });
+                        }
+                    }).catch(function () { });
                 }).catch(function (e) {
                     postMessage({
                         error: e,