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

package/widget/multimodal_v2/stores/screen_share_store.js

@@ -1,5 +1,6 @@
 import { __webpack_require__ } from "../../../js/runtime.js";
 import { signals_core_module_E, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { isCapabilityAllowed } from "../../capabilities.js";
 import { getSentryClient } from "../../widget/sentry.js";
 import "../../utils/native_globals.js";
 
@@ -7,6 +8,7 @@ import "../../utils/native_globals.js";
 /* provided dependency */ var screen_share_store_clearInterval = __webpack_require__(68034).wm;
 
 
+
 // Cap the longest side so the encoded JPEG stays small enough to travel through
 // ActionCable -> Redis -> the OpenAI websocket comfortably, while remaining
 // readable (text + faces) for the agent.
@@ -42,41 +44,51 @@ class ScreenShareStore {
         // window and rejects page frames while it owns the slot, so hand the slot back on the way out.
         this.clearPerception();
     }
-    // Reactively push the current slide (on change) and clear perception when no slide is shown or
-    // the call ends.
+    // Reactively push the current slide (on change) and clear perception when no slide is shown,
+    // while a replacement is loading, or when the call ends.
     sync() {
         // Server-side perception is disabled without the flag, so don't capture or ship frames.
         if (!this.rootStore.featureFlags.piperPerceptionSlides) return;
+        // QAI-5864: don't capture or egress slide frames to the perception loop unless the consumer
+        // allowed the "slidePerception" capability. Defense-in-depth alongside the flag check — the
+        // runtime-config filter strips `piperPerceptionSlides` when denied, and this guard holds even
+        // if the flag reached us another way. Allow-all for the hosted widget (no boundary installed).
+        if (!isCapabilityAllowed("slidePerception")) return;
         const slideUrl = this.currentSlideImageUrl.value;
+        const frameKey = this.currentSlideFrameKey.value;
         const inCall = this.rootStore.callInProgress.value;
         if (!inCall) {
             this.clearPerception();
             return;
         }
-        if (slideUrl) {
-            if (slideUrl !== this.lastPushedKey && slideUrl !== this.pendingKey) {
-                void this.pushSlide(slideUrl);
+        if (slideUrl && frameKey) {
+            if (frameKey !== this.lastPushedKey && frameKey !== this.pendingKey) {
+                // The previous frame no longer matches what's visible. Retract it before awaiting the
+                // replacement image so pointing cannot resolve against the old slide during the load.
+                // clearPerception() is a no-op for the first slide and after the first transition clear.
+                this.clearPerception();
+                void this.pushSlide(slideUrl, frameKey);
             }
             return;
         }
         // No slide on screen: clear whatever slide we last pushed.
         this.clearPerception();
     }
-    async pushSlide(url) {
-        this.pendingKey = url;
+    async pushSlide(url, frameKey) {
+        this.pendingKey = frameKey;
         try {
             const image = await this.loadImage(url);
-            if (this.currentSlideImageUrl.peek() !== url) return; // superseded while loading
+            if (this.currentSlideFrameKey.peek() !== frameKey) return; // superseded while loading
             // The call may have ended while the image was loading; don't push after call end
             // (the !inCall branch of sync() has already cleared perception).
             if (!this.rootStore.callInProgress.peek()) return;
             const imageData = this.encodeImage(image);
             if (!imageData) {
-                this.retractOnFailure(url);
+                this.retractOnFailure(frameKey);
                 return;
             }
             this.push(imageData);
-            this.lastPushedKey = url;
+            this.lastPushedKey = frameKey;
             this.lastPushedImageData = imageData;
             this.startKeepalive();
         } catch (error) {
@@ -84,17 +96,15 @@ class ScreenShareStore {
             (_getSentryClient = getSentryClient({
                 project: "multimodal"
             })) == null ? void 0 : _getSentryClient.captureException(error);
-            this.retractOnFailure(url);
+            this.retractOnFailure(frameKey);
         } finally{
-            if (this.pendingKey === url) this.pendingKey = null;
+            if (this.pendingKey === frameKey) this.pendingKey = null;
         }
     }
-    // A slide that failed to load or encode leaves the *previous* slide pushed, with the keepalive
-    // actively refreshing it — so the agent keeps describing content the visitor has already moved
-    // on from, and coffee's staleness expiry never fires because the frame keeps arriving. Retract
-    // it: showing the agent nothing beats showing it something confidently wrong.
-    retractOnFailure(url) {
-        if (this.currentSlideImageUrl.peek() !== url) return; // already superseded; leave it alone
+    // Ensure a slide that failed to load or encode cannot leave any stale frame behind. Replacement
+    // slides are already retracted before loading, so clearPerception() keeps this idempotent.
+    retractOnFailure(frameKey) {
+        if (this.currentSlideFrameKey.peek() !== frameKey) return; // already superseded; leave it alone
         this.clearPerception();
     }
     loadImage(url) {
@@ -183,11 +193,21 @@ class ScreenShareStore {
             if (slide) return (_slide_url = slide.url) != null ? _slide_url : null;
             return null;
         });
+        // A new presentation message is a fresh share even when it displays the same URL. The backend
+        // clears perception before broadcasting that message, so include its id to ensure the widget
+        // replaces the cleared frame instead of treating the share as an already-pushed slide.
+        this.currentSlideFrameKey = signals_core_module_w(()=>{
+            const url = this.currentSlideImageUrl.value;
+            const messageId = this.rootStore.artifact.messageId.value;
+            return url && messageId ? messageId + ":" + url : null;
+        });
         this.disposeEffect = null;
-        // The slide URL we last pushed, so we only send on change and know when to clear.
+        // The presentation-message/slide pair we last pushed, so we only send on change and know when
+        // to clear. Message identity matters because re-sharing the visible slide clears it server-side.
         this.lastPushedKey = null;
-        // The slide URL currently loading/encoding for a push. sync() can re-run while pushSlide is
-        // still awaiting the image load; without this an in-flight URL would be pushed twice.
+        // The presentation-message/slide pair currently loading/encoding for a push. sync() can re-run
+        // while pushSlide is still awaiting the image load; without this an in-flight frame would be
+        // pushed twice.
         this.pendingKey = null;
         // The encoded payload we last pushed, so the keepalive can re-send it without re-encoding.
         this.lastPushedImageData = null;

package/widget/multimodal_v2/stores/translation_store.js

@@ -1,10 +1,12 @@
 import { signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
 import { importLocale, isSupported } from "../locales/index.js";
+import { toIntlLocale } from "../utils/locale.js";
 import { useRootStore } from "./root_store.js";
 
 
 
 
+
 const DEFAULT_LOCALE = "en";
 /**
  * Flatten a nested translations object into a Map with dot-separated keys.
@@ -156,6 +158,13 @@ const DEFAULT_LOCALE = "en";
             return DEFAULT_LOCALE;
         });
         /**
+   * Browser/Intl-compatible form of `effectiveLocale`. This is the shared
+   * normalization boundary: code that hands a locale to `Intl.*` or a
+   * `toLocale*String` call should read this instead of normalizing `effectiveLocale`
+   * itself at the call site (see INC-136 / QAI-5726 -- an unnormalized locale reaching
+   * Intl throws and crashes the widget render).
+   */ this.effectiveIntlLocale = signals_core_module_w(()=>toIntlLocale(this.effectiveLocale.value));
+        /**
    * Translate a key with optional field substitution.
    *
    * @param key - Dot-separated key path (e.g., "chat.enterMessage")

package/widget/multimodal_v2/stores/ui_store.js

@@ -274,9 +274,9 @@ class UIStore extends BaseStore {
                     break;
             }
         }, /**
-   * Dismisses the widget to CLOSED state and marks that the user has manually dismissed.
-   * Once dismissed, subsequent close actions will always return to CLOSED instead of
-   * the configured starting position.
+   * Dismisses the widget to CLOSED state and records the manual dismissal for
+   * persistence and redirect recovery. Reopening starts a new open → compact →
+   * launcher cycle for experiences with a compact starting position.
    */ this.dismissWidget = ()=>{
             signals_core_module_r(()=>{
                 this.rootStore.clearElementConversationState();
@@ -289,15 +289,15 @@ class UIStore extends BaseStore {
             this.saveUIState.flush();
             this.persistRedirectDismissedUIState();
         }, /**
-   * Closes the widget, respecting the user's previous dismiss preference.
-   * If the user has previously dismissed the widget (userHasDismissed), goes to CLOSED.
-   * Otherwise, goes to the configured starting position.
+   * Closes the opened widget to its configured starting position. Experiences
+   * configured to start opened have no compact position, so they close directly
+   * to the launcher.
    */ this.closeWidget = ()=>{
             signals_core_module_r(()=>{
                 this.rootStore.clearElementConversationState();
                 this.rootStore.closeLightbox();
                 this.rootStore.clearArtifact();
-                if (this.uiState.userHasDismissed.value || this.initialDisplayMode.value === types_InitialDisplayMode.OPENED) {
+                if (this.initialDisplayMode.value === types_InitialDisplayMode.OPENED) {
                     this.setDisplayMode(types_DisplayMode.CLOSED);
                 } else {
                     this.resetToStartingPosition();

package/widget/multimodal_v2/stores/website_navigation_store.js

@@ -85,7 +85,9 @@ class WebsiteNavigationStore {
             }
             // Minimize video if maximized so user can see the navigated content,
             // this will also clear the slide if it is maximized with an artifact
-            this.rootStore.clearMaximizedState();
+            this.rootStore.endPresentationAndClearMaximizedState({
+                reason: "replaced"
+            });
             const promises = [];
             // Perform soft navigation if URL is provided
             if (message.url) {

package/widget/multimodal_v2/text_turn_response_tracker.js

@@ -0,0 +1,419 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { serverLogger } from "../server-logger.js";
+import "../telemetry/index.js";
+import "./constants.js";
+import "../utils/native_globals.js";
+import { metrics } from "../telemetry/metrics.js";
+
+/* provided dependency */ var text_turn_response_tracker_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var text_turn_response_tracker_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);
+}
+
+
+
+const defaultDependencies = {
+    now: ()=>performance.now(),
+    setTimer: (callback, delayMs)=>text_turn_response_tracker_setTimeout(callback, delayMs),
+    clearTimer: (timerId)=>text_turn_response_tracker_clearTimeout(timerId),
+    isCurrentlyHidden: ()=>typeof document !== "undefined" && document.hidden,
+    emitIncrement: (metricName, tags)=>metrics.emitIncrement(metricName, tags),
+    emitTiming: (metricName, deltaMs, tags)=>metrics.emitTiming(metricName, deltaMs, tags),
+    serverLog: (params)=>serverLogger.serverLog(params)
+};
+const TEXT_RESPONSE_ENDED_REASONS = [
+    "suppressed",
+    "blank_output"
+];
+const isTextResponseEndedReason = (reason)=>TEXT_RESPONSE_ENDED_REASONS.includes(reason);
+// Kept in sync with AiConversations::TurnCause::CAUSES.
+const TURN_CAUSES = [
+    "queue_wait",
+    "setup",
+    "llm_slow",
+    "agent_loop",
+    "tool_slow",
+    "side_llm_wait",
+    "generation_failed",
+    "output_moderation_retry",
+    "unknown"
+];
+const isRecognizedTurnCause = (cause)=>TURN_CAUSES.includes(cause);
+const CAUSE_REPORT_SOURCES = [
+    "deadline_watchdog",
+    "slow_turn_completion",
+    "output_moderation_retry"
+];
+const causeReportSourceForLog = (source)=>CAUSE_REPORT_SOURCES.includes(source != null ? source : "") ? source : "unavailable";
+/**
+ * Owns the non-reactive lifecycle and telemetry for one outstanding text turn.
+ * RootStore remains responsible for deciding which messages start and resolve a turn.
+ */ class TextTurnResponseTracker {
+    begin(param) {
+        let { clientId, callActive, initiallyHidden } = param;
+        // First-message-wins while a turn is still outstanding.
+        if (this.sentAt !== null && !this.counterEmitted) return null;
+        // A held metric belongs to the prior turn and reads its cause when flushed.
+        this.flushCauseHoldFor("turn_superseded");
+        this.flushHeldTimeout();
+        if (this.timedOut && !this.acceptedOutcomeLogged && this.clientId && this.sentAt !== null) {
+            var _this_timeoutFlushReason;
+            this.previousTimedOutTurn = {
+                clientId: this.clientId,
+                deadlineAt: this.sentAt + (/* inlined export .RESPONSE_BUDGET_MS */25000),
+                flushReason: (_this_timeoutFlushReason = this.timeoutFlushReason) != null ? _this_timeoutFlushReason : "turn_superseded"
+            };
+        }
+        this.sentAt = this.dependencies.now();
+        this.clientId = clientId;
+        this.counterEmitted = false;
+        this.replyHandled = false;
+        this.obscured = initiallyHidden;
+        this.callActive = callActive;
+        this.cause = null;
+        this.hasToolCall = false;
+        this.timedOut = false;
+        this.causeHoldActive = false;
+        this.timeoutFlushReason = null;
+        this.acceptedCauseReceivedAt = null;
+        this.acceptedCauseReportSource = "unavailable";
+        this.acceptedOutcomeLogged = false;
+        this.unrecognizedCause = null;
+        this.unrecognizedCauseReportSource = "unavailable";
+        this.unrecognizedCauseReceivedAt = null;
+        const handle = ++this.turnToken;
+        this.clearResponseTimer();
+        this.responseTimerId = this.dependencies.setTimer(()=>{
+            var _this_clientId;
+            this.responseTimerId = null;
+            if (handle !== this.turnToken || this.counterEmitted) return;
+            const obscured = this.obscured || this.dependencies.isCurrentlyHidden();
+            this.counterEmitted = true;
+            if (obscured) {
+                this.dependencies.emitIncrement("multimodal_text_response", {
+                    status: "backgrounded",
+                    call_active: this.callActiveTag
+                });
+                return;
+            }
+            this.clientTimedOut();
+            this.holdTimeoutForCause();
+            this.dependencies.serverLog({
+                type: "log",
+                message: "Multimodal text reply did not arrive within response budget",
+                extra: {
+                    text_turn_client_id: (_this_clientId = this.clientId) != null ? _this_clientId : ""
+                }
+            });
+        }, (/* inlined export .RESPONSE_BUDGET_MS */25000));
+        return handle;
+    }
+    handleSendResult(handle, result) {
+        if (!(result == null ? void 0 : result.error)) return;
+        if (handle !== this.turnToken || this.counterEmitted) return;
+        this.clearResponseTimer();
+        this.dependencies.emitIncrement("multimodal_text_response", {
+            status: "send_failed",
+            call_active: this.callActiveTag
+        });
+        this.counterEmitted = true;
+        this.replyHandled = true;
+        this.turnToken++;
+    }
+    handleAssistantReply(param) {
+        let { currentlyHidden } = param;
+        if (this.sentAt === null || this.replyHandled) return;
+        this.clearResponseTimer();
+        const deltaMs = this.dependencies.now() - this.sentAt;
+        const withinBudget = deltaMs <= (/* inlined export .RESPONSE_BUDGET_MS */25000);
+        const obscured = this.obscured || currentlyHidden;
+        if (withinBudget || !obscured) {
+            this.dependencies.emitTiming("multimodal_text_response_ms", deltaMs, {
+                call_active: this.callActiveTag,
+                has_tool_call: this.hasToolCall ? "true" : "false"
+            });
+        }
+        if (!this.counterEmitted) {
+            var _this_cause;
+            const status = withinBudget ? "success" : obscured ? "backgrounded" : "timeout";
+            this.dependencies.emitIncrement("multimodal_text_response", _extends({
+                status,
+                call_active: this.callActiveTag
+            }, status === "timeout" ? {
+                cause: (_this_cause = this.cause) != null ? _this_cause : "unknown"
+            } : {}));
+            this.counterEmitted = true;
+        } else {
+            this.dependencies.serverLog({
+                type: "log",
+                message: "Multimodal text reply arrived after response budget (late)",
+                extra: {
+                    context: "elapsed_ms:" + Math.round(deltaMs)
+                }
+            });
+        }
+        this.replyHandled = true;
+        this.turnToken++;
+    }
+    handleResponseEnded(payload) {
+        var _ref;
+        if (this.sentAt === null || this.counterEmitted) return;
+        if ((payload == null ? void 0 : payload.clientId) !== this.clientId) return;
+        const reason = (_ref = payload == null ? void 0 : payload.reason) != null ? _ref : "";
+        const status = isTextResponseEndedReason(reason) ? reason : "suppressed";
+        this.clearResponseTimer();
+        this.dependencies.emitIncrement("multimodal_text_response", _extends({
+            status,
+            call_active: this.callActiveTag
+        }, this.cause ? {
+            cause: this.cause
+        } : {}));
+        this.counterEmitted = true;
+        this.replyHandled = true;
+        this.turnToken++;
+    }
+    handleDiagnostic(payload) {
+        var _ref;
+        const cause = (_ref = payload == null ? void 0 : payload.cause) != null ? _ref : "";
+        const receivedAt = this.dependencies.now();
+        const causeReportSource = causeReportSourceForLog(payload == null ? void 0 : payload.causeReportSource);
+        if (this.handlePreviousTurnDiagnostic(payload, cause, causeReportSource, receivedAt)) return;
+        if (this.handleMismatchedDiagnostic(payload, cause, causeReportSource, receivedAt)) return;
+        if ((payload == null ? void 0 : payload.hasToolCall) === true) this.hasToolCall = true;
+        if (!cause) return;
+        if (!isRecognizedTurnCause(cause)) {
+            this.handleUnrecognizedCause(cause, causeReportSource, receivedAt);
+            return;
+        }
+        this.acceptDiagnosticCause(cause, causeReportSource, receivedAt);
+    }
+    onHidden() {
+        if (this.sentAt !== null && !this.replyHandled) this.obscured = true;
+    }
+    dispose() {
+        this.clearResponseTimer();
+        this.flushCauseHoldFor("store_disposed");
+        this.flushHeldTimeout();
+        this.turnToken++;
+    }
+    get callActiveTag() {
+        return this.callActive ? "true" : "false";
+    }
+    holdTimeoutForCause() {
+        this.flushHeldTimeout();
+        const callActive = this.callActiveTag;
+        this.heldTimeoutFlush = ()=>{
+            var _this_cause;
+            this.clearCauseHold();
+            this.dependencies.emitIncrement("multimodal_text_response", {
+                status: "timeout",
+                call_active: callActive,
+                cause: (_this_cause = this.cause) != null ? _this_cause : "unknown"
+            });
+        };
+        this.causeHoldTimerId = this.dependencies.setTimer(()=>{
+            this.flushCauseHoldFor("grace_expired");
+            this.heldTimeoutFlush == null ? void 0 : this.heldTimeoutFlush.call(this);
+        }, (/* inlined export .CAUSE_REPORT_GRACE_MS */1500));
+    }
+    handlePreviousTurnDiagnostic(payload, cause, causeReportSource, receivedAt) {
+        const previous = this.previousTimedOutTurn;
+        if (!previous || (payload == null ? void 0 : payload.clientId) !== previous.clientId || !isRecognizedTurnCause(cause)) {
+            return false;
+        }
+        this.logDiagnostic("accepted_after_timeout_flush", previous, {
+            cause,
+            causeReportSource,
+            receivedAt,
+            timeoutFlushReason: previous.flushReason
+        });
+        this.previousTimedOutTurn = null;
+        return true;
+    }
+    handleMismatchedDiagnostic(payload, cause, causeReportSource, receivedAt) {
+        if ((payload == null ? void 0 : payload.clientId) === this.clientId) return false;
+        // Cause-less tool progress is valid and deliberately excluded from mismatch noise.
+        if (this.timedOut && cause) {
+            const turn = this.currentDiagnosticTurn;
+            if (turn) {
+                this.logDiagnostic("client_id_mismatch", turn, {
+                    cause,
+                    causeReportSource,
+                    receivedAt,
+                    receivedTextTurnClientId: payload == null ? void 0 : payload.clientId
+                });
+            }
+        }
+        return true;
+    }
+    handleUnrecognizedCause(cause, causeReportSource, receivedAt) {
+        if (this.timedOut) {
+            const turn = this.currentDiagnosticTurn;
+            if (turn) {
+                this.logDiagnostic("unrecognized_cause", turn, {
+                    cause,
+                    causeReportSource,
+                    receivedAt
+                });
+            }
+            return;
+        }
+        this.unrecognizedCause = cause;
+        this.unrecognizedCauseReportSource = causeReportSource;
+        this.unrecognizedCauseReceivedAt = receivedAt;
+    }
+    acceptDiagnosticCause(cause, causeReportSource, receivedAt) {
+        var _this_acceptedCauseReceivedAt;
+        if (this.cause === null || this.cause === "unknown") {
+            this.cause = cause;
+            this.acceptedCauseReportSource = causeReportSource;
+        }
+        (_this_acceptedCauseReceivedAt = this.acceptedCauseReceivedAt) != null ? _this_acceptedCauseReceivedAt : this.acceptedCauseReceivedAt = receivedAt;
+        if (this.timedOut && !this.acceptedOutcomeLogged) {
+            const status = this.causeHoldActive ? "accepted_within_grace" : this.timeoutFlushReason === "grace_expired" ? "accepted_after_grace" : "accepted_after_timeout_flush";
+            const turn = this.currentDiagnosticTurn;
+            if (turn) {
+                this.logDiagnostic(status, turn, _extends({
+                    cause,
+                    causeReportSource,
+                    receivedAt
+                }, status === "accepted_after_timeout_flush" && this.timeoutFlushReason ? {
+                    timeoutFlushReason: this.timeoutFlushReason
+                } : {}));
+            }
+            this.acceptedOutcomeLogged = true;
+        }
+        if (this.causeHoldActive) {
+            this.causeHoldActive = false;
+            this.flushHeldTimeout();
+        }
+    }
+    clientTimedOut() {
+        this.timedOut = true;
+        this.causeHoldActive = true;
+        const turn = this.currentDiagnosticTurn;
+        if (!turn) return;
+        if (this.acceptedCauseReceivedAt !== null && !this.acceptedOutcomeLogged) {
+            var _this_cause;
+            this.logDiagnostic("accepted_within_grace", turn, {
+                cause: (_this_cause = this.cause) != null ? _this_cause : undefined,
+                causeReportSource: this.acceptedCauseReportSource,
+                receivedAt: this.acceptedCauseReceivedAt
+            });
+            this.acceptedOutcomeLogged = true;
+        }
+        if (this.unrecognizedCause !== null) {
+            this.logDiagnostic("unrecognized_cause", turn, {
+                cause: this.unrecognizedCause,
+                causeReportSource: this.unrecognizedCauseReportSource,
+                receivedAt: this.unrecognizedCauseReceivedAt
+            });
+            this.unrecognizedCause = null;
+            this.unrecognizedCauseReportSource = "unavailable";
+            this.unrecognizedCauseReceivedAt = null;
+        }
+    }
+    flushCauseHoldFor(reason) {
+        if (!this.causeHoldActive) return;
+        this.causeHoldActive = false;
+        this.timeoutFlushReason = reason;
+        if (this.cause === null) {
+            const turn = this.currentDiagnosticTurn;
+            if (turn) this.logDiagnostic("no_valid_diagnostic", turn, {
+                timeoutFlushReason: reason
+            });
+        }
+    }
+    get currentDiagnosticTurn() {
+        if (!this.clientId || this.sentAt === null) return null;
+        return {
+            clientId: this.clientId,
+            deadlineAt: this.sentAt + (/* inlined export .RESPONSE_BUDGET_MS */25000)
+        };
+    }
+    logDiagnostic(diagnosticStatus, turn, param) {
+        let { cause, causeReportSource, receivedAt, receivedTextTurnClientId, timeoutFlushReason } = param === void 0 ? {} : param;
+        try {
+            this.dependencies.serverLog({
+                type: "log",
+                message: "Multimodal text turn diagnostic",
+                extra: _extends({
+                    diagnostic_source: "client_timeout_attribution",
+                    diagnostic_status: diagnosticStatus,
+                    text_turn_client_id: turn.clientId
+                }, receivedTextTurnClientId ? {
+                    received_text_turn_client_id: receivedTextTurnClientId
+                } : {}, cause ? {
+                    cause
+                } : {}, causeReportSource ? {
+                    cause_report_source: causeReportSource
+                } : {}, timeoutFlushReason ? {
+                    timeout_flush_reason: timeoutFlushReason
+                } : {}, receivedAt !== null && receivedAt !== undefined ? {
+                    delivery_lag_ms: Math.round(receivedAt - turn.deadlineAt)
+                } : {})
+            });
+        } catch (unused) {
+        // Diagnostics are best-effort and must never alter the response SLI lifecycle.
+        }
+    }
+    flushHeldTimeout() {
+        this.heldTimeoutFlush == null ? void 0 : this.heldTimeoutFlush.call(this);
+    }
+    clearCauseHold() {
+        if (this.causeHoldTimerId !== null) {
+            this.dependencies.clearTimer(this.causeHoldTimerId);
+            this.causeHoldTimerId = null;
+        }
+        this.heldTimeoutFlush = null;
+    }
+    clearResponseTimer() {
+        if (this.responseTimerId !== null) {
+            this.dependencies.clearTimer(this.responseTimerId);
+            this.responseTimerId = null;
+        }
+    }
+    constructor(dependencies = {}){
+        this.sentAt = null;
+        this.counterEmitted = false;
+        this.replyHandled = false;
+        this.responseTimerId = null;
+        this.causeHoldTimerId = null;
+        this.heldTimeoutFlush = null;
+        this.turnToken = 0;
+        this.clientId = null;
+        this.cause = null;
+        this.hasToolCall = false;
+        this.obscured = false;
+        this.callActive = false;
+        this.timedOut = false;
+        // True only during the 1.5-second window when the timeout metric is held
+        // so a matching backend cause can still replace `unknown`.
+        this.causeHoldActive = false;
+        // Why the client stopped waiting for a cause. Retained so a later diagnostic
+        // can distinguish normal grace expiry from a turn/lifecycle interruption.
+        this.timeoutFlushReason = null;
+        this.acceptedCauseReceivedAt = null;
+        this.acceptedCauseReportSource = "unavailable";
+        this.acceptedOutcomeLogged = false;
+        this.unrecognizedCause = null;
+        this.unrecognizedCauseReportSource = "unavailable";
+        this.unrecognizedCauseReceivedAt = null;
+        this.previousTimedOutTurn = null;
+        this.dependencies = _extends({}, defaultDependencies, dependencies);
+    }
+}
+
+export { TextTurnResponseTracker };

package/widget/multimodal_v2/types.js

@@ -80,6 +80,26 @@ var types_ButtonShape = /*#__PURE__*/ function(ButtonShape) {
     InitialDisplayMode["CLOSED"] = "closed";
     return InitialDisplayMode;
 }({});
+/**
+ * Which of the two shapes the deck artifact takes. Every difference in the deck
+ * component — navigation, caption panel, zoom-follow, dot palette, surface and
+ * sizing — turns on this one discriminant, because all of them are consequences
+ * of the same fact: whose hands the deck is in.
+ *
+ * - `Guided`: Piper narrates, slides advance on their own (the decks store's
+ *   timer), and she can zoom into the slide she is pointing at. Also covers a
+ *   revisit, where the store hands over a single static slide with
+ *   `sequenceLength: 1` — same chrome, minus the dots.
+ * - `SelfGuided`: the visitor opened the deck from its timeline card and steps
+ *   through it themselves, reading the narration beneath each slide.
+ *
+ * Local to the widget, unlike the enums at the top of this file: the values
+ * cross no wire, they only name the mode and key the deck's style variants.
+ */ var types_DeckMode = /*#__PURE__*/ function(DeckMode) {
+    DeckMode["Guided"] = "guided";
+    DeckMode["SelfGuided"] = "self_guided";
+    return DeckMode;
+}({});
 /**
  * Identifies what triggered a call start so the agent can open the call with the
  * right intent (e.g. begin a presentation) instead of a generic greeting.
@@ -102,4 +122,4 @@ var types_ButtonShape = /*#__PURE__*/ function(ButtonShape) {
 }({});
 
 var multimodal_v2_types_CallMode = /* unused export */ undefined;
-export { multimodal_v2_types_CallMode as CallMode, types_AvatarProvider as AvatarProvider, types_ButtonShape as ButtonShape, types_ButtonStyle as ButtonStyle, types_ConversationMode as ConversationMode, types_DisplayMode as DisplayMode, types_InitialDisplayMode as InitialDisplayMode, types_InputHiddenReason as InputHiddenReason, types_InputState as InputState, types_LoadingState as LoadingState, types_MaximizedState as MaximizedState, types_OpenedDisplayMode as OpenedDisplayMode, types_StartCallTrigger as StartCallTrigger };
+export { multimodal_v2_types_CallMode as CallMode, types_AvatarProvider as AvatarProvider, types_ButtonShape as ButtonShape, types_ButtonStyle as ButtonStyle, types_ConversationMode as ConversationMode, types_DeckMode as DeckMode, types_DisplayMode as DisplayMode, types_InitialDisplayMode as InitialDisplayMode, types_InputHiddenReason as InputHiddenReason, types_InputState as InputState, types_LoadingState as LoadingState, types_MaximizedState as MaximizedState, types_OpenedDisplayMode as OpenedDisplayMode, types_StartCallTrigger as StartCallTrigger };

package/widget/multimodal_v2/utils/locale.js

@@ -7,7 +7,8 @@ import "../stores/translation_store.js";
  *
  * Our locale identifiers use underscores (they mirror the locale filenames), which the
  * Intl constructors reject with `RangeError: Invalid language tag`. Anything handed to
- * `Intl.*` or a `toLocale*String` call must go through this first.
+ * `Intl.*` or a `toLocale*String` call must go through this first -- prefer reading
+ * `TranslationStore.effectiveIntlLocale` over calling this directly on a store locale.
  */ function toIntlLocale(locale) {
     if (!locale) return (/* inlined export .DEFAULT_LOCALE */"en");
     return locale.replace(/_/g, "-");