@oxvo/ai-live-assist 7.4.23 → 7.4.36

package/cjs/AiLiveAssist.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveAiGuideProtocolVersion = exports.normalizeAiGuideOpenInput = exports.confirmationReplyIntent = exports.ReplaySessionReadiness = exports.REPLAY_SESSION_READY_TIMEOUT_MS = void 0;
+exports.resolveAiGuideProtocolVersion = exports.normalizeAiGuideOpenInput = exports.resolveAiGuideLocale = exports.confirmationReplyIntent = exports.ReplaySessionReadiness = exports.REPLAY_SESSION_READY_TIMEOUT_MS = void 0;
 const client_js_1 = require("./client.js");
 const control_js_1 = require("./control.js");
 const context_js_1 = require("./context.js");
@@ -78,6 +78,7 @@ const MESSENGER_RETURN_RELEASE_REQUEST_TIMEOUT_MS = 2500;
 const MESSENGER_RETURN_END_AUTHORITY_MAX_FUTURE_MS = 60 * 60 * 1000;
 const MESSENGER_BINDING_POLL_MS = 50;
 const HANDOFF_REQUEST_REPLAY_TIMEOUT_MS = 15000;
+const MANUAL_HANDOFF_RECONNECT_REPLAY_LIMIT = 1;
 const MESSENGER_RETURN_EVENT = "oxvo:ai-guide-return-requested";
 const MESSENGER_SUPPORT_STATE_EVENT = "oxvo:support-state";
 const MESSENGER_SWITCH_ID_PATTERN = /^[0-9a-f]{32}$/;
@@ -461,12 +462,41 @@ const confirmationReplyIntent = (value) => {
     return null;
 };
 exports.confirmationReplyIntent = confirmationReplyIntent;
-const boundedLocale = (value) => {
-    const normalized = value.replace("_", "-").slice(0, 16);
-    return /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/.test(normalized)
-        ? normalized
-        : "en";
+const canonicalLocale = (value) => {
+    const normalized = value.trim().replace(/_/g, "-");
+    if (!normalized || normalized.length > 64)
+        return null;
+    try {
+        return Intl.getCanonicalLocales(normalized)[0] ?? null;
+    }
+    catch {
+        return null;
+    }
 };
+const boundedLocale = (value) => canonicalLocale(value) ?? "en";
+const resolveAiGuideLocale = (configured, requested) => {
+    const fallback = boundedLocale(configured?.default ?? "en");
+    if (!requested?.trim())
+        return fallback;
+    const candidate = canonicalLocale(requested);
+    if (!candidate)
+        return fallback;
+    const allowedByKey = new Map();
+    for (const locale of configured?.allowed ?? [fallback]) {
+        const canonical = canonicalLocale(locale);
+        if (canonical) {
+            allowedByKey.set(canonical.toLocaleLowerCase("en"), canonical);
+        }
+    }
+    const exact = allowedByKey.get(candidate.toLocaleLowerCase("en"));
+    if (exact)
+        return exact;
+    const baseLanguage = candidate.split("-")[0];
+    if (!baseLanguage || baseLanguage === candidate)
+        return fallback;
+    return allowedByKey.get(baseLanguage.toLocaleLowerCase("en")) ?? fallback;
+};
+exports.resolveAiGuideLocale = resolveAiGuideLocale;
 const path = () => window.location.pathname || "/";
 const randomId = (prefix) => `${prefix}_${crypto.randomUUID()}`;
 const normalizeAiGuideOpenInput = (input = {}) => {
@@ -631,7 +661,7 @@ const parseResumeRecord = (value) => {
     try {
         const record = JSON.parse(value);
         const scopes = Array.isArray(record.scopes) ? record.scopes : [];
-        const locale = typeof record.locale === "string" ? record.locale.replace("_", "-") : "";
+        const locale = typeof record.locale === "string" ? canonicalLocale(record.locale) : null;
         if (!PUBLIC_REQUEST_ID_PATTERN.test(record.sessionId ?? "") ||
             !(0, client_js_1.isValidAssistSessionGrant)(record.resumeCredential) ||
             !["text", "voice"].includes(record.mode ?? "") ||
@@ -640,8 +670,7 @@ const parseResumeRecord = (value) => {
             scopes.some((scope) => typeof scope !== "string" ||
                 !CONSENT_SCOPES.has(scope)) ||
             new Set(scopes).size !== scopes.length ||
-            locale.length > 16 ||
-            !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/.test(locale) ||
+            !locale ||
             typeof record.expiresAt !== "number" ||
             !Number.isFinite(record.expiresAt) ||
             record.expiresAt <= Date.now()) {
@@ -1162,6 +1191,7 @@ class AiLiveAssist {
         this.messengerLoadPromise = null;
         this.messengerHandoffRequestInFlight = false;
         this.handoffRequestLifecycleOwner = null;
+        this.pendingManualHandoffIntent = null;
         this.handoffRequestProgressTimer = null;
         this.messengerBindingChallengesInFlight = new Set();
         this.messengerBindingChallengesDelivered = new Set();
@@ -1281,6 +1311,8 @@ class AiLiveAssist {
         this.pageAssistanceRecoverySubmissionDigest = null;
         this.pageAssistanceRecoveryEffectTail = Promise.resolve();
         this.unsubscribePageAssistancePreference = null;
+        this.pageAssistanceTrackerIdentity = null;
+        this.pageAssistanceTrackerRotationPending = false;
         this.pageAssistanceAuthorityGeneration = 0;
         this.pageAssistanceBindingGeneration = "";
         this.minimumPageAssistanceAuthorityEpoch = 0;
@@ -1355,12 +1387,22 @@ class AiLiveAssist {
             this.handleMessengerReturnRequested(event);
         };
         this.onPageHide = (event) => {
+            const recoveryWasBusy = !event.persisted && (this.reconnecting || this.reconnectTimer !== null);
+            const resumeAtHide = recoveryWasBusy ? this.readResume() : null;
+            const ordinaryRecoveryPending = recoveryWasBusy &&
+                !resumeAtHide?.modeUpgrade &&
+                this.recoveryBusy(resumeAtHide);
             this.clearReconnectTimer();
             if (this.terminalRequestPending || this.readTerminalEndIntent()) {
                 this.parkTerminalRetry();
                 this.cleanupTransport({ preserveConnectionRequest: true });
-                if (!event.persisted)
-                    this.lock.release();
+                return;
+            }
+            if (!event.persisted && ordinaryRecoveryPending) {
+                // A real navigation cannot leave an outgoing resume authorization or
+                // socket alive after giving another page the activity lock. BFCache
+                // keeps the existing suspended-page behavior and resumes on pageshow.
+                this.cleanupTransport();
                 return;
             }
             if ((!this.result && !this.readResume()?.modeUpgrade) || this.ended)
@@ -1373,8 +1415,6 @@ class AiLiveAssist {
                 this.messengerTerminalDeliveryObserved) {
                 this.reconnecting = false;
             }
-            if (!event.persisted)
-                this.lock.release();
         };
         this.onPageShow = (event) => {
             if (this.restoreTerminalFromStorage()) {
@@ -1489,8 +1529,11 @@ class AiLiveAssist {
         this.terminalEndStorageKey = `__oxvo_ai_live_assist_terminal_end_${this.siteKey}`;
         this.messengerReturnEndStorageKey = `__oxvo_ai_live_assist_handoff_terminal_${this.siteKey}`;
         this.freshAiReturnProvisionalStorageKey = `__oxvo_ai_live_assist_fresh_return_${this.siteKey}`;
+        this.pageAssistanceTrackerIdentityStorageKey = `__oxvo_ai_live_assist_page_assistance_tracker_${this.siteKey}`;
         this.transcript = this.readTranscript();
         this.visitorIdentity = this.resolveVisitorId();
+        this.pageAssistanceTrackerIdentity =
+            this.readPageAssistanceTrackerIdentity();
         const resume = this.readResume();
         this.tabId = resume?.tabId || app.session.getTabId() || randomId("tab");
         this.pageAssistanceBindingGeneration =
@@ -1503,10 +1546,12 @@ class AiLiveAssist {
         }
         this.windowId = randomId("window");
         this.terminalOffline = navigator.onLine === false;
-        this.locale = boundedLocale(options.locale ||
-            document.documentElement.lang ||
-            navigator.language ||
-            "en");
+        this.locale =
+            resume?.locale ??
+                boundedLocale(options.locale ||
+                    navigator.language ||
+                    document.documentElement.lang ||
+                    "en");
         const endpoint = app.options.endpoint;
         const runtimeUrl = options.runtimeUrl ||
             (endpoint
@@ -1525,9 +1570,17 @@ class AiLiveAssist {
         this.bindWindowLifecycle();
         void this.initialize();
     }
+    recoveryBusy(record = this.readResume()) {
+        return (!this.ended &&
+            !this.destroyed &&
+            !this.terminalRequestPending &&
+            (this.reconnecting || this.reconnectTimer !== null) &&
+            Boolean(record || this.result || this.modeUpgradeTerminalResult));
+    }
     open(input = {}) {
-        if (this.terminalRequestPending)
+        if (this.terminalRequestPending || this.recoveryBusy()) {
             return this.getState();
+        }
         const normalized = (0, exports.normalizeAiGuideOpenInput)(input);
         const requestedMode = this.result && !this.ended
             ? (this.lastLaunch?.mode ?? this.mode)
@@ -1581,6 +1634,8 @@ class AiLiveAssist {
         return this.getState();
     }
     close() {
+        if (this.recoveryBusy())
+            return;
         this.clearPendingIntentBeforeAuthorization();
         this.view?.close();
         if (!this.result &&
@@ -1591,18 +1646,23 @@ class AiLiveAssist {
         this.emitStateEvent();
     }
     getState() {
+        const resume = this.readResume();
+        const recovering = this.recoveryBusy(resume);
         const active = !this.ended &&
             Boolean(this.result ||
                 this.modeUpgradeTerminalResult ||
                 this.pendingSessionAuthorization ||
-                this.launchInFlight);
+                this.launchInFlight ||
+                recovering);
         return {
             ready: this.initialized,
             available: Boolean(this.bootstrap && this.view),
             open: this.view?.isOpen ?? false,
             active,
             mode: active
-                ? (this.lastLaunch?.mode ?? this.mode)
+                ? (this.lastLaunch?.mode ??
+                    (recovering && !this.result ? resume?.mode : null) ??
+                    this.mode)
                 : (this.pendingOpenIntent?.mode ?? null),
             phase: this.lifecyclePhase,
             companion: this.messengerIntegrationEnabled,
@@ -1738,7 +1798,7 @@ class AiLiveAssist {
         this.replayReadiness?.destroy();
         this.clearPendingIntent();
         this.discardPendingConfirmationDecisions();
-        window.removeEventListener("pagehide", this.onPageHide);
+        window.removeEventListener("pagehide", this.onPageHide, true);
         window.removeEventListener("pageshow", this.onPageShow);
         window.removeEventListener("online", this.onOnline);
         window.removeEventListener("offline", this.onOffline);
@@ -1793,9 +1853,10 @@ class AiLiveAssist {
         this.bootstrapAbort = controller;
         const timeout = setTimeout(() => controller.abort(), Math.max(1000, Math.min(15000, this.options.bootstrapTimeoutMs ?? 15000)));
         try {
-            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), controller.signal);
+            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), this.locale, controller.signal);
             if (this.destroyed)
                 return;
+            this.locale = (0, exports.resolveAiGuideLocale)(bootstrap.locale, this.locale);
             this.syncAgentDiscovery(bootstrap.agentAccess?.discoveryUrl ?? null);
             if (bootstrap.replayRecordingEnabled === false) {
                 this.bootstrap = bootstrap;
@@ -1876,7 +1937,7 @@ class AiLiveAssist {
             (this.renderedTranscriptIds ?? (this.renderedTranscriptIds = new Set())).clear();
             this.transcriptRestoredFromCache = false;
             this.view = voicePresenceView
-                ? new voicePresenceUi_js_1.VoicePresenceView(bootstrap, this.options.messages ?? {}, callbacks, this.tabId, (fallback) => void this.activateFallback(fallback), this.options.visualTestMode === true)
+                ? new voicePresenceUi_js_1.VoicePresenceView(effectiveBootstrap, this.options.messages ?? {}, callbacks, this.tabId, (fallback) => void this.activateFallback(fallback), this.options.visualTestMode === true)
                 : new ui_js_1.WidgetView(effectiveBootstrap, this.options.messages ?? {}, callbacks);
             this.syncCompanionView();
             this.initializePageAssistancePreference(effectiveBootstrap);
@@ -2028,6 +2089,10 @@ class AiLiveAssist {
         if (this.queuedQuestions?.some((question) => question.submissionId === submissionId && question.shown)) {
             return true;
         }
+        if ((this.renderedTranscriptIds ?? (this.renderedTranscriptIds = new Set())).has(submissionId) ||
+            this.transcript?.some((entry) => entry.role === "user" && entry.id === submissionId)) {
+            return true;
+        }
         return (this.acknowledgedQuestionIds?.has(submissionId) === true ||
             this.failedQuestionIds?.has(submissionId) === true);
     }
@@ -2086,7 +2151,11 @@ class AiLiveAssist {
     performPendingOpen() {
         const intent = this.pendingOpenIntent;
         const view = this.view;
-        if (!intent || !view || this.destroyed || this.terminalRequestPending)
+        if (!intent ||
+            !view ||
+            this.destroyed ||
+            this.terminalRequestPending ||
+            this.recoveryBusy())
             return;
         const unavailable = this.publicModeUnavailable(intent.mode);
         if (unavailable) {
@@ -2841,6 +2910,8 @@ class AiLiveAssist {
             if (!challengeId)
                 return null;
             this.clearHandoffRequestProgressTimer();
+            if (current.kind === "manual")
+                this.pendingManualHandoffIntent = null;
         }
         const token = {};
         this.handoffRequestLifecycleOwner = challengeId
@@ -2857,6 +2928,9 @@ class AiLiveAssist {
             return false;
         const owner = this.handoffRequestLifecycleOwner;
         this.clearHandoffRequestProgressTimer();
+        if (this.pendingManualHandoffIntent?.token === owner?.token) {
+            this.pendingManualHandoffIntent = null;
+        }
         this.handoffRequestLifecycleOwner = null;
         this.messengerHandoffRequestInFlight = false;
         if (owner?.kind === "challenge") {
@@ -2866,6 +2940,149 @@ class AiLiveAssist {
         this.view?.dismissHandoffRequestPreparing?.();
         return true;
     }
+    manualHandoffLaunchGeneration() {
+        return Number.isSafeInteger(this.launchGeneration)
+            ? this.launchGeneration
+            : 0;
+    }
+    manualHandoffIntentIsCurrent(intent) {
+        const owner = this.handoffRequestLifecycleOwner;
+        if (owner?.kind !== "manual" ||
+            owner.token !== intent.token ||
+            this.pendingManualHandoffIntent !== intent ||
+            intent.launchGeneration !== this.manualHandoffLaunchGeneration() ||
+            this.terminalRequestPending ||
+            this.ended ||
+            this.destroyed) {
+            return false;
+        }
+        const currentSessionId = this.result?.sessionId ?? this.readResume()?.sessionId ?? null;
+        return !intent.sessionId || !currentSessionId
+            ? true
+            : intent.sessionId === currentSessionId;
+    }
+    manualHandoffAuthorityReady(intent) {
+        return (this.manualHandoffIntentIsCurrent(intent) &&
+            this.result !== null &&
+            this.channel?.isOpen === true &&
+            this.channel.hasFencedAuthority &&
+            (this.lifecyclePhase === "active_text" ||
+                this.lifecyclePhase === "active_voice" ||
+                this.lifecyclePhase === "paused"));
+    }
+    queueManualHandoff(reason) {
+        const current = this.pendingManualHandoffIntent;
+        if (current && this.manualHandoffIntentIsCurrent(current))
+            return;
+        const lifecycleToken = this.beginHandoffRequestLifecycle();
+        if (!lifecycleToken)
+            return;
+        const requestId = randomId("handoff_request");
+        this.pendingManualHandoffIntent = {
+            reason,
+            requestId,
+            token: lifecycleToken,
+            launchGeneration: this.manualHandoffLaunchGeneration(),
+            sessionId: this.result?.sessionId ?? null,
+            reconnectReplaysRemaining: MANUAL_HANDOFF_RECONNECT_REPLAY_LIMIT,
+            awaitingReconnect: false,
+            deliveryAttempt: 0,
+            deliveryInFlight: false,
+        };
+        const owner = this.handoffRequestLifecycleOwner;
+        if (owner?.kind !== "manual" || owner.token !== lifecycleToken)
+            return;
+        owner.requestId = requestId;
+        if (this.handoffContextPromptExpected()) {
+            this.view?.showHandoffRequestPreparing?.(HANDOFF_REQUEST_PREPARING_TITLE, HANDOFF_REQUEST_PREPARING_DESCRIPTION);
+        }
+        this.view?.setStatus(this.view.message("humanConnecting"));
+        this.drainPendingManualHandoff();
+    }
+    drainPendingManualHandoff() {
+        const intent = this.pendingManualHandoffIntent;
+        if (!intent)
+            return;
+        if (!this.manualHandoffIntentIsCurrent(intent)) {
+            this.finishHandoffRequestLifecycle(intent.token);
+            return;
+        }
+        if (intent.awaitingReconnect &&
+            (this.reconnecting || this.reconnectTimer !== null)) {
+            return;
+        }
+        if (!this.manualHandoffAuthorityReady(intent))
+            return;
+        if (intent.deliveryInFlight)
+            return;
+        intent.sessionId ?? (intent.sessionId = this.result?.sessionId ?? null);
+        intent.awaitingReconnect = false;
+        intent.deliveryInFlight = true;
+        intent.deliveryAttempt += 1;
+        const deliveryAttempt = intent.deliveryAttempt;
+        const delivery = this.sendControlOutcome("handoff.request", { reason: intent.reason }, intent.requestId, 5000);
+        this.armHandoffRequestProgressTimer(intent.token);
+        void this.observeManualHandoffDelivery(intent, deliveryAttempt, delivery);
+    }
+    async observeManualHandoffDelivery(intent, deliveryAttempt, delivery) {
+        let outcome = null;
+        try {
+            outcome = await delivery;
+        }
+        catch {
+            // The stable request identity makes an ambiguous transport outcome safe
+            // to replay once after a newly fenced reconnect.
+        }
+        if (!this.manualHandoffIntentIsCurrent(intent) ||
+            intent.deliveryAttempt !== deliveryAttempt) {
+            return;
+        }
+        intent.deliveryInFlight = false;
+        if (outcome?.status === "ack")
+            return;
+        if (outcome?.status === "explicit_error") {
+            if (outcome.code === "LEASE_CONFLICT" && outcome.retryable) {
+                this.requeueManualHandoffAfterReconnect(intent, outcome.message);
+            }
+            else {
+                this.showRecoverableHandoffFailure(outcome.message, intent.token);
+            }
+            return;
+        }
+        this.requeueManualHandoffAfterReconnect(intent, this.view?.message("humanUnavailable") ?? "Human support is unavailable");
+    }
+    requeueManualHandoffAfterReconnect(intent, exhaustedMessage) {
+        if (!this.manualHandoffIntentIsCurrent(intent))
+            return;
+        const owner = this.handoffRequestLifecycleOwner;
+        if (owner?.kind !== "manual" || owner.token !== intent.token)
+            return;
+        if (intent.awaitingReconnect)
+            return;
+        if (intent.reconnectReplaysRemaining <= 0) {
+            this.showRecoverableHandoffFailure(exhaustedMessage, intent.token);
+            return;
+        }
+        intent.reconnectReplaysRemaining -= 1;
+        intent.awaitingReconnect = true;
+        intent.deliveryInFlight = false;
+        this.clearHandoffRequestProgressTimer();
+        this.view?.setStatus(this.view.message("humanConnecting"));
+        this.scheduleReconnect(true);
+    }
+    handleManualHandoffLeaseConflict(requestId, message) {
+        const intent = this.pendingManualHandoffIntent;
+        const owner = this.handoffRequestLifecycleOwner;
+        if (!intent ||
+            owner?.kind !== "manual" ||
+            owner.token !== intent.token ||
+            owner.requestId !== requestId ||
+            !this.manualHandoffIntentIsCurrent(intent)) {
+            return false;
+        }
+        this.requeueManualHandoffAfterReconnect(intent, message);
+        return true;
+    }
     handoffContextPromptExpected() {
         const offered = new Set([
             ...(this.bootstrap?.consent?.requiredScopes ?? []),
@@ -2892,6 +3109,14 @@ class AiLiveAssist {
                 return;
             }
             this.handoffRequestProgressTimer = null;
+            if (owner.kind === "manual") {
+                const intent = this.pendingManualHandoffIntent;
+                if (intent?.token === ownerToken) {
+                    this.requeueManualHandoffAfterReconnect(intent, this.view?.message("humanUnavailable") ??
+                        "Human support is unavailable");
+                }
+                return;
+            }
             // This is a replay checkpoint, not a terminal handoff deadline. Console
             // creation and its durable outbox can legitimately outlive this browser
             // interval. Once Messenger has an exact prepared-open proof, that
@@ -2900,11 +3125,59 @@ class AiLiveAssist {
                 return;
             this.view?.setStatus(this.view.message("humanConnecting"));
             this.armHandoffRequestProgressTimer(ownerToken);
-            if (!this.channel?.isOpen || !this.channel.hasFencedAuthority) {
+            if (owner.kind === "challenge" ||
+                !this.channel?.isOpen ||
+                !this.channel.hasFencedAuthority) {
                 this.scheduleReconnect(true);
             }
         }, HANDOFF_REQUEST_REPLAY_TIMEOUT_MS);
     }
+    rememberDeliveredMessengerBindingChallenge(challengeId) {
+        this.messengerBindingChallengesDelivered.add(challengeId);
+        if (this.messengerBindingChallengesDelivered.size <= 32)
+            return;
+        const oldest = this.messengerBindingChallengesDelivered
+            .values()
+            .next().value;
+        if (oldest)
+            this.messengerBindingChallengesDelivered.delete(oldest);
+    }
+    async observeMessengerBindingChallengeDelivery(challengeId, lifecycleToken, delivery) {
+        let outcome = null;
+        try {
+            outcome = await delivery;
+        }
+        catch {
+            // A thrown transport outcome is the same ambiguous delivery class as a
+            // timeout: the persisted stable request may already be committed.
+        }
+        this.messengerBindingChallengesInFlight.delete(challengeId);
+        if (!this.handoffRequestLifecycleIsCurrent(lifecycleToken))
+            return;
+        if (outcome?.status === "ack") {
+            this.rememberDeliveredMessengerBindingChallenge(challengeId);
+            return;
+        }
+        if (this.messengerTransferPending ||
+            this.messengerTransferMaterialized() ||
+            this.messengerTerminalDeliveryObserved) {
+            this.rememberDeliveredMessengerBindingChallenge(challengeId);
+            return;
+        }
+        if (outcome?.status === "explicit_error") {
+            this.clearMessengerBindingChallenge(challengeId);
+            this.showRecoverableHandoffFailure(outcome.message ||
+                this.view?.message("humanUnavailable") ||
+                "Human support is unavailable", lifecycleToken);
+            return;
+        }
+        // The server may have committed this stable request without returning its
+        // ACK. Reconnect even when the old socket still looks healthy so a newly
+        // fenced owner can replay the exact durable challenge promptly.
+        this.view?.setStatus(this.view.message("humanConnecting"));
+        this.armHandoffRequestProgressTimer(lifecycleToken);
+        this.scheduleReconnect(true);
+    }
     async requestHumanHandoff(reason, messengerBindingChallengeId, challengeExpiresAt, isCurrent) {
         if (!isCurrent() ||
             this.terminalRequestPending ||
@@ -2912,32 +3185,29 @@ class AiLiveAssist {
             this.destroyed) {
             return;
         }
-        if (messengerBindingChallengeId) {
-            if (this.messengerBindingChallengesDelivered.has(messengerBindingChallengeId) ||
-                this.messengerBindingChallengesInFlight.has(messengerBindingChallengeId)) {
-                return;
-            }
+        if (!messengerBindingChallengeId) {
+            this.queueManualHandoff(reason);
+            return;
+        }
+        if (this.messengerBindingChallengesDelivered.has(messengerBindingChallengeId) ||
+            this.messengerBindingChallengesInFlight.has(messengerBindingChallengeId)) {
+            return;
         }
         const lifecycleToken = this.beginHandoffRequestLifecycle(messengerBindingChallengeId);
         if (!lifecycleToken)
             return;
-        if (messengerBindingChallengeId) {
-            this.messengerBindingChallengesInFlight.add(messengerBindingChallengeId);
-            this.view?.dismissHandoffRequestPreparing?.();
-        }
-        else if (this.handoffContextPromptExpected()) {
-            this.view?.showHandoffRequestPreparing?.(HANDOFF_REQUEST_PREPARING_TITLE, HANDOFF_REQUEST_PREPARING_DESCRIPTION);
-        }
+        this.messengerBindingChallengesInFlight.add(messengerBindingChallengeId);
+        this.view?.dismissHandoffRequestPreparing?.();
         this.view?.setStatus(this.view.message("humanConnecting"));
         const payload = { reason };
         let requestDelivered = false;
-        let reconnectAfterRequest = false;
+        let bindingDeliveryObserved = false;
         try {
             // The first request intentionally carries no provider receipt. The
             // server must issue a one-time binding challenge before it can accept
             // proof from this browser. Only the challenge response is allowed to
             // fetch and return the Messenger binding receipt.
-            if (this.messengerIntegrationEnabled && messengerBindingChallengeId) {
+            if (this.messengerIntegrationEnabled) {
                 const messengerBindingReceipt = await this.ensureMessengerBindingReceipt(challengeExpiresAt, isCurrent);
                 if (!isCurrent() ||
                     !this.handoffRequestLifecycleIsCurrent(lifecycleToken) ||
@@ -2947,8 +3217,8 @@ class AiLiveAssist {
                     return;
                 }
                 if (!messengerBindingReceipt ||
-                    (messengerBindingChallengeId &&
-                        (!challengeExpiresAt || challengeExpiresAt <= Date.now()))) {
+                    !challengeExpiresAt ||
+                    challengeExpiresAt <= Date.now()) {
                     const unavailableMessage = this.view?.message("humanUnavailable") ??
                         "Human support is unavailable";
                     this.showRecoverableHandoffFailure(!messengerBindingReceipt && this.messengerHandoffRequiresRefresh()
@@ -2963,44 +3233,10 @@ class AiLiveAssist {
                 !this.handoffRequestLifecycleIsCurrent(lifecycleToken)) {
                 return;
             }
-            let messageId;
-            if (messengerBindingChallengeId) {
-                // Persist the server correlation before sending. The server may accept
-                // the request even when the response is lost, so ACK-first persistence
-                // would make a reload unable to recognize its terminal replay.
-                if (!this.rememberMessengerBindingChallenge(messengerBindingChallengeId)) {
-                    this.showRecoverableHandoffFailure(this.view?.message("humanUnavailable") ??
-                        "Human support is unavailable", lifecycleToken);
-                    return;
-                }
-                const lifecycleOwner = this.handoffRequestLifecycleOwner;
-                if (!lifecycleOwner || lifecycleOwner.token !== lifecycleToken)
-                    return;
-                // Challenge responses use the challenge as their stable message ID.
-                // Persist the correlation before delivery because a timeout is
-                // ambiguous: the server may already own the durable handoff.
-                lifecycleOwner.requestId = messengerBindingChallengeId;
-                const delivery = await this.sendControlOutcome("handoff.request", payload, messengerBindingChallengeId, 10000);
-                if (delivery?.status !== "ack") {
-                    if (delivery?.status === "explicit_error") {
-                        this.clearMessengerBindingChallenge(messengerBindingChallengeId);
-                        this.showRecoverableHandoffFailure(delivery.message ||
-                            this.view?.message("humanUnavailable") ||
-                            "Human support is unavailable", lifecycleToken);
-                    }
-                    else if (this.handoffRequestLifecycleIsCurrent(lifecycleToken)) {
-                        requestDelivered = true;
-                        reconnectAfterRequest = true;
-                        this.armHandoffRequestProgressTimer(lifecycleToken);
-                    }
-                    return;
-                }
-                messageId = delivery.messageId;
-            }
-            else {
-                messageId = this.send("handoff.request", payload);
-            }
-            if (!messageId) {
+            // Persist the server correlation before sending. The server may accept
+            // the request even when the response is lost, so ACK-first persistence
+            // would make a reload unable to recognize its terminal replay.
+            if (!this.rememberMessengerBindingChallenge(messengerBindingChallengeId)) {
                 this.showRecoverableHandoffFailure(this.view?.message("humanUnavailable") ??
                     "Human support is unavailable", lifecycleToken);
                 return;
@@ -3008,34 +3244,28 @@ class AiLiveAssist {
             const lifecycleOwner = this.handoffRequestLifecycleOwner;
             if (!lifecycleOwner || lifecycleOwner.token !== lifecycleToken)
                 return;
-            lifecycleOwner.requestId = messageId;
+            // Challenge responses use the challenge as their stable message ID.
+            // Persist the correlation before delivery because a timeout is
+            // ambiguous: the server may already own the durable handoff.
+            lifecycleOwner.requestId = messengerBindingChallengeId;
+            const delivery = this.sendControlOutcome("handoff.request", payload, messengerBindingChallengeId, 5000);
+            // Do not serialize the prepared/open server event behind an ACK that
+            // is emitted only after the durable Console handoff finishes. The
+            // stable challenge ID and persisted correlation make this observation
+            // safely replayable if the outcome is lost.
             requestDelivered = true;
+            bindingDeliveryObserved = true;
             this.armHandoffRequestProgressTimer(lifecycleToken);
-            if (messageId && messengerBindingChallengeId) {
-                this.messengerBindingChallengesDelivered.add(messengerBindingChallengeId);
-                if (this.messengerBindingChallengesDelivered.size > 32) {
-                    const oldest = this.messengerBindingChallengesDelivered
-                        .values()
-                        .next().value;
-                    if (oldest)
-                        this.messengerBindingChallengesDelivered.delete(oldest);
-                }
-            }
+            void this.observeMessengerBindingChallengeDelivery(messengerBindingChallengeId, lifecycleToken, delivery);
+            return;
         }
         finally {
-            if (messengerBindingChallengeId) {
-                if (isCurrent()) {
-                    this.messengerBindingChallengesInFlight.delete(messengerBindingChallengeId);
-                }
+            if (isCurrent() && !bindingDeliveryObserved) {
+                this.messengerBindingChallengesInFlight.delete(messengerBindingChallengeId);
             }
             if (!requestDelivered) {
                 this.finishHandoffRequestLifecycle(lifecycleToken);
             }
-            if (reconnectAfterRequest &&
-                this.handoffRequestLifecycleIsCurrent(lifecycleToken) &&
-                (!this.channel?.isOpen || !this.channel.hasFencedAuthority)) {
-                this.scheduleReconnect(true);
-            }
         }
     }
     showRecoverableHandoffFailure(message, lifecycleToken) {
@@ -3083,7 +3313,22 @@ class AiLiveAssist {
             try {
                 const minimizing = this.view.minimizeForCompanionTransfer();
                 if (minimizing) {
-                    await minimizing;
+                    const morphBudgetMs = this.view.companionTransferMorphBudgetMs();
+                    await new Promise((resolve) => {
+                        let settled = false;
+                        const finish = () => {
+                            if (settled)
+                                return;
+                            settled = true;
+                            window.clearTimeout(timeout);
+                            resolve();
+                        };
+                        const timeout = window.setTimeout(finish, Math.max(1, morphBudgetMs));
+                        // A visual transition must never become protocol authority. If its
+                        // completion callback is lost or throws, the bounded deadline lets
+                        // the current transfer hide the AI surface and continue safely.
+                        minimizing.then(finish, finish);
+                    });
                     if (!isCurrent())
                         return false;
                 }
@@ -3558,7 +3803,7 @@ class AiLiveAssist {
             }
         }
         const expectedMode = provisional?.mode ?? this.preferredCompanionMode();
-        if (mode !== expectedMode)
+        if (provisional?.phase !== "released" && mode !== expectedMode)
             return;
         this.startMessengerReturn(mode, freshSession, switchId);
     }
@@ -3638,6 +3883,23 @@ class AiLiveAssist {
             expiresAt,
         };
     }
+    releaseFreshAiReturnAfterPreRuntimeFailure(authority) {
+        if (!this.messengerReturnLaunchIsCurrent(authority, authority.mode, authority.launchIdempotencyKey)) {
+            return;
+        }
+        const provisional = this.freshAiReturnProvisionalFor(authority.conversationDisplayId);
+        if (provisional?.phase !== "launching" ||
+            provisional.sessionId !== null ||
+            provisional.mode !== authority.mode ||
+            provisional.launchIdempotencyKey !== authority.launchIdempotencyKey) {
+            return;
+        }
+        this.persistFreshAiReturnProvisional({
+            ...provisional,
+            phase: "released",
+            launchIdempotencyKey: null,
+        });
+    }
     quiesceProvisionalFreshAiReturn() {
         this.launchGeneration += 1;
         this.clearReconnectTimer();
@@ -3654,9 +3916,7 @@ class AiLiveAssist {
             return true;
         const resume = this.readResume();
         const result = this.result;
-        const sessionId = provisional.sessionId ??
-            (resume?.sessionId ?? null) ??
-            (result?.sessionId ?? null);
+        const sessionId = provisional.sessionId ?? resume?.sessionId ?? result?.sessionId ?? null;
         if (!sessionId)
             return false;
         const authority = resume?.sessionId === sessionId
@@ -3739,8 +3999,9 @@ class AiLiveAssist {
             return "launch";
         const resume = this.readResume();
         const sessionId = provisional.sessionId ??
-            (resume?.sessionId ?? null) ??
-            (this.result?.sessionId ?? null);
+            resume?.sessionId ??
+            this.result?.sessionId ??
+            null;
         if (!sessionId) {
             // Keep and reuse the exact launch identity. A launch whose response was
             // interrupted must never be replaced by a second fresh operation.
@@ -3961,10 +4222,30 @@ class AiLiveAssist {
         };
         if (!this.persistFreshAiReturnProvisional(launching))
             return false;
+        const messengerDescriptor = this.currentMessengerDescriptor();
+        const messengerReturnAuthority = this.messengerTransferredSurface &&
+            this.companion &&
+            messengerDescriptor &&
+            this.resolveMessenger() === this.messengerTransferredSurface &&
+            this.messengerMatchesDescriptor(this.messengerTransferredSurface, messengerDescriptor) &&
+            this.messengerConversation?.inboxId === messengerDescriptor.inboxId
+            ? {
+                conversationDisplayId: conversationId,
+                inboxId: messengerDescriptor.inboxId,
+                linkId: this.companion.linkId,
+                launchIdempotencyKey,
+                mode,
+                previousAiSessionId: this.companion.currentAiSessionId,
+                surface: this.messengerTransferredSurface,
+            }
+            : null;
+        if (!messengerReturnAuthority)
+            return false;
         this.messengerReturnRetryRemaining = 1;
         await this.launch(mode, scopes, launchIdempotencyKey, {
             startMuted: mode === "voice",
             associateCompanion: false,
+            messengerReturnAuthority,
         });
         this.messengerReturnRetryRemaining = null;
         const sessionId = this.result?.sessionId;
@@ -3988,7 +4269,7 @@ class AiLiveAssist {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 5000);
         try {
-            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), controller.signal);
+            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), this.locale, controller.signal);
             if (this.destroyed)
                 return false;
             this.bootstrap = this.effectivePageAssistanceBootstrap(bootstrap);
@@ -5531,7 +5812,8 @@ class AiLiveAssist {
                     return false;
                 if (this.destroyed ||
                     this.launchInFlight ||
-                    this.terminalRequestPending) {
+                    this.terminalRequestPending ||
+                    this.recoveryBusy()) {
                     return false;
                 }
                 if (initialQuestion) {
@@ -5560,7 +5842,10 @@ class AiLiveAssist {
                     if (this.queuedLaunchToken !== queuedLaunchToken)
                         return;
                     this.queuedLaunchToken = null;
-                    if (this.destroyed || this.ended || this.terminalRequestPending)
+                    if (this.destroyed ||
+                        this.ended ||
+                        this.terminalRequestPending ||
+                        this.recoveryBusy())
                         return;
                     void this.launch(mode, scopes, launchKey);
                 });
@@ -5888,26 +6173,52 @@ class AiLiveAssist {
         }
     }
     async launch(mode, scopes, launchIdempotencyKey = (0, client_js_1.idempotencyKey)("launch"), options = {}) {
+        let runtimeLaunchStarted = false;
+        const releaseMessengerReturnIfPreRuntime = () => {
+            if (options.messengerReturnAuthority && !runtimeLaunchStarted) {
+                this.releaseFreshAiReturnAfterPreRuntimeFailure(options.messengerReturnAuthority);
+            }
+        };
         if (this.launchInFlight ||
             this.terminalRequestPending ||
             this.ended ||
-            this.destroyed)
+            this.destroyed ||
+            this.recoveryBusy()) {
+            releaseMessengerReturnIfPreRuntime();
             return;
+        }
         const launchGeneration = ++this.launchGeneration;
         const launchIsCurrent = () => launchGeneration === this.launchGeneration &&
             !this.terminalRequestPending &&
             !this.ended &&
             !this.destroyed;
         const bootstrap = this.bootstrap;
-        if (!bootstrap?.configRevision || !bootstrap.consent || !this.view)
+        if (!bootstrap?.configRevision || !bootstrap.consent || !this.view) {
+            releaseMessengerReturnIfPreRuntime();
             return;
+        }
         const experienceMode = bootstrap.experienceMode ?? "standard";
         const voicePresence = experienceMode === "voice_presence";
         const protocolVersion = (0, exports.resolveAiGuideProtocolVersion)(bootstrap);
         if (voicePresence && mode !== "voice") {
             this.view.showError("Voice assist requires microphone access.", false, false);
+            releaseMessengerReturnIfPreRuntime();
             return;
         }
+        if (this.visitorActiveTakeoverOnly &&
+            options.messengerReturnAuthority !== undefined) {
+            if (!this.messengerReturnLaunchIsCurrent(options.messengerReturnAuthority, mode, launchIdempotencyKey)) {
+                releaseMessengerReturnIfPreRuntime();
+                return;
+            }
+            // A page reload can recover Messenger while bootstrap still reports the
+            // AI session that was handed off as visitor-active. The authenticated
+            // terminal release and exact return authority above make that marker
+            // stale. Cancel its generic eligibility retry so it cannot later launch
+            // a second session without the Messenger return authority.
+            this.cancelVisitorActiveEligibilityRecheck(true);
+            this.visitorActiveTakeoverOnly = false;
+        }
         if (this.visitorActiveTakeoverOnly) {
             const pendingLaunch = {
                 mode,
@@ -5922,6 +6233,7 @@ class AiLiveAssist {
             if (handoffRequested === false) {
                 this.beginVisitorActiveEligibilityRecheck(pendingLaunch, launchGeneration);
             }
+            releaseMessengerReturnIfPreRuntime();
             return;
         }
         this.pageAssistanceAuthorityGeneration += 1;
@@ -5936,6 +6248,7 @@ class AiLiveAssist {
             this.view.showActiveElsewhere(false);
             this.launchInFlight = false;
             this.requestFocusedHandoff();
+            releaseMessengerReturnIfPreRuntime();
             return;
         }
         let activeMode = mode;
@@ -5961,7 +6274,7 @@ class AiLiveAssist {
             this.replayReadiness.assertCurrent(replay);
             const controller = new AbortController();
             const connectionGeneration = this.beginConnectionAttempt(controller);
-            const assertConnectionCurrent = () => this.assertConnectionCurrent(controller, connectionGeneration, replay);
+            const assertConnectionCurrent = () => this.assertConnectionCurrent(controller, connectionGeneration, replay, options.messengerReturnAuthority, activeMode, launchIdempotencyKey);
             media = this.createMedia(() => {
                 try {
                     assertConnectionCurrent();
@@ -5986,7 +6299,8 @@ class AiLiveAssist {
                 assertConnectionCurrent();
                 if (voicePresence ||
                     mode !== "voice" ||
-                    !bootstrap.capabilities?.text) {
+                    !bootstrap.capabilities?.text ||
+                    options.messengerReturnAuthority !== undefined) {
                     throw error;
                 }
                 this.releaseMedia(media);
@@ -6039,6 +6353,7 @@ class AiLiveAssist {
                 return;
             }
             const requestedLaunchPath = path();
+            runtimeLaunchStarted = true;
             const authorization = this.runtime.launch({
                 siteKey: this.siteKey,
                 configRevision: bootstrap.configRevision,
@@ -6141,6 +6456,7 @@ class AiLiveAssist {
             this.state("error");
         }
         finally {
+            releaseMessengerReturnIfPreRuntime();
             this.launchInFlight = false;
             this.drainPendingFocusedHandoff();
         }
@@ -6156,7 +6472,7 @@ class AiLiveAssist {
         this.visitorLimitAbort = controller;
         const timeout = setTimeout(() => controller.abort(), 5000);
         try {
-            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), controller.signal);
+            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), this.locale, controller.signal);
             if (!isCurrent() || controller.signal.aborted)
                 return false;
             const effectiveBootstrap = this.effectivePageAssistanceBootstrap(bootstrap);
@@ -6277,7 +6593,7 @@ class AiLiveAssist {
         operation = (async () => {
             try {
                 const bootstrap = await Promise.race([
-                    this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), controller.signal),
+                    this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), this.locale, controller.signal),
                     aborted,
                 ]);
                 if (!bootstrap) {
@@ -6620,9 +6936,20 @@ class AiLiveAssist {
                     : modeUpgrade
                         ? this.retryableModeUpgradeFailure(error, transportStarted)
                         : this.retryableResumeFailure(error, transportStarted);
+            const unrecoverableResume = this.unrecoverableResumeFailure(error);
+            const durableResumeAtFailure = !retryableFailure && !modeUpgrade && unrecoverableResume
+                ? this.readResume()
+                : null;
+            const supersededByNewerSessionCredential = Boolean(durableResumeAtFailure?.sessionId === record.sessionId &&
+                !attemptedCredentials.has(durableResumeAtFailure.resumeCredential));
             const preparedMediaWasAttached = preparedModeUpgradeMedia !== null &&
                 this.media === preparedModeUpgradeMedia;
-            this.cleanupTransport();
+            const pendingManualHandoff = this.pendingManualHandoffIntent;
+            this.cleanupTransport({
+                preserveHandoffRequestLifecycle: Boolean((retryableFailure || supersededByNewerSessionCredential) &&
+                    pendingManualHandoff &&
+                    this.manualHandoffIntentIsCurrent(pendingManualHandoff)),
+            });
             if (preparedModeUpgradeMedia && !preparedMediaWasAttached) {
                 preparedModeUpgradeMedia.close();
             }
@@ -6650,7 +6977,6 @@ class AiLiveAssist {
                 await this.endFailedModeUpgrade();
                 return;
             }
-            const unrecoverableResume = this.unrecoverableResumeFailure(error);
             const retainedModeUpgradeAuthority = this.modeUpgradeTerminalResult;
             if (modeUpgrade &&
                 !retryableFailure &&
@@ -6712,6 +7038,12 @@ class AiLiveAssist {
             if (ownsResume) {
                 this.resumeAttemptOwner = null;
                 this.reconnecting = false;
+                // connectTransport reaches the authoritative active state while the
+                // enclosing resume still owns the recovery flag. Drain only after
+                // that flag is cleared so a deferred handoff is replayed exactly once
+                // on the newly fenced channel instead of remaining stranded.
+                if (connected)
+                    this.drainPendingManualHandoff();
             }
             if (ownsResume &&
                 retryableFailure &&
@@ -7019,6 +7351,7 @@ class AiLiveAssist {
             this.reconcilePendingHandoffContext();
             if (this.lifecyclePhase !== "paused")
                 this.state("paused");
+            this.drainPendingManualHandoff();
             return;
         }
         const welcomeMessage = this.pendingHumanFallback
@@ -7050,6 +7383,7 @@ class AiLiveAssist {
         const activeState = mode === "voice" ? "active_voice" : "active_text";
         if (this.lifecyclePhase !== activeState)
             this.state(activeState);
+        this.drainPendingManualHandoff();
         void this.flushPendingConfirmationDecision();
         void this.flushPendingQuestion();
         if (this.pendingHumanFallback) {
@@ -7720,10 +8054,7 @@ class AiLiveAssist {
     }
     parsePageAssistanceRequest(payload, sentAt = new Date().toISOString()) {
         const bootstrap = this.bootstrap;
-        if (this.resolveVisitorId() !== this.visitorIdentity) {
-            this.disposePageAssistancePreference();
-            this.view?.setPageAssistancePersistentAllowed(false);
-        }
+        this.reconcilePageAssistanceTrackerIdentity(this.pageAssistancePreferenceStore, this.pageAssistancePreferenceStore !== null);
         if (!this.result ||
             !this.channel?.isOpen ||
             !versionAtLeast(version_js_1.VERSION, "7.4.0") ||
@@ -7907,7 +8238,8 @@ class AiLiveAssist {
             !this.pageAssistanceDecisionWindowOpen(pending.decisionDeadline)) {
             return;
         }
-        const saved = request.persistenceEligible &&
+        const saved = !this.pageAssistanceTrackerRotationPending &&
+            request.persistenceEligible &&
             PERSISTENT_PAGE_ASSISTANCE_CATEGORIES.has(request.actionCategory)
             ? (store?.read() ?? null)
             : null;
@@ -8803,6 +9135,9 @@ class AiLiveAssist {
         };
     }
     handleHandoffContextRequest(request) {
+        // The authoritative prompt proves the stable manual request was accepted;
+        // visitor decision expiry now owns the only remaining deadline.
+        this.clearHandoffRequestProgressTimer();
         const current = this.pendingHandoffContext;
         if (current?.request.requestId === request.requestId &&
             current.request.requestChecksum === request.requestChecksum) {
@@ -9158,10 +9493,18 @@ class AiLiveAssist {
             !this.messengerTransferred &&
             !(this.messengerTransferPending && this.messengerTerminalDeliveryObserved)) {
             // Microphone authority loss must not wait behind a slower ordered
-            // presentation or page-action handler. The normal FIFO handler observes
-            // the already-committed mode and remains idempotent.
+            // presentation or page-action handler. When this state belongs to our
+            // pending mode command, stop capture immediately but wait for the
+            // correlated ACK before sending another control frame or retiring the
+            // transport. Otherwise the text-mode media update can collide with the
+            // still-claimed mode command and force a revision-conflict reconnect.
             this.revokeActiveActionAtIngress();
-            this.commitTextModeActivation();
+            if (this.pendingTextModeTransition) {
+                this.revokePendingTextModeCapture();
+            }
+            else {
+                this.commitTextModeActivation();
+            }
             return;
         }
         if (sessionState === "ending") {
@@ -9842,6 +10185,10 @@ class AiLiveAssist {
                 if (!lifecycleOwner || lifecycleOwner.requestId !== requestId)
                     return;
                 this.pendingAction = false;
+                if (code === "LEASE_CONFLICT" &&
+                    this.handleManualHandoffLeaseConflict(requestId, message)) {
+                    return;
+                }
                 this.showRecoverableHandoffFailure(message, lifecycleOwner.token);
                 return;
             }
@@ -9876,10 +10223,16 @@ class AiLiveAssist {
                     if (!currentPauseObservation)
                         this.pauseCommandGeneration += 1;
                     this.applyAuthoritativePauseState(state);
+                    this.drainPendingManualHandoff();
                 }
                 if (state === "active_text" &&
                     (this.mode === "voice" || this.pendingTextModeTransition)) {
-                    this.commitTextModeActivation();
+                    if (this.pendingTextModeTransition) {
+                        this.revokePendingTextModeCapture();
+                    }
+                    else {
+                        this.commitTextModeActivation();
+                    }
                 }
                 if (TERMINAL_STATES.has(state)) {
                     this.finishFromServer(this.string(payload.reasonCode), message.sessionId);
@@ -10014,6 +10367,12 @@ class AiLiveAssist {
                 }
                 const retryable = payload.retryable === true;
                 if (code === "LEASE_CONFLICT" && retryable) {
+                    if (operation?.type === "handoff.request" &&
+                        this.handleManualHandoffLeaseConflict(operation.messageId, this.string(payload.message) ||
+                            this.view?.message("humanUnavailable") ||
+                            "Human support is unavailable")) {
+                        return;
+                    }
                     // The backend only marks a missing lease or a newer fence owned by
                     // this same tab retryable. Retire this transport and reconcile via
                     // /resume without flashing a false cross-tab takeover error.
@@ -12663,7 +13022,7 @@ class AiLiveAssist {
             this.scheduleReconnect(true);
             return;
         }
-        const transition = { channel, messageId };
+        const transition = { channel, messageId, captureRevoked: false };
         this.pendingTextModeTransition = transition;
         if (this.view instanceof ui_js_1.WidgetView)
             this.view.setActivity("connecting");
@@ -12690,6 +13049,13 @@ class AiLiveAssist {
         }
         this.commitTextModeActivation();
     }
+    revokePendingTextModeCapture() {
+        const transition = this.pendingTextModeTransition;
+        if (!transition || transition.captureRevoked)
+            return;
+        transition.captureRevoked = true;
+        this.media?.revokeLocalAudioCapture();
+    }
     commitTextModeActivation() {
         this.pendingTextModeTransition = null;
         if (this.mode === "text" ||
@@ -13133,12 +13499,12 @@ class AiLiveAssist {
                 : 0) + 1;
         return this.connectionGeneration;
     }
-    assertConnectionCurrent(controller, generation, replay) {
+    assertConnectionCurrent(controller, generation, replay, messengerReturnAuthority, mode, launchIdempotencyKey) {
         if (controller.signal.aborted ||
             this.destroyed ||
             this.ended ||
             this.terminalRequestPending ||
-            this.messengerTransferred ||
+            !this.messengerReturnLaunchIsCurrent(messengerReturnAuthority, mode, launchIdempotencyKey) ||
             (this.messengerTransferPending &&
                 this.messengerTerminalDeliveryObserved) ||
             generation !== this.connectionGeneration) {
@@ -13146,6 +13512,48 @@ class AiLiveAssist {
         }
         this.replayReadiness.assertCurrent(replay);
     }
+    messengerReturnLaunchIsCurrent(authority, mode, launchIdempotencyKey) {
+        if (!this.messengerTransferred)
+            return true;
+        if (!authority)
+            return false;
+        const messenger = this.resolveMessenger();
+        const descriptor = this.currentMessengerDescriptor();
+        const provisional = this.freshAiReturnProvisionalFor(authority.conversationDisplayId);
+        const returningSessionId = this.result?.sessionId ?? null;
+        const provisionalIsCurrent = provisional?.phase === "launching"
+            ? provisional.sessionId === null
+            : provisional?.phase === "launched" &&
+                provisional.sessionId !== null &&
+                provisional.sessionId === returningSessionId;
+        const companionIsCurrent = (this.companion?.activeSurface === "messenger" &&
+            (this.companion.currentAiSessionId === authority.previousAiSessionId ||
+                this.companion.currentAiSessionId === null)) ||
+            (this.companion?.activeSurface === "ai" &&
+                returningSessionId !== null &&
+                this.companion.currentAiSessionId === returningSessionId);
+        return Boolean(this.messengerReturnInFlight !== null &&
+            messenger === authority.surface &&
+            descriptor !== null &&
+            descriptor.inboxId === authority.inboxId &&
+            this.messengerMatchesDescriptor(authority.surface, descriptor) &&
+            this.messengerTransferredConversationId ===
+                authority.conversationDisplayId &&
+            this.messengerTransferredSurface === authority.surface &&
+            this.messengerReleasedReturnConversationId ===
+                authority.conversationDisplayId &&
+            companionIsCurrent &&
+            this.companion?.linkId === authority.linkId &&
+            this.messengerConversation?.conversationDisplayId ===
+                authority.conversationDisplayId &&
+            this.messengerConversation?.inboxId === authority.inboxId &&
+            authority.mode === mode &&
+            authority.launchIdempotencyKey === launchIdempotencyKey &&
+            provisionalIsCurrent &&
+            provisional?.mode === mode &&
+            provisional?.launchIdempotencyKey === authority.launchIdempotencyKey &&
+            provisional?.linkId === authority.linkId);
+    }
     modeUpgradePathIsCurrent(boundPath) {
         const authoritativePath = this.authoritativeSessionPath;
         return (path() === boundPath &&
@@ -13716,10 +14124,11 @@ class AiLiveAssist {
         const current = this.bootstrap;
         if (current?.configRevision && current.consent)
             return current;
-        const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), signal);
+        const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), this.locale, signal);
         if (!bootstrap.configRevision || !bootstrap.consent) {
             throw new client_js_1.RuntimeClientError("INTERNAL_UNAVAILABLE", "Terminal launch recovery metadata is temporarily unavailable.", true, null, 503);
         }
+        this.locale = (0, exports.resolveAiGuideLocale)(bootstrap.locale, this.locale);
         this.bootstrap = bootstrap;
         return bootstrap;
     }
@@ -14077,12 +14486,16 @@ class AiLiveAssist {
             }
             this.pageAssistancePreferenceStore = store;
             if (!store) {
+                this.reconcilePageAssistanceTrackerIdentity(null, true);
                 this.view?.setPageAssistancePersistentAllowed(false);
                 return;
             }
             this.unsubscribePageAssistancePreference = store.subscribe((receipt, previous) => this.handlePageAssistancePreferenceChange(receipt, previous));
+            this.reconcilePageAssistanceTrackerIdentity(store, true);
             const pendingRevocation = this.restorePendingPageAssistanceRevocation();
-            this.view?.setPageAssistancePersistentAllowed(Boolean(store.read()) && !pendingRevocation);
+            this.view?.setPageAssistancePersistentAllowed(Boolean(store.read()) &&
+                !pendingRevocation &&
+                !this.pageAssistanceTrackerRotationPending);
             if (pendingRevocation) {
                 this.invalidatePageAssistanceAuthority(false);
                 void this.flushPendingPageAssistanceRevocation();
@@ -14121,22 +14534,105 @@ class AiLiveAssist {
     visitorId() {
         return this.visitorIdentity;
     }
+    currentTrackerVisitorIdentity() {
+        try {
+            const meta = this.app.getSessionMeta();
+            const trackerId = typeof meta?.userUUID === "string" ? meta.userUUID : "";
+            return PUBLIC_REQUEST_ID_PATTERN.test(trackerId) ? trackerId : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    readPageAssistanceTrackerIdentity() {
+        try {
+            const stored = localStorage.getItem(this.pageAssistanceTrackerIdentityStorageKey) ??
+                "";
+            return PUBLIC_REQUEST_ID_PATTERN.test(stored) ? stored : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    persistPageAssistanceTrackerIdentity(identity) {
+        try {
+            localStorage.setItem(this.pageAssistanceTrackerIdentityStorageKey, identity);
+            return (localStorage.getItem(this.pageAssistanceTrackerIdentityStorageKey) ===
+                identity);
+        }
+        catch {
+            return false;
+        }
+    }
+    clearPageAssistancePreferenceForTrackerRotation(store) {
+        const previous = store.read();
+        if (previous)
+            this.rememberPendingPageAssistanceRevocation(previous);
+        this.suppressPageAssistancePreferenceChange = true;
+        try {
+            store.clear();
+        }
+        finally {
+            this.suppressPageAssistancePreferenceChange = false;
+        }
+        this.invalidatePageAssistanceAuthority(true);
+        this.view?.setPageAssistancePersistentAllowed(false);
+        if (previous)
+            void this.flushPendingPageAssistanceRevocation();
+        return store.read() === null;
+    }
+    reconcilePageAssistanceTrackerIdentity(store, permissionStateKnown) {
+        const current = this.currentTrackerVisitorIdentity();
+        if (!current)
+            return;
+        if (current === this.pageAssistanceTrackerIdentity) {
+            this.pageAssistanceTrackerRotationPending = false;
+            return;
+        }
+        const previous = this.pageAssistanceTrackerIdentity;
+        if (!permissionStateKnown) {
+            if (previous) {
+                this.pageAssistanceTrackerRotationPending = true;
+                this.view?.setPageAssistancePersistentAllowed(false);
+            }
+            return;
+        }
+        const saved = store?.read() ?? null;
+        const requiresRevocation = previous !== null || saved !== null;
+        if (requiresRevocation) {
+            this.pageAssistanceTrackerRotationPending = true;
+            const cleared = store
+                ? this.clearPageAssistancePreferenceForTrackerRotation(store)
+                : true;
+            if (!store) {
+                this.invalidatePageAssistanceAuthority(true);
+                this.view?.setPageAssistancePersistentAllowed(false);
+            }
+            if (!cleared)
+                return;
+        }
+        this.pageAssistanceTrackerIdentity = current;
+        this.persistPageAssistanceTrackerIdentity(current);
+        this.pageAssistanceTrackerRotationPending = false;
+    }
     resolveVisitorId() {
         const key = `__oxvo_ai_live_assist_visitor_${this.siteKey}`;
-        const meta = this.app.getSessionMeta();
-        const trackerId = typeof meta.userUUID === "string" ? meta.userUUID : "";
-        if (/^[A-Za-z0-9_.:-]{8,128}$/.test(trackerId))
-            return trackerId;
         try {
             const stored = localStorage.getItem(key) ?? "";
-            if (/^[A-Za-z0-9_.:-]{8,128}$/.test(stored))
+            if (PUBLIC_REQUEST_ID_PATTERN.test(stored))
                 return stored;
-            const created = randomId("visitor");
-            localStorage.setItem(key, created);
-            return created;
         }
         catch {
-            return randomId("visitor");
+            /* Fall through to the tracker identity or an in-memory fallback. */
+        }
+        const resolved = this.currentTrackerVisitorIdentity() ?? randomId("visitor");
+        try {
+            localStorage.setItem(key, resolved);
+            const stored = localStorage.getItem(key) ?? "";
+            return PUBLIC_REQUEST_ID_PATTERN.test(stored) ? stored : resolved;
+        }
+        catch {
+            return resolved;
         }
     }
     readTranscript() {
@@ -14966,7 +15462,10 @@ class AiLiveAssist {
         return connection?.saveData === true || connection?.effectiveType === "2g";
     }
     bindWindowLifecycle() {
-        window.addEventListener("pagehide", this.onPageHide);
+        // Run transport cleanup before TabActivityLock's own pagehide listener
+        // releases cross-tab authority. Pagehide targets Window, where capture
+        // listeners are invoked before the lock's non-capture listener.
+        window.addEventListener("pagehide", this.onPageHide, true);
         window.addEventListener("pageshow", this.onPageShow);
         window.addEventListener("online", this.onOnline);
         window.addEventListener("offline", this.onOffline);