@pendo/agent 2.340.0 → 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.340.0_';
-let PACKAGE_VERSION = '2.340.0';
+let VERSION = '2.341.0_';
+let PACKAGE_VERSION = '2.341.0';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -14305,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;
@@ -14391,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) {
@@ -14669,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;
@@ -15089,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);
@@ -23533,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();
@@ -25168,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;
 }
@@ -25400,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();
     };
 };
@@ -25871,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) {
@@ -25966,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 = {};
@@ -43105,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 = {
@@ -43114,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')) {
@@ -43129,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})`));
@@ -43205,9 +43413,11 @@ const RequiredQuestions = {
             }
             if (allRequiredComplete) {
                 enableEligibleButtons(submitButtons);
+                autoAdvance.notifyAnswered();
             }
             else {
                 disableEligibleButtons(submitButtons);
+                autoAdvance.cancel();
             }
         }
         function disableEligibleButtons(buttons) {