@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/multimodal_channel.js

@@ -0,0 +1,195 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { esm_browser_v4 } from "../../js/4101.js";
+import "../telemetry/index.js";
+import { getSentryClient } from "../widget/sentry.js";
+import { Disposable } from "../../src/mixins/disposable.js";
+import { createBetterPromise } from "../../src/promises.js";
+import "../utils/native_globals.js";
+import { metrics } from "../telemetry/metrics.js";
+
+const tiny_emitter = __webpack_require__("47441");
+/* provided dependency */ var multimodal_channel_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var multimodal_channel_setTimeout = __webpack_require__(68034).pS;
+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;
+}
+
+
+
+
+
+
+const PERFORM_TIMEOUT = 30000;
+const ACTION_PREFIX = "__action__";
+const SUPPORTED_EVENTS = [
+    "initState",
+    "stateUpdate",
+    "message",
+    "messageRead",
+    "typingStarted",
+    "typingEnded",
+    "visitorBlocked",
+    "visitorUnblocked",
+    "botProcessEnded",
+    "textResponseEnded",
+    "textTurnDiagnostics",
+    "callEnded",
+    "toolCallStarted",
+    "toolCallCompleted",
+    "coffeeStateUpdate",
+    "open"
+];
+const FORWARDED_EVENTS = [
+    "botProcessEnded"
+];
+class MultimodalChannel extends Disposable(Object) {
+    cleanup() {
+        this.channel.off("multimodal", this.eventHandler);
+    }
+    on(event, listener) {
+        return this._emitter.on(event, listener);
+    }
+    once(event, listener) {
+        return this._emitter.once(event, listener);
+    }
+    off(event, listener) {
+        return this._emitter.off(event, listener);
+    }
+    perform(action, data) {
+        const id = esm_browser_v4();
+        const event = "" + action + ":response";
+        const promise = createBetterPromise();
+        let timeoutId = null;
+        const listener = (_0)=>{
+            let { __id } = _0, result = _object_without_properties_loose(_0, [
+                "__id"
+            ]);
+            if (__id !== id) return;
+            settle(result);
+        };
+        const timeoutCallback = ()=>{
+            var _getSentryClient, _this_widget_config_featureFlags;
+            const error = new Error("Timeout waiting for " + event + " with id " + id);
+            (_getSentryClient = getSentryClient({
+                project: "multimodal"
+            })) == null ? void 0 : _getSentryClient.captureException(error);
+            if ((_this_widget_config_featureFlags = this.widget.config.featureFlags) == null ? void 0 : _this_widget_config_featureFlags.piperXAgent) {
+                metrics.emitIncrement("multimodal_client_error");
+            }
+            settle({
+                error: {
+                    message: error.message
+                }
+            });
+        };
+        const settle = (result)=>{
+            this.channel.off(event, listener);
+            if (timeoutId) multimodal_channel_clearTimeout(timeoutId);
+            if (result.error) {
+                this.widget.serverLog({
+                    type: "log",
+                    message: "Perform action " + event + " failed with error " + result.error.message
+                });
+            }
+            promise.resolve(result);
+        };
+        this.channel.on(event, listener);
+        this.channel.perform("" + ACTION_PREFIX + action, _extends({}, data, {
+            __id: id
+        }));
+        timeoutId = multimodal_channel_setTimeout(timeoutCallback, PERFORM_TIMEOUT);
+        return promise;
+    }
+    /**
+   * Emit a piper web tracking event locally so Analytics can push it to GTM.
+   * Use for client-originated events (e.g. content click, link click).
+   */ emitPiperWebTrackingEvent(payload) {
+        this.channel.emit("received", "piperWebTrackingEvent", payload);
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(widget){
+        super(), this.widget = widget, // first one). Replaces the old one-way `initStateReceived` latch so we can
+        // detect a switch in either direction — e.g. another tab flips the shared
+        // session to the other experience — and tear down the outgoing messenger.
+        this.currentMode = null, this.eventHandler = (message)=>{
+            if (this.currentMode === "new" && message.event === "initState" && message.payload.isReconnecting) {
+                // We need to ignore the payload as it can be invalid due to the reconnecting state.
+                // Directly emit the event to the multimodal channel so that it handles the reconnecting state.
+                this._emitter.emit(message.event, message.payload);
+                return;
+            }
+            if (message.event === "initState") {
+                var _this_widget_multimodal;
+                const nextMode = message.payload.useNewMessengerStyling ? "new" : "legacy";
+                const prevMode = this.currentMode;
+                this.currentMode = nextMode;
+                // Tell the composite adapter which layer owns the session so visible-behavior
+                // verbs/getters route to it. Signalled on every initState (both directions)
+                // — the initial-new case below skips hideLegacyMessenger, so ownership can't
+                // be inferred from that call alone.
+                this.widget.setMultimodalOwnsSession(nextMode === "new");
+                if (nextMode === "legacy") {
+                    var _window_qualified_docking, _window_qualified;
+                    (_window_qualified = window.qualified) == null ? void 0 : (_window_qualified_docking = _window_qualified.docking) == null ? void 0 : _window_qualified_docking.disable();
+                    // Legacy now owns the session: tear down the multimodal UI so it stops
+                    // rendering over the legacy messenger. (Initial legacy sessions skip this.)
+                    if (prevMode === "new") {
+                        var _this_widget_multimodal1;
+                        (_this_widget_multimodal1 = this.widget.multimodal) == null ? void 0 : _this_widget_multimodal1.teardownUI();
+                    }
+                    // Restore the legacy iframe in case an earlier switch had hidden it.
+                    this.widget.showLegacyMessenger();
+                    this.channel.emit("received", message.event, message.payload);
+                    return;
+                }
+                // Multimodal now owns the session.
+                if (prevMode === "legacy") {
+                    // Hide the legacy iframe so its stale UI (e.g. a pounce bubble) doesn't
+                    // show alongside the multimodal messenger.
+                    this.widget.hideLegacyMessenger();
+                }
+                (_this_widget_multimodal = this.widget.multimodal) == null ? void 0 : _this_widget_multimodal.ensureUI();
+                // Re-bind the events bridge to the (possibly freshly rebuilt) RootStore so
+                // events + visible-behavior verbs never target a disposed store. Must run
+                // AFTER ensureUI() creates the new store; idempotent, so the initial-new
+                // case (bridge already bound at init) is a harmless no-op re-bind.
+                this.widget.bindMultimodalEventsBridge();
+            }
+            if (this.currentMode === "new" && SUPPORTED_EVENTS.includes(message.event)) {
+                this._emitter.emit(message.event, message.payload);
+                if (FORWARDED_EVENTS.includes(message.event)) {
+                    this.channel.emit("received", message.event, message.payload);
+                }
+            } else {
+                this.channel.emit("received", message.event, message.payload);
+            }
+        };
+        this.channel = widget.channel;
+        this._emitter = new tiny_emitter.TinyEmitter();
+        this.channel.on("multimodal", this.eventHandler);
+    }
+}
+
+export { MultimodalChannel };

package/widget/multimodal_v2/signals/active_conversation_signal.js

@@ -0,0 +1,33 @@
+import { signals_core_module_w } from "../../../js/multimodal_v2.js";
+
+
+function createActiveConversationSignal(conversations) {
+    const activeConversation = signals_core_module_w(()=>getActiveConversation(conversations.value));
+    const aiSdr = signals_core_module_w(()=>{
+        var _ref;
+        var _activeConversation_value;
+        return (_ref = (_activeConversation_value = activeConversation.value) == null ? void 0 : _activeConversation_value.aiSdr) != null ? _ref : null;
+    });
+    const user = signals_core_module_w(()=>{
+        var _ref;
+        var _activeConversation_value;
+        return (_ref = (_activeConversation_value = activeConversation.value) == null ? void 0 : _activeConversation_value.user) != null ? _ref : null;
+    });
+    const aiStrategyButtonCtas = signals_core_module_w(()=>{
+        var _ref;
+        var _activeConversation_value;
+        return user.value ? [] : (_ref = (_activeConversation_value = activeConversation.value) == null ? void 0 : _activeConversation_value.aiStrategyButtonCtas) != null ? _ref : [];
+    });
+    return Object.assign(activeConversation, {
+        aiSdr,
+        user,
+        aiStrategyButtonCtas
+    });
+}
+/** Finds the first active (non-ended) chat conversation from a plain array. */ function getActiveConversation(conversations) {
+    var _conversations_find;
+    return (_conversations_find = conversations.find((conversation)=>conversation.type === "chat" && conversation.endedAt == null)) != null ? _conversations_find : null;
+}
+
+var active_conversation_signal_getActiveConversation = /* unused export */ undefined;
+export { active_conversation_signal_getActiveConversation as getActiveConversation, createActiveConversationSignal };

package/widget/multimodal_v2/signals/allowed_conversation_mode_signal.js

@@ -0,0 +1,38 @@
+import { signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { ConversationMode as types_ConversationMode } from "../types.js";
+
+
+
+function createAllowedConversationModeSignal(rootStore) {
+    const allowedConversationModes = signals_core_module_w(()=>{
+        const modes = [
+            types_ConversationMode.TEXT
+        ];
+        const { piperXAgentAvatar, piperXAgentVoice } = rootStore.featureFlags;
+        const { voiceDisabled, videoDisabled } = rootStore.conversationModeFailover.value;
+        const modality = rootStore.modalityPreference.value;
+        const voiceEnabled = piperXAgentVoice || piperXAgentAvatar;
+        const videoEnabled = piperXAgentAvatar;
+        // When a modality preference is set, restrict available modes to the chosen one.
+        // Failover flags still take precedence and can further restrict what's allowed.
+        // "text" modality means voice/video are intentionally suppressed — TEXT is always in modes.
+        // A mid-call video failover (avatar died) turns a video experience into a voice one.
+        const effectiveModality = modality === "video" && videoDisabled ? "voice" : modality;
+        if (effectiveModality === "video") {
+            if (videoEnabled && !videoDisabled) modes.push(types_ConversationMode.VIDEO);
+        } else if (effectiveModality === "voice") {
+            if (voiceEnabled && !voiceDisabled) modes.push(types_ConversationMode.VOICE);
+        } else if (effectiveModality !== "text") {
+            if (voiceEnabled && !voiceDisabled) modes.push(types_ConversationMode.VOICE);
+            if (videoEnabled && !videoDisabled) modes.push(types_ConversationMode.VIDEO);
+        }
+        return modes;
+    });
+    return Object.assign(allowedConversationModes, {
+        video: signals_core_module_w(()=>allowedConversationModes.value.includes(types_ConversationMode.VIDEO)),
+        voice: signals_core_module_w(()=>allowedConversationModes.value.includes(types_ConversationMode.VOICE)),
+        text: signals_core_module_w(()=>allowedConversationModes.value.includes(types_ConversationMode.TEXT))
+    });
+}
+
+export { createAllowedConversationModeSignal };

package/widget/multimodal_v2/signals/artifact_signal.js

@@ -0,0 +1,22 @@
+import { signals_core_module_w } from "../../../js/multimodal_v2.js";
+
+
+function createArtifactSignal(rootStore, uiState) {
+    const messageId = signals_core_module_w(()=>uiState.value.artifactMessageId);
+    const message = signals_core_module_w(()=>{
+        var _rootStore_messages_value_find;
+        if (!messageId.value) return null;
+        const found = (_rootStore_messages_value_find = rootStore.messages.value.find((m)=>m.id === messageId.value)) != null ? _rootStore_messages_value_find : null;
+        if (!found) return null;
+        if (found.type === "present_content" || found.type === "present_video" || found.type === "present_deck" || found.type === "calendar_event_offer") {
+            return found;
+        }
+        return null;
+    });
+    return {
+        messageId,
+        message
+    };
+}
+
+export { createArtifactSignal };

package/widget/multimodal_v2/signals/layout_signal.js

@@ -0,0 +1,98 @@
+import { signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { isLandscapeNarrow } from "../utils/media_queries.js";
+import { MaximizedState as types_MaximizedState, InputState as types_InputState } from "../types.js";
+
+
+
+
+const CONTAINER_TYPES = [
+    "controls",
+    "toolbar",
+    "multimodal",
+    "preview",
+    "chat",
+    "artifact",
+    "input",
+    "privacy",
+    "launcher"
+];
+// `createLayoutSignal` runs from inside `UIStore`'s constructor (UIStore lazy-
+// reads `this.layout` for its docking subscription), so this factory must not
+// touch any rootStore property whose getter delegates back into `uiStore`
+// (e.g. `rootStore.displayMode`, `rootStore.conversationMode`, `rootStore.input`).
+// Those getters throw at construction time because `rootStore.uiStore` is still
+// the field being initialised. To stay safe, every access goes inside a
+// `computed(...)` callback — computeds defer their body until first read,
+// which is well after rootStore finishes wiring up `this.uiStore`.
+function createLayoutSignal(rootStore) {
+    const root = {
+        visible: signals_core_module_w(()=>!!rootStore.activeConversation.value && (rootStore.messages.hasStartChatBotEvent.value || rootStore.messages.hasShowWidgetEvent.value))
+    };
+    const background = {
+        visible: signals_core_module_w(()=>rootStore.maximizedState.value !== types_MaximizedState.NONE)
+    };
+    const preview = {
+        hidden: signals_core_module_w(()=>!rootStore.messages.preview.visible.value || rootStore.displayMode.opened.value || rootStore.input.state.value === types_InputState.FIELD_REQUEST && rootStore.displayMode.collapsed.value)
+    };
+    const input = {
+        hidden: signals_core_module_w(()=>rootStore.displayMode.closed.value)
+    };
+    const artifact = {
+        hidden: signals_core_module_w(()=>!rootStore.artifact.message.value)
+    };
+    const chat = {
+        hidden: signals_core_module_w(()=>rootStore.displayMode.minimized.value)
+    };
+    const launcher = {
+        hidden: signals_core_module_w(()=>{
+            if (!rootStore.displayMode.closed.value) return true;
+            const adapter = rootStore.getCallUiAdapter();
+            return adapter.state.isInCall.value || adapter.state.isVideoLoading.value;
+        })
+    };
+    const multimodal = {
+        hidden: signals_core_module_w(()=>{
+            var _rootStore_callStore_value;
+            return rootStore.conversationMode.text.value || rootStore.displayMode.closed.value && !((_rootStore_callStore_value = rootStore.callStore.value) == null ? void 0 : _rootStore_callStore_value.dailyCall.value) || rootStore.displayMode.collapsedCenter.value && !rootStore.conversationMode.video.value;
+        }),
+        usesFlipAnimation: signals_core_module_w(()=>rootStore.conversationMode.video.value || undefined)
+    };
+    const controls = {
+        hidden: signals_core_module_w(()=>!rootStore.displayMode.collapsed.value)
+    };
+    const privacy = {
+        hidden: signals_core_module_w(()=>{
+            var _rootStore_activePrivacyDisclosure_value, _rootStore_privacyDisclosures_value;
+            return !((_rootStore_activePrivacyDisclosure_value = rootStore.activePrivacyDisclosure.value) == null ? void 0 : _rootStore_activePrivacyDisclosure_value.markdown) || rootStore.displayMode.closed.value || ((_rootStore_privacyDisclosures_value = rootStore.privacyDisclosures.value) == null ? void 0 : _rootStore_privacyDisclosures_value.displayMode) === "inline";
+        })
+    };
+    const toolbar = {
+        hidden: signals_core_module_w(()=>rootStore.displayMode.collapsedCenter.value || rootStore.displayMode.closed.value || rootStore.displayMode.collapsedRight.value && rootStore.conversationMode.multimodal.value)
+    };
+    return {
+        root,
+        background,
+        containers: {
+            TYPES: CONTAINER_TYPES,
+            preview,
+            input,
+            privacy,
+            multimodal,
+            toolbar,
+            chat,
+            launcher,
+            artifact,
+            controls
+        },
+        additionalState: {
+            isInCall: signals_core_module_w(()=>{
+                const adapter = rootStore.getCallUiAdapter();
+                return adapter.state.isInCall.value || adapter.state.isVideoLoading.value;
+            }),
+            isDialogActive: signals_core_module_w(()=>rootStore.maximizedState.value !== types_MaximizedState.NONE && rootStore.displayMode.opened.value)
+        },
+        rotateToPortraitOverlay: signals_core_module_w(()=>isLandscapeNarrow.value && (!rootStore.displayMode.minimized.value || rootStore.maximizedState.value !== types_MaximizedState.NONE))
+    };
+}
+
+export { createLayoutSignal };

package/widget/multimodal_v2/signals/messages_signal.js

@@ -0,0 +1,207 @@
+import { signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+
+/* eslint-disable no-continue */ 
+function createMessagesSignal(initialMessages) {
+    if (initialMessages === void 0) initialMessages = [];
+    const messages = signals_core_module_d(initialMessages);
+    const unread = signals_core_module_w(()=>messages.value.filter((message)=>!message.isRead));
+    const hasPounceDismissed = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "event" && message.eventType === "pounce_dismissed");
+    });
+    const hasAiSdrCallRequested = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "event" && message.eventType === "ai_sdr_call_requested");
+    });
+    const hasVisitorTextMessage = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "text" && message.isOwn);
+    });
+    const pounceMessage = signals_core_module_w(()=>findPounceMessage(messages.value));
+    // A human rep pounce *is* a rep text message (userId + !isAp). We only want to
+    // deactivate when a rep sends a follow-up *after* the pounce. findPounceMessage
+    // returns the last pre-visitor pounce candidate, so earlier rep messages in a
+    // back-to-back pounce sequence sit at indices ≤ pounceIndex — keep them out of
+    // the follow-up check by gating on index > pounceIndex.
+    const hasRepTextMessage = signals_core_module_w(()=>{
+        const pounceMsg = pounceMessage.value;
+        const pounceIndex = pounceMsg ? messages.value.indexOf(pounceMsg) : -1;
+        return messages.value.some((message, index)=>index > pounceIndex && isRepTextMessage(message));
+    });
+    // Gating on hasStartChatBotEvent would permanently block non-AI pounces (human rep
+    // pounces and old-Piper auto pounces), which never emit startChatBot. Require a
+    // pounce candidate message instead — otherwise empty or event-only conversations
+    // would satisfy every deactivation check and spuriously mark pounceActive true,
+    // causing callers (e.g. pounceTrackingStore init in root_store) to start tracking
+    // and URL observation on conversations that have no pounce at all.
+    const pounceActive = signals_core_module_w(()=>!!pounceMessage.value && !hasPounceDismissed.value && !hasAiSdrCallRequested.value && !hasVisitorTextMessage.value && !hasRepTextMessage.value);
+    const pounce = createPounceMessageSignal(pounceMessage, pounceActive);
+    // The latest unread human-rep text message that arrives *after* the pounce. Once the
+    // visitor engages, the pounce bubble deactivates (see pounceActive), so a rep who
+    // replies while the visitor has the widget minimized used to have no collapsed-state
+    // surfacing at all — only the tab-title flash. This re-uses the preview bubble to show
+    // that reply (QAI-5515). Gating on index > pounceIndex (as hasRepTextMessage does)
+    // keeps a rep text that is itself part of a pre-engagement pounce sequence (e.g. a rep
+    // greeting followed by a shared_offer/field_request) from being treated as a follow-up
+    // and hijacking the pounce the bubble should show.
+    const repFollowUpMessage = signals_core_module_w(()=>{
+        var _messages_value_findLast;
+        const pounceMsg = pounceMessage.value;
+        const pounceIndex = pounceMsg ? messages.value.indexOf(pounceMsg) : -1;
+        return (_messages_value_findLast = messages.value.findLast((message, index)=>index > pounceIndex && isRepTextMessage(message) && !message.isRead)) != null ? _messages_value_findLast : null;
+    });
+    const preview = createPreviewSignal(pounce, repFollowUpMessage);
+    // WORKAROUND: Deduplicate consecutive field entries for the same field.
+    // Coffee's voice agent can call save_field twice for the same value due to a
+    // race condition in _end_turnstile_execution: when a cancelled response's
+    // cleanup clears _last_user_input/_current_turnstile_execution_id, it can
+    // clobber state that the next turn has already written. This causes the LLM
+    // to process the same input twice, creating duplicate field entries.
+    // Remove this once the root cause in Coffee is fixed.
+    const dedupedMessages = signals_core_module_w(()=>{
+        const result = [];
+        for (const message of messages.value){
+            if (!isDuplicateFieldEntry(message, result[result.length - 1])) {
+                result.push(message);
+            }
+        }
+        return result;
+    });
+    const visible = signals_core_module_w(()=>{
+        const visible = [];
+        const startIndex = pounce.value ? dedupedMessages.value.indexOf(pounce.value) : 0;
+        for(let i = startIndex; i < dedupedMessages.value.length; i++){
+            const message = dedupedMessages.value[i];
+            if (message.type === "event") continue;
+            // After visitor interaction, add read messages, stop at first unread streamable message
+            if (!isStreamableMessage(message)) {
+                visible.push(message);
+            } else if (message.isRead) {
+                visible.push(message);
+            } else {
+                visible.push(message);
+                return visible.sort((a, b)=>new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            }
+        }
+        return visible.sort((a, b)=>new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    });
+    const hasOpenEvent = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "event" && message.eventType === "open");
+    });
+    const hasStartChatBotEvent = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "event" && message.eventType === "startChatBot");
+    });
+    const hasShowWidgetEvent = signals_core_module_w(()=>{
+        return messages.value.some((message)=>message.type === "event" && message.eventType === "showWidget");
+    });
+    const repliedToIds = signals_core_module_w(()=>{
+        return new Set(messages.value.filter((message)=>message.replyToId).map((message)=>message.replyToId.toString()));
+    });
+    return Object.assign(messages, {
+        pounce,
+        preview,
+        repFollowUpMessage,
+        unread,
+        visible,
+        hasOpenEvent,
+        hasStartChatBotEvent,
+        hasShowWidgetEvent,
+        hasPounceDismissed,
+        hasAiSdrCallRequested,
+        hasVisitorTextMessage,
+        hasRepTextMessage,
+        pounceActive,
+        repliedToIds
+    });
+}
+function createPounceMessageSignal(pounceMessage, pounceActive) {
+    return Object.assign(pounceMessage, {
+        visible: signals_core_module_w(()=>!!pounceMessage.value && !pounceMessage.value.isRead && pounceActive.value)
+    });
+}
+// The collapsed preview bubble shows the active pounce, or — once the pounce has
+// deactivated — an unread rep follow-up. The layout hides the whole preview area
+// while the widget is opened, so this only surfaces in minimized/collapsed states.
+function createPreviewSignal(pounce, repFollowUpMessage) {
+    // `value` is the message the bubble would render and stays visibility-independent
+    // (the parent gates on `visible`): prefer an unread rep follow-up, otherwise fall
+    // back to the pounce message. During an active pounce there is no post-engagement
+    // rep follow-up, so this resolves to the pounce as before.
+    const previewMessage = signals_core_module_w(()=>{
+        var _repFollowUpMessage_value;
+        return (_repFollowUpMessage_value = repFollowUpMessage.value) != null ? _repFollowUpMessage_value : pounce.value;
+    });
+    return Object.assign(previewMessage, {
+        visible: signals_core_module_w(()=>pounce.visible.value || !!repFollowUpMessage.value)
+    });
+}
+function findPounceMessage(messages) {
+    let pounceMessage = null;
+    for (const message of messages){
+        if (message.type === "event") continue;
+        if (isPounceMessage(message)) {
+            pounceMessage = message;
+            continue;
+        }
+        // First visitor message found - stop searching
+        if (isVisitorMessage(message)) break;
+    }
+    return pounceMessage;
+}
+/** Non-own text messages that are animated letter-by-letter and gated on read status. */ function isStreamableMessage(message) {
+    var _message_offerContent_variation, _message_offerContent;
+    if (message.isRead) return false;
+    if (message.type === "text" && message.text && !message.isOwn) {
+        return true;
+    }
+    if (message.type === "shared_offer" && (message.text || ((_message_offerContent = message.offerContent) == null ? void 0 : (_message_offerContent_variation = _message_offerContent.variation) == null ? void 0 : _message_offerContent_variation.textContent))) {
+        return true;
+    }
+    return false;
+}
+function isPounceMessage(message) {
+    // Non visitor text messages are pounce messages
+    if (message.type === "text" && !message.isOwn) return true;
+    // Shared offers are pounce messages
+    if (message.type === "shared_offer") return true;
+    // Field requests are pounce messages
+    if (message.type === "field_request") return true;
+    // All other messages cannot be pounced
+    return false;
+}
+/**
+ * A human rep's text message — as opposed to a visitor message or an AI auto-pounce.
+ * Matches the rep-message predicate used by v2_adapter and the pounce tracking stores.
+ */ function isRepTextMessage(message) {
+    return message.type === "text" && !message.isOwn && "userId" in message && !!message.userId && "isAp" in message && !message.isAp;
+}
+/** Messages originating from the visitor: own text, own field entries, and calendar picks. */ function isVisitorMessage(message) {
+    // Text messages are visitor messages if they are own
+    if (message.type === "text") return message.isOwn;
+    // Field entries are visitor messages if they are own
+    if (message.type === "field_entry") return message.isOwn;
+    // Calendar event picks are visitor messages
+    if (message.type === "calendar_event_pick") return true;
+    // All other messages are not visitor messages
+    return false;
+}
+function isEventMessage(message, type) {
+    return message.type === "event" && (type ? message.eventType === type : true);
+}
+/** System-level messages (e.g. participant_joined) that are neither visitor nor assistant. */ function isSystemMessage(message) {
+    return message.type === "system";
+}
+/** Everything that is not a visitor message, event, or system message. */ function isAssistantMessage(message) {
+    return !isVisitorMessage(message) && !isEventMessage(message) && !isSystemMessage(message);
+}
+// WORKAROUND: See comment in deduped computed above. Remove once Coffee root cause is fixed.
+function isDuplicateFieldEntry(message, prev) {
+    if (message.type !== "field_entry" || (prev == null ? void 0 : prev.type) !== "field_entry") return false;
+    if (message.fieldId != null && prev.fieldId != null) {
+        return message.fieldId === prev.fieldId && message.text === prev.text;
+    }
+    return message.text === prev.text;
+}
+
+var messages_signal_isPounceMessage = /* unused export */ undefined;
+var messages_signal_isRepTextMessage = /* unused export */ undefined;
+var messages_signal_isSystemMessage = /* unused export */ undefined;
+var messages_signal_isVisitorMessage = /* unused export */ undefined;
+export { createMessagesSignal, isAssistantMessage, isEventMessage, isStreamableMessage, messages_signal_isPounceMessage as isPounceMessage, messages_signal_isRepTextMessage as isRepTextMessage, messages_signal_isSystemMessage as isSystemMessage, messages_signal_isVisitorMessage as isVisitorMessage };