@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/pounce_tracking_store_v2.js

@@ -0,0 +1,511 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { signals_core_module_E, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { addEventListener } from "../../../src/dom.js";
+import { every } from "../../../src/timing.js";
+import { UrlObserver } from "../utils/url_observer.js";
+import "../../utils/native_globals.js";
+
+/* provided dependency */ var pounce_tracking_store_v2_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var pounce_tracking_store_v2_setTimeout = __webpack_require__(68034).pS;
+
+
+
+
+const IDLE_GENERATION_THRESHOLD_MS = 5000;
+const ACTIVE_THRESHOLD_MS = 10000;
+const IDLE_GENERATION_TIMEOUT_MS = 30000;
+const SCROLL_POUNCE_DEBOUNCE_MS = 2000;
+class PounceTrackingStoreV2 {
+    // Actions
+    startTracking() {
+        this.startUrlObservation();
+        this.setupEffects();
+    }
+    dispose() {
+        var _this_urlObserver;
+        this.stopBehaviorTracking();
+        this.firstScrollDisposer();
+        this.teardownScrollTracking();
+        this.clearPendingScrollPounce();
+        (_this_urlObserver = this.urlObserver) == null ? void 0 : _this_urlObserver.stop();
+    }
+    // Inactivity threshold (ms) before a follow-up/scroll pounce fires. Uses the
+    // team-configured value, otherwise falls back to the hardcoded
+    // ACTIVE_THRESHOLD_MS default.
+    get activeThresholdMs() {
+        const configured = this.rootStore.pounceInactivityThresholdMs.value;
+        if (configured !== null && Number.isFinite(configured) && configured > 0) {
+            return configured;
+        }
+        return ACTIVE_THRESHOLD_MS;
+    }
+    // Effects
+    setupEffects() {
+        signals_core_module_E(()=>{
+            if (this.isCallRequested.value || this.visitorHasTyped.value || this.triggeredScrollPounceIds.size > 0 || this.triggeredIdlePounceId.value) {
+                this.stopBehaviorTracking();
+                return;
+            }
+            if (this.trackingStarted.value) return;
+            // Only start tracking when we receive a fresh assistant message for this URL visit.
+            // This prevents race conditions where idle pounces fire before initial pounces
+            // when returning to a previously visited page.
+            if (this.lastTrackablePounceMessageAfterUrlChange.value !== null) {
+                this.trackingStarted.value = true;
+                this.startBehaviorTracking();
+            }
+        });
+        // Reset pounce state on URL change
+        signals_core_module_E(()=>{
+            const url = this.currentUrl.value;
+            if (url !== this.lastUrl) {
+                const isFirstUrlChange = this.lastUrl === null;
+                this.triggeredScrollPounceIds.clear();
+                this.idleGenerationRequested = false;
+                this.autoPounceNudgeRequested = false;
+                this.triggeredIdlePounceId.value = null;
+                this.lastUrl = url;
+                this.hasScrolledForCurrentUrl.value = false;
+                this.stopBehaviorTracking();
+                this.firstScrollDisposer();
+                this.teardownScrollTracking();
+                this.clearPendingScrollPounce();
+                this.trackingStarted.value = false;
+                this.visitorHasTyped.value = false;
+                // Only update timestamp on subsequent URL changes, not the first one.
+                // On first load, we want all messages to pass the filter.
+                if (!isFirstUrlChange) {
+                    this.urlChangeTimestamp.value = Date.now();
+                }
+            }
+        });
+        // Scroll pounce
+        signals_core_module_E(()=>{
+            const url = this.currentUrl.value;
+            const scrollPounces = this.scrollPouncesForCurrentUrl.value;
+            const candidatesLoaded = this.pounceCandidates.value !== null;
+            // If pounceCandidates haven't arrived yet, wait
+            if (!candidatesLoaded) {
+                return;
+            }
+            // Stop if call requested, visitor typed/responded, user responded, URL missing, idle pounce already triggered, or no scroll pounces
+            if (this.isCallRequested.value || this.visitorHasTyped.value || this.visitorResponded.value || this.userResponded.value || !url || this.triggeredIdlePounceId.value !== null || scrollPounces.length === 0) {
+                this.firstScrollDisposer();
+                this.teardownScrollTracking();
+                return;
+            }
+            // Register first scroll listener if not scrolled yet
+            if (!this.hasScrolledForCurrentUrl.value) {
+                this.registerFirstScrollListener();
+            } else {
+                this.setupScrollTracking(scrollPounces, url);
+            }
+        });
+    }
+    findPounceForElement(scrollPounces, el) {
+        var _scrollPounces_find;
+        return (_scrollPounces_find = scrollPounces.find((pounce)=>{
+            if (!pounce.trigger) return false;
+            const elements = this.getElementsForPounce(pounce);
+            return elements.some((candidateEl)=>candidateEl === el);
+        })) != null ? _scrollPounces_find : null;
+    }
+    // Helper methods
+    isFromRep(msg) {
+        return !!("userId" in msg && msg.userId && "isAp" in msg && !msg.isAp && msg.type === "text");
+    }
+    isFromVisitor(msg) {
+        return !!("visitorId" in msg && msg.visitorId && msg.type === "text");
+    }
+    isTrackablePounceMessage(msg) {
+        return this.isAutoRespondPounceMessage(msg) || this.isAutoPounceMessage(msg);
+    }
+    isAutoRespondPounceMessage(msg) {
+        return msg.source === "auto_respond";
+    }
+    isAutoPounceMessage(msg) {
+        return msg.type === "text" && (msg.source === "auto_pounce" || "isAp" in msg && msg.isAp === true);
+    }
+    findLatestTrackablePounceEntry(afterTimestamp) {
+        let latestEntry = null;
+        for (const message of this.rootStore.messages.value){
+            if (this.isTrackablePounceMessage(message)) {
+                const timestamp = new Date(message.createdAt).getTime();
+                const isAfterTimestamp = afterTimestamp === undefined || timestamp > afterTimestamp;
+                if (Number.isFinite(timestamp) && isAfterTimestamp) {
+                    if (!latestEntry || timestamp > latestEntry.timestamp) {
+                        latestEntry = {
+                            message,
+                            timestamp
+                        };
+                    }
+                }
+            }
+        }
+        return latestEntry;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        // Derived state
+        this.userResponded = signals_core_module_w(()=>{
+            return this.rootStore.messages.value.some((msg)=>this.isFromRep(msg));
+        });
+        this.visitorResponded = signals_core_module_w(()=>{
+            return this.rootStore.messages.value.some((msg)=>this.isFromVisitor(msg));
+        });
+        this.aiSdrCallRequested = signals_core_module_d(false);
+        this.isCallRequested = signals_core_module_w(()=>this.aiSdrCallRequested.value || this.rootStore.messages.hasAiSdrCallRequested.value);
+        this.pounceCandidates = signals_core_module_w(()=>this.rootStore.pounceCandidates.value);
+        this.currentUrl = signals_core_module_d(null);
+        // Track when the current URL was set to filter out old messages.
+        // Initialize to 0 so all messages pass the filter on first page load.
+        this.urlChangeTimestamp = signals_core_module_d(0);
+        this.currentUrlPounceCandidates = signals_core_module_w(()=>{
+            var _candidates_url;
+            const url = this.currentUrl.value;
+            const candidates = this.pounceCandidates.value;
+            if (!url || !candidates) return [];
+            return (_candidates_url = candidates[url]) != null ? _candidates_url : [];
+        });
+        this.scrollPouncesForCurrentUrl = signals_core_module_w(()=>{
+            return this.currentUrlPounceCandidates.value.filter((candidate)=>candidate.pounceType === "scroll" && !!candidate.trigger && !!candidate.baseUrl && !candidate.triggered);
+        });
+        this.idlePounceForCurrentUrl = signals_core_module_w(()=>{
+            return this.currentUrlPounceCandidates.value.find((candidate)=>candidate.pounceType === "idle_followup" && !!candidate.baseUrl && !candidate.triggered);
+        });
+        this.latestTrackablePounceMessage = signals_core_module_w(()=>{
+            var _ref;
+            var _this_findLatestTrackablePounceEntry;
+            return (_ref = (_this_findLatestTrackablePounceEntry = this.findLatestTrackablePounceEntry()) == null ? void 0 : _this_findLatestTrackablePounceEntry.message) != null ? _ref : null;
+        });
+        this.isAutoPounceFollowup = signals_core_module_w(()=>{
+            const latestMessage = this.latestTrackablePounceMessage.value;
+            return latestMessage !== null && this.isAutoPounceMessage(latestMessage);
+        });
+        this.lastTrackablePounceMessageTimestamp = signals_core_module_w(()=>{
+            var _ref;
+            var _this_findLatestTrackablePounceEntry;
+            return (_ref = (_this_findLatestTrackablePounceEntry = this.findLatestTrackablePounceEntry()) == null ? void 0 : _this_findLatestTrackablePounceEntry.timestamp) != null ? _ref : null;
+        });
+        // Only count pounce messages that arrived after the URL change.
+        // This prevents old messages from triggering idle pounces on return visits.
+        this.lastTrackablePounceMessageAfterUrlChange = signals_core_module_w(()=>{
+            var _ref;
+            var _this_findLatestTrackablePounceEntry;
+            const urlChangeTime = this.urlChangeTimestamp.value;
+            return (_ref = (_this_findLatestTrackablePounceEntry = this.findLatestTrackablePounceEntry(urlChangeTime)) == null ? void 0 : _this_findLatestTrackablePounceEntry.timestamp) != null ? _ref : null;
+        });
+        // Private state
+        this.tabOpenedAt = Date.now();
+        this.timeToStartTracking = null;
+        this.timerDisposer = ()=>{};
+        this.windowFocusDisposer = ()=>{};
+        this.windowBlurDisposer = ()=>{};
+        this.pageVisibilityDisposer = ()=>{};
+        this.trackingStarted = signals_core_module_d(false);
+        this.visitorHasTyped = signals_core_module_d(false);
+        this.scrollObserver = null;
+        this.triggeredScrollPounceIds = new Set();
+        this.lastUrl = null;
+        this.idleGenerationRequested = false;
+        this.autoPounceNudgeRequested = false;
+        this.triggeredIdlePounceId = signals_core_module_d(null);
+        this.hasScrolledForCurrentUrl = signals_core_module_d(false);
+        this.firstScrollDisposer = ()=>{};
+        this.urlObserver = null;
+        this.pendingScrollPounce = null;
+        this.scrollPouncePreDelayTimer = null;
+        this.scrollPounceDebounceTimer = null;
+        this.startUrlObservation = ()=>{
+            this.urlObserver = new UrlObserver((url)=>{
+                this.currentUrl.value = url;
+            });
+            this.urlObserver.start();
+        };
+        this.notifyVisitorTyped = ()=>{
+            this.visitorHasTyped.value = true;
+            this.timeToStartTracking = null;
+            this.stopBehaviorTracking();
+            this.firstScrollDisposer();
+            this.teardownScrollTracking();
+            this.clearPendingScrollPounce();
+        };
+        this.notifyCallRequested = ()=>{
+            this.aiSdrCallRequested.value = true;
+            this.stopBehaviorTracking();
+            this.firstScrollDisposer();
+            this.teardownScrollTracking();
+            this.clearPendingScrollPounce();
+        };
+        this.startBehaviorTracking = ()=>{
+            var _this_lastTrackablePounceMessageAfterUrlChange_value;
+            // Start timing from the fresh assistant message, not from now.
+            // This ensures idle thresholds are measured from when the initial pounce was sent.
+            // Clamp to tabOpenedAt so a newly opened tab always waits the full threshold
+            // from its own open time, even when the initial pounce message predates it
+            // (e.g. the visitor opened a second tab on a conversation that already sent one).
+            const lastMessageTime = (_this_lastTrackablePounceMessageAfterUrlChange_value = this.lastTrackablePounceMessageAfterUrlChange.value) != null ? _this_lastTrackablePounceMessageAfterUrlChange_value : Date.now();
+            this.timeToStartTracking = Math.max(lastMessageTime, this.tabOpenedAt);
+            this.startWindowFocusTracking();
+            this.startWindowBlurTracking();
+            this.startPageVisibilityTracking();
+            this.timerDisposer = every(500, ()=>{
+                if (this.timeToStartTracking === null) {
+                    return;
+                }
+                const currentTime = Date.now();
+                const timeElapsed = currentTime - this.timeToStartTracking;
+                const lastTrackablePounceMessageTimestamp = this.lastTrackablePounceMessageTimestamp.value;
+                const msFromLastTrackablePounceMessageOrNull = lastTrackablePounceMessageTimestamp !== null ? currentTime - lastTrackablePounceMessageTimestamp : null;
+                const idlePounce = this.idlePounceForCurrentUrl.value;
+                const { activeThresholdMs } = this;
+                if (this.isAutoPounceFollowup.value) {
+                    if (!this.autoPounceNudgeRequested && timeElapsed >= activeThresholdMs && (msFromLastTrackablePounceMessageOrNull === null || msFromLastTrackablePounceMessageOrNull > activeThresholdMs)) {
+                        this.triggerAutoPounceNudge();
+                    }
+                } else if (!this.idleGenerationRequested && timeElapsed >= IDLE_GENERATION_THRESHOLD_MS && (msFromLastTrackablePounceMessageOrNull === null || msFromLastTrackablePounceMessageOrNull > IDLE_GENERATION_THRESHOLD_MS)) {
+                    this.generateIdleFollowupPounce();
+                } else if (this.idleGenerationRequested && idlePounce && timeElapsed >= activeThresholdMs && (msFromLastTrackablePounceMessageOrNull === null || msFromLastTrackablePounceMessageOrNull > activeThresholdMs)) {
+                    this.triggerIdleFollowupPounce();
+                } else if (this.idleGenerationRequested && !idlePounce && timeElapsed >= IDLE_GENERATION_THRESHOLD_MS + IDLE_GENERATION_TIMEOUT_MS) {
+                    this.stopBehaviorTracking();
+                }
+            });
+        };
+        this.getTitleAndDescription = ()=>{
+            const metaDescription = document.querySelector('meta[name="description"]');
+            let description = null;
+            if (metaDescription instanceof HTMLMetaElement) {
+                description = metaDescription.content;
+            }
+            const title = this.resolveTitle();
+            return {
+                title,
+                description
+            };
+        };
+        this.resolveTitle = ()=>{
+            const documentTitle = document.title;
+            // Hack to prevent "Message from" title flashes from being fed to the backend
+            // Needed only temporarily until we start using chunks in auto pounce instead of the HTML title
+            if (documentTitle.startsWith("Message from")) {
+                return null;
+            }
+            return documentTitle;
+        };
+        this.startWindowFocusTracking = ()=>{
+            this.windowFocusDisposer = addEventListener(window, "focus", ()=>{
+                this.timeToStartTracking = Date.now();
+            });
+        };
+        this.startWindowBlurTracking = ()=>{
+            this.windowBlurDisposer = addEventListener(window, "blur", ()=>{
+                this.timeToStartTracking = null;
+            });
+        };
+        this.startPageVisibilityTracking = ()=>{
+            this.pageVisibilityDisposer = addEventListener(document, "visibilitychange", ()=>{
+                if (document.visibilityState === "visible") {
+                    this.timeToStartTracking = Date.now();
+                } else {
+                    this.timeToStartTracking = null;
+                }
+            });
+        };
+        this.stopBehaviorTracking = ()=>{
+            this.windowFocusDisposer();
+            this.windowBlurDisposer();
+            this.pageVisibilityDisposer();
+            this.timerDisposer();
+        };
+        this.setupScrollTracking = (scrollPounces, currentUrl)=>{
+            if (scrollPounces.length === 0 || this.scrollObserver) return;
+            this.scrollObserver = new IntersectionObserver((entries)=>{
+                entries.forEach((entry)=>{
+                    var _this_scrollObserver;
+                    if (!entry.isIntersecting) return;
+                    const pounce = this.findPounceForElement(scrollPounces, entry.target);
+                    if (!pounce) return;
+                    this.handleScrollPounce(pounce, currentUrl);
+                    (_this_scrollObserver = this.scrollObserver) == null ? void 0 : _this_scrollObserver.unobserve(entry.target);
+                });
+            }, {
+                rootMargin: "-5% 0px -40% 0px"
+            });
+            scrollPounces.forEach((pounce)=>this.observePounceTriggers(pounce));
+        };
+        this.teardownScrollTracking = ()=>{
+            var _this_scrollObserver;
+            (_this_scrollObserver = this.scrollObserver) == null ? void 0 : _this_scrollObserver.disconnect();
+            this.scrollObserver = null;
+        };
+        this.registerFirstScrollListener = ()=>{
+            this.firstScrollDisposer = addEventListener(window, "scroll", ()=>{
+                this.hasScrolledForCurrentUrl.value = true;
+                this.firstScrollDisposer();
+            }, {
+                passive: true
+            });
+        };
+        this.observePounceTriggers = (pounce)=>{
+            if (!pounce.trigger || !this.scrollObserver) return;
+            const elements = this.getElementsForPounce(pounce);
+            elements.forEach((el)=>{
+                var _this_scrollObserver;
+                return (_this_scrollObserver = this.scrollObserver) == null ? void 0 : _this_scrollObserver.observe(el);
+            });
+        };
+        this.getElementsForPounce = (pounce)=>{
+            var _pounce_trigger;
+            const trigger = (_pounce_trigger = pounce.trigger) == null ? void 0 : _pounce_trigger.trim();
+            if (!trigger) return [];
+            // This must be in sync with the ALLOWED_TRIGGER_TAGS in PageStructureAnalyzer.rb
+            const CONTENT_TAGS = [
+                "h1",
+                "h2",
+                "h3",
+                "h4",
+                "h5",
+                "h6",
+                "p",
+                "li",
+                "a",
+                "span",
+                "strong",
+                "em"
+            ];
+            const all = document.querySelectorAll(CONTENT_TAGS.join(", "));
+            return Array.from(all).filter((el)=>{
+                var _el_textContent;
+                return (_el_textContent = el.textContent) == null ? void 0 : _el_textContent.includes(trigger);
+            });
+        };
+        this.handleScrollPounce = (pounce, currentUrl)=>{
+            if (this.triggeredScrollPounceIds.has(pounce.id)) return;
+            if (!pounce.baseUrl || pounce.baseUrl !== currentUrl) return;
+            if (this.visitorResponded.value || this.userResponded.value) return;
+            // Clear any existing pre-delay/debounce timers (last pounce wins).
+            if (this.scrollPouncePreDelayTimer !== null) {
+                pounce_tracking_store_v2_clearTimeout(this.scrollPouncePreDelayTimer);
+                this.scrollPouncePreDelayTimer = null;
+            }
+            if (this.scrollPounceDebounceTimer !== null) {
+                pounce_tracking_store_v2_clearTimeout(this.scrollPounceDebounceTimer);
+                this.scrollPounceDebounceTimer = null;
+            }
+            // Store the pending pounce (last one wins)
+            this.pendingScrollPounce = {
+                pounce,
+                url: currentUrl
+            };
+            const lastAssistantMessageTimestamp = this.lastTrackablePounceMessageTimestamp.value;
+            const msSinceLastAssistantMessage = lastAssistantMessageTimestamp !== null ? Date.now() - lastAssistantMessageTimestamp : Number.POSITIVE_INFINITY;
+            const preDebounceDelayMs = Math.max(0, this.activeThresholdMs - SCROLL_POUNCE_DEBOUNCE_MS - msSinceLastAssistantMessage);
+            if (preDebounceDelayMs > 0) {
+                this.scrollPouncePreDelayTimer = pounce_tracking_store_v2_setTimeout(()=>{
+                    this.scrollPouncePreDelayTimer = null;
+                    this.startScrollPounceDebounce();
+                }, preDebounceDelayMs);
+                return;
+            }
+            this.startScrollPounceDebounce();
+        };
+        this.startScrollPounceDebounce = ()=>{
+            this.rootStore.setTypingIndicator(true);
+            this.scrollPounceDebounceTimer = pounce_tracking_store_v2_setTimeout(()=>{
+                this.executePendingScrollPounce();
+            }, SCROLL_POUNCE_DEBOUNCE_MS);
+        };
+        this.executePendingScrollPounce = ()=>{
+            const pending = this.pendingScrollPounce;
+            if (!pending) return;
+            const { pounce, url } = pending;
+            this.pendingScrollPounce = null;
+            this.scrollPounceDebounceTimer = null;
+            // Re-check conditions haven't changed during debounce
+            const shouldAbort = this.isCallRequested.value || this.visitorHasTyped.value || this.triggeredScrollPounceIds.has(pounce.id) || this.currentUrl.value !== url || this.visitorResponded.value || this.userResponded.value || this.triggeredIdlePounceId.value !== null;
+            if (shouldAbort) {
+                this.rootStore.setTypingIndicator(false);
+                return;
+            }
+            this.triggeredScrollPounceIds.add(pounce.id);
+            this.rootStore.channel.perform("trigger_multimodal_pounce", {
+                pounce_id: pounce.id,
+                base_url: pounce.baseUrl,
+                trigger: pounce.trigger,
+                pounce_type: pounce.pounceType
+            }).then(()=>{
+                this.rootStore.setTypingIndicator(false);
+            });
+            this.stopBehaviorTracking();
+        };
+        this.clearPendingScrollPounce = ()=>{
+            if (this.scrollPouncePreDelayTimer !== null) {
+                pounce_tracking_store_v2_clearTimeout(this.scrollPouncePreDelayTimer);
+                this.scrollPouncePreDelayTimer = null;
+            }
+            if (this.scrollPounceDebounceTimer !== null) {
+                pounce_tracking_store_v2_clearTimeout(this.scrollPounceDebounceTimer);
+                this.scrollPounceDebounceTimer = null;
+            }
+            // Turn off typing indicator if we had a pending pounce that's being cancelled
+            if (this.pendingScrollPounce !== null) {
+                this.rootStore.setTypingIndicator(false);
+            }
+            this.pendingScrollPounce = null;
+        };
+        // Auto pounce nudge
+        this.triggerAutoPounceNudge = ()=>{
+            if (this.isCallRequested.value || this.visitorResponded.value || this.userResponded.value || this.autoPounceNudgeRequested || this.triggeredScrollPounceIds.size > 0 || this.pendingScrollPounce !== null) return;
+            const { title, description } = this.getTitleAndDescription();
+            this.autoPounceNudgeRequested = true;
+            this.rootStore.channel.perform("trigger_nudge_pounce", {
+                title,
+                description,
+                source: "auto_pounce"
+            });
+            this.stopBehaviorTracking();
+            this.firstScrollDisposer();
+            this.teardownScrollTracking();
+        };
+        // Idle followup
+        this.generateIdleFollowupPounce = ()=>{
+            if (this.isCallRequested.value) return;
+            if (this.triggeredScrollPounceIds.size > 0 || this.pendingScrollPounce !== null) return;
+            this.idleGenerationRequested = true;
+            const { title, description } = this.getTitleAndDescription();
+            this.rootStore.channel.perform("generate_multimodal_pounce", {
+                pounce_types: [
+                    "idle_followup"
+                ],
+                title,
+                description
+            });
+        };
+        this.triggerIdleFollowupPounce = ()=>{
+            if (this.isCallRequested.value || this.visitorResponded.value || this.userResponded.value || this.triggeredIdlePounceId.value || this.triggeredScrollPounceIds.size > 0 || this.pendingScrollPounce !== null) return;
+            const currentUrl = this.currentUrl.value;
+            if (!currentUrl) return;
+            const pounce = this.idlePounceForCurrentUrl.value;
+            if (!pounce) return;
+            this.rootStore.setTypingIndicator(true);
+            this.rootStore.channel.perform("trigger_multimodal_pounce", {
+                pounce_id: pounce.id,
+                base_url: pounce.baseUrl,
+                trigger: pounce.trigger,
+                pounce_type: pounce.pounceType
+            }).then(()=>{
+                this.rootStore.setTypingIndicator(false);
+            });
+            this.triggeredIdlePounceId.value = pounce.id;
+            this.stopBehaviorTracking();
+            this.firstScrollDisposer();
+            this.teardownScrollTracking();
+        };
+    }
+}
+/* export default */ const pounce_tracking_store_v2 = (PounceTrackingStoreV2);
+
+export { ACTIVE_THRESHOLD_MS, IDLE_GENERATION_THRESHOLD_MS, IDLE_GENERATION_TIMEOUT_MS, PounceTrackingStoreV2, SCROLL_POUNCE_DEBOUNCE_MS };
+export default pounce_tracking_store_v2;

package/widget/multimodal_v2/stores/presentations_store.js

@@ -0,0 +1,111 @@
+import { signals_core_module_d, signals_core_module_w, signals_core_module_E, signals_core_module_n } from "../../../js/multimodal_v2.js";
+
+
+class PresentationsStore {
+    dispose() {
+        this.unsubscribeArtifact == null ? void 0 : this.unsubscribeArtifact.call(this);
+        this.unsubscribeArtifact = null;
+        this.disposeInterruptEffect == null ? void 0 : this.disposeInterruptEffect.call(this);
+        this.disposeTextInterruptEffect == null ? void 0 : this.disposeTextInterruptEffect.call(this);
+    }
+    constructor(rootStore){
+        // The demo clip currently open in the artifact overlay. A single continuous
+        // span plays start -> end; there are no title slides, transition slides, or
+        // chapters — the agent shares one clip at a time and narrates over it.
+        this.currentPresentation = signals_core_module_w(()=>{
+            const message = this.rootStore.artifact.message.value;
+            if (!message || message.type !== "present_video") return null;
+            // Older messages carry only startTime/endTime; treat that as a single segment.
+            const segments = message.segments && message.segments.length > 0 ? message.segments : [
+                {
+                    start: message.startTime,
+                    end: message.endTime
+                }
+            ];
+            return {
+                messageId: message.id,
+                presentationId: message.presentationId,
+                sectionId: message.sectionId,
+                videoUrl: message.videoUrl,
+                segments,
+                startTime: segments[0].start,
+                endTime: segments[segments.length - 1].end,
+                sectionTitle: message.sectionTitle,
+                presentationTitle: message.presentationTitle
+            };
+        });
+        // Set true when the visitor interrupts; the component reads this to pause the
+        // video. Reset to false when a new clip takes over (resume / next / jump).
+        this.stopped = signals_core_module_d(false);
+        // Current playback position in seconds, written by the video component on
+        // timeupdate. Reported to the backend on interruption so the agent knows where
+        // the video paused and can navigate relative to it.
+        this.currentTimeSeconds = signals_core_module_d(0);
+        // Everything below is private
+        this.lastClipMessageId = null;
+        this.lastVisitorTextMessageId = null;
+        this.unsubscribeArtifact = null;
+        this.disposeInterruptEffect = null;
+        this.disposeTextInterruptEffect = null;
+        // The visitor spoke/typed over the demo. Pause and report where playback stopped
+        // so the agent can address them and later continue/replay/skip from there.
+        this.handleInterruption = ()=>{
+            if (this.stopped.value) return;
+            const pres = this.currentPresentation.value;
+            if (!pres) return;
+            this.rootStore.channel.perform("notify_presentation_interrupted", {
+                presentation_id: pres.presentationId,
+                from_seconds: Math.round(this.currentTimeSeconds.value)
+            });
+            this.stopped.value = true;
+        };
+        this.rootStore = rootStore;
+        // Reset per-clip playback state whenever a new present_video takes over the
+        // artifact, so a resumed/next clip plays again after a prior interruption.
+        this.unsubscribeArtifact = this.rootStore.artifact.message.subscribe((message)=>{
+            var _message_startTime;
+            if ((message == null ? void 0 : message.type) !== "present_video") {
+                this.lastClipMessageId = null;
+                return;
+            }
+            if (message.id === this.lastClipMessageId) return;
+            this.lastClipMessageId = message.id;
+            this.stopped.value = false;
+            this.currentTimeSeconds.value = (_message_startTime = message.startTime) != null ? _message_startTime : 0;
+        });
+        // Halt the moment the visitor speaks over the demo (barge-in): pause the video
+        // and tell the agent where it stopped so it can respond and later move around.
+        // Depend ONLY on isVisitorSpeaking. handleInterruption reads currentPresentation /
+        // stopped, so calling it untracked keeps those out of this effect's deps — otherwise
+        // a new demo arriving while the visitor is speaking would re-run this and interrupt
+        // the fresh clip the instant it loads.
+        this.disposeInterruptEffect = signals_core_module_E(()=>{
+            var _ref;
+            var _this_rootStore_callStore_value_isVisitorSpeaking, _this_rootStore_callStore_value, _this_rootStore_callStore;
+            const speaking = (_ref = (_this_rootStore_callStore = this.rootStore.callStore) == null ? void 0 : (_this_rootStore_callStore_value = _this_rootStore_callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_isVisitorSpeaking = _this_rootStore_callStore_value.isVisitorSpeaking) == null ? void 0 : _this_rootStore_callStore_value_isVisitorSpeaking.value) != null ? _ref : false;
+            if (speaking) signals_core_module_n(()=>this.handleInterruption());
+        });
+        // A visitor text message sent mid-demo is a text-mode interruption with the
+        // same effect as speaking over the video. Seed from existing history so we only
+        // react to a message sent AFTER this store is watching, not to backlog.
+        this.lastVisitorTextMessageId = latestVisitorTextId(this.rootStore.messages.value);
+        this.disposeTextInterruptEffect = signals_core_module_E(()=>{
+            const latestId = latestVisitorTextId(this.rootStore.messages.value);
+            if (latestId === null || latestId === this.lastVisitorTextMessageId) return;
+            this.lastVisitorTextMessageId = latestId;
+            signals_core_module_n(()=>this.handleInterruption());
+        });
+    }
+}
+
+// Id of the most recent visitor-authored text message in the list, or null if
+// there is none. Used to detect a text-mode interruption of a live demo.
+function latestVisitorTextId(messages) {
+    for(let i = messages.length - 1; i >= 0; i--){
+        const message = messages[i];
+        if (message.type === "text" && message.isOwn) return message.id;
+    }
+    return null;
+}
+
+export default PresentationsStore;