@pendo/agent 2.339.1 → 2.341.0

package/dist/pendo.module.js

@@ -4046,8 +4046,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.339.1_';
-let PACKAGE_VERSION = '2.339.1';
+let VERSION = '2.341.0_';
+let PACKAGE_VERSION = '2.341.0';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4464,6 +4464,135 @@ 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'];
+let enabledProducts = null;
+function getClassification() {
+    return ConfigReader.get(CONSENT_COLLECTION) || {};
+}
+function toTierList(tiers) {
+    if (_.isString(tiers))
+        return [tiers];
+    return _.isArray(tiers) ? tiers : [];
+}
+function warnOnUnconfiguredTiers(grantedTiers, classification) {
+    _.each(grantedTiers, function (tier) {
+        if (_.isUndefined(classification[tier])) {
+            log.warn('Consent tier "' + tier + '" is not present in ' + CONSENT_COLLECTION + '.');
+        }
+    });
+}
+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 unionArrays(a, b) {
+    return _.union(a, b);
+}
+// 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.
+ *
+ * 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.
+ *
+ * @access private
+ * @param {string | string[]} tiers tier or tiers the visitor consented to
+ * @returns {object} map of product to its resolved value
+ */
+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;
+    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.
+ *
+ * @access private
+ * @param {string} product
+ * @returns {boolean}
+ */
+function isProductEnabled(product) {
+    if (!enabledProducts || _.isUndefined(enabledProducts[product]))
+        return true;
+    return enabledProducts[product] === true;
+}
+function isTrackingConsentDenied() {
+    return !isProductEnabled('identity');
+}
+/**
+ * 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
+ * tier explicitly denies the `replay` product on its own.
+ *
+ * @access private
+ * @returns {boolean}
+ */
+function isReplayConsentDenied() {
+    return isTrackingConsentDenied() || !isProductEnabled('replay');
+}
+/**
+ * Returns the consented text collection mode of the visitor.
+ *
+ * @access private
+ * @returns {string} 'all', 'whitelist', or 'none'
+ */
+function getTextCollectionMode() {
+    if (!enabledProducts)
+        return 'all';
+    var mode = enabledProducts[TEXT_COLLECTION];
+    return _.isUndefined(mode) ? 'all' : mode;
+}
+function hasConsentForProduct(type, product) {
+    if (!enabledProducts)
+        return true;
+    var allowed = enabledProducts[product];
+    return _.isUndefined(allowed) ? true : _.contains(allowed, type);
+}
+function hasConsentForAnalyticsEvent(type) {
+    return !isTrackingConsentDenied() && hasConsentForProduct(type, ANALYTICS);
+}
+function hasConsentForGuideEvent(type) {
+    return hasConsentForProduct(type, GUIDE_ANALYTICS);
+}
+
 const allowKeys = function () {
     var allowKeys = ConfigReader.get('storage.allowKeys') || '*';
     return _.isArray(allowKeys) ? _.indexBy(allowKeys) : allowKeys;
@@ -4529,7 +4658,7 @@ function createStorageShim(storageAccessor) {
     }
 }
 var pendoLocalStorage$3 = createStorageShim(function () { return window.localStorage; });
-var pendoSessionStorage$2 = createStorageShim(function () { return window.sessionStorage; });
+var pendoSessionStorage$3 = createStorageShim(function () { return window.sessionStorage; });
 
 /**
  * Safely deserializes JSON if value is a valid json string.
@@ -4556,9 +4685,11 @@ var areCookiesEnabled = true;
 var allowLocalStorageOnly = function () {
     return ConfigReader.get('localStorageOnly');
 };
-// This config setting really describes any persistence at all.
+/*
+ * This config setting really describes any persistence at all.
+ */
 var storageIsDisabled = function () {
-    return !!ConfigReader.get('disableCookies');
+    return !!ConfigReader.get('disableCookies') || isTrackingConsentDenied();
 };
 function enableCookies(enabled) {
     areCookiesEnabled = enabled;
@@ -4914,7 +5045,7 @@ var agentStorage = (function () {
             }
         });
     }
-    const wrappedPendoSessionStorage = _.extend({}, pendoSessionStorage$2);
+    const wrappedPendoSessionStorage = _.extend({}, pendoSessionStorage$3);
     wrappedPendoSessionStorage.setItem = wrapStorageWriteMethod(wrappedPendoSessionStorage.setItem, 'hasSession');
     const wrappedPendoLocalStorage = _.extend({}, pendoLocalStorage$3);
     wrappedPendoLocalStorage.setItem = wrapStorageWriteMethod(wrappedPendoLocalStorage.setItem, 'hasLocal');
@@ -5501,7 +5632,7 @@ else {
     };
 }
 
-const pendoSessionStorage$1 = agentStorage.getSession();
+const pendoSessionStorage$2 = agentStorage.getSession();
 /*
 * EventTracer.addTracerIds - Returns a new copy of the original object with
 * additional, contextual IDs added that provide a means of tracing event output
@@ -5583,7 +5714,7 @@ function createEventTracer(window) {
         return tabId;
     }
     function getSessionStorage() {
-        return sessionStorageMemoryCache(MemoryStorage, pendoSessionStorage$1);
+        return sessionStorageMemoryCache(MemoryStorage, pendoSessionStorage$2);
     }
     function tabIdChanged(callback) {
         if (!sniffer.addEventListener)
@@ -5771,6 +5902,8 @@ var Events = (function () {
         new EventType('ptm:paused', [LIFECYCLE]),
         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])
     ];
@@ -5987,6 +6120,7 @@ var SIZE_UNIQUE_ID = 11;
 const VISITOR_ID_KEY = 'visitorId';
 const OLD_VISITOR_ID_KEY = 'oldVisitorId';
 const ACCOUNT_ID_KEY = 'accountId';
+const COOKIELESS_VISITOR_ID = '__cookieless_visitor__';
 /**
  * Generate a unique id string, usually for a visitor id. Default for anonymous visitor ids.
  *
@@ -6038,6 +6172,9 @@ var DEFAULT_VISITOR_ID = 'VISITOR-UNIQUE-ID';
 var isDefaultVisitor = function (vId) {
     return DEFAULT_VISITOR_ID === vId;
 };
+var isVisitorDNT = function (vId = pendo$1.visitorId) {
+    return vId === COOKIELESS_VISITOR_ID;
+};
 var SUBACCOUNT_DELIMITER = '::';
 var isSubaccount = function (aId) {
     return new RegExp(SUBACCOUNT_DELIMITER).test(aId);
@@ -6085,6 +6222,9 @@ function generate_anonymous_visitor_id() {
     return generate_unique_id(TEMP_PREFIX);
 }
 function persistVisitorId(visitorId) {
+    if (isTrackingConsentDenied()) {
+        visitorId = COOKIELESS_VISITOR_ID;
+    }
     if (pendo$1.visitorId === visitorId)
         return visitorId;
     if (shouldPersist()) {
@@ -6153,6 +6293,10 @@ var set_visitor_id = function (new_visitor_id) {
         log.info('Invalid visitor id ' + new_visitor_id);
         return;
     }
+    if (isTrackingConsentDenied() && new_visitor_id !== COOKIELESS_VISITOR_ID) {
+        log.warn('Ignoring visitor id ' + new_visitor_id + ' while identity consent is dnt.');
+        return;
+    }
     persistVisitorId('' + new_visitor_id);
 };
 function set_old_visitor_id(new_old_visitor_id) {
@@ -6197,6 +6341,10 @@ var set_account_id = function (new_account_id) {
         log.info('No account id provided');
         return;
     }
+    if (isTrackingConsentDenied()) {
+        log.warn('Ignoring account id ' + new_account_id + ' while identity consent is dnt.');
+        return;
+    }
     if (!isValidId(new_account_id)) {
         clearAccount();
         log.info('Invalid account id: ' + new_account_id + '. Account cleared');
@@ -6239,10 +6387,12 @@ function clearAccount() {
  *
  * @access public
  * @category Identity
+ * @param {object} [options]
+ * @param {boolean} [options.doNotTrack] register the visitor as DNT instead of a new anonymous visitor
  * @example
  * pendo.clearSession()
  */
-function clearSession() {
+function clearSession(options = { doNotTrack: false }) {
     var props = {
         old_visitor_id: get_visitor_id({ generate: false }),
         old_account_id: get_account_id(),
@@ -6251,7 +6401,12 @@ function clearSession() {
     removeIdentificationCookies();
     delete pendo$1.visitorId;
     delete pendo$1.accountId;
-    get_visitor_id({ generate: true });
+    if (options.doNotTrack) {
+        set_visitor_id(COOKIELESS_VISITOR_ID);
+    }
+    else {
+        get_visitor_id({ generate: true });
+    }
     _.extend(props, {
         visitor_id: get_visitor_id(),
         account_id: get_account_id()
@@ -11072,6 +11227,9 @@ function wouldBeVisibleAfterAutoScroll(element) {
 function scrollElementIntoParentRect(element, scrollParent) {
     var clientRect = getClientRect(element);
     var scrollRect = getClientRect(scrollParent);
+    // A fixed element should already be visible so no need to scroll to it.
+    if (clientRect.fixed && !scrollRect.fixed)
+        return;
     var yScrollAmount = 0;
     var xScrollAmount = 0;
     var diff;
@@ -13394,7 +13552,7 @@ function createSendQueue(options, send, guaranteedSend) {
 }
 function filterNonGuideAnalytics(beacon) {
     return function (event, next) {
-        var isGuidesOnly = ConfigReader.get('excludeNonGuideAnalytics');
+        var isGuidesOnly = ConfigReader.get('excludeNonGuideAnalytics') || isTrackingConsentDenied();
         if (beacon === 'ptm' && isGuidesOnly) {
             return;
         }
@@ -13403,7 +13561,7 @@ function filterNonGuideAnalytics(beacon) {
 }
 function filterAnalyticsByType(event, next) {
     var excludeEvents = ConfigReader.get('analytics.excludeEvents');
-    if (_.indexOf(excludeEvents, event.type) >= 0) {
+    if (_.indexOf(excludeEvents, event.type) >= 0 || !hasConsentForAnalyticsEvent(event.type)) {
         return;
     }
     next(event);
@@ -14039,13 +14197,15 @@ const internalEvents = {
     onEventCaptured: 1,
     segmentFlagsUpdated: 1,
     segmentFlagsReady: 1,
-    segmentFlagsError: 1
+    segmentFlagsError: 1,
+    identifyRequested: 1
 };
 const browserEvents = {
     ready: 1,
     segmentFlagsUpdated: 1,
     segmentFlagsReady: 1,
-    segmentFlagsError: 1
+    segmentFlagsError: 1,
+    identifyRequested: 1
 };
 const supportedPublicEvents = [
     'ready',
@@ -14059,7 +14219,8 @@ const supportedPublicEvents = [
     'segmentFlagsError',
     'validateGuide',
     'validateLauncher',
-    'validateGlobalScript'
+    'validateGlobalScript',
+    'identifyRequested'
 ];
 function forwardInternalEvents(Events) {
     const unsubscribes = _.reduce(supportedPublicEvents, function (unsubscribes, eventName) {
@@ -14144,6 +14305,330 @@ var XHRGuideLoader = {
     }
 };
 
+function base32Encode(uint8array) {
+    var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+
+    var length = uint8array.length;
+
+    var bits = 0;
+    var value = 0;
+    var output = '';
+
+    for (var i = 0; i < length; i++) {
+        value = (value << 8) | uint8array[i];
+        bits += 8;
+
+        while (bits >= 5) {
+            output += alphabet[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+
+    if (bits > 0) {
+        output += alphabet[(value << (5 - bits)) & 31];
+    }
+
+    return output;
+}
+
+// A CNAME contentHost is commonly configured without a scheme, which would leave the rewritten
+// url relative to the current page rather than absolute. Leading-slash values are deliberate and
+// kept as-is: '//host' is protocol-relative, '/path' is same-origin (see fixContentHostUrl).
+function normalizeContentHost(contentHost) {
+    if (/:\/\//.test(contentHost) || /^\//.test(contentHost))
+        return contentHost;
+    return 'https://' + contentHost;
+}
+function stripScheme(host) {
+    return host.replace(/^https?:\/\//, '');
+}
+// Self hosted installs aim assetHost at their own host, or drop it entirely - the npm package
+// deletes it for the assets option - so it cannot locate our CDN. SERVER survives either way, and
+// app, cdn and static are sibling labels in every environment's domain template. Builds that point
+// SERVER somewhere other than an app host (--env=local) are left with assetHost.
+function getPendoCdnHost() {
+    var appLabel = /(^|\.)app\./;
+    var serverHost = stripScheme(SERVER);
+    if (!appLabel.test(serverHost))
+        return stripScheme(ASSET_HOST);
+    return serverHost.replace(appLabel, '$1cdn.');
+}
+// NOTE: this previously was *only* checking the snippet provided config for contentHost
+function replaceWithContentHost(str) {
+    var contentHost = ConfigReader.getLocalConfig('contentHost');
+    if (!contentHost || !str)
+        return str;
+    contentHost = normalizeContentHost(contentHost);
+    var cdnHost = getPendoCdnHost();
+    var assetHost = stripScheme(ASSET_HOST);
+    // Content proxy hosts are the environment's domain with static in the variable label, which is
+    // not always the leading one - us1 is content-<subId>.us1.static.pendo.io
+    var staticHost = cdnHost.replace(/(^|\.)cdn\./, '$1static.');
+    // An unknown host has to be dropped rather than interpolated: an empty one leaves a pattern
+    // that matches the // of every absolute url
+    var hostPatterns = [
+        SUBSCRIPTION_BUCKET && `${escapeRegExp(SUBSCRIPTION_BUCKET)}-\\d+\\.storage\\.googleapis\\.com`,
+        GLOBAL_BUCKET && `${escapeRegExp(GLOBAL_BUCKET)}\\.storage\\.googleapis\\.com`,
+        cdnHost && `content-\\d+\\.${escapeRegExp(staticHost)}`,
+        cdnHost && escapeRegExp(cdnHost),
+        assetHost && assetHost !== cdnHost && escapeRegExp(assetHost)
+    ];
+    return _.reduce(hostPatterns, function (rewritten, hostPattern) {
+        if (!hostPattern)
+            return rewritten;
+        return rewritten.replace(new RegExp(`(https:)?\\/\\/${hostPattern}`, 'g'), contentHost);
+    }, str);
+}
+function replaceObjectWithContentHost(obj) {
+    var contentHost = ConfigReader.getLocalConfig('contentHost');
+    if (!contentHost)
+        return obj;
+    return JSON.parse(replaceWithContentHost(JSON.stringify(obj)));
+}
+// APP-37205 we're only checking the remote contentHost config setting
+function getContentHostRegex() {
+    var ch = escapeRegExp(ConfigReader.getHostedConfig('contentHost'));
+    if (ch)
+        return ch + '*';
+}
+/**
+ * @access private
+ * @param {Function} isValidGuideResponse
+ * @param {object} guideResponse
+ */
+function isValidGuideResponse(guideResponse) {
+    // Is it in proper JSON format/an object? If guideResponse does not have the 'type', 'props', or the 'children'
+    // prop, we should also return false.
+    if (!(_.isObject(guideResponse) && guideResponse.hasOwnProperty('type') &&
+        guideResponse.hasOwnProperty('children') && guideResponse.hasOwnProperty('props'))) {
+        return false;
+    }
+    return true;
+}
+var ContentLoader = (function (pendo) {
+    var cache = {};
+    // For APP-37205, we're verifing that the result is what it is. I know.
+    var replaceWithContentHostAndVerify = _.compose(function (url) {
+        var test = getContentHostRegex();
+        if (test) {
+            var v = new RegExp(test);
+            if (!v.test(url)) {
+                log.debug('Failed to verify URL: ' + url + ' vs ' + test);
+            }
+        }
+        return url;
+    }, replaceWithContentHost);
+    /**
+     * @access private
+     * @typedef {object} ContentRequest
+     * @param {string} id uniquely identifies the container
+     * @param {string} contentUrl
+     * @param {string} contentUrlCss
+     * @param {string} contentUrlJs
+     */
+    /**
+     * @access private
+     * @typedef {object} ContentEntry
+     * @param {string} content The raw content as a string
+     * @param {Function} template The template function compiled from the raw content
+     * @param {Function} script The javascript to execute
+     */
+    /**
+     * Loads the content for the given container
+     *
+     * @access private
+     * @param  {ContentRequest} contentContainer
+     * @returns {Promise.<ContentEntry>} Resolved when all of the content is loaded
+     */
+    function load(contentContainer) {
+        try {
+            var cacheEntry = cache[contentContainer.id];
+            if (cacheEntry && cacheEntry.language !== contentContainer.language) {
+                delete cache[contentContainer.id];
+            }
+            if (!cache[contentContainer.id]) {
+                var promises = [];
+                var entry = {
+                    deferred: {},
+                    language: contentContainer.language
+                };
+                var fetchedDomContent = false;
+                cache[contentContainer.id] = entry;
+                if (XHRGuideLoader.usesXhr() && contentContainer.domUrl) {
+                    entry.deferred.domJson = q.defer();
+                    ajax.get(replaceWithContentHostAndVerify(contentContainer.domUrl)).then(function (result) {
+                        entry.domJson = replaceObjectWithContentHost(result.data);
+                        var guideResponse = result.data;
+                        if (isValidGuideResponse(guideResponse)) {
+                            entry.deferred.domJson.resolve();
+                        }
+                        else {
+                            // Log that the guide was invalid
+                            // handle promise
+                            log.critical(new Error('Response from the guide was not in proper JSON format'));
+                            entry.deferred.domJson.reject();
+                        }
+                    }).catch(function (e) {
+                        log.critical(e);
+                        Events.resourceFetchFail.trigger(contentContainer, e);
+                        entry.deferred.domJson.reject('Failed to load content');
+                    });
+                    promises.push(entry.deferred.domJson.promise);
+                    fetchedDomContent = true;
+                }
+                else if (contentContainer.domJsonpUrl) {
+                    entry.deferred.domJson = q.defer();
+                    var jsonpNode = loadResource(replaceWithContentHostAndVerify(contentContainer.domJsonpUrl), function (err) {
+                        dom.removeNode(jsonpNode);
+                        if (err) {
+                            Events.resourceFetchFail.trigger(contentContainer, err);
+                            return;
+                        }
+                    }, true);
+                    promises.push(entry.deferred.domJson.promise);
+                    fetchedDomContent = true;
+                }
+                if (contentContainer.contentUrlJs && !ConfigReader.get('preventCodeInjection')) {
+                    // Content, template, and script for 2.1+ agents
+                    entry.deferred.content = q.defer();
+                    var scriptNode = loadResource(replaceWithContentHostAndVerify(lightningRedirect(contentContainer.contentUrlJs)), function (err) {
+                        dom.removeNode(scriptNode);
+                        if (err) {
+                            Events.resourceFetchFail.trigger(contentContainer, err);
+                            return;
+                        }
+                    }, true);
+                    promises.push(entry.deferred.content.promise);
+                    // Style
+                    if (contentContainer.contentUrlCss) {
+                        entry.deferred.css = q.defer();
+                        loadResource({ url: replaceWithContentHostAndVerify(contentContainer.contentUrlCss), type: 'text/css' }, function () {
+                            entry.deferred.css.resolve();
+                        });
+                        promises.push(entry.deferred.css.promise);
+                    }
+                }
+                else if (contentContainer.contentUrl && !ConfigReader.get('preventCodeInjection')) {
+                    // Content with inlined script and css (2.0.x agents, or guides that have not migrated to the 2.1 format yet)
+                    entry.deferred.content = q.defer();
+                    var contentNode = loadResource(addExtensionToUrl(replaceWithContentHostAndVerify(contentContainer.contentUrl), '.js'), function (err) {
+                        dom.removeNode(contentNode);
+                        if (err) {
+                            Events.resourceFetchFail.trigger(contentContainer, err);
+                            return;
+                        }
+                    }, true);
+                    promises.push(entry.deferred.content.promise);
+                }
+                else if (!fetchedDomContent) {
+                    return q.reject('fetchedDomContent is still false');
+                }
+                entry.deferred.promise = q.all(promises).then(function () {
+                    return _.omit(entry, 'deferred');
+                });
+            }
+            return cache[contentContainer.id].deferred.promise;
+        }
+        catch (e) {
+            Events.resourceFetchFail.trigger(contentContainer, e);
+            throw e;
+        }
+    }
+    // Clears the content cache. Used for testing.
+    function reset() {
+        cache = {};
+    }
+    /**
+     * JSONP-style callback for loading guide content
+     * from script resources. Step content stored in
+     * GCS is wrapped with pendo.guideContent(...)
+     *
+     * @access private
+     * @param {string} guideId
+     * @param {string} stepId
+     * @param {string} content
+     * @param {Function} templateFn
+     * @param {Function} scriptFn
+     */
+    function guideContent(guideId, stepId, content, templateFn, scriptFn) {
+        if (_.isString(content)) {
+            content = preprocessGuideContent(content, guideId, stepId);
+            if (!_.isFunction(templateFn)) {
+                if (shouldCreateTemplate(content)) {
+                    templateFn = _.template(content);
+                }
+                else {
+                    templateFn = _.constant(content);
+                }
+            }
+            var entry = cache[guideId + stepId];
+            if (entry && entry.deferred.content) {
+                entry.content = content;
+                entry.template = templateFn;
+                entry.script = scriptFn;
+                entry.deferred.content.resolve();
+            }
+        }
+    }
+    // preprocess content to remove simple guide and step IDs templating
+    function removeStandardTemplating(content, guideId, stepId) {
+        const stdTemplating = `<% if (typeof guide !== 'undefined') { %>
+var guide = pendo.findGuideById('<%= guide.id %>');
+var step = guide && guide.findStepById('<%= step.id %>');
+<% } %>`;
+        const sansTemplating = `var guide = pendo.findGuideById('${guideId}');
+var step = guide && guide.findStepById('${stepId}');`;
+        return content.replace(stdTemplating, sansTemplating);
+    }
+    // execute all content preprocessors and return end result
+    const GuideContentProcessorList = [removeStandardTemplating];
+    function preprocessGuideContent(content, guideId, stepId) {
+        return _.reduce(GuideContentProcessorList, (acc, procFn) => {
+            return procFn(acc, guideId, stepId);
+        }, content);
+    }
+    function shouldCreateTemplate(content) {
+        return /<%/.test(content) && /%>/.test(content);
+    }
+    function receiveDomStructureJson(guideId, stepId, domJson) {
+        var entry = cache[guideId + stepId];
+        if (entry && entry.deferred.domJson) {
+            entry.domJson = replaceObjectWithContentHost(domJson);
+            entry.deferred.domJson.resolve();
+        }
+    }
+    function lightningRedirect(url) {
+        if (isSfdcLightning()) {
+            // https://pendo-static-1234.storage.googleapis.com/guide-content/:guideId/:stepId/:someKindaHash.guide.js
+            var path = url.replace(/^https?:\/\/[^/]+\/guide-content\//, '').split('/');
+            var guideId = path[0];
+            /* global $A */
+            var resourcePath = $A.get('$Resource.pendoGuide' + base32Encode(toUTF8Array(guideId)));
+            if (_.isString(resourcePath)) {
+                return resourcePath + '/' + path.join('/');
+            }
+        }
+        return url;
+    }
+    function addExtensionToUrl(url, extension) {
+        if (!_.isString(url))
+            return url;
+        var i = _.indexOf(url, '?');
+        if (i < 0) {
+            return url + extension;
+        }
+        else {
+            return url.substring(0, i) + extension + url.substring(i);
+        }
+    }
+    return {
+        load,
+        reset,
+        guideContent,
+        receiveDomStructureJson
+    };
+})();
+
 function getHashFromContentUrl(url) {
     var contentUrl = parseUrl(url);
     var sha1Length = 27;
@@ -14230,10 +14715,12 @@ var ContentVerifier = (function () {
         if (!_.isString(url))
             return q.reject('unable to parse "' + url + '"');
         var stepHash = computeStepHash(contentContainer, urlProp);
-        return ajax.get(url).then(function (response) {
+        // Verify against the host the loader fetches from; the hash still comes from the original url.
+        var fetchUrl = replaceWithContentHost(url);
+        return ajax.get(fetchUrl).then(function (response) {
             if (computeHashFromFile(response.data) === stepHash)
                 return;
-            return q.reject('Unable to verify content at "' + url + '"');
+            return q.reject('Unable to verify content at "' + fetchUrl + '"');
         });
     }
     function verifyContentHashUnlessSri(contentContainer, urlProp) {
@@ -14508,297 +14995,6 @@ function GuideStepFactory(step, guide) {
 GuideFactory.behaviors = [];
 GuideStepFactory.behaviors = [];
 
-function base32Encode(uint8array) {
-    var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-
-    var length = uint8array.length;
-
-    var bits = 0;
-    var value = 0;
-    var output = '';
-
-    for (var i = 0; i < length; i++) {
-        value = (value << 8) | uint8array[i];
-        bits += 8;
-
-        while (bits >= 5) {
-            output += alphabet[(value >>> (bits - 5)) & 31];
-            bits -= 5;
-        }
-    }
-
-    if (bits > 0) {
-        output += alphabet[(value << (5 - bits)) & 31];
-    }
-
-    return output;
-}
-
-// NOTE: this previously was *only* checking the snippet provided config for contentHost
-function replaceWithContentHost(str) {
-    var contentHost = ConfigReader.getLocalConfig('contentHost');
-    if (!contentHost || !str)
-        return str;
-    var subBucketPattern = new RegExp(`(https:)?\\/\\/${SUBSCRIPTION_BUCKET}-\\d+\\.storage\\.googleapis\\.com`, 'g');
-    var globalBucketPattern = new RegExp(`(https:)?\\/\\/${GLOBAL_BUCKET}\\.storage\\.googleapis\\.com`, 'g');
-    // Content proxy hosts look like content-<subId>.static.<envDomain>, where envDomain is ASSET_HOST minus its cdn. prefix
-    var envDomain = ASSET_HOST.replace(/^cdn\./, '');
-    var contentProxyPattern = new RegExp(`(https:)?\\/\\/content-\\d+\\.static\\.${escapeRegExp(envDomain)}`, 'g');
-    return str.replace(subBucketPattern, contentHost)
-        .replace(globalBucketPattern, contentHost)
-        .replace(contentProxyPattern, contentHost)
-        .replace(new RegExp(`(https:)?\\/\\/${escapeRegExp(ASSET_HOST)}`, 'g'), contentHost);
-}
-function replaceObjectWithContentHost(obj) {
-    var contentHost = ConfigReader.getLocalConfig('contentHost');
-    if (!contentHost)
-        return obj;
-    return JSON.parse(replaceWithContentHost(JSON.stringify(obj)));
-}
-// APP-37205 we're only checking the remote contentHost config setting
-function getContentHostRegex() {
-    var ch = escapeRegExp(ConfigReader.getHostedConfig('contentHost'));
-    if (ch)
-        return ch + '*';
-}
-/**
- * @access private
- * @param {Function} isValidGuideResponse
- * @param {object} guideResponse
- */
-function isValidGuideResponse(guideResponse) {
-    // Is it in proper JSON format/an object? If guideResponse does not have the 'type', 'props', or the 'children'
-    // prop, we should also return false.
-    if (!(_.isObject(guideResponse) && guideResponse.hasOwnProperty('type') &&
-        guideResponse.hasOwnProperty('children') && guideResponse.hasOwnProperty('props'))) {
-        return false;
-    }
-    return true;
-}
-var ContentLoader = (function (pendo) {
-    var cache = {};
-    // For APP-37205, we're verifing that the result is what it is. I know.
-    var replaceWithContentHostAndVerify = _.compose(function (url) {
-        var test = getContentHostRegex();
-        if (test) {
-            var v = new RegExp(test);
-            if (!v.test(url)) {
-                log.debug('Failed to verify URL: ' + url + ' vs ' + test);
-            }
-        }
-        return url;
-    }, replaceWithContentHost);
-    /**
-     * @access private
-     * @typedef {object} ContentRequest
-     * @param {string} id uniquely identifies the container
-     * @param {string} contentUrl
-     * @param {string} contentUrlCss
-     * @param {string} contentUrlJs
-     */
-    /**
-     * @access private
-     * @typedef {object} ContentEntry
-     * @param {string} content The raw content as a string
-     * @param {Function} template The template function compiled from the raw content
-     * @param {Function} script The javascript to execute
-     */
-    /**
-     * Loads the content for the given container
-     *
-     * @access private
-     * @param  {ContentRequest} contentContainer
-     * @returns {Promise.<ContentEntry>} Resolved when all of the content is loaded
-     */
-    function load(contentContainer) {
-        try {
-            var cacheEntry = cache[contentContainer.id];
-            if (cacheEntry && cacheEntry.language !== contentContainer.language) {
-                delete cache[contentContainer.id];
-            }
-            if (!cache[contentContainer.id]) {
-                var promises = [];
-                var entry = {
-                    deferred: {},
-                    language: contentContainer.language
-                };
-                var fetchedDomContent = false;
-                cache[contentContainer.id] = entry;
-                if (XHRGuideLoader.usesXhr() && contentContainer.domUrl) {
-                    entry.deferred.domJson = q.defer();
-                    ajax.get(replaceWithContentHostAndVerify(contentContainer.domUrl)).then(function (result) {
-                        entry.domJson = replaceObjectWithContentHost(result.data);
-                        var guideResponse = result.data;
-                        if (isValidGuideResponse(guideResponse)) {
-                            entry.deferred.domJson.resolve();
-                        }
-                        else {
-                            // Log that the guide was invalid
-                            // handle promise
-                            log.critical(new Error('Response from the guide was not in proper JSON format'));
-                            entry.deferred.domJson.reject();
-                        }
-                    }).catch(function (e) {
-                        log.critical(e);
-                        Events.resourceFetchFail.trigger(contentContainer, e);
-                        entry.deferred.domJson.reject('Failed to load content');
-                    });
-                    promises.push(entry.deferred.domJson.promise);
-                    fetchedDomContent = true;
-                }
-                else if (contentContainer.domJsonpUrl) {
-                    entry.deferred.domJson = q.defer();
-                    var jsonpNode = loadResource(replaceWithContentHostAndVerify(contentContainer.domJsonpUrl), function (err) {
-                        dom.removeNode(jsonpNode);
-                        if (err) {
-                            Events.resourceFetchFail.trigger(contentContainer, err);
-                            return;
-                        }
-                    }, true);
-                    promises.push(entry.deferred.domJson.promise);
-                    fetchedDomContent = true;
-                }
-                if (contentContainer.contentUrlJs && !ConfigReader.get('preventCodeInjection')) {
-                    // Content, template, and script for 2.1+ agents
-                    entry.deferred.content = q.defer();
-                    var scriptNode = loadResource(replaceWithContentHostAndVerify(lightningRedirect(contentContainer.contentUrlJs)), function (err) {
-                        dom.removeNode(scriptNode);
-                        if (err) {
-                            Events.resourceFetchFail.trigger(contentContainer, err);
-                            return;
-                        }
-                    }, true);
-                    promises.push(entry.deferred.content.promise);
-                    // Style
-                    if (contentContainer.contentUrlCss) {
-                        entry.deferred.css = q.defer();
-                        loadResource({ url: replaceWithContentHostAndVerify(contentContainer.contentUrlCss), type: 'text/css' }, function () {
-                            entry.deferred.css.resolve();
-                        });
-                        promises.push(entry.deferred.css.promise);
-                    }
-                }
-                else if (contentContainer.contentUrl && !ConfigReader.get('preventCodeInjection')) {
-                    // Content with inlined script and css (2.0.x agents, or guides that have not migrated to the 2.1 format yet)
-                    entry.deferred.content = q.defer();
-                    var contentNode = loadResource(addExtensionToUrl(replaceWithContentHostAndVerify(contentContainer.contentUrl), '.js'), function (err) {
-                        dom.removeNode(contentNode);
-                        if (err) {
-                            Events.resourceFetchFail.trigger(contentContainer, err);
-                            return;
-                        }
-                    }, true);
-                    promises.push(entry.deferred.content.promise);
-                }
-                else if (!fetchedDomContent) {
-                    return q.reject('fetchedDomContent is still false');
-                }
-                entry.deferred.promise = q.all(promises).then(function () {
-                    return _.omit(entry, 'deferred');
-                });
-            }
-            return cache[contentContainer.id].deferred.promise;
-        }
-        catch (e) {
-            Events.resourceFetchFail.trigger(contentContainer, e);
-            throw e;
-        }
-    }
-    // Clears the content cache. Used for testing.
-    function reset() {
-        cache = {};
-    }
-    /**
-     * JSONP-style callback for loading guide content
-     * from script resources. Step content stored in
-     * GCS is wrapped with pendo.guideContent(...)
-     *
-     * @access private
-     * @param {string} guideId
-     * @param {string} stepId
-     * @param {string} content
-     * @param {Function} templateFn
-     * @param {Function} scriptFn
-     */
-    function guideContent(guideId, stepId, content, templateFn, scriptFn) {
-        if (_.isString(content)) {
-            content = preprocessGuideContent(content, guideId, stepId);
-            if (!_.isFunction(templateFn)) {
-                if (shouldCreateTemplate(content)) {
-                    templateFn = _.template(content);
-                }
-                else {
-                    templateFn = _.constant(content);
-                }
-            }
-            var entry = cache[guideId + stepId];
-            if (entry && entry.deferred.content) {
-                entry.content = content;
-                entry.template = templateFn;
-                entry.script = scriptFn;
-                entry.deferred.content.resolve();
-            }
-        }
-    }
-    // preprocess content to remove simple guide and step IDs templating
-    function removeStandardTemplating(content, guideId, stepId) {
-        const stdTemplating = `<% if (typeof guide !== 'undefined') { %>
-var guide = pendo.findGuideById('<%= guide.id %>');
-var step = guide && guide.findStepById('<%= step.id %>');
-<% } %>`;
-        const sansTemplating = `var guide = pendo.findGuideById('${guideId}');
-var step = guide && guide.findStepById('${stepId}');`;
-        return content.replace(stdTemplating, sansTemplating);
-    }
-    // execute all content preprocessors and return end result
-    const GuideContentProcessorList = [removeStandardTemplating];
-    function preprocessGuideContent(content, guideId, stepId) {
-        return _.reduce(GuideContentProcessorList, (acc, procFn) => {
-            return procFn(acc, guideId, stepId);
-        }, content);
-    }
-    function shouldCreateTemplate(content) {
-        return /<%/.test(content) && /%>/.test(content);
-    }
-    function receiveDomStructureJson(guideId, stepId, domJson) {
-        var entry = cache[guideId + stepId];
-        if (entry && entry.deferred.domJson) {
-            entry.domJson = replaceObjectWithContentHost(domJson);
-            entry.deferred.domJson.resolve();
-        }
-    }
-    function lightningRedirect(url) {
-        if (isSfdcLightning()) {
-            // https://pendo-static-1234.storage.googleapis.com/guide-content/:guideId/:stepId/:someKindaHash.guide.js
-            var path = url.replace(/^https?:\/\/[^/]+\/guide-content\//, '').split('/');
-            var guideId = path[0];
-            /* global $A */
-            var resourcePath = $A.get('$Resource.pendoGuide' + base32Encode(toUTF8Array(guideId)));
-            if (_.isString(resourcePath)) {
-                return resourcePath + '/' + path.join('/');
-            }
-        }
-        return url;
-    }
-    function addExtensionToUrl(url, extension) {
-        if (!_.isString(url))
-            return url;
-        var i = _.indexOf(url, '?');
-        if (i < 0) {
-            return url + extension;
-        }
-        else {
-            return url.substring(0, i) + extension + url.substring(i);
-        }
-    }
-    return {
-        load,
-        reset,
-        guideContent,
-        receiveDomStructureJson
-    };
-})();
-
 var AsyncContent = (function () {
     function AsyncContent(guide) {
         var step = this;
@@ -14928,7 +15124,7 @@ var GuideRuntime = (function (agentEvents) {
     }
     function teardown() {
         EventChannel.off(handleEvent);
-        _.each(pluginAddGlobalScripts, GuideRuntime.removeGlobalScript);
+        pluginAddGlobalScripts.length = 0;
     }
     function addGlobalScript(obj) {
         obj = autoSubscribe(obj);
@@ -18391,6 +18587,10 @@ var updateVisitorOptions = function (options = {}) {
     if (!_.isObject(options)) {
         options = {};
     }
+    if (isTrackingConsentDenied()) {
+        log.warn('Ignoring identify/updateOptions metadata while identity consent is dnt.');
+        return { options: getMetadata(), hashChanged: false, storeChanged: false };
+    }
     if (options.jwt && options.signingKeyName) {
         var jwtOptions = JWT.getJwtOptions(options, 'updateOptions');
         if (jwtOptions) {
@@ -23368,7 +23568,7 @@ function autofocusRuntimeScript(step, guide, pendo) {
     if (pendo._.get(step, 'attributes.isAutoFocus')) {
         BuildingBlockGuides.autofocusStep(step, guideContainer);
         BuildingBlockGuides.trapFocusStep(step, guideContainer);
-        step.hiddenElements = BuildingBlockGuides.addAriaHiddenOutsideGuide(step.guideElement[0]);
+        step.hiddenElements = (step.hiddenElements || []).concat(BuildingBlockGuides.addAriaHiddenOutsideGuide(step.guideElement[0]));
     }
     if (isGuideRCType(guide)) {
         BuildingBlockGuides.attachRCFocusHandlers();
@@ -25003,22 +25203,31 @@ function hasLegacyGuides(guides, pendo) {
 }
 const DEFAULT_CSS_ID = '_pendo-default-css_';
 const CUSTOM_CSS_ID = '_pendo-css_';
+// Several SDK instances can share a page. Scoping the <link> ids by api key stops one app's
+// teardown, or its "no custom css" path, from stripping the stylesheet another app injected.
+function getCssElementId(baseId) {
+    return pendo$1.apiKey ? baseId + pendo$1.apiKey : baseId;
+}
+// Api keys are arbitrary customer-supplied strings, so '#' + id is not a safe selector.
+function removeGuideCss(baseId) {
+    dom(document.getElementById(getCssElementId(baseId))).remove();
+}
 function loadGuideCss() {
     var promises = [];
     if (!shouldLoadGlobalCSS()) {
         return q.resolve();
     }
     if (hasLegacyGuides(getActiveGuides(), pendo$1)) {
-        promises.push(loadExternalCss(DEFAULT_CSS_ID, getDefaultCssUrl()));
+        promises.push(loadExternalCss(getCssElementId(DEFAULT_CSS_ID), getDefaultCssUrl()));
     }
     var guideWidget = pendo$1.guideWidget || {};
     var data = guideWidget.data || {};
     var customCssUrl = data.guideCssUrl;
     if (customCssUrl) {
-        promises.push(loadExternalCss(CUSTOM_CSS_ID, replaceWithContentHost(customCssUrl)));
+        promises.push(loadExternalCss(getCssElementId(CUSTOM_CSS_ID), replaceWithContentHost(customCssUrl)));
     }
     else {
-        dom('#' + CUSTOM_CSS_ID).remove();
+        removeGuideCss(CUSTOM_CSS_ID);
     }
     return promises;
 }
@@ -25030,9 +25239,15 @@ var processGuideEventCache = function (options) {
 var getGuideEventCache = function () {
     return guideEvtCache;
 };
+function filterGuideAnalyticsByType(event, next) {
+    if (!hasConsentForGuideEvent(event.type)) {
+        return;
+    }
+    next(event);
+}
 function createGuideEventQueue(options) {
     const processSilos = pipeline(filterAnalyticsDisabled, splitSiloOnFieldChange('visitor_id'), splitSiloOnFieldChange('props.source'), filterAccountIdsForSendQueue, compressSilo, errorLogger(), addSiloParams(options), addAccountIdParamIfAdoptPartner, addSourceParamIfPresent, convertSiloToObject);
-    const packageSilos = pipeline(filterBrokenTimestamps, fireEventCaptured, eventSequence, siloReducer(options.cache), _.noop // do not move to the silo queue until manual flush
+    const packageSilos = pipeline(filterBrokenTimestamps, filterGuideAnalyticsByType, fireEventCaptured, eventSequence, siloReducer(options.cache), _.noop // do not move to the silo queue until manual flush
     );
     return new EventQueue(_.extend({ processSilos, packageSilos }, options));
 }
@@ -25137,6 +25352,12 @@ var initGuides = function (observer) {
         const { guideIds } = event.data[0];
         pruneBadges(guideIds);
     });
+    Events['consent:changed'].on(function (event) {
+        var { guides } = event.data[0];
+        if (_.isUndefined(guides))
+            return;
+        guides ? enableGuides() : disableGuides();
+    });
     teardownFns.push(onTurbolinksPageLoad(document, function onPageLoad() {
         if (pendoDotUrl.get() === reloadGuides.lastUrl) {
             // Force a reload if Turbolinks replaces the document body without changing the url
@@ -25223,8 +25444,8 @@ var initGuides = function (observer) {
         _.each(teardownFns, function (teardownFn) {
             teardownFn();
         });
-        dom('#' + DEFAULT_CSS_ID).remove();
-        dom('#' + CUSTOM_CSS_ID).remove();
+        removeGuideCss(DEFAULT_CSS_ID);
+        removeGuideCss(CUSTOM_CSS_ID);
         GuideRuntime.teardown();
     };
 };
@@ -25257,6 +25478,14 @@ var setGuidesDisabled = function (areDisabled) {
     originalOptions.disableGuides = areDisabled;
     ConfigReader.setLocalConfig(originalOptions);
 };
+function enableGuides() {
+    setGuidesDisabled(false);
+    forceGuideReload();
+}
+function disableGuides() {
+    setGuidesDisabled(true);
+    resetPendoUI();
+}
 var setGuidesDelayed = function (areDelayed) {
     var originalOptions = ConfigReader.getLocalConfig();
     delete originalOptions.delayGuides;
@@ -25686,6 +25915,8 @@ _.extend(TopFrameRelay.prototype, {
         if (!message.data)
             return;
         if (message.data.action === 'pendo::connect') {
+            if (!isSameWindowTree(message, this._window))
+                return;
             this._impl.frameConnect(message);
         }
         if (message.data.action === REMOVE_FRAME_ACTION) {
@@ -25781,6 +26012,38 @@ var ImplCommon = {
 function isPortValid(port) {
     return port && _.all(['addEventListener', 'start'], function (cmd) { return _.isFunction(port[cmd]); });
 }
+// A connect is only ever posted to window.top by a frame below us, so a sender we
+// cannot find in our own frame tree is not one of our frames no matter what it
+// claims. window.open gives an attacker a handle to post through, and neither
+// X-Frame-Options nor frame-ancestors covers that - they only govern embedding
+// (APP-168708). frames and its indexed children are readable across origins, so
+// this holds where an origin check can't: no ancestorOrigins needed, and sandboxed
+// frames (origin "null") are still found.
+function isFrameBelowUs(source, window) {
+    if (!source)
+        return false;
+    if (source === window)
+        return true;
+    var pending = [window];
+    while (pending.length) {
+        var children = pending.shift().frames;
+        var count = children ? children.length : 0;
+        for (var i = 0; i < count; i++) {
+            if (children[i] === source)
+                return true;
+            pending.push(children[i]);
+        }
+    }
+    return false;
+}
+function isSameWindowTree(message, window) {
+    try {
+        return isFrameBelowUs(message.source, window);
+    }
+    catch (e) {
+        return false;
+    }
+}
 function MessageChannelImpl(window, singletonMessageHandler) {
     this._window = window;
     this._ports = {};
@@ -27017,11 +27280,24 @@ const Keys = (function () {
 })();
 
 const pendoLocalStorage = agentStorage.getLocal();
+const pendoSessionStorage$1 = agentStorage.getSession();
+const DESIGNER_LAUNCH_RECEIPT = 'pendo-designer-launch-receipt';
 var DesignerV2 = (function () {
     // Always use the production server for CNAME customers
     var host = DESIGNER_SERVER || SERVER;
     var bucket = 'in-app-designer';
     var target = 'latest';
+    /**
+     * The designerId of a designer session launched from this tab. Read back after a
+     * page reload to tell a relaunch of that session apart from a URL token planted
+     * by another origin.
+     *
+     * @name pendo-designer-launch-receipt
+     * @category Cookies/sessionStorage
+     * @access public
+     * @label DESIGNER_LAUNCH_RECEIPT
+     */
+    agentStorage.registry.addSession(DESIGNER_LAUNCH_RECEIPT);
     Events.leaderChanged.on(function () {
         // check to make sure that we aren't trying to launch nav mode from a designer frame
         var inDesignerOrPreview = /pendo-/.test(window.name) || isInDesignerPreviewMode();
@@ -27146,13 +27422,20 @@ var DesignerV2 = (function () {
             return false;
         }
     }
+    function writeLaunchReceipt(designerId) {
+        if (!designerId)
+            return;
+        pendoSessionStorage$1.setItem(DESIGNER_LAUNCH_RECEIPT, designerId);
+    }
+    function hasLaunchReceipt(designerId) {
+        if (!designerId)
+            return false;
+        return pendoSessionStorage$1.getItem(DESIGNER_LAUNCH_RECEIPT) === designerId;
+    }
     function launchOnToken(url) {
         if (isDesignerFrame(window.name)) {
             return;
         }
-        if (isPendoDomain(window.location.origin) && !hasSameOriginOpener()) {
-            return;
-        }
         var tokenParamTest = /pendo-designer=([A-Za-z0-9-]+)/;
         if (!tokenParamTest.test(url))
             return;
@@ -27160,6 +27443,9 @@ var DesignerV2 = (function () {
         if (!tokenMatch)
             return;
         var parsedToken = parsePendoToken(tokenMatch[1]);
+        if (isPendoDomain(window.location.origin) && !hasSameOriginOpener() && !hasLaunchReceipt(parsedToken.designerId)) {
+            return;
+        }
         var validAssetHost = getValidDesignerHost(parsedToken);
         var validTarget = getValidTarget(parsedToken);
         // clear stored designer state if we're launching from a token
@@ -27211,6 +27497,7 @@ var DesignerV2 = (function () {
         if (!options) {
             options = {};
         }
+        writeLaunchReceipt(options.designerId);
         var validAssetHost = getValidDesignerHost(options);
         var validBucket = getValidGCSBucket(options);
         var validTarget = getValidTarget(options);
@@ -28960,7 +29247,10 @@ const PluginAPI = {
     agentStorage,
     analytics: {
         ptm: () => eventQueue,
-        collectEvent
+        collectEvent,
+        hasConsentForAnalyticsEvent,
+        getTextCollectionMode,
+        isReplayConsentDenied
     },
     attachEvent,
     attachEventInternal,
@@ -29163,14 +29453,27 @@ function initIdentityEvents() {
             }
         }
     };
+    const requestReidentification = function () {
+        if (!isTrackingConsentDenied() && isVisitorDNT()) {
+            Events.identifyRequested.trigger();
+        }
+    };
+    const handleConsentChange = function (event) {
+        var { identity } = event.data[0];
+        if (_.isUndefined(identity))
+            return;
+        identity ? requestReidentification() : clearSession({ doNotTrack: true });
+    };
     Events.identify.on(collectIdentifyEvent);
     Events.metadata.on(collectMetadataEvent);
     Events.identify.on(handleIdentifyEvent);
+    Events['consent:changed'].on(handleConsentChange);
     initialized = true;
     return function () {
         Events.identify.off(collectIdentifyEvent);
         Events.metadata.off(collectMetadataEvent);
         Events.identify.off(handleIdentifyEvent);
+        Events['consent:changed'].off(handleConsentChange);
         initialized = false;
     };
 }
@@ -29524,7 +29827,7 @@ function registerEventHandlers({ events = [] }) {
 function applyDoNotTrackConfigOverrides(options) {
     options.excludeNonGuideAnalytics = true;
     options.disableCookies = true;
-    options.visitor = { id: '__cookieless_visitor__' };
+    options.visitor = { id: COOKIELESS_VISITOR_ID };
     delete options.account;
     delete options.parentAccount;
 }
@@ -30901,6 +31204,28 @@ 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
  */
@@ -31973,6 +32298,7 @@ function exportPublicApi(pendo) {
     // cache.js
     pendo.flushNow = exportPendoCoreOnly(flushNow);
     pendo.teardown = makeSafe(teardown);
+    pendo.updateCookieConsent = makeSafe(updateCookieConsent);
     // guides.js
     pendo.initGuides = exportPendoCoreOnly(initGuides);
     pendo.loadGuides = exportPendoCoreOnly(loadGuides);
@@ -34512,12 +34838,15 @@ var FramesModule = (function () {
         receiveLastGuideStepSeen(context, payload) {
             if (payload.frameId === context.state.frameId)
                 return;
-            // The extension and native installs will never have the same visitor id
+            // The extension and native installs will never have the same visitor id,
+            // and neither will frames from different applications (apiKeys).
             // However, all frames need to keep an accurate record of what has been viewed, to ensure
-            // that native frames do not attempt to re-display extension guides, and vice versa
+            // that one agent's frames do not attempt to re-display another agent's guides
             var originatingFrame = context.state.frames[payload.frameId];
             var originatingInstallType = _.get(originatingFrame, 'agentInstallType');
-            if (originatingInstallType && originatingInstallType !== context.state.agentInstallType) {
+            var originatingApiKey = _.get(originatingFrame, 'apiKey');
+            if ((originatingInstallType && originatingInstallType !== context.state.agentInstallType) ||
+                (originatingApiKey && originatingApiKey !== pendo$1.apiKey)) {
                 delete payload.lastGuideStepSeen.visitorId;
             }
             context.dispatch('guideState/updateLastGuideStepSeen', payload.lastGuideStepSeen, { root: true });
@@ -42313,9 +42642,11 @@ function TextCapture() {
     }
     function isEnabled() {
         // this preserves the ability for a user to disable text collection after initialization
-        return !pendoGlobal.excludeAllText;
+        return !pendoGlobal.excludeAllText && pluginAPI.analytics.getTextCollectionMode() === 'all';
     }
     function isTextCapturable(text) {
+        if (pluginAPI.analytics.getTextCollectionMode() === 'none')
+            return false;
         var trimmedText = pluginAPI.util.trim.call(text);
         // pass the text as an array so that our toPath override doesn't try to split it on `.`
         return isEnabled() || pendoGlobal._.has(whitelist, [trimmedText]) || pendoGlobal._.has(whitelist, [text]);
@@ -42852,6 +43183,124 @@ 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 = {
@@ -42861,6 +43310,7 @@ const RequiredQuestions = {
         let requiredPollIds = [];
         let submitButtons = (_a = guideMarkdownUtil.lookupGuideButtons(step.domJson)) === null || _a === void 0 ? void 0 : _a.filter(button => button.actions.find(action => action.action === 'submitPoll' || action.action === 'submitPollAndGoToStep'));
         const requiredQuestions = processRequiredQuestions();
+        let autoAdvance = createInertController();
         if (requiredQuestions) {
             pendo._.forEach(requiredQuestions, (question) => {
                 if (question.classList.contains('_pendo-open-text-poll-question')) {
@@ -42876,6 +43326,17 @@ const 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._)) {
+            this.on('beforeUnmount', () => autoAdvance.cancel());
+            try {
+                autoAdvance = createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds);
+            }
+            catch (error) {
+                pendo.log('[auto-advance] arming failed, leaving the step on manual submit', error && error.message);
+            }
+        }
         function getEligibleQuestions() {
             const pollQuestions = pendo._.toArray(step.guideElement.find(`[class*=-poll-question]:contains(${requiredSyntax})`));
             const surveyMatches = pendo._.toArray(step.guideElement.find(`[data-pendo-poll-id]:contains(${requiredSyntax})`));
@@ -42952,9 +43413,11 @@ const RequiredQuestions = {
             }
             if (allRequiredComplete) {
                 enableEligibleButtons(submitButtons);
+                autoAdvance.notifyAnswered();
             }
             else {
                 disableEligibleButtons(submitButtons);
+                autoAdvance.cancel();
             }
         }
         function disableEligibleButtons(buttons) {
@@ -51405,7 +51868,8 @@ class SessionRecorder {
             this.api.attachEvent(this.api.Events, 'eventCaptured', bind(this.addRecordingId, this)),
             this.api.attachEvent(this.api.Events, 'transmit:locked', bind(this.stop, this)),
             this.api.attachEvent(this.api.Events, 'transmit:unlocked', bind(this._start, this)),
-            this.api.attachEvent(this.api.Events, 'tabIdChanged:self', bind(this.handleTabIdChange, this))
+            this.api.attachEvent(this.api.Events, 'tabIdChanged:self', bind(this.handleTabIdChange, this)),
+            this.api.attachEvent(this.api.Events, 'consent:changed', bind(this.handleConsentChange, this))
         ];
         // APP-153357 Zone.js could bypass filterCrossWindowMessages (don't use attachEvent)
         const channel = this.api.frames.getChannel();
@@ -51516,6 +51980,20 @@ class SessionRecorder {
             return this.checkVisitorEligibility();
         }
     }
+    handleConsentChange(event) {
+        var { identity, replay } = event.data[0];
+        if (this.pendo._.isUndefined(identity) && this.pendo._.isUndefined(replay))
+            return;
+        if (this.api.analytics.isReplayConsentDenied()) {
+            if (this.isRecording()) {
+                this.logStopReason('CONSENT_DENIED');
+                this.stop();
+            }
+        }
+        else if (!this.isRecording()) {
+            this.start();
+        }
+    }
     checkVisitorEligibility(continuationCallback) {
         if (!this.isRecording() && this.pendo._.isNull(this.visitorId) && this.pendo._.isNull(this.accountId))
             return;
@@ -51598,6 +52076,8 @@ class SessionRecorder {
      * pendo.recording.start()
      */
     start() {
+        if (this.api.analytics.isReplayConsentDenied())
+            return;
         this._restartPtm = this.api.analytics.ptm().pause();
         this.allowStart = true;
         this.visitorId = this.pendo.get_visitor_id();
@@ -51655,6 +52135,11 @@ class SessionRecorder {
         });
     }
     _startRecordingForVisitor(visitorConfig) {
+        if (this.api.analytics.isReplayConsentDenied()) {
+            this.restartPtm();
+            this.logStopReason('CONSENT_DENIED');
+            return;
+        }
         this.api.Events.trigger('recording:unpaused');
         this.transport.start(this.config);
         const disableFallback = this.pendo._.get(this.config, 'disableFallback', true);
@@ -56009,6 +56494,8 @@ class PredictApiService {
 
 const PREDICT_STEP_REGEX = /\$\$predict\$\$/;
 const DRAG_THRESHOLD = 5;
+const FLOATING_MODAL_OFFSET = '20px';
+const DEFAULT_INITIAL_POSITION = 'TOP_RIGHT';
 const STYLE_ID = 'pendo-predict-plugin-styles';
 const GUIDE_BUTTON_IDENTIFIER = 'button:contains("token")';
 const pluginVersion = '1.0.1';
@@ -56070,7 +56557,7 @@ const injectStyles = (pendoContainerId, log = () => { }) => {
                 }
                 .frame-explanation {
                 aspect-ratio: 16/9; overflow: hidden; min-height: 300px;
-                width: 100vw; height: 100vh; background: transparent;
+                width: 554px; height: 100vh; background: transparent;
                 position: fixed; bottom: 0; right: 0; z-index: 1; border: none;
                 visibility: hidden; opacity: 0; pointer-events: none;
                 transition: opacity 0.1s ease-out, visibility 0s linear 0.1s;
@@ -56228,7 +56715,9 @@ const setupDragAndDrop = (handle, container, frameTargetOrigin) => {
         initialLeft = rect.left;
         initialTop = rect.top;
         container.style.left = `${initialLeft}px`;
+        container.style.top = `${initialTop}px`;
         container.style.right = 'auto';
+        container.style.bottom = 'auto';
         startX = e.clientX;
         startY = e.clientY;
         document.addEventListener('mousemove', onMouseMove);
@@ -56301,6 +56790,19 @@ const createExplanationIframe = ({ analysisId, recordId, configuration, predictB
         src: buildFrameSrc(`${base}?${params}`, wrapperBase)
     }, document.body);
 };
+// The floating modal defaults to the top-right corner (see injected styles).
+// `initialPosition` overrides that by anchoring the container to the requested
+// corner; the drag logic later switches to explicit left/top on first drag.
+const applyInitialPosition = (container, initialPosition = DEFAULT_INITIAL_POSITION) => {
+    var _a;
+    const corners = {
+        TOP_LEFT: { top: FLOATING_MODAL_OFFSET, left: FLOATING_MODAL_OFFSET, bottom: 'auto', right: 'auto' },
+        TOP_RIGHT: { top: FLOATING_MODAL_OFFSET, right: FLOATING_MODAL_OFFSET, bottom: 'auto', left: 'auto' },
+        BOTTOM_LEFT: { bottom: FLOATING_MODAL_OFFSET, left: FLOATING_MODAL_OFFSET, top: 'auto', right: 'auto' },
+        BOTTOM_RIGHT: { bottom: FLOATING_MODAL_OFFSET, right: FLOATING_MODAL_OFFSET, top: 'auto', left: 'auto' }
+    };
+    Object.assign(container.style, (_a = corners[initialPosition]) !== null && _a !== void 0 ? _a : corners[DEFAULT_INITIAL_POSITION]);
+};
 // ----- Floating Modal Creation -----
 const createFloatingModal = ({ recordId, configuration, predictBaseUrl, wrapperBase = '' }) => {
     var _a, _b;
@@ -56315,6 +56817,7 @@ const createFloatingModal = ({ recordId, configuration, predictBaseUrl, wrapperB
         });
     }
     const container = createElement('div', { id: 'floatingModalContainer', className: 'floating-modal-container' }, document.body);
+    applyInitialPosition(container, configuration.initialPosition);
     const dragHandle = createElement('div', {
         className: 'floating-modal-drag-handle',
         innerHTML: `<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
@@ -56455,7 +56958,7 @@ const fetchWidgetConfiguration = (_a) => __awaiter(void 0, void 0, void 0, funct
     if (!widgetSettings) {
         return inlineConfiguration;
     }
-    return Object.assign(Object.assign({}, inlineConfiguration), { analysisIds: mapAnalysisIds(widgetSettings.analysesHierarchy), recordRegexPattern: widgetSettings.recordRegexPattern, recordRegexName: widgetSettings.recordRegexKeyword });
+    return Object.assign(Object.assign({}, inlineConfiguration), { analysisIds: mapAnalysisIds(widgetSettings.analysesHierarchy), recordRegexPattern: widgetSettings.recordRegexPattern, recordRegexName: widgetSettings.recordRegexKeyword, initialPosition: widgetSettings.initialPosition });
 });
 const predictGuidesScript = ({ step, pendo, cleanupArray, cleanup, log, designerServer }) => __awaiter(void 0, void 0, void 0, function* () {
     var _c;