@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/utils/native_globals.js

@@ -0,0 +1,129 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+
+__webpack_require__.add({
+68034(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+let _og = null;
+function og() {
+    if (!_og) {
+        var _ref;
+        var _window_qualified_sentinel_getOriginals, _window_qualified_sentinel, _window_qualified;
+        const result = (_ref = (_window_qualified = window.qualified) == null ? void 0 : (_window_qualified_sentinel = _window_qualified.sentinel) == null ? void 0 : (_window_qualified_sentinel_getOriginals = _window_qualified_sentinel.getOriginals) == null ? void 0 : _window_qualified_sentinel_getOriginals.call(_window_qualified_sentinel)) != null ? _ref : null;
+        if (result) _og = result;
+        return result;
+    }
+    return _og;
+}
+// Timers — ProvidePlugin rewrites free `setTimeout` / `setInterval` / etc.
+// references in the widget bundle to these exports, bypassing sentinel's patches.
+// Uses .call(window, ...) to forward the correct `this` context.
+const nativeSetTimeout = function nativeSetTimeout(cb, delay) {
+    for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+        args[_key - 2] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.setTimeout) != null ? _ref : globalThis.setTimeout;
+    return fn.call(window, cb, delay, ...args);
+};
+const nativeClearTimeout = (id)=>{
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.clearTimeout) != null ? _ref : globalThis.clearTimeout;
+    fn.call(window, id);
+};
+const nativeSetInterval = function nativeSetInterval(cb, delay) {
+    for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+        args[_key - 2] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.setInterval) != null ? _ref : globalThis.setInterval;
+    return fn.call(window, cb, delay, ...args);
+};
+const nativeClearInterval = (id)=>{
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.clearInterval) != null ? _ref : globalThis.clearInterval;
+    fn.call(window, id);
+};
+const nativeRequestAnimationFrame = (cb)=>{
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.requestAnimationFrame) != null ? _ref : globalThis.requestAnimationFrame;
+    return fn.call(window, cb);
+};
+const nativeCancelAnimationFrame = (id)=>{
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.cancelAnimationFrame) != null ? _ref : globalThis.cancelAnimationFrame;
+    fn.call(window, id);
+};
+// Event listeners — the build-time loader rewrites `window.addEventListener(` →
+// `__nativeWindowAddEventListener(` etc., and ProvidePlugin maps those identifiers here.
+function __nativeWindowAddEventListener() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.windowAddEventListener) != null ? _ref : window.addEventListener;
+    fn.call(window, ...args);
+}
+function __nativeDocumentAddEventListener() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.documentAddEventListener) != null ? _ref : document.addEventListener;
+    fn.call(document, ...args);
+}
+function __nativeWindowRemoveEventListener() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.windowRemoveEventListener) != null ? _ref : window.removeEventListener;
+    fn.call(window, ...args);
+}
+function __nativeDocumentRemoveEventListener() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    var _ref;
+    var _og;
+    const fn = (_ref = (_og = og()) == null ? void 0 : _og.documentRemoveEventListener) != null ? _ref : document.removeEventListener;
+    fn.call(document, ...args);
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  LA: () => (__nativeDocumentRemoveEventListener),
+  Qj: () => (__nativeDocumentAddEventListener),
+  kZ: () => (__nativeWindowRemoveEventListener),
+  zh: () => (__nativeWindowAddEventListener)
+}, {
+  Kj: nativeClearTimeout,
+  LK: nativeSetInterval,
+  gj: nativeRequestAnimationFrame,
+  pP: nativeCancelAnimationFrame,
+  pS: nativeSetTimeout,
+  wm: nativeClearInterval
+});
+
+
+},
+});
+const native_globals = __webpack_require__("68034");
+var Qj = native_globals.Qj;
+var LA = native_globals.LA;
+var zh = native_globals.zh;
+var kZ = native_globals.kZ;
+var pP = native_globals.pP;
+var wm = native_globals.wm;
+var Kj = native_globals.Kj;
+var gj = native_globals.gj;
+var LK = native_globals.LK;
+var pS = native_globals.pS;
+
+export { Kj as nativeClearTimeout, LA as __nativeDocumentRemoveEventListener, LK as nativeSetInterval, Qj as __nativeDocumentAddEventListener, gj as nativeRequestAnimationFrame, kZ as __nativeWindowRemoveEventListener, pP as nativeCancelAnimationFrame, pS as nativeSetTimeout, wm as nativeClearInterval, zh as __nativeWindowAddEventListener };

package/widget/v1_adapter.js

@@ -0,0 +1,50 @@
+/**
+ * V1Adapter wraps IframeManager, delegating every ExperienceAdapter method
+ * and property directly to it with zero additional logic. This preserves
+ * existing V1 behaviour exactly while allowing tracker.ts, api_handler.ts,
+ * and widget.ts to depend on the ExperienceAdapter interface rather than
+ * IframeManager directly.
+ */ class V1Adapter {
+    dispose() {}
+    showLightboxLoading() {
+        this.iframeManager.showLightboxLoading();
+    }
+    showMessengerLoading() {
+        this.iframeManager.showMessengerLoading();
+    }
+    showInlineLoading(uuid) {
+        this.iframeManager.showInlineLoading(uuid);
+    }
+    closeLightbox() {
+        this.iframeManager.closeLightbox();
+    }
+    openMessenger() {
+        this.iframeManager.openMessenger();
+    }
+    setChatIsVisible(visible) {
+        this.iframeManager.setChatIsVisible(visible);
+    }
+    addMessengerEventsListener(handler) {
+        this.iframeManager.addMessengerEventsListener(handler);
+    }
+    get apMessagesCount() {
+        return this.iframeManager.apMessagesCount;
+    }
+    get autoRespondPounceCount() {
+        return this.iframeManager.autoRespondPounceCount;
+    }
+    get visitorResponded() {
+        return this.iframeManager.visitorResponded;
+    }
+    get userResponded() {
+        return this.iframeManager.userResponded;
+    }
+    get originalDocumentTitle() {
+        return this.iframeManager.originalDocumentTitle;
+    }
+    constructor(iframeManager){
+        this.iframeManager = iframeManager;
+    }
+}
+
+export { V1Adapter };

package/widget/v2_adapter.js

@@ -0,0 +1,368 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { DisplayMode as types_DisplayMode } from "./multimodal_v2/types.js";
+import "./utils/native_globals.js";
+
+/* provided dependency */ var v2_adapter_setInterval = __webpack_require__(68034).LK;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var v2_adapter_clearInterval = __webpack_require__(68034).wm;
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+// The import is type-only to avoid circular dependencies; the runtime methods
+// are added on RootStore in the multimodal_v2 store layer.
+
+/**
+ * V2Adapter implements ExperienceAdapter for the multimodal_v2 / shadow DOM
+ * presentation layer. It delegates loading-state changes to RootStore signals.
+ *
+ * RootStore is NOT passed to the constructor — it is bound after construction
+ * via bindRootStore(). This is necessary because the adapter is created during
+ * Widget.init() but the RootStore only exists once multimodal_v2 has loaded.
+ * All loading methods no-op until bindRootStore() is called.
+ *
+ * LinkedWidgetV2 creates a V2Adapter and calls bindRootStore() after
+ * multimodal_v2 finishes loading.
+ */ class V2Adapter {
+    /**
+   * Bind the RootStore after it has been created by multimodal_v2.
+   * Call this once, immediately after the RootStore becomes available.
+   * After this call, all loading/visibility methods become active.
+   */ bindRootStore(rootStore) {
+        if (this.rootStore) {
+            this.rootStore.messengerEventListener = null;
+        }
+        this.teardownSubscriptions();
+        this.rootStore = rootStore;
+        this.rootStore.messengerEventListener = (name)=>this.broadcastMessengerEvent(name);
+        if (this.messengerEventsListeners.length > 0 && !this.displayModeDisposer) {
+            this.startMessengerEventSubscriptions();
+        }
+        // Wire messages subscription for pounce counter tracking, title flash and
+        // the meeting lifecycle messenger events.
+        let titleFlashBaselined = false;
+        // The first callback fires synchronously with the timeline as it already
+        // stands, so it is a baseline, never new activity.
+        let meetingEventsBaselined = false;
+        this.messagesDisposer = this.rootStore.messages.subscribe((messages)=>{
+            this.trackMeetingEvents(messages, {
+                isBaselineTick: !meetingEventsBaselined
+            });
+            meetingEventsBaselined = true;
+            // Count AP (assistant auto-pounce) messages
+            const apMessages = messages.filter((m)=>m.type === "text" && !m.isOwn && "isAp" in m && m.isAp);
+            if (apMessages.length > this._lastApMessageCount) {
+                this._lastApMessageCount = apMessages.length;
+                const wasZero = this._apMessagesCount === 0;
+                this._apMessagesCount = apMessages.length;
+                if (wasZero && this._apMessagesCount > 0) {
+                    this.onFirstApMessage == null ? void 0 : this.onFirstApMessage.call(this);
+                }
+            }
+            // Track visitor responses (any own text message)
+            const visitorMessages = messages.filter((m)=>m.type === "text" && m.isOwn);
+            if (visitorMessages.length > this._lastVisitorMessageCount) {
+                this._lastVisitorMessageCount = visitorMessages.length;
+                this._visitorResponded = true;
+            }
+            // Track rep responses (non-own, non-AP text messages with a userId)
+            const repMessages = messages.filter((m)=>m.type === "text" && !m.isOwn && "userId" in m && !!m.userId && !("isAp" in m && m.isAp));
+            if (repMessages.length > this._lastRepMessageCount) {
+                this._lastRepMessageCount = repMessages.length;
+                this._userResponded = true;
+            }
+            // Title flash: new rep message while tab is backgrounded or widget minimized.
+            // Only flash for human rep messages (has userId, not auto-pounce).
+            // We must baseline the count after initialization so that messages
+            // restored from the server on page load don't trigger a spurious flash.
+            const repTextMessages = messages.filter((m)=>m.type === "text" && !m.isOwn && "userId" in m && !!m.userId && !("isAp" in m && m.isAp));
+            const currentRepCount = repTextMessages.length;
+            if (!titleFlashBaselined) {
+                var _this_rootStore;
+                this._lastNonOwnTextCount = currentRepCount;
+                if ((_this_rootStore = this.rootStore) == null ? void 0 : _this_rootStore.initialized.peek()) {
+                    titleFlashBaselined = true;
+                }
+            } else {
+                var _this__lastNonOwnTextCount;
+                var _this_rootStore1;
+                const isNewRepMessage = currentRepCount > ((_this__lastNonOwnTextCount = this._lastNonOwnTextCount) != null ? _this__lastNonOwnTextCount : 0);
+                this._lastNonOwnTextCount = currentRepCount;
+                if (isNewRepMessage && !((_this_rootStore1 = this.rootStore) == null ? void 0 : _this_rootStore1.disableTitleFlash.peek())) {
+                    var _ref;
+                    var _this_rootStore2;
+                    const isMinimized = (_ref = (_this_rootStore2 = this.rootStore) == null ? void 0 : _this_rootStore2.displayMode.minimized.peek()) != null ? _ref : true;
+                    if (!document.hasFocus() || isMinimized) {
+                        var _ref1;
+                        var _this_rootStore3, _this_rootStore4;
+                        const companyName = (_ref1 = (_this_rootStore3 = this.rootStore) == null ? void 0 : _this_rootStore3.companyName.peek()) != null ? _ref1 : "Qualified";
+                        const title = ((_this_rootStore4 = this.rootStore) == null ? void 0 : _this_rootStore4.translationStore.t("titleFlash.messageFrom", {
+                            companyName
+                        })) || "Message from " + companyName;
+                        this.setTitle(title);
+                    }
+                }
+            }
+        });
+        if (this.pendingRootStoreActions.length > 0) {
+            this.pendingRootStoreActions.forEach((action)=>action());
+            this.pendingRootStoreActions = [];
+        }
+    }
+    // ---- ExperienceAdapter methods ----
+    dispose() {
+        this.teardownSubscriptions();
+        this.resetTitle();
+        if (this.rootStore) {
+            this.rootStore.messengerEventListener = null;
+        }
+        this.rootStore = null;
+        this.pendingRootStoreActions = [];
+    }
+    showLightboxLoading() {
+        this.withRootStore((rootStore)=>rootStore.showLightboxLoading());
+    }
+    showMessengerLoading() {
+        this.withRootStore((rootStore)=>rootStore.showMessengerLoading());
+    }
+    showInlineLoading(uuid) {
+        this.withRootStore((rootStore)=>rootStore.showInlineLoading(uuid));
+    }
+    closeLightbox() {
+        this.withRootStore((rootStore)=>rootStore.closeLightbox());
+    }
+    openMessenger() {
+        this.withRootStore((rootStore)=>rootStore.setOpenedDisplayMode());
+    }
+    setChatIsVisible(visible) {
+        this.withRootStore((rootStore)=>{
+            if (visible) {
+                rootStore.setOpenedDisplayMode();
+            } else {
+                rootStore.closeWidget();
+            }
+        });
+    }
+    addMessengerEventsListener(handler) {
+        this.messengerEventsListeners.push(handler);
+        if (this.rootStore && !this.displayModeDisposer) {
+            this.startMessengerEventSubscriptions();
+        }
+    }
+    // ---- Private event handling ----
+    startDisplayModeSubscription() {
+        let isFirstCall = true;
+        this.displayModeDisposer = this.rootStore.displayMode.subscribe((mode)=>{
+            if (isFirstCall) {
+                isFirstCall = false;
+                this.previousDisplayMode = mode;
+                return;
+            }
+            this.handleDisplayModeChange(mode);
+        });
+    }
+    startCallInProgressSubscription() {
+        let isFirstCall = true;
+        this.callInProgressDisposer = this.rootStore.callInProgress.subscribe((inCall)=>{
+            if (isFirstCall) {
+                isFirstCall = false;
+                return;
+            }
+            this.broadcastMessengerEvent(inCall ? "callStarted" : "callEnded");
+        });
+    }
+    startCallStoreSubscription() {
+        this.callStoreDisposer = this.rootStore.callStore.subscribe((callStore)=>{
+            this.teardownCallStoreObservers();
+            if (!callStore) return;
+            let isFirstMicMutedCall = true;
+            this.micMutedDisposer = callStore.deviceStore.isMicMuted.subscribe((isMicMuted)=>{
+                if (isFirstMicMutedCall) {
+                    isFirstMicMutedCall = false;
+                    return;
+                }
+                this.broadcastMessengerEvent(isMicMuted ? "micMuted" : "micUnmuted");
+            });
+        });
+    }
+    startMessengerEventSubscriptions() {
+        this.startDisplayModeSubscription();
+        this.startCallInProgressSubscription();
+        this.startCallStoreSubscription();
+    }
+    /**
+   * Emit the meeting lifecycle events off the message timeline, which is the
+   * durable record of what actually happened in the conversation.
+   *
+   * An offer is a `calendar_event_offer` message; a booking is the
+   * `calendar_event_pick` reply. Deriving these from UI state instead (the
+   * meeting-booker input state, or MeetingStore#booked) is lossy: booker
+   * visibility is gated on the messenger not being minimized and can toggle
+   * repeatedly for one offer, and `booked` only flips for bookings made through
+   * this session's MeetingStore instance.
+   *
+   * Dedupe is by message id, so re-renders and in-place message updates (e.g.
+   * marking the offer booked) don't re-emit. In voice mode an offer arrives with
+   * `showCalendarEventOfferUi: false` and flips to visible later; it counts at
+   * the point it becomes visible, which is when the visitor is actually offered
+   * the meeting.
+   *
+   * Ids are recorded without emitting on the baseline tick and until
+   * `initialized`: those are messages already on the timeline when we bound to
+   * the store, or restored by init-state hydration on page load — not new
+   * activity. The baseline tick matters on rebind too (a bundle reswitch binds a
+   * store that is already initialized and already has messages).
+   */ trackMeetingEvents(messages, param) {
+        let { isBaselineTick } = param;
+        var _ref;
+        var _this_rootStore;
+        const shouldEmit = !isBaselineTick && ((_ref = (_this_rootStore = this.rootStore) == null ? void 0 : _this_rootStore.initialized.peek()) != null ? _ref : false);
+        const emitForNewIds = (ids, seen, eventName)=>{
+            ids.forEach((id)=>{
+                if (seen.has(id)) return;
+                seen.add(id);
+                if (shouldEmit) this.broadcastMessengerEvent(eventName);
+            });
+        };
+        emitForNewIds(messages.filter((m)=>m.type === "calendar_event_offer" && m.showCalendarEventOfferUi !== false).map((m)=>m.id), this._seenMeetingOfferIds, "meetingOffered");
+        emitForNewIds(messages.filter((m)=>m.type === "calendar_event_pick").map((m)=>m.id), this._seenMeetingBookedIds, "meetingBooked");
+    }
+    teardownCallStoreObservers() {
+        this.micMutedDisposer == null ? void 0 : this.micMutedDisposer.call(this);
+        this.micMutedDisposer = null;
+    }
+    teardownSubscriptions() {
+        this.displayModeDisposer == null ? void 0 : this.displayModeDisposer.call(this);
+        this.displayModeDisposer = null;
+        this.callInProgressDisposer == null ? void 0 : this.callInProgressDisposer.call(this);
+        this.callInProgressDisposer = null;
+        this.callStoreDisposer == null ? void 0 : this.callStoreDisposer.call(this);
+        this.callStoreDisposer = null;
+        this.teardownCallStoreObservers();
+        this.messagesDisposer == null ? void 0 : this.messagesDisposer.call(this);
+        this.messagesDisposer = null;
+        this.previousDisplayMode = null;
+        this._seenMeetingOfferIds.clear();
+        this._seenMeetingBookedIds.clear();
+    }
+    withRootStore(action) {
+        if (this.rootStore) {
+            action(this.rootStore);
+            return;
+        }
+        this.pendingRootStoreActions.push(()=>{
+            if (this.rootStore) action(this.rootStore);
+        });
+    }
+    broadcastMessengerEvent(eventName) {
+        this.messengerEventsListeners.forEach((listener)=>{
+            try {
+                listener(eventName);
+            } catch (e) {
+                // eslint-disable-next-line no-console
+                console.error("Qualified: Error in messenger event handler", e);
+            }
+        });
+    }
+    isOpenedMode(mode) {
+        return mode === types_DisplayMode.SIDEBAR || mode === types_DisplayMode.DOCKED;
+    }
+    // ---- Read-only counters and metadata ----
+    get apMessagesCount() {
+        return this._apMessagesCount;
+    }
+    get autoRespondPounceCount() {
+        return this._autoRespondPounceCount;
+    }
+    get visitorResponded() {
+        return this._visitorResponded;
+    }
+    get userResponded() {
+        return this._userResponded;
+    }
+    get originalDocumentTitle() {
+        return this._originalDocumentTitle;
+    }
+    /** Store the current document title and start alternating flash. */ setTitle(title) {
+        if (!this._originalDocumentTitle) {
+            this._originalDocumentTitle = document.title;
+        }
+        this._flashDocumentTitle = title;
+        document.title = title;
+        if (!this._flashInterval) {
+            let tick = 0;
+            this._flashInterval = v2_adapter_setInterval(()=>{
+                if (tick++ % 2 === 0) {
+                    if (document.title === this._flashDocumentTitle) {
+                        var _this__originalDocumentTitle;
+                        document.title = (_this__originalDocumentTitle = this._originalDocumentTitle) != null ? _this__originalDocumentTitle : "";
+                    }
+                } else {
+                    var _this__flashDocumentTitle;
+                    document.title = (_this__flashDocumentTitle = this._flashDocumentTitle) != null ? _this__flashDocumentTitle : "";
+                }
+            }, 1250);
+            this._focusListener = ()=>this.resetTitle();
+            __nativeWindowAddEventListener("focus", this._focusListener);
+        }
+    }
+    /** Stop flashing and restore the original document title. */ resetTitle() {
+        if (this._flashInterval !== null) {
+            v2_adapter_clearInterval(this._flashInterval);
+            this._flashInterval = null;
+        }
+        if (this._focusListener) {
+            __nativeWindowRemoveEventListener("focus", this._focusListener);
+            this._focusListener = null;
+        }
+        if (this._flashDocumentTitle !== null && document.title === this._flashDocumentTitle) {
+            var _this__originalDocumentTitle;
+            document.title = (_this__originalDocumentTitle = this._originalDocumentTitle) != null ? _this__originalDocumentTitle : "";
+        }
+        this._originalDocumentTitle = null;
+        this._flashDocumentTitle = null;
+    }
+    constructor(onFirstApMessage){
+        this.rootStore = null;
+        this.pendingRootStoreActions = [];
+        // Messenger events listeners registered before rootStore is bound
+        this.messengerEventsListeners = [];
+        this.displayModeDisposer = null;
+        this.callInProgressDisposer = null;
+        this.callStoreDisposer = null;
+        this.micMutedDisposer = null;
+        this.messagesDisposer = null;
+        // Meeting lifecycle events are deduped per message id (see trackMeetingEvents).
+        this._seenMeetingOfferIds = new Set();
+        this._seenMeetingBookedIds = new Set();
+        this.previousDisplayMode = null;
+        // Pounce / engagement counters (owned by this adapter for V2 path)
+        this._apMessagesCount = 0;
+        this._autoRespondPounceCount = 0;
+        this._visitorResponded = false;
+        this._userResponded = false;
+        this._originalDocumentTitle = null;
+        this._flashDocumentTitle = null;
+        this._flashInterval = null;
+        this._focusListener = null;
+        // Track message counts to detect changes
+        this._lastApMessageCount = 0;
+        this._lastVisitorMessageCount = 0;
+        this._lastRepMessageCount = 0;
+        this.handleDisplayModeChange = (mode)=>{
+            const wasOpened = this.isOpenedMode(this.previousDisplayMode);
+            const isNowOpened = this.isOpenedMode(mode);
+            this.previousDisplayMode = mode;
+            if (!wasOpened && isNowOpened) {
+                this.broadcastMessengerEvent("messengerOpened");
+            } else if (wasOpened && !isNowOpened) {
+                this.broadcastMessengerEvent("messengerClosed");
+            }
+            if (isNowOpened) {
+                this.resetTitle();
+            }
+        };
+        // Track non-own text messages for title flash
+        this._lastNonOwnTextCount = undefined;
+        this.onFirstApMessage = onFirstApMessage;
+    }
+}
+
+export { V2Adapter };

package/widget/visitor/base_visitor_state.js

@@ -0,0 +1,11 @@
+/*
+ * These attributes are not longer used and should be removed from all visitor cookies.
+ * Unlike BoundedAttributeKey, this is a const array to allow runtime iteration over these keys.
+ */ const DEPRECATED_ATTRIBUTE_KEYS = [
+    "activeSessionId",
+    "promptAutoDismissed",
+    "scriptId",
+    "stateByScriptId"
+];
+
+export { DEPRECATED_ATTRIBUTE_KEYS };