@qualified-salesforce/web 0.0.1-oidc-bootstrap → 0.1.1

package/widget/multimodal_v2/stores/decks_store.js

@@ -1,14 +1,36 @@
 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 { DeckMode as types_DeckMode } from "../types.js";
 import "../../utils/native_globals.js";
 
 /* provided dependency */ var decks_store_setTimeout = __webpack_require__(68034).pS;
 /* provided dependency */ var decks_store_clearTimeout = __webpack_require__(68034).Kj;
+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);
+}
+
 
 // Floor for how long a slide stays up before auto-advancing. A slide whose
 // talk-track generation failed has an estimated duration of 0; without a floor
 // setTimeout(…, 0) would flash through the whole sequence instantly.
+// An absent estimate is legacy unknown timing and is not auto-completed.
 const MIN_SLIDE_DURATION_MS = 2000;
+// Matches the server-side deck-ready wait. If Coffee never reports a silent
+// boundary (for example on an older/partial client where the lead-in flows
+// directly into narration), start timing when the server releases the tool on
+// its timeout rather than leaving the deck frozen forever.
+const DECK_READY_TIMEOUT_MS = 3000;
 class DecksStore {
     dispose() {
         this.unsubscribeArtifact == null ? void 0 : this.unsubscribeArtifact.call(this);
@@ -17,13 +39,46 @@ class DecksStore {
         this.disposeInterruptEffect = null;
         this.disposeTextInterruptEffect == null ? void 0 : this.disposeTextInterruptEffect.call(this);
         this.disposeTextInterruptEffect = null;
+        this.disposeNarrationStartEffect == null ? void 0 : this.disposeNarrationStartEffect.call(this);
+        this.disposeNarrationStartEffect = null;
+        this.disposeDeckReadyEffect == null ? void 0 : this.disposeDeckReadyEffect.call(this);
+        this.disposeDeckReadyEffect = null;
+        this.clearPendingDeckReady();
+        this.clearNarrationStart();
         this.clearAdvanceTimer();
+        // The starting state's watch and deadline are armed by the artifact store but
+        // are waiting on state that lives here, so they go down with it.
+        this.rootStore.artifactStore.stopWatchingDeckPresentation();
+    }
+    // Called by the guided deck image's load event. Send at most one readiness
+    // acknowledgement per presentation message; later slide loads do not gate the
+    // already-running narration turn.
+    notifyCurrentSlideReady() {
+        var _this_deckReadyDeadlineAt;
+        const message = this.rootStore.artifact.message.peek();
+        const deck = this.currentDeck.peek();
+        if (!message || message.type !== "present_deck" || message.navigationOnly || !message.syncNarration || this.stopped.peek()) {
+            return;
+        }
+        if (!deck || deck.mode !== types_DeckMode.Guided || deck.sequencePosition !== 0) return;
+        if (this.readyMessageIds.has(message.id)) return;
+        this.clearDeckReadyFallbackTimer();
+        const fallbackDelay = Math.max(0, ((_this_deckReadyDeadlineAt = this.deckReadyDeadlineAt) != null ? _this_deckReadyDeadlineAt : Date.now() + DECK_READY_TIMEOUT_MS) - Date.now());
+        this.deckReadyFallbackTimerId = decks_store_setTimeout(()=>{
+            var _ref;
+            var _this_rootStore_callStore_value_isBotSpeaking, _this_rootStore_callStore_value;
+            if (this.pendingReadyMessageId.peek() !== message.id || this.stopped.peek()) return;
+            const speaking = (_ref = (_this_rootStore_callStore_value = this.rootStore.callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_isBotSpeaking = _this_rootStore_callStore_value.isBotSpeaking) == null ? void 0 : _this_rootStore_callStore_value_isBotSpeaking.peek()) != null ? _ref : false;
+            this.releaseDeckReady(message.id, speaking);
+        }, fallbackDelay);
+        this.pendingReadyMessageId.value = message.id;
     }
     // Show a single slide statically (visitor clicked it in the transcript record).
     // Set the revisit target before the artifact overlay opens so the artifact
     // subscription treats the open as a revisit rather than a fresh presentation.
     prepareRevisit(messageId, slideIndex, pageTitle) {
         this.clearAdvanceTimer();
+        this.clearSelfGuided();
         this.stopped.value = true;
         this.revisitMessageId = messageId;
         // Set the title before the index signal, which triggers the currentDeck recompute.
@@ -33,11 +88,55 @@ class DecksStore {
     isRevisiting(messageId) {
         return this.revisitMessageId === messageId && this.revisitIndex.peek() != null;
     }
+    // Hand the deck over to the visitor: they step through it themselves from the
+    // interactive viewer. Like prepareRevisit this is set BEFORE the artifact
+    // overlay opens, so the artifact subscription treats the open as self-guided
+    // rather than a fresh presentation. `stopped` keeps the interruption effects
+    // inert — there is no narration to barge in on.
+    //
+    // Deliberately never auto-advances, unlike the guided path next door: the
+    // visitor sets the pace, and a timer would fight the arrows they are using.
+    prepareSelfGuidedPlayback(messageId, startIndex) {
+        if (startIndex === void 0) startIndex = 0;
+        this.clearAdvanceTimer();
+        this.clearRevisit();
+        this.stopped.value = true;
+        this.selfGuidedMessageId = messageId;
+        this.selfGuidedIndex.value = Math.max(startIndex, 0);
+    }
+    isSelfGuided(messageId) {
+        return this.selfGuidedMessageId === messageId && this.selfGuidedIndex.peek() != null;
+    }
+    // The visitor has handed the deck to Piper and the call is starting. Holds the
+    // slide they were on with the viewer's controls dropped, which is the whole of
+    // the state — see CurrentDeck#starting.
+    //
+    // Self-guided underneath, with the same index it always had: the deck is still
+    // in the visitor's hands until Piper's own share replaces this message, and
+    // going through the same preparation means the path in from the timeline card
+    // and the path in from the viewer arrive at the same place. From the viewer that
+    // makes this a no-op plus a flag — it is already this message, at this index.
+    prepareStartingPresentation(messageId, startIndex) {
+        if (startIndex === void 0) startIndex = 0;
+        this.prepareSelfGuidedPlayback(messageId, startIndex);
+        this.startingMessageId.value = messageId;
+    }
+    // Give the deck back to the visitor, leaving them on the slide they handed over
+    // — the whole of what undoing this state means, since the viewer underneath was
+    // never dismantled. Piper arriving does not come through here: her share is a
+    // different message, and the artifact change clears this along with the rest of
+    // the visitor's playback state.
+    cancelStartingPresentation() {
+        this.startingMessageId.value = null;
+    }
+    goToNextSlide() {
+        this.stepSlide(1);
+    }
+    goToPreviousSlide() {
+        this.stepSlide(-1);
+    }
     // Fire-and-forget the current on-screen slide + the full sequence to the backend,
-    // which computes the remaining slides and seeds the agent's context. The early
-    // return in handleInterruption (guarding on `stopped`) makes this fire exactly
-    // once per guided run; a new deck message resets `stopped` so a later resume can
-    // be interrupted and re-report.
+    // which computes the remaining slides and seeds the agent's context.
     notifyInterruption(message) {
         var _ref, _message_slides;
         var _message_slides1;
@@ -52,22 +151,34 @@ class DecksStore {
         });
     }
     scheduleAdvance(slides) {
-        var _ref;
-        var _slides_, _slides_position;
-        if (this.stopped.value) return; // visitor interrupted — do not advance
+        var _currentSlide_estimatedDurationMs;
+        if (this.stopped.value || slides.length === 0) return;
         const position = this.playbackIndex.value;
-        if (position >= slides.length - 1) return; // last slide — stop advancing
-        // Warm the browser cache for the next slide's image now, while the current one
-        // is on screen, so the auto-advance swap doesn't flash a blank/stale frame
-        // while the full-res PDF page downloads (narration keeps pace regardless).
-        this.preloadImage((_slides_ = slides[position + 1]) == null ? void 0 : _slides_.imageUrl);
-        // Each slide stays up for as long as its talk track takes to narrate, but
-        // never less than the floor (a failed talk track estimates to 0ms).
-        const durationMs = Math.max((_ref = (_slides_position = slides[position]) == null ? void 0 : _slides_position.estimatedDurationMs) != null ? _ref : 0, MIN_SLIDE_DURATION_MS);
+        const currentSlide = slides[position];
+        if (!currentSlide) return;
+        if (position >= slides.length - 1 && currentSlide.estimatedDurationMs === undefined) {
+            return;
+        }
+        const durationMs = Math.max((_currentSlide_estimatedDurationMs = currentSlide.estimatedDurationMs) != null ? _currentSlide_estimatedDurationMs : MIN_SLIDE_DURATION_MS, MIN_SLIDE_DURATION_MS);
+        if (position < slides.length - 1) {
+            var _slides_;
+            // Warm the browser cache for the next slide's image now, while the current one
+            // is on screen, so the auto-advance swap doesn't flash a blank/stale frame
+            // while the full-res PDF page downloads (narration keeps pace regardless).
+            this.preloadImage((_slides_ = slides[position + 1]) == null ? void 0 : _slides_.imageUrl);
+        }
         this.advanceTimerId = decks_store_setTimeout(()=>{
             this.advanceTimerId = null;
             if (this.stopped.value) return;
-            this.playbackIndex.value = Math.min(this.playbackIndex.value + 1, slides.length - 1);
+            if (position >= slides.length - 1) {
+                this.rootStore.presentationTelemetryStore.onDeckFinalDisplayIntervalComplete();
+                return;
+            }
+            this.playbackIndex.value = position + 1;
+            const nextSlide = slides[position + 1];
+            if (nextSlide) {
+                this.rootStore.presentationTelemetryStore.onDeckSlideRendered(nextSlide.pageId, nextSlide.slideIndex, nextSlide.pageTitle);
+            }
             this.scheduleAdvance(slides);
         }, durationMs);
     }
@@ -76,12 +187,71 @@ class DecksStore {
         this.revisitIndex.value = null;
         this.revisitPageTitle = undefined;
     }
+    clearSelfGuided() {
+        this.selfGuidedMessageId = null;
+        this.selfGuidedIndex.value = null;
+        // The starting state is a state of self-guided playback, so it cannot outlive
+        // it. This is what makes Piper's arrival the end of it for free: her share is
+        // a new message, and handling it clears the visitor's playback wholesale.
+        this.startingMessageId.value = null;
+    }
+    // Move one slide, stopping at either end. Wrapping would silently restart the
+    // deck; a disabled arrow says what happened.
+    stepSlide(delta) {
+        var _ref;
+        var _this_currentDeck_peek;
+        const current = this.selfGuidedIndex.peek();
+        if (current == null) return;
+        const length = (_ref = (_this_currentDeck_peek = this.currentDeck.peek()) == null ? void 0 : _this_currentDeck_peek.slideImageUrls.length) != null ? _ref : 0;
+        const next = current + delta;
+        if (next < 0 || next >= length) return;
+        this.selfGuidedIndex.value = next;
+    }
     clearAdvanceTimer() {
         if (this.advanceTimerId !== null) {
             decks_store_clearTimeout(this.advanceTimerId);
             this.advanceTimerId = null;
         }
     }
+    releaseDeckReady(messageId, continuousSpeechFallback) {
+        if (this.pendingReadyMessageId.peek() !== messageId) return;
+        this.clearPendingDeckReady();
+        if (this.readyMessageIds.has(messageId)) return;
+        this.readyMessageIds.add(messageId);
+        if (continuousSpeechFallback) {
+            // The server releases present_deck after the same timeout. With no usable
+            // silence/sequence boundary, this is the closest observable narration
+            // anchor and, critically, prevents permanent first-slide stalls.
+            this.clearNarrationStart();
+            this.scheduleAdvance(this.sequence.peek());
+        } else {
+            var _ref;
+            var _this_rootStore_callStore_value_voiceAnswerSequence, _this_rootStore_callStore_value;
+            // Snapshot only after the slide is visible and the lead-in has stopped.
+            // Any delayed preamble marker received before this point becomes part of
+            // the baseline rather than being mistaken for the narration response.
+            this.narrationAnswerBaseline = (_ref = (_this_rootStore_callStore_value = this.rootStore.callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_voiceAnswerSequence = _this_rootStore_callStore_value.voiceAnswerSequence) == null ? void 0 : _this_rootStore_callStore_value_voiceAnswerSequence.peek()) != null ? _ref : null;
+            this.awaitingNarrationStart.value = true;
+        }
+        this.rootStore.channel.perform("notify_deck_ready", {
+            presentation_message_id: messageId
+        });
+    }
+    clearDeckReadyFallbackTimer() {
+        if (this.deckReadyFallbackTimerId !== null) {
+            decks_store_clearTimeout(this.deckReadyFallbackTimerId);
+            this.deckReadyFallbackTimerId = null;
+        }
+    }
+    clearPendingDeckReady() {
+        this.pendingReadyMessageId.value = null;
+        this.deckReadyDeadlineAt = null;
+        this.clearDeckReadyFallbackTimer();
+    }
+    clearNarrationStart() {
+        this.awaitingNarrationStart.value = false;
+        this.narrationAnswerBaseline = null;
+    }
     // Kick off a background fetch of an image URL so it's cached before it's shown. Crossorigin
     // like every other slide load, so this warm-up can't be the one that caches an ACAO-less
     // response and poisons the entry the visible <img> needs.
@@ -97,7 +267,7 @@ class DecksStore {
         this.rootStore = rootStore;
         // Derived state: the deck slide currently presented in the ARTIFACT overlay.
         //
-        // A single share_deck tool call can present one slide or an auto-advancing
+        // A single present_deck tool call can present one slide or an auto-advancing
         // sequence. The slide on screen is `slides[playbackIndex]`; for legacy/single
         // messages the index comes straight from the message.
         this.currentDeck = signals_core_module_w(()=>{
@@ -108,11 +278,43 @@ class DecksStore {
             const slideImageUrls = ((_message_slideImageUrls = message.slideImageUrls) == null ? void 0 : _message_slideImageUrls.length) > 0 ? message.slideImageUrls : [
                 message.imageUrl
             ];
+            // Self-guided: the visitor opened the deck from its timeline card and steps
+            // through it themselves. The whole deck is in scope — every image the
+            // message carries, not just the slides this share presented — so position
+            // and length come from slideImageUrls.
+            //
+            // Only ever for the share the visitor is actually driving. The position is
+            // theirs and so is the message it is a position in, so a different message
+            // being on screen means this branch is not what the deck is, whatever is left
+            // in the position. `handleArtifactMessageChange` clears that leftover a moment
+            // later; checking the id means nothing can observe the gap, where before this
+            // branch would answer for Piper's share with the visitor's chrome — and with
+            // `starting` false, since that is keyed to the visitor's message too. The
+            // field is read rather than subscribed to because it never changes without
+            // `selfGuidedIndex` changing in the same breath, which is what recomputes this.
+            const selfGuidedIndex = this.selfGuidedIndex.value;
+            if (selfGuidedIndex != null && message.id === this.selfGuidedMessageId) {
+                var _ref3;
+                const currentIndex = clampIndex(selfGuidedIndex, slideImageUrls.length);
+                const slide = this.presentedSlides.value.get(currentIndex);
+                return {
+                    deckId: message.deckId,
+                    slideImageUrls,
+                    currentIndex,
+                    sequencePosition: currentIndex,
+                    sequenceLength: slideImageUrls.length,
+                    pageTitle: (_ref3 = slide == null ? void 0 : slide.pageTitle) != null ? _ref3 : message.pageTitle,
+                    deckTitle: message.deckTitle,
+                    mode: types_DeckMode.SelfGuided,
+                    starting: this.startingMessageId.value === message.id,
+                    caption: slide == null ? void 0 : slide.talkTrack
+                };
+            }
             // Revisit: the visitor clicked a slide in the transcript record. Show that
             // single slide statically (no auto-advance, no progress dots).
             const revisitIndex = this.revisitIndex.value;
             if (revisitIndex != null) {
-                var _ref3, _this_revisitPageTitle;
+                var _ref4, _this_revisitPageTitle;
                 var _message_slides_find, _message_slides;
                 return {
                     deckId: message.deckId,
@@ -120,8 +322,10 @@ class DecksStore {
                     currentIndex: clampIndex(revisitIndex, slideImageUrls.length),
                     sequencePosition: 0,
                     sequenceLength: 1,
-                    pageTitle: (_ref3 = (_this_revisitPageTitle = this.revisitPageTitle) != null ? _this_revisitPageTitle : (_message_slides = message.slides) == null ? void 0 : (_message_slides_find = _message_slides.find((slide)=>slide.slideIndex === revisitIndex)) == null ? void 0 : _message_slides_find.pageTitle) != null ? _ref3 : message.pageTitle,
-                    deckTitle: message.deckTitle
+                    pageTitle: (_ref4 = (_this_revisitPageTitle = this.revisitPageTitle) != null ? _this_revisitPageTitle : (_message_slides = message.slides) == null ? void 0 : (_message_slides_find = _message_slides.find((slide)=>slide.slideIndex === revisitIndex)) == null ? void 0 : _message_slides_find.pageTitle) != null ? _ref4 : message.pageTitle,
+                    deckTitle: message.deckTitle,
+                    mode: types_DeckMode.Guided,
+                    starting: false
                 };
             }
             const sequence = this.sequence.value;
@@ -135,7 +339,9 @@ class DecksStore {
                 sequencePosition: position,
                 sequenceLength: sequence.length,
                 pageTitle: (_ref2 = slide == null ? void 0 : slide.pageTitle) != null ? _ref2 : message.pageTitle,
-                deckTitle: message.deckTitle
+                deckTitle: message.deckTitle,
+                mode: types_DeckMode.Guided,
+                starting: false
             };
         });
         // Everything below is private
@@ -145,6 +351,11 @@ class DecksStore {
         this.stopped = signals_core_module_d(false);
         this.advanceTimerId = null;
         this.lastHandledMessageId = null;
+        // The last guided sequence for the deck on screen. A go_to call arrives as a
+        // new one-slide navigation message, but it is still movement within this
+        // presentation. Retain the sequence so the progress dots remain oriented
+        // while auto-advance stays stopped on the requested slide.
+        this.presentationSequence = signals_core_module_d(null);
         // Set when the visitor clicks a slide in the transcript record to revisit it.
         // While set, `currentDeck` shows that single slide statically. Cleared when a
         // new/different deck message becomes the active artifact.
@@ -154,9 +365,25 @@ class DecksStore {
         // revisit shows the right title even when the active message (the last share)
         // doesn't contain that slide. Cleared alongside the revisit state.
         this.revisitPageTitle = undefined;
+        // 0-based position within the whole deck while the visitor drives it. Null
+        // whenever playback is agent-driven.
+        this.selfGuidedIndex = signals_core_module_d(null);
+        this.selfGuidedMessageId = null;
+        // The self-guided share whose call is starting, or null. Always one of the
+        // above — cleared with them by clearSelfGuided, so no artifact change can leave
+        // it behind.
+        this.startingMessageId = signals_core_module_d(null);
         this.unsubscribeArtifact = null;
         this.disposeInterruptEffect = null;
         this.disposeTextInterruptEffect = null;
+        this.disposeNarrationStartEffect = null;
+        this.disposeDeckReadyEffect = null;
+        this.awaitingNarrationStart = signals_core_module_d(false);
+        this.narrationAnswerBaseline = null;
+        this.pendingReadyMessageId = signals_core_module_d(null);
+        this.deckReadyFallbackTimerId = null;
+        this.deckReadyDeadlineAt = null;
+        this.readyMessageIds = new Set();
         // Id of the most recent visitor text message we've already accounted for, so a
         // text-mode interruption only fires for a genuinely new message.
         this.lastVisitorTextMessageId = null;
@@ -164,27 +391,79 @@ class DecksStore {
         // synthesized one-item sequence for legacy messages without a `slides` array.
         this.sequence = signals_core_module_w(()=>{
             var _message_slideIndex;
-            var _message_slides;
+            var _messageSlides_;
             const message = this.rootStore.artifact.message.value;
             if (!message || message.type !== "present_deck") return [];
-            if ((_message_slides = message.slides) == null ? void 0 : _message_slides.length) return message.slides;
-            return [
-                {
-                    pageId: message.pageId,
-                    slideIndex: (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : 0,
-                    imageUrl: message.imageUrl,
-                    pageTitle: message.pageTitle
+            const messageSlides = slidesForMessage(message);
+            if (!message.navigationOnly) return messageSlides;
+            const currentSlideIndex = (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : (_messageSlides_ = messageSlides[0]) == null ? void 0 : _messageSlides_.slideIndex;
+            const preserved = this.presentationSequence.value;
+            if ((preserved == null ? void 0 : preserved.deckId) === message.deckId && currentSlideIndex !== undefined && preserved.slides.some((slide)=>slide.slideIndex === currentSlideIndex)) {
+                return preserved.slides;
+            }
+            return messageSlides;
+        });
+        // Every slide of the active deck the widget can caption, keyed by slide index.
+        //
+        // A presentation can span several `present_deck` messages — the initial share
+        // plus any resume after an interruption, where the agent re-shares only the
+        // remaining slides. Merging them oldest-first means the latest share wins for a
+        // slide covered twice, so a slide's caption is the narration actually delivered
+        // on the resumed run.
+        //
+        // `deckPages` goes underneath as the base layer. Every share carries a seed
+        // caption for every page of the deck, so a visitor stepping past the slides the
+        // agent actually selected still gets a caption instead of a blank panel — the
+        // card's slide count promises the whole deck. `slides` layered on top means a
+        // slide that was presented shows what she said rather than the seed.
+        //
+        // The top layer often has no caption of its own, and the seed shows through
+        // rather than the slide blanking out. That happens for an off-call share, which
+        // narrates nothing, and for a slide still being narrated, whose talk track the
+        // server withholds until the turn ends (Message::PresentDeckSerializer#slides).
+        this.presentedSlides = signals_core_module_w(()=>{
+            const message = this.rootStore.artifact.message.value;
+            if (!message || message.type !== "present_deck") return new Map();
+            const forDeck = this.rootStore.messages.value.filter((m)=>m.type === "present_deck" && m.deckId === message.deckId);
+            if (!forDeck.some((m)=>m.id === message.id)) forDeck.push(message);
+            forDeck.sort((a, b)=>new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            const byIndex = new Map();
+            for (const share of forDeck){
+                var _share_deckPages;
+                for (const page of (_share_deckPages = share.deckPages) != null ? _share_deckPages : []){
+                    byIndex.set(page.slideIndex, page);
                 }
-            ];
+            }
+            for (const share of forDeck){
+                var _share_slides;
+                for (const slide of (_share_slides = share.slides) != null ? _share_slides : []){
+                    var _slide_talkTrack;
+                    const under = byIndex.get(slide.slideIndex);
+                    byIndex.set(slide.slideIndex, _extends({}, slide, {
+                        talkTrack: (_slide_talkTrack = slide.talkTrack) != null ? _slide_talkTrack : under == null ? void 0 : under.talkTrack
+                    }));
+                }
+            }
+            return byIndex;
         });
         this.handleArtifactMessageChange = (message)=>{
-            var _ref;
-            var _message_slides;
             if (!message || message.type !== "present_deck") {
                 this.clearAdvanceTimer();
+                this.clearNarrationStart();
+                this.clearPendingDeckReady();
                 this.lastHandledMessageId = null;
                 this.playbackIndex.value = 0;
+                this.presentationSequence.value = null;
                 this.clearRevisit();
+                this.clearSelfGuided();
+                return;
+            }
+            // A self-guided open (prepareSelfGuidedPlayback set the id first): the
+            // visitor owns the pacing, so leave their position alone and start nothing.
+            if (message.id === this.selfGuidedMessageId) {
+                this.clearAdvanceTimer();
+                this.lastHandledMessageId = message.id;
+                this.stopped.value = true;
                 return;
             }
             // A revisit open (prepareRevisit set revisitMessageId first): show the
@@ -204,21 +483,49 @@ class DecksStore {
             // presentation on the current slide with nothing left to reschedule it.
             if (this.lastHandledMessageId === message.id) return;
             this.clearAdvanceTimer();
-            // Any other deck message supersedes a revisit view.
+            this.clearNarrationStart();
+            this.clearPendingDeckReady();
+            // Any other deck message supersedes a revisit or self-guided view.
             this.clearRevisit();
+            this.clearSelfGuided();
             this.lastHandledMessageId = message.id;
+            const messageSlides = slidesForMessage(message);
+            if (!message.navigationOnly) {
+                this.presentationSequence.value = {
+                    deckId: message.deckId,
+                    slides: messageSlides
+                };
+            }
+            const slides = this.sequence.peek();
+            if (message.navigationOnly) {
+                var _message_slideIndex;
+                var _messageSlides_;
+                const currentSlideIndex = (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : (_messageSlides_ = messageSlides[0]) == null ? void 0 : _messageSlides_.slideIndex;
+                const position = slides.findIndex((slide)=>slide.slideIndex === currentSlideIndex);
+                this.playbackIndex.value = Math.max(position, 0);
+                this.stopped.value = true;
+                return;
+            }
+            // Auto-advance through the sequence so the agent can present it as
+            // one continuous flow without re-calling the tool for each slide.
             this.playbackIndex.value = 0;
             this.stopped.value = false;
-            // Auto-advance through a multi-slide sequence so the agent can present it as
-            // one continuous flow without re-calling the tool for each slide.
-            if (message.autoAdvance && ((_ref = (_message_slides = message.slides) == null ? void 0 : _message_slides.length) != null ? _ref : 0) > 1) {
-                var _message_slides1;
-                this.scheduleAdvance((_message_slides1 = message.slides) != null ? _message_slides1 : []);
+            if (message.autoAdvance || slides.length === 1) {
+                if (message.syncNarration) {
+                    // Start the fallback clock with the deck message, which also starts the
+                    // server wait. Starting it after image loading would add render time to
+                    // the timeout and recreate narration/slide drift.
+                    this.deckReadyDeadlineAt = Date.now() + DECK_READY_TIMEOUT_MS;
+                } else {
+                    this.scheduleAdvance(slides);
+                }
             }
         };
         // The visitor started speaking over the presentation. Stop advancing; the current
         // slide stays on screen, and tell the agent where the presentation stopped so it
-        // can address the visitor and later resume the remaining slides.
+        // can address the visitor and later resume the remaining slides. The stopped
+        // guard makes this fire exactly once per guided run; a new continuation message
+        // resets stopped so a later resume can be interrupted and re-reported.
         this.handleInterruption = ()=>{
             if (this.stopped.value) return;
             const message = this.rootStore.artifact.message.value;
@@ -227,8 +534,11 @@ class DecksStore {
             // slide is frozen on screen and which slides remain. Only worth reporting for a
             // multi-slide auto-advancing sequence with unshown slides left — single-slide
             // narration is agent-driven and the last slide has nothing to resume.
+            this.rootStore.presentationTelemetryStore.onDeckInterrupted();
             this.notifyInterruption(message);
             this.clearAdvanceTimer();
+            this.clearNarrationStart();
+            this.clearPendingDeckReady();
             this.stopped.value = true;
         };
         this.unsubscribeArtifact = this.rootStore.artifact.message.subscribe(this.handleArtifactMessageChange);
@@ -265,6 +575,49 @@ class DecksStore {
             }
             this.handleInterruption();
         });
+        // The deck message and realtime narration are separate asynchronous streams.
+        // Arm only after the first slide is ready and the lead-in has stopped, then
+        // begin slide timing on the narration's actual response boundary.
+        this.disposeNarrationStartEffect = signals_core_module_E(()=>{
+            var _ref, _ref1;
+            var _this_rootStore_callStore_value_voiceAnswerSequence, _this_rootStore_callStore_value, _this_rootStore_callStore_value_isBotSpeaking, _this_rootStore_callStore_value1;
+            const awaitingStart = this.awaitingNarrationStart.value;
+            const answerSequence = (_ref = (_this_rootStore_callStore_value = this.rootStore.callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_voiceAnswerSequence = _this_rootStore_callStore_value.voiceAnswerSequence) == null ? void 0 : _this_rootStore_callStore_value_voiceAnswerSequence.value) != null ? _ref : null;
+            const speaking = (_ref1 = (_this_rootStore_callStore_value1 = this.rootStore.callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_isBotSpeaking = _this_rootStore_callStore_value1.isBotSpeaking) == null ? void 0 : _this_rootStore_callStore_value_isBotSpeaking.value) != null ? _ref1 : false;
+            if (!awaitingStart) return;
+            // Coffee publishes a new sequence number on the first audio byte of each
+            // response. This is the authoritative narration boundary when available:
+            // it still advances if a preamble and post-tool narration are one
+            // continuous run with no false -> true speaking edge.
+            if (this.narrationAnswerBaseline !== null) {
+                // A call restart resets Coffee's response sequence. Drop the stale
+                // baseline so the first response from the replacement call can start
+                // narration even when its sequence begins below the previous call's.
+                if (answerSequence === null) {
+                    this.narrationAnswerBaseline = null;
+                } else {
+                    if (answerSequence <= this.narrationAnswerBaseline) return;
+                    this.awaitingNarrationStart.value = false;
+                    this.scheduleAdvance(this.sequence.peek());
+                    return;
+                }
+            }
+            if (!speaking) return;
+            this.awaitingNarrationStart.value = false;
+            this.scheduleAdvance(this.sequence.peek());
+        });
+        // A rendered slide is not sufficient if the pre-tool lead-in is still
+        // audible. Releasing the tool result mid-utterance can strand the realtime
+        // continuation, so acknowledge readiness only once both the image is visible
+        // and the bot has stopped speaking.
+        this.disposeDeckReadyEffect = signals_core_module_E(()=>{
+            var _ref;
+            var _this_rootStore_callStore_value_isBotSpeaking, _this_rootStore_callStore_value;
+            const messageId = this.pendingReadyMessageId.value;
+            const speaking = (_ref = (_this_rootStore_callStore_value = this.rootStore.callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_isBotSpeaking = _this_rootStore_callStore_value.isBotSpeaking) == null ? void 0 : _this_rootStore_callStore_value_isBotSpeaking.value) != null ? _ref : false;
+            if (!messageId || speaking) return;
+            this.releaseDeckReady(messageId, false);
+        });
     }
 }
 
@@ -272,6 +625,19 @@ function clampIndex(index, length) {
     if (length <= 0) return 0;
     return Math.min(Math.max(index, 0), length - 1);
 }
+function slidesForMessage(message) {
+    var _message_slideIndex;
+    var _message_slides;
+    if ((_message_slides = message.slides) == null ? void 0 : _message_slides.length) return message.slides;
+    return [
+        {
+            pageId: message.pageId,
+            slideIndex: (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : 0,
+            imageUrl: message.imageUrl,
+            pageTitle: message.pageTitle
+        }
+    ];
+}
 // 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 deck.
 function latestVisitorText(messages) {