@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/signals/ui_state_signal.js

@@ -0,0 +1,128 @@
+import { signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { createArtifactSignal } from "./artifact_signal.js";
+import { ConversationMode as types_ConversationMode, OpenedDisplayMode as types_OpenedDisplayMode, DisplayMode as types_DisplayMode, InputHiddenReason as types_InputHiddenReason, InputState as types_InputState } from "../types.js";
+
+
+
+
+function createUIStateSignal(rootStore) {
+    const state = signals_core_module_d({
+        displayMode: types_DisplayMode.COLLAPSED_CENTER,
+        openedDisplayMode: types_OpenedDisplayMode.SIDEBAR,
+        conversationMode: types_ConversationMode.TEXT,
+        inputMessageId: null,
+        artifactMessageId: null,
+        userHasDismissed: false,
+        userHasIgnoredMultimodal: false
+    });
+    return Object.assign(state, {
+        displayMode: createDisplayModeSignal(state),
+        openedDisplayMode: signals_core_module_w(()=>{
+            var _state_value_openedDisplayMode;
+            return (_state_value_openedDisplayMode = state.value.openedDisplayMode) != null ? _state_value_openedDisplayMode : types_OpenedDisplayMode.SIDEBAR;
+        }),
+        conversationMode: createConversationModeSignal(state),
+        input: createInputSignal(rootStore, state),
+        artifact: createArtifactSignal(rootStore, state),
+        userHasDismissed: signals_core_module_w(()=>{
+            var _state_value_userHasDismissed;
+            return (_state_value_userHasDismissed = state.value.userHasDismissed) != null ? _state_value_userHasDismissed : false;
+        }),
+        userHasIgnoredMultimodal: signals_core_module_w(()=>{
+            var _state_value_userHasIgnoredMultimodal;
+            return (_state_value_userHasIgnoredMultimodal = state.value.userHasIgnoredMultimodal) != null ? _state_value_userHasIgnoredMultimodal : false;
+        }),
+        // Persisted UI state is used to save the UI state to DB
+        persisted: signals_core_module_w(()=>extractPersistedUIState(state.value))
+    });
+}
+function createConversationModeSignal(state) {
+    const conversationMode = signals_core_module_w(()=>state.value.conversationMode);
+    return Object.assign(conversationMode, {
+        text: signals_core_module_w(()=>conversationMode.value === types_ConversationMode.TEXT),
+        voice: signals_core_module_w(()=>conversationMode.value === types_ConversationMode.VOICE),
+        video: signals_core_module_w(()=>conversationMode.value === types_ConversationMode.VIDEO),
+        multimodal: signals_core_module_w(()=>conversationMode.value !== types_ConversationMode.TEXT)
+    });
+}
+function createDisplayModeSignal(state) {
+    const displayMode = signals_core_module_w(()=>state.value.displayMode);
+    const collapsedCenter = signals_core_module_w(()=>displayMode.value === types_DisplayMode.COLLAPSED_CENTER);
+    const collapsedRight = signals_core_module_w(()=>displayMode.value === types_DisplayMode.COLLAPSED_RIGHT);
+    const closed = signals_core_module_w(()=>displayMode.value === types_DisplayMode.CLOSED);
+    const sidebar = signals_core_module_w(()=>displayMode.value === types_DisplayMode.SIDEBAR);
+    const docked = signals_core_module_w(()=>displayMode.value === types_DisplayMode.DOCKED);
+    // Convenience computed signals
+    const collapsed = signals_core_module_w(()=>collapsedCenter.value || collapsedRight.value);
+    const minimized = signals_core_module_w(()=>collapsed.value || closed.value);
+    const opened = signals_core_module_w(()=>sidebar.value || docked.value);
+    return Object.assign(displayMode, {
+        collapsedCenter,
+        collapsedRight,
+        collapsed,
+        closed,
+        sidebar,
+        docked,
+        minimized,
+        opened
+    });
+}
+function createInputSignal(rootStore, uiState) {
+    const messageId = signals_core_module_w(()=>uiState.value.inputMessageId);
+    const message = signals_core_module_w(()=>{
+        var _rootStore_messages_visible_value_find;
+        if (!messageId.value) return null;
+        const message = (_rootStore_messages_visible_value_find = rootStore.messages.visible.value.find((m)=>m.id === messageId.value)) != null ? _rootStore_messages_visible_value_find : null;
+        if (!message) return null;
+        if (message.type === "field_request") {
+            return message;
+        }
+        return null;
+    });
+    const hiddenReason = signals_core_module_w(()=>{
+        if (rootStore.isVisitorBlocked.value) {
+            return types_InputHiddenReason.VISITOR_BLOCKED;
+        }
+        if (!rootStore.agentsAvailable.value && rootStore.userEngaged.value) {
+            return types_InputHiddenReason.REPS_OFFLINE;
+        }
+        if (!rootStore.messages.hasStartChatBotEvent.value && !rootStore.activeConversation.user.value) {
+            return types_InputHiddenReason.CONVERSATION_NOT_STARTED;
+        }
+        return null;
+    });
+    const state = signals_core_module_w(()=>{
+        var _message_value;
+        if (hiddenReason.value === types_InputHiddenReason.VISITOR_BLOCKED) return types_InputState.HIDDEN;
+        if (((_message_value = message.value) == null ? void 0 : _message_value.type) === "field_request") return types_InputState.FIELD_REQUEST;
+        if (hiddenReason.value) return types_InputState.HIDDEN;
+        return types_InputState.CHAT;
+    });
+    const isAnchored = signals_core_module_w(()=>{
+        const msg = message.value;
+        return (msg == null ? void 0 : msg.type) === "field_request" && (msg.fieldType === "picklist" || msg.fieldType === "multi_picklist") && !rootStore.displayMode.minimized.value;
+    });
+    return {
+        messageId,
+        message,
+        state,
+        hiddenReason,
+        isAnchored
+    };
+}
+function extractPersistedUIState(uiState) {
+    const persisted = {
+        displayMode: uiState.displayMode,
+        openedDisplayMode: uiState.openedDisplayMode,
+        userHasDismissed: uiState.userHasDismissed,
+        userHasIgnoredMultimodal: uiState.userHasIgnoredMultimodal
+    };
+    // Drop null/undefined so restoring partial/older sessions (e.g. state that
+    // predates openedDisplayMode) doesn't clobber existing values with nullish.
+    return Object.fromEntries(Object.entries(persisted).filter((param)=>{
+        let [, value] = param;
+        return value != null;
+    }));
+}
+
+export { createUIStateSignal, extractPersistedUIState };

package/widget/multimodal_v2/stable_bundle_src.js

@@ -0,0 +1,44 @@
+var _ref;
+var _document_currentScript;
+/**
+ * Resolves the base URL this bundle was loaded from, so sibling artifacts (e.g.
+ * call-machine-object-bundle.js) can be resolved relative to it.
+ *
+ * Two resolution sources, tried in this order:
+ *
+ *   1. `globalThis.__qualifiedBundleBaseUrl` — a runtime override, set by `setup()`
+ *      before any call object is created. This is how the unbundled ESM package supplies
+ *      its base: the entry resolves `import.meta.url` and assigns it here. It cannot be a
+ *      build-time constant read at module-evaluation time — the widget graph is reached by
+ *      static imports that run in full before the entry's first statement, so a value
+ *      captured then would always be too late. Reading it on demand is what lets `setup()`
+ *      set it in time.
+ *   2. `document.currentScript.src` — classic-script builds: the hosted snippet and
+ *      today's self-hosted zip. Only readable during synchronous script execution,
+ *      which is why it is captured at module-evaluation time below and why this module
+ *      must be imported at the very top of a classic entry pack.
+ *
+ * Under ESM, source 2 is always null, because `document.currentScript` is only set
+ * while a classic script tag is executing. That is the defect this ordering exists to
+ * fix: a null base URL used to fall through to a remote call-machine bundle without
+ * erroring. See the TDD, "Verified blockers", blocker 1.
+ *
+ * Hosted snippets legitimately have no sibling artifact and keep using the
+ * backend-provided CDN URL; only self-hosted builds require this to resolve.
+ */ /**
+ * Source 3, captured while the classic script tag is still executing.
+ *
+ * This one cannot be deferred: `document.currentScript` is non-null only during
+ * synchronous execution of the script that set it, and reads `null` from any later
+ * task. Null throughout an ES module's evaluation by design, which is the ESM shape
+ * blocker 1 describes.
+ */ const CURRENT_SCRIPT_SRC = typeof document !== "undefined" ? (_ref = (_document_currentScript = document.currentScript) == null ? void 0 : _document_currentScript.src) != null ? _ref : null : null;
+/** The base URL sibling assets resolve against, or null when nothing supplies one. */ function resolveBundleBaseUrl() {
+    const runtimeOverride = globalThis.__qualifiedBundleBaseUrl;
+    if (runtimeOverride) {
+        return runtimeOverride;
+    }
+    return CURRENT_SCRIPT_SRC;
+}
+
+export { resolveBundleBaseUrl };

package/widget/multimodal_v2/stores/ai_conversation_store.js

@@ -0,0 +1,221 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { signals_core_module_r, signals_core_module_d } from "../../../js/multimodal_v2.js";
+import { snakify } from "../../../src/utils.js";
+import "../../telemetry/index.js";
+import "../../utils/native_globals.js";
+import { ConversationMode as types_ConversationMode } from "../types.js";
+import { metrics } from "../../telemetry/metrics.js";
+
+/* provided dependency */ var ai_conversation_store_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var ai_conversation_store_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);
+}
+
+
+
+
+class AiConversationStore {
+    emitAvailabilityFailed() {
+        if (this.availabilityTimeoutId === null) return;
+        ai_conversation_store_clearTimeout(this.availabilityTimeoutId);
+        this.availabilityTimeoutId = null;
+        metrics.emitIncrement("multimodal_session_failed");
+    }
+    dispose() {
+        if (this.startConversationTimeoutId !== null) {
+            ai_conversation_store_clearTimeout(this.startConversationTimeoutId);
+            this.startConversationTimeoutId = null;
+        }
+        if (this.availabilityTimeoutId !== null) {
+            ai_conversation_store_clearTimeout(this.availabilityTimeoutId);
+            this.availabilityTimeoutId = null;
+        }
+    }
+    constructor(callStore){
+        this.callStore = callStore;
+        this.conversation = signals_core_module_d(null);
+        this.isCoffeeReady = signals_core_module_d(false);
+        this.error = signals_core_module_d(false);
+        this.alreadyInCall = signals_core_module_d(false);
+        this.startConversationTimestamp = null;
+        this.startConversationTimeoutId = null;
+        this.availabilityTimeoutId = null;
+        this.startConversation = async (restart, startCallContext)=>{
+            if (restart === void 0) restart = false;
+            if (startCallContext === void 0) startCallContext = null;
+            this.rootStore.isVideoLoading.value = true;
+            this.isCoffeeReady.value = false;
+            this.alreadyInCall.value = false;
+            this.startConversationTimestamp = performance.now();
+            if (this.startConversationTimeoutId !== null) {
+                ai_conversation_store_clearTimeout(this.startConversationTimeoutId);
+            }
+            if (this.availabilityTimeoutId !== null) {
+                ai_conversation_store_clearTimeout(this.availabilityTimeoutId);
+            }
+            if (!restart) {
+                this.callStore.resetCallAvailabilityMetric();
+            }
+            // Set up 30s timeout to log metric if all_participants_joined doesn't fire
+            this.startConversationTimeoutId = ai_conversation_store_setTimeout(()=>{
+                if (this.startConversationTimestamp !== null) {
+                    metrics.emitTiming("multimodal_time_to_all_participants_joined_ms", 30000);
+                    this.startConversationTimestamp = null;
+                }
+                this.startConversationTimeoutId = null;
+            }, 30000);
+            this.availabilityTimeoutId = ai_conversation_store_setTimeout(()=>{
+                this.availabilityTimeoutId = null;
+                metrics.emitIncrement("multimodal_session_failed");
+            }, AiConversationStore.AVAILABILITY_BUDGET_MS);
+            this.callStore.preload();
+            // Forward the start-call context (set when the call was started with a specific
+            // trigger, e.g. from a "present_video" card). Skipped on restart/reconnect so
+            // re-joins don't re-trigger the opening intent.
+            const context = restart ? null : startCallContext;
+            const response = await this.rootStore.channel.perform("start_ai_sdr_conversation", _extends({
+                restart,
+                call_type: this.rootStore.allowVoiceVideoToggle.value ? types_ConversationMode.VIDEO : this.rootStore.conversationMode.value
+            }, this.rootStore.featureFlags.piperXAnam && {
+                avatar_provider: "anam"
+            }, context && {
+                start_call_context: snakify(context)
+            }));
+            if (response.error) {
+                if (this.startConversationTimeoutId !== null) {
+                    ai_conversation_store_clearTimeout(this.startConversationTimeoutId);
+                    this.startConversationTimeoutId = null;
+                }
+                this.startConversationTimestamp = null;
+                this.emitAvailabilityFailed();
+                // Degrade gracefully to text instead of surfacing a hard error, so the
+                // visitor can keep talking to us when room creation can't be recovered.
+                this.failoverToText();
+            } else if ("active_call_exists" in response.data) {
+                this.alreadyInCall.value = true;
+                this.rootStore.isVideoLoading.value = false;
+            } else {
+                this.handleStartResponse(response.data);
+            }
+            try {
+                // Initialize navigation interception only when we know the conversation was created successfully
+                if (this.conversation.value) {
+                    const store = await this.rootStore.websiteNavigationStore.load();
+                    // Guard: conversation may have been cleared while we were waiting for the response
+                    if (this.conversation.value) {
+                        store.initNavigationInterceptor();
+                    }
+                }
+            } catch (error) {
+            // Suppress error - we'll handle it later
+            // TODO: report to sentry when sentry is available within stores
+            }
+        };
+        /**
+   * End the current conversation.
+   */ this.endConversation = async ()=>{
+            if (!this.conversation.value) return;
+            // We don't need to await this we can assume the backend will end it correctly
+            this.rootStore.channel.perform("end_ai_sdr_conversation", {
+                conversation_id: this.conversation.value.conversation_id
+            });
+            await this.handleEndResponse();
+        };
+        this.handleEndResponse = async ()=>{
+            var _ref;
+            var _this_conversation_value;
+            const conversationId = (_ref = (_this_conversation_value = this.conversation.value) == null ? void 0 : _this_conversation_value.conversation_id) != null ? _ref : null;
+            if (this.availabilityTimeoutId !== null) {
+                ai_conversation_store_clearTimeout(this.availabilityTimeoutId);
+                this.availabilityTimeoutId = null;
+            }
+            await this.callStore.leaveCall();
+            signals_core_module_r(()=>{
+                this.conversation.value = null;
+                this.rootStore.isVideoLoading.value = false;
+                this.rootStore.isBlurredVideoActive.value = false;
+                this.rootStore.setTypingIndicator(false);
+                try {
+                    var _this_rootStore_websiteNavigationStore_value;
+                    (_this_rootStore_websiteNavigationStore_value = this.rootStore.websiteNavigationStore.value) == null ? void 0 : _this_rootStore_websiteNavigationStore_value.disposeNavigationInterceptor();
+                } catch (error) {
+                // Suppress error - we'll handle it later
+                // TODO: report to sentry when sentry is available within stores
+                }
+            });
+            if (conversationId && this.rootStore.featureFlags.piperXPostCallSurvey) {
+                const surveyStore = await this.rootStore.postCallSurveyStore.load();
+                surveyStore.show(conversationId);
+            }
+        };
+        /**
+   * End a conversation by ID without requiring conversation.value to be set.
+   * Used to clean up conversations created on the backend when the user cancels
+   * before the start response is processed.
+   */ this.endConversationById = async (conversationId)=>{
+            // Fire and forget - we don't need to handle the response since we're just cleaning up
+            this.rootStore.channel.perform("end_ai_sdr_conversation", {
+                conversation_id: conversationId
+            });
+        };
+        this.failoverToText = ()=>{
+            this.rootStore.isVideoLoading.value = false;
+            this.rootStore.setConversationMode(types_ConversationMode.TEXT);
+            // There is no call to sit behind a picture-in-picture widget any more, so a
+            // widget parked for one would hide the fallback notice below with nothing in
+            // its place.
+            if (this.rootStore.displayMode.minimized.peek()) {
+                this.rootStore.setOpenedDisplayMode();
+            }
+            this.rootStore.displayLocalNotice("Voice and video are temporarily unavailable. Let's keep chatting here.");
+            this.callStore.resolveCallAvailabilityMetric("success");
+        };
+        // Handlers
+        this.handleStartResponse = (payload)=>{
+            // If isVideoLoading was set to false while we were waiting for the response,
+            // it means the user canceled the connection - don't proceed
+            if (!this.rootStore.isVideoLoading.value) {
+                // The conversation was created on the backend, so we need to send an end message
+                // to clean it up. This handles the race condition where user clicks X before
+                // the start response comes back.
+                if (payload.conversation_id) {
+                    this.endConversationById(payload.conversation_id);
+                }
+                return;
+            }
+            if (payload.forced_voice_only) {
+                this.rootStore.setConversationMode(types_ConversationMode.VOICE);
+            }
+            const { conversation_id, conversation_url, visitor_token } = payload;
+            if (!conversation_id || !conversation_url) {
+                // eslint-disable-next-line no-console
+                console.error("Conversation Id or URL is missing");
+                this.error.value = true;
+                this.rootStore.isVideoLoading.value = false;
+                return;
+            }
+            this.conversation.value = {
+                conversation_id,
+                conversation_url,
+                visitor_token
+            };
+        };
+        this.rootStore = callStore.rootStore;
+    }
+}
+AiConversationStore.AVAILABILITY_BUDGET_MS = 15000;
+
+
+export default AiConversationStore;

package/widget/multimodal_v2/stores/artifact_store.js

@@ -0,0 +1,205 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { signals_core_module_r, signals_core_module_d } from "../../../js/multimodal_v2.js";
+import { BaseStore } from "./base_store.js";
+import "../../utils/native_globals.js";
+import { MaximizedState as types_MaximizedState } from "../types.js";
+
+/* provided dependency */ var artifact_store_setTimeout = __webpack_require__(68034).pS;
+
+
+
+/**
+ * Owns artifact orchestration: presenting slides / presentation videos / the
+ * meeting booker in the maximized ARTIFACT overlay, navigating the host page
+ * (co-browsing), and tearing down the overlay. The underlying signal lives in the
+ * UI state (see `createArtifactSignal`); this store exposes it via `current`
+ * and drives the side effects that show/hide it.
+ */ class ArtifactStore extends BaseStore {
+    /** The currently presented artifact (slide, presentation video, deck or meeting), if any. */ get current() {
+        return this.rootStore.uiStore.artifact;
+    }
+    constructor(rootStore){
+        super(rootStore), this.rootStore = rootStore, /** Deck/video message ids already hidden, including ones still loading. */ this.hiddenArtifactIds = new Set(), /**
+   * Messages whose artifact is on its way into the overlay: queued, and still
+   * waiting on the chunk it needs (or on a deliberate delay) before it can be
+   * shown. The timeline reads this to withhold the entry point it would otherwise
+   * draw for a message that is about to fill the overlay anyway — see
+   * CalendarEventOfferRenderer, where the "continue booking" card would flash in
+   * front of a booker already coming up.
+   *
+   * A set rather than one id because the waits overlap: two messages arriving
+   * within a delay of each other are both on their way, and only the overlay
+   * itself is exclusive. Held as one id, the second to be queued would take the
+   * first's slot back out of hiding, and the first to open would then release the
+   * second's.
+   */ this.pending = signals_core_module_d(new Set()), /**
+   * Queues an incoming message for the overlay, optionally after a delay.
+   *
+   * The id is marked pending synchronously, before any of the waiting starts, so
+   * the timeline can withhold this message's own entry point for the whole of it.
+   * Getting to the overlay is asynchronous — it waits on the artifact's lazy chunk,
+   * and on this delay — and until it lands the timeline would otherwise draw a card
+   * in front of an artifact that is on its way up anyway.
+   *
+   * Awaitable, but callers reacting to an incoming message have nothing to wait
+   * for: hand it over and let it come up on its own.
+   */ this.queueArtifactMessage = async (message, param)=>{
+            let { delayMs = 0 } = param === void 0 ? {} : param;
+            this.markPending(message.id);
+            try {
+                if (delayMs > 0) await new Promise((resolve)=>artifact_store_setTimeout(resolve, delayMs));
+                await this.presentArtifactMessage(message);
+            } finally{
+                // Safe to release the slot now: on the way through here the artifact id has
+                // been set, so the renderer is already withholding it for that reason
+                // instead. On the way out of a failure nothing is coming, and the card is
+                // the only entry point left. Either way it says nothing about any other
+                // message still on its way.
+                this.clearPending(message.id);
+            }
+        }, /**
+   * Shows a message's artifact now, loading whatever its body needs first so the
+   * overlay never flashes empty.
+   *
+   * Unlike {@link queueArtifactMessage} this leaves the timeline alone, for the
+   * visitor asking to (re)open an artifact from a card that is already on screen:
+   * hiding it mid-load would blank the spot they just clicked.
+   */ this.presentArtifactMessage = async (message)=>{
+            switch(message.type){
+                case "present_content":
+                    await this.rootStore.slidesStore.load();
+                    // Mirror the on-screen slide into the voice agent's perception loop
+                    // (ScreenShareStore ships it via the update_perception channel action).
+                    this.loadSlidePerception();
+                    this.showArtifact(message);
+                    break;
+                case "present_video":
+                    if (this.rootStore.callInProgress.value) {
+                        await this.rootStore.presentationsStore.load();
+                        if (!this.hiddenArtifactIds.has(message.id)) this.showArtifact(message);
+                    }
+                    break;
+                case "present_deck":
+                    // Like present_video, a deck only opens in the overlay during a call.
+                    // Off-call the visitor gets a "join call" prompt (see PresentDeckRenderer).
+                    if (this.rootStore.callInProgress.value) {
+                        var _message_slides;
+                        await this.rootStore.decksStore.load();
+                        // Only open the overlay for a LIVE presentation. Once narration finishes
+                        // the deck re-broadcasts (PyperxController#absorb_deck_narration!) with
+                        // per-slide talk tracks populated — that update is for the timeline
+                        // record, not a fresh present, so it must not (re)open the overlay, least
+                        // of all one the visitor has already dismissed. A live present arrives
+                        // with talk tracks withheld (awaiting_narration), so this distinguishes
+                        // the two without needing to track dismissal separately.
+                        const narrationAbsorbed = ((_message_slides = message.slides) != null ? _message_slides : []).some((slide)=>!!slide.talkTrack);
+                        if (!narrationAbsorbed && !this.hiddenArtifactIds.has(message.id)) {
+                            // Mirror the slide to the voice agent's perception loop
+                            // (ScreenShareStore ships it via the update_perception channel action).
+                            // Gated with the present so we only mirror a live, on-screen slide.
+                            this.loadSlidePerception();
+                            this.showArtifact(message);
+                        }
+                    }
+                    break;
+                case "calendar_event_offer":
+                    // The overlay is the booker's only surface in the messenger. (The
+                    // element-conversation lightbox is a separate flow; see
+                    // RootStore#elementConversationOffer.)
+                    await this.rootStore.meetingStore.load();
+                    this.showArtifact(message);
+                    break;
+                case "navigate_content":
+                    // The one kind that never reaches the overlay: it drives the host page
+                    // instead, so no timeline card stands in for it and nothing is withheld.
+                    await this.rootStore.websiteNavigationStore.load().then((store)=>store.navigateToContent(message));
+                    break;
+            }
+        }, // fresh presentation this is a static single-slide view (no auto-advance) and
+        // is allowed regardless of call state — it's a review of an already-shown
+        // slide, not the agent presenting.
+        this.revisitDeckSlide = async (message, slideIndex, pageTitle)=>{
+            const store = await this.rootStore.decksStore.load();
+            // Pass the clicked slide's own title: on a consolidated resume record `message`
+            // is the last share, whose `slides` may not include this slide, so the store
+            // can't look the title up from it.
+            store.prepareRevisit(message.id, slideIndex, pageTitle);
+            this.showArtifact(message);
+        }, /**
+   * Tears down the overlay for whatever artifact is in it. Deliberately says
+   * nothing about the meeting booker: clearing the artifact message is the whole
+   * of what dismissing the booker means, since the overlay is the only surface it
+   * has. Meeting-aware teardown — which also has the element conversation to let
+   * go of — belongs to `closeMeetingBooker` and `clearMeetingArtifact`.
+   */ this.clearArtifact = ()=>{
+            const artifactMessage = this.current.message.value;
+            const closedArtifact = this.rootStore.maximizedState.value === types_MaximizedState.ARTIFACT && ((artifactMessage == null ? void 0 : artifactMessage.type) === "present_video" || (artifactMessage == null ? void 0 : artifactMessage.type) === "present_deck") ? artifactMessage : null;
+            if (closedArtifact) {
+                this.hiddenArtifactIds.add(closedArtifact.id);
+            }
+            this.rootStore.clearMaximizedState({
+                when: types_MaximizedState.ARTIFACT
+            });
+            // Closing the presentation overlay mid-call: let the agent know so it stops
+            // narrating and acknowledges that the visitor dismissed the presentation.
+            if (closedArtifact && this.rootStore.callInProgress.value) {
+                this.channel.perform("notify_artifact_closed", {
+                    artifact_type: closedArtifact.type === "present_video" ? "presentation" : "deck",
+                    artifact_message_id: closedArtifact.id
+                });
+            }
+        }, /** Silently hides the live deck/demo targeted by Piper's hide event. */ this.hideArtifact = (artifactMessageId)=>{
+            var _this_rootStore_decksStore_value;
+            // Record the hide before checking the current overlay. The matching artifact
+            // may still be waiting on a lazy store; when that wait resolves,
+            // presentArtifactMessage checks this set and does not open stale content.
+            this.hiddenArtifactIds.add(artifactMessageId);
+            const artifactMessage = this.current.message.value;
+            if (this.rootStore.maximizedState.value !== types_MaximizedState.ARTIFACT) return;
+            if ((artifactMessage == null ? void 0 : artifactMessage.id) !== artifactMessageId) return;
+            if (artifactMessage.type !== "present_video" && artifactMessage.type !== "present_deck") return;
+            // A visitor may reopen an old deck slide from the timeline after Piper has
+            // finished. A late/replayed completion event must not close that review.
+            if (artifactMessage.type === "present_deck" && ((_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.isRevisiting(artifactMessageId))) {
+                return;
+            }
+            // Do not call clearArtifact: that path represents a visitor dismissal and
+            // notifies Piper when a video is closed mid-presentation.
+            this.rootStore.clearMaximizedState({
+                when: types_MaximizedState.ARTIFACT
+            });
+        }, /**
+   * Instantiate ScreenShareStore so it mirrors the on-screen slide to the agent's
+   * perception loop. Gated on `piper_perception_slides`: without the flag the server
+   * drops perception frames, so skip the store entirely rather than canvas-encoding
+   * and shipping ~100-500KB base64 frames over ActionCable for nothing.
+   */ this.loadSlidePerception = ()=>{
+            if (!this.rootStore.featureFlags.piperPerceptionSlides) return;
+            void this.rootStore.screenShareStore.load();
+        }, this.markPending = (messageId)=>{
+            const pending = new Set(this.pending.peek());
+            pending.add(messageId);
+            this.pending.value = pending;
+        }, this.clearPending = (messageId)=>{
+            const pending = new Set(this.pending.peek());
+            if (!pending.delete(messageId)) return;
+            this.pending.value = pending;
+        }, this.showArtifact = (message)=>{
+            if (this.current.messageId.value === message.id) {
+                this.rootStore.setMaximizedState(types_MaximizedState.ARTIFACT);
+                return;
+            }
+            signals_core_module_r(()=>{
+                this.rootStore.setUIState({
+                    artifactMessageId: message.id
+                });
+                this.rootStore.setMaximizedState(types_MaximizedState.ARTIFACT);
+                if (this.rootStore.displayMode.minimized.value && !this.rootStore.conversationMode.video.value) {
+                    this.rootStore.setOpenedDisplayMode();
+                }
+            });
+        };
+    }
+}
+
+export { ArtifactStore };

package/widget/multimodal_v2/stores/base_store.js

@@ -0,0 +1,16 @@
+class BaseStore {
+    get experienceAdapter() {
+        return this.context.experienceAdapter;
+    }
+    get channel() {
+        return this.context.channel;
+    }
+    get visitor() {
+        return this.context.visitor;
+    }
+    constructor(contextOrInstance){
+        this.context = contextOrInstance instanceof BaseStore ? contextOrInstance.context : contextOrInstance;
+    }
+}
+
+export { BaseStore };