@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/root_store.js

@@ -0,0 +1,1919 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { hooks_module_x, message_initial_namespaceObject, Q, message_sent_namespaceObject, signals_core_module_d, signals_core_module_w, message_received_namespaceObject, signals_core_module_r } from "../../../js/multimodal_v2.js";
+import { playAudio } from "../../../src/audio.js";
+import { BoundedSet } from "../../../src/bounded-set.js";
+import { isDebugMode } from "../../../src/smart_website/utils.js";
+import { snakify } from "../../../src/utils.js";
+import { BookerIntentTracker } from "../../booker_intent_tracker.js";
+import { BOOKER_PATHWAY_ORIGIN, BOOKER_SURFACE } from "../../booker_outcome_tracker.js";
+import { serverLogger } from "../../server-logger.js";
+import "../../telemetry/index.js";
+import { getSentryClient } from "../../widget/sentry.js";
+import { CAN_OFFER_MEETING_BOOKER_EVENT_TYPE } from "../constants.js";
+import { createActiveConversationSignal } from "../signals/active_conversation_signal.js";
+import { createMessagesSignal, isStreamableMessage, isAssistantMessage, isEventMessage } from "../signals/messages_signal.js";
+import { $fromImport } from "../utils/signals.js";
+import { ArtifactStore } from "./artifact_store.js";
+import { getCallUiAdapter } from "./call_ui_adapter.js";
+import { DockingStore } from "./docking_store.js";
+import { TranslationStore } from "./translation_store.js";
+import { UIStore } from "./ui_store.js";
+import { BaseStore } from "./base_store.js";
+import "../../utils/native_globals.js";
+import { validateEmail } from "../../../src/validation.js.js";
+import { ConversationMode as types_ConversationMode, LoadingState as types_LoadingState, DisplayMode as types_DisplayMode, MaximizedState as types_MaximizedState, InputState as types_InputState } from "../types.js";
+import { buildCustEvChatViewPayload, buildCustEvContentImpressionPayload } from "../components/helpers/content_click_payloads.js";
+import { esm_browser_v4 } from "../../../js/4101.js";
+import { metrics } from "../../telemetry/metrics.js";
+
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+/* provided dependency */ var root_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var root_store_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+/* eslint-disable no-continue */ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// A reply slower than RESPONSE_BUDGET_MS (or none at all) counts as unavailable. Both live in the
+// leaf constants module (avoids a store import cycle), re-exported so `from "./root_store"`
+// importers still work.
+
+/**
+ * Whether an offer was authored by the AI rather than a rep, a form, or a bot
+ * script. `auto_respond` is the same marker `bookerPathwayOrigin` reads to
+ * classify an offer as `ai_agent`; both AI tool paths stamp it.
+ */ function isAiAuthoredOffer(source) {
+    return (source != null ? source : "").toLowerCase() === "auto_respond";
+}
+class RootStore extends BaseStore {
+    get allowVoiceVideoToggle() {
+        return this.uiStore.allowVoiceVideoToggle;
+    }
+    /**
+  * Get the appropriate CallUiAdapter for the current context.
+  * In debug mode, returns a debug adapter backed by DebugMultimodalScenarioStore.
+  * Otherwise, returns the real adapter backed by CallStore/DeviceStore/TavusStore.
+  */ getCallUiAdapter() {
+        return getCallUiAdapter(this);
+    }
+    // --- Backward-compat getters delegating to UIStore ---
+    get uiState() {
+        return this.uiStore.uiState;
+    }
+    get maximizedState() {
+        return this.uiStore.maximizedState;
+    }
+    get initialDisplayMode() {
+        return this.uiStore.initialDisplayMode;
+    }
+    get openedDisplayMode() {
+        return this.uiStore.openedDisplayMode;
+    }
+    get launcherImageUrl() {
+        return this.uiStore.launcherImageUrl;
+    }
+    get orbConfig() {
+        return this.uiStore.orbConfig;
+    }
+    get previewVideoConfig() {
+        return this.uiStore.previewVideoConfig;
+    }
+    get demoFeatures() {
+        return this.uiStore.demoFeatures;
+    }
+    get layout() {
+        return this.uiStore.layout;
+    }
+    get piperConversationId() {
+        var _ref;
+        const conversation = this.activeConversation.value;
+        return (_ref = conversation == null ? void 0 : conversation.encodedId) != null ? _ref : "";
+    }
+    get featureFlags() {
+        var _ref;
+        var _this_config;
+        return (_ref = (_this_config = this.config) == null ? void 0 : _this_config.featureFlags) != null ? _ref : {};
+    }
+    /**
+  * Server-side email validation shared by chat and meeting flows.
+  * Fail-open: network / API errors treat the email as valid.
+  */ async validateEmail(email, source) {
+        if (source === void 0) source = "Chat";
+        try {
+            const url = this.visitor.resourceUrl("validate_email", {});
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json; charset=utf-8"
+                },
+                body: JSON.stringify({
+                    email,
+                    source
+                })
+            });
+            if (response.ok) {
+                const json = await response.json();
+                return json.valid !== false;
+            }
+            return true;
+        } catch (error) {
+            var _getSentryClient;
+            (_getSentryClient = getSentryClient({
+                project: "multimodal"
+            })) == null ? void 0 : _getSentryClient.captureException(error);
+            return true;
+        }
+    }
+    get displayMode() {
+        return this.uiStore.displayMode;
+    }
+    get conversationMode() {
+        return this.uiStore.conversationMode;
+    }
+    get input() {
+        return this.uiStore.input;
+    }
+    get artifact() {
+        return this.artifactStore.current;
+    }
+    /** Messages whose artifact is on its way into the overlay. See ArtifactStore#pending. */ get pendingArtifacts() {
+        return this.artifactStore.pending;
+    }
+    get userHasIgnoredMultimodal() {
+        return this.uiStore.userHasIgnoredMultimodal;
+    }
+    get isPiP() {
+        return this.uiStore.isPiP;
+    }
+    dispose() {
+        var _this_pounceTrackingStore_value, _this_callStore_value, _this_waitingStore_value, _this_websiteNavigationStore_value, _this_presentationsStore_value, _this_decksStore_value, _this_screenShareStore_value;
+        // Unsubscribe WS message handlers from the (persistent) channel so a rebuilt
+        // store doesn't run alongside this disposed one when the multimodal UI is
+        // torn down and later recreated on the same channel.
+        for (const [event, handler] of Object.entries(this.messageHandlers)){
+            this.channel.off(event, handler);
+        }
+        this.dockingStore.disable();
+        // Armed trackers hold window/document listeners; the multimodal rebuild path
+        // replaces this store in-page, so an undisposed tracker would outlive it and
+        // emit a false abandonment alongside its replacement.
+        this.bookerIntentTracker.dispose();
+        (_this_pounceTrackingStore_value = this.pounceTrackingStore.value) == null ? void 0 : _this_pounceTrackingStore_value.dispose();
+        (_this_callStore_value = this.callStore.value) == null ? void 0 : _this_callStore_value.dispose();
+        (_this_waitingStore_value = this.waitingStore.value) == null ? void 0 : _this_waitingStore_value.dispose();
+        (_this_websiteNavigationStore_value = this.websiteNavigationStore.value) == null ? void 0 : _this_websiteNavigationStore_value.dispose();
+        (_this_presentationsStore_value = this.presentationsStore.value) == null ? void 0 : _this_presentationsStore_value.dispose();
+        (_this_decksStore_value = this.decksStore.value) == null ? void 0 : _this_decksStore_value.dispose();
+        (_this_screenShareStore_value = this.screenShareStore.value) == null ? void 0 : _this_screenShareStore_value.dispose();
+        this.clearResponseTimeout();
+        this.flushHeldTimeout();
+        this.turnToken++;
+        if (typeof document !== "undefined") {
+            __nativeDocumentRemoveEventListener("visibilitychange", this.handleTurnVisibilityChange);
+        }
+    }
+    startTextTurn(messageClientId) {
+        // Before any per-turn state resets: the held metric belongs to the turn that
+        // just timed out and reads `turnCause` when it fires.
+        this.flushHeldTimeout();
+        this.lastVisitorMessageSentAt = performance.now();
+        this.turnMessageClientId = messageClientId;
+        this.turnCounterEmitted = false;
+        this.turnReplyHandled = false;
+        this.turnObscured = this.isDocumentHidden();
+        this.turnCallActive = this.callInProgress.peek();
+        this.turnCause = null;
+        this.turnHasToolCall = false;
+        const token = ++this.turnToken;
+        this.clearResponseTimeout();
+        this.responseTimeoutId = root_store_setTimeout(()=>{
+            this.responseTimeoutId = null;
+            if (token !== this.turnToken || this.turnCounterEmitted) return;
+            // Treat the turn as obscured if the tab was hidden at any point, not just
+            // now: backgrounded tabs throttle setTimeout, so the timer often fires only
+            // after the visitor returns (document.hidden already false). Checking the
+            // whole wait keeps that throttling delay out of the timeout (unavailable) count.
+            const obscured = this.turnObscured || this.isDocumentHidden();
+            // The turn is counted from this moment, whenever the metric actually
+            // leaves: a reply or a `textResponseEnded` arriving later must not talk us
+            // out of a timeout the visitor has already experienced.
+            this.turnCounterEmitted = true;
+            if (obscured) {
+                metrics.emitIncrement("multimodal_text_response", {
+                    status: "backgrounded",
+                    call_active: this.turnCallActiveTag
+                });
+                return;
+            }
+            // Before the breadcrumb: nothing between latching the outcome and arming the
+            // emission, so a counted timeout cannot be lost to a failure in between.
+            this.holdTimeoutForCause();
+            serverLogger.serverLog({
+                type: "log",
+                message: "Multimodal text reply did not arrive within response budget"
+            });
+        }, (/* inlined export .RESPONSE_BUDGET_MS */25000));
+        return token;
+    }
+    get turnCallActiveTag() {
+        return this.turnCallActive ? "true" : "false";
+    }
+    /**
+  * Holds a decided timeout's metric back briefly so the server's cause report
+  * can land on it (see CAUSE_REPORT_GRACE_MS). Only the `cause` tag is
+  * outstanding — the turn is already counted — so this delays an emission, it
+  * never changes an outcome.
+  *
+  * Ends early when the report arrives, and is flushed rather than dropped if the
+  * turn is superseded or the store torn down first, so a held timeout can't go
+  * missing from the SLI.
+  */ holdTimeoutForCause() {
+        // Flush rather than clear: a hold here would already have been counted, and
+        // dropping it would delete a failure from the SLI. Unreachable today (one
+        // budget timer per turn, and starting a turn flushes), enforced here so it
+        // stays that way.
+        this.flushHeldTimeout();
+        // Captured now: a turn starting during the window resets the live value.
+        const callActive = this.turnCallActiveTag;
+        this.heldTimeoutFlush = ()=>{
+            var _this_turnCause;
+            this.clearTimeoutHold();
+            metrics.emitIncrement("multimodal_text_response", {
+                status: "timeout",
+                call_active: callActive,
+                // `unknown` rather than omitted: every timeout carries a cause, so a
+                // dashboard split by cause always adds up to the timeout total. A growing
+                // `unknown` slice means the report is not reaching us.
+                cause: (_this_turnCause = this.turnCause) != null ? _this_turnCause : "unknown"
+            });
+        };
+        this.timeoutHoldId = root_store_setTimeout(this.heldTimeoutFlush, (/* inlined export .CAUSE_REPORT_GRACE_MS */1500));
+    }
+    // No-op unless a timeout is being held. Self-clearing, so it is safe to call
+    // from every path that might race the window.
+    flushHeldTimeout() {
+        this.heldTimeoutFlush == null ? void 0 : this.heldTimeoutFlush.call(this);
+    }
+    clearTimeoutHold() {
+        if (this.timeoutHoldId !== null) {
+            root_store_clearTimeout(this.timeoutHoldId);
+            this.timeoutHoldId = null;
+        }
+        this.heldTimeoutFlush = null;
+    }
+    clearResponseTimeout() {
+        if (this.responseTimeoutId !== null) {
+            root_store_clearTimeout(this.responseTimeoutId);
+            this.responseTimeoutId = null;
+        }
+    }
+    isDocumentHidden() {
+        return typeof document !== "undefined" && document.hidden;
+    }
+    handleTextTurnSendResult(result, turnToken) {
+        if (!(result == null ? void 0 : result.error)) return;
+        if (turnToken !== this.turnToken || this.turnCounterEmitted) return;
+        this.clearResponseTimeout();
+        metrics.emitIncrement("multimodal_text_response", {
+            status: "send_failed",
+            call_active: this.turnCallActiveTag
+        });
+        // A failed send has no reply coming, so close the turn entirely (no latency).
+        this.turnCounterEmitted = true;
+        this.turnReplyHandled = true;
+        this.turnToken++;
+    }
+    static isTextResponseEndedReason(reason) {
+        return RootStore.TEXT_RESPONSE_ENDED_REASONS.includes(reason);
+    }
+    static isTurnCause(cause) {
+        return RootStore.TURN_CAUSES.includes(cause);
+    }
+    unresolvedAiSdrEmailRequest() {
+        var _this_activeConversation_value;
+        const activeConversationId = (_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id;
+        if (!activeConversationId) return null;
+        const resolvedFieldIds = new Set();
+        for (const message of [
+            ...this.messages.value
+        ].reverse()){
+            if (message.conversationId !== activeConversationId) continue;
+            if (message.type === "field_entry" && message.fieldId) {
+                resolvedFieldIds.add(message.fieldId);
+                continue;
+            }
+            if (message.type === "field_request" && message.createdByMultimodalAgent === true && message.fieldType === "email" && (!message.fieldId || !resolvedFieldIds.has(message.fieldId))) {
+                return message;
+            }
+        }
+        return null;
+    }
+    async aisdrEmailReplyPassesPreflight(text) {
+        if (!this.featureFlags.aisdrChatEmailValidation) return true;
+        if (!this.unresolvedAiSdrEmailRequest()) return true;
+        const email = text.trim();
+        if (!email.includes("@") || /\s/.test(email)) return true;
+        const [formatValid] = validateEmail(email, false);
+        if (!formatValid) return false;
+        return this.validateEmail(email);
+    }
+    async sendVisitorTextWithoutCookieConsent(text, extra) {
+        if (!await this.aisdrEmailReplyPassesPreflight(text)) {
+            this.sendTextError.value = "Invalid email address";
+            return;
+        }
+        const result = await this.sendMessage(_extends({
+            type: "text",
+            text,
+            isOwn: true
+        }, extra));
+        if (result.error) {
+            this.sendTextError.value = result.error.message || "Your message wasn't sent. Please try again.";
+        }
+    }
+    // Initialize voice and video stores when needed
+    async initializeVoiceAndVideo() {
+        this.isVideoLoading.value = true;
+        await this.callStore.load();
+    }
+    async checkPermissions() {
+        // Check current permission status before
+        let res = await navigator.permissions.query({
+            name: "microphone"
+        });
+        if (res.state !== "prompt") {
+            this.sendMessage({
+                type: "event",
+                eventType: "mediaPermissionStatus",
+                mediaStatus: "audio_already_" + res.state
+            });
+        } else {
+            // Request permission
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: false,
+                audio: true
+            }).catch(()=>null);
+            stream == null ? void 0 : stream.getTracks().forEach((track)=>track.stop());
+            // Check state again
+            res = await navigator.permissions.query({
+                name: "microphone"
+            });
+            this.sendMessage({
+                type: "event",
+                eventType: "mediaPermissionStatus",
+                mediaStatus: "audio_prompted_" + res.state
+            });
+        }
+    }
+    constructor(context, config = null){
+        super(context), this.config = config, // Initialized is true once we receive the first init state.
+        this.initialized = signals_core_module_d(false), // Set while a socket reconnect is in flight. The server answers a reconnect
+        // with a full initState re-broadcast, which must not move the widget away
+        // from where the visitor left it. Cleared once that initState is applied.
+        this.isReconnecting = signals_core_module_d(false), /** Admin-customizable chat input placeholder (English only) */ this.inputPlaceholder = signals_core_module_d(null), /** Whether to hide the visible 'Ask {name}' label on the multimodal messenger launcher */ this.multimodalHideLauncherLabel = signals_core_module_d(false), /**
+    * When the user expresses chat-view intent before initState provides the `formJoinIdUnique`
+    * payload field (or before conversations exist), we defer `custEv_chatView` until the store
+    * has `formJoinIDUnique` and an active conversation.
+    */ this.chatViewDeferredUserIntent = false, // Sub Stores (lazy-loaded via $fromImport)
+        this.meetingStore = $fromImport(()=>import("./meeting_store.js"), this), this.fieldRequestStore = $fromImport(()=>import("./field_request_store.js"), this), this.callStore = $fromImport(()=>import("./call_store.js"), this), this.pounceTrackingStore = $fromImport(()=>this.featureFlags.piperXAgent ? import("./pounce_tracking_store_v2.js") : import("./pounce_tracking_store.js"), this), this.slidesStore = $fromImport(()=>import("./slides_store.js"), this), this.presentationsStore = $fromImport(()=>import("./presentations_store.js"), this), this.decksStore = $fromImport(()=>import("./decks_store.js"), this), this.screenShareStore = $fromImport(()=>import("./screen_share_store.js"), this), this.waitingStore = $fromImport(()=>import("./waiting_store.js"), this), this.websiteNavigationStore = $fromImport(()=>import("./website_navigation_store.js"), this), this.debugScenarioStore = $fromImport(()=>import("./debug_multimodal_scenario_store.js"), this), this.postCallSurveyStore = $fromImport(()=>import("./post_call_survey_store.js"), this), /**
+    * Pre-offer booker SLI (intent -> offer -> shown). Owned here, not by
+    * `meetingStore`, for two reasons: the intent signal arrives on this store's
+    * message stream, and `meetingStore` is lazily imported — routing the arm
+    * through it would make the intent timestamp wait on a dynamic import,
+    * inflating the very latency we are measuring. `meetingStore` resolves it
+    * (`markOffered` / `markShown`) once the offer lands.
+    */ this.bookerIntentTracker = new BookerIntentTracker({
+            surface: BOOKER_SURFACE.MULTIMODAL,
+            log: (params)=>serverLogger.serverLog(params)
+        }), // Translation store is directly instantiated (not lazy-loaded) because
+        // translations are needed immediately when the app renders
+        this.translationStore = new TranslationStore(this), this.dockingStore = new DockingStore(this), this.artifactStore = new ArtifactStore(this), // Mutable State
+        this.isVisitorBlocked = signals_core_module_d(false), /** Piper form join ID for this page view; same for all custEv_* events on the page. */ this.formJoinIDUnique = signals_core_module_d(null), /** Tracks fired custEv_contentImpression IDs; bounded to prevent unbounded growth. */ this.impressedMessageIds = new BoundedSet(RootStore.IMPRESSED_MESSAGE_IDS_MAX_SIZE), this.agentsAvailable = signals_core_module_d(false), this.companyName = signals_core_module_d(), this.disableTitleFlash = signals_core_module_d(false), this.messengerEventListener = null, this.callInProgress = signals_core_module_w(()=>{
+            var _this_callStore_value;
+            return ((_this_callStore_value = this.callStore.value) == null ? void 0 : _this_callStore_value.dailyCall.value) != null;
+        }), this.typingIndicatorState = signals_core_module_d(false), this.activeToolCall = signals_core_module_d(null), this.pounceResponseStartTimestamp = null, this.callInitiatedAt = null, // Whether the team has configured a custom voice greeting (set by the admin
+        // via the multimodal voice greeting setting). When true, the initial greeting
+        // can be multiple sentences and varies per team, which affects greeting-sensitive
+        // timing metrics. Used to tag those metrics so dashboards can filter them out.
+        this.hasCustomVoiceGreeting = false, this.pounceTrackingLoadStarted = false, this.lastVisitorMessageSentAt = null, this.turnCounterEmitted = false, // Separate from the counter: lets a late reply still record latency after the
+        // timer resolved availability.
+        this.turnReplyHandled = false, this.responseTimeoutId = null, // A timeout that has been counted but whose metric is still waiting on the
+        // server's cause report (see holdTimeoutForCause).
+        this.timeoutHoldId = null, this.heldTimeoutFlush = null, // Dedups a late reply against a turn the timer already resolved.
+        this.turnToken = 0, // clientId of the message that opened the current turn; used to ignore a
+        // stale `textResponseEnded` event from a turn we've already superseded.
+        this.turnMessageClientId = null, // Latest cause the server reported for the outstanding turn, if any. Read only
+        // when the turn times out.
+        this.turnCause = null, // Whether the agent reached for a tool on this turn, which costs the call plus
+        // another model round trip to use what it returned. Reported as it happens, so a
+        // turn that never finishes is still on the right side of the split.
+        this.turnHasToolCall = false, // Tab hidden mid-turn → bucket as `backgrounded` (not a false `timeout`) and skip its latency.
+        this.turnObscured = false, this.turnCallActive = false, this.conversations = signals_core_module_d([]), this.messages = createMessagesSignal(), this.pounceCandidates = signals_core_module_d(null), this.isVideoLoading = signals_core_module_d(false), this.isBlurredVideoActive = signals_core_module_d(false), /**
+    * Which provider's track Coffee has committed to as the avatar video for this call.
+    * Null until Coffee reports one (an older Coffee never will), which callers treat as
+    * "fall back to the per-team flag".
+    */ this.activeAvatarProvider = signals_core_module_d(null), this.conversationModeFailover = signals_core_module_d({
+            voiceDisabled: false,
+            videoDisabled: false
+        }), this.modalityPreference = signals_core_module_d(null), this.dailyCallObjectBundleUrl = signals_core_module_d(null), this.dailyWsProxyUrl = signals_core_module_d(null), this.privacyDisclosures = signals_core_module_d(null), this.privacyDisclosureShown = signals_core_module_d(false), this.privacyDisclosureConsented = signals_core_module_d(false), this.cookieConsent = signals_core_module_d(null), this.cookieConsentGiven = signals_core_module_d(false), this.showCookieConsentModal = signals_core_module_d(false), this.pendingMessage = signals_core_module_d(null), // A call start awaiting cookie consent. When set, it also carries the optional
+        // trigger context (e.g. from a "present_video" card) so a single signal survives
+        // the consent re-entry path; the consent handlers read it back and re-invoke
+        // startCall with the stored context. `null` means no pending call.
+        this.pendingCallStart = signals_core_module_d(null), // Set when a visitor-typed text send is rejected server-side (e.g. the 2000-character
+        // limit in Message::Text) so the composer can tell the visitor their message never went
+        // through, rather than leaving them to wait on a reply that isn't coming. Cleared at the
+        // start of the next send attempt.
+        this.sendTextError = signals_core_module_d(null), // Loading overlay state (for lightbox / messenger loading screens)
+        this.loadingState = signals_core_module_d(types_LoadingState.NONE), this.loadingUuid = signals_core_module_d(null), // Element conversation state (for lightbox_gather from smart buttons)
+        this.elementConversation = signals_core_module_d(null), // Element conversation meeting offer (for calendar_event_offer from smart forms)
+        this.elementConversationOffer = signals_core_module_d(null), // Element conversation text message (for LightboxMessage step from offer/form bots)
+        this.elementConversationTextMessage = signals_core_module_d(null), // True while waiting for the backend to respond after submitLightboxGather
+        this.elementConversationLoading = signals_core_module_d(false), // Bumped whenever the element-conversation loading phase (re)starts. The inline
+        // meeting booker uses this to distinguish "the experience is still producing a
+        // conversation" (a fresh loading tick arrived after an endLoadingState) from
+        // "it ended without one", so it doesn't clear the spinner mid-flow (a white
+        // flash) while a slow booker is still computing its offer.
+        this.elementConversationLoadingSeq = signals_core_module_d(0), // Set by restoreGatherFromOffer ("Not you?") while a change_identity event is
+        // in flight and we are waiting for the backend to re-run the gather step. For a
+        // manual booker the backend echoes a stale calendar_event_offer (a known
+        // change_identity limitation) *before* the fresh lightbox_gather, both as
+        // separate elementMessage broadcasts in that order. Without this flag the offer
+        // flips elementConversationLoading to false and the gather that follows is
+        // dropped by the loading guard, stranding the visitor on an email-less offer
+        // instead of the email step. While set, an incoming offer is ignored; the flag
+        // clears when the gather (or a text/end) arrives, or the element state resets.
+        this.awaitingIdentityChangeRegather = signals_core_module_d(false), // True when a manual-experience meeting booker is being rendered inline into a
+        // page container div (inline_meeting_booker flag + a tagged container present).
+        // While set, the full-screen LightboxExperience suppresses itself so the booker
+        // only appears in the container, not as the default full-screen overlay.
+        this.inlineMeetingBookerActive = signals_core_module_d(false), // Computed: select the right disclosure based on effective locale
+        this.activePrivacyDisclosure = signals_core_module_w(()=>{
+            var _disclosures_;
+            var _disclosuresData_disclosures;
+            const disclosuresData = this.privacyDisclosures.value;
+            if (!(disclosuresData == null ? void 0 : (_disclosuresData_disclosures = disclosuresData.disclosures) == null ? void 0 : _disclosuresData_disclosures.length)) return null;
+            const locale = this.translationStore.effectiveLocale.value;
+            const { disclosures } = disclosuresData;
+            // First try exact locale match
+            const exactMatch = disclosures.find((d)=>d.locale === locale);
+            if (exactMatch) return exactMatch;
+            // Fallback to English
+            const englishMatch = disclosures.find((d)=>d.locale === "en");
+            if (englishMatch) return englishMatch;
+            // Return first available if no English
+            return (_disclosures_ = disclosures[0]) != null ? _disclosures_ : null;
+        }), // Computed: select the right cookie consent disclosure based on visitor location and locale.
+        // Resolution: state-specific > country-specific > ALL, with locale match then English fallback.
+        this.activeCookieDisclosure = signals_core_module_w(()=>{
+            var _cookieConsentData_disclosures;
+            const cookieConsentData = this.cookieConsent.value;
+            if (!(cookieConsentData == null ? void 0 : (_cookieConsentData_disclosures = cookieConsentData.disclosures) == null ? void 0 : _cookieConsentData_disclosures.length)) return null;
+            const locale = this.translationStore.effectiveLocale.value;
+            const { disclosures, visitorCountryCode, visitorStateCode } = cookieConsentData;
+            const findByLocation = (countryCode, stateCode)=>{
+                const localeMatch = disclosures.find((d)=>{
+                    var _d_stateCode;
+                    return d.countryCode === countryCode && ((_d_stateCode = d.stateCode) != null ? _d_stateCode : null) === (stateCode != null ? stateCode : null) && d.locale === locale;
+                });
+                if (localeMatch) return localeMatch;
+                const englishMatch = disclosures.find((d)=>{
+                    var _d_stateCode;
+                    return d.countryCode === countryCode && ((_d_stateCode = d.stateCode) != null ? _d_stateCode : null) === (stateCode != null ? stateCode : null) && d.locale === "en";
+                });
+                if (englishMatch) return englishMatch;
+                return null;
+            };
+            if (visitorStateCode && visitorCountryCode) {
+                const stateMatch = findByLocation(visitorCountryCode, visitorStateCode);
+                if (stateMatch) return stateMatch;
+            }
+            if (visitorCountryCode) {
+                const countryMatch = findByLocation(visitorCountryCode, null);
+                if (countryMatch) return countryMatch;
+            }
+            return findByLocation("ALL", null);
+        }), this.needsCookieConsent = signals_core_module_w(()=>{
+            var _cookieConsentData_consentedDisclosureIds;
+            if (!this.featureFlags.piperXCookieConsent) return false;
+            const cookieConsentData = this.cookieConsent.value;
+            if (!cookieConsentData) return !this.initialized.value;
+            const activeDisclosure = this.activeCookieDisclosure.value;
+            if (activeDisclosure && ((_cookieConsentData_consentedDisclosureIds = cookieConsentData.consentedDisclosureIds) == null ? void 0 : _cookieConsentData_consentedDisclosureIds.includes(activeDisclosure.id))) return false;
+            if (this.cookieConsentGiven.value) return false;
+            return !!this.activeCookieDisclosure.value;
+        }), // Cold start questions
+        this.coldStartQuestions = signals_core_module_d([]), this.coldStartVisibleLimit = signals_core_module_d(3), // Team-configured inactivity threshold (ms) before a follow-up pounce fires.
+        // Falls back to the hardcoded ACTIVE_THRESHOLD_MS default if not set.
+        this.pounceInactivityThresholdMs = signals_core_module_d(null), /**
+    * Debug mode for multimodal development.
+    * Enabled by adding `?q_debug_multimodal=1` to the URL.
+    * When enabled, allows previewing call UI states without starting a real call.
+    */ this.isDebugMultimodal = signals_core_module_w(()=>{
+            try {
+                var _window_location;
+                if (typeof window === "undefined") return false;
+                if (!((_window_location = window.location) == null ? void 0 : _window_location.search)) return false;
+                return new URLSearchParams(window.location.search).get("q_debug_multimodal") === "1";
+            } catch (unused) {
+                return false;
+            }
+        }), this.joinCallForPresentation = ()=>{
+            this.getCallUiAdapter().actions.startCall();
+        }, this.activeConversation = createActiveConversationSignal(this.conversations), this.userEngaged = signals_core_module_w(()=>!!this.activeConversation.user.value), this.isMessageStreamingEnabled = signals_core_module_w(()=>{
+            return !this.getCallUiAdapter().state.isInCall.value;
+        }), // UIStore must be initialized after messages, activeConversation, callStore
+        // since createLayoutSignal uses those during construction.
+        this.uiStore = new UIStore(this), /**
+    * Emits custEv_chatView piper web tracking event when eligible.
+    * Fires once per conversation after active user intent (expand launcher, focus composer,
+    * CTA/canned prompt, voice CTA, etc.) — not on page load when the widget restores opened.
+    * Pass `{ fromUserIntent: true }` from UI entry points so we can defer until initState fills
+    * `formJoinIdUnique` (stored as `formJoinIDUnique`) and conversations when intent is early.
+    * Only emits when `formJoinIDUnique` is set so the event matches other custEv_* events.
+    */ this.emitChatViewIfEligible = (options)=>{
+            var _ref, _this_formJoinIDUnique_value;
+            var _this_config_featureFlags, _this_config, _this_activeConversation_value;
+            const fromUserIntent = (_ref = options == null ? void 0 : options.fromUserIntent) != null ? _ref : false;
+            if (!((_this_config = this.config) == null ? void 0 : (_this_config_featureFlags = _this_config.featureFlags) == null ? void 0 : _this_config_featureFlags.piperWebTrackingEvents)) return;
+            if (this.userEngaged.value) {
+                this.chatViewDeferredUserIntent = false;
+                return;
+            }
+            const activeConvId = (_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id;
+            if (!activeConvId) {
+                // Mirror !formJoinIDUnique: only set defer on user intent; do not clear defer here —
+                // system calls before conversations exist must not wipe a pending user intent.
+                if (fromUserIntent) {
+                    this.chatViewDeferredUserIntent = true;
+                }
+                return;
+            }
+            const hasFired = this.messages.peek().some((m)=>m.type === "event" && m.eventType === "chatViewFired" && m.conversationId === activeConvId);
+            if (hasFired) {
+                this.chatViewDeferredUserIntent = false;
+                return;
+            }
+            const formJoinIDUnique = (_this_formJoinIDUnique_value = this.formJoinIDUnique.value) != null ? _this_formJoinIDUnique_value : "";
+            if (!formJoinIDUnique) {
+                if (fromUserIntent) {
+                    this.chatViewDeferredUserIntent = true;
+                }
+                return;
+            }
+            this.chatViewDeferredUserIntent = false;
+            this.sendMessage({
+                type: "event",
+                eventType: "chatViewFired"
+            });
+            const data = buildCustEvChatViewPayload(this.piperConversationId, formJoinIDUnique);
+            this.channel.emitPiperWebTrackingEvent({
+                name: "custEv_chatView",
+                data
+            });
+        }, /**
+    * Emits custEv_contentImpression piper web tracking event.
+    * Used when links or rich content become visible in the viewport.
+    * Payload matches cold-start content impressions (no formJoinIDUnique).
+    */ this.emitContentImpression = (modules)=>{
+            var _this_config_featureFlags, _this_config;
+            if (!((_this_config = this.config) == null ? void 0 : (_this_config_featureFlags = _this_config.featureFlags) == null ? void 0 : _this_config_featureFlags.piperWebTrackingEvents)) return;
+            if (modules.length === 0) return;
+            const data = buildCustEvContentImpressionPayload(modules);
+            this.channel.emitPiperWebTrackingEvent({
+                name: "custEv_contentImpression",
+                data
+            });
+        }, this.handleTurnVisibilityChange = ()=>{
+            if (this.isDocumentHidden() && this.lastVisitorMessageSentAt !== null && !this.turnReplyHandled) {
+                this.turnObscured = true;
+            }
+        }, // Actions — delegated to UIStore
+        this.setUIState = (uiState)=>{
+            this.uiStore.setUIState(uiState);
+        }, this.setDisplayMode = (displayMode)=>{
+            this.uiStore.setDisplayMode(displayMode);
+        }, this.setOpenedDisplayMode = ()=>{
+            this.uiStore.setOpenedDisplayMode();
+        }, this.updateOpenedDisplayMode = (openedDisplayMode)=>{
+            this.uiStore.updateOpenedDisplayMode(openedDisplayMode);
+        }, this.setConversationMode = (conversationMode)=>{
+            this.uiStore.setConversationMode(conversationMode);
+        }, this.toggleVideoMode = (mode)=>{
+            this.uiStore.toggleVideoMode(mode);
+        }, this.setMaximizedState = (state)=>{
+            this.uiStore.setMaximizedState(state);
+        }, this.clearMaximizedState = (param)=>{
+            let { when } = param === void 0 ? {} : param;
+            this.uiStore.clearMaximizedState({
+                when
+            });
+        }, this.sendTypingEvent = (content)=>{
+            this.channel.perform("update_visitor_typing", {
+                content
+            });
+        }, this.updateConversationModeFailover = (failover)=>{
+            signals_core_module_r(()=>{
+                this.conversationModeFailover.value = _extends({}, this.conversationModeFailover.value, failover);
+                if (this.conversationModeFailover.value.voiceDisabled) {
+                    this.cancelCallOrConnection({
+                        closeWidget: false
+                    });
+                } else if (this.conversationModeFailover.value.videoDisabled) {
+                    this.isVideoLoading.value = false;
+                }
+                this.uiStore.ensureValidUIState();
+            });
+        }, this.sendMessage = async (payload, param)=>{
+            let { optimistic = true, conversationId } = param === void 0 ? {} : param;
+            var _ref, _ref1, _ref2;
+            var _this_elementConversationOffer_value, _this_activeConversation_value, _this_elementConversation_value;
+            const id = esm_browser_v4();
+            const resolvedConversationId = (_ref = (_ref1 = (_ref2 = conversationId != null ? conversationId : (_this_elementConversationOffer_value = this.elementConversationOffer.value) == null ? void 0 : _this_elementConversationOffer_value.conversationId) != null ? _ref2 : (_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id) != null ? _ref1 : (_this_elementConversation_value = this.elementConversation.value) == null ? void 0 : _this_elementConversation_value.id) != null ? _ref : "";
+            const message = _extends({}, payload, {
+                id,
+                clientId: id,
+                optimistic,
+                conversationId: resolvedConversationId,
+                createdAt: new Date().toISOString(),
+                source: "standard",
+                multimodalDisplayMode: this.displayMode.value
+            });
+            if (optimistic && payload.type !== "field_entries") {
+                this.addMessage(message);
+            }
+            const { isInCall, isVideoLoading } = this.getCallUiAdapter().state;
+            if (!isInCall.peek() && !isVideoLoading.peek() && payload.type === "text" && payload.isOwn && this.uiStore.allowedConversationModes.video.peek()) {
+                this.setUIState({
+                    userHasIgnoredMultimodal: true
+                });
+            }
+            const isVisitorAction = payload.type === "text" && "isOwn" in payload && payload.isOwn || payload.type === "field_entry" && "isOwn" in payload && payload.isOwn || payload.type === "calendar_event_pick";
+            if (message.type !== "event") {
+                // Visitor actions (text, field entry, calendar pick) imply chat-view intent even when
+                // the widget is already open — e.g. first interaction is booking while in SIDEBAR.
+                if (isVisitorAction) {
+                    this.emitChatViewIfEligible({
+                        fromUserIntent: true
+                    });
+                }
+                // Don't pop the full messenger open beside the inline meeting booker: its
+                // container has no overlay, so opening the messenger would be an unwanted
+                // visible side-effect (same reasoning as openMessengerForElementConversation).
+                // The inline gather submit (field_entries) and time confirm
+                // (calendar_event_pick) route through here, so guard them too.
+                if (!this.inlineMeetingBookerActive.value) {
+                    this.setOpenedDisplayMode();
+                }
+            }
+            if (payload.type === "text") {
+                this.recordPrivacyDisclosureConsent(id);
+            }
+            // Known limitation: we track a single outstanding turn (first-message-wins).
+            // If a turn times out and the visitor sends again before its late reply lands,
+            // that reply is attributed to the newer turn (replies carry no link to the
+            // visitor message they answer, so we can't match them by anything but timing).
+            // Rare (needs a >budget reply plus a resend in the gap) and self-correcting in
+            // aggregate, so we accept it rather than track per-message turns.
+            const startedTurnToken = isVisitorAction && (this.lastVisitorMessageSentAt === null || this.turnCounterEmitted) ? this.startTextTurn(id) : null;
+            const result = await this.channel.perform("send_message", snakify(message));
+            if (startedTurnToken !== null) {
+                this.handleTextTurnSendResult(result, startedTurnToken);
+            }
+            return result;
+        }, /**
+    * Backend closed a turn with no reply on purpose (guardrail block, rep
+    * takeover, blank output, ...). Close the turn under a distinct status so the
+    * budget timer doesn't fire a false `timeout` and dashboards can exclude it
+    * from the success rate. Guarded on `turnCounterEmitted` so a turn already
+    * resolved by a real reply (or the timer) is left untouched.
+    */ this.handleTextResponseEnded = (payload)=>{
+            var _ref;
+            if (this.lastVisitorMessageSentAt === null || this.turnCounterEmitted) return;
+            // Ignore a late event from a turn we've already superseded: it must belong
+            // to the message that opened the current outstanding turn.
+            if ((payload == null ? void 0 : payload.clientId) !== this.turnMessageClientId) return;
+            const reason = (_ref = payload == null ? void 0 : payload.reason) != null ? _ref : "";
+            const status = RootStore.isTextResponseEndedReason(reason) ? reason : "suppressed";
+            this.clearResponseTimeout();
+            metrics.emitIncrement("multimodal_text_response", _extends({
+                status,
+                call_active: this.turnCallActiveTag
+            }, this.turnCause ? {
+                cause: this.turnCause
+            } : {}));
+            // No reply is coming, so close the turn entirely (no latency recorded).
+            this.turnCounterEmitted = true;
+            this.turnReplyHandled = true;
+            this.turnToken++;
+        }, /**
+    * The server telling us what this turn is spending its time on, sent when the
+    * response budget expires (and again afterwards for turns that finished slow).
+    * Purely an annotation: it never resolves or ends a turn, it only supplies the
+    * `cause` tag the timeout would otherwise lack.
+    */ this.handleTextTurnDiagnostics = (payload)=>{
+            var _ref;
+            if ((payload == null ? void 0 : payload.clientId) !== this.turnMessageClientId) return;
+            if ((payload == null ? void 0 : payload.hasToolCall) === true) this.turnHasToolCall = true;
+            // A tool report carries no cause and arrives mid-turn, so it must not release a
+            // held timeout: that would emit the metric before the cause it is waiting for.
+            const cause = (_ref = payload == null ? void 0 : payload.cause) != null ? _ref : "";
+            if (!RootStore.isTurnCause(cause)) return;
+            // Preserve the first concrete explanation for this client turn; `unknown`
+            // is a placeholder and may be replaced when a real cause arrives.
+            this.turnCause = this.turnCause && this.turnCause !== "unknown" ? this.turnCause : cause;
+            // This report is what a held timeout was waiting for; no reason to sit out
+            // the rest of the window.
+            this.flushHeldTimeout();
+        }, this.sendVisitorText = async (text, extra)=>{
+            this.sendTextError.value = null;
+            if (this.featureFlags.piperXCookieConsent && this.needsCookieConsent.value) {
+                this.pendingMessage.value = _extends({
+                    text
+                }, extra);
+                this.setOpenedDisplayMode();
+                this.showCookieConsentModal.value = true;
+                return;
+            }
+            await this.sendVisitorTextWithoutCookieConsent(text, extra);
+        }, this.markMessagesAsRead = (messages)=>{
+            const messagesToMarkAsRead = messages != null ? messages : this.messages.unread.value;
+            const messageIds = messagesToMarkAsRead.filter((m)=>!m.isRead).map((m)=>m.id);
+            if (messageIds.length === 0) return;
+            this.channel.perform("mark_messages_as_read", snakify({
+                messageIds
+            }));
+            signals_core_module_r(()=>{
+                for (const message of messagesToMarkAsRead){
+                    this.updateMessage(message, {
+                        isRead: true
+                    });
+                }
+            });
+        }, this.dismissPounce = ()=>{
+            if (this.messages.pounceActive.peek()) {
+                this.sendMessage({
+                    type: "event",
+                    eventType: "pounce_dismissed"
+                });
+            }
+            this.markMessagesAsRead();
+        }, this.fireMessagesDismissed = ()=>{
+            this.messengerEventListener == null ? void 0 : this.messengerEventListener.call(this, "messagesDismissed");
+        }, this.recordPrivacyDisclosure = ()=>{
+            var _this_activeConversation_value, _this_activeConversation_value1;
+            const disclosure = this.activePrivacyDisclosure.value;
+            if (!disclosure || !((_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id)) return;
+            // Send the exact disclosure ID that was shown to the user
+            this.channel.perform("record_privacy_disclosure_shown", {
+                disclosure_id: disclosure.id,
+                conversation_id: (_this_activeConversation_value1 = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value1.id
+            });
+            this.privacyDisclosureShown.value = true;
+        }, this.recordPrivacyDisclosureConsent = (clientId)=>{
+            if (this.privacyDisclosureConsented.value) return;
+            if (!this.privacyDisclosures.value) return;
+            this.channel.perform("record_privacy_disclosure_consent_given", {
+                client_id: clientId
+            });
+            this.privacyDisclosureConsented.value = true;
+        }, // Cookie consent actions
+        this.acceptCookieConsent = ()=>{
+            if (!this.featureFlags.piperXCookieConsent) return;
+            const pending = this.pendingMessage.value;
+            const disclosure = this.activeCookieDisclosure.value;
+            const cookieConsentData = this.cookieConsent.value;
+            if (!disclosure || !cookieConsentData) return;
+            const pendingCall = this.pendingCallStart.value;
+            signals_core_module_r(()=>{
+                this.channel.perform("record_cookie_consent", {
+                    messenger_theme_id: cookieConsentData.messengerThemeId,
+                    cookie_disclosure_id: disclosure.id
+                });
+                this.cookieConsentGiven.value = true;
+                this.showCookieConsentModal.value = false;
+                if (pending) {
+                    const { text } = pending, extra = _object_without_properties_loose(pending, [
+                        "text"
+                    ]);
+                    this.pendingMessage.value = null;
+                    void this.sendVisitorTextWithoutCookieConsent(text, extra);
+                }
+                this.pendingCallStart.value = null;
+            });
+            if (pendingCall) {
+                var _pendingCall_context;
+                this.startCall((_pendingCall_context = pendingCall.context) != null ? _pendingCall_context : undefined);
+            }
+        }, this.denyCookieConsent = ()=>{
+            if (!this.featureFlags.piperXCookieConsent) return;
+            signals_core_module_r(()=>{
+                this.showCookieConsentModal.value = false;
+                this.pendingMessage.value = null;
+                // Clearing the pending call also discards any stashed trigger context, so a
+                // later regular call is never mistaken for a presentation start.
+                this.pendingCallStart.value = null;
+                this.setDisplayMode(types_DisplayMode.CLOSED);
+            });
+        }, this.flushPendingCookieConsentActions = ()=>{
+            if (!this.featureFlags.piperXCookieConsent) return;
+            const pending = this.pendingMessage.value;
+            const pendingCall = this.pendingCallStart.value;
+            if (!pending && !pendingCall) return;
+            if (this.needsCookieConsent.value) {
+                this.setOpenedDisplayMode();
+                this.showCookieConsentModal.value = true;
+            } else {
+                if (pending) {
+                    const { text } = pending, extra = _object_without_properties_loose(pending, [
+                        "text"
+                    ]);
+                    this.pendingMessage.value = null;
+                    void this.sendVisitorTextWithoutCookieConsent(text, extra);
+                }
+                if (pendingCall) {
+                    var _pendingCall_context;
+                    this.pendingCallStart.value = null;
+                    this.startCall((_pendingCall_context = pendingCall.context) != null ? _pendingCall_context : undefined);
+                }
+            }
+        }, this.updateMessage = (message, payload)=>{
+            this.messages.value = this.messages.value.map((m)=>m.id === message.id ? this.mergeMessage(m, payload) : m);
+        }, this.mergeMessage = (existing, incoming)=>_extends({}, existing, incoming, {
+                isRead: existing.isRead || incoming.isRead
+            }), this.updateInputMessage = async (message)=>{
+            await this.fieldRequestStore.load();
+            signals_core_module_r(()=>{
+                this.setOpenedDisplayMode();
+                this.setUIState({
+                    inputMessageId: message.id
+                });
+            });
+        }, /** Opens the booker in the artifact overlay, or closes it if it is already showing this offer. */ this.toggleMeetingBookerArtifact = async (message)=>{
+            if (this.artifact.messageId.peek() === message.id) {
+                this.clearArtifact();
+                return;
+            }
+            await this.artifactStore.presentArtifactMessage(message);
+        }, /** Dismisses the booker on whichever surface is showing it. */ this.closeMeetingBooker = ()=>{
+            signals_core_module_r(()=>{
+                this.clearMeetingArtifact();
+                this.elementConversationOffer.value = null;
+                this.elementConversationLoading.value = false;
+            // NOTE: elementConversationTextMessage is intentionally NOT cleared here —
+            // see the note in clearInputMessage.
+            });
+        }, /** Tears down the artifact overlay only when it is the meeting booker. */ this.clearMeetingArtifact = ()=>{
+            var _this_artifact_message_peek;
+            if (((_this_artifact_message_peek = this.artifact.message.peek()) == null ? void 0 : _this_artifact_message_peek.type) !== "calendar_event_offer") return;
+            this.clearArtifact();
+        }, /** Hands an incoming message to the overlay. See ArtifactStore#queueArtifactMessage. */ this.queueArtifactMessage = (message, options)=>{
+            if (options === void 0) options = {};
+            return this.artifactStore.queueArtifactMessage(message, options);
+        }, /** Re-opens an artifact the visitor asked for from the timeline. */ this.presentArtifactMessage = (message)=>this.artifactStore.presentArtifactMessage(message), this.revisitDeckSlide = (message, slideIndex, pageTitle)=>this.artifactStore.revisitDeckSlide(message, slideIndex, pageTitle), this.clearArtifact = ()=>{
+            this.artifactStore.clearArtifact();
+        }, this.clearInputMessage = (param)=>{
+            let { when } = param === void 0 ? {} : param;
+            if (!when || this.input.state.value === when) {
+                this.setUIState({
+                    inputMessageId: null
+                });
+                signals_core_module_r(()=>{
+                    this.elementConversationOffer.value = null;
+                    this.elementConversationLoading.value = false;
+                });
+            // NOTE: elementConversationTextMessage is intentionally NOT cleared here.
+            // After a successful booking, the server broadcasts calendar_event_confirmation
+            // (which sets elementConversationTextMessage) BEFORE send_message:response is
+            // processed. Clearing it here would race with that broadcast and erase the
+            // confirmation overlay. Instead, clear it when a new element conversation
+            // begins (handleInitElementConversation / handleInitQualifiedFormElementConversation)
+            // or when the user dismisses it via the "Done" button in LightboxExperience.
+            }
+        }, this.setTypingIndicator = (typing)=>{
+            this.typingIndicatorState.value = typing;
+            if (!typing) {
+                this.activeToolCall.value = null;
+            }
+        }, this.startCall = async (startCallContext, displayState)=>{
+            if (displayState === void 0) displayState = "open";
+            var _this_pounceTrackingStore_value, _this_callStore_value;
+            if (this.conversationMode.text.peek()) {
+                return;
+            }
+            if (this.featureFlags.piperXCookieConsent && this.needsCookieConsent.value) {
+                // Stash the (optional) trigger context so it survives the cookie-consent
+                // re-entry path: acceptCookieConsent/flushPendingCookieConsentActions read
+                // it back and re-call startCall with the stored context.
+                //
+                // The requested display state is deliberately dropped. Asking for consent
+                // opens the widget and puts the visitor in front of it, so re-applying the
+                // original request afterwards would move (or close) a widget they are
+                // already looking at.
+                this.pendingCallStart.value = {
+                    context: startCallContext != null ? startCallContext : null
+                };
+                this.setOpenedDisplayMode();
+                this.showCookieConsentModal.value = true;
+                return;
+            }
+            this.callInitiatedAt = performance.now();
+            this.messengerEventListener == null ? void 0 : this.messengerEventListener.call(this, "callRequested");
+            (_this_pounceTrackingStore_value = this.pounceTrackingStore.value) == null ? void 0 : _this_pounceTrackingStore_value.notifyCallRequested();
+            this.sendMessage({
+                type: "event",
+                eventType: "ai_sdr_call_requested"
+            });
+            signals_core_module_r(()=>{
+                this.setUIState({
+                    userHasIgnoredMultimodal: false
+                });
+                this.applyStartCallDisplayState(displayState);
+            });
+            const callStore = this.callStore.value;
+            if (!callStore) {
+                await this.initializeVoiceAndVideo();
+            }
+            const dailyCall = (_this_callStore_value = this.callStore.value) == null ? void 0 : _this_callStore_value.dailyCall.value;
+            if (!dailyCall) {
+                var _this_callStore_value1;
+                (_this_callStore_value1 = this.callStore.value) == null ? void 0 : _this_callStore_value1.aiConversationStore.startConversation(false, startCallContext != null ? startCallContext : null);
+            }
+        }, /**
+    * Position the widget for a call that is about to start.
+    *
+    * `minimized` runs the call in picture-in-picture over the host page, which
+    * only reads as picture-in-picture with nothing layered on top: a maximized
+    * artifact keeps its backdrop and z-index even once the display mode is
+    * closed, so it has to be cleared as well.
+    */ this.applyStartCallDisplayState = (displayState)=>{
+            if (displayState === "minimized") {
+                this.clearMaximizedState();
+                this.setDisplayMode(types_DisplayMode.CLOSED);
+                return;
+            }
+            // Expand to opened display mode if minimized
+            if (this.displayMode.minimized.value) {
+                this.setOpenedDisplayMode();
+            }
+            // Maximizing centers the multimodal UI, which collides with the custom entry
+            // points voice-only setups render, so it is video-only.
+            if (displayState === "maximized" && this.conversationMode.video.peek()) {
+                this.setMaximizedState(types_MaximizedState.MULTIMODAL);
+            }
+        }, this.resetToStartingPosition = ()=>{
+            this.uiStore.resetToStartingPosition();
+        }, this.dismissWidget = ()=>{
+            this.uiStore.dismissWidget();
+        }, this.closeWidget = ()=>{
+            this.uiStore.closeWidget();
+        }, /**
+    * Show a full-screen lightbox loading overlay and expand the widget.
+    * If the widget is minimized, opens it first.
+    */ this.showLightboxLoading = ()=>{
+            signals_core_module_r(()=>{
+                this.loadingState.value = types_LoadingState.LIGHTBOX;
+                if (this.displayMode.minimized.value && !this.uiStore.hasPendingRedirectDismissedUIState()) {
+                    this.setOpenedDisplayMode();
+                }
+            });
+        }, /**
+    * Opens the messenger for an element-conversation step when the widget is
+    * minimized — unless the meeting booker is being rendered inline into a page
+    * container ({@link inlineMeetingBookerActive}). The full-screen lightbox flow
+    * hides the opened messenger behind its overlay, but inline mode has no
+    * overlay, so popping the messenger open would be an unwanted visible
+    * side-effect next to the container booker.
+    */ this.openMessengerForElementConversation = ()=>{
+            if (this.inlineMeetingBookerActive.value) return;
+            if (this.displayMode.minimized.value) {
+                this.setOpenedDisplayMode();
+            }
+        }, /**
+    * Enters the element-conversation loading phase used by lightbox smart-site
+    * flows before the gather/offer payload is available.
+    */ this.showElementConversationLoadingState = ()=>{
+            signals_core_module_r(()=>{
+                this.openMessengerForElementConversation();
+                this.elementConversation.value = null;
+                this.elementConversationOffer.value = null;
+                this.elementConversationTextMessage.value = null;
+                this.elementConversationLoading.value = true;
+                this.elementConversationLoadingSeq.value += 1;
+                this.closeLightbox();
+            });
+        }, /**
+    * Show a messenger-panel loading overlay and expand the widget.
+    */ this.showMessengerLoading = ()=>{
+            signals_core_module_r(()=>{
+                this.loadingState.value = types_LoadingState.MESSENGER;
+                this.setOpenedDisplayMode();
+            });
+        }, /**
+    * Show an inline spinner for a specific personalization element.
+    * The DOM spinner is managed by PersonalizationManager; this just
+    * tracks the uuid for cleanup purposes.
+    */ this.showInlineLoading = (uuid)=>{
+            signals_core_module_r(()=>{
+                this.loadingState.value = types_LoadingState.INLINE;
+                this.loadingUuid.value = uuid;
+            });
+        }, /**
+    * Clear any active loading state (lightbox, messenger, or inline).
+    * No-op when loading state is already NONE.
+    */ this.closeLightbox = ()=>{
+            if (this.loadingState.peek() !== types_LoadingState.NONE) {
+                signals_core_module_r(()=>{
+                    this.loadingState.value = types_LoadingState.NONE;
+                    this.loadingUuid.value = null;
+                });
+            }
+        }, /**
+    * Cancels any active call or connecting state and returns to starting position.
+    * Used when the Toolbar close button is clicked while in a call or connecting.
+    *
+    * Behavior:
+    * - FULLSCREEN → COLLAPSED
+    * - SIDEBAR → CLOSED
+    */ this.cancelCallOrConnection = async (param)=>{
+            let { closeWidget = true } = param === void 0 ? {} : param;
+            // Reset maximized state when ending call
+            this.clearMaximizedState();
+            // Handle debug mode - reset the scenario store
+            const debugStore = this.debugScenarioStore.value;
+            if (this.isDebugMultimodal.value && debugStore) {
+                debugStore.reset();
+                if (closeWidget) {
+                    this.closeWidget();
+                }
+                return;
+            }
+            // Handle real call mode
+            const callStore = this.callStore.value;
+            const aiConversationStore = callStore == null ? void 0 : callStore.aiConversationStore;
+            const dailyCall = callStore == null ? void 0 : callStore.dailyCall.value;
+            // Always reset the loading state first to prevent any pending async operations
+            // from continuing (e.g., tavusStore.handleStartResponse checks this flag)
+            this.isVideoLoading.value = false;
+            this.isBlurredVideoActive.value = false;
+            this.activeAvatarProvider.value = null;
+            this.setTypingIndicator(false);
+            // End the tavus conversation if one exists
+            if (aiConversationStore == null ? void 0 : aiConversationStore.conversation.value) {
+                await aiConversationStore.endConversation();
+            }
+            // Leave any active Daily call
+            if (dailyCall) {
+                await (callStore == null ? void 0 : callStore.leaveCall());
+            }
+            if (closeWidget) {
+                this.closeWidget();
+            }
+        }, // Everything below is private
+        // Signal subscriptions
+        this.signalSubscriptions = [
+            ()=>this.activePrivacyDisclosure.subscribe(this.handlePrivacyDisclosureChange),
+            ()=>this.messages.pounceActive.subscribe((active)=>{
+                    var _this_pounceTrackingStore_value;
+                    if (active) {
+                        this.startPounceTracking();
+                        return;
+                    }
+                    if (this.pounceTrackingStore.value) {
+                        this.pounceTrackingLoadStarted = false;
+                    }
+                    (_this_pounceTrackingStore_value = this.pounceTrackingStore.value) == null ? void 0 : _this_pounceTrackingStore_value.dispose();
+                    this.setTypingIndicator(false);
+                })
+        ], this.handlePrivacyDisclosureChange = ()=>{
+            var _this_privacyDisclosures_value, _this_activeConversation_value;
+            const isInline = ((_this_privacyDisclosures_value = this.privacyDisclosures.value) == null ? void 0 : _this_privacyDisclosures_value.displayMode) === "inline";
+            const isDisclosureVisible = isInline ? this.displayMode.opened.value : !this.displayMode.closed.value;
+            if (isDisclosureVisible && this.activePrivacyDisclosure.value && ((_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id)) {
+                this.recordPrivacyDisclosure();
+            }
+        }, // Message handlers
+        this.messageHandlers = {
+            initState: (payload)=>this.handleInitState(payload),
+            stateUpdate: (payload)=>this.handleStateUpdate(payload),
+            message: (payload)=>this.handleMessage(payload),
+            messageRead: (payload)=>this.handleMessageRead(payload),
+            typingStarted: ()=>this.setTypingIndicator(true),
+            typingEnded: ()=>this.setTypingIndicator(false),
+            visitorBlocked: ()=>signals_core_module_r(()=>{
+                    this.isVisitorBlocked.value = true;
+                    this.setTypingIndicator(false);
+                    this.setConversationMode(types_ConversationMode.TEXT);
+                }),
+            visitorUnblocked: ()=>this.isVisitorBlocked.value = false,
+            botProcessEnded: ()=>this.handleBotProcessEnded(),
+            textResponseEnded: (payload)=>this.handleTextResponseEnded(payload),
+            textTurnDiagnostics: (payload)=>this.handleTextTurnDiagnostics(payload),
+            toolCallStarted: (payload)=>{
+                var _ref;
+                this.activeToolCall.value = (_ref = payload == null ? void 0 : payload.toolName) != null ? _ref : null;
+            },
+            toolCallCompleted: ()=>{
+                this.activeToolCall.value = null;
+            },
+            open: ()=>{
+                // Close via the adapter so the active experience's lightbox closes, whether it's the legacy iframe (V1Adapter) or multimodal (V2Adapter).
+                this.experienceAdapter.closeLightbox();
+                this.setOpenedDisplayMode();
+            }
+        }, this.handleInitElementConversation = (payload)=>{
+            var _payload_messages_filter, _payload_messages;
+            // Use the LAST lightbox_gather message — conversations with show_follow_up_questions
+            // accumulate multiple lightbox_gather messages (initial + follow-up). .find() would
+            // return the stale initial message; .at(-1) returns the most recent one.
+            const lightboxGatherMsg = (_payload_messages = payload.messages) == null ? void 0 : (_payload_messages_filter = _payload_messages.filter((m)=>m.type === "lightbox_gather")) == null ? void 0 : _payload_messages_filter.at(-1);
+            if (!lightboxGatherMsg) {
+                var _payload_messages1;
+                // No gather step — check for a direct meeting booker offer (bot goes straight
+                // to RouteForMeeting without a LightboxGather step).  The server still broadcasts
+                // initElementConversation for manual (non-form) bots; the payload contains the
+                // calendar_event_offer message we need to show the meeting calendar.
+                const offerMsg = (_payload_messages1 = payload.messages) == null ? void 0 : _payload_messages1.find((m)=>m.type === "calendar_event_offer");
+                if (offerMsg) {
+                    // "Not you?" in flight: ignore the stale offer and keep waiting for the
+                    // re-gather (see restoreGatherFromOffer / handleInitQualifiedFormElementConversation).
+                    if (this.awaitingIdentityChangeRegather.value) return;
+                    signals_core_module_r(()=>{
+                        this.openMessengerForElementConversation();
+                        this.elementConversationLoading.value = false;
+                        this.elementConversationOffer.value = offerMsg;
+                        this.elementConversationTextMessage.value = null;
+                        this.closeLightbox();
+                    });
+                    this.meetingStore.load();
+                } else {
+                    signals_core_module_r(()=>{
+                        this.openMessengerForElementConversation();
+                        // StartElementConversation can arrive before the backend has produced the
+                        // follow-up gather or offer message. Keep the lightbox loading overlay up
+                        // so the visitor sees progress instead of falling back to no overlay.
+                        this.elementConversationLoading.value = true;
+                        // Bump the loading seq so the inline booker's end-of-experience grace
+                        // check (InlineMeetingBooker.handleExperienceEnd) sees this restart and
+                        // does not blank the container while the offer is still in flight.
+                        this.elementConversationLoadingSeq.value += 1;
+                        // Clear any stale confirmation overlay from a previous booking.
+                        this.elementConversationTextMessage.value = null;
+                    });
+                }
+                return;
+            }
+            signals_core_module_r(()=>{
+                this.openMessengerForElementConversation();
+                this.elementConversation.value = {
+                    id: payload.id,
+                    message: lightboxGatherMsg
+                };
+                this.elementConversationTextMessage.value = null;
+                // Clear loading state — this handles both the initial gather and any
+                // follow-up gather steps (show_follow_up_questions) where the server
+                // re-broadcasts initElementConversation after processing the response.
+                this.elementConversationLoading.value = false;
+                // The re-gather we were waiting on ("Not you?") has arrived.
+                this.awaitingIdentityChangeRegather.value = false;
+                this.closeLightbox();
+            });
+        }, this.submitLightboxGather = (entries)=>{
+            const elementConv = this.elementConversation.value;
+            if (!elementConv) return;
+            // Batched so subscribers (e.g. LightboxExperience's completion-hold effects)
+            // never observe elementConversationLoading=true while elementConversation is
+            // still its stale pre-submit value — that intermediate state spuriously
+            // satisfied the gather-hold's isReady() and snapped the bar to 100% for the
+            // wrong reason, long before the real offer ever arrived.
+            signals_core_module_r(()=>{
+                this.elementConversationLoading.value = true;
+                // Restart the loading seq so the inline booker's grace check keeps the
+                // spinner up while the offer computes (see handleInitElementConversation).
+                this.elementConversationLoadingSeq.value += 1;
+                this.elementConversation.value = null;
+            });
+            this.sendMessage({
+                type: "field_entries",
+                entries,
+                id: elementConv.message.id,
+                botStep: elementConv.message.botStep,
+                executionStep: elementConv.message.executionStep
+            }, {
+                optimistic: false,
+                conversationId: elementConv.id
+            });
+        }, /**
+    * Clears the meeting offer and asks the backend to drop the visitor's
+    * identity so the LightboxGather step can re-run ("Not you?" flow). The
+    * server destroys identities in MeetingBookerOffer#call and broadcasts a
+    * fresh lightbox_gather message, which the standard init path hydrates
+    * back into `elementConversation`.
+    */ this.restoreGatherFromOffer = ()=>{
+            const offer = this.elementConversationOffer.value;
+            if (!offer) return;
+            this.sendMessage({
+                type: "event",
+                eventType: "change_identity",
+                botStep: offer.botStep,
+                executionStep: offer.executionStep
+            }, {
+                conversationId: offer.conversationId
+            }).then((result)=>{
+                // MultimodalChannel.perform reports timeouts and server errors by
+                // resolving with an { error } result rather than rejecting, so a channel
+                // failure lands here (not in catch). Without this, loading and the
+                // re-gather guard would stay set forever and every later offer would be
+                // dropped by the guard in handleInitElementConversation.
+                if (result == null ? void 0 : result.error) this.clearRegatherOnChannelFailure();
+            }).catch(()=>this.clearRegatherOnChannelFailure());
+            signals_core_module_r(()=>{
+                this.elementConversationOffer.value = null;
+                this.elementConversationLoading.value = true;
+                // Restart the loading seq so the inline booker's grace check keeps the
+                // spinner up until the re-gathered lightbox_gather arrives.
+                this.elementConversationLoadingSeq.value += 1;
+                // Ignore the stale offer the backend echoes before the re-gather; hold the
+                // spinner until the lightbox_gather arrives so we land on the email step.
+                this.awaitingIdentityChangeRegather.value = true;
+            });
+        }, /**
+    * Mirror LightboxEntry#handleRefreshMeetingOffer: when the "Not you?" re-gather
+    * channel call drops or resolves with an error, clear the spinner so the
+    * visitor isn't stuck on a perpetual overlay, and clear the re-gather guard so
+    * a later offer isn't silently dropped.
+    */ this.clearRegatherOnChannelFailure = ()=>{
+            this.elementConversationLoading.value = false;
+            this.awaitingIdentityChangeRegather.value = false;
+        }, this.handleInitQualifiedFormElementConversation = (conversation)=>{
+            var _conversation_messages;
+            const offerMessage = conversation == null ? void 0 : (_conversation_messages = conversation.messages) == null ? void 0 : _conversation_messages.find((m)=>m.type === "calendar_event_offer");
+            // "Not you?" in flight: the backend echoes a stale calendar_event_offer just
+            // before the fresh gather. Ignore it so the spinner holds until the
+            // lightbox_gather arrives and shows the email step (see restoreGatherFromOffer).
+            if (offerMessage && this.awaitingIdentityChangeRegather.value) return;
+            if (!offerMessage) {
+                var _conversation_messages_filter, _conversation_messages1;
+                const textMessage = conversation == null ? void 0 : (_conversation_messages1 = conversation.messages) == null ? void 0 : (_conversation_messages_filter = _conversation_messages1.filter((m)=>m.type === "text")) == null ? void 0 : _conversation_messages_filter.at(-1);
+                if (!textMessage) return;
+                this.handleElementConversationTextMessage(textMessage);
+                return;
+            }
+            signals_core_module_r(()=>{
+                this.openMessengerForElementConversation();
+                this.elementConversationLoading.value = false;
+                this.elementConversationOffer.value = offerMessage;
+                this.elementConversationTextMessage.value = null;
+                this.closeLightbox();
+            });
+            this.meetingStore.load();
+        }, this.handleElementConversationTextMessage = (payload)=>{
+            var _ref, _ref1, _ref2;
+            const title = (_ref = payload == null ? void 0 : payload.title) != null ? _ref : "";
+            const text = (_ref1 = payload == null ? void 0 : payload.text) != null ? _ref1 : "";
+            const buttonText = (_ref2 = payload == null ? void 0 : payload.button_text) != null ? _ref2 : "Done";
+            if (!title && !text) return;
+            signals_core_module_r(()=>{
+                this.openMessengerForElementConversation();
+                this.elementConversationLoading.value = false;
+                this.elementConversationTextMessage.value = {
+                    title,
+                    text,
+                    buttonText
+                };
+                // If the experience ended with text instead of a re-gather, stop waiting.
+                this.awaitingIdentityChangeRegather.value = false;
+            });
+        }, this.handleInitState = (initialState)=>{
+            // Ignore any state changes just set the reconnecting flag this ensures the next initState will be handled correctly.
+            if (initialState.isReconnecting) {
+                this.isReconnecting.value = true;
+                return;
+            }
+            this.dockingStore.cancelAbort();
+            this.initialized.value = true;
+            metrics.multimodal.timeToInit.log();
+            signals_core_module_r(()=>{
+                var _ref, _initialState_formJoinIdUnique, _initialState_multimodalModalityPreference, _initialState_conversationModeFailover, _initialState_dailyCallObjectBundleUrl, _initialState_dailyWsProxyUrl;
+                var _initialState_themeConfig, _initialState_themeConfig1, _initialState_themeConfig2;
+                // Clear any loading overlay now that the widget has fully initialised.
+                this.closeLightbox();
+                if (initialState.companyName) {
+                    this.companyName.value = initialState.companyName;
+                }
+                if (initialState.disableTitleFlash != null) {
+                    this.disableTitleFlash.value = initialState.disableTitleFlash;
+                }
+                if (initialState.hasCustomVoiceGreeting !== undefined) {
+                    this.hasCustomVoiceGreeting = initialState.hasCustomVoiceGreeting;
+                }
+                if (initialState.conversations) {
+                    this.conversations.value = initialState.conversations;
+                }
+                if (initialState.agentsAvailable) {
+                    this.agentsAvailable.value = initialState.agentsAvailable;
+                }
+                if (initialState.messages) {
+                    const mergedServerMessages = initialState.messages.map((incoming)=>{
+                        const existing = this.messages.value.find((m)=>m.id === incoming.id);
+                        return existing ? this.mergeMessage(existing, incoming) : incoming;
+                    });
+                    this.messages.value = mergedServerMessages;
+                    this.handleLastInitStateMessage(initialState.messages);
+                    // Track pounce response time: start timer when the experience has started
+                    // (startChatBot present) but the pounce hasn't arrived yet. Skipped on
+                    // page reloads where the pounce is already in the initial messages.
+                    //
+                    // Not every startChatBot leads to a pounce. Generation is blocked when
+                    // proactive pounce is not configured, the visitor replied before the
+                    // pounce was created, or the pounce was dismissed. In those cases the
+                    // timer is set but never consumed — no metric is emitted.
+                    //
+                    // NOTE: If a visitor has multiple tabs open and the second tab connects
+                    // before the pounce arrives, both tabs will emit the metric. This is
+                    // acceptable for a P95 distribution — the duplication window is narrow
+                    // and multi-tab is rare.
+                    if (this.activeConversationAwaitsPounce() && this.featureFlags.piperXAgent) {
+                        this.pounceResponseStartTimestamp = performance.now();
+                    }
+                }
+                if (initialState.pounceCandidates !== undefined) {
+                    var _initialState_pounceCandidates;
+                    this.pounceCandidates.value = (_initialState_pounceCandidates = initialState.pounceCandidates) != null ? _initialState_pounceCandidates : null;
+                }
+                if (this.messages.pounceActive.value) {
+                    this.startPounceTracking();
+                }
+                const formJoinIDUnique = (_ref = (_initialState_formJoinIdUnique = initialState.formJoinIdUnique) != null ? _initialState_formJoinIdUnique : (_initialState_themeConfig = initialState.themeConfig) == null ? void 0 : _initialState_themeConfig.formJoinIDUnique) != null ? _ref : null;
+                if (formJoinIDUnique) {
+                    this.formJoinIDUnique.value = formJoinIDUnique;
+                }
+                if (initialState.themeConfig) {
+                    var _themeConfig_inputPlaceholder, _themeConfig_multimodalHideLauncherLabel;
+                    const { themeConfig } = initialState;
+                    this.inputPlaceholder.value = (_themeConfig_inputPlaceholder = themeConfig.inputPlaceholder) != null ? _themeConfig_inputPlaceholder : null;
+                    this.multimodalHideLauncherLabel.value = (_themeConfig_multimodalHideLauncherLabel = themeConfig.multimodalHideLauncherLabel) != null ? _themeConfig_multimodalHideLauncherLabel : false;
+                    if (themeConfig.formJoinIDUnique != null && this.formJoinIDUnique.value == null) {
+                        this.formJoinIDUnique.value = themeConfig.formJoinIDUnique;
+                    }
+                }
+                this.modalityPreference.value = (_initialState_multimodalModalityPreference = initialState.multimodalModalityPreference) != null ? _initialState_multimodalModalityPreference : null;
+                // Delegate UI-related init to UIStore after server-side modality is available.
+                this.uiStore.handleInitState(initialState);
+                const inputMessage = this.input.message.peek();
+                if (inputMessage) {
+                    this.updateInputMessage(inputMessage);
+                }
+                if ((_initialState_themeConfig1 = initialState.themeConfig) == null ? void 0 : _initialState_themeConfig1.privacyDisclosures) {
+                    this.privacyDisclosures.value = initialState.themeConfig.privacyDisclosures;
+                }
+                if ((_initialState_themeConfig2 = initialState.themeConfig) == null ? void 0 : _initialState_themeConfig2.cookieConsent) {
+                    this.cookieConsent.value = initialState.themeConfig.cookieConsent;
+                }
+                this.flushPendingCookieConsentActions();
+                // Initialize cold start questions
+                if (initialState.coldStartQuestions) {
+                    this.coldStartQuestions.value = initialState.coldStartQuestions;
+                }
+                if (typeof initialState.coldStartVisibleLimit === "number") {
+                    this.coldStartVisibleLimit.value = initialState.coldStartVisibleLimit;
+                }
+                if (typeof initialState.pounceInactivityThresholdMs === "number") {
+                    this.pounceInactivityThresholdMs.value = initialState.pounceInactivityThresholdMs;
+                } else if (initialState.pounceInactivityThresholdMs === null) {
+                    this.pounceInactivityThresholdMs.value = null;
+                }
+                if (initialState.scriptLocale) {
+                    this.translationStore.setScriptLocale(initialState.scriptLocale);
+                }
+                this.updateConversationModeFailover((_initialState_conversationModeFailover = initialState.conversationModeFailover) != null ? _initialState_conversationModeFailover : {
+                    voiceDisabled: false,
+                    videoDisabled: false
+                });
+                this.dailyCallObjectBundleUrl.value = (_initialState_dailyCallObjectBundleUrl = initialState.dailyCallObjectBundleUrl) != null ? _initialState_dailyCallObjectBundleUrl : null;
+                this.dailyWsProxyUrl.value = (_initialState_dailyWsProxyUrl = initialState.dailyWsProxyUrl) != null ? _initialState_dailyWsProxyUrl : null;
+                if (this.chatViewDeferredUserIntent) {
+                    this.emitChatViewIfEligible({
+                        fromUserIntent: true
+                    });
+                }
+                if (!this.displayMode.minimized.peek()) {
+                    this.markMessagesAsRead();
+                }
+            });
+            this.submitInitialDisplayMode();
+            this.submitInitialModality();
+            this.submitInitialMessage();
+            this.armBookerIntentFromHistory();
+            this.isReconnecting.value = false;
+        }, this.clearElementConversationState = ()=>{
+            signals_core_module_r(()=>{
+                this.elementConversation.value = null;
+                this.elementConversationOffer.value = null;
+                this.elementConversationTextMessage.value = null;
+                this.elementConversationLoading.value = false;
+                this.awaitingIdentityChangeRegather.value = false;
+            });
+        }, this.handleStateUpdate = (stateUpdate)=>{
+            signals_core_module_r(()=>{
+                if (typeof stateUpdate.agentsAvailable === "boolean") {
+                    this.agentsAvailable.value = stateUpdate.agentsAvailable;
+                }
+                if (stateUpdate.pounceCandidates !== undefined) {
+                    var _stateUpdate_pounceCandidates;
+                    this.pounceCandidates.value = (_stateUpdate_pounceCandidates = stateUpdate.pounceCandidates) != null ? _stateUpdate_pounceCandidates : null;
+                }
+                if (stateUpdate.hasCustomVoiceGreeting !== undefined) {
+                    this.hasCustomVoiceGreeting = stateUpdate.hasCustomVoiceGreeting;
+                }
+                if (stateUpdate.conversations) {
+                    stateUpdate.conversations.forEach((conversation)=>{
+                        this.updateConversation(conversation);
+                    });
+                }
+                if (stateUpdate.coldStartQuestions) {
+                    this.coldStartQuestions.value = stateUpdate.coldStartQuestions;
+                }
+                // A multimodal experience that starts after a delay broadcasts a stateUpdate with
+                // its resolved starting state. Re-apply it so the widget opens in the correct mode
+                // and with the correct profile assets rather than the fallbacks baked in at init.
+                if (stateUpdate.multimodalModalityPreference !== undefined) {
+                    var _stateUpdate_multimodalModalityPreference;
+                    this.modalityPreference.value = (_stateUpdate_multimodalModalityPreference = stateUpdate.multimodalModalityPreference) != null ? _stateUpdate_multimodalModalityPreference : null;
+                }
+                this.uiStore.applyMultimodalStartState(stateUpdate);
+            });
+        }, this.handleMessage = (incomingMessage)=>{
+            const existingMessage = this.messages.value.find((message)=>message.id === incomingMessage.id);
+            if (existingMessage) {
+                this.handleExistingMessage(existingMessage, incomingMessage);
+                return;
+            }
+            const clientMessageIndex = this.messages.value.findIndex((message)=>message.id === incomingMessage.clientId);
+            // Play audio for text messages
+            if (incomingMessage.type === "text") {
+                this.playMessageAudio(incomingMessage);
+            }
+            signals_core_module_r(()=>{
+                if (incomingMessage.conversation) {
+                    this.updateConversation(incomingMessage.conversation);
+                }
+                if (isEventMessage(incomingMessage, "startChatBot") && this.pounceResponseStartTimestamp === null && this.featureFlags.piperXAgent) {
+                    this.pounceResponseStartTimestamp = performance.now();
+                } else if (incomingMessage.isPounce && this.pounceResponseStartTimestamp !== null) {
+                    const deltaMs = performance.now() - this.pounceResponseStartTimestamp;
+                    metrics.emitTiming("multimodal_first_pounce_ms", deltaMs);
+                    this.pounceResponseStartTimestamp = null;
+                }
+                if (isAssistantMessage(incomingMessage) && !incomingMessage.isPounce && this.lastVisitorMessageSentAt !== null && !this.turnReplyHandled) {
+                    this.clearResponseTimeout();
+                    const deltaMs = performance.now() - this.lastVisitorMessageSentAt;
+                    const withinBudget = deltaMs <= (/* inlined export .RESPONSE_BUDGET_MS */25000);
+                    const obscured = this.turnObscured || this.isDocumentHidden();
+                    // Within budget the wait is short enough to trust regardless of visibility;
+                    // over budget we only trust the timing if the tab stayed foreground,
+                    // since a hidden tab can throttle delivery.
+                    if (withinBudget || !obscured) {
+                        metrics.emitTiming("multimodal_text_response_ms", deltaMs, {
+                            call_active: this.turnCallActiveTag,
+                            has_tool_call: this.turnHasToolCall ? "true" : "false"
+                        });
+                    }
+                    if (!this.turnCounterEmitted) {
+                        var _this_turnCause;
+                        const status = withinBudget ? "success" : obscured ? "backgrounded" : "timeout";
+                        metrics.emitIncrement("multimodal_text_response", _extends({
+                            status,
+                            call_active: this.turnCallActiveTag
+                        }, status === "timeout" ? {
+                            cause: (_this_turnCause = this.turnCause) != null ? _this_turnCause : "unknown"
+                        } : {}));
+                        this.turnCounterEmitted = true;
+                    } else {
+                        // The 25s timer already fired and counted this turn as a timeout.
+                        // Log the late reply so we can distinguish "AI responded slowly" from
+                        // "reply never arrived" when investigating timeout events.
+                        serverLogger.serverLog({
+                            type: "log",
+                            message: "Multimodal text reply arrived after response budget (late)",
+                            extra: {
+                                context: "elapsed_ms:" + Math.round(deltaMs)
+                            }
+                        });
+                    }
+                    this.turnReplyHandled = true;
+                    this.turnToken++;
+                }
+                this.addMessage(incomingMessage, clientMessageIndex);
+                if (isAssistantMessage(incomingMessage)) {
+                    this.setTypingIndicator(false);
+                    this.markIncomingMessageAsRead(incomingMessage);
+                }
+                this.handleIncomingMessage(incomingMessage);
+            });
+        }, this.handleExistingMessage = (existingMessage, incomingMessage)=>{
+            // Capture before updateMessage mutates existingMessage in place.
+            // In voice mode the CalendarEventOffer starts hidden (showCalendarEventOfferUi: false)
+            // until the voice placeholder is filled. When it transitions to visible we delay
+            // showing the meeting booker so the visitor can read the transcript first.
+            const wasHiddenByPlaceholder = existingMessage.type === "calendar_event_offer" && existingMessage.showCalendarEventOfferUi === false;
+            signals_core_module_r(()=>{
+                this.updateMessage(existingMessage, incomingMessage);
+                this.markIncomingMessageAsRead(incomingMessage);
+                this.handleIncomingMessage(incomingMessage, {
+                    wasHiddenByPlaceholder
+                });
+            });
+        }, this.markIncomingMessageAsRead = (incomingMessage)=>{
+            if (isAssistantMessage(incomingMessage) && !this.displayMode.minimized.value && (!isStreamableMessage(incomingMessage) || !this.isMessageStreamingEnabled.value)) {
+                this.markMessagesAsRead([
+                    incomingMessage
+                ]);
+            }
+        }, this.handleIncomingMessage = (incomingMessage, param)=>{
+            let { wasHiddenByPlaceholder = false } = param === void 0 ? {} : param;
+            switch(incomingMessage.type){
+                case "calendar_event_offer":
+                    // Closes the pre-offer SLI here, at message *receipt*, which is where the
+                    // metric is defined to end. Resolving it off `activeOfferMessage` instead
+                    // would fold in client-side delay: that subscription waits on the lazy
+                    // `meetingStore` import, and the voice-placeholder path below defers it a
+                    // further second — neither of which is time the visitor spent waiting for
+                    // an offer.
+                    //
+                    // Only an AI-authored offer closes an AI intent. The client is never told
+                    // when the server decided *not* to offer (`no_offer` lives only in the
+                    // tool's `decision_outcome`), so a rejected intent stays armed — and a
+                    // later offer from a rep or a form would otherwise report `offered`
+                    // against it, giving one journey two terminal outcomes and inflating the
+                    // offer-made rate. `auto_respond` is the same discriminator
+                    // `bookerPathwayOrigin` uses to tell `ai_agent` from `chat`, and both AI
+                    // paths stamp it (Goals inline, Foundry via the deferred offer). Checked
+                    // directly rather than through that helper, which resolves `element`
+                    // conversations to `form` first and so would miss an AI offer made inside
+                    // one.
+                    if (isAiAuthoredOffer(incomingMessage.source)) {
+                        var _incomingMessage_calendarEventTypeId;
+                        this.bookerIntentTracker.markOffered(incomingMessage.id, {
+                            calendarEventTypeId: (_incomingMessage_calendarEventTypeId = incomingMessage.calendarEventTypeId) == null ? void 0 : _incomingMessage_calendarEventTypeId.toString()
+                        });
+                    }
+                    if (incomingMessage.showCalendarEventOfferUi !== false) {
+                        // When transitioning from hidden to visible (voice placeholder just
+                        // filled), delay showing the meeting booker so the visitor has time
+                        // to read the transcript text that appeared in the placeholder.
+                        void this.queueArtifactMessage(incomingMessage, {
+                            delayMs: wasHiddenByPlaceholder ? RootStore.MEETING_BOOKER_PLACEHOLDER_DELAY_MS : 0
+                        });
+                    }
+                    break;
+                case "field_request":
+                    if (incomingMessage.showFieldUi) {
+                        this.updateInputMessage(incomingMessage);
+                    }
+                    break;
+                case "field_entry":
+                    if (!this.conversationMode.text.value) {
+                        this.clearInputMessage({
+                            when: types_InputState.FIELD_REQUEST
+                        });
+                    }
+                    break;
+                case "present_content":
+                case "present_video":
+                case "present_deck":
+                case "navigate_content":
+                    void this.queueArtifactMessage(incomingMessage);
+                    break;
+                case "point_cursor":
+                    {
+                        const { x, y, rect, nodeId, textSnippet } = incomingMessage;
+                        this.websiteNavigationStore.load().then((store)=>{
+                            // x/y => point at a spot on the slide/video image; otherwise anchor to a page element by node-id.
+                            if (x != null && y != null) {
+                                store.pointAtSlide(x, y, rect != null ? rect : null);
+                            } else {
+                                store.pointAtNode(nodeId != null ? nodeId : null, textSnippet);
+                            }
+                        });
+                        break;
+                    }
+                case "event":
+                    if (incomingMessage.eventType === "hide_artifact") {
+                        this.artifactStore.hideArtifact(incomingMessage.artifactMessageId);
+                    }
+                    if (incomingMessage.eventType === "waiting") {
+                        this.waitingStore.load().then((store)=>store.handleWaitingMessage(incomingMessage));
+                    }
+                    if (incomingMessage.eventType === CAN_OFFER_MEETING_BOOKER_EVENT_TYPE) {
+                        this.armBookerIntent(incomingMessage.id, {
+                            scriptId: incomingMessage.scriptId
+                        });
+                    }
+                    break;
+                case "system":
+                    {
+                        const { eventType } = incomingMessage;
+                        // if we are  in an active call and a rep joins, coffee will signal to us to switch over to text
+                        if (eventType === "participant_joined" && !this.getCallUiAdapter().state.isInCall.peek()) {
+                            this.setConversationMode(types_ConversationMode.TEXT);
+                        }
+                        break;
+                    }
+                default:
+                    break;
+            }
+        }, this.handleMessageRead = (messageId)=>{
+            const message = this.messages.value.find((m)=>m.id === messageId);
+            if (message && !message.isRead) {
+                this.updateMessage(message, {
+                    isRead: true
+                });
+            }
+        }, this.handleBotProcessEnded = ()=>{
+            var _this_waitingStore_value;
+            if (this.messages.hasStartChatBotEvent.peek() || ((_this_waitingStore_value = this.waitingStore.value) == null ? void 0 : _this_waitingStore_value.isWaiting.value)) {
+                return;
+            }
+            this.setTypingIndicator(false);
+        }, // Helpers
+        /**
+    * Scans init state messages from the end to find the last message that needs
+    * to be handled (e.g. an unreplied field_request or an unresolved waiting event).
+    * Only the first match is handled, ensuring a single call to handleIncomingMessage.
+    */ this.handleLastInitStateMessage = (messages)=>{
+            const matchers = [
+                // Unreplied field_request from an assistant
+                (m)=>m.type === "field_request" && m.showFieldUi === true && !this.messages.repliedToIds.value.has(m.id),
+                // Active (unresolved) waiting event
+                (m)=>isEventMessage(m, "waiting") && !this.messages.repliedToIds.value.has(m.id)
+            ];
+            for(let i = messages.length - 1; i >= 0; i--){
+                const message = messages[i];
+                if (matchers.some((matcher)=>matcher(message))) {
+                    this.handleIncomingMessage(message);
+                    return;
+                }
+            }
+        }, /**
+    * Inject a client-only text message into the active conversation. Renders as a
+    * normal (non-own) text bubble, not a SystemMessage. Used for transient UI notices
+    * (e.g. graceful degradation when voice/video is unavailable). Not persisted server-side.
+    */ this.displayLocalNotice = (text)=>{
+            var _this_activeConversation_value;
+            const conversationId = (_this_activeConversation_value = this.activeConversation.value) == null ? void 0 : _this_activeConversation_value.id;
+            if (!conversationId) return;
+            this.addMessage({
+                id: "local-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8),
+                type: "text",
+                text,
+                isOwn: false,
+                conversationId,
+                createdAt: new Date().toISOString()
+            });
+        }, this.addMessage = (message, index)=>{
+            if (index !== undefined && index >= 0) {
+                this.messages.value[index] = message;
+                this.messages.value = [
+                    ...this.messages.value
+                ];
+            } else {
+                this.messages.value = [
+                    ...this.messages.value,
+                    message
+                ];
+            }
+        }, this.firstSystemMessageReceived = false, this.playMessageAudio = (message)=>{
+            if (this.featureFlags.disableMessengerSounds) return;
+            if (this.getCallUiAdapter().state.isInCall.peek()) {
+                // Don't play audio if we're in a call
+                return;
+            }
+            if (message.isOwn) {
+                playAudio(message_sent_namespaceObject);
+            } else if (!this.firstSystemMessageReceived) {
+                playAudio(message_initial_namespaceObject);
+                this.firstSystemMessageReceived = true;
+            } else {
+                playAudio(message_received_namespaceObject);
+            }
+        }, this.updateConversation = (conversation)=>{
+            this.conversations.value = this.conversations.value.map((c)=>c.id === conversation.id ? conversation : c);
+        }, /**
+    * Arms the pre-offer booker SLI for the AI pathway.
+    *
+    * `pathway_origin` is the literal `ai_agent` rather than the derivation the
+    * post-offer tracker uses: that derivation reads the offer's `source`, and at
+    * intent there is no offer yet — it would silently classify every AI intent as
+    * `chat`. This signal *is* the AI deciding to offer.
+    */ this.armBookerIntent = (intentId, param)=>{
+            let { scriptId, fromHistory = false } = param === void 0 ? {} : param;
+            var _ref;
+            var _this_activeConversation_peek;
+            // Gated at arm rather than at emit: with nothing armed the tracker holds no
+            // state and its listeners are never attached, so the feature costs nothing
+            // when off. Does not affect the already-live `booker_outcome` stream, which
+            // `meeting_store` emits independently.
+            if (!this.featureFlags.bookerJourneySLI) return;
+            this.bookerIntentTracker.arm({
+                intentId,
+                pathwayOrigin: BOOKER_PATHWAY_ORIGIN.AI_AGENT,
+                conversationType: (_ref = (_this_activeConversation_peek = this.activeConversation.peek()) == null ? void 0 : _this_activeConversation_peek.type) != null ? _ref : "chat",
+                scriptId,
+                fromHistory
+            });
+        }, /**
+    * Re-arms the pre-offer SLI after a reload that lands mid-wait: the intent
+    * event is already in the hydrated history, so the live `case "event"` path
+    * never sees it and the wait would go unmeasured.
+    *
+    * Armed as `fromHistory`, which reports it far more conservatively: no timings
+    * (the intent moment belongs to a previous JS context) and never
+    * `abandoned_pre_offer`. Absence of a later offer does not prove the intent is
+    * still pending — a rejected server-side decision leaves exactly this shape,
+    * since `no_offer` never reaches the client — so abandoning here would
+    * double-count that journey against the server's own `no_offer`. `offered` is
+    * the one transition this path can claim unambiguously.
+    */ this.armBookerIntentFromHistory = ()=>{
+            const messages = this.messages.peek();
+            const intentIndex = messages.findLastIndex((message)=>message.type === "event" && message.eventType === CAN_OFFER_MEETING_BOOKER_EVENT_TYPE);
+            if (intentIndex === -1) return;
+            const intentMessage = messages[intentIndex];
+            // If the offer this intent asked for already arrived, the wait is over.
+            // Arming anyway would emit a second `offered` for an offer no one waited on.
+            //
+            // Matched on AI-authored offers only, the same test the live path applies. A
+            // rep can offer a meeting while the AI's own offer is still being prepared, and
+            // treating that as the intent's answer would abandon a wait that is still
+            // running and drop the journey from the SLI entirely. Arming when the AI never
+            // does answer is harmless: a hydrated intent cannot report abandonment.
+            const offerArrived = messages.slice(intentIndex + 1).some((message)=>message.type === "calendar_event_offer" && isAiAuthoredOffer("source" in message ? message.source : undefined));
+            if (offerArrived) return;
+            this.armBookerIntent(intentMessage.id, {
+                // An index cannot carry the narrowing out of the predicate above, and the
+                // optimistic (not-yet-persisted) message variants carry no server fields at
+                // all, so this probes for the field rather than asserting it away.
+                scriptId: "scriptId" in intentMessage ? intentMessage.scriptId : undefined,
+                fromHistory: true
+            });
+        }, this.submitInitialDisplayMode = ()=>{
+            const hasStartingDisplayModeMessage = !!this.messages.peek().find((message)=>message.type === "event" && message.eventType === "startingDisplayMode");
+            if (!hasStartingDisplayModeMessage) {
+                this.sendMessage({
+                    type: "event",
+                    eventType: "startingDisplayMode"
+                });
+            }
+        }, this.submitInitialModality = ()=>{
+            const hasStartingModalityMessage = !!this.messages.peek().find((message)=>message.type === "event" && message.eventType === "startingModality");
+            if (hasStartingModalityMessage) return;
+            const modality = this.modalityPreference.peek();
+            if (!modality) return;
+            this.sendMessage({
+                type: "event",
+                eventType: "startingModality",
+                multimodalStartingModality: modality
+            });
+        }, this.submitInitialMessage = ()=>{
+            var _this_activeConversation_peek;
+            const initialMessage = (_this_activeConversation_peek = this.activeConversation.peek()) == null ? void 0 : _this_activeConversation_peek.initialMessage;
+            if (!initialMessage) return;
+            const hasVisitorText = this.getActiveConversationMessages().some((m)=>m.type === "text" && "isOwn" in m && m.isOwn);
+            if (!hasVisitorText) {
+                this.sendVisitorText(initialMessage);
+            }
+        }, this.getActiveConversationMessages = ()=>{
+            var _this_activeConversation_peek;
+            const conversationId = (_this_activeConversation_peek = this.activeConversation.peek()) == null ? void 0 : _this_activeConversation_peek.id;
+            if (!conversationId) return [];
+            return this.messages.value.filter((m)=>m.conversationId === conversationId);
+        }, this.activeConversationAwaitsPounce = ()=>{
+            let pastStartChatBot = false;
+            for (const m of this.getActiveConversationMessages()){
+                if (isEventMessage(m, "startChatBot")) {
+                    pastStartChatBot = true;
+                } else if (pastStartChatBot && m.type !== "event") {
+                    return false;
+                }
+            }
+            return pastStartChatBot;
+        }, this.debugLog = (msg, context)=>{
+            if (isDebugMode()) {
+                // eslint-disable-next-line no-console
+                console.log("[Multimodal - RootStore] " + msg, context);
+            }
+        }, this.startPounceTracking = ()=>{
+            if (this.pounceTrackingLoadStarted) {
+                return;
+            }
+            this.pounceTrackingLoadStarted = true;
+            this.pounceTrackingStore.load().then((pounceTrackingStore)=>{
+                if (this.messages.pounceActive.peek()) {
+                    pounceTrackingStore.startTracking();
+                } else {
+                    pounceTrackingStore.dispose();
+                    this.pounceTrackingLoadStarted = false;
+                }
+            }).catch(()=>{
+                this.pounceTrackingLoadStarted = false;
+            // Pounce tracking is non-critical - fail silently
+            });
+        };
+        // WS message handlers
+        for (const [event, handler] of Object.entries(this.messageHandlers)){
+            this.channel.on(event, handler);
+        }
+        // Effect handlers
+        for (const handler of this.signalSubscriptions){
+            handler();
+        }
+        // Initialize translation store (sets up locale effects)
+        this.translationStore.initialize();
+        if (typeof document !== "undefined") {
+            __nativeDocumentAddEventListener("visibilitychange", this.handleTurnVisibilityChange);
+        }
+    }
+}
+RootStore.IMPRESSED_MESSAGE_IDS_MAX_SIZE = 100;
+/**
+   * How long the booker waits when the offer arrives by way of a voice
+   * placeholder, so the visitor can read the transcript text that just filled it
+   * before the overlay covers the page.
+   */ RootStore.MEETING_BOOKER_PLACEHOLDER_DELAY_MS = 1000;
+// Kept in sync with MultimodalAgentWorker#broadcast_text_response_ended.
+RootStore.TEXT_RESPONSE_ENDED_REASONS = [
+    "suppressed",
+    "blank_output"
+];
+// Kept in sync with AiConversations::TurnCause::CAUSES.
+RootStore.TURN_CAUSES = [
+    "queue_wait",
+    "setup",
+    "llm_slow",
+    "agent_loop",
+    "tool_slow",
+    "side_llm_wait",
+    "generation_failed",
+    "output_moderation_retry",
+    "unknown"
+];
+const RootStoreContext = Q(null);
+/**
+ * Please avoid using this hook as much as possible!!!
+ * It makes components harder to test and work with.
+ */ function useRootStore() {
+    return hooks_module_x(RootStoreContext);
+}
+
+var root_store_CAUSE_REPORT_GRACE_MS = (/* inlined export .CAUSE_REPORT_GRACE_MS */1500);
+var root_store_RESPONSE_BUDGET_MS = (/* inlined export .RESPONSE_BUDGET_MS */25000);
+export { RootStore, RootStoreContext, root_store_CAUSE_REPORT_GRACE_MS as CAUSE_REPORT_GRACE_MS, root_store_RESPONSE_BUDGET_MS as RESPONSE_BUDGET_MS, useRootStore };