@pendo/agent 2.314.0 → 2.315.0

package/dist/pendo.module.js

@@ -3422,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`
@@ -3433,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.
@@ -3945,8 +3945,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.314.0_';
-let PACKAGE_VERSION = '2.314.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 */
 /**
@@ -5569,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]),
@@ -14201,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
@@ -14211,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) {
@@ -14362,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;
@@ -14501,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',
@@ -14512,6 +14544,7 @@ const supportedPublicEvents = [
     'deliverablesLoaded',
     'guidesFailed',
     'guidesLoaded',
+    'segmentFlagsUpdated',
     'validateGuide',
     'validateLauncher',
     'validateGlobalScript'
@@ -20641,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');
@@ -20665,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: {},
@@ -20701,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) {
@@ -20768,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)) {
@@ -20783,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);
@@ -20793,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);
@@ -20838,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());
@@ -21160,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';
@@ -21177,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) {
@@ -24792,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();
     });
 };
@@ -24879,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);
         }
@@ -25031,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
@@ -25638,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)) {
@@ -25650,7 +25741,7 @@ var beforeShowGuide = function (guide) {
             }
         }
         else {
-            hideGuides();
+            hideGuides({ channel: guide.channel });
             store.dispatch('frames/hideGuides');
         }
     }
@@ -25793,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 = {};
@@ -25814,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') {
@@ -25927,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();
@@ -25964,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;
@@ -25973,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) {
@@ -26238,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
@@ -26528,6 +26603,7 @@ var initGuides = function (observer) {
         }
     });
     Events.identify.on(function () {
+        clearDoNotProcess();
         queueGuideReload();
     });
     Events.urlChanged.on(function () {
@@ -26845,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')) {
@@ -28076,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);
@@ -28087,7 +28162,7 @@ var GuideActivity = (function () {
                 return { guide, step };
             }
         }
-        return activeGuide;
+        return getActiveGuide();
     }
 })();
 
@@ -28126,6 +28201,11 @@ const PluginAPI = {
         removeGlobalScript: GuideRuntime.removeGlobalScript
     },
     GuideActivity,
+    GuideEvents: {
+        stageGuideEvent,
+        createGuideEvent,
+        getSeenTime
+    },
     GuideLoop: {
         addUpdatePhase,
         removeUpdatePhase
@@ -28134,7 +28214,9 @@ const PluginAPI = {
         addProcessor: addGuideProcessor,
         removeProcessor: removeGuideProcessor,
         registerDisplayableGuides,
-        removeDisplayableGuides
+        removeDisplayableGuides,
+        GuideFactory,
+        GuideStepFactory
     },
     hosts: {
         SERVER
@@ -28157,7 +28239,8 @@ const PluginAPI = {
         base64EncodeString,
         parseUrl,
         addInlineStyles: _.partial(addInlineStyles, ConfigReader),
-        getNow
+        getNow,
+        escapeRegExp
     },
     constants: {
         URL_MAX_LENGTH
@@ -28923,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) {
@@ -28930,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); }));
@@ -28949,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 () {
@@ -28962,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;
@@ -29002,7 +29088,7 @@ var renderStepPosition = function (template, guide, step) {
     return template(posObj);
 };
 var guideDev = {
-    getActiveGuide,
+    getActiveGuide: getActiveDefaultGuide,
     smartNextStep,
     smartFirstStep,
     advanceOn,
@@ -30893,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);
@@ -31685,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;
         };
@@ -31772,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
@@ -33842,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);
@@ -34430,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 || {});
@@ -37946,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'](); },
@@ -37962,7 +38092,6 @@ function debuggerExports() {
         setActiveGuides,
         getBody: dom.getBody,
         isMobileUserAgent: sniffer.isMobileUserAgent,
-        areGuidesDelayed,
         doesElementMatchContainsRules,
         getMetadata,
         isStagingServer,
@@ -38928,6 +39057,7 @@ class SessionManager {
 }
 var SessionManager$1 = new SessionManager();
 
+const SEGMENT_FLAGS_CACHE = 'segmentFlagsCache';
 class SegmentFlags {
     constructor() {
         this.name = 'SegmentFlags';
@@ -38945,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;
@@ -39013,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);
     }
@@ -40541,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() {
@@ -40815,6 +41001,30 @@ 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,
@@ -40859,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);
     }
 }
@@ -40869,29 +41085,52 @@ 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) {
@@ -53771,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';
@@ -53893,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 = [];
@@ -54187,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();
@@ -54299,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
@@ -54609,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}`, {
@@ -57032,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`
@@ -57043,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.
@@ -58304,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';
@@ -58311,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
     };
@@ -58341,6 +58581,8 @@ function NetworkCapture() {
         processBody,
         processRequestBody,
         processResponseBody,
+        buildExcludeRequestUrls,
+        isUrlExcluded,
         get isCapturingNetworkLogs() {
             return isCapturingNetworkLogs;
         },
@@ -58367,6 +58609,9 @@ function NetworkCapture() {
         },
         get responseBodyCb() {
             return responseBodyCb;
+        },
+        get excludeRequestUrls() {
+            return excludeRequestUrls;
         }
     };
     function initialize(pendo, PluginAPI) {
@@ -58384,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();
@@ -58444,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;
         });
@@ -58466,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;
     }
@@ -58518,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;
     }
@@ -58576,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);