@pendo/agent 2.342.0 → 2.343.1

package/dist/pendo.module.js

@@ -4058,8 +4058,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.342.0_';
-let PACKAGE_VERSION = '2.342.0';
+let VERSION = '2.343.1_';
+let PACKAGE_VERSION = '2.343.1';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -4476,15 +4476,35 @@ class LogEmitter extends EventTarget {
 }
 const log = new LogEmitter();
 
-/** Key used to lookup the consent collection policy in the pendo configuration. */
 const CONSENT_COLLECTION = 'cookieConsentCollection';
-/** Key used to lookup the analytics events in the consent collection policy. */
 const ANALYTICS = 'analytics';
-/** Key used to lookup the guide analytics events in the consent collection policy. */
 const GUIDE_ANALYTICS = 'guideAnalytics';
-/** Key used to lookup the text collection mode in the consent collection policy. */
 const TEXT_COLLECTION = 'textCollection';
 const TEXT_COLLECTION_LEVELS = ['none', 'whitelist', 'all'];
+const ANALYTICS_EVENT_TYPES = {
+    agentResponse: 'agent_response',
+    clicks: 'click',
+    fieldChanges: 'change',
+    focus: 'focus',
+    formSubmits: 'submit',
+    identify: 'identify',
+    meta: 'meta',
+    pageLoads: 'load',
+    prompt: 'prompt',
+    trackEvents: 'track',
+    userReaction: 'user_reaction'
+};
+const GUIDE_EVENT_TYPES = [
+    'guideActivity',
+    'guideAdvanced',
+    'guideDismissed',
+    'guideNotSeen',
+    'guideSeen',
+    'guideSnoozeCanceled',
+    'guideSnoozed',
+    'guideTimeout',
+    'pollResponse'
+];
 let enabledProducts = null;
 function getClassification() {
     return ConfigReader.get(CONSENT_COLLECTION) || {};
@@ -4504,30 +4524,59 @@ function warnOnUnconfiguredTiers(grantedTiers, classification) {
 function moreTextPermissive(a, b) {
     return TEXT_COLLECTION_LEVELS.indexOf(b) > TEXT_COLLECTION_LEVELS.indexOf(a) ? b : a;
 }
-function orBoolean(a, b) {
-    return a || Boolean(b);
+function toTextCollectionLevel(mode) {
+    return _.contains(TEXT_COLLECTION_LEVELS, mode) ? mode : TEXT_COLLECTION_LEVELS[0];
 }
-function unionArrays(a, b) {
-    return _.union(a, b);
+function toAnalyticsEventTypes(eventCollection) {
+    return _.reduce(ANALYTICS_EVENT_TYPES, function (types, eventType, key) {
+        if (eventCollection[key] === true) {
+            types.push(eventType);
+        }
+        return types;
+    }, []);
+}
+function normalizeTier(tier) {
+    const { visitorIdentity = {}, analytics = {}, guides = {}, sessionReplay = {} } = tier || {};
+    const eventCollection = analytics.eventCollection || {};
+    const analyticsEnabled = analytics.enabled === true;
+    return {
+        identity: visitorIdentity.trackVisitors === true,
+        guides: guides.enabled === true,
+        replay: sessionReplay.enabled === true,
+        analytics: analyticsEnabled ? toAnalyticsEventTypes(eventCollection) : [],
+        guideAnalytics: analyticsEnabled && eventCollection.guideServing === true ? GUIDE_EVENT_TYPES.slice() : [],
+        textCollection: analyticsEnabled ? toTextCollectionLevel(eventCollection.textCollectionMode) : TEXT_COLLECTION_LEVELS[0]
+    };
+}
+function deniedProducts() {
+    return {
+        identity: false,
+        guides: false,
+        replay: false,
+        [ANALYTICS]: [],
+        [GUIDE_ANALYTICS]: [],
+        [TEXT_COLLECTION]: TEXT_COLLECTION_LEVELS[0]
+    };
+}
+function combineTiers(resolved, granted) {
+    return {
+        identity: resolved.identity || granted.identity,
+        guides: resolved.guides || granted.guides,
+        replay: resolved.replay || granted.replay,
+        [ANALYTICS]: _.union(resolved[ANALYTICS], granted[ANALYTICS]),
+        [GUIDE_ANALYTICS]: _.union(resolved[GUIDE_ANALYTICS], granted[GUIDE_ANALYTICS]),
+        [TEXT_COLLECTION]: moreTextPermissive(resolved[TEXT_COLLECTION], granted[TEXT_COLLECTION])
+    };
 }
-// How a granted tier's value for a product combines with what's been resolved so far.
-// `initial` doubles as what an ungranted tier contributes -- an unlisted product falls
-// back to DEFAULT_RESOLVER, the plain "any granted tier turns it on" boolean rule.
-const RESOLVERS = {
-    [TEXT_COLLECTION]: { initial: TEXT_COLLECTION_LEVELS[0], combine: moreTextPermissive },
-    [ANALYTICS]: { initial: [], combine: unionArrays },
-    [GUIDE_ANALYTICS]: { initial: [], combine: unionArrays }
-};
-const DEFAULT_RESOLVER = { initial: false, combine: orBoolean };
 /**
- * Resolves the granted tiers against the configured product classification.
+ * Resolves the tiers a visitor consented to into what each product is allowed to do.
+ *
+ * Every product starts denied and only granted tiers contribute, so a tier the visitor
+ * hasn't opted into has no say -- it can't deny anything, and it can't allow anything.
  *
- * A 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.
+ * A subscription with no cookie consent configured resolves to an empty map instead, which
+ * every read below treats as unconstrained: consent that was never set up can't deny
+ * anything either.
  *
  * @access private
  * @param {string | string[]} tiers tier or tiers the visitor consented to
@@ -4536,26 +4585,22 @@ const DEFAULT_RESOLVER = { initial: false, combine: orBoolean };
 function applyConsentTiers(tiers) {
     const cookieConsentCollection = getClassification();
     const consentedCookieTiers = toTierList(tiers);
-    const resolved = {};
     warnOnUnconfiguredTiers(consentedCookieTiers, cookieConsentCollection);
-    _.each(cookieConsentCollection, function (products, tier) {
-        var isGranted = _.contains(consentedCookieTiers, tier);
-        _.each(products, function (level, product) {
-            var resolver = RESOLVERS[product] || DEFAULT_RESOLVER;
-            var current = _.has(resolved, product) ? resolved[product] : resolver.initial;
-            var contributed = isGranted ? level : resolver.initial;
-            resolved[product] = resolver.combine(current, contributed);
-        });
-    });
-    enabledProducts = resolved;
+    if (_.isEmpty(cookieConsentCollection)) {
+        enabledProducts = {};
+        return getEnabledProducts();
+    }
+    enabledProducts = _.reduce(consentedCookieTiers, function (resolved, tier) {
+        const granted = cookieConsentCollection[tier];
+        return granted ? combineTiers(resolved, normalizeTier(granted)) : resolved;
+    }, deniedProducts());
     return getEnabledProducts();
 }
 function getEnabledProducts() {
     return enabledProducts ? _.extend({}, enabledProducts) : null;
 }
 /**
- * A product is enabled unless a tier has explicitly resolved it to false -- with no cookie
- * consent configured at all, or a product no tier ever mentions, there's nothing to deny.
+ * A product is enabled only if some granted tier turned it on or cookie consent has not been set.
  *
  * @access private
  * @param {string} product
@@ -4569,6 +4614,9 @@ function isProductEnabled(product) {
 function isTrackingConsentDenied() {
     return !isProductEnabled('identity');
 }
+function isGuideConsentDenied() {
+    return !isProductEnabled('guides');
+}
 /**
  * Session replay is denied whenever tracking itself is denied (DNT) -- a visitor
  * who can't be identified shouldn't have their session recorded either -- or when a
@@ -4604,6 +4652,9 @@ function hasConsentForAnalyticsEvent(type) {
 function hasConsentForGuideEvent(type) {
     return hasConsentForProduct(type, GUIDE_ANALYTICS);
 }
+function resetConsentPolicy() {
+    enabledProducts = null;
+}
 
 const allowKeys = function () {
     var allowKeys = ConfigReader.get('storage.allowKeys') || '*';
@@ -22161,14 +22212,29 @@ function ClickActivation() {
         }
         stopEvent(evt);
     };
+    // Safari does not focus the badge on mousedown, so focus leaves the app instead.
+    // Apps that re-render on blur can remove the badge before mouseup, and the browser
+    // then generates no click at all. Holding focus where it is avoids that (APP-168412)
+    var preserveFocus = function (evt) {
+        if (evt.preventDefault) {
+            evt.preventDefault();
+        }
+        else {
+            evt.returnValue = false;
+        }
+    };
     badge.after('show', function () {
         if (!attached) {
             attachEvent(badgeElem, 'click', click);
+            if (badge.preserveFocusOnClick) {
+                attachEvent(badgeElem, 'mousedown', preserveFocus);
+            }
             attached = true;
         }
     });
     badge.after('hide', function () {
         detachEvent(badgeElem, 'click', click);
+        detachEvent(badgeElem, 'mousedown', preserveFocus);
         attached = false;
     });
     return badge;
@@ -22639,7 +22705,7 @@ function stepShowingProc(guide, step) {
         return;
     }
     const embedSelector = _.get(guide, 'attributes.embedConfig.selector');
-    if (embedSelector && !dom(embedSelector).length) {
+    if (embedSelector && (!dom(embedSelector).length || (guideElement && !isInDocument(guideElement[0])))) {
         step.hide();
         return;
     }
@@ -25383,6 +25449,9 @@ var initGuides = function (observer) {
             return;
         guides ? enableGuides() : disableGuides();
     });
+    if (isGuideConsentDenied()) {
+        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
@@ -26044,10 +26113,14 @@ function isPortValid(port) {
 // (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.
+//
+// frames skips iframes whose element lives in a shadow root, so a web-component
+// modal's frame never turns up in the walk. top is also readable across origins
+// and can't be spoofed by a popup, so it covers those frames (APP-171528).
 function isFrameBelowUs(source, window) {
     if (!source)
         return false;
-    if (source === window)
+    if (source === window || source.top === window)
         return true;
     var pending = [window];
     while (pending.length) {
@@ -29325,6 +29398,7 @@ const PluginAPI = {
     q,
     SendQueue,
     sessionStorage: agentStorage.getSession(),
+    storageIsDisabled,
     sizeElements,
     store,
     Tombstone,
@@ -29503,6 +29577,34 @@ function initIdentityEvents() {
     };
 }
 
+/**
+ * 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;
+}
+function initializeCookieConsent(tiers) {
+    resetConsentPolicy();
+    if (tiers) {
+        updateCookieConsent(tiers);
+    }
+}
+
 /*
 * ResourceCenterActivity Event
 *
@@ -29986,6 +30088,8 @@ function initialize(options) {
         }
         // Save the options somewhere
         ConfigReader.setLocalConfig(options);
+        const cookieConsentTiers = _.get(options, 'cookieConsentTiers');
+        initializeCookieConsent(cookieConsentTiers);
         initDataHost();
         exportDataHost(pendo$1);
         const cookieDomain = ConfigReader.get('cookieDomain');
@@ -31232,28 +31336,6 @@ logPublic.setActiveContexts = setActiveContexts;
 logPublic.showLogHistory = showLogHistory;
 logPublic.getLoggedContexts = getLoggedContexts;
 
-/**
- * Enforces the cookie consent policy a visitor has agreed to. The policy is defined by the subscription's cookie consent configuration,
- * and is used to determine whether each product the web SDK may run.
- *
- * @access public
- * @category Core
- * @param {string | string[]} tiers tier or tiers the visitor consented to
- * @returns {object} map of product to its resolved value -- `guides` and `identity` are
- *   booleans (identity disabled means DNT), `textCollection` is `none`/`whitelist`/`all`,
- *   `analytics` and `guideAnalytics` are each an array of allowed event types
- * @example
- * pendo.updateCookieConsent('strictlyNecessary');
- * @example
- * pendo.updateCookieConsent(['strictlyNecessary', 'functional']);
- */
-function updateCookieConsent(tiers) {
-    const enabledProducts = applyConsentTiers(tiers);
-    Events['consent:changed'].trigger(enabledProducts);
-    log.debug('Cookie consent updated for ' + JSON.stringify(tiers) + '.');
-    return enabledProducts;
-}
-
 /**
  * Shared helper for event collection
  */
@@ -42735,6 +42817,310 @@ var guideMarkdownUtil = {
     removeMarkdownSyntax
 };
 
+const AUTO_ADVANCE_DELAY_MS = 250;
+function isAutoAdvanceRequested(step, _) {
+    return _.get(step, 'attributes.autoAdvance') === true;
+}
+// Survey-authored DOM carries no question-type classes, so eligibility keys off
+// answer-control shape: every required poll id must be radio-backed, which also
+// refuses a future non-radio type by default.
+function isStepEligibleInDom(step, _, requiredPollIds) {
+    const guideElement = step && step.guideElement;
+    if (!guideElement)
+        return false;
+    if (guideElement.find('textarea, input:text, input:checkbox, select').length)
+        return false;
+    const pollIds = _.uniq(_.map(guideElement.find('[data-pendo-poll-id]'), (element) => element.getAttribute('data-pendo-poll-id')));
+    if (!pollIds.length)
+        return false;
+    return _.all(pollIds, (pollId) => _.contains(requiredPollIds, pollId) &&
+        guideElement.find(`input:radio[data-pendo-poll-id="${pollId}"]`).length > 0);
+}
+function hideSubmitButtons(step, _, submitButtons) {
+    const hiddenButtons = [];
+    _.each(submitButtons, (button) => {
+        const element = step.guideElement.find(`#${button.props.id}`)[0];
+        if (!element)
+            return;
+        // display, not visibility: a reserved-but-invisible box leaves an empty gap
+        // at the foot of the step. Authored styles reach the button inline
+        // (build.js:151), so the original value is kept rather than blanked.
+        hiddenButtons.push({ element, display: element.style.display });
+        element.style.display = 'none';
+    });
+    return function restoreSubmitButtons() {
+        _.each(hiddenButtons, (hiddenButton) => {
+            hiddenButton.element.style.display = hiddenButton.display;
+        });
+    };
+}
+// The container's pixel height is measured during render (layout.js) before custom
+// scripts run, so collapsing a row afterwards leaves the box stale and the step keeps
+// the empty space. Same reflow pair metadata-substitution uses, scoped to this step so
+// a second guide on screen is left alone.
+function reflowGuide(step, _, pendo) {
+    const recalculateGuideHeight = _.get(pendo, 'BuildingBlocks.BuildingBlockGuides.recalculateGuideHeight');
+    try {
+        if (_.isFunction(pendo.flexElement)) {
+            pendo.flexElement(step.guideElement.find(guideMarkdownUtil.containerSelector));
+        }
+        if (_.isFunction(recalculateGuideHeight)) {
+            recalculateGuideHeight(`pendo-g-${step.id}`, step.guideElement);
+        }
+    }
+    catch (error) {
+        pendo.log('[auto-advance] guide reflow failed, the step may keep an empty row', error && error.message);
+    }
+}
+function createInertController() {
+    return { isActive: false, notifyAnswered() { }, cancel() { } };
+}
+function createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds) {
+    const _ = pendo._;
+    const inert = createInertController();
+    if (!isAutoAdvanceRequested(step, _))
+        return inert;
+    // Only reachable for API-authored guides; choosing between two
+    // submitPollAndGoToStep targets would be a guess.
+    if (_.size(submitButtons) !== 1) {
+        pendo.log(`[auto-advance] not arming: step ${step.id} needs exactly one submit button, found ${_.size(submitButtons)}`);
+        return inert;
+    }
+    if (!isStepEligibleInDom(step, _, requiredPollIds)) {
+        pendo.log(`[auto-advance] not arming: rendered step ${step.id} failed the eligibility re-check`);
+        return inert;
+    }
+    const submitButton = submitButtons[0];
+    // A click binds every action on the node and dispatches one event each
+    // (build.js:205-207); we dispatch one, so a second action would be dropped.
+    if (_.size(submitButton.actions) !== 1) {
+        pendo.log(`[auto-advance] not arming: step ${step.id} submit button carries ${_.size(submitButton.actions)} actions, expected one`);
+        return inert;
+    }
+    const submitAction = _.find(submitButton.actions, (action) => action.action === 'submitPoll' || action.action === 'submitPollAndGoToStep');
+    if (!submitAction)
+        return inert;
+    let hasFired = false;
+    let restoreSubmitButtons = _.noop;
+    function fire() {
+        if (hasFired)
+            return;
+        hasFired = true;
+        try {
+            // Shape-identical to what bindActionToNode emits for a click, so
+            // beforeAdvance consumers intercept an auto-advance the same way.
+            step.eventRouter.eventable.trigger('pendoEvent', {
+                action: submitAction.action,
+                params: submitAction.parameters,
+                step,
+                ignore: !!submitAction.ignore,
+                srcElement: step.guideElement.find(`#${submitButton.props.id}`)[0]
+            });
+        }
+        catch (error) {
+            restoreSubmitButtons();
+            reflowGuide(step, _, pendo);
+            pendo.log('[auto-advance] submit dispatch failed, restored the submit button', error && error.message);
+        }
+    }
+    const debouncedFire = _.debounce(fire, AUTO_ADVANCE_DELAY_MS);
+    // Last, so nothing between here and the return can throw and leave the step
+    // with a hidden button and no controller to un-hide it.
+    restoreSubmitButtons = hideSubmitButtons(step, _, submitButtons);
+    reflowGuide(step, _, pendo);
+    return {
+        isActive: true,
+        notifyAnswered: debouncedFire,
+        cancel: debouncedFire.cancel
+    };
+}
+
+const SURVEY_ANSWERS_KEY = 'pendo_survey_answers';
+const ANSWER_CONTROLS = 'input:radio, input:text, textarea, select';
+const TEXT_CONTROLS = 'input:text, textarea';
+// Matches MULTISTEP_CONTINUATION_TIME_LIMIT (walkthrough-guide.js:67), past which a guide is not continued.
+const ANSWER_TTL_MS = 12 * 60 * 60 * 1000;
+let pluginApi = null;
+let inMemoryAnswers = {};
+let persistedAnswersDropped = false;
+// A restricted storage.allowKeys silently rejects the session write, so mirror the visit here.
+const visitedSteps = {};
+function setPluginApi(api) {
+    pluginApi = api;
+    if (!api || !api.agentStorage)
+        return;
+    /**
+     * Answers the visitor has given on each step of a survey, so a step re-shown
+     * after Previous comes back filled in rather than blank.
+     *
+     * @name pendo_survey_answers
+     * @category Cookies/sessionStorage
+     * @access public
+     * @label SURVEY_ANSWERS_KEY
+     */
+    api.agentStorage.registry.addSession(SURVEY_ANSWERS_KEY);
+}
+// getSession() checks the allow-list but not storageIsDisabled, which the cookie path applies.
+function persistenceAllowed() {
+    const allowed = !!pluginApi &&
+        !!pluginApi.sessionStorage &&
+        typeof pluginApi.storageIsDisabled === 'function' &&
+        !pluginApi.storageIsDisabled();
+    if (allowed) {
+        persistedAnswersDropped = false;
+    }
+    else {
+        dropPersistedAnswers();
+    }
+    return allowed;
+}
+// agentStorage.clearAll only walks local keys, so a session key has to be dropped here.
+function dropPersistedAnswers() {
+    if (persistedAnswersDropped || !pluginApi || !pluginApi.sessionStorage)
+        return;
+    persistedAnswersDropped = true;
+    pluginApi.sessionStorage.removeItem(SURVEY_ANSWERS_KEY);
+}
+function readAll() {
+    if (!persistenceAllowed())
+        return inMemoryAnswers;
+    try {
+        return JSON.parse(pluginApi.sessionStorage.getItem(SURVEY_ANSWERS_KEY)) || {};
+    }
+    catch (error) {
+        return {};
+    }
+}
+function writeAll(answers) {
+    if (!persistenceAllowed()) {
+        inMemoryAnswers = answers;
+        return;
+    }
+    pluginApi.sessionStorage.setItem(SURVEY_ANSWERS_KEY, JSON.stringify(answers));
+}
+// identify() sets the new id before the reload tears the step down, so resolve this once per render.
+function visitorKey(pendo) {
+    return (pendo._.isFunction(pendo.get_visitor_id) && pendo.get_visitor_id()) || 'unknown';
+}
+function stateKey(step, guide, visitor) {
+    return `${visitor}:${guide.id}:${step.id}`;
+}
+// Host pages reassign Date.now to return a Date, which JSON writes out as a string.
+function getNow() {
+    return new Date().getTime();
+}
+function isFresh(writtenAt) {
+    return !!writtenAt && (getNow() - writtenAt) <= ANSWER_TTL_MS;
+}
+function readRecord(step, guide, visitor) {
+    const forVisitor = readAll()[visitor];
+    const forGuide = forVisitor && forVisitor[guide.id];
+    const record = (forGuide && forGuide[step.id]) || null;
+    return isFresh(record && record.at) ? record : null;
+}
+function updateRecord(step, guide, visitor, changes) {
+    const all = readAll();
+    const current = readRecord(step, guide, visitor) || {};
+    if (!all[visitor])
+        all[visitor] = {};
+    if (!all[visitor][guide.id])
+        all[visitor][guide.id] = {};
+    all[visitor][guide.id][step.id] = {
+        at: getNow(),
+        visited: changes.visited || current.visited || 0,
+        answers: changes.answers || current.answers || {}
+    };
+    writeAll(all);
+}
+// Previous only renders after an auto-advance step, so any other guide needs none of this.
+function guideAutoAdvances(guide, _) {
+    return _.any(_.get(guide, 'steps', []), (step) => isAutoAdvanceRequested(step, _));
+}
+function pollIdFor(control) {
+    let node = control;
+    while (node && node.getAttribute) {
+        const pollId = node.getAttribute('data-pendo-poll-id');
+        if (pollId)
+            return pollId;
+        node = node.parentNode;
+    }
+    return null;
+}
+// submitPoll never reads a checkbox back (event-router.js:264), so restoring one shows nothing sent.
+function isRadio(control) {
+    return control.type === 'radio';
+}
+function collectAnswers(step, pendo) {
+    const answers = {};
+    pendo._.each(step.guideElement.find(ANSWER_CONTROLS), (control) => {
+        const pollId = pollIdFor(control);
+        // One value per poll id, first in document order, as submitPoll reads it.
+        if (!pollId || answers[pollId])
+            return;
+        if (isRadio(control) && !control.checked)
+            return;
+        if (!control.value)
+            return;
+        answers[pollId] = [control.value];
+    });
+    return answers;
+}
+// No event dispatched: a restored answer must not reach the gate listeners or re-arm auto-advance.
+function restoreAnswers(step, pendo, answers) {
+    pendo._.each(step.guideElement.find(ANSWER_CONTROLS), (control) => {
+        const pollId = pollIdFor(control);
+        const values = pollId && answers[pollId];
+        if (!values)
+            return;
+        if (isRadio(control)) {
+            if (pendo._.contains(values, control.value))
+                control.checked = true;
+            return;
+        }
+        control.value = values[0];
+    });
+}
+function isRevisit(step, guide, pendo) {
+    if (!guideAutoAdvances(guide, pendo._))
+        return false;
+    const visitor = visitorKey(pendo);
+    if (isFresh(visitedSteps[stateKey(step, guide, visitor)]))
+        return true;
+    const record = readRecord(step, guide, visitor);
+    return !!record && (!!record.visited || !pendo._.isEmpty(record.answers));
+}
+const AnswerCache = {
+    name: 'AnswerCache',
+    script(step, guide, pendo) {
+        const visitor = visitorKey(pendo);
+        const record = readRecord(step, guide, visitor);
+        restoreAnswers(step, pendo, (record && record.answers) || {});
+        // Marked on leaving, not on render: sessionStorage survives a reload, which is not a revisit.
+        this.on('beforeUnmount', (event) => {
+            if (event && event.reason === 'hidden')
+                return;
+            visitedSteps[stateKey(step, guide, visitor)] = getNow();
+            updateRecord(step, guide, visitor, { visited: 1 });
+        });
+        const stepRoot = step.guideElement[0];
+        // change does not bubble on legacy browsers; it is here only for keyboard selection.
+        step.attachEvent(stepRoot, 'click', capture);
+        step.attachEvent(stepRoot, 'change', capture);
+        pendo._.each(step.guideElement.find(TEXT_CONTROLS), (control) => {
+            step.attachEvent(control, 'input', capture);
+        });
+        function capture() {
+            updateRecord(step, guide, visitor, { answers: collectAnswers(step, pendo) });
+        }
+    },
+    test(step, guide, pendo) {
+        const guideElement = step && step.guideElement;
+        return !!guideElement &&
+            guideAutoAdvances(guide, pendo._) &&
+            guideElement.find(ANSWER_CONTROLS).length > 0;
+    }
+};
+
 function getZoneSafeMethod(_, method, target = window) {
     var zoneSymbol = '__symbol__';
     /* global Zone */
@@ -43211,124 +43597,6 @@ function substitutionIcon(color, size) {
                 13.7239 15.5 14V17Z" fill="${color}"></path> </g></svg></div>`);
 }
 
-const AUTO_ADVANCE_DELAY_MS = 250;
-function isAutoAdvanceRequested(step, _) {
-    return _.get(step, 'attributes.autoAdvance') === true;
-}
-// Survey-authored DOM carries no question-type classes, so eligibility keys off
-// answer-control shape: every required poll id must be radio-backed, which also
-// refuses a future non-radio type by default.
-function isStepEligibleInDom(step, _, requiredPollIds) {
-    const guideElement = step && step.guideElement;
-    if (!guideElement)
-        return false;
-    if (guideElement.find('textarea, input:text, input:checkbox, select').length)
-        return false;
-    const pollIds = _.uniq(_.map(guideElement.find('[data-pendo-poll-id]'), (element) => element.getAttribute('data-pendo-poll-id')));
-    if (!pollIds.length)
-        return false;
-    return _.all(pollIds, (pollId) => _.contains(requiredPollIds, pollId) &&
-        guideElement.find(`input:radio[data-pendo-poll-id="${pollId}"]`).length > 0);
-}
-function hideSubmitButtons(step, _, submitButtons) {
-    const hiddenButtons = [];
-    _.each(submitButtons, (button) => {
-        const element = step.guideElement.find(`#${button.props.id}`)[0];
-        if (!element)
-            return;
-        // display, not visibility: a reserved-but-invisible box leaves an empty gap
-        // at the foot of the step. Authored styles reach the button inline
-        // (build.js:151), so the original value is kept rather than blanked.
-        hiddenButtons.push({ element, display: element.style.display });
-        element.style.display = 'none';
-    });
-    return function restoreSubmitButtons() {
-        _.each(hiddenButtons, (hiddenButton) => {
-            hiddenButton.element.style.display = hiddenButton.display;
-        });
-    };
-}
-// The container's pixel height is measured during render (layout.js) before custom
-// scripts run, so collapsing a row afterwards leaves the box stale and the step keeps
-// the empty space. Same reflow pair metadata-substitution uses, scoped to this step so
-// a second guide on screen is left alone.
-function reflowGuide(step, _, pendo) {
-    const recalculateGuideHeight = _.get(pendo, 'BuildingBlocks.BuildingBlockGuides.recalculateGuideHeight');
-    try {
-        if (_.isFunction(pendo.flexElement)) {
-            pendo.flexElement(step.guideElement.find(guideMarkdownUtil.containerSelector));
-        }
-        if (_.isFunction(recalculateGuideHeight)) {
-            recalculateGuideHeight(`pendo-g-${step.id}`, step.guideElement);
-        }
-    }
-    catch (error) {
-        pendo.log('[auto-advance] guide reflow failed, the step may keep an empty row', error && error.message);
-    }
-}
-function createInertController() {
-    return { isActive: false, notifyAnswered() { }, cancel() { } };
-}
-function createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds) {
-    const _ = pendo._;
-    const inert = createInertController();
-    if (!isAutoAdvanceRequested(step, _))
-        return inert;
-    // Only reachable for API-authored guides; choosing between two
-    // submitPollAndGoToStep targets would be a guess.
-    if (_.size(submitButtons) !== 1) {
-        pendo.log(`[auto-advance] not arming: step ${step.id} needs exactly one submit button, found ${_.size(submitButtons)}`);
-        return inert;
-    }
-    if (!isStepEligibleInDom(step, _, requiredPollIds)) {
-        pendo.log(`[auto-advance] not arming: rendered step ${step.id} failed the eligibility re-check`);
-        return inert;
-    }
-    const submitButton = submitButtons[0];
-    // A click binds every action on the node and dispatches one event each
-    // (build.js:205-207); we dispatch one, so a second action would be dropped.
-    if (_.size(submitButton.actions) !== 1) {
-        pendo.log(`[auto-advance] not arming: step ${step.id} submit button carries ${_.size(submitButton.actions)} actions, expected one`);
-        return inert;
-    }
-    const submitAction = _.find(submitButton.actions, (action) => action.action === 'submitPoll' || action.action === 'submitPollAndGoToStep');
-    if (!submitAction)
-        return inert;
-    let hasFired = false;
-    let restoreSubmitButtons = _.noop;
-    function fire() {
-        if (hasFired)
-            return;
-        hasFired = true;
-        try {
-            // Shape-identical to what bindActionToNode emits for a click, so
-            // beforeAdvance consumers intercept an auto-advance the same way.
-            step.eventRouter.eventable.trigger('pendoEvent', {
-                action: submitAction.action,
-                params: submitAction.parameters,
-                step,
-                ignore: !!submitAction.ignore,
-                srcElement: step.guideElement.find(`#${submitButton.props.id}`)[0]
-            });
-        }
-        catch (error) {
-            restoreSubmitButtons();
-            reflowGuide(step, _, pendo);
-            pendo.log('[auto-advance] submit dispatch failed, restored the submit button', error && error.message);
-        }
-    }
-    const debouncedFire = _.debounce(fire, AUTO_ADVANCE_DELAY_MS);
-    // Last, so nothing between here and the return can throw and leave the step
-    // with a hidden button and no controller to un-hide it.
-    restoreSubmitButtons = hideSubmitButtons(step, _, submitButtons);
-    reflowGuide(step, _, pendo);
-    return {
-        isActive: true,
-        notifyAnswered: debouncedFire,
-        cancel: debouncedFire.cancel
-    };
-}
-
 const requiredElement = '<span class="_pendo-required-indicator" style="color:red; font-style:italic;" title="Question is required"> *</span>';
 const requiredSyntax = '{required/}';
 const RequiredQuestions = {
@@ -43354,9 +43622,14 @@ const RequiredQuestions = {
                 }
             });
         }
+        // Restored answers reach no listener, and the controller is still inert here.
+        const revisited = isRevisit(step, guide, pendo);
+        if (revisited) {
+            evaluateRequiredQuestions(requiredQuestions);
+        }
         // Armed last, after the listeners above: runCustomScripts abandons the rest of
         // this script on a throw, and the submit button is already disabled by now.
-        if (isAutoAdvanceRequested(step, pendo._)) {
+        if (isAutoAdvanceRequested(step, pendo._) && !revisited) {
             this.on('beforeUnmount', () => autoAdvance.cancel());
             try {
                 autoAdvance = createAutoAdvanceController(step, pendo, submitButtons, requiredPollIds);
@@ -43707,7 +43980,9 @@ function GuideMarkdown() {
         const markdownScriptsEnabled = configReader.get(GUIDEMARKDOWN_CONFIG);
         if (!markdownScriptsEnabled)
             return;
-        guideMarkdown = [PollBranching, MetadataSubstitution, RequiredQuestions, SkipToEligibleStep];
+        setPluginApi(PluginAPI);
+        // AnswerCache first: it restores the answers RequiredQuestions reads the gate against.
+        guideMarkdown = [AnswerCache, PollBranching, MetadataSubstitution, RequiredQuestions, SkipToEligibleStep];
         if (!pendo.designer) {
             pendo._.each(guideMarkdown, function (script) {
                 PluginAPI.GlobalRuntime.addGlobalScript(script);
@@ -51498,11 +51773,13 @@ class Transport {
     }
 }
 
-const CATCHALL_TYPES = ['load', 'click', 'track'];
+const CATCHALL_TYPES = ['load', 'click', 'track', 'guideSeen'];
+const AGENTIC_TYPES = ["prompt", "agent_response", "user_reaction"];
 const EVENT_KINDS = {
-    catchall: 'catchall',
-    devlog: 'devlog',
-    recording: 'recording'
+    AGENTIC: 'agentic',
+    CATCHALL: 'catchall',
+    DEVLOG: 'devlog',
+    RECORDING: 'recording'
 };
 class LiveReplayClient {
     constructor(pendo, api) {
@@ -51583,18 +51860,21 @@ class LiveReplayClient {
         catch (_a) { }
     }
     sendRecordingEvent(fields) {
-        this.send(Object.assign(Object.assign({}, fields), { kind: EVENT_KINDS.recording, sequence: this.sequence++ }));
+        this.send(Object.assign(Object.assign({}, fields), { kind: EVENT_KINDS.RECORDING, sequence: this.sequence++ }));
     }
     forwardEvent(event) {
         if (!event || !event.data || !event.data.length)
             return;
         const capturedEvent = event.data[0];
         const config = { event: capturedEvent };
+        if (this.pendo._.contains(AGENTIC_TYPES, capturedEvent.type)) {
+            config.kind = EVENT_KINDS.AGENTIC;
+        }
         if (this.pendo._.contains(CATCHALL_TYPES, capturedEvent.type)) {
-            config.kind = EVENT_KINDS.catchall;
+            config.kind = EVENT_KINDS.CATCHALL;
         }
-        if (capturedEvent.type === EVENT_KINDS.devlog) {
-            config.kind = EVENT_KINDS.devlog;
+        if (capturedEvent.type === EVENT_KINDS.DEVLOG) {
+            config.kind = EVENT_KINDS.DEVLOG;
         }
         if (!config.kind)
             return;
@@ -52181,7 +52461,6 @@ class SessionRecorder {
             var bind = this.pendo._.bind;
             this.visitorConfig = visitorConfig;
             this.clearOldSessionId();
-            this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId);
             this.sendQueue.start();
             this.interval = setInterval(() => {
                 if (!this.sendQueue.failed()) {
@@ -52194,6 +52473,7 @@ class SessionRecorder {
                 errorHandler: this.errorHandler
             }, config));
             this._refreshIds();
+            this.liveReplayClient.onLiveFlag(visitorConfig.live, this.visitorId, () => this.snapshot());
             this.onRecordingStart();
         }
         catch (e) {