@pendo/agent 2.342.0 → 2.344.0

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.342.0_';
-let PACKAGE_VERSION = '2.342.0';
+let VERSION = '2.344.0_';
+let PACKAGE_VERSION = '2.344.0';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4476,15 +4547,36 @@ class LogEmitter extends EventTarget {
 }
 const log = new LogEmitter();
 
-/** Key used to lookup the consent collection policy in the pendo configuration. */
 const CONSENT_COLLECTION = 'cookieConsentCollection';
-/** Key used to lookup the analytics events in the consent collection policy. */
 const ANALYTICS = 'analytics';
-/** Key used to lookup the guide analytics events in the consent collection policy. */
 const GUIDE_ANALYTICS = 'guideAnalytics';
-/** Key used to lookup the text collection mode in the consent collection policy. */
 const TEXT_COLLECTION = 'textCollection';
 const TEXT_COLLECTION_LEVELS = ['none', 'whitelist', 'all'];
+const ANALYTICS_EVENT_TYPES = {
+    agentResponse: 'agent_response',
+    clicks: 'click',
+    fieldChanges: 'change',
+    focus: 'focus',
+    formSubmits: 'submit',
+    identify: 'identify',
+    meta: 'meta',
+    objectMetadata: 'objectMetadata',
+    pageLoads: 'load',
+    prompt: 'prompt',
+    trackEvents: 'track',
+    userReaction: 'user_reaction'
+};
+const GUIDE_EVENT_TYPES = [
+    'guideActivity',
+    'guideAdvanced',
+    'guideDismissed',
+    'guideNotSeen',
+    'guideSeen',
+    'guideSnoozeCanceled',
+    'guideSnoozed',
+    'guideTimeout',
+    'pollResponse'
+];
 let enabledProducts = null;
 function getClassification() {
     return ConfigReader.get(CONSENT_COLLECTION) || {};
@@ -4494,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])) {
@@ -4504,30 +4599,62 @@ function warnOnUnconfiguredTiers(grantedTiers, classification) {
 function moreTextPermissive(a, b) {
     return TEXT_COLLECTION_LEVELS.indexOf(b) > TEXT_COLLECTION_LEVELS.indexOf(a) ? b : a;
 }
-function orBoolean(a, b) {
-    return a || Boolean(b);
+function toTextCollectionLevel(mode) {
+    return _.contains(TEXT_COLLECTION_LEVELS, mode) ? mode : TEXT_COLLECTION_LEVELS[0];
 }
-function unionArrays(a, b) {
-    return _.union(a, b);
+function toAnalyticsEventTypes(eventCollection) {
+    return _.reduce(ANALYTICS_EVENT_TYPES, function (types, eventType, key) {
+        if (eventCollection[key] === true) {
+            types.push(eventType);
+        }
+        return types;
+    }, []);
+}
+function normalizeTier(tier) {
+    const { visitorIdentity = {}, analytics = {}, guides = {}, sessionReplay = {} } = tier || {};
+    const eventCollection = analytics.eventCollection || {};
+    const analyticsEnabled = analytics.enabled === true;
+    return {
+        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]
+    };
+}
+function deniedProducts() {
+    return {
+        identity: false,
+        guides: false,
+        replay: false,
+        utm: false,
+        [ANALYTICS]: [],
+        [GUIDE_ANALYTICS]: [],
+        [TEXT_COLLECTION]: TEXT_COLLECTION_LEVELS[0]
+    };
+}
+function combineTiers(resolved, granted) {
+    return {
+        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])
+    };
 }
-// How a granted tier's value for a product combines with what's been resolved so far.
-// `initial` doubles as what an ungranted tier contributes -- an unlisted product falls
-// back to DEFAULT_RESOLVER, the plain "any granted tier turns it on" boolean rule.
-const RESOLVERS = {
-    [TEXT_COLLECTION]: { initial: TEXT_COLLECTION_LEVELS[0], combine: moreTextPermissive },
-    [ANALYTICS]: { initial: [], combine: unionArrays },
-    [GUIDE_ANALYTICS]: { initial: [], combine: unionArrays }
-};
-const DEFAULT_RESOLVER = { initial: false, combine: orBoolean };
 /**
- * Resolves the granted tiers against the configured product classification.
+ * Resolves the tiers a visitor consented to into what each product is allowed to do.
  *
- * A product the classification mentions anywhere starts at its resolver's `initial` value
- * -- a tier the visitor hasn't opted into contributes that same `initial` value, so it has
- * no say over the product, even to explicitly allow something. Only a granted tier's actual
- * value is combined in, so opting into an additional tier only ever adds capability. Most
- * products are plain booleans (DEFAULT_RESOLVER); `textCollection`, `analytics`, and
- * `guideAnalytics` have their own entries in RESOLVERS since none of them is a boolean.
+ * Every product starts denied and only granted tiers contribute, so a tier the visitor
+ * hasn't opted into has no say -- it can't deny anything, and it can't allow anything.
+ *
+ * A subscription with no cookie consent configured resolves to an empty map instead, which
+ * every read below treats as unconstrained: consent that was never set up can't deny
+ * anything either.
  *
  * @access private
  * @param {string | string[]} tiers tier or tiers the visitor consented to
@@ -4536,26 +4663,22 @@ const DEFAULT_RESOLVER = { initial: false, combine: orBoolean };
 function applyConsentTiers(tiers) {
     const cookieConsentCollection = getClassification();
     const consentedCookieTiers = toTierList(tiers);
-    const resolved = {};
     warnOnUnconfiguredTiers(consentedCookieTiers, cookieConsentCollection);
-    _.each(cookieConsentCollection, function (products, tier) {
-        var isGranted = _.contains(consentedCookieTiers, tier);
-        _.each(products, function (level, product) {
-            var resolver = RESOLVERS[product] || DEFAULT_RESOLVER;
-            var current = _.has(resolved, product) ? resolved[product] : resolver.initial;
-            var contributed = isGranted ? level : resolver.initial;
-            resolved[product] = resolver.combine(current, contributed);
-        });
-    });
-    enabledProducts = resolved;
+    if (_.isEmpty(cookieConsentCollection)) {
+        enabledProducts = {};
+        return getEnabledProducts();
+    }
+    enabledProducts = _.reduce(consentedCookieTiers, function (resolved, tier) {
+        const granted = cookieConsentCollection[tier];
+        return granted ? combineTiers(resolved, normalizeTier(granted)) : resolved;
+    }, deniedProducts());
     return getEnabledProducts();
 }
 function getEnabledProducts() {
     return enabledProducts ? _.extend({}, enabledProducts) : null;
 }
 /**
- * A product is enabled unless a tier has explicitly resolved it to false -- with no cookie
- * consent configured at all, or a product no tier ever mentions, there's nothing to deny.
+ * A product is enabled only if some granted tier turned it on or cookie consent has not been set.
  *
  * @access private
  * @param {string} product
@@ -4569,6 +4692,12 @@ function isProductEnabled(product) {
 function isTrackingConsentDenied() {
     return !isProductEnabled('identity');
 }
+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
@@ -4604,6 +4733,9 @@ function hasConsentForAnalyticsEvent(type) {
 function hasConsentForGuideEvent(type) {
     return hasConsentForProduct(type, GUIDE_ANALYTICS);
 }
+function resetConsentPolicy() {
+    enabledProducts = null;
+}
 
 const allowKeys = function () {
     var allowKeys = ConfigReader.get('storage.allowKeys') || '*';
@@ -5915,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])
     ];
@@ -11994,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$/,
@@ -12001,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())
@@ -12021,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);
@@ -14209,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',
@@ -14231,8 +14421,7 @@ const supportedPublicEvents = [
     'segmentFlagsError',
     'validateGuide',
     'validateLauncher',
-    'validateGlobalScript',
-    'identifyRequested'
+    'validateGlobalScript'
 ];
 function forwardInternalEvents(Events) {
     const unsubscribes = _.reduce(supportedPublicEvents, function (unsubscribes, eventName) {
@@ -21118,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)) {
@@ -22161,14 +22353,29 @@ function ClickActivation() {
         }
         stopEvent(evt);
     };
+    // Safari does not focus the badge on mousedown, so focus leaves the app instead.
+    // Apps that re-render on blur can remove the badge before mouseup, and the browser
+    // then generates no click at all. Holding focus where it is avoids that (APP-168412)
+    var preserveFocus = function (evt) {
+        if (evt.preventDefault) {
+            evt.preventDefault();
+        }
+        else {
+            evt.returnValue = false;
+        }
+    };
     badge.after('show', function () {
         if (!attached) {
             attachEvent(badgeElem, 'click', click);
+            if (badge.preserveFocusOnClick) {
+                attachEvent(badgeElem, 'mousedown', preserveFocus);
+            }
             attached = true;
         }
     });
     badge.after('hide', function () {
         detachEvent(badgeElem, 'click', click);
+        detachEvent(badgeElem, 'mousedown', preserveFocus);
         attached = false;
     });
     return badge;
@@ -22639,7 +22846,7 @@ function stepShowingProc(guide, step) {
         return;
     }
     const embedSelector = _.get(guide, 'attributes.embedConfig.selector');
-    if (embedSelector && !dom(embedSelector).length) {
+    if (embedSelector && (!dom(embedSelector).length || (guideElement && !isInDocument(guideElement[0])))) {
         step.hide();
         return;
     }
@@ -23603,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);
@@ -23626,8 +23833,8 @@ function getExcludedElements(step) {
     }
     return excludeElements;
 }
-var backdropInertStep = {
-    script: backdropInertRuntimeScript
+var backdropVisibilityStep = {
+    script: backdropVisibilityRuntimeScript
 };
 
 function isTooltip({ _ }, step) {
@@ -23787,7 +23994,7 @@ function registerPostrenderScripts(runtime) {
         advanceOnElement,
         announcementMarkSeen,
         autofocusStep,
-        backdropInertStep,
+        backdropVisibilityStep,
         repositionOnScroll,
         setFocusToActivationElement$1,
         videoLoadingAttribute
@@ -25381,8 +25588,17 @@ 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) {
             // Force a reload if Turbolinks replaces the document body without changing the url
@@ -25511,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;
@@ -25549,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', '');
@@ -25881,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)) {
@@ -25942,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) {
@@ -25964,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;
@@ -26213,23 +26513,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;
@@ -29275,7 +29558,8 @@ const PluginAPI = {
         collectEvent,
         hasConsentForAnalyticsEvent,
         getTextCollectionMode,
-        isReplayConsentDenied
+        isReplayConsentDenied,
+        isUtmConsentDenied
     },
     attachEvent,
     attachEventInternal,
@@ -29325,6 +29609,7 @@ const PluginAPI = {
     q,
     SendQueue,
     sessionStorage: agentStorage.getSession(),
+    storageIsDisabled,
     sizeElements,
     store,
     Tombstone,
@@ -29345,7 +29630,8 @@ const PluginAPI = {
         escapeRegExp,
         getZoneSafeMethod(method, target) {
             return getZoneSafeMethod$1(_, method, target);
-        }
+        },
+        isNativeCode
     },
     constants: {
         URL_MAX_LENGTH,
@@ -29478,16 +29764,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);
@@ -29503,6 +29791,62 @@ 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
+ * @example
+ * 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, identity) {
+    store.dispatch('frames/changeCookieConsent', { tiers });
+    return applyCookieConsent(tiers, identity);
+}
+function initializeCookieConsent(tiers) {
+    resetConsentPolicy();
+    if (tiers) {
+        applyCookieConsent(tiers);
+    }
+}
+
 /*
 * ResourceCenterActivity Event
 *
@@ -29986,6 +30330,8 @@ function initialize(options) {
         }
         // Save the options somewhere
         ConfigReader.setLocalConfig(options);
+        const cookieConsentTiers = _.get(options, 'cookieConsentTiers');
+        initializeCookieConsent(cookieConsentTiers);
         initDataHost();
         exportDataHost(pendo$1);
         const cookieDomain = ConfigReader.get('cookieDomain');
@@ -30177,8 +30523,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();
 }
@@ -31232,28 +31579,6 @@ logPublic.setActiveContexts = setActiveContexts;
 logPublic.showLogHistory = showLogHistory;
 logPublic.getLoggedContexts = getLoggedContexts;
 
-/**
- * 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.
- *
- * @access public
- * @category Core
- * @param {string | string[]} tiers tier or tiers the visitor consented to
- * @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
- * @example
- * pendo.updateCookieConsent('strictlyNecessary');
- * @example
- * pendo.updateCookieConsent(['strictlyNecessary', 'functional']);
- */
-function updateCookieConsent(tiers) {
-    const enabledProducts = applyConsentTiers(tiers);
-    Events['consent:changed'].trigger(enabledProducts);
-    log.debug('Cookie consent updated for ' + JSON.stringify(tiers) + '.');
-    return enabledProducts;
-}
-
 /**
  * Shared helper for event collection
  */
@@ -34051,20 +34376,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
@@ -34291,7 +34602,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}`);
@@ -35029,6 +35340,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);
         },
@@ -39010,6 +39337,7 @@ const IFrameMonitor = (function () {
     let pendoGlobal;
     let pluginAPI;
     let topDownSync;
+    let identitySync;
     return {
         name: 'IFrameMonitor',
         initialize: init,
@@ -39025,7 +39353,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');
@@ -39128,14 +39461,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() {
@@ -42300,7 +42642,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');
         /**
@@ -42312,11 +42655,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);
@@ -42372,10 +42723,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, '');
@@ -42390,6 +42747,8 @@ class WebAnalytics {
         this.subscriptions.length = 0;
     }
     addUtmToEvent(event) {
+        if (this.api.analytics.isUtmConsentDenied())
+            return;
         let utm;
         try {
             utm = this.loadParameters(this.api.agentStorage);
@@ -42403,11 +42762,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();
 
@@ -42735,6 +43102,310 @@ var guideMarkdownUtil = {
     removeMarkdownSyntax
 };
 
+const AUTO_ADVANCE_DELAY_MS = 250;
+function isAutoAdvanceRequested(step, _) {
+    return _.get(step, 'attributes.autoAdvance') === true;
+}
+// Survey-authored DOM carries no question-type classes, so eligibility keys off
+// answer-control shape: every required poll id must be radio-backed, which also
+// refuses a future non-radio type by default.
+function isStepEligibleInDom(step, _, requiredPollIds) {
+    const guideElement = step && step.guideElement;
+    if (!guideElement)
+        return false;
+    if (guideElement.find('textarea, input:text, input:checkbox, select').length)
+        return false;
+    const pollIds = _.uniq(_.map(guideElement.find('[data-pendo-poll-id]'), (element) => element.getAttribute('data-pendo-poll-id')));
+    if (!pollIds.length)
+        return false;
+    return _.all(pollIds, (pollId) => _.contains(requiredPollIds, pollId) &&
+        guideElement.find(`input:radio[data-pendo-poll-id="${pollId}"]`).length > 0);
+}
+function hideSubmitButtons(step, _, submitButtons) {
+    const hiddenButtons = [];
+    _.each(submitButtons, (button) => {
+        const element = step.guideElement.find(`#${button.props.id}`)[0];
+        if (!element)
+            return;
+        // display, not visibility: a reserved-but-invisible box leaves an empty gap
+        // at the foot of the step. Authored styles reach the button inline
+        // (build.js:151), so the original value is kept rather than blanked.
+        hiddenButtons.push({ element, display: element.style.display });
+        element.style.display = 'none';
+    });
+    return function restoreSubmitButtons() {
+        _.each(hiddenButtons, (hiddenButton) => {
+            hiddenButton.element.style.display = hiddenButton.display;
+        });
+    };
+}
+// The container's pixel height is measured during render (layout.js) before custom
+// scripts run, so collapsing a row afterwards leaves the box stale and the step keeps
+// the empty space. Same reflow pair metadata-substitution uses, scoped to this step so
+// a second guide on screen is left alone.
+function reflowGuide(step, _, pendo) {
+    const recalculateGuideHeight = _.get(pendo, 'BuildingBlocks.BuildingBlockGuides.recalculateGuideHeight');
+    try {
+        if (_.isFunction(pendo.flexElement)) {
+            pendo.flexElement(step.guideElement.find(guideMarkdownUtil.containerSelector));
+        }
+        if (_.isFunction(recalculateGuideHeight)) {
+            recalculateGuideHeight(`pendo-g-${step.id}`, step.guideElement);
+        }
+    }
+    catch (error) {
+        pendo.log('[auto-advance] guide reflow failed, the step may keep an empty row', error && error.message);
+    }
+}
+function createInertController() {
+    return { isActive: false, notifyAnswered() { }, cancel() { } };
+}
+function createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds) {
+    const _ = pendo._;
+    const inert = createInertController();
+    if (!isAutoAdvanceRequested(step, _))
+        return inert;
+    // Only reachable for API-authored guides; choosing between two
+    // submitPollAndGoToStep targets would be a guess.
+    if (_.size(submitButtons) !== 1) {
+        pendo.log(`[auto-advance] not arming: step ${step.id} needs exactly one submit button, found ${_.size(submitButtons)}`);
+        return inert;
+    }
+    if (!isStepEligibleInDom(step, _, requiredPollIds)) {
+        pendo.log(`[auto-advance] not arming: rendered step ${step.id} failed the eligibility re-check`);
+        return inert;
+    }
+    const submitButton = submitButtons[0];
+    // A click binds every action on the node and dispatches one event each
+    // (build.js:205-207); we dispatch one, so a second action would be dropped.
+    if (_.size(submitButton.actions) !== 1) {
+        pendo.log(`[auto-advance] not arming: step ${step.id} submit button carries ${_.size(submitButton.actions)} actions, expected one`);
+        return inert;
+    }
+    const submitAction = _.find(submitButton.actions, (action) => action.action === 'submitPoll' || action.action === 'submitPollAndGoToStep');
+    if (!submitAction)
+        return inert;
+    let hasFired = false;
+    let restoreSubmitButtons = _.noop;
+    function fire() {
+        if (hasFired)
+            return;
+        hasFired = true;
+        try {
+            // Shape-identical to what bindActionToNode emits for a click, so
+            // beforeAdvance consumers intercept an auto-advance the same way.
+            step.eventRouter.eventable.trigger('pendoEvent', {
+                action: submitAction.action,
+                params: submitAction.parameters,
+                step,
+                ignore: !!submitAction.ignore,
+                srcElement: step.guideElement.find(`#${submitButton.props.id}`)[0]
+            });
+        }
+        catch (error) {
+            restoreSubmitButtons();
+            reflowGuide(step, _, pendo);
+            pendo.log('[auto-advance] submit dispatch failed, restored the submit button', error && error.message);
+        }
+    }
+    const debouncedFire = _.debounce(fire, AUTO_ADVANCE_DELAY_MS);
+    // Last, so nothing between here and the return can throw and leave the step
+    // with a hidden button and no controller to un-hide it.
+    restoreSubmitButtons = hideSubmitButtons(step, _, submitButtons);
+    reflowGuide(step, _, pendo);
+    return {
+        isActive: true,
+        notifyAnswered: debouncedFire,
+        cancel: debouncedFire.cancel
+    };
+}
+
+const SURVEY_ANSWERS_KEY = 'pendo_survey_answers';
+const ANSWER_CONTROLS = 'input:radio, input:text, textarea, select';
+const TEXT_CONTROLS = 'input:text, textarea';
+// Matches MULTISTEP_CONTINUATION_TIME_LIMIT (walkthrough-guide.js:67), past which a guide is not continued.
+const ANSWER_TTL_MS = 12 * 60 * 60 * 1000;
+let pluginApi = null;
+let inMemoryAnswers = {};
+let persistedAnswersDropped = false;
+// A restricted storage.allowKeys silently rejects the session write, so mirror the visit here.
+const visitedSteps = {};
+function setPluginApi(api) {
+    pluginApi = api;
+    if (!api || !api.agentStorage)
+        return;
+    /**
+     * Answers the visitor has given on each step of a survey, so a step re-shown
+     * after Previous comes back filled in rather than blank.
+     *
+     * @name pendo_survey_answers
+     * @category Cookies/sessionStorage
+     * @access public
+     * @label SURVEY_ANSWERS_KEY
+     */
+    api.agentStorage.registry.addSession(SURVEY_ANSWERS_KEY);
+}
+// getSession() checks the allow-list but not storageIsDisabled, which the cookie path applies.
+function persistenceAllowed() {
+    const allowed = !!pluginApi &&
+        !!pluginApi.sessionStorage &&
+        typeof pluginApi.storageIsDisabled === 'function' &&
+        !pluginApi.storageIsDisabled();
+    if (allowed) {
+        persistedAnswersDropped = false;
+    }
+    else {
+        dropPersistedAnswers();
+    }
+    return allowed;
+}
+// agentStorage.clearAll only walks local keys, so a session key has to be dropped here.
+function dropPersistedAnswers() {
+    if (persistedAnswersDropped || !pluginApi || !pluginApi.sessionStorage)
+        return;
+    persistedAnswersDropped = true;
+    pluginApi.sessionStorage.removeItem(SURVEY_ANSWERS_KEY);
+}
+function readAll() {
+    if (!persistenceAllowed())
+        return inMemoryAnswers;
+    try {
+        return JSON.parse(pluginApi.sessionStorage.getItem(SURVEY_ANSWERS_KEY)) || {};
+    }
+    catch (error) {
+        return {};
+    }
+}
+function writeAll(answers) {
+    if (!persistenceAllowed()) {
+        inMemoryAnswers = answers;
+        return;
+    }
+    pluginApi.sessionStorage.setItem(SURVEY_ANSWERS_KEY, JSON.stringify(answers));
+}
+// identify() sets the new id before the reload tears the step down, so resolve this once per render.
+function visitorKey(pendo) {
+    return (pendo._.isFunction(pendo.get_visitor_id) && pendo.get_visitor_id()) || 'unknown';
+}
+function stateKey(step, guide, visitor) {
+    return `${visitor}:${guide.id}:${step.id}`;
+}
+// Host pages reassign Date.now to return a Date, which JSON writes out as a string.
+function getNow() {
+    return new Date().getTime();
+}
+function isFresh(writtenAt) {
+    return !!writtenAt && (getNow() - writtenAt) <= ANSWER_TTL_MS;
+}
+function readRecord(step, guide, visitor) {
+    const forVisitor = readAll()[visitor];
+    const forGuide = forVisitor && forVisitor[guide.id];
+    const record = (forGuide && forGuide[step.id]) || null;
+    return isFresh(record && record.at) ? record : null;
+}
+function updateRecord(step, guide, visitor, changes) {
+    const all = readAll();
+    const current = readRecord(step, guide, visitor) || {};
+    if (!all[visitor])
+        all[visitor] = {};
+    if (!all[visitor][guide.id])
+        all[visitor][guide.id] = {};
+    all[visitor][guide.id][step.id] = {
+        at: getNow(),
+        visited: changes.visited || current.visited || 0,
+        answers: changes.answers || current.answers || {}
+    };
+    writeAll(all);
+}
+// Previous only renders after an auto-advance step, so any other guide needs none of this.
+function guideAutoAdvances(guide, _) {
+    return _.any(_.get(guide, 'steps', []), (step) => isAutoAdvanceRequested(step, _));
+}
+function pollIdFor(control) {
+    let node = control;
+    while (node && node.getAttribute) {
+        const pollId = node.getAttribute('data-pendo-poll-id');
+        if (pollId)
+            return pollId;
+        node = node.parentNode;
+    }
+    return null;
+}
+// submitPoll never reads a checkbox back (event-router.js:264), so restoring one shows nothing sent.
+function isRadio(control) {
+    return control.type === 'radio';
+}
+function collectAnswers(step, pendo) {
+    const answers = {};
+    pendo._.each(step.guideElement.find(ANSWER_CONTROLS), (control) => {
+        const pollId = pollIdFor(control);
+        // One value per poll id, first in document order, as submitPoll reads it.
+        if (!pollId || answers[pollId])
+            return;
+        if (isRadio(control) && !control.checked)
+            return;
+        if (!control.value)
+            return;
+        answers[pollId] = [control.value];
+    });
+    return answers;
+}
+// No event dispatched: a restored answer must not reach the gate listeners or re-arm auto-advance.
+function restoreAnswers(step, pendo, answers) {
+    pendo._.each(step.guideElement.find(ANSWER_CONTROLS), (control) => {
+        const pollId = pollIdFor(control);
+        const values = pollId && answers[pollId];
+        if (!values)
+            return;
+        if (isRadio(control)) {
+            if (pendo._.contains(values, control.value))
+                control.checked = true;
+            return;
+        }
+        control.value = values[0];
+    });
+}
+function isRevisit(step, guide, pendo) {
+    if (!guideAutoAdvances(guide, pendo._))
+        return false;
+    const visitor = visitorKey(pendo);
+    if (isFresh(visitedSteps[stateKey(step, guide, visitor)]))
+        return true;
+    const record = readRecord(step, guide, visitor);
+    return !!record && (!!record.visited || !pendo._.isEmpty(record.answers));
+}
+const AnswerCache = {
+    name: 'AnswerCache',
+    script(step, guide, pendo) {
+        const visitor = visitorKey(pendo);
+        const record = readRecord(step, guide, visitor);
+        restoreAnswers(step, pendo, (record && record.answers) || {});
+        // Marked on leaving, not on render: sessionStorage survives a reload, which is not a revisit.
+        this.on('beforeUnmount', (event) => {
+            if (event && event.reason === 'hidden')
+                return;
+            visitedSteps[stateKey(step, guide, visitor)] = getNow();
+            updateRecord(step, guide, visitor, { visited: 1 });
+        });
+        const stepRoot = step.guideElement[0];
+        // change does not bubble on legacy browsers; it is here only for keyboard selection.
+        step.attachEvent(stepRoot, 'click', capture);
+        step.attachEvent(stepRoot, 'change', capture);
+        pendo._.each(step.guideElement.find(TEXT_CONTROLS), (control) => {
+            step.attachEvent(control, 'input', capture);
+        });
+        function capture() {
+            updateRecord(step, guide, visitor, { answers: collectAnswers(step, pendo) });
+        }
+    },
+    test(step, guide, pendo) {
+        const guideElement = step && step.guideElement;
+        return !!guideElement &&
+            guideAutoAdvances(guide, pendo._) &&
+            guideElement.find(ANSWER_CONTROLS).length > 0;
+    }
+};
+
 function getZoneSafeMethod(_, method, target = window) {
     var zoneSymbol = '__symbol__';
     /* global Zone */
@@ -43211,124 +43882,6 @@ function substitutionIcon(color, size) {
                 13.7239 15.5 14V17Z" fill="${color}"></path> </g></svg></div>`);
 }
 
-const AUTO_ADVANCE_DELAY_MS = 250;
-function isAutoAdvanceRequested(step, _) {
-    return _.get(step, 'attributes.autoAdvance') === true;
-}
-// Survey-authored DOM carries no question-type classes, so eligibility keys off
-// answer-control shape: every required poll id must be radio-backed, which also
-// refuses a future non-radio type by default.
-function isStepEligibleInDom(step, _, requiredPollIds) {
-    const guideElement = step && step.guideElement;
-    if (!guideElement)
-        return false;
-    if (guideElement.find('textarea, input:text, input:checkbox, select').length)
-        return false;
-    const pollIds = _.uniq(_.map(guideElement.find('[data-pendo-poll-id]'), (element) => element.getAttribute('data-pendo-poll-id')));
-    if (!pollIds.length)
-        return false;
-    return _.all(pollIds, (pollId) => _.contains(requiredPollIds, pollId) &&
-        guideElement.find(`input:radio[data-pendo-poll-id="${pollId}"]`).length > 0);
-}
-function hideSubmitButtons(step, _, submitButtons) {
-    const hiddenButtons = [];
-    _.each(submitButtons, (button) => {
-        const element = step.guideElement.find(`#${button.props.id}`)[0];
-        if (!element)
-            return;
-        // display, not visibility: a reserved-but-invisible box leaves an empty gap
-        // at the foot of the step. Authored styles reach the button inline
-        // (build.js:151), so the original value is kept rather than blanked.
-        hiddenButtons.push({ element, display: element.style.display });
-        element.style.display = 'none';
-    });
-    return function restoreSubmitButtons() {
-        _.each(hiddenButtons, (hiddenButton) => {
-            hiddenButton.element.style.display = hiddenButton.display;
-        });
-    };
-}
-// The container's pixel height is measured during render (layout.js) before custom
-// scripts run, so collapsing a row afterwards leaves the box stale and the step keeps
-// the empty space. Same reflow pair metadata-substitution uses, scoped to this step so
-// a second guide on screen is left alone.
-function reflowGuide(step, _, pendo) {
-    const recalculateGuideHeight = _.get(pendo, 'BuildingBlocks.BuildingBlockGuides.recalculateGuideHeight');
-    try {
-        if (_.isFunction(pendo.flexElement)) {
-            pendo.flexElement(step.guideElement.find(guideMarkdownUtil.containerSelector));
-        }
-        if (_.isFunction(recalculateGuideHeight)) {
-            recalculateGuideHeight(`pendo-g-${step.id}`, step.guideElement);
-        }
-    }
-    catch (error) {
-        pendo.log('[auto-advance] guide reflow failed, the step may keep an empty row', error && error.message);
-    }
-}
-function createInertController() {
-    return { isActive: false, notifyAnswered() { }, cancel() { } };
-}
-function createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds) {
-    const _ = pendo._;
-    const inert = createInertController();
-    if (!isAutoAdvanceRequested(step, _))
-        return inert;
-    // Only reachable for API-authored guides; choosing between two
-    // submitPollAndGoToStep targets would be a guess.
-    if (_.size(submitButtons) !== 1) {
-        pendo.log(`[auto-advance] not arming: step ${step.id} needs exactly one submit button, found ${_.size(submitButtons)}`);
-        return inert;
-    }
-    if (!isStepEligibleInDom(step, _, requiredPollIds)) {
-        pendo.log(`[auto-advance] not arming: rendered step ${step.id} failed the eligibility re-check`);
-        return inert;
-    }
-    const submitButton = submitButtons[0];
-    // A click binds every action on the node and dispatches one event each
-    // (build.js:205-207); we dispatch one, so a second action would be dropped.
-    if (_.size(submitButton.actions) !== 1) {
-        pendo.log(`[auto-advance] not arming: step ${step.id} submit button carries ${_.size(submitButton.actions)} actions, expected one`);
-        return inert;
-    }
-    const submitAction = _.find(submitButton.actions, (action) => action.action === 'submitPoll' || action.action === 'submitPollAndGoToStep');
-    if (!submitAction)
-        return inert;
-    let hasFired = false;
-    let restoreSubmitButtons = _.noop;
-    function fire() {
-        if (hasFired)
-            return;
-        hasFired = true;
-        try {
-            // Shape-identical to what bindActionToNode emits for a click, so
-            // beforeAdvance consumers intercept an auto-advance the same way.
-            step.eventRouter.eventable.trigger('pendoEvent', {
-                action: submitAction.action,
-                params: submitAction.parameters,
-                step,
-                ignore: !!submitAction.ignore,
-                srcElement: step.guideElement.find(`#${submitButton.props.id}`)[0]
-            });
-        }
-        catch (error) {
-            restoreSubmitButtons();
-            reflowGuide(step, _, pendo);
-            pendo.log('[auto-advance] submit dispatch failed, restored the submit button', error && error.message);
-        }
-    }
-    const debouncedFire = _.debounce(fire, AUTO_ADVANCE_DELAY_MS);
-    // Last, so nothing between here and the return can throw and leave the step
-    // with a hidden button and no controller to un-hide it.
-    restoreSubmitButtons = hideSubmitButtons(step, _, submitButtons);
-    reflowGuide(step, _, pendo);
-    return {
-        isActive: true,
-        notifyAnswered: debouncedFire,
-        cancel: debouncedFire.cancel
-    };
-}
-
 const requiredElement = '<span class="_pendo-required-indicator" style="color:red; font-style:italic;" title="Question is required"> *</span>';
 const requiredSyntax = '{required/}';
 const RequiredQuestions = {
@@ -43354,9 +43907,14 @@ const RequiredQuestions = {
                 }
             });
         }
+        // Restored answers reach no listener, and the controller is still inert here.
+        const revisited = isRevisit(step, guide, pendo);
+        if (revisited) {
+            evaluateRequiredQuestions(requiredQuestions);
+        }
         // Armed last, after the listeners above: runCustomScripts abandons the rest of
         // this script on a throw, and the submit button is already disabled by now.
-        if (isAutoAdvanceRequested(step, pendo._)) {
+        if (isAutoAdvanceRequested(step, pendo._) && !revisited) {
             this.on('beforeUnmount', () => autoAdvance.cancel());
             try {
                 autoAdvance = createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds);
@@ -43707,7 +44265,9 @@ function GuideMarkdown() {
         const markdownScriptsEnabled = configReader.get(GUIDEMARKDOWN_CONFIG);
         if (!markdownScriptsEnabled)
             return;
-        guideMarkdown = [PollBranching, MetadataSubstitution, RequiredQuestions, SkipToEligibleStep];
+        setPluginApi(PluginAPI);
+        // AnswerCache first: it restores the answers RequiredQuestions reads the gate against.
+        guideMarkdown = [AnswerCache, PollBranching, MetadataSubstitution, RequiredQuestions, SkipToEligibleStep];
         if (!pendo.designer) {
             pendo._.each(guideMarkdown, function (script) {
                 PluginAPI.GlobalRuntime.addGlobalScript(script);
@@ -51498,12 +52058,15 @@ class Transport {
     }
 }
 
-const CATCHALL_TYPES = ['load', 'click', 'track'];
 const EVENT_KINDS = {
-    catchall: 'catchall',
-    devlog: 'devlog',
-    recording: 'recording'
-};
+    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;
@@ -51511,6 +52074,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}`);
@@ -51523,11 +52087,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;
@@ -51583,21 +52154,31 @@ class LiveReplayClient {
         catch (_a) { }
     }
     sendRecordingEvent(fields) {
-        this.send(Object.assign(Object.assign({}, fields), { kind: EVENT_KINDS.recording, sequence: this.sequence++ }));
+        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;
         const capturedEvent = event.data[0];
         const config = { event: capturedEvent };
+        if (this.pendo._.contains(AGENTIC_TYPES, capturedEvent.type)) {
+            config.kind = EVENT_KINDS.AGENTIC;
+        }
         if (this.pendo._.contains(CATCHALL_TYPES, capturedEvent.type)) {
-            config.kind = EVENT_KINDS.catchall;
+            config.kind = EVENT_KINDS.CATCHALL;
         }
-        if (capturedEvent.type === EVENT_KINDS.devlog) {
-            config.kind = EVENT_KINDS.devlog;
+        if (capturedEvent.type === EVENT_KINDS.DEVLOG) {
+            config.kind = EVENT_KINDS.DEVLOG;
         }
         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);
@@ -52017,6 +52598,7 @@ class SessionRecorder {
                 this.logStopReason('CONSENT_DENIED');
                 this.stop();
             }
+            this.clearSessionInfo();
         }
         else if (!this.isRecording()) {
             this.start();
@@ -52181,7 +52763,6 @@ class SessionRecorder {
             var bind = this.pendo._.bind;
             this.visitorConfig = visitorConfig;
             this.clearOldSessionId();
-            this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId);
             this.sendQueue.start();
             this.interval = setInterval(() => {
                 if (!this.sendQueue.failed()) {
@@ -52194,6 +52775,7 @@ class SessionRecorder {
                 errorHandler: this.errorHandler
             }, config));
             this._refreshIds();
+            this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId, () => this.snapshot());
             this.onRecordingStart();
         }
         catch (e) {