@pendo/agent 2.343.1 → 2.344.1

package/dist/pendo.module.js

@@ -1,5 +1,26 @@
 function loadAgent(PendoConfig) {
 
+let policy;
+const policyOptions = {
+    createScriptURL: (str) => str,
+    createHTML: (str) => str
+};
+function getPolicy(pendo) {
+    if (!policy) {
+        if (pendo.trustedTypesPolicy) {
+            policy = pendo.trustedTypesPolicy;
+        }
+        else if (window.trustedTypes && typeof window.trustedTypes.createPolicy === 'function') {
+            policy = window.trustedTypes.createPolicy('pendo', policyOptions);
+        }
+        else {
+            policy = policyOptions;
+        }
+        pendo.trustedTypesPolicy = policy;
+    }
+    return policy;
+}
+
 var b64 = (function() {
 
     var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split('');
@@ -409,93 +430,52 @@ var sha1$1 = {exports: {}};
 var sha1Exports = sha1$1.exports;
 var sha1 = /*@__PURE__*/getDefaultExportFromCjs(sha1Exports);
 
-let policy;
-const policyOptions = {
-    createScriptURL: (str) => str,
-    createHTML: (str) => str
-};
-function getPolicy(pendo) {
-    if (!policy) {
-        if (pendo.trustedTypesPolicy) {
-            policy = pendo.trustedTypesPolicy;
-        }
-        else if (window.trustedTypes && typeof window.trustedTypes.createPolicy === 'function') {
-            policy = window.trustedTypes.createPolicy('pendo', policyOptions);
-        }
-        else {
-            policy = policyOptions;
-        }
-        pendo.trustedTypesPolicy = policy;
-    }
-    return policy;
-}
-
 function escapeRegExp(string) {
     if (!string)
         return;
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-var STAGING_SERVER_HASHES = 'stagingServerHashes';
-var STAGING_DOMAINS = 'stagingDomains';
-var pendo$1;
-var _pendoConfig = {};
-function loadAsModule(config) {
-    return config.loadAsModule;
-}
-function createPendoObject(config) {
-    var windowOrMountPoint = loadAsModule(config) ? {} : window;
-    const agentScriptTag = document.currentScript || findAgentScriptTag(document.getElementsByTagName('script'), config.apiKey);
-    let globalKey = config.pendoGlobalKey || 'pendo';
-    if (agentScriptTag) {
-        globalKey = agentScriptTag.getAttribute('data-pendo-global-key') || globalKey;
-        config.pendoGlobalKey = globalKey;
-    }
-    pendo$1 = windowOrMountPoint[globalKey] = windowOrMountPoint[globalKey] || {};
-    return pendo$1;
-}
-function isStagingEnvironment(config) {
-    return config.environmentName === 'staging';
-}
-function isMinifiedAgent(config) {
-    return !config.unminified;
-}
-function isExtension(config) {
-    return config.installType === 'extension'; // can't use isExtensionAgent() here because of circular dependency and ConfigReader not being ready yet
-}
-function shouldUseStagingAgent(config) {
-    return !isExtension(config) && !isStagingEnvironment(config) && isStagingServer(config);
-}
-function shouldUseUnminifiedAgent(config, debuggingEnabled) {
-    return !isExtension(config) && isMinifiedAgent(config) && debuggingEnabled;
-}
-function findAgentScriptTag(scripts = [], apiKey) {
-    const regex = /^https:\/\/[\w\-.]*cdn[\w\-.]*\.(pendo-dev\.com|pendo\.io)\/agent\/static\/([\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}|PENDO_API_KEY)\/pendo\.js$/g;
-    for (let i = 0; i < scripts.length; i++) {
-        const script = scripts[i];
-        if (regex.test(script.src) || script.id === `pendo-${apiKey}`) {
-            return script;
-        }
-    }
-}
-function buildCDNStagingAgentUrl(scripts = []) {
-    const agentScript = findAgentScriptTag(scripts);
-    if (agentScript) {
-        return agentScript.src.replace(/\.js$/, '-staging.js');
-    }
-}
-function getAlternateAgentUrl(config, useStaging, debuggingEnabled) {
-    var agentUrl = buildCDNStagingAgentUrl(document.getElementsByTagName('script')) || config.stagingAgentUrl;
-    if (debuggingEnabled) {
-        var suffix = 'unminified.js';
-        if (useStaging) {
-            suffix = 'staging-' + suffix;
-        }
-        agentUrl = agentUrl && agentUrl.replace(/staging\.js$/, suffix);
-    }
-    return agentUrl;
+// Matching a host or url against configured patterns and hashes. Shared by the
+// preamble and by the agent, so it must stay as light on imports as the preamble
+// is - nothing from the core SDK belongs in here.
+function getHash(str) {
+    return b64.uint8ToBase64(sha1
+        .create()
+        .update(str)
+        .digest());
 }
-function urlMatchesPatterns(url, patterns = [], hashes = []) {
+// A configured pattern is meant for a whole origin, but test() is a substring
+// search, so on its own it also accepts a look-alike like
+// "https://app.customer.com.attacker.tld". Rebuild it anchored. The group keeps
+// a top-level alternation from escaping the anchors, and the optional port keeps
+// a pattern that doesn't spell one out matching an origin that carries one. A
+// pattern ending in its own '$' opts out of the port, having already said where
+// it ends.
+//
+// Nothing here makes room for a missing scheme. allowedOriginServers is tested
+// against a full origin and only ever comes from the Pendo config, and a string
+// entry is already compiled as ^value$, so a scheme-less entry has never
+// matched anything. A scheme-less glob only did because it wasn't anchored,
+// which is the bug being fixed rather than behaviour to keep.
+//
+// 'm' is dropped rather than carried over, since it would let ^ and $ match at
+// a line break instead of at the ends.
+//
+// Compiled forms are kept by source: isTrustedOrigin runs on every postMessage,
+// and this would otherwise build a RegExp per pattern per call. A plain object
+// rather than a Map or WeakMap - neither exists in IE, and nothing here is
+// polyfilled.
+var anchoredPatterns = {};
+function anchorToWholeOrigin(regexp) {
+    var flags = regexp.ignoreCase ? 'i' : '';
+    var key = 're:' + flags + ':' + regexp.source;
+    if (!anchoredPatterns[key]) {
+        anchoredPatterns[key] = new RegExp('^(?:' + regexp.source + ')(?::\\d+)?$', flags);
+    }
+    return anchoredPatterns[key];
+}
+function urlMatchesPatterns(url, patterns = [], hashes = [], anchorPatterns = true) {
     if (!url)
         return false;
     if (hashes.length > 0) {
@@ -520,6 +500,9 @@ function urlMatchesPatterns(url, patterns = [], hashes = []) {
                     pattern = pattern.value;
                 }
             }
+            if (anchorPatterns && pattern instanceof RegExp) {
+                pattern = anchorToWholeOrigin(pattern);
+            }
             if (typeof pattern === 'string') {
                 // String entries are literal origins/hosts, not patterns. Escape
                 // them so a '.' can't act as a wildcard and match a look-alike domain.
@@ -532,6 +515,15 @@ function urlMatchesPatterns(url, patterns = [], hashes = []) {
     }
     return false;
 }
+/**
+ * The host part of an origin, or the input unchanged when it carries no scheme.
+ * Allowed-origin entries are stored however they were provided - the host picker
+ * offers bare hosts, while Pendo's own entries and older hand-entered ones are
+ * full origins - so matching tries both forms rather than rewriting either.
+ */
+function stripScheme$1(origin) {
+    return String(origin || '').replace(/^[a-z][a-z0-9+.-]*:\/\//i, '');
+}
 function domainSuffixes(host) {
     var hostname = (host || '').split(':')[0].toLowerCase();
     if (!hostname || /^[\d.]+$/.test(hostname) || hostname.indexOf(':') >= 0)
@@ -543,7 +535,7 @@ function domainSuffixes(host) {
     }
     return suffixes;
 }
-function hostMatchesStagingDomains(host, domains = []) {
+function hostMatchesDomains(host, domains = []) {
     if (!domains.length)
         return false;
     var suffixes = domainSuffixes(host);
@@ -553,6 +545,79 @@ function hostMatchesStagingDomains(host, domains = []) {
     }
     return false;
 }
+
+var STAGING_SERVER_HASHES = 'stagingServerHashes';
+var STAGING_DOMAINS = 'stagingDomains';
+var pendo$1;
+var _pendoConfig = {};
+function loadAsModule(config) {
+    return config.loadAsModule;
+}
+function createPendoObject(config) {
+    var windowOrMountPoint = loadAsModule(config) ? {} : window;
+    const agentScriptTag = document.currentScript || findAgentScriptTag(document.getElementsByTagName('script'), config.apiKey);
+    let globalKey = config.pendoGlobalKey || 'pendo';
+    if (agentScriptTag) {
+        globalKey = agentScriptTag.getAttribute('data-pendo-global-key') || globalKey;
+        config.pendoGlobalKey = globalKey;
+    }
+    pendo$1 = windowOrMountPoint[globalKey] = windowOrMountPoint[globalKey] || {};
+    return pendo$1;
+}
+function isStagingEnvironment(config) {
+    return config.environmentName === 'staging';
+}
+function isMinifiedAgent(config) {
+    return !config.unminified;
+}
+function isExtension(config) {
+    return config.installType === 'extension'; // can't use isExtensionAgent() here because of circular dependency and ConfigReader not being ready yet
+}
+function shouldUseStagingAgent(config) {
+    return !isExtension(config) && !isStagingEnvironment(config) && isStagingServer(config);
+}
+function shouldUseUnminifiedAgent(config, debuggingEnabled) {
+    return !isExtension(config) && isMinifiedAgent(config) && debuggingEnabled;
+}
+var CDN_AGENT_URL = /^https:\/\/[\w\-.]*cdn[\w\-.]*\.(pendo-dev\.com|pendo\.io)\/agent\/static\/([\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}|PENDO_API_KEY)\/pendo\.js$/;
+function isCDNAgentScript(script) {
+    return CDN_AGENT_URL.test(script.src);
+}
+function findAgentScriptTag(scripts = [], apiKey) {
+    for (let i = 0; i < scripts.length; i++) {
+        const script = scripts[i];
+        if (isCDNAgentScript(script) || script.id === `pendo-${apiKey}`) {
+            return script;
+        }
+    }
+}
+function findCDNAgentScriptTag(scripts = []) {
+    for (let i = 0; i < scripts.length; i++) {
+        if (isCDNAgentScript(scripts[i])) {
+            return scripts[i];
+        }
+    }
+}
+// Only a src that passed the CDN allowlist may be rewritten into an alternate
+// agent URL. Matching on id here would let any <script> in the page pick the
+// script that replaces the agent.
+function buildCDNStagingAgentUrl(scripts = []) {
+    const agentScript = findCDNAgentScriptTag(scripts);
+    if (agentScript) {
+        return agentScript.src.replace(/\.js$/, '-staging.js');
+    }
+}
+function getAlternateAgentUrl(config, useStaging, debuggingEnabled) {
+    var agentUrl = buildCDNStagingAgentUrl(document.getElementsByTagName('script')) || config.stagingAgentUrl;
+    if (debuggingEnabled) {
+        var suffix = 'unminified.js';
+        if (useStaging) {
+            suffix = 'staging-' + suffix;
+        }
+        agentUrl = agentUrl && agentUrl.replace(/staging\.js$/, suffix);
+    }
+    return agentUrl;
+}
 function isStagingServer(config, location) {
     if (!config) {
         config = getPendoConfig();
@@ -566,14 +631,10 @@ function isStagingServer(config, location) {
     if (!location) {
         location = window.location;
     }
-    return urlMatchesPatterns(location.host, config.stagingServers, config[STAGING_SERVER_HASHES]) ||
-        hostMatchesStagingDomains(location.host, config[STAGING_DOMAINS]);
-}
-function getHash(str) {
-    return b64.uint8ToBase64(sha1
-        .create()
-        .update(str)
-        .digest());
+    // Unanchored: staging globs are matched against location.host and don't
+    // account for a port, and picking the staging agent isn't a trust decision.
+    return urlMatchesPatterns(location.host, config.stagingServers, config[STAGING_SERVER_HASHES], false) ||
+        hostMatchesDomains(location.host, config[STAGING_DOMAINS]);
 }
 var METHODS_TO_CAPTURE = [
     'initialize',
@@ -2793,6 +2854,15 @@ function deepCopy(obj) {
     }
 }
 
+// Markup alone can define window.pendo_options (DOM clobbering via an element's id), so only
+// accept it when it's a plain object the page actually assigned
+function getLegacyGlobalSnippetOptions() {
+    var options = window.pendo_options;
+    if (Object.prototype.toString.call(options) !== '[object Object]')
+        return;
+    return options;
+}
+
 var originalOptions;
 var ConfigReader = (function () {
     // imports
@@ -2869,6 +2939,7 @@ var ConfigReader = (function () {
         addOption('additionalPublicAppIds', [PENDO_CONFIG_SRC, SNIPPET_SRC], undefined, undefined, ['additionalApiKeys']);
         addOption('allowedOriginServers');
         addOption('allowedOriginServerHashes');
+        addOption('enforceAllowedOriginServers', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
         addOption('allowMixedApplicationFrames', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
         addOption('allowMixedApiKeyFrames', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
         /**
@@ -3120,16 +3191,16 @@ var ConfigReader = (function () {
         addOption('pendoGlobalKey', [PENDO_CONFIG_SRC]);
         /**
          * By default, if there are multiple frames on the page that have the web SDK installed, they will communicate
-         * using `window.postMessage`. If set to `true` the web SDK will instead use the browser's Broadcast Channel
-         * API to communicate. This will only work when all frames use the same domain.
+         * using the browser's Broadcast Channel API. This will only work when all frames use the same domain. If set
+         * to `false` the web SDK will instead use `window.postMessage`, which also works across domains.
          *
          * @access public
          * @category Config/Core
          * @name preferBroadcastChannel
-         * @default false
+         * @default true
          * @type {boolean}
          */
-        addOption('preferBroadcastChannel', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
+        addOption('preferBroadcastChannel', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
         /**
          * By default, the web SDK will scan the page every 500ms to determine if any new badges or guides are eligible.
          * To improve idle performance, this can be set to `true` and then the web SDK will instead use a mutation
@@ -3144,17 +3215,17 @@ var ConfigReader = (function () {
         addOption('preferMutationObserver', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
         addOption('preventCookieRefresh');
         /**
-         * By default, the web SDK adds an `unload` event listener to the page to make sure it sends events upon
-         * navigation. If set to `true`, the web SDK will instead use the `visibilitychange` event listener and send
-         * events when the visibility is changing to `"hidden"`.
+         * By default, the web SDK uses the `visibilitychange` event listener and sends events when the visibility is
+         * changing to `"hidden"`. If set to `false`, the web SDK will instead add an `unload` event listener to the
+         * page to make sure it sends events upon navigation.
          *
          * @access public
          * @category Config/Core
          * @name preventUnloadListener
-         * @default false
+         * @default true
          * @type {boolean}
          */
-        addOption('preventUnloadListener', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
+        addOption('preventUnloadListener', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
         addOption('promotedWebSDKMetadataConfigurations', [PENDO_CONFIG_SRC], undefined, undefined, ['promotedAgentMetadataConfigurations']);
         /**
          * An array of strings or a function that returns an array of strings. The web SDK will then strip any query
@@ -3419,6 +3490,18 @@ var ConfigReader = (function () {
          */
         addOption('disableGuidePseudoStyles', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
         addOption('disableImportantStyleAttributes', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
+        /**
+         * When a guide has a backdrop enabled, by default elements outside the guide are hidden from assistive
+         * technology using `aria-hidden`. If `true`, the web SDK will instead apply the `inert` attribute,
+         * which also removes those elements from focus and pointer interaction.
+         *
+         * @access public
+         * @category Config/Guides
+         * @name useInertForBackdrop
+         * @default false
+         * @type {boolean}
+         */
+        addOption('useInertForBackdrop', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
         /**
          * Content of badge and target element activated guides will be prefetched on load to improve guide display
          * time unless set to `true`.
@@ -3676,7 +3759,7 @@ var ConfigReader = (function () {
     initializeOptions();
     var sourceGetters = {};
     sourceGetters[SNIPPET_SRC] = function () {
-        return { lookup: originalOptions || window.pendo_options, name: SNIPPET_SRC };
+        return { lookup: originalOptions || getLegacyGlobalSnippetOptions(), name: SNIPPET_SRC };
     };
     sourceGetters[PENDO_CONFIG_SRC] = function () {
         var lookup = getPendoConfig();
@@ -3926,17 +4009,6 @@ function shouldWrapHashChange() {
 function isMobileUserAgent() {
     return (/Android|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i).test(getUA());
 }
-// WICG inert polyfills through 3.1.0 install their MutationObserver-driven manager even where
-// the browser supports inert natively, and inject #inert-style when they do. With one active,
-// inerting a large subtree costs a full tree walk plus a subtree observer for as long as the
-// attribute stays, so treat the page as not supporting inert.
-function supportsInert() {
-    const descriptor = window.HTMLElement && _.isFunction(Object.getOwnPropertyDescriptor) &&
-        Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'inert');
-    const isNative = !!(descriptor && descriptor.get && isNativeCode(descriptor.get));
-    const isPolyfilled = !!document.getElementById('inert-style');
-    return isNative && !isPolyfilled;
-}
 function isSafari(userAgent = getUA()) {
     return userAgent.indexOf('Safari') >= 0 && !isChromium(userAgent);
 }
@@ -3949,7 +4021,6 @@ function isChromium(userAgent = getUA()) {
 const sniffer = {
     supportsHistoryApi: shouldWrapNativeHistory,
     supportsHashChange: shouldWrapHashChange,
-    supportsInert,
     hasEvent(event) {
         // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
         // it. In particular the event is not fired when backspace or delete key are pressed or
@@ -4058,8 +4129,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.343.1_';
-let PACKAGE_VERSION = '2.343.1';
+let VERSION = '2.344.1_';
+let PACKAGE_VERSION = '2.344.1';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4489,6 +4560,7 @@ const ANALYTICS_EVENT_TYPES = {
     formSubmits: 'submit',
     identify: 'identify',
     meta: 'meta',
+    objectMetadata: 'objectMetadata',
     pageLoads: 'load',
     prompt: 'prompt',
     trackEvents: 'track',
@@ -4514,6 +4586,9 @@ function toTierList(tiers) {
         return [tiers];
     return _.isArray(tiers) ? tiers : [];
 }
+function sameConsentTiers(a, b) {
+    return _.isEqual(toTierList(a).slice().sort(), toTierList(b).slice().sort());
+}
 function warnOnUnconfiguredTiers(grantedTiers, classification) {
     _.each(grantedTiers, function (tier) {
         if (_.isUndefined(classification[tier])) {
@@ -4543,6 +4618,7 @@ function normalizeTier(tier) {
         identity: visitorIdentity.trackVisitors === true,
         guides: guides.enabled === true,
         replay: sessionReplay.enabled === true,
+        utm: analyticsEnabled && eventCollection.utmParameters === true,
         analytics: analyticsEnabled ? toAnalyticsEventTypes(eventCollection) : [],
         guideAnalytics: analyticsEnabled && eventCollection.guideServing === true ? GUIDE_EVENT_TYPES.slice() : [],
         textCollection: analyticsEnabled ? toTextCollectionLevel(eventCollection.textCollectionMode) : TEXT_COLLECTION_LEVELS[0]
@@ -4553,6 +4629,7 @@ function deniedProducts() {
         identity: false,
         guides: false,
         replay: false,
+        utm: false,
         [ANALYTICS]: [],
         [GUIDE_ANALYTICS]: [],
         [TEXT_COLLECTION]: TEXT_COLLECTION_LEVELS[0]
@@ -4563,6 +4640,7 @@ function combineTiers(resolved, granted) {
         identity: resolved.identity || granted.identity,
         guides: resolved.guides || granted.guides,
         replay: resolved.replay || granted.replay,
+        utm: resolved.utm || granted.utm,
         [ANALYTICS]: _.union(resolved[ANALYTICS], granted[ANALYTICS]),
         [GUIDE_ANALYTICS]: _.union(resolved[GUIDE_ANALYTICS], granted[GUIDE_ANALYTICS]),
         [TEXT_COLLECTION]: moreTextPermissive(resolved[TEXT_COLLECTION], granted[TEXT_COLLECTION])
@@ -4617,6 +4695,9 @@ function isTrackingConsentDenied() {
 function isGuideConsentDenied() {
     return !isProductEnabled('guides');
 }
+function isUtmConsentDenied() {
+    return !isProductEnabled('utm');
+}
 /**
  * Session replay is denied whenever tracking itself is denied (DNT) -- a visitor
  * who can't be identified shouldn't have their session recorded either -- or when a
@@ -5966,7 +6047,6 @@ var Events = (function () {
         new EventType('recording:unpaused', [LIFECYCLE]),
         new EventType('recording:paused', [LIFECYCLE]),
         new EventType('consent:changed', [LIFECYCLE]),
-        new EventType('identifyRequested', [DEBUG, LIFECYCLE]),
         new EventType('childFrameJoined', [FRAMES]),
         new EventType('tabIdChanged:self', [DEBUG, LIFECYCLE])
     ];
@@ -12045,6 +12125,30 @@ _.extend(dom, {
 });
 _.extend(dom.prototype, DomEvent.$, DomQuery.$);
 
+// location.origin only arrived in IE11, and is missing again under the older
+// document modes IE11 can emulate
+function readOrigin(location) {
+    if (location.origin !== undefined)
+        return location.origin;
+    return location.protocol + '//' + location.host;
+}
+function getLocationOrigin(window) {
+    const strNull = 'null';
+    const origin = readOrigin(window.location);
+    if (origin === strNull && window.parent && window.parent != window) {
+        try {
+            const parentOrigin = readOrigin(window.parent.location);
+            if (parentOrigin && parentOrigin !== strNull) {
+                return parentOrigin;
+            }
+        }
+        catch (e) {
+            // cross-origin ancestor; cannot read top location
+        }
+    }
+    return origin;
+}
+
 // Domains that Pendo owns, will be swapped in by build patches
 const pendoDomainPatterns = [
         /^https:\/\/((adopt|oem)\.)?((us1)\.)?(app|via|adopt|cdn|oem|novus-api|novus|portal)(\.(au|eu|gov|hsbc|jpn|tv))?\.pendo\.io$/,
@@ -12052,11 +12156,34 @@ const pendoDomainPatterns = [
         /^https:\/\/hotfix-(ops|app)-([0-9]+-dot-)(pendo-au|pendo-eu|pendo-govramp|pendo-hsbc|pendo-io|pendo-jp-prod|pendo-tv|pendo-us1)\.appspot\.com$/,
         /^https:\/\/(pendo-au|pendo-eu|pendo-govramp|pendo-hsbc|pendo-io|pendo-jp-prod|pendo-tv|pendo-us1)-static\.storage\.googleapis\.com$/
     ]; // eslint-disable-line web-sdk-eslint-rules/no-gulp-env-references
+/**
+ * A leading dot marks a subtree: ".foo.com" covers foo.com and everything below
+ * it, while "foo.com" stays that one host and is matched exactly above.
+ *
+ * Keeping the dot in what we compare is what tells the two apart, so subtree
+ * entries can share allowedOriginServers / allowedOriginServerHashes instead of
+ * needing a list of their own. stagingDomains needs a separate list only because
+ * it strips the dot and hashes unconditionally, which allowed origins don't.
+ *
+ * Both forms are checked because appengine passes a non-glob name through
+ * verbatim: as a quoted string when the subscription doesn't hash its servers,
+ * as sha1 of that same string when it does.
+ *
+ * domainSuffixes drops any port and never yields a single label, so ".com" can
+ * never match.
+ */
+function matchesSubtreeEntry(host, servers, hashes) {
+    var suffixes = domainSuffixes(stripScheme$1(host));
+    return _.any(suffixes, function (suffix) {
+        var entry = '.' + suffix;
+        return _.contains(servers, entry) || _.contains(hashes, getHash(entry));
+    });
+}
 function isTrustedOrigin(host) {
     if (!host)
         return false;
     // for CNAME, trust the top-level origin
-    if (host === window.location.origin)
+    if (host === readOrigin(window.location))
         return true;
     // Trust the configured hosts
     if (host === getDataHost())
@@ -12072,7 +12199,21 @@ function isTrustedOrigin(host) {
         if (host === fullHostname)
             return true;
     }
-    if (urlMatchesPatterns(host, ConfigReader.get('allowedOriginServers', []), ConfigReader.get('allowedOriginServerHashes', [])))
+    // Entries are matched as both a full origin and a bare host, because that is
+    // how they were stored: the host picker offers names straight off servername,
+    // while Pendo's own entries and older hand-entered ones carry a scheme. A
+    // string entry compiles to ^value$, so a bare host has never matched the full
+    // origin these callers pass, and only a glob did - by accident, its leading
+    // '.*' swallowing the scheme. Testing both forms keeps existing origin
+    // entries pinned to their scheme and lets a bare host match whichever scheme
+    // it arrives on, without rewriting anything already provisioned.
+    var allowedServers = ConfigReader.get('allowedOriginServers', []);
+    var allowedHashes = ConfigReader.get('allowedOriginServerHashes', []);
+    if (urlMatchesPatterns(host, allowedServers, allowedHashes))
+        return true;
+    if (urlMatchesPatterns(stripScheme$1(host), allowedServers, allowedHashes))
+        return true;
+    if (matchesSubtreeEntry(host, allowedServers, allowedHashes))
         return true;
     return _.any(pendoDomainPatterns, function (pattern) {
         return pattern.test(host);
@@ -14260,15 +14401,13 @@ const internalEvents = {
     onEventCaptured: 1,
     segmentFlagsUpdated: 1,
     segmentFlagsReady: 1,
-    segmentFlagsError: 1,
-    identifyRequested: 1
+    segmentFlagsError: 1
 };
 const browserEvents = {
     ready: 1,
     segmentFlagsUpdated: 1,
     segmentFlagsReady: 1,
-    segmentFlagsError: 1,
-    identifyRequested: 1
+    segmentFlagsError: 1
 };
 const supportedPublicEvents = [
     'ready',
@@ -14282,8 +14421,7 @@ const supportedPublicEvents = [
     'segmentFlagsError',
     'validateGuide',
     'validateLauncher',
-    'validateGlobalScript',
-    'identifyRequested'
+    'validateGlobalScript'
 ];
 function forwardInternalEvents(Events) {
     const unsubscribes = _.reduce(supportedPublicEvents, function (unsubscribes, eventName) {
@@ -21169,8 +21307,11 @@ function isHidden(document) {
 const visibilitychange = 'visibilitychange';
 const pagehide = 'pagehide';
 const unload = 'unload';
+function supportsPageHide() {
+    return 'onpagehide' in window;
+}
 function onPageHidden(callback, useVisibilityChange) {
-    if (useVisibilityChange) {
+    if (useVisibilityChange && supportsPageHide()) {
         const unlisten = [];
         const onChange = () => {
             if (isHidden(document)) {
@@ -23669,14 +23810,14 @@ var autofocusStep = {
     script: autofocusRuntimeScript
 };
 
-function backdropInertRuntimeScript(step, guide, pendo) {
+function backdropVisibilityRuntimeScript(step, guide, pendo) {
     if (pendo.designer || !step.guideElement)
         return;
     if (step.hasBackdrop) {
         const BuildingBlockGuides = pendo.BuildingBlocks.BuildingBlockGuides;
         const guideElement = step.guideElement[0];
         const excludeElements = getExcludedElements(step);
-        const disabledElements = sniffer.supportsInert()
+        const disabledElements = ConfigReader.get('useInertForBackdrop')
             ? BuildingBlockGuides.addInertOutsideGuide(guideElement, [], excludeElements)
             : BuildingBlockGuides.addAriaHiddenOutsideGuide(guideElement, [], excludeElements);
         step.hiddenElements = (step.hiddenElements || []).concat(disabledElements);
@@ -23692,8 +23833,8 @@ function getExcludedElements(step) {
     }
     return excludeElements;
 }
-var backdropInertStep = {
-    script: backdropInertRuntimeScript
+var backdropVisibilityStep = {
+    script: backdropVisibilityRuntimeScript
 };
 
 function isTooltip({ _ }, step) {
@@ -23853,7 +23994,7 @@ function registerPostrenderScripts(runtime) {
         advanceOnElement,
         announcementMarkSeen,
         autofocusStep,
-        backdropInertStep,
+        backdropVisibilityStep,
         repositionOnScroll,
         setFocusToActivationElement$1,
         videoLoadingAttribute
@@ -25447,10 +25588,16 @@ var initGuides = function (observer) {
         var { guides } = event.data[0];
         if (_.isUndefined(guides))
             return;
-        guides ? enableGuides() : disableGuides();
+        if (guides) {
+            enableGuides();
+            return;
+        }
+        disableGuides();
+        clearGuideThrottlingState();
     });
     if (isGuideConsentDenied()) {
         disableGuides();
+        clearGuideThrottlingState();
     }
     teardownFns.push(onTurbolinksPageLoad(document, function onPageLoad() {
         if (pendoDotUrl.get() === reloadGuides.lastUrl) {
@@ -25580,6 +25727,11 @@ function disableGuides() {
     setGuidesDisabled(true);
     resetPendoUI();
 }
+function clearGuideThrottlingState() {
+    _.each(THROTTLING_STATE, function (throttlingStorageKey) {
+        agentStorage.clear(throttlingStorageKey);
+    });
+}
 var setGuidesDelayed = function (areDelayed) {
     var originalOptions = ConfigReader.getLocalConfig();
     delete originalOptions.delayGuides;
@@ -25618,10 +25770,20 @@ var adjustActiveGuideOnResize = function () {
     // as the user zooms the browser APP-53281
     log.debug('adjustActiveGuideOnResize firing');
     var activeGuide = getActiveGuide();
-    if (activeGuide && activeGuide.step && !pendo$1.ignoreResize) {
+    if (activeGuide && activeGuide.step && !pendo$1.ignoreResize && !isEditingGuideTextField(activeGuide.step)) {
         activeGuide.step.redraw();
     }
 };
+// Skip the resize redraw while the user is focused in a guide text field: the redraw blurs the
+// field, which on mobile dismisses the soft keyboard (APP-167261).
+var isEditingGuideTextField = function (step) {
+    var active = document.activeElement;
+    if (!active || (active.tagName !== 'TEXTAREA' && active.tagName !== 'INPUT')) {
+        return false;
+    }
+    var guideEl = step.guideElement && step.guideElement[0];
+    return !!guideEl && guideEl.contains(active);
+};
 var resizeHandler = function () {
     // In some browsers, it's possible for activeElement to become undefined or null
     var activeElementId = _.get(document, 'activeElement.id', '');
@@ -25950,6 +26112,46 @@ function stopLivePreviewRelay(onStopped) {
     }, relay.origin);
 }
 
+/**
+ * Whether to police who may join the cross-frame channel (APP-165872).
+ *
+ * Off by default, and deliberately named after the setting it depends on: the
+ * check trusts allowedOriginServers, which Pendo provisions per subscription,
+ * so it can only be switched on for an application whose origins are actually
+ * listed. With it off the relay behaves exactly as it always has.
+ */
+function enforceAllowedOriginServers() {
+    return ConfigReader.get('enforceAllowedOriginServers') === true;
+}
+/**
+ * Top's origin, read straight off the ancestor chain. Every current browser
+ * exposes location.ancestorOrigins; IE does not.
+ *
+ * Returns null whenever top can't be identified - no ancestorOrigins, an empty
+ * chain, an opaque top that reports the literal string "null", or a location
+ * that throws. Callers must treat null as "refuse", never as "trusted": an
+ * application that asked for enforcement gets it everywhere, including on the
+ * browsers where we have no way to look.
+ */
+function readTopOrigin(window) {
+    try {
+        if (window === window.top)
+            return readOrigin(window.location);
+        var ancestors = window.location.ancestorOrigins;
+        if (!ancestors || !ancestors.length)
+            return null;
+        // last entry is the top-most ancestor; a sandboxed or data: top reports
+        // the literal string "null", which is not a usable targetOrigin. Only the
+        // top matters here - an opaque ancestor in between still leaves a real
+        // origin at the end of the chain.
+        var top = ancestors[ancestors.length - 1];
+        return (top && top !== 'null') ? top : null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+
 var REMOVE_FRAME_ACTION = 'frames/removeFrame';
 function tryParseJson(messageData) {
     if (!_.isString(messageData)) {
@@ -26011,6 +26213,12 @@ _.extend(TopFrameRelay.prototype, {
         if (message.data.action === 'pendo::connect') {
             if (!isSameWindowTree(message, this._window))
                 return;
+            // A third-party widget embedded on the page is a frame below us, so it
+            // passes the tree check and frameConnect would wire its port straight
+            // into the store. Who the sender is, rather than where it sits, is what
+            // keeps that out (APP-165872).
+            if (enforceAllowedOriginServers() && !isTrustedOrigin(message.origin))
+                return;
             this._impl.frameConnect(message);
         }
         if (message.data.action === REMOVE_FRAME_ACTION) {
@@ -26033,10 +26241,33 @@ _.extend(TopFrameRelay.prototype, {
         this._impl.broadcast(message);
     },
     _connectToTop(timeout, retries, timeoutFn) {
-        this._impl.connectToTop({
-            action: 'pendo::connect',
-            frameId: this._store.state.frames.frameId
-        }, this._targetOrigin);
+        // The port goes out with the connect, so it can never be taken back once an
+        // untrusted top has it. Check who top is against the trusted origins before
+        // handing it over, and address the message to that origin rather than '*'
+        // (APP-165872).
+        //
+        // An application that turned enforcement on gets it everywhere, so a top we
+        // cannot identify is refused rather than trusted. That includes IE, which
+        // has no ancestorOrigins at all: the alternative is a browser-shaped hole in
+        // a control somebody opted into, which is worse than the frame running
+        // standalone there.
+        var enforcing = enforceAllowedOriginServers();
+        var topOrigin = enforcing ? readTopOrigin(this._window) : null;
+        if (!enforcing || (topOrigin && isTrustedOrigin(topOrigin))) {
+            this._impl.connectToTop({
+                action: 'pendo::connect',
+                frameId: this._store.state.frames.frameId
+            }, topOrigin || this._targetOrigin);
+        }
+        else {
+            // nothing reads frames/connectFailed, so without this the frame just
+            // goes quiet after ~3 minutes of retries with nothing to point at
+            log.warn('cross-frame connect refused: top origin is not allowed', {
+                topOrigin: topOrigin || 'unknown'
+            });
+        }
+        // when refused, fall through to the timeout so the frame still gives up
+        // cleanly via setConnectFailed instead of hanging half-connected
         setTimeout$1(_.bind(function () {
             if (this._connected)
                 return;
@@ -26286,23 +26517,6 @@ _.extend(PostMessageImpl.prototype, ImplCommon, {
     }
 });
 
-function getLocationOrigin(window) {
-    const strNull = 'null';
-    const origin = window.location.origin;
-    if (origin === strNull && window.parent && window.parent != window) {
-        try {
-            const parentOrigin = window.parent.location.origin;
-            if (parentOrigin && parentOrigin !== strNull) {
-                return parentOrigin;
-            }
-        }
-        catch (e) {
-            // cross-origin ancestor; cannot read top location
-        }
-    }
-    return origin;
-}
-
 function createSingletonMessageHandler(window, isTrustedOriginFn) {
     var listeners = [];
     var secure = false;
@@ -29348,7 +29562,8 @@ const PluginAPI = {
         collectEvent,
         hasConsentForAnalyticsEvent,
         getTextCollectionMode,
-        isReplayConsentDenied
+        isReplayConsentDenied,
+        isUtmConsentDenied
     },
     attachEvent,
     attachEventInternal,
@@ -29419,7 +29634,8 @@ const PluginAPI = {
         escapeRegExp,
         getZoneSafeMethod(method, target) {
             return getZoneSafeMethod$1(_, method, target);
-        }
+        },
+        isNativeCode
     },
     constants: {
         URL_MAX_LENGTH,
@@ -29552,16 +29768,18 @@ function initIdentityEvents() {
             }
         }
     };
-    const requestReidentification = function () {
-        if (!isTrackingConsentDenied() && isVisitorDNT()) {
-            Events.identifyRequested.trigger();
+    const resumeIdentity = function (newIdentity) {
+        if (!newIdentity || isTrackingConsentDenied() || !isVisitorDNT()) {
+            return;
         }
+        updateOptions(newIdentity);
     };
     const handleConsentChange = function (event) {
         var { identity } = event.data[0];
+        var newIdentity = event.data[1];
         if (_.isUndefined(identity))
             return;
-        identity ? requestReidentification() : clearSession({ doNotTrack: true });
+        identity ? resumeIdentity(newIdentity) : clearSession({ doNotTrack: true });
     };
     Events.identify.on(collectIdentifyEvent);
     Events.metadata.on(collectMetadataEvent);
@@ -29577,13 +29795,38 @@ function initIdentityEvents() {
     };
 }
 
+const CONSENT_TIERS = 'cookieConsentTiers';
+function applyCookieConsent(tiers, identity) {
+    rememberConsentTiers(tiers);
+    const enabledProducts = applyConsentTiers(tiers);
+    Events['consent:changed'].trigger(enabledProducts, identity);
+    log.debug('Cookie consent updated for ' + JSON.stringify(tiers) + '.');
+    return enabledProducts;
+}
+function rememberConsentTiers(tiers) {
+    const options = ConfigReader.getLocalConfig() || {};
+    options[CONSENT_TIERS] = tiers;
+    ConfigReader.setLocalConfig(options);
+}
+function getCookieConsentTiers() {
+    return ConfigReader.get(CONSENT_TIERS);
+}
+function isCurrentCookieConsent(tiers) {
+    return sameConsentTiers(tiers, getCookieConsentTiers());
+}
 /**
  * Enforces the cookie consent policy a visitor has agreed to. The policy is defined by the subscription's cookie consent configuration,
  * and is used to determine whether each product the web SDK may run.
  *
+ * A visitor who was not being tracked has no identity for the web SDK to resume, so pass one in
+ * `identity` when the new tiers start allowing identity. It is ignored otherwise.
+ *
  * @access public
  * @category Core
  * @param {string | string[]} tiers tier or tiers the visitor consented to
+ * @param {object} [identity] visitor and account to identify, in the same shape as
+ *   `pendo.updateOptions` -- applied only when consent moves a do-not-track visitor to a tier
+ *   that permits identity
  * @returns {object} map of product to its resolved value -- `guides` and `identity` are
  *   booleans (identity disabled means DNT), `textCollection` is `none`/`whitelist`/`all`,
  *   `analytics` and `guideAnalytics` are each an array of allowed event types
@@ -29591,17 +29834,20 @@ function initIdentityEvents() {
  * pendo.updateCookieConsent('strictlyNecessary');
  * @example
  * pendo.updateCookieConsent(['strictlyNecessary', 'functional']);
+ * @example
+ * pendo.updateCookieConsent(['strictlyNecessary', 'functional'], {
+ *     visitor: { id: 'put_visitor_id_here', role: 'admin' },
+ *     account: { id: 'put_account_id_here' }
+ * });
  */
-function updateCookieConsent(tiers) {
-    const enabledProducts = applyConsentTiers(tiers);
-    Events['consent:changed'].trigger(enabledProducts);
-    log.debug('Cookie consent updated for ' + JSON.stringify(tiers) + '.');
-    return enabledProducts;
+function updateCookieConsent(tiers, identity) {
+    store.dispatch('frames/changeCookieConsent', { tiers });
+    return applyCookieConsent(tiers, identity);
 }
 function initializeCookieConsent(tiers) {
     resetConsentPolicy();
     if (tiers) {
-        updateCookieConsent(tiers);
+        applyCookieConsent(tiers);
     }
 }
 
@@ -30281,8 +30527,9 @@ function autoInitialize() {
         log.info('already running');
         return;
     }
-    if (window.pendo_options) { // Support pre-2.0 initialization
-        initialize(window.pendo_options);
+    const snippetOptions = getLegacyGlobalSnippetOptions();
+    if (snippetOptions) { // Support pre-2.0 initialization
+        initialize(snippetOptions);
     }
     flushCallQueue();
 }
@@ -34133,20 +34380,6 @@ function GuideStep(guide) {
             stepId: step.id,
             isShown: step.isShown()
         });
-        // Android and some other mobile frameworks (Cordova webviews) send a resize event when the keyboard opens on focusing a text input
-        // due to redrawing the guide on resize this ends up closing the keyboard immediately.
-        // We need to ignore resize events in these cases to not redraw yet
-        // This idea comes from the 2nd solution of: https://stackoverflow.com/questions/38296574/disappearing-soft-keyboard-in-android-app
-        if (step.guideElement && step.guideElement[0]) {
-            step.attachEvent(step.guideElement[0], 'focusin', function (e) {
-                if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') {
-                    pendo$1.ignoreResize = true;
-                    setTimeout$1(function () {
-                        pendo$1.ignoreResize = false;
-                    }, 1000);
-                }
-            });
-        }
     };
     /**
      * Hides the Step if shown. Use an argument of an Object containing a
@@ -34373,7 +34606,7 @@ const ErrorLogModule = (function () {
             }
             const errMsg = `[${logEvent}]`;
             if (logEvent.level === LogLevel.Critical) {
-                const options = window.pendo_options || {};
+                const options = getLegacyGlobalSnippetOptions() || {};
                 logError(errMsg);
                 if (pendo$1.logStackTraces !== false && options.logStackTraces !== false && error.stack) {
                     writeErrorPOST(`${errMsg}\n${error.stack}`);
@@ -35111,6 +35344,22 @@ var FramesModule = (function () {
                 return;
             identifyVisitor(payload.visitorId, payload.accountId);
         },
+        changeCookieConsent(context, payload) {
+            crossFrameChannel.postMessage({
+                action: 'frames/receiveCookieConsent',
+                frameId: context.state.frameId,
+                tiers: payload.tiers
+            });
+        },
+        receiveCookieConsent(context, payload) {
+            if (context.getters.getMyApiKey() !== payload.apiKey)
+                return;
+            if (context.state.frameId === payload.frameId)
+                return;
+            if (isCurrentCookieConsent(payload.tiers))
+                return;
+            applyCookieConsent(payload.tiers);
+        },
         setReady(context, payload) {
             context.commit('setReady', payload.isReady);
         },
@@ -39092,6 +39341,7 @@ const IFrameMonitor = (function () {
     let pendoGlobal;
     let pluginAPI;
     let topDownSync;
+    let identitySync;
     return {
         name: 'IFrameMonitor',
         initialize: init,
@@ -39107,7 +39357,12 @@ const IFrameMonitor = (function () {
         removeHandlers();
     }
     function onChildFrameJoined() {
-        syncIdentity();
+        // Consent first. A frame applies these in the order they arrive, and one whose policy
+        // still denies tracking will throw away the identity sent below.
+        syncCookieConsent();
+        if (identitySync) {
+            syncIdentity();
+        }
     }
     function getAgentUrl() {
         const selfHostedUrl = pluginAPI.ConfigReader.get('selfHostedAgentUrl');
@@ -39210,14 +39465,23 @@ const IFrameMonitor = (function () {
             return;
         pluginAPI.store.dispatch('frames/syncIdentity', { visitorId, accountId });
     }
+    function syncCookieConsent() {
+        const tiers = getCookieConsentTiers();
+        if (!tiers)
+            return; // nothing to replay for a subscription that never configured consent
+        pluginAPI.store.dispatch('frames/changeCookieConsent', { tiers });
+    }
     function monitorFrames() {
         if (pluginAPI.ConfigReader.get('autoFrameInstall')) {
             pluginAPI.Events.ready.on(readyHandler);
         }
-        if (pluginAPI.ConfigReader.get('frameIdentitySync')) {
+        identitySync = pluginAPI.ConfigReader.get('frameIdentitySync');
+        // A frame that installs itself misses consent changes made before it joined, whether or
+        // not identity is being shared with it.
+        pluginAPI.Events.childFrameJoined.on(onChildFrameJoined);
+        if (identitySync) {
             pluginAPI.Events.metadata.on(metadataHandler);
             pluginAPI.Events.identify.on(identifyHandler);
-            pluginAPI.Events.childFrameJoined.on(onChildFrameJoined);
         }
     }
     function removeHandlers() {
@@ -42382,7 +42646,8 @@ class WebAnalytics {
         const { bind } = pendo._;
         this.subscriptions = [
             PluginAPI.attachEvent(PluginAPI.Events, 'eventCaptured', bind(this.addUtmToEvent, this)),
-            PluginAPI.attachEvent(PluginAPI.Events, 'sessionChanged', bind(this.sessionChanged, this))
+            PluginAPI.attachEvent(PluginAPI.Events, 'sessionChanged', bind(this.sessionChanged, this)),
+            PluginAPI.attachEvent(PluginAPI.Events, 'consent:changed', bind(this.handleConsentChange, this))
         ];
         this.suffix = this.api.ConfigReader.get('identityStorageSuffix');
         /**
@@ -42394,11 +42659,19 @@ class WebAnalytics {
          * @label WEB_ANALYTICS_STORAGE_KEY
          */
         this.api.agentStorage.registry.addLocal(WEB_ANALYTICS_STORAGE_KEY, { cookieSuffix: this.suffix, isSecure: true });
-        let params = this.loadParameters(PluginAPI.agentStorage);
-        if (!params || pendo._.isEmpty(params)) {
+        if (PluginAPI.analytics.isUtmConsentDenied()) {
+            return this.clearParameters(PluginAPI.agentStorage);
+        }
+        this.captureParameters();
+    }
+    captureParameters() {
+        if (this.api.analytics.isUtmConsentDenied())
+            return;
+        let params = this.loadParameters(this.api.agentStorage);
+        if (!params || this.pendo._.isEmpty(params)) {
             params = this.extractParameters(window.location.href, document.referrer);
         }
-        this.storeParameters(params, PluginAPI.agentStorage);
+        this.storeParameters(params, this.api.agentStorage);
     }
     extractParameters(url, referrer) {
         const locationUrl = new URL(url);
@@ -42454,10 +42727,16 @@ class WebAnalytics {
         }
     }
     storeParameters(params, storage) {
+        if (this.api.analytics.isUtmConsentDenied())
+            return;
         if (this.pendo._.size(params) > 0) {
             storage.write(WEB_ANALYTICS_STORAGE_KEY, JSON.stringify(params));
         }
     }
+    clearParameters(storage) {
+        storage.clear(WEB_ANALYTICS_STORAGE_KEY);
+        storage.clear(WEB_ANALYTICS_STORAGE_KEY, false, '');
+    }
     loadParameters(storage) {
         const storedParamsJson = storage.read(WEB_ANALYTICS_STORAGE_KEY) ||
             storage.read(WEB_ANALYTICS_STORAGE_KEY, false, '');
@@ -42472,6 +42751,8 @@ class WebAnalytics {
         this.subscriptions.length = 0;
     }
     addUtmToEvent(event) {
+        if (this.api.analytics.isUtmConsentDenied())
+            return;
         let utm;
         try {
             utm = this.loadParameters(this.api.agentStorage);
@@ -42485,11 +42766,19 @@ class WebAnalytics {
     }
     sessionChanged() {
         const agentStorage = this.api.agentStorage;
-        agentStorage.clear(WEB_ANALYTICS_STORAGE_KEY);
-        agentStorage.clear(WEB_ANALYTICS_STORAGE_KEY, false, '');
+        this.clearParameters(agentStorage);
         const params = this.extractParameters(window.location.href, document.referrer);
         this.storeParameters(params, agentStorage);
     }
+    handleConsentChange(event) {
+        const { utm } = event.data[0];
+        if (this.pendo._.isUndefined(utm))
+            return;
+        if (this.api.analytics.isUtmConsentDenied()) {
+            return this.clearParameters(this.api.agentStorage);
+        }
+        this.captureParameters();
+    }
 }
 var WebAnalytics$1 = new WebAnalytics();
 
@@ -51773,14 +52062,15 @@ class Transport {
     }
 }
 
-const CATCHALL_TYPES = ['load', 'click', 'track', 'guideSeen'];
-const AGENTIC_TYPES = ["prompt", "agent_response", "user_reaction"];
 const EVENT_KINDS = {
     AGENTIC: 'agentic',
     CATCHALL: 'catchall',
     DEVLOG: 'devlog',
     RECORDING: 'recording'
 };
+const CATCHALL_TYPES = ['load', 'click', 'track', 'guideSeen'];
+const AGENTIC_TYPES = ["prompt", "agent_response", "user_reaction"];
+const CONSENT_EXEMPT_TYPES = ['guideSeen', EVENT_KINDS.DEVLOG];
 class LiveReplayClient {
     constructor(pendo, api) {
         this.pendo = pendo;
@@ -51788,6 +52078,7 @@ class LiveReplayClient {
         this.ws = null;
         this.sequence = 0;
         this.unsubscribeEventCaptured = null;
+        this.disabled = false;
     }
     buildWsUrl() {
         const url = new URL$1(`${this.pendo.HOST}/data/live-replay/${this.pendo.apiKey}`);
@@ -51800,11 +52091,18 @@ class LiveReplayClient {
         return url.href;
     }
     start(visitorId, onOpen) {
-        if (this.ws && this.ws.readyState !== WebSocket.CLOSED)
+        const wsIsOpen = this.ws && this.ws.readyState !== WebSocket.CLOSED;
+        if (wsIsOpen || this.disabled)
             return;
         this.sequence = 0;
         this.unsubscribeEventCaptured = this.api.attachEvent(this.api.Events, 'eventCaptured', this.pendo._.bind(this.forwardEvent, this));
         this.ws = new WebSocket(this.buildWsUrl());
+        if (!this.api.util.isNativeCode(this.ws.send)) {
+            this.disabled = true;
+            this.api.log.warn('Live replay disabled: WebSocket send is not native.');
+            this.stop();
+            return;
+        }
         this.ws.onopen = this.pendo._.bind(this.handleOpen, this, visitorId, onOpen);
         const boundHandleClose = this.pendo._.bind(this.handleClose, this);
         this.ws.onclose = boundHandleClose;
@@ -51862,6 +52160,11 @@ class LiveReplayClient {
     sendRecordingEvent(fields) {
         this.send(Object.assign(Object.assign({}, fields), { kind: EVENT_KINDS.RECORDING, sequence: this.sequence++ }));
     }
+    hasConsentToForward(type) {
+        if (this.pendo._.contains(CONSENT_EXEMPT_TYPES, type))
+            return true;
+        return this.api.analytics.hasConsentForAnalyticsEvent(type);
+    }
     forwardEvent(event) {
         if (!event || !event.data || !event.data.length)
             return;
@@ -51878,6 +52181,8 @@ class LiveReplayClient {
         }
         if (!config.kind)
             return;
+        if (!this.hasConsentToForward(capturedEvent.type))
+            return;
         // other eventCaptured listeners still mutate capturedEvent in place; defer until they're done
         this.pendo._.defer(() => {
             this.send(config);
@@ -52297,6 +52602,7 @@ class SessionRecorder {
                 this.logStopReason('CONSENT_DENIED');
                 this.stop();
             }
+            this.clearSessionInfo();
         }
         else if (!this.isRecording()) {
             this.start();