@pendo/agent 2.313.0 → 2.315.0

package/dist/pendo.module.js

@@ -3389,7 +3389,6 @@ var ConfigReader = (function () {
          * @type {number}
          */
         addOption('guideSeenTimeoutLength', [PENDO_CONFIG_SRC, SNIPPET_SRC], 10000);
-        // addOption('guideTimeout', [SNIPPET_SRC]); // old, use guides.timeout instead
         /**
          * If `true`, guides will be verified against their saved content hash before display to ensure validity of
          * guide content.
@@ -3423,7 +3422,7 @@ var ConfigReader = (function () {
          * @default false
          * @type {boolean}
          */
-        addOption('guides.delay', [SNIPPET_SRC], undefined, undefined, ['delayGuides']);
+        addOption('guides.delay', [SNIPPET_SRC], false, undefined, ['delayGuides']);
         /**
          * Completely disables guides (this option has been moved from `disableGuides`).
          * Alias: `disableGuides`
@@ -3434,7 +3433,7 @@ var ConfigReader = (function () {
          * @default false
          * @type {boolean}
          */
-        addOption('guides.disabled', [SNIPPET_SRC], undefined, undefined, ['disableGuides']);
+        addOption('guides.disabled', [SNIPPET_SRC], false, undefined, ['disableGuides']);
         /**
          * If 'true', guides with slow selectors will be removed from guide display processing.
          * This will improve application performance, but slow guides will not be shown to users.
@@ -3946,8 +3945,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.313.0_';
-let PACKAGE_VERSION = '2.313.0';
+let VERSION = '2.315.0_';
+let PACKAGE_VERSION = '2.315.0';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -5570,6 +5569,7 @@ var Events = (function () {
         new EventType('deliverablesLoaded', [DEBUG, LIFECYCLE]),
         new EventType('guidesFailed', [DEBUG, LIFECYCLE]),
         new EventType('guidesLoaded', [DEBUG, LIFECYCLE]),
+        new EventType('segmentFlagsUpdated', [DEBUG, LIFECYCLE]),
         new EventType('guideListChanged', [DEBUG, LIFECYCLE]),
         new EventType('guideSeen', [DEBUG, LIFECYCLE]),
         new EventType('guideNotSeen', [DEBUG, LIFECYCLE]),
@@ -12275,16 +12275,17 @@ var JWT = (function () {
     };
 })();
 
-const MAX_BACKOFF = 6;
-const MAX_FAILURES = 100;
+const MAX_RETRY_DELAY_MS = 5 * 60 * 1000; // 5 minutes
+const ONE_HOUR = 60 * 60 * 1000; // 1 hour
+const FAILURE_WINDOW_MS = 2 * ONE_HOUR;
 class SendQueue {
-    constructor(sendFn, maxFailures = MAX_FAILURES) {
+    constructor(sendFn) {
         this.queue = [];
         this.unloads = new Set();
         this.pending = new Set();
         this.failures = new Map();
+        this.firstFailureTime = null;
         this.sendFn = sendFn;
-        this.maxFailures = maxFailures;
     }
     isEmpty() {
         return this.queue.length <= 0;
@@ -12294,6 +12295,7 @@ class SendQueue {
         this.unloads.clear();
         this.pending.clear();
         this.failures.clear();
+        this.firstFailureTime = null;
         this.stopped = true;
         clearTimeout(this.timer);
         delete this.timer;
@@ -12314,12 +12316,16 @@ class SendQueue {
     incrementFailure(payload) {
         const failureCount = (this.failures.get(payload) || 0) + 1;
         this.failures.set(payload, failureCount);
+        if (this.firstFailureTime == null) {
+            this.firstFailureTime = new Date().getTime();
+        }
         return failureCount;
     }
     pass(payload, dequeue = true) {
         this.unloads.delete(payload);
         this.pending.delete(payload);
-        this.failures.clear();
+        this.failures.delete(payload);
+        this.firstFailureTime = null;
         const index = this.queue.indexOf(payload);
         if (index >= 0) {
             this.queue.splice(index, 1);
@@ -12334,18 +12340,26 @@ class SendQueue {
         const failureCount = this.incrementFailure(payload);
         if (this.stopped || !retry)
             return;
-        if (failureCount >= this.maxFailures) {
+        const now = new Date().getTime();
+        const elapsed = now - (this.firstFailureTime || now);
+        if (elapsed >= FAILURE_WINDOW_MS) {
             if (this.onTimeout) {
                 this.onTimeout();
             }
-            this.pass(payload, false);
+            this.firstFailureTime = null;
+            this.retryLater(ONE_HOUR);
+            return;
         }
-        this.retryLater(Math.pow(2, Math.min(failureCount - 1, MAX_BACKOFF)) * 1000);
+        this.retryLater(Math.min(Math.pow(2, failureCount - 1) * 1000, MAX_RETRY_DELAY_MS));
+    }
+    retryNow() {
+        clearTimeout(this.timer);
+        delete this.timer;
+        this.next();
     }
     retryLater(delay) {
         this.timer = setTimeout$1(() => {
-            delete this.timer;
-            this.next();
+            this.retryNow();
         }, delay);
     }
     failed() {
@@ -12360,7 +12374,7 @@ class SendQueue {
     }
     drain(finalPayloadArray, isUnload = true) {
         this.queue.push(...finalPayloadArray);
-        if (this.failed())
+        if (this.failed() && !this.allowDrainWhileFailed)
             return Promise$2.reject();
         const promises = [];
         for (const payload of this.queue) {
@@ -12379,7 +12393,7 @@ class SendQueue {
 }
 
 const UNSENT_EVENTS_KEY = 'unsentEvents';
-const UNSENT_EVENTS_DURATION = 6 * 24 * 60 * 60 * 1000; // 6 days
+const UNSENT_EVENTS_MAX_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days
 class LocalStorageEventBuffer {
     constructor() {
         this.events = {};
@@ -12421,7 +12435,7 @@ class LocalStorageEventBuffer {
     }
     write(storage) {
         if (_.size(this.events) > 0) {
-            storage.write(UNSENT_EVENTS_KEY, JSON.stringify(this.events), UNSENT_EVENTS_DURATION);
+            storage.write(UNSENT_EVENTS_KEY, JSON.stringify(this.events), UNSENT_EVENTS_MAX_AGE);
         }
         else {
             storage.clear(UNSENT_EVENTS_KEY);
@@ -12920,6 +12934,7 @@ function addSiloParams(options) {
         silo.params = _.extend({}, silo.params, options.params);
         silo.beacon = options.beacon;
         silo.eventLength = silo.JZB.length;
+        silo.ts = silo[0].browser_time || getNow();
         var jwtOptions = JWT.get();
         if (!_.isEmpty(jwtOptions)) {
             silo.auth = jwtOptions;
@@ -13110,6 +13125,9 @@ function createSendQueue(options, send, guaranteedSend) {
     const apiKeys = getApiKeysFromOptions(options);
     const queues = _.map(apiKeys, (apiKey, i) => {
         const queue = new SendQueue(function (request, isUnload, failureCount) {
+            if (getNow() - request.ts > UNSENT_EVENTS_MAX_AGE) {
+                return q.resolve(); // ignore event if it's too old
+            }
             if (failureCount) {
                 request.params = _.extend({}, request.params, {
                     rt: failureCount
@@ -13121,7 +13139,10 @@ function createSendQueue(options, send, guaranteedSend) {
                 }
                 return q.resolve();
             }
-            else if (isUnload) {
+            if (isUnload && queue.failed()) {
+                return q.reject();
+            }
+            if (isUnload) {
                 return guaranteedSend(apiKey, request);
             }
             else {
@@ -13131,6 +13152,7 @@ function createSendQueue(options, send, guaranteedSend) {
         queue.onTimeout = function () {
             performanceMonitor.count(BEACON_GIF_FAILURES[options.beacon]);
         };
+        queue.allowDrainWhileFailed = true;
         queue.retryPending = true;
         return queue;
     });
@@ -14180,9 +14202,31 @@ var activeGuides = [];
 var activeElements = [];
 var badgesShown = {};
 let _displayableGuides = {};
+const Channel = {
+    ALL: '*',
+    DEFAULT: 'default'
+};
 function setBadgesShown(badges) {
     badgesShown = badges;
 }
+function createChannelMatcher(options = {}) {
+    let channel = options.channel;
+    if (!options.hasOwnProperty('channel')) {
+        channel = Channel.ALL;
+    }
+    else if (channel == null) {
+        channel = Channel.DEFAULT;
+    }
+    if (channel === Channel.ALL) {
+        return () => true;
+    }
+    else if (channel === Channel.DEFAULT) {
+        return (guide) => guide.channel == null;
+    }
+    else {
+        return (guide) => guide.channel == channel;
+    }
+}
 /**
  * Returns an array of all guides available on the current page to the current user.
  * If multiple frames on a pages, `pendo.getActiveGuides()` will return the list of eligible
@@ -14190,15 +14234,18 @@ function setBadgesShown(badges) {
  *
  * @access public
  * @category Guides
+ * @param {object} options - Options for filtering guides
+ * @param {string} options.channel - Channel to filter guides by
  * @returns {Guide[]}
  * @example
  * pendo.getActiveGuides() => [{ Pendo Guide Object }, ...]
  */
-function getActiveGuides() {
-    return activeGuides;
+function getActiveGuides(options) {
+    const hasChannel = createChannelMatcher(options);
+    return _.filter(activeGuides, hasChannel);
 }
-function getLocalActiveGuides() {
-    return frameLocalGuides(getActiveGuides());
+function getLocalActiveGuides(options) {
+    return frameLocalGuides(getActiveGuides(options));
 }
 function frameLocalGuides(guideList) {
     return _.filter(guideList, function (guide) {
@@ -14341,6 +14388,10 @@ function getGuideAttachPoint(doc = document) {
     return attachPoint || getBody(doc);
 }
 var findBadgeForStep = function (step) {
+    var guide = step.getGuide();
+    if (!guide)
+        return;
+    guide.placeBadge();
     var badge = badgesShown[step.guideId];
     if (!badge)
         return;
@@ -14480,10 +14531,12 @@ const internalEvents = {
     deliverablesLoaded: 1,
     guidesFailed: 1,
     guidesLoaded: 1,
-    onClickCaptured: 1
+    onClickCaptured: 1,
+    segmentFlagsUpdated: 1
 };
 const browserEvents = {
-    ready: 1
+    ready: 1,
+    segmentFlagsUpdated: 1
 };
 const supportedPublicEvents = [
     'ready',
@@ -14491,6 +14544,7 @@ const supportedPublicEvents = [
     'deliverablesLoaded',
     'guidesFailed',
     'guidesLoaded',
+    'segmentFlagsUpdated',
     'validateGuide',
     'validateLauncher',
     'validateGlobalScript'
@@ -20620,6 +20674,11 @@ var BuildingBlockResourceCenter = (function () {
 
 var GUIDE_STATE_TTL = 10000; // 10 seconds
 var LAST_STEP_ADVANCED_COOKIE = 'lastStepAdvanced';
+var THROTTLING_STATE = {
+    DISMISSED: 'latestDismissedAutoAt',
+    SNOOZED: 'latestSnoozedAutoAt',
+    ADVANCED: 'finalAdvancedAutoAt'
+};
 function writeLastStepSeenCache(lastSeen) {
     store.dispatch('guideState/updateLastGuideStepSeen', lastSeen);
     store.dispatch('guideState/write');
@@ -20644,6 +20703,18 @@ function regainFocus() {
 function getLastGuideStepSeen() {
     return store.state.guideState.lastGuideStepSeen;
 }
+function applyTimerCache(timerValue, cachedTimerValue) {
+    cachedTimerValue = parseInt(cachedTimerValue, 10);
+    if (isNaN(cachedTimerValue) || !_.isNumber(cachedTimerValue))
+        return timerValue;
+    if (_.isNumber(timerValue) && cachedTimerValue > timerValue) {
+        return cachedTimerValue;
+    }
+    if (!_.isNumber(timerValue)) {
+        return cachedTimerValue;
+    }
+    return timerValue;
+}
 var GuideStateModule = (function () {
     var state = {
         steps: {},
@@ -20680,19 +20751,25 @@ var GuideStateModule = (function () {
                 }
             });
         },
-        load(context, storedValue) {
-            if (!storedValue)
-                return;
-            var parsedValue;
-            try {
-                parsedValue = JSON.parse(storedValue);
-            }
-            catch (e) {
+        load(context) {
+            const storage = context.getters.storage();
+            let storedValue = storage.read(LAST_STEP_ADVANCED_COOKIE, false, context.getters.cookieSuffix());
+            if (storedValue) {
+                var parsedValue;
+                try {
+                    parsedValue = JSON.parse(storedValue);
+                }
+                catch (e) {
+                }
+                if (parsedValue) {
+                    _.each([].concat(parsedValue), function (stepState) {
+                        context.commit('setStepState', stepState);
+                    });
+                }
             }
-            if (!parsedValue)
-                return;
-            _.each([].concat(parsedValue), function (stepState) {
-                context.commit('setStepState', stepState);
+            _.each(THROTTLING_STATE, function (throttlingStorageKey) {
+                const value = storage.read(throttlingStorageKey);
+                context.dispatch('updateThrottlingState', { name: throttlingStorageKey, value });
             });
         },
         forceExpire(context) {
@@ -20747,6 +20824,14 @@ var GuideStateModule = (function () {
                             }
                             log.info('making sure that dismissCount = \'' + step.dismissCount + '\' for ' + storageKey + ': ' + stepId);
                         }
+                        if (stepState.destinationStepId !== undefined && step.destinationStepId != stepState.destinationStepId) {
+                            log.info('making sure that destinationStepId = \'' + stepState.destinationStepId + '\' for ' + storageKey + ': ' + stepId);
+                            step.destinationStepId = stepState.destinationStepId;
+                        }
+                        if (step.lastSeenAt != stepState.time) {
+                            log.info('making sure that lastSeenAt = \'' + stepState.time + '\' for ' + storageKey + ': ' + stepId);
+                            step.lastSeenAt = stepState.time;
+                        }
                         var stepIndex = _.indexOf(guide.steps, step);
                         _.each(guide.steps.slice(0, stepIndex), function (step) {
                             if (!_.contains(['advanced', 'dismissed'], step.seenState)) {
@@ -20762,6 +20847,10 @@ var GuideStateModule = (function () {
             if (mostRecentLastGuideStepSeen) {
                 context.dispatch('updateLastGuideStepSeen', _.extend({}, context.state.lastGuideStepSeen, mostRecentLastGuideStepSeen));
             }
+            _.each(THROTTLING_STATE, function (throttlingStorageKey) {
+                pendo$1[throttlingStorageKey] = applyTimerCache(pendo$1[throttlingStorageKey], context.state[throttlingStorageKey]);
+                context.dispatch('updateThrottlingState', { name: throttlingStorageKey, value: pendo$1[throttlingStorageKey] });
+            });
         },
         receiveLastGuideStepSeen(context, lastGuideStepSeen) {
             context.commit('setReceivedLastGuideStepSeen', lastGuideStepSeen);
@@ -20772,8 +20861,8 @@ var GuideStateModule = (function () {
                 return;
             // Embedded guides should not update the lastGuideStepSeen in order to not interfere with auto guide display
             // Embedded guides are not included in getters.guideList
-            const shouldUpdateLastGuideStepSeen = _.some(context.getters.guideList(), function ({ id }) {
-                return id === lastGuideStepSeen.guideId;
+            const shouldUpdateLastGuideStepSeen = _.some(context.getters.guideList(), function ({ id, channel }) {
+                return id === lastGuideStepSeen.guideId && !channel;
             });
             if (lastGuideStepSeen.guideStepId) {
                 context.commit('setStepState', lastGuideStepSeen);
@@ -20817,7 +20906,7 @@ var GuideStateModule = (function () {
                 }
                 if (context.getters.storageChangedInOtherTab()(newValue)) {
                     clearLoopTimer();
-                    context.dispatch('load', rawNewValue);
+                    context.dispatch('load');
                     context.dispatch('apply');
                     if (!context.state.receivedStateChangeAt) {
                         context.commit('setReceivedStateChange', context.getters.now());
@@ -21139,15 +21228,27 @@ var Permalink = _.memoize(function () {
     return PermalinkConstructor(findGuideById);
 });
 
+function shouldNotResumeWalkthrough(walkthrough) {
+    return walkthrough && walkthrough.attributes && walkthrough.attributes.doNotResume;
+}
 function findInProgressWalkthrough(guidesList, lastGuideStepSeen) {
-    var walkthrough = _.find(guidesList, function (guide) {
+    const walkthrough = _.find(guidesList, function (guide) {
         return guide.isContinuation(lastGuideStepSeen);
     });
-    var shouldNotResume = walkthrough && walkthrough.attributes && walkthrough.attributes.doNotResume;
-    if (walkthrough && !shouldNotResume) {
+    if (walkthrough && !shouldNotResumeWalkthrough(walkthrough)) {
         return walkthrough;
     }
 }
+function findInProgressChannelWalkthroughs(guidesList) {
+    return _.filter(guidesList, function (guide) {
+        return guide.channel && !shouldNotResumeWalkthrough(guide) && guide.isContinuation();
+    });
+}
+const AutoDisplayType = {
+    permalink: 'permalink',
+    continuation: 'continuation',
+    auto: 'auto'
+};
 class AutoDisplayPhase {
     constructor() {
         this.name = 'autoDisplay';
@@ -21156,33 +21257,45 @@ class AutoDisplayPhase {
     markDirty() {
         if (!isLeader())
             return;
-        this.queue.push('permalink', 'continuation');
-        this.queue.push(...AutoDisplay.sortAndFilter(getActiveGuides(), pendo$1.autoOrdering));
+        this.queue.push({ type: AutoDisplayType.permalink });
+        const activeGuides = getActiveGuides();
+        const walkthrough = findInProgressWalkthrough(activeGuides, getLastGuideStepSeen());
+        if (walkthrough) {
+            this.queue.push({
+                type: AutoDisplayType.continuation,
+                guide: walkthrough
+            });
+        }
+        for (const channelWalkthrough of findInProgressChannelWalkthroughs(activeGuides)) {
+            this.queue.push({
+                type: AutoDisplayType.continuation,
+                guide: channelWalkthrough
+            });
+        }
+        const allAutoGuides = AutoDisplay.sortAndFilter(activeGuides, pendo$1.autoOrdering);
+        const filteredAutoGuides = walkthrough ? _.filter(allAutoGuides, guide => guide.channel) : allAutoGuides;
+        this.queue.push(..._.map(filteredAutoGuides, guide => ({ type: AutoDisplayType.auto, guide })));
     }
     process(monitor) {
-        if (isGuideShown()) {
-            this.cancel();
-            return;
-        }
-        var next = this.queue.shift();
-        if (next === 'permalink') {
-            return Permalink().tryDisplay();
+        const next = this.queue.shift();
+        if (next.type === AutoDisplayType.permalink) {
+            if (!isGuideShown()) {
+                return Permalink().tryDisplay();
+            }
         }
-        else if (next === 'continuation') {
-            // check for in-progress walkthroughs
-            var walkthrough = findInProgressWalkthrough(getActiveGuides(), getLastGuideStepSeen());
-            if (walkthrough) {
-                monitor.saveContext(walkthrough);
-                return walkthrough.show('continue');
+        else if (next.type === AutoDisplayType.continuation) {
+            const { guide } = next;
+            if (!isGuideShown({ channel: guide.channel })) {
+                monitor.saveContext(guide);
+                return guide.show('continue');
             }
         }
-        else if (next) {
-            if (findInProgressWalkthrough(getActiveGuides(), getLastGuideStepSeen())) {
-                this.cancel();
-                return;
+        else {
+            const { guide } = next;
+            if (!isGuideShown({ channel: guide.channel })) {
+                monitor.saveContext(guide);
+                return AutoDisplay.tryDisplayGuide(guide, pendo$1);
             }
-            monitor.saveContext(next);
-            return AutoDisplay.tryDisplayGuide(next, pendo$1);
         }
     }
     handleProcessTimeExceeded(monitor) {
@@ -24771,9 +24884,8 @@ function setSeenTime(time) {
 function getSeenTime() {
     return seenTime;
 }
-// Fix: this is a terrible name.
-var isGuideShown = function () {
-    return _.any(getActiveGuides(), function (guide) {
+var isGuideShown = function (options = {}) {
+    return _.any(getActiveGuides(options), function (guide) {
         return guide.isShown();
     });
 };
@@ -24858,8 +24970,8 @@ var getStepIdFromElement = function (element) {
  * @example
  * pendo.hideGuides({stayHidden: true})
  */
-function hideGuides(hideOptions) {
-    _.each(getActiveGuides(), function (guide) {
+function hideGuides(hideOptions = {}) {
+    _.each(getActiveGuides(hideOptions), function (guide) {
         if (_.isFunction(guide.isShown) && guide.isShown()) {
             guide.hide(hideOptions);
         }
@@ -25010,7 +25122,7 @@ var setFocusToActivationElement = function (guide) {
     }
 };
 function shouldAffectThrottling(guide, seenReason) {
-    return !guide.isMultiApp && (seenReason === 'auto' || seenReason === 'repeatGuide');
+    return !guide.isMultiApp && !guide.channel && (seenReason === 'auto' || seenReason === 'repeatGuide');
 }
 /**
  * Hides the current guide and invokes the `guideDismissed` event. Dismissed guides will not
@@ -25617,7 +25729,7 @@ var showPreview = function () {
 };
 var isGuideRCType = _.partial(_.get, _, 'attributes.resourceCenter');
 var beforeShowGuide = function (guide) {
-    if (isGuideShown()) {
+    if (isGuideShown({ channel: guide.channel })) {
         var guideStep = findStepForGuideEvent();
         removeGuideEventListeners(guideStep);
         if (isGuideRCType(guide)) {
@@ -25629,7 +25741,7 @@ var beforeShowGuide = function (guide) {
             }
         }
         else {
-            hideGuides();
+            hideGuides({ channel: guide.channel });
             store.dispatch('frames/hideGuides');
         }
     }
@@ -25772,11 +25884,6 @@ function snoozeCanceledGuide(guideId, stepId, visitorId, seenReason, language) {
     stageGuideEvent(evt, null, true);
     Events.guideSnoozeCancelled.trigger(evt);
 }
-var THROTTLING_STATE = {
-    DISMISSED: 'latestDismissedAutoAt',
-    SNOOZED: 'latestSnoozedAutoAt',
-    ADVANCED: 'finalAdvancedAutoAt'
-};
 function writeThrottlingStateCache(time, cacheName) {
     _writeThrottlingStateCache(time, cacheName);
     var message = {};
@@ -25793,10 +25900,6 @@ function _writeThrottlingStateCache(time, cacheName) {
     agentStorage.write(cacheName, time, GUIDE_STATE_TTL);
     store.dispatch('guideState/updateThrottlingState', { name: cacheName, value: time });
 }
-function readGuideStatusesFromStorage(cacheName) {
-    const cookieSuffix = ConfigReader.get('crossAppGuideStorageSuffix');
-    return agentStorage.read(cacheName, false, cookieSuffix);
-}
 function createGuideEvent(name, guideId, stepId, visitorId, reason, language) {
     var params = name;
     if (typeof params !== 'object') {
@@ -25906,18 +26009,6 @@ var showGuideById = function (id, reason) {
     }
     return false;
 };
-function applyTimerCache(timerValue, cachedTimerValue) {
-    cachedTimerValue = parseInt(cachedTimerValue, 10);
-    if (isNaN(cachedTimerValue) || !_.isNumber(cachedTimerValue))
-        return timerValue;
-    if (_.isNumber(timerValue) && cachedTimerValue > timerValue) {
-        return cachedTimerValue;
-    }
-    if (!_.isNumber(timerValue)) {
-        return cachedTimerValue;
-    }
-    return timerValue;
-}
 var resetPendoUI = function () {
     stopGuides();
     clearLoopTimer();
@@ -25943,6 +26034,15 @@ function handleDoNotProcess() {
     store.commit('debugger/doNotProcess', true);
     log.info('not tracking visitor due to 451 response');
 }
+function clearDoNotProcess() {
+    if (!pendo$1.doNotProcess)
+        return;
+    delete pendo$1.doNotProcess;
+    unlockEvents();
+    startGuides();
+    store.commit('debugger/doNotProcess', false);
+    log.info('cleared do not process flag');
+}
 function guidesPayload(guidesJson) {
     if (!mostRecentGuideRequest)
         return;
@@ -25952,6 +26052,9 @@ function guidesPayload(guidesJson) {
     }
     if (_.isString(guidesJson.id) && guidesJson.id !== mostRecentGuideRequest.id)
         return;
+    if (ConfigReader.get('requestSegmentFlags')) {
+        delete guidesJson.segmentFlags; // This is temporary until the BE stops sending segment flags in the guides payload, at which point this can be removed
+    }
     _.extend(pendo$1, guidesJson);
     pendo$1.guides = _.map(pendo$1.guides, function (guide) {
         if (_.keys(guide).length == 1 && guide.id) {
@@ -25978,6 +26081,9 @@ var mostRecentGuideRequest;
 var loadGuideJs = function (apiKey, params) {
     var guideRequestId = _.uniqueId();
     var deferred = q.defer();
+    if (mostRecentGuideRequest && mostRecentGuideRequest.deferred) {
+        mostRecentGuideRequest.deferred.reject('newRequest'); // make sure that we don't leave open any promises if multiple guide requests are made in quick succession
+    }
     mostRecentGuideRequest = {
         id: guideRequestId,
         deferred
@@ -26204,8 +26310,7 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
             resetPendoUI();
             var lastGuideStepSeen = pendo$1.lastGuideStepSeen;
             if (!lastGuideStepSeen) {
-                log.info('lastGuideStepSeen is not set, shutting down guides');
-                return;
+                throw new Error('lastGuideStepSeen is not set, check response from guide payload');
             }
             store.dispatch('guideState/receiveLastGuideStepSeen', lastGuideStepSeen);
             lastGuideStepSeen.visitorId = visitorId;
@@ -26215,15 +26320,8 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
             const activeGuides = buildActiveGuideList(pendo$1.guides);
             setActiveGuides(activeGuides);
             const displayableGuides = getDisplayableGuides();
-            store.dispatch('guideState/load', readGuideStatusesFromStorage(LAST_STEP_ADVANCED_COOKIE));
+            store.dispatch('guideState/load');
             store.dispatch('guideState/apply');
-            pendo$1.latestDismissedAutoAt = applyTimerCache(pendo$1.latestDismissedAutoAt, agentStorage.read('latestDismissedAutoAt'));
-            store.dispatch('guideState/updateThrottlingState', { name: 'latestDismissedAutoAt', value: pendo$1.latestDismissedAutoAt });
-            pendo$1.finalAdvancedAutoAt = applyTimerCache(pendo$1.finalAdvancedAutoAt, agentStorage.read('finalAdvancedAutoAt'));
-            store.dispatch('guideState/updateThrottlingState', { name: 'finalAdvancedAutoAt', value: pendo$1.finalAdvancedAutoAt });
-            // APP-40144
-            pendo$1.latestSnoozedAutoAt = applyTimerCache(pendo$1.latestSnoozedAutoAt, agentStorage.read('latestSnoozedAutoAt'));
-            store.dispatch('guideState/updateThrottlingState', { name: 'latestSnoozedAutoAt', value: pendo$1.latestSnoozedAutoAt });
             store.dispatch('healthCheck/init', activeGuides);
             // This needs to run *immediately* when pendo.guides changes
             // so Events.guidesLoaded.trigger() doesn't cut it, since it
@@ -26270,6 +26368,12 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
             }
         }
     }).catch(function (err) {
+        if (err === 'newRequest') {
+            log.info('Guide load cancelled due to new request');
+            deferred.resolve('Guide load cancelled due to new request');
+            return;
+        }
+        log.info(`Error in loadGuideJs, shutting down guides, err: ${_.get(err, 'message', err || 'Unknown error')}`);
         Events.guidesFailed.trigger();
         deferred.reject(err);
     });
@@ -26499,6 +26603,7 @@ var initGuides = function (observer) {
         }
     });
     Events.identify.on(function () {
+        clearDoNotProcess();
         queueGuideReload();
     });
     Events.urlChanged.on(function () {
@@ -26816,9 +26921,9 @@ function removeGuideProcessor(callback) {
  * @returns {Object | null}
  */
 // TODO: this needs to be updated to support an array of steps
-function getActiveGuide() {
+function getActiveGuide(options) {
     var currentStep, currentSteps, stepIndex;
-    var currentGuide = _.find(getActiveGuides(), function (guide) { return guide.isShown(); });
+    var currentGuide = _.find(getActiveGuides(options), function (guide) { return guide.isShown(); });
     if (!currentGuide)
         return null;
     if (_.get(currentGuide, 'attributes.resourceCenter.isModule')) {
@@ -28047,8 +28152,7 @@ var GuideActivity = (function () {
                 return guide;
         }
         const stepId = getStepIdFromAppData(appData);
-        const activeGuide = getActiveGuide();
-        if (stepId && activeGuide && activeGuide.step && stepId != activeGuide.step.id) {
+        if (stepId) {
             let step;
             const guide = _.find(getLocalActiveGuides(), function (guide) {
                 step = _.find(guide.steps, (step) => step.id === stepId);
@@ -28058,7 +28162,7 @@ var GuideActivity = (function () {
                 return { guide, step };
             }
         }
-        return activeGuide;
+        return getActiveGuide();
     }
 })();
 
@@ -28097,6 +28201,11 @@ const PluginAPI = {
         removeGlobalScript: GuideRuntime.removeGlobalScript
     },
     GuideActivity,
+    GuideEvents: {
+        stageGuideEvent,
+        createGuideEvent,
+        getSeenTime
+    },
     GuideLoop: {
         addUpdatePhase,
         removeUpdatePhase
@@ -28105,7 +28214,9 @@ const PluginAPI = {
         addProcessor: addGuideProcessor,
         removeProcessor: removeGuideProcessor,
         registerDisplayableGuides,
-        removeDisplayableGuides
+        removeDisplayableGuides,
+        GuideFactory,
+        GuideStepFactory
     },
     hosts: {
         SERVER
@@ -28128,7 +28239,8 @@ const PluginAPI = {
         base64EncodeString,
         parseUrl,
         addInlineStyles: _.partial(addInlineStyles, ConfigReader),
-        getNow
+        getNow,
+        escapeRegExp
     },
     constants: {
         URL_MAX_LENGTH
@@ -28894,6 +29006,9 @@ function teardown() {
     initializeCounter = 0;
 }
 
+function getActiveDefaultGuide(options = { channel: Channel.DEFAULT }) {
+    return getActiveGuide(options);
+}
 // CANDIDATES for behaviors to add to guides
 // Starting to expose some useful utilities from service experiences
 var smartNextStep = function (delay) {
@@ -28901,7 +29016,7 @@ var smartNextStep = function (delay) {
     // if it's not, skip that step.
     // need to know:
     // -- this steps' index
-    var activeObj = getActiveGuide();
+    var activeObj = getActiveDefaultGuide();
     if (!activeObj)
         return;
     // var stepIndex = _.last(_.map(activeObj.steps, function(s){ return _.indexOf(activeObj.guide.steps, s); }));
@@ -28920,7 +29035,7 @@ var smartNextStep = function (delay) {
     setTimeout$1(checkNext, delay);
 };
 var advanceOn = function (eventType, elementPath) {
-    var obj = getActiveGuide();
+    var obj = getActiveDefaultGuide();
     elementPath = elementPath || obj.step.elementPathRule;
     var btn = dom(elementPath)[0];
     var onEvent = function () {
@@ -28933,7 +29048,7 @@ var smartFirstStep = function () {
     dom('._pendo-guide_').css('display:none;');
     // look through steps to see which are applicable for the current url.
     var url = getNormalizedUrl();
-    var activeObj = getActiveGuide();
+    var activeObj = getActiveDefaultGuide();
     var steps = activeObj.guide.steps;
     var testSteps = _.filter(_.rest(steps), function (step) {
         return !!step.pageId;
@@ -28973,7 +29088,7 @@ var renderStepPosition = function (template, guide, step) {
     return template(posObj);
 };
 var guideDev = {
-    getActiveGuide,
+    getActiveGuide: getActiveDefaultGuide,
     smartNextStep,
     smartFirstStep,
     advanceOn,
@@ -30864,12 +30979,17 @@ function exportPublicApi(pendo) {
     pendo.startGuides = exportPendoCoreOnly(manuallyStartGuides);
     pendo.stopGuides = exportPendoCoreOnly(manuallyStopGuides);
     pendo.defaultCssUrl = exportPendoCoreOnly(getDefaultCssUrl());
-    pendo.getActiveGuides = getActiveGuides;
-    pendo.getActiveGuide = getActiveGuide;
+    pendo.getActiveGuides = function (options = { channel: Channel.DEFAULT }) {
+        return getActiveGuides(options);
+    };
+    pendo.getActiveGuide = function (options = { channel: Channel.DEFAULT }) {
+        return getActiveGuide(options);
+    };
     pendo.guideSeenTimeoutLength = StepTimeoutMonitor.getGuideSeenTimeoutLength();
     pendo.guidesPayload = guidesPayload;
     pendo.areGuidesDisabled = exportPendoCoreOnly(areGuidesDisabled);
     pendo.setGuidesDisabled = exportPendoCoreOnly(setGuidesDisabled);
+    pendo.areGuidesDelayed = exportPendoCoreOnly(areGuidesDelayed);
     pendo.buildNodeFromJSON = BuildingBlockGuides.buildNodeFromJSON;
     pendo.flexElement = exportPendoCoreOnly(BuildingBlockGuides.flexElement);
     pendo.GuideFactory = exportPendoCoreOnly(GuideFactory);
@@ -31656,44 +31776,48 @@ function WalkthroughGuide() {
             // Do not continue a snoozed guide
             if (currentGuide.isGuideSnoozed())
                 return null;
-            lastSeenObj = lastSeenObj || {};
-            for (var j = 0; j < currentGuide.steps.length; j++) {
-                if (currentGuide.steps[j].id === lastSeenObj.guideStepId) {
-                    if (lastSeenObj.state === 'dismissed') {
-                        // The guide was dismissed
-                        break;
-                    }
-                    else if (lastSeenObj.state === 'active' || lastSeenObj.state === 'snoozed') {
-                        // This is current.
-                        nextStep = currentGuide.steps[j];
-                        break;
-                    }
-                    else if (lastSeenObj.state === 'advanced' && lastSeenObj.destinationStepId) {
-                        nextStep = _.find(currentGuide.steps, function (step) {
-                            return step.id === lastSeenObj.destinationStepId;
-                        });
-                        break;
-                    }
-                    else if ((j + 1) < currentGuide.steps.length) {
-                        // Get the step after that last one seen
-                        nextStep = currentGuide.steps[j + 1];
-                        break;
+            if (lastSeenObj != null) {
+                for (var j = 0; j < currentGuide.steps.length; j++) {
+                    if (currentGuide.steps[j].id === lastSeenObj.guideStepId) {
+                        if (lastSeenObj.state === 'dismissed') {
+                            // The guide was dismissed
+                            break;
+                        }
+                        else if (lastSeenObj.state === 'active' || lastSeenObj.state === 'snoozed') {
+                            // This is current.
+                            nextStep = currentGuide.steps[j];
+                            break;
+                        }
+                        else if (lastSeenObj.state === 'advanced' && lastSeenObj.destinationStepId) {
+                            nextStep = _.find(currentGuide.steps, function (step) {
+                                return step.id === lastSeenObj.destinationStepId;
+                            });
+                            break;
+                        }
+                        else if ((j + 1) < currentGuide.steps.length) {
+                            // Get the step after that last one seen
+                            nextStep = currentGuide.steps[j + 1];
+                            break;
+                        }
                     }
                 }
-            }
-            if (nextStep) {
-                var now = new Date().getTime();
-                var lastSeenTime = lastSeenObj.time;
-                if (lastSeenTime &&
-                    ((now - lastSeenTime) > MULTISTEP_CONTINUATION_TIME_LIMIT) &&
-                    !isOB(currentGuide)) {
-                    if (!didLogContinuationExpired) {
-                        log.info('Multi-step continuation has expired', { contexts: ['guides', 'info'] });
-                        didLogContinuationExpired = true;
+                if (nextStep) {
+                    var now = new Date().getTime();
+                    var lastSeenTime = lastSeenObj.time;
+                    if (lastSeenTime &&
+                        ((now - lastSeenTime) > MULTISTEP_CONTINUATION_TIME_LIMIT) &&
+                        !isOB(currentGuide)) {
+                        if (!didLogContinuationExpired) {
+                            log.info('Multi-step continuation has expired', { contexts: ['guides', 'info'] });
+                            didLogContinuationExpired = true;
+                        }
+                        return null;
                     }
-                    return null;
+                    return nextStep;
                 }
-                return nextStep;
+            }
+            else {
+                return findNextStepFromState(currentGuide);
             }
             return null;
         };
@@ -31743,6 +31867,40 @@ function WalkthroughGuide() {
     }
     return this;
 }
+/*
+ * Finds next step in guide based on seen state/time of steps (instead of pendo.lastGuideStepSeen)
+ */
+function findNextStepFromState(guide) {
+    const { steps } = guide;
+    if (!steps || !steps.length)
+        return null;
+    // find the step with the most recent lastSeenAt
+    const { currentStep, currentIndex } = _.reduce(steps, (memo, currentStep, currentIndex) => {
+        const { lastSeenAt } = memo.currentStep;
+        if (lastSeenAt == null)
+            return memo;
+        return currentStep.lastSeenAt > lastSeenAt ? { currentStep, currentIndex } : memo;
+    }, { currentStep: steps[0], currentIndex: 0 });
+    if (currentStep.seenState === 'dismissed')
+        return null;
+    if (typeof currentStep.isSnoozed === 'function' && currentStep.isSnoozed()) {
+        return null;
+    }
+    if (currentStep.seenState === 'active' || currentStep.seenState === 'snoozed')
+        return currentStep;
+    if (currentStep.seenState === 'advanced') {
+        const { destinationStepId } = currentStep;
+        if (destinationStepId) {
+            return _.find(steps, function (step) {
+                return step.id === destinationStepId;
+            });
+        }
+        else {
+            return steps[currentIndex + 1] || null;
+        }
+    }
+    return null;
+}
 
 /*
  * Traps and logs errors that occur while displaying a guide. If the
@@ -33813,7 +33971,7 @@ function updateMasterGuideList(state) {
     })
         .map(GuideFactory)
         .value();
-    var mergedGuideList = _.toArray(guidesInThisFrame).concat(guidesInOtherFrames).filter(runGuideProcessors);
+    var mergedGuideList = _.filter(_.toArray(guidesInThisFrame).concat(guidesInOtherFrames), runGuideProcessors);
     sortGuidesByPriority(mergedGuideList);
     initializeResourceCenter(mergedGuideList);
     setActiveGuides(mergedGuideList);
@@ -34401,7 +34559,7 @@ const DebuggerModule = (() => {
         store.commit('debugger/stepEligibilitySet', stepElg);
     }
     function guidesLoadedFn(evt) {
-        const autoOrdering = _.map(AutoDisplay.sortAndFilter(getActiveGuides(), pendo$1.autoOrdering), guide => guide.id);
+        const autoOrdering = _.map(AutoDisplay.sortAndFilter(getActiveGuides({ channel: Channel.DEFAULT }), pendo$1.autoOrdering), guide => guide.id);
         store.commit('debugger/autoOrdering', autoOrdering || []);
         store.commit('debugger/excludedGuides', pendo$1.excludedGuides || []);
         store.commit('debugger/throttling', pendo$1.throttling || {});
@@ -37917,14 +38075,15 @@ const OemAccountId = (function () {
 
 var debugging;
 function debuggerExports() {
+    const getActiveDefaultGuides = () => getActiveGuides({ channel: Channel.DEFAULT });
     return {
         store,
         ConfigReader,
         getState() { return JSON.stringify(store.state); },
         getEventCache() { return [].concat(eventCache); },
-        getAllGuides() { return [].concat(getActiveGuides()); },
-        getAutoGuides() { return AutoDisplay.sortAndFilter(getActiveGuides(), pendo$1.autoOrdering); },
-        getBadgeGuides() { return _.filter(getActiveGuides(), isBadge); },
+        getAllGuides() { return [].concat(getActiveDefaultGuides()); },
+        getAutoGuides() { return AutoDisplay.sortAndFilter(getActiveDefaultGuides(), pendo$1.autoOrdering); },
+        getBadgeGuides() { return _.filter(getActiveDefaultGuides(), isBadge); },
         getLauncherGuides() { return []; },
         getEventHistory() { return []; },
         getAllFrames() { return store.getters['frames/allFrames'](); },
@@ -37933,7 +38092,6 @@ function debuggerExports() {
         setActiveGuides,
         getBody: dom.getBody,
         isMobileUserAgent: sniffer.isMobileUserAgent,
-        areGuidesDelayed,
         doesElementMatchContainsRules,
         getMetadata,
         isStagingServer,
@@ -38501,7 +38659,6 @@ const FrustrationEvent = (function () {
 // A guide that show nested inside another element.
 // Multiple embedded guides can show at the same time.
 const buildGuideBehaviors = function ({ globalPendo, pluginApi }) {
-    const guide = this;
     const { _ } = globalPendo;
     const { store } = pluginApi;
     this.process = function () {
@@ -38558,12 +38715,6 @@ const buildGuideBehaviors = function ({ globalPendo, pluginApi }) {
         const nextStep = guide.nextStep(lastSeenStep) || firstStep;
         return nextStep.show(reason);
     };
-    // when embedded guide is initialized set the forceShowFirstStep property.
-    // This property is deleted after the guide shows because we no longer want to foce show the first step.
-    // The propert is reset on urlChanged events.
-    if (!this.hasOwnProperty('forceShowFirstStep')) {
-        this.forceShowFirstStep = _.get(guide, 'attributes.restartOnReload');
-    }
     this.isShownInThisFrame = function () {
         const guide = this;
         return _.any(guide.steps, function (step) {
@@ -38620,7 +38771,6 @@ const EmbeddedGuides = (function () {
         pluginApi.Events.on('deliverablesLoaded', clearEmbeddedGuides);
         pluginApi.Events.on('guideLoopStopped', onGuidesStopped);
         pluginApi.Events.on('guideListChanged', initializeEmbeddedGuides);
-        pluginApi.Events.on('urlChanged', setForceShowFirstStepFlags);
         pluginApi.Events.on('guideAdvanced', hideGuide);
         pluginApi.Events.on('metadata', onMetadataChange);
         pluginApi.Events.on('identify', onIdentify);
@@ -38635,7 +38785,6 @@ const EmbeddedGuides = (function () {
         pluginApi.Events.off('deliverablesLoaded', clearEmbeddedGuides);
         pluginApi.Events.off('guideLoopStopped', onGuidesStopped);
         pluginApi.Events.off('guideListChanged', initializeEmbeddedGuides);
-        pluginApi.Events.off('urlChanged', setForceShowFirstStepFlags);
         pluginApi.Events.off('guideAdvanced', hideGuide);
         pluginApi.Events.off('metadata', onMetadataChange);
         pluginApi.Events.off('identify', onIdentify);
@@ -38700,13 +38849,6 @@ const EmbeddedGuides = (function () {
     function onIdentify() {
         setEmbeddedGuideCacheValid(false);
     }
-    // This function syncs the forceShowFirstStep with the restartOnReload property on guides
-    // This function is run on the urlChanged event.
-    function setForceShowFirstStepFlags() {
-        _.forEach(embeddedGuides, function (guide) {
-            guide.forceShowFirstStep = !!_.get(guide, 'attributes.restartOnReload');
-        });
-    }
     function extractEmbeddedGuides(guide) {
         if (isEmbedded(guide)) {
             if (!_.some(embeddedGuides, ({ id }) => id === guide.id)) {
@@ -38915,6 +39057,7 @@ class SessionManager {
 }
 var SessionManager$1 = new SessionManager();
 
+const SEGMENT_FLAGS_CACHE = 'segmentFlagsCache';
 class SegmentFlags {
     constructor() {
         this.name = 'SegmentFlags';
@@ -38932,26 +39075,57 @@ class SegmentFlags {
         if (!this.segmentFlagsEnabled)
             return;
         this.mostRecentSegmentsRequest = null;
+        /**
+         * Stores the cached segment flags for the current visitor.
+         * Cleared on identity change and refreshed from server on page load.
+         *
+         * @name _pendo_segmentFlagsCache
+         * @category Cookies/localStorage
+         * @access public
+         * @label SEGMENT_FLAGS_CACHE
+         */
+        PluginAPI.agentStorage.registry.addLocal(SEGMENT_FLAGS_CACHE, {
+            isSecure: true,
+            serializer: JSON.stringify,
+            deserializer: SafeJsonDeserializer
+        });
+        if (shouldPersist()) {
+            try {
+                const cached = PluginAPI.agentStorage.read(SEGMENT_FLAGS_CACHE);
+                if (cached) {
+                    this.pendo.segmentFlags = cached;
+                }
+            }
+            catch (e) {
+                // ignore read errors
+            }
+        }
         this.pendo.segmentsPayload = this.pendo._.bind(this.segmentsPayload, this);
-        this.handleMetadataChange = this.pendo._.debounce(this.pendo._.bind(this.requestSegmentFlags, this), 50);
         this.handleReadyBound = this.pendo._.bind(this.handleReady, this);
+        this.handleIdentityChangeBound = this.pendo._.bind(this.handleIdentityChange, this);
         this.api.Events.ready.on(this.handleReadyBound);
-        this.api.Events.metadata.on(this.handleMetadataChange);
-        this.api.Events.identify.on(this.handleMetadataChange);
+        this.api.Events.identify.on(this.handleIdentityChangeBound);
+        this.api.Events.metadata.on(this.handleIdentityChangeBound);
     }
     teardown() {
         if (!this.segmentFlagsEnabled)
             return;
         this.pendo.segmentsPayload = this.pendo._.noop;
-        this.handleMetadataChange.cancel();
         this.api.Events.ready.off(this.handleReadyBound);
-        this.api.Events.metadata.off(this.handleMetadataChange);
-        this.api.Events.identify.off(this.handleMetadataChange);
+        this.api.Events.identify.off(this.handleIdentityChangeBound);
+        this.api.Events.metadata.off(this.handleIdentityChangeBound);
     }
     handleReady() {
         this.ready = true;
         this.requestSegmentFlags();
     }
+    handleIdentityChange(event) {
+        if (this.pendo._.get(event, 'data[0].wasCleared')) {
+            this.api.agentStorage.clear(SEGMENT_FLAGS_CACHE);
+            delete this.pendo.segmentFlags;
+        }
+        this.requestSegmentFlags();
+    }
     requestSegmentFlags() {
         if (!this.ready)
             return;
@@ -39000,10 +39174,23 @@ class SegmentFlags {
             return;
         if (this.pendo._.isString(payload.id) && payload.id !== this.mostRecentSegmentsRequest)
             return;
+        const changed = this.flagsChanged(this.pendo.segmentFlags, payload.segmentFlags);
         this.pendo.segmentFlags = payload.segmentFlags;
+        if (shouldPersist()) {
+            this.api.agentStorage.write(SEGMENT_FLAGS_CACHE, payload.segmentFlags);
+        }
+        if (changed) {
+            this.api.Events.segmentFlagsUpdated.trigger(this.pendo.segmentFlags);
+        }
         this.api.log.info('successfully loaded segment flags');
         this.mostRecentSegmentsRequest = null;
     }
+    flagsChanged(oldFlags = [], newFlags = []) {
+        if (oldFlags.length !== newFlags.length)
+            return true;
+        const intersection = this.pendo._.intersection(oldFlags, newFlags);
+        return intersection.length !== oldFlags.length;
+    }
     scriptLoad(url) {
         this.pendo.loadResource(url, this.pendo._.noop);
     }
@@ -40339,6 +40526,35 @@ class PromptPlugin {
 }
 var PromptAnalytics = new PromptPlugin();
 
+class RestartOnReload {
+    initialize(pendo, { Events }) {
+        this.pendo = pendo;
+        const { _, attachEvent } = pendo;
+        const boundSetForceShowFirstStepFlags = _.bind(this.setForceShowFirstStepFlags, this);
+        this.subscriptions = [
+            attachEvent(Events, 'deliverablesLoaded', boundSetForceShowFirstStepFlags),
+            attachEvent(Events, 'urlChanged', boundSetForceShowFirstStepFlags)
+        ];
+    }
+    teardown() {
+        this.pendo._.forEach(this.subscriptions, function (unsubscribe) {
+            unsubscribe();
+        });
+        this.subscriptions.length = 0;
+    }
+    setForceShowFirstStepFlags() {
+        const { pendo } = this;
+        const { _ } = pendo;
+        _.forEach(pendo.guides, function (guide) {
+            const restartOnReload = !!_.get(guide, 'attributes.restartOnReload');
+            if (restartOnReload) {
+                guide.forceShowFirstStep = true;
+            }
+        });
+    }
+}
+var RestartOnReload$1 = new RestartOnReload();
+
 function registerBuiltInPlugins() {
     registerPlugin(IFrameMonitor);
     registerPlugin(DOMActivation);
@@ -40358,6 +40574,7 @@ function registerBuiltInPlugins() {
     registerPlugin(WebAnalytics$1);
     registerPlugin(FormValidation);
     registerPlugin(PromptAnalytics);
+    registerPlugin(RestartOnReload$1);
 }
 
 /*
@@ -40498,18 +40715,30 @@ function TextCapture() {
     function guideActivity(pendo, event) {
         if (!isEnabled())
             return;
-        var eventData = event.data[0];
+        const { _ } = pendo;
+        const eventData = event.data[0];
         if (eventData && eventData.type === 'guideActivity') {
-            var activeGuideObj = pendo.getActiveGuide();
-            if (!activeGuideObj)
+            const shownSteps = _.reduce(pendo.getActiveGuides({ channel: '*' }), (shown, guide) => {
+                if (guide.isShown()) {
+                    return shown.concat(_.filter(guide.steps, (step) => step.isShown()));
+                }
+                return shown;
+            }, []);
+            if (!shownSteps.length)
                 return;
-            var findDomBlockInDomJson = pendo.BuildingBlocks.BuildingBlockGuides.findDomBlockInDomJson;
-            var element = findDomBlockInDomJson(activeGuideObj.step.domJson, function (domJson) {
-                return domJson.props && domJson.props.id && domJson.props.id === eventData.props.ui_element_id;
+            const findDomBlockInDomJson = pendo.BuildingBlocks.BuildingBlockGuides.findDomBlockInDomJson;
+            let elementJson;
+            _.find(shownSteps, (step) => {
+                if (!step.domJson)
+                    return false;
+                elementJson = findDomBlockInDomJson(step.domJson, function (domJson) {
+                    return domJson.props && domJson.props.id && domJson.props.id === eventData.props.ui_element_id;
+                });
+                return elementJson;
             });
-            if (!element)
+            if (!elementJson)
                 return;
-            eventData.props.ui_element_text = element.content;
+            eventData.props.ui_element_text = elementJson.content;
         }
     }
     function isEnabled() {
@@ -40536,6 +40765,7 @@ const substitutionRegex = '\\{(?:\\s?)([^.\\s]?visitor|account|parentAccount)\\.
 const skipStepString = '{skipStep:* *(auto|\\d+)\\/}';
 const goToMiddleString = '(?!0)(\\d+)';
 const goToString = `({goto-${goToMiddleString}\\/})`;
+const containerSelector = '[id^="pendo-guide-container"]';
 function lookupGuideButtons(domJson, buttons = []) {
     if (domJson.type === 'button' && domJson.actions) {
         buttons.push(domJson);
@@ -40573,6 +40803,7 @@ var guideMarkdownUtil = {
     substitutionRegex,
     skipStepString,
     goToString,
+    containerSelector,
     lookupGuideButtons,
     removeMarkdownSyntax
 };
@@ -40626,7 +40857,7 @@ const PollBranching = {
             attributes: true,
             childList: true,
             characterData: true,
-            subtree: false
+            subtree: true
         };
         const MutationObserver = getZoneSafeMethod$1(pendo._, 'MutationObserver');
         const observer = new MutationObserver(applyBranchingIndicators);
@@ -40745,13 +40976,13 @@ function branchingGoToStep(event, step, guide, pendo) {
     if (pollStepIndex < 0)
         return;
     const destinationObject = {
-        destinationStepId: guide.steps[pollStepIndex].id
+        destinationStepId: guide.steps[pollStepIndex].id,
+        step
     };
     pendo.goToStep(destinationObject);
     event.cancel = true;
 }
 
-const containerSelector = '[id^="pendo-guide-container"]';
 const MetadataSubstitution = {
     name: 'MetadataSubstitution',
     script(step, guide, pendo) {
@@ -40770,12 +41001,36 @@ const MetadataSubstitution = {
     },
     designerListener(pendo) {
         const target = pendo.dom.getBody();
+        if (pendo.designerv2) {
+            pendo.designerv2.runMetadataSubstitutionForDesignerPreview = function runMetadataSubstitutionForDesignerPreview() {
+                var _a;
+                if (!document.querySelector(guideMarkdownUtil.containerSelector))
+                    return;
+                const step = (_a = pendo.designerv2.currentlyPreviewedGuide) === null || _a === void 0 ? void 0 : _a.steps[0];
+                if (!step)
+                    return;
+                const placeholderData = findSubstitutableElements(pendo);
+                if (step.buildingBlocks) {
+                    findSubstitutableUrlsInJson(step.buildingBlocks, placeholderData, pendo);
+                }
+                if (pendo._.size(placeholderData)) {
+                    pendo._.each(placeholderData, function (placeholder) {
+                        if (pendo._.isUndefined(placeholder))
+                            return;
+                        processPlaceholder(placeholder, pendo);
+                    });
+                    const containerId = `pendo-g-${step.id}`;
+                    const context = step.guideElement;
+                    updateGuideContainer(containerId, context, pendo);
+                }
+            };
+        }
         const config = {
             attributeFilter: ['data-layout'],
             attributes: true,
             childList: true,
             characterData: true,
-            subtree: false
+            subtree: true
         };
         const MutationObserver = getZoneSafeMethod$1(pendo._, 'MutationObserver');
         const observer = new MutationObserver(applySubstitutionIndicators);
@@ -40784,7 +41039,7 @@ const MetadataSubstitution = {
             pendo._.each(mutations, function (mutation) {
                 var _a;
                 if (mutation.addedNodes.length) {
-                    if (document.querySelector(containerSelector)) {
+                    if (document.querySelector(guideMarkdownUtil.containerSelector)) {
                         const placeholderData = findSubstitutableElements(pendo);
                         const step = (_a = pendo.designerv2.currentlyPreviewedGuide) === null || _a === void 0 ? void 0 : _a.steps[0];
                         if (!step)
@@ -40814,8 +41069,14 @@ function processPlaceholder(placeholder, pendo) {
     const { data, target } = placeholder;
     const subRegex = new RegExp(guideMarkdownUtil.substitutionRegex);
     while ((match = matchPlaceholder(placeholder, subRegex))) {
-        let matched = subRegex.exec(match);
-        let mdValue = getSubstituteValue(matched, pendo);
+        const usedArrayPath = Array.isArray(match) && match.length >= 2;
+        const currentStr = target === 'textContent'
+            ? data[target]
+            : decodeURI((data.getAttribute && (target === 'href' || target === 'value') ? (data.getAttribute(target) || '') : data[target]));
+        const matched = usedArrayPath ? match : subRegex.exec(currentStr);
+        if (!matched)
+            continue;
+        const mdValue = getSubstituteValue(matched, pendo);
         substituteMetadataByTarget(data, target, mdValue, matched);
     }
 }
@@ -40824,36 +41085,59 @@ function matchPlaceholder(placeholder, regex) {
         return placeholder.data[placeholder.target].match(regex);
     }
     else {
-        return decodeURI(placeholder.data[placeholder.target]).match(regex);
+        const raw = placeholder.data.getAttribute && (placeholder.target === 'href' || placeholder.target === 'value')
+            ? (placeholder.data.getAttribute(placeholder.target) || '')
+            : placeholder.data[placeholder.target];
+        return decodeURI(raw).match(regex);
     }
 }
+function getMetadataValueCaseInsensitive(metadata, type, property) {
+    const kind = metadata && metadata[type];
+    if (!kind || typeof kind !== 'object')
+        return undefined;
+    const direct = Object.prototype.hasOwnProperty.call(kind, property) ? kind[property] : undefined;
+    if (direct !== undefined) {
+        return direct;
+    }
+    const propLower = property.toLowerCase();
+    const key = Object.keys(kind).find(k => k.toLowerCase() === propLower);
+    const value = key !== undefined ? kind[key] : undefined;
+    return value;
+}
 function getSubstituteValue(match, pendo) {
-    if (pendo._.isUndefined(match[1]) || pendo._.isUndefined(match[2]))
+    if (pendo._.isUndefined(match[1]) || pendo._.isUndefined(match[2])) {
         return;
+    }
     let type = match[1];
     let property = match[2];
     let defaultValue = match[3];
     if (pendo._.isUndefined(type) || pendo._.isUndefined(property)) {
         return;
     }
-    let mdValue = pendo._.get(pendo.getSerializedMetadata(), `${type}.${property}`) || defaultValue || '';
+    const metadata = pendo.getSerializedMetadata();
+    let mdValue = getMetadataValueCaseInsensitive(metadata, type, property);
+    if (mdValue === undefined || mdValue === null)
+        mdValue = defaultValue || '';
     return mdValue;
 }
 function substituteMetadataByTarget(data, target, mdValue, matched) {
+    const isElement = data && typeof data.getAttribute === 'function';
+    const current = (target === 'href' || target === 'value') && isElement
+        ? (data.getAttribute(target) || '')
+        : data[target];
     if (target === 'href' || target === 'value') {
-        data[target] = decodeURI(data[target])
-            .replace(matched[0], window.encodeURI(mdValue));
+        const safeValue = window.encodeURIComponent(String(mdValue === undefined || mdValue === null ? '' : mdValue));
+        data[target] = decodeURI(current).replace(matched[0], safeValue);
     }
     else {
-        data[target] = data[target]
-            .replace(matched[0], mdValue);
+        data[target] = current.replace(matched[0], mdValue);
     }
 }
 function updateGuideContainer(containerId, context, pendo) {
     if (pendo.designer && !pendo._.size(pendo.dom('#pendo-ps-substitution-icon'))) {
-        pendo.dom(containerSelector).append(substitutionIcon('#999', '30px'));
+        pendo.dom(guideMarkdownUtil.containerSelector).append(substitutionIcon('#999', '30px'));
     }
-    pendo.flexElement(pendo.dom(containerSelector));
+    pendo.flexElement(pendo.dom(guideMarkdownUtil.containerSelector));
     pendo.BuildingBlocks.BuildingBlockGuides.recalculateGuideHeight(containerId, context);
 }
 function findSubstitutableUrlsInJson(originalData, placeholderData = [], pendo) {
@@ -40894,7 +41178,7 @@ function findSubstitutableUrlsInJson(originalData, placeholderData = [], pendo)
     return placeholderData;
 }
 function findSubstitutableElements(pendo) {
-    let elements = pendo.dom(`${containerSelector} *:not(.pendo-inline-ui)`);
+    let elements = pendo.dom(`${guideMarkdownUtil.containerSelector} *:not(.pendo-inline-ui)`);
     return pendo._.chain(elements)
         .filter(function (placeholder) {
         const subRegex = new RegExp(guideMarkdownUtil.substitutionRegex);
@@ -41002,7 +41286,7 @@ const RequiredQuestions = {
                     });
                 }
             });
-            step.attachEvent(step.guideElement.find('[id^="pendo-guide-container"]')[0], 'click', function (event) {
+            step.attachEvent(step.guideElement.find(guideMarkdownUtil.containerSelector)[0], 'click', function (event) {
                 if (!event.target.classList.contains('_pendo-button')) {
                     evaluateRequiredQuestions(requiredQuestions);
                 }
@@ -41173,7 +41457,7 @@ const SkipToEligibleStep = {
     script(step, guide, pendo) {
         let isAdvanceIntercepted = false;
         let isPreviousIntercepted = false;
-        let guideContainer = step.guideElement.find('#pendo-guide-container');
+        let guideContainer = step.guideElement.find(guideMarkdownUtil.containerSelector);
         let guideContainerAriaLabel = guideContainer.attr('aria-label');
         let stepNumberOrAuto = skipStepRegex.exec(guideContainerAriaLabel)[1];
         if (guideContainer) {
@@ -41185,7 +41469,7 @@ const SkipToEligibleStep = {
             let eligibleStep = findEligibleSkipStep(stepNumberOrAuto, 'next');
             if (!isAdvanceIntercepted && stepNumberOrAuto) {
                 isAdvanceIntercepted = true;
-                pendo.goToStep({ destinationStepId: eligibleStep.id });
+                pendo.goToStep({ destinationStepId: eligibleStep.id, step });
                 evt.cancel = true;
             }
         });
@@ -41195,7 +41479,7 @@ const SkipToEligibleStep = {
             let eligibleStep = findEligibleSkipStep(stepNumberOrAuto, 'previous');
             if (!isPreviousIntercepted && stepNumberOrAuto) {
                 isPreviousIntercepted = true;
-                pendo.goToStep({ destinationStepId: eligibleStep.id });
+                pendo.goToStep({ destinationStepId: eligibleStep.id, step });
                 evt.cancel = true;
             }
         });
@@ -41205,10 +41489,10 @@ const SkipToEligibleStep = {
             let skipForwardStep = findStepOnPage(guide.getPositionOfStep(step), 'next', stepNumber);
             let skipPreviousStep = findStepOnPage(guide.getPositionOfStep(step) - 2, 'previous', stepNumber);
             if (skipForwardStep && direction == 'next') {
-                pendo.goToStep({ destinationStepId: skipForwardStep });
+                pendo.goToStep({ destinationStepId: skipForwardStep, step });
             }
             if (skipPreviousStep && direction == 'previous') {
-                pendo.goToStep({ destinationStepId: skipPreviousStep });
+                pendo.goToStep({ destinationStepId: skipPreviousStep, step });
             }
             return direction === 'next' ? skipForwardStep : skipPreviousStep;
         }
@@ -41234,7 +41518,7 @@ const SkipToEligibleStep = {
     },
     test(step, guide, pendo) {
         var _a;
-        const guideContainerAriaLabel = (_a = step.guideElement) === null || _a === void 0 ? void 0 : _a.find('#pendo-guide-container').attr('aria-label');
+        const guideContainerAriaLabel = (_a = step.guideElement) === null || _a === void 0 ? void 0 : _a.find(guideMarkdownUtil.containerSelector).attr('aria-label');
         return pendo._.isString(guideContainerAriaLabel) && guideContainerAriaLabel.indexOf('{skipStep') !== -1;
     },
     designerListener(pendo) {
@@ -41244,7 +41528,7 @@ const SkipToEligibleStep = {
             attributes: true,
             childList: true,
             characterData: true,
-            subtree: false
+            subtree: true
         };
         const MutationObserver = getZoneSafeMethod$1(pendo._, 'MutationObserver');
         const observer = new MutationObserver(applySkipStepIndicator);
@@ -41255,14 +41539,14 @@ const SkipToEligibleStep = {
                 var _a, _b;
                 const nodeHasQuerySelector = pendo._.isFunction((_a = mutation.addedNodes[0]) === null || _a === void 0 ? void 0 : _a.querySelectorAll);
                 if (mutation.addedNodes.length && nodeHasQuerySelector) {
-                    let guideContainer = mutation.addedNodes[0].querySelectorAll('#pendo-guide-container');
+                    let guideContainer = mutation.addedNodes[0].querySelectorAll(guideMarkdownUtil.containerSelector);
                     let guideContainerAriaLabel = (_b = guideContainer[0]) === null || _b === void 0 ? void 0 : _b.getAttribute('aria-label');
                     if (guideContainerAriaLabel) {
                         if (guideContainerAriaLabel.match(skipStepRegex)) {
                             let fullSkipStepString = guideContainerAriaLabel.match(skipStepRegex)[0];
                             guideContainerAriaLabel.replace(fullSkipStepString, '');
                             if (!pendo.dom('#_pendoSkipIcon').length) {
-                                pendo.dom('#pendo-guide-container').append(skipIcon('#999', '30px').trim());
+                                pendo.dom(guideMarkdownUtil.containerSelector).append(skipIcon('#999', '30px').trim());
                             }
                         }
                     }
@@ -48566,16 +48850,17 @@ class SessionRecorderBuffer {
     }
 }
 
-const MAX_BACKOFF = 6;
-const MAX_FAILURES = 100;
+const MAX_RETRY_DELAY_MS = 5 * 60 * 1000; // 5 minutes
+const ONE_HOUR = 60 * 60 * 1000; // 1 hour
+const FAILURE_WINDOW_MS = 2 * ONE_HOUR;
 class SendQueue {
-    constructor(sendFn, maxFailures = MAX_FAILURES) {
+    constructor(sendFn) {
         this.queue = [];
         this.unloads = new Set();
         this.pending = new Set();
         this.failures = new Map();
+        this.firstFailureTime = null;
         this.sendFn = sendFn;
-        this.maxFailures = maxFailures;
     }
     isEmpty() {
         return this.queue.length <= 0;
@@ -48585,6 +48870,7 @@ class SendQueue {
         this.unloads.clear();
         this.pending.clear();
         this.failures.clear();
+        this.firstFailureTime = null;
         this.stopped = true;
         clearTimeout(this.timer);
         delete this.timer;
@@ -48605,12 +48891,16 @@ class SendQueue {
     incrementFailure(payload) {
         const failureCount = (this.failures.get(payload) || 0) + 1;
         this.failures.set(payload, failureCount);
+        if (this.firstFailureTime == null) {
+            this.firstFailureTime = new Date().getTime();
+        }
         return failureCount;
     }
     pass(payload, dequeue = true) {
         this.unloads.delete(payload);
         this.pending.delete(payload);
-        this.failures.clear();
+        this.failures.delete(payload);
+        this.firstFailureTime = null;
         const index = this.queue.indexOf(payload);
         if (index >= 0) {
             this.queue.splice(index, 1);
@@ -48625,18 +48915,26 @@ class SendQueue {
         const failureCount = this.incrementFailure(payload);
         if (this.stopped || !retry)
             return;
-        if (failureCount >= this.maxFailures) {
+        const now = new Date().getTime();
+        const elapsed = now - (this.firstFailureTime || now);
+        if (elapsed >= FAILURE_WINDOW_MS) {
             if (this.onTimeout) {
                 this.onTimeout();
             }
-            this.pass(payload, false);
+            this.firstFailureTime = null;
+            this.retryLater(ONE_HOUR);
+            return;
         }
-        this.retryLater(Math.pow(2, Math.min(failureCount - 1, MAX_BACKOFF)) * 1000);
+        this.retryLater(Math.min(Math.pow(2, failureCount - 1) * 1000, MAX_RETRY_DELAY_MS));
+    }
+    retryNow() {
+        clearTimeout(this.timer);
+        delete this.timer;
+        this.next();
     }
     retryLater(delay) {
         this.timer = setTimeout$1(() => {
-            delete this.timer;
-            this.next();
+            this.retryNow();
         }, delay);
     }
     failed() {
@@ -48651,7 +48949,7 @@ class SendQueue {
     }
     drain(finalPayloadArray, isUnload = true) {
         this.queue.push(...finalPayloadArray);
-        if (this.failed())
+        if (this.failed() && !this.allowDrainWhileFailed)
             return Promise$2.reject();
         const promises = [];
         for (const payload of this.queue) {
@@ -53712,6 +54010,7 @@ const RECORDING_CONFIG_TREAT_IFRAME_AS_ROOT = 'recording.treatIframeAsRoot';
 const RECORDING_CONFIG_DISABLE_UNLOAD = 'recording.disableUnload';
 const RESOURCE_CACHING = 'resourceCaching';
 const ONE_DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
+const ONE_MINUTE_IN_MILLISECONDS = 60 * 1000;
 const THIRTY_MINUTES = 1000 * 60 * 30;
 const ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
 const SESSION_RECORDING_ID = 'pendo_srId';
@@ -53834,6 +54133,7 @@ class SessionRecorder {
         this.transport.onWorkerMessage = bind(this.onWorkerMessage, this);
         this.sendQueue = new 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 });
         this.isNewSession = false;
         this.isCheckingVisitorEligibility = false;
         this.pageLifecycleListeners = [];
@@ -54128,7 +54428,7 @@ class SessionRecorder {
             var config = this.recordingConfig(visitorConfig);
             this._stop = this.record(this.pendo._.extend({
                 emit: bind(this.emit, this),
-                errorHandler: bind(this.errorHandler, this)
+                errorHandler: this.errorHandler
             }, config));
             this._refreshIds();
             this.onRecordingStart();
@@ -54240,9 +54540,6 @@ class SessionRecorder {
             return null;
         }
     }
-    errorHandler(error) {
-        this.logStopReason('RRWEB_ERROR', error);
-    }
     /**
      * Handle new rrweb events coming in. This will also make sure that we are properly sending a "keyframe"
      * as the BE expects it. A "keyframe" should consist of only the events needed to start a recording. This includes
@@ -54550,7 +54847,7 @@ class SessionRecorder {
             recordingPayload: [],
             sequence: 0,
             recordingPayloadCount: 0,
-            props: Object.assign({ reason }, (error && { error }))
+            props: Object.assign({ reason }, (error && { error: error instanceof Error ? error === null || error === void 0 ? void 0 : error.message : error }))
         }, tracer);
         var jzb = this.pendo.compress(payload);
         var url = this.buildRequestUrl(`${this.pendo.HOST}/data/rec/${this.pendo.apiKey}`, {
@@ -56940,7 +57237,6 @@ var ConfigReader = (function () {
          * @type {number}
          */
         addOption('guideSeenTimeoutLength', [PENDO_CONFIG_SRC, SNIPPET_SRC], 10000);
-        // addOption('guideTimeout', [SNIPPET_SRC]); // old, use guides.timeout instead
         /**
          * If `true`, guides will be verified against their saved content hash before display to ensure validity of
          * guide content.
@@ -56974,7 +57270,7 @@ var ConfigReader = (function () {
          * @default false
          * @type {boolean}
          */
-        addOption('guides.delay', [SNIPPET_SRC], undefined, undefined, ['delayGuides']);
+        addOption('guides.delay', [SNIPPET_SRC], false, undefined, ['delayGuides']);
         /**
          * Completely disables guides (this option has been moved from `disableGuides`).
          * Alias: `disableGuides`
@@ -56985,7 +57281,7 @@ var ConfigReader = (function () {
          * @default false
          * @type {boolean}
          */
-        addOption('guides.disabled', [SNIPPET_SRC], undefined, undefined, ['disableGuides']);
+        addOption('guides.disabled', [SNIPPET_SRC], false, undefined, ['disableGuides']);
         /**
          * If 'true', guides with slow selectors will be removed from guide display processing.
          * This will improve application performance, but slow guides will not be shown to users.
@@ -58246,6 +58542,7 @@ function NetworkCapture() {
     let responseBodyCb;
     let pendoDevlogBaseUrl;
     let isCapturingNetworkLogs = false;
+    let excludeRequestUrls = [];
     const CAPTURE_NETWORK_CONFIG = 'captureNetworkRequests';
     const NETWORK_SUB_TYPE = 'network';
     const NETWORK_LOGS_CONFIG = 'networkLogs';
@@ -58253,6 +58550,7 @@ function NetworkCapture() {
     const NETWORK_LOGS_CONFIG_ALLOWED_RESPONSE_HEADERS = 'networkLogs.allowedResponseHeaders';
     const NETWORK_LOGS_CONFIG_CAPTURE_REQUEST_BODY = 'networkLogs.captureRequestBody';
     const NETWORK_LOGS_CONFIG_CAPTURE_RESPONSE_BODY = 'networkLogs.captureResponseBody';
+    const NETWORK_LOGS_CONFIG_EXCLUDE_REQUEST_URLS = 'networkLogs.excludeRequestUrls';
     const allowedRequestHeaders = {
         'content-type': true, 'content-length': true, 'accept': true, 'accept-language': true
     };
@@ -58283,6 +58581,8 @@ function NetworkCapture() {
         processBody,
         processRequestBody,
         processResponseBody,
+        buildExcludeRequestUrls,
+        isUrlExcluded,
         get isCapturingNetworkLogs() {
             return isCapturingNetworkLogs;
         },
@@ -58309,6 +58609,9 @@ function NetworkCapture() {
         },
         get responseBodyCb() {
             return responseBodyCb;
+        },
+        get excludeRequestUrls() {
+            return excludeRequestUrls;
         }
     };
     function initialize(pendo, PluginAPI) {
@@ -58326,6 +58629,7 @@ function NetworkCapture() {
         processHeaderConfig(NETWORK_LOGS_CONFIG_ALLOWED_REQUEST_HEADERS, allowedRequestHeaders);
         processHeaderConfig(NETWORK_LOGS_CONFIG_ALLOWED_RESPONSE_HEADERS, allowedResponseHeaders);
         setupBodyCallbacks();
+        buildExcludeRequestUrls();
         sendInterval = setInterval(() => {
             if (!sendQueue.failed()) {
                 send();
@@ -58386,13 +58690,26 @@ function NetworkCapture() {
          * @type {function}
          */
         ConfigReader.addOption(NETWORK_LOGS_CONFIG_CAPTURE_RESPONSE_BODY, [ConfigReader.sources.SNIPPET_SRC], undefined);
+        /**
+         * A list of request URL patterns to exclude from network capture.
+         * String patterns must match the full URL, including query parameters and fragments.
+         * Use RegExp for flexible or partial matching.
+         *
+         * Example: `['https://example.com', new RegExp('https://test\\.com\\/.*'), /.*\\.domain\\.com/]`
+         * @access public
+         * @category Config/Network Logs
+         * @name networkLogs.excludeRequestUrls
+         * @default []
+         * @type {Array<string|RegExp>}
+         */
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG_EXCLUDE_REQUEST_URLS, [ConfigReader.sources.SNIPPET_SRC], []);
     }
     function processHeaderConfig(configHeaderName, targetHeaders) {
         const configHeaders = pluginAPI.ConfigReader.get(configHeaderName);
         if (!configHeaders || configHeaders.length === 0)
             return;
         globalPendo._.each(configHeaders, (header) => {
-            if (!header || typeof header !== 'string')
+            if (!header || !globalPendo._.isString(header))
                 return;
             targetHeaders[header.toLowerCase()] = true;
         });
@@ -58408,6 +58725,28 @@ function NetworkCapture() {
             responseBodyCb = config.captureResponseBody;
         }
     }
+    function buildExcludeRequestUrls() {
+        const requestUrls = pluginAPI.ConfigReader.get(NETWORK_LOGS_CONFIG_EXCLUDE_REQUEST_URLS);
+        if (!requestUrls || requestUrls.length === 0)
+            return;
+        globalPendo._.each(requestUrls, (requestUrl) => {
+            const processedRequestUrl = processUrlPattern(requestUrl);
+            if (!processedRequestUrl)
+                return;
+            excludeRequestUrls.push(processedRequestUrl);
+        });
+    }
+    function processUrlPattern(url) {
+        if (!url)
+            return;
+        const isRegex = globalPendo._.isRegExp(url);
+        if (!globalPendo._.isString(url) && !isRegex)
+            return;
+        if (isRegex)
+            return url;
+        const escapedUrl = pluginAPI.util.escapeRegExp(url);
+        return new RegExp(`^${escapedUrl}$`);
+    }
     function onPtmPaused() {
         isPtmPaused = true;
     }
@@ -58460,8 +58799,17 @@ function NetworkCapture() {
         pluginAPI.Events['recording:unpaused'].off(recordingStarted);
         pluginAPI.Events['recording:paused'].off(recordingStopped);
     }
+    function isUrlExcluded(url) {
+        if (!url || !globalPendo._.isString(url))
+            return false;
+        if (excludeRequestUrls.length === 0)
+            return false;
+        return globalPendo._.some(excludeRequestUrls, (excludeRequestUrl) => {
+            return excludeRequestUrl.test(url);
+        });
+    }
     function handleRequest(request) {
-        if (!isCapturingNetworkLogs)
+        if (!isCapturingNetworkLogs || !request || isUrlExcluded(request.url))
             return;
         requestMap[request.requestId] = request;
     }
@@ -58518,7 +58866,7 @@ function NetworkCapture() {
         }, []);
     }
     function processBody(body, contentType) {
-        if (!body || typeof body !== 'string')
+        if (!body || !globalPendo._.isString(body))
             return '';
         const processedBody = maskSensitiveFields({ string: body, contentType, _: globalPendo._ });
         return truncate(processedBody, true);