@oxvo/ai-live-assist 7.3.0

package/lib/AiLiveAssist.js

@@ -0,0 +1,1769 @@
+import { RuntimeClient, RuntimeClientError } from './client.js';
+import { ControlChannel } from './control.js';
+import { PageContextCollector } from './context.js';
+import { RealtimeMedia } from './media.js';
+import { PresentationPlane, parsePresentationIntent } from './presentation.js';
+import { disableReplayRecording } from './recordingPolicy.js';
+import { TabActivityLock } from './tabLock.js';
+import { WidgetView } from './ui.js';
+import { VERSION } from './version.js';
+import { VoicePresenceView } from './voicePresenceUi.js';
+const TERMINAL_STATES = new Set(['ended', 'failed', 'revoked']);
+const ACTION_SCOPED_ERROR_CODES = new Set([
+    'CONFIRMATION_EXPIRED',
+    'STALE_TARGET',
+    'TOKEN_REPLAYED',
+]);
+const STORAGE_TTL_MS = 15 * 60 * 1000;
+const APPROVAL_REPLIES = new Set([
+    'apply',
+    'apply it',
+    'approve',
+    'confirm',
+    'continue',
+    'do it',
+    'go ahead',
+    'proceed',
+    'save',
+    'save changes',
+    'save it',
+    'submit',
+    'yes',
+    'yes please',
+]);
+const DECLINE_REPLIES = new Set([
+    'cancel',
+    'cancel it',
+    'close',
+    'close it',
+    'decline',
+    'do not do that',
+    'do not save',
+    'dont do that',
+    'dont save',
+    'never mind',
+    'nevermind',
+    'no',
+    'no thanks',
+    'reject',
+    'stop',
+]);
+export const confirmationReplyIntent = (value) => {
+    const normalized = value
+        .normalize('NFKC')
+        .toLocaleLowerCase('en')
+        .replace(/[\u2018\u2019']/gu, '')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim()
+        .replace(/\s+/gu, ' ');
+    if (!normalized || normalized.split(' ').length > 5)
+        return null;
+    if (DECLINE_REPLIES.has(normalized))
+        return 'decline';
+    if (APPROVAL_REPLIES.has(normalized))
+        return 'approve';
+    return null;
+};
+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 path = () => window.location.pathname || '/';
+const randomId = (prefix) => `${prefix}_${crypto.randomUUID()}`;
+const versionParts = (value) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value);
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+};
+const versionAtLeast = (current, minimum) => {
+    const left = versionParts(current);
+    const right = versionParts(minimum);
+    if (!left || !right)
+        return false;
+    for (let index = 0; index < left.length; index += 1) {
+        const currentPart = left[index] ?? 0;
+        const minimumPart = right[index] ?? 0;
+        if (currentPart !== minimumPart)
+            return currentPart > minimumPart;
+    }
+    return true;
+};
+const parseResumeRecord = (value) => {
+    if (!value)
+        return null;
+    try {
+        const record = JSON.parse(value);
+        if (typeof record.sessionId !== 'string' ||
+            typeof record.resumeCredential !== 'string' ||
+            !['text', 'voice'].includes(record.mode ?? '') ||
+            !Array.isArray(record.scopes) ||
+            typeof record.locale !== 'string' ||
+            typeof record.expiresAt !== 'number' ||
+            record.expiresAt <= Date.now()) {
+            return null;
+        }
+        return {
+            ...record,
+            tabId: typeof record.tabId === 'string' &&
+                /^[A-Za-z0-9_.:-]{8,128}$/.test(record.tabId)
+                ? record.tabId
+                : '',
+            clientSequence: Number.isSafeInteger(record.clientSequence) &&
+                (record.clientSequence ?? -1) >= 0
+                ? record.clientSequence
+                : 0,
+            visualConsentGranted: typeof record.visualConsentGranted === 'boolean'
+                ? record.visualConsentGranted
+                : record.scopes.includes('visual_context'),
+            manualTurn: record.manualTurn === true,
+            protocolVersion: record.protocolVersion === 2 ? 2 : 1,
+            experienceMode: record.experienceMode === 'voice_presence' ? 'voice_presence' : 'standard',
+            fallbackIntent: record.fallbackIntent === 'standard_assist' ||
+                record.fallbackIntent === 'human_handoff'
+                ? record.fallbackIntent
+                : null,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+export default class AiLiveAssist {
+    constructor(app, options) {
+        this.app = app;
+        this.options = options;
+        this.version = VERSION;
+        this.bootstrap = null;
+        this.view = null;
+        this.result = null;
+        this.channel = null;
+        this.media = null;
+        this.context = null;
+        this.presentation = null;
+        this.connectionAbort = null;
+        this.scopes = [];
+        this.mode = 'text';
+        this.ended = false;
+        this.reconnecting = false;
+        this.pendingSessionAuthorization = null;
+        this.terminalRequestPending = false;
+        this.reconnectAttempts = 0;
+        this.heartbeatSeconds = 15;
+        this.pendingAction = false;
+        this.pendingConfirmation = null;
+        this.destroyed = false;
+        this.lastLaunch = null;
+        this.visualConsentGranted = false;
+        this.manualTurn = false;
+        this.pushActive = false;
+        this.activeFallback = null;
+        this.pendingHumanFallback = false;
+        this.pendingFocusedHandoff = null;
+        this.agentDiscoveryLink = null;
+        this.onPageHide = (event) => {
+            if (!this.result || this.ended)
+                return;
+            this.cleanupTransport();
+            if (!event.persisted)
+                this.lock.release();
+        };
+        this.onPageShow = (event) => {
+            if (!event.persisted || this.ended || this.channel?.isOpen)
+                return;
+            const resume = this.readResume();
+            if (resume && this.lock.acquire())
+                void this.resume(resume);
+        };
+        this.onWindowFocus = () => this.requestFocusedHandoff();
+        this.onVisibilityChange = () => {
+            if (document.visibilityState === 'visible')
+                this.requestFocusedHandoff();
+        };
+        this.onOffline = () => {
+            if (!this.ended && this.result) {
+                this.view?.showConnecting(true, this.mode);
+                this.cleanupTransport();
+            }
+        };
+        this.onOnline = () => this.scheduleReconnect();
+        this.onVisitorControl = (event) => {
+            if (event.isTrusted && !this.result && this.isVoicePresence()) {
+                this.requestFocusedHandoff();
+            }
+            if (!this.pendingAction)
+                return;
+            const eventPath = event.composedPath();
+            if (eventPath.some((target) => target instanceof HTMLElement &&
+                target.dataset.oxvoAiLiveAssistRoot === 'true')) {
+                return;
+            }
+            this.pendingAction = false;
+            if (this.view?.cancelPendingConfirmation())
+                return;
+            void this.updatePause(true);
+        };
+        if (options.recordReplay === false)
+            disableReplayRecording(app);
+        this.siteKey = options.siteKey || app.getProjectKey();
+        this.storageKey = `__oxvo_ai_live_assist_resume_${this.siteKey}`;
+        const resume = this.readResume();
+        this.tabId = resume?.tabId || app.session.getTabId() || randomId('tab');
+        this.windowId = randomId('window');
+        this.locale = boundedLocale(options.locale ||
+            document.documentElement.lang ||
+            navigator.language ||
+            'en');
+        const endpoint = app.options.endpoint;
+        const runtimeUrl = options.runtimeUrl ||
+            (endpoint
+                ? new URL(endpoint, window.location.href).origin
+                : window.location.origin);
+        this.runtime = new RuntimeClient(runtimeUrl, VERSION);
+        this.lock = new TabActivityLock(this.siteKey, this.windowId, (active) => this.view?.showActiveElsewhere(active), (requesterId, requestId) => this.handoffToFocusedTab(requesterId, requestId), (payload) => void this.acceptFocusedTabHandoff(payload));
+        this.bindWindowLifecycle();
+        void this.initialize();
+    }
+    async end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        const result = this.result;
+        const pendingAuthorization = this.pendingSessionAuthorization;
+        const controlChannel = this.channel;
+        const fencingToken = this.channel?.leaseToken ?? 0;
+        const terminalMessageId = result?.protocolVersion === 2
+            ? this.send('experience.end', { reason: 'visitor_button' })
+            : null;
+        this.terminalRequestPending = Boolean(result || pendingAuthorization);
+        this.clearResume();
+        this.cleanupTransport({
+            preserveConnectionRequest: this.terminalRequestPending,
+            preserveControlChannel: Boolean(controlChannel),
+        });
+        this.lock.release();
+        this.view?.showEnded();
+        this.state('ended');
+        try {
+            let authorizedResult = result;
+            if (!authorizedResult && pendingAuthorization) {
+                try {
+                    authorizedResult = await pendingAuthorization;
+                }
+                catch {
+                    authorizedResult = null;
+                }
+            }
+            if (authorizedResult) {
+                await this.requestRuntimeEnd(authorizedResult, result ? fencingToken : 0, controlChannel, terminalMessageId);
+            }
+        }
+        finally {
+            this.terminalRequestPending = false;
+            this.cleanupTransport();
+        }
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        if (this.result?.protocolVersion === 2 && !this.ended) {
+            this.send('experience.end', { reason: 'unmount' });
+        }
+        this.destroyed = true;
+        window.removeEventListener('pagehide', this.onPageHide);
+        window.removeEventListener('pageshow', this.onPageShow);
+        window.removeEventListener('online', this.onOnline);
+        window.removeEventListener('offline', this.onOffline);
+        window.removeEventListener('focus', this.onWindowFocus);
+        document.removeEventListener('visibilitychange', this.onVisibilityChange);
+        document.removeEventListener('pointerdown', this.onVisitorControl, true);
+        document.removeEventListener('keydown', this.onVisitorControl, true);
+        this.cleanupTransport({
+            preserveConnectionRequest: this.terminalRequestPending,
+            preserveControlChannel: this.terminalRequestPending,
+        });
+        this.lock.destroy();
+        this.agentDiscoveryLink?.remove();
+        this.agentDiscoveryLink = null;
+        this.view?.destroy();
+        this.view = null;
+    }
+    async initialize() {
+        if (this.options.enabled === false || this.destroyed)
+            return;
+        const controller = new AbortController();
+        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);
+            this.syncAgentDiscovery(bootstrap.agentAccess?.discoveryUrl ?? null);
+            if (bootstrap.replayRecordingEnabled === false) {
+                disableReplayRecording(this.app);
+            }
+            const experienceMode = bootstrap.experienceMode ?? 'standard';
+            const voicePresence = experienceMode === 'voice_presence';
+            const requestedProtocol = voicePresence ? 2 : 1;
+            const minimumProtocol = bootstrap.minimumProtocolVersion ?? requestedProtocol;
+            if (!bootstrap.available ||
+                bootstrap.protocol.min > requestedProtocol ||
+                bootstrap.protocol.max < requestedProtocol ||
+                minimumProtocol > requestedProtocol ||
+                !bootstrap.configRevision ||
+                !bootstrap.consent ||
+                !bootstrap.capabilities ||
+                (voicePresence &&
+                    (!bootstrap.capabilities.voice ||
+                        !bootstrap.capabilities.voicePresence ||
+                        !bootstrap.appearance?.voicePresence?.enabled))) {
+                return;
+            }
+            if (bootstrap.widgetVersion &&
+                bootstrap.widgetVersion.split('.')[0] !== VERSION.split('.')[0]) {
+                return;
+            }
+            if (bootstrap.minimumClientVersion &&
+                !versionAtLeast(VERSION, bootstrap.minimumClientVersion)) {
+                return;
+            }
+            let resume = this.readResume();
+            const resumedFallback = resume?.experienceMode === 'standard' &&
+                resume.protocolVersion === 2 &&
+                resume.fallbackIntent !== null &&
+                this.fallbackAllowed(bootstrap, resume.fallbackIntent);
+            if (resume &&
+                !resumedFallback &&
+                (resume.experienceMode !== experienceMode ||
+                    resume.protocolVersion !== requestedProtocol ||
+                    resume.fallbackIntent !== null)) {
+                this.clearResume();
+                resume = null;
+            }
+            if (resumedFallback && resume) {
+                this.activeFallback = resume.fallbackIntent;
+                this.pendingHumanFallback = resume.fallbackIntent === 'human_handoff';
+            }
+            const effectiveBootstrap = resumedFallback
+                ? this.standardFallbackBootstrap(bootstrap)
+                : bootstrap;
+            this.bootstrap = effectiveBootstrap;
+            if (!resume &&
+                bootstrap.visitorEligibility?.status === 'visitor_limited' &&
+                bootstrap.appearance?.hideLauncherWhenVisitorLimited !== false) {
+                return;
+            }
+            const callbacks = this.widgetCallbacks();
+            const voicePresenceView = voicePresence &&
+                (!resumedFallback || resume?.fallbackIntent === 'human_handoff');
+            this.view = voicePresenceView
+                ? new VoicePresenceView(bootstrap, this.options.messages ?? {}, callbacks, this.tabId, (fallback) => void this.activateFallback(fallback), this.options.visualTestMode === true)
+                : new WidgetView(effectiveBootstrap, this.options.messages ?? {}, callbacks);
+            this.view.showActiveElsewhere(this.lock.isOwnedByOther());
+            if (!resume && bootstrap.visitorEligibility?.status !== 'eligible') {
+                const key = bootstrap.visitorEligibility?.status === 'visitor_limited'
+                    ? 'visitorLimitReached'
+                    : bootstrap.visitorEligibility?.status === 'cooldown_limited'
+                        ? 'visitorCooldown'
+                        : bootstrap.visitorEligibility?.status === 'visitor_active'
+                            ? 'visitorAlreadyActive'
+                            : null;
+                if (key && !(voicePresenceView && key === 'visitorAlreadyActive')) {
+                    this.view.showLaunchUnavailable(this.view.message(key));
+                }
+            }
+            if (resume && this.lock.acquire()) {
+                this.view.showConnecting(true, resume.mode);
+                await this.resume(resume);
+            }
+            else if (voicePresenceView && !resume) {
+                this.requestFocusedHandoff();
+            }
+        }
+        catch (error) {
+            if (!(error instanceof DOMException && error.name === 'AbortError')) {
+                this.view?.showError(this.publicError(error), this.retryable(error));
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    syncAgentDiscovery(discoveryUrl) {
+        this.agentDiscoveryLink?.remove();
+        this.agentDiscoveryLink = null;
+        if (!discoveryUrl || !document.head)
+            return;
+        let parsed;
+        try {
+            parsed = new URL(discoveryUrl, window.location.href);
+        }
+        catch {
+            return;
+        }
+        if (!['http:', 'https:'].includes(parsed.protocol))
+            return;
+        const link = document.createElement('link');
+        link.rel = 'alternate';
+        link.type = 'application/vnd.oxvo.ai-assist+json';
+        link.href = parsed.href;
+        link.dataset.oxvoAiAgentDiscovery = 'true';
+        document.head.append(link);
+        this.agentDiscoveryLink = link;
+    }
+    widgetCallbacks() {
+        return {
+            onStart: (mode, scopes) => void this.launch(mode, scopes),
+            onEnd: () => void this.end(),
+            onMute: (muted) => this.updateMute(muted),
+            onInterrupt: () => this.interrupt(),
+            onVoiceTurnMode: (manual) => this.updateVoiceTurnMode(manual),
+            onPushToTalk: (active) => this.updatePushToTalk(active),
+            onPause: (paused) => void this.updatePause(paused),
+            onCaptions: (enabled) => this.updateCaptions(enabled),
+            onTextOnly: () => void this.switchToText(),
+            onText: (text) => void this.sendText(text),
+            onHuman: () => this.send('handoff.request', {
+                reason: 'The visitor requested a human support agent.',
+            }),
+            onConfirmation: (actionId, proposalChecksum, approved) => {
+                this.pendingConfirmation = null;
+                this.send('confirmation.result', {
+                    actionId,
+                    proposalChecksum,
+                    approved,
+                });
+                if (!approved)
+                    this.pendingAction = false;
+            },
+            onVisualContext: (request, approved) => {
+                void this.resolveVisualContext(request, approved, true);
+            },
+            onVisualPause: (paused) => this.updateVisualPause(paused),
+            onFeedback: (outcome) => void this.submitFeedback(outcome),
+            onRetry: () => void this.retry(),
+            onPlaybackState: (value) => {
+                if (this.result?.protocolVersion === 2) {
+                    this.send('playback.state', value);
+                }
+            },
+        };
+    }
+    fallbackAllowed(bootstrap, intent) {
+        const configured = bootstrap.appearance?.voicePresence?.fallback;
+        if (intent === 'standard_assist') {
+            return (configured === 'offer_standard_assist' &&
+                Boolean(bootstrap.capabilities?.text || bootstrap.capabilities?.voice));
+        }
+        return (configured === 'offer_human_handoff' &&
+            bootstrap.capabilities?.handoff === true &&
+            bootstrap.capabilities.text);
+    }
+    standardFallbackBootstrap(bootstrap) {
+        if (!bootstrap.capabilities || !bootstrap.consent)
+            return bootstrap;
+        const requiredScopes = ['ai_disclosure', 'text'];
+        const optionalScopes = [
+            ...(bootstrap.consent?.requiredScopes ?? []),
+            ...(bootstrap.consent?.optionalScopes ?? []),
+        ].filter((scope, index, values) => scope !== 'ai_disclosure' &&
+            scope !== 'text' &&
+            scope !== 'presentation_guidance' &&
+            values.indexOf(scope) === index);
+        return {
+            ...bootstrap,
+            experienceMode: 'standard',
+            minimumProtocolVersion: 2,
+            capabilities: {
+                ...bootstrap.capabilities,
+                voicePresence: false,
+                presentation: false,
+                aiCursor: false,
+                annotations: false,
+                spatialCallouts: false,
+            },
+            consent: {
+                ...bootstrap.consent,
+                requiredScopes,
+                optionalScopes,
+            },
+        };
+    }
+    async activateFallback(intent) {
+        const bootstrap = this.bootstrap;
+        if (!bootstrap || !this.fallbackAllowed(bootstrap, intent))
+            return;
+        if (intent === 'human_handoff' &&
+            this.result?.capabilities?.handoff &&
+            this.channel?.isOpen) {
+            this.view?.setStatus(this.view.message('humanConnecting'));
+            this.send('handoff.request', {
+                reason: 'The visitor requested human support after voice assistance became unavailable.',
+            });
+            return;
+        }
+        if (this.result && !this.ended)
+            await this.end();
+        this.result = null;
+        this.lastLaunch = null;
+        this.activeFallback = intent;
+        this.pendingHumanFallback = intent === 'human_handoff';
+        this.ended = false;
+        const fallbackBootstrap = this.standardFallbackBootstrap(bootstrap);
+        this.bootstrap = fallbackBootstrap;
+        if (intent === 'standard_assist') {
+            this.view?.destroy();
+            this.view = new WidgetView(fallbackBootstrap, this.options.messages ?? {}, this.widgetCallbacks());
+            this.state('fallback_standard_offered');
+            return;
+        }
+        const scopes = [
+            ...(fallbackBootstrap.consent?.requiredScopes ?? []),
+            ...(fallbackBootstrap.consent?.optionalScopes ?? []),
+        ].filter((scope, index, values) => values.indexOf(scope) === index);
+        if (!scopes.includes('handoff_context')) {
+            this.view?.showError(this.view.message('humanUnavailable'), false, false);
+            return;
+        }
+        this.view?.setStatus(this.view.message('humanConnecting'));
+        await this.launch('text', scopes);
+    }
+    async launch(mode, scopes) {
+        const bootstrap = this.bootstrap;
+        if (!bootstrap?.configRevision || !bootstrap.consent || !this.view)
+            return;
+        const experienceMode = bootstrap.experienceMode ?? 'standard';
+        const voicePresence = experienceMode === 'voice_presence';
+        const protocolVersion = this.activeFallback ? 2 : voicePresence ? 2 : 1;
+        if (voicePresence && mode !== 'voice') {
+            this.view.showError('Voice assist requires microphone access.', false, false);
+            return;
+        }
+        if (!this.lock.acquire()) {
+            this.view.showActiveElsewhere(true);
+            return;
+        }
+        this.lastLaunch = { mode, scopes: [...scopes] };
+        let activeMode = mode;
+        let activeScopes = [...scopes];
+        this.manualTurn =
+            mode === 'voice' && bootstrap.voice?.turnMode === 'manual';
+        this.pushActive = false;
+        this.ended = false;
+        if (this.view instanceof VoicePresenceView) {
+            this.view.showRequestingMicrophone();
+        }
+        else {
+            this.view.showConnecting(false, mode);
+        }
+        this.state('requesting_access');
+        let runtimeSessionCreated = false;
+        let media = this.createMedia();
+        this.media = media;
+        try {
+            media.setManualTurn(this.manualTurn);
+            try {
+                await media.prepare(mode);
+            }
+            catch (error) {
+                if (voicePresence ||
+                    mode !== 'voice' ||
+                    !bootstrap.capabilities?.text) {
+                    throw error;
+                }
+                media.close();
+                activeMode = 'text';
+                activeScopes = activeScopes.filter((scope) => scope !== 'microphone');
+                this.manualTurn = false;
+                media = this.createMedia();
+                this.media = media;
+                this.view.setStatus(this.view.message('microphoneUnavailable'));
+            }
+            if (voicePresence)
+                this.view.showConnecting(false, 'voice');
+            this.mode = activeMode;
+            this.scopes = activeScopes;
+            this.visualConsentGranted = activeScopes.includes('visual_context');
+            const controller = new AbortController();
+            this.connectionAbort = controller;
+            const authorization = this.runtime.launch({
+                siteKey: this.siteKey,
+                configRevision: bootstrap.configRevision,
+                path: path(),
+                tabId: this.tabId,
+                mode: activeMode,
+                anonymousId: this.visitorId(),
+                ...this.replayContext(),
+                disclosureChecksum: bootstrap.consent.disclosureChecksum,
+                scopes: activeScopes,
+                locale: this.locale,
+                microphone: activeMode === 'voice',
+                reducedMotion: window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+                protocolVersion,
+                experienceMode,
+                ...(this.activeFallback
+                    ? { fallbackIntent: this.activeFallback }
+                    : {}),
+                lowPower: this.lowPowerMode(),
+            }, controller.signal);
+            this.pendingSessionAuthorization = authorization;
+            let result;
+            try {
+                result = await authorization;
+            }
+            finally {
+                if (this.pendingSessionAuthorization === authorization) {
+                    this.pendingSessionAuthorization = null;
+                }
+            }
+            if (result.experienceMode !== experienceMode ||
+                result.protocolVersion !== protocolVersion) {
+                throw new RuntimeClientError('PROTOCOL_INVALID', 'The voice assist runtime returned an incompatible session.', false, null, 502);
+            }
+            this.result = result;
+            runtimeSessionCreated = true;
+            if (this.ended)
+                return;
+            this.writeResume(result, activeMode, activeScopes, undefined, 0);
+            await this.connectTransport(result, activeMode, activeScopes, false, controller, media);
+            this.reconnectAttempts = 0;
+            this.lastLaunch = null;
+        }
+        catch (error) {
+            this.cleanupTransport();
+            this.lock.release();
+            if (this.ended)
+                return;
+            if (!(await this.applyVisitorLimitFailure(error))) {
+                this.view?.showError(this.publicError(error), this.retryable(error), runtimeSessionCreated);
+            }
+            this.state('error');
+        }
+    }
+    async applyVisitorLimitFailure(error) {
+        if (!(error instanceof RuntimeClientError) || error.code !== 'RATE_LIMITED') {
+            return false;
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        try {
+            const bootstrap = await this.runtime.bootstrap(this.siteKey, path(), this.visitorId(), controller.signal);
+            this.bootstrap = bootstrap;
+            const status = bootstrap.visitorEligibility?.status;
+            if (status === 'visitor_limited') {
+                if (bootstrap.appearance?.hideLauncherWhenVisitorLimited !== false) {
+                    this.view?.destroy();
+                    this.view = null;
+                    return true;
+                }
+                this.view?.showLaunchUnavailable(this.view.message('visitorLimitReached'));
+                return true;
+            }
+            if (status === 'cooldown_limited') {
+                this.view?.showLaunchUnavailable(this.view.message('visitorCooldown'));
+                return true;
+            }
+        }
+        catch {
+            // Preserve the original launch error when eligibility refresh is unavailable.
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        return false;
+    }
+    async resume(record) {
+        if (this.reconnecting || this.destroyed)
+            return;
+        this.reconnecting = true;
+        let connected = false;
+        this.mode = record.mode;
+        this.scopes = [...record.scopes];
+        this.visualConsentGranted = record.visualConsentGranted;
+        this.manualTurn =
+            record.mode === 'voice' &&
+                (record.manualTurn || this.bootstrap?.voice?.turnMode === 'manual');
+        this.pushActive = false;
+        this.state('reconnecting');
+        const controller = new AbortController();
+        this.connectionAbort = controller;
+        try {
+            const authorization = this.runtime.resume(record.sessionId, record.resumeCredential, path(), record.protocolVersion, controller.signal);
+            this.pendingSessionAuthorization = authorization;
+            let result;
+            try {
+                result = await authorization;
+            }
+            finally {
+                if (this.pendingSessionAuthorization === authorization) {
+                    this.pendingSessionAuthorization = null;
+                }
+            }
+            if (result.protocolVersion !== record.protocolVersion ||
+                result.experienceMode !== record.experienceMode) {
+                throw new RuntimeClientError('PROTOCOL_INVALID', 'The saved voice assist session is no longer compatible.', false, null, 409);
+            }
+            this.result = result;
+            if (this.ended)
+                return;
+            this.writeResume(result, record.mode, record.scopes, record.visualConsentGranted, record.clientSequence);
+            const media = this.createMedia();
+            this.media = media;
+            media.setManualTurn(this.manualTurn);
+            await media.prepare(record.mode);
+            await this.connectTransport(result, record.mode, record.scopes, true, controller, media);
+            this.reconnectAttempts = 0;
+            connected = true;
+        }
+        catch (error) {
+            this.clearResume();
+            this.cleanupTransport();
+            this.lock.release();
+            if (this.ended)
+                return;
+            this.view?.showError(this.publicError(error), this.retryable(error));
+            this.state('error');
+        }
+        finally {
+            this.reconnecting = false;
+            const pending = this.pendingFocusedHandoff;
+            if (connected && pending && !this.ended && this.result) {
+                this.pendingFocusedHandoff = null;
+                this.handoffToFocusedTab(pending.requesterId, pending.requestId);
+            }
+        }
+    }
+    async connectTransport(result, mode, scopes, resume, controller, media) {
+        const channel = new ControlChannel(result, this.tabId, VERSION, () => this.scheduleReconnect(), this.readResume()?.clientSequence ?? 0, (sequence) => this.updateResumeSequence(sequence));
+        this.channel = channel;
+        channel.subscribe((message) => this.handleServerMessage(message));
+        await channel.connect(controller.signal, resume);
+        const fencingToken = await media.connect(result, mode, controller.signal);
+        channel.setFencingToken(fencingToken);
+        channel.startHeartbeat(this.heartbeatSeconds);
+        channel.send('consent.update', { scopes, locale: this.locale });
+        channel.send('media.state', {
+            microphone: mode === 'voice' ? 'active' : 'unavailable',
+            playback: mode === 'voice' ? 'active' : 'paused',
+            captions: true,
+        });
+        if (mode === 'voice' &&
+            this.manualTurn &&
+            this.bootstrap?.voice?.turnMode !== 'manual') {
+            channel.send('voice.turn_mode', { mode: 'manual' });
+        }
+        this.startContext(scopes);
+        this.startPresentation(result, scopes);
+        if (this.view instanceof VoicePresenceView) {
+            this.view.setCapabilityTier(result.capabilityTier);
+        }
+        this.view?.setVisualAvailable(this.visualConsentGranted, !scopes.includes('visual_context'));
+        this.view?.configureVoiceControls(mode === 'voice', this.manualTurn, this.bootstrap?.voice?.turnMode !== 'manual');
+        const welcomeMessage = this.pendingHumanFallback
+            ? null
+            : result.assistant?.welcomeMessage ??
+                this.bootstrap?.appearance?.welcomeMessage;
+        this.view?.showActive(this.view instanceof VoicePresenceView && mode === 'voice'
+            ? null
+            : welcomeMessage);
+        this.state(mode === 'voice' ? 'active_voice' : 'active_text');
+        if (this.pendingHumanFallback) {
+            this.pendingHumanFallback = false;
+            if (result.capabilities?.handoff) {
+                this.view?.setStatus(this.view.message('humanConnecting'));
+                this.send('handoff.request', {
+                    reason: 'The visitor chose human support because voice assistance was unavailable.',
+                });
+            }
+            else {
+                this.view?.showError(this.view.message('humanUnavailable'), false);
+            }
+        }
+    }
+    startContext(scopes) {
+        this.context?.stop();
+        this.context = null;
+        if (!scopes.includes('page_context') ||
+            !this.bootstrap?.capabilities?.pageContext) {
+            return;
+        }
+        this.context = new PageContextCollector({
+            onSnapshot: (snapshot) => {
+                if (this.channel?.leaseToken)
+                    this.send('context.snapshot', snapshot);
+            },
+            onNavigation: (pageId, revision, url) => {
+                this.presentation?.clear('navigation');
+                this.send('context.navigation', {
+                    pageId,
+                    revision,
+                    url,
+                    navigationType: 'spa',
+                });
+            },
+            onHighlight: (element, status) => this.view?.updateHighlight(element, status),
+        }, this.bootstrap.safety?.selectorRegions ?? [], this.bootstrap.safety?.policyVersion ?? 1);
+        this.context.start();
+    }
+    startPresentation(result, scopes) {
+        this.presentation?.destroy();
+        this.presentation = null;
+        const voice = this.bootstrap?.appearance?.voicePresence;
+        if (result.protocolVersion !== 2 ||
+            result.experienceMode !== 'voice_presence' ||
+            result.capabilities?.presentation !== true ||
+            !scopes.includes('presentation_guidance') ||
+            !this.context ||
+            !voice) {
+            return;
+        }
+        const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+        const presentationConfig = voice.presentation;
+        this.presentation = new PresentationPlane(this.bootstrap?.appearance?.accent ?? '#2563eb', voice.presentation.maxActiveCues, reducedMotion || result.capabilityTier !== 'standard', {
+            resolveTarget: (targetId, revision) => this.context?.presentationTarget(targetId, revision) ?? null,
+            currentPage: () => ({
+                pageId: this.context?.currentPageId ?? 'page_unknown',
+                revision: this.context?.currentRevision ?? 0,
+            }),
+            onResult: (value) => this.sendPresentationResult(value),
+            onVisibility: (pageId, domRevision, visiblePresentationIds) => {
+                this.send('presentation.visibility', {
+                    pageId,
+                    domRevision,
+                    visiblePresentationIds,
+                    documentVisible: !document.hidden,
+                });
+            },
+            launcherRect: () => this.view instanceof VoicePresenceView ? this.view.launcherRect() : null,
+            obstacleRects: () => this.view instanceof VoicePresenceView
+                ? this.view.presentationObstacles()
+                : [],
+            spatialTrail: voice.visual.spatialTrail,
+            kindEnabled: (kind) => {
+                if (kind === 'clear')
+                    return true;
+                if (kind === 'pointer') {
+                    return (presentationConfig.aiCursor && result.capabilities?.aiCursor !== false);
+                }
+                if (kind === 'spotlight')
+                    return presentationConfig.spotlight;
+                if (['underline', 'circle', 'arrow', 'connector'].includes(kind)) {
+                    return (presentationConfig.annotations &&
+                        result.capabilities?.annotations !== false);
+                }
+                if (kind === 'sequence_marker')
+                    return presentationConfig.sequenceMarkers;
+                return (kind === 'callout' &&
+                    presentationConfig.spatialCallouts &&
+                    result.capabilities?.spatialCallouts !== false);
+            },
+        });
+    }
+    async sendText(text) {
+        if (this.resolvePendingConfirmationReply(text))
+            return;
+        const supersedesConfirmation = this.pendingConfirmation !== null;
+        await this.context?.captureAndPublish();
+        if (this.ended)
+            return;
+        this.send('text.message', { text });
+        if (supersedesConfirmation)
+            this.cancelConfirmationForNewRequest();
+    }
+    resolvePendingConfirmationReply(text) {
+        const pending = this.pendingConfirmation;
+        if (!pending)
+            return false;
+        const intent = confirmationReplyIntent(text);
+        if (!intent)
+            return false;
+        if (this.mode === 'voice')
+            this.interrupt();
+        const approved = intent === 'approve';
+        if (this.view?.resolvePendingConfirmation(approved))
+            return true;
+        this.pendingConfirmation = null;
+        this.send('confirmation.result', {
+            actionId: pending.actionId,
+            proposalChecksum: pending.proposalChecksum,
+            approved,
+        });
+        if (!approved)
+            this.pendingAction = false;
+        return true;
+    }
+    cancelConfirmationForNewRequest() {
+        const pending = this.pendingConfirmation;
+        if (!pending)
+            return;
+        if (this.mode === 'voice')
+            this.interrupt();
+        if (this.view?.resolvePendingConfirmation(false))
+            return;
+        this.pendingConfirmation = null;
+        this.pendingAction = false;
+        this.send('confirmation.result', {
+            actionId: pending.actionId,
+            proposalChecksum: pending.proposalChecksum,
+            approved: false,
+        });
+    }
+    async handleServerMessage(message) {
+        const payload = message.payload;
+        switch (message.type) {
+            case 'control.ready':
+                if (typeof payload.heartbeatSeconds === 'number') {
+                    this.heartbeatSeconds = payload.heartbeatSeconds;
+                    if (this.channel?.leaseToken) {
+                        this.channel.startHeartbeat(this.heartbeatSeconds);
+                    }
+                }
+                return;
+            case 'presence.state': {
+                const state = this.string(payload.state);
+                if (this.view instanceof VoicePresenceView &&
+                    [
+                        'ready',
+                        'listening',
+                        'thinking',
+                        'speaking',
+                        'acting',
+                        'awaiting_confirmation',
+                        'reconnecting',
+                        'ending',
+                    ].includes(state) &&
+                    this.result) {
+                    this.view.applyPresenceState(state, message.sequence, message.sessionId, this.context?.currentPageId ?? null, this.channel?.leaseToken ?? 0);
+                }
+                return;
+            }
+            case 'caption.segment': {
+                const text = this.string(payload.text);
+                const speaker = payload.speaker === 'visitor' ? 'user' : 'assistant';
+                if (text) {
+                    this.view?.addCaption(speaker, text, payload.final === true);
+                    if (speaker === 'user' && payload.final === true) {
+                        if (!this.resolvePendingConfirmationReply(text)) {
+                            this.cancelConfirmationForNewRequest();
+                        }
+                    }
+                }
+                return;
+            }
+            case 'presentation.intent':
+            case 'presentation.clear': {
+                const intent = parsePresentationIntent(payload);
+                if (!intent || !this.presentation) {
+                    if (intent) {
+                        this.sendPresentationResult({
+                            presentationId: intent.presentationId,
+                            status: 'unsupported',
+                            reasonCode: 'PRESENTATION_DISABLED',
+                            pageId: this.context?.currentPageId ?? 'page_unknown',
+                            domRevision: intent.domRevision,
+                            shownAt: null,
+                        });
+                    }
+                    return;
+                }
+                this.sendPresentationResult(this.presentation.render(intent));
+                return;
+            }
+            case 'experience.notice': {
+                const code = this.string(payload.code);
+                if (code === 'AUDIO_PLAYBACK_BLOCKED') {
+                    this.view?.setStatus('Tap the voice button to resume audio.');
+                }
+                return;
+            }
+            case 'assistant.state': {
+                const state = payload.state;
+                if (state === 'listening' ||
+                    state === 'thinking' ||
+                    state === 'ready') {
+                    this.view?.setAssistantState(state);
+                }
+                return;
+            }
+            case 'assistant.caption':
+            case 'user.caption': {
+                const text = typeof payload.text === 'string' ? payload.text : '';
+                if (!text)
+                    return;
+                const role = message.type.startsWith('assistant')
+                    ? 'assistant'
+                    : 'user';
+                this.view?.addCaption(role, text, payload.final === true);
+                if (role === 'user' && payload.final === true) {
+                    if (!this.resolvePendingConfirmationReply(text)) {
+                        this.cancelConfirmationForNewRequest();
+                    }
+                }
+                if (role === 'assistant' && message.v === 1) {
+                    this.view?.setAssistantState('speaking');
+                }
+                return;
+            }
+            case 'assistant.interrupted':
+                this.presentation?.clear('all');
+                this.media?.endPushToTalk();
+                this.pushActive = false;
+                this.view?.interruptPlayback();
+                return;
+            case 'voice.turn_mode': {
+                const manual = payload.mode === 'manual';
+                this.manualTurn = manual;
+                this.pushActive = false;
+                this.media?.setManualTurn(manual);
+                this.view?.setManualTurn(manual);
+                this.updateResumeManualTurn();
+                return;
+            }
+            case 'voice.push.ready':
+                if (!this.manualTurn)
+                    return;
+                this.pushActive = true;
+                this.media?.beginPushToTalk();
+                this.view?.setPushActive(true);
+                return;
+            case 'voice.push.committed':
+                this.pushActive = false;
+                this.view?.setPushActive(false);
+                return;
+            case 'confirmation.request': {
+                this.presentation?.clear('all');
+                const actionId = this.string(payload.actionId);
+                const proposalChecksum = this.string(payload.proposalChecksum);
+                const expiresAt = this.string(payload.expiresAt);
+                if (!actionId || !proposalChecksum || !expiresAt)
+                    return;
+                this.pendingAction = true;
+                this.pendingConfirmation = { actionId, proposalChecksum };
+                this.view?.showConfirmation({
+                    actionId,
+                    proposalChecksum,
+                    action: this.string(payload.action) ||
+                        this.string(payload.title) ||
+                        this.view?.message('connectedTool') || '',
+                    targetLabel: this.string(payload.targetLabel) ||
+                        this.string(payload.title) ||
+                        this.view?.message('approvedService') || '',
+                    reason: this.string(payload.reason) || this.string(payload.description),
+                    expectedEffect: this.string(payload.expectedEffect) ||
+                        this.view?.message('approvedToolEffect') || '',
+                    expiresAt,
+                });
+                void this.confirmSafetySurface(actionId, proposalChecksum);
+                return;
+            }
+            case 'action.grant':
+                await this.executeGrant(payload);
+                return;
+            case 'action.verified':
+                this.pendingAction = false;
+                this.view?.showActionState(payload.verified === true ? 'verified' : 'failed');
+                return;
+            case 'action.revoked':
+                this.pendingAction = false;
+                this.pendingConfirmation = null;
+                this.view?.dismissActionState();
+                return;
+            case 'context.resync_required':
+                await this.context?.captureAndPublish();
+                return;
+            case 'visual_context.request': {
+                const requestId = this.string(payload.requestId);
+                const functionCallId = this.string(payload.functionCallId);
+                const expiresAt = this.string(payload.expiresAt);
+                const expiresAtMs = Date.parse(expiresAt);
+                const approvalMode = payload.approvalMode === 'automatic' ? 'automatic' : 'manual';
+                if (!/^[A-Za-z0-9_.:-]{8,128}$/.test(requestId) ||
+                    !functionCallId ||
+                    functionCallId.length > 256 ||
+                    !Number.isFinite(expiresAtMs) ||
+                    expiresAtMs <= Date.now() ||
+                    expiresAtMs > Date.now() + 90000) {
+                    return;
+                }
+                const request = {
+                    requestId,
+                    functionCallId,
+                    reason: this.string(payload.reason).slice(0, 500),
+                    expiresAt,
+                    approvalMode,
+                };
+                if (!this.scopes.includes('visual_context') ||
+                    !this.scopes.includes('page_context') ||
+                    !this.bootstrap?.capabilities?.visualContext ||
+                    !this.context) {
+                    this.send('visual_context.result', {
+                        requestId,
+                        functionCallId,
+                        approved: false,
+                        reasonCode: 'CAPTURE_UNAVAILABLE',
+                    });
+                    return;
+                }
+                if (approvalMode === 'automatic') {
+                    void this.resolveVisualContext(request, true, false);
+                }
+                else {
+                    this.view?.showVisualRequest(request);
+                }
+                return;
+            }
+            case 'session.state': {
+                const state = this.string(payload.state);
+                if (state === 'paused')
+                    this.view?.setPaused(true);
+                if (state === 'active_text' || state === 'active_voice') {
+                    this.view?.setPaused(false);
+                }
+                if (TERMINAL_STATES.has(state)) {
+                    this.finishFromServer(this.string(payload.reasonCode));
+                }
+                return;
+            }
+            case 'provider.reconnecting':
+                this.view?.showConnecting(true, this.mode);
+                this.state('reconnecting');
+                return;
+            case 'provider.warning':
+                this.view?.setStatus(this.string(payload.message) || this.view.message('error'));
+                return;
+            case 'limit.reached':
+                this.view?.showLimit(this.string(payload.message));
+                return;
+            case 'handoff.state': {
+                const state = this.string(payload.state);
+                const configuredMessage = this.string(payload.message);
+                this.view?.setStatus(state === 'connected' && configuredMessage
+                    ? configuredMessage
+                    : state === 'connected'
+                        ? this.view.message('humanConnected')
+                        : state === 'connecting'
+                            ? this.view.message('humanConnecting')
+                            : this.view.message('humanUnavailable'));
+                if (state === 'connected') {
+                    this.pendingAction = false;
+                    this.presentation?.clear('all');
+                }
+                return;
+            }
+            case 'error': {
+                const code = this.string(payload.code);
+                if (this.pendingAction && ACTION_SCOPED_ERROR_CODES.has(code)) {
+                    this.pendingAction = false;
+                    this.pendingConfirmation = null;
+                    this.view?.showActionState('failed');
+                    await this.context?.captureAndPublish();
+                    return;
+                }
+                const retryable = payload.retryable === true;
+                this.view?.showError(this.string(payload.message), retryable);
+                if (!retryable)
+                    this.clearResume();
+                return;
+            }
+        }
+    }
+    async executeGrant(payload) {
+        const grant = this.parseGrant(payload);
+        if (!grant || !this.context || !this.channel)
+            return;
+        this.pendingAction = true;
+        this.view?.showActionState('running');
+        let result;
+        if (!this.view?.safetySurfaceVisible()) {
+            result = {
+                grant: grant.grant,
+                actionId: grant.actionId,
+                status: 'blocked',
+                observed: {
+                    url: `${location.origin}${location.pathname}`,
+                    revision: this.context.currentRevision,
+                    targetState: 'unchanged',
+                    safeSummary: 'The isolated safety controls were not visible.',
+                },
+            };
+        }
+        else {
+            result = await this.context.execute(grant);
+        }
+        const channel = this.channel;
+        const messageId = this.send('action.result', result);
+        const deferredNavigation = await this.context.completeActionExecution(grant.actionId);
+        if (!deferredNavigation || !channel || !messageId)
+            return;
+        const acknowledged = await channel.waitForAck(messageId);
+        if (acknowledged &&
+            channel === this.channel &&
+            !this.ended &&
+            new URL(deferredNavigation).origin === window.location.origin) {
+            window.location.assign(deferredNavigation);
+        }
+        else if (!acknowledged) {
+            this.view?.showActionState('failed');
+        }
+    }
+    async confirmSafetySurface(actionId, proposalChecksum) {
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+            if (this.pendingConfirmation?.actionId !== actionId ||
+                this.pendingConfirmation.proposalChecksum !== proposalChecksum) {
+                return;
+            }
+            if (this.view?.safetySurfaceVisible())
+                return;
+        }
+        if (this.pendingConfirmation?.actionId !== actionId ||
+            this.pendingConfirmation.proposalChecksum !== proposalChecksum) {
+            return;
+        }
+        this.pendingAction = false;
+        this.view?.cancelPendingConfirmation();
+    }
+    async resolveVisualContext(request, approved, requireVisibleSafetySurface) {
+        const showManualResult = request.approvalMode === 'manual';
+        if (!approved) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'VISITOR_DECLINED',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        if (Date.parse(request.expiresAt) <= Date.now()) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'REQUEST_EXPIRED',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        if (requireVisibleSafetySurface && !this.view?.safetySurfaceVisible()) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'SAFETY_SURFACE_HIDDEN',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        const context = this.context;
+        if (!context) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'CAPTURE_UNAVAILABLE',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        await context.captureAndPublish();
+        if (Date.parse(request.expiresAt) <= Date.now()) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'REQUEST_EXPIRED',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        const capture = context.captureVisualContext();
+        if (!capture) {
+            this.send('visual_context.result', {
+                requestId: request.requestId,
+                functionCallId: request.functionCallId,
+                approved: false,
+                reasonCode: 'CAPTURE_UNAVAILABLE',
+            });
+            if (showManualResult)
+                this.view?.showVisualResult(false);
+            return;
+        }
+        this.send('visual_context.result', {
+            requestId: request.requestId,
+            functionCallId: request.functionCallId,
+            approved: true,
+            capture,
+        });
+        if (showManualResult)
+            this.view?.showVisualResult(true);
+    }
+    parseGrant(payload) {
+        const action = this.string(payload.action);
+        if (![
+            'scroll',
+            'highlight',
+            'focus',
+            'click',
+            'type',
+            'select',
+            'submit',
+        ].includes(action)) {
+            return null;
+        }
+        const grant = this.string(payload.grant);
+        const actionId = this.string(payload.actionId);
+        const targetId = this.string(payload.targetId);
+        const expiresAt = this.string(payload.expiresAt);
+        const domRevision = payload.domRevision;
+        const fencingToken = payload.fencingToken;
+        if (!grant ||
+            !actionId ||
+            !targetId ||
+            !expiresAt ||
+            typeof domRevision !== 'number' ||
+            typeof fencingToken !== 'number' ||
+            fencingToken !== this.channel?.leaseToken) {
+            return null;
+        }
+        return {
+            grant,
+            actionId,
+            action: action,
+            targetId,
+            domRevision,
+            fencingToken,
+            expiresAt,
+            ...(typeof payload.value === 'string' ? { value: payload.value } : {}),
+            ...(typeof payload.optionValueId === 'string'
+                ? { optionValueId: payload.optionValueId }
+                : {}),
+            ...(typeof payload.desiredChecked === 'boolean'
+                ? { desiredChecked: payload.desiredChecked }
+                : {}),
+        };
+    }
+    updateMute(muted) {
+        this.media?.setMuted(muted);
+        this.send('media.state', {
+            microphone: muted
+                ? 'muted'
+                : this.mode === 'voice'
+                    ? 'active'
+                    : 'unavailable',
+            playback: this.mode === 'voice' ? 'active' : 'paused',
+            captions: true,
+        });
+    }
+    interrupt() {
+        if (this.mode !== 'voice')
+            return;
+        this.presentation?.clear('all');
+        this.media?.endPushToTalk();
+        this.pushActive = false;
+        this.view?.setPushActive(false);
+        this.send('session.interrupt', {});
+    }
+    updateVoiceTurnMode(manual) {
+        if (this.mode !== 'voice' || !this.channel?.isOpen)
+            return;
+        if (!manual && this.bootstrap?.voice?.turnMode === 'manual')
+            return;
+        if (this.pushActive) {
+            this.media?.endPushToTalk();
+            this.pushActive = false;
+            this.view?.setPushActive(false);
+        }
+        this.send('voice.turn_mode', { mode: manual ? 'manual' : 'configured' });
+    }
+    updatePushToTalk(active) {
+        if (this.mode !== 'voice' ||
+            !this.manualTurn ||
+            !this.channel?.isOpen) {
+            return;
+        }
+        if (active) {
+            if (!this.pushActive)
+                this.send('voice.push.start', {});
+            return;
+        }
+        if (!this.pushActive)
+            return;
+        this.media?.endPushToTalk();
+        this.pushActive = false;
+        this.view?.setPushActive(false);
+        this.send('voice.push.commit', {});
+    }
+    async updatePause(paused) {
+        if (!this.result || !this.channel?.leaseToken)
+            return;
+        try {
+            this.send(paused ? 'session.pause' : 'session.resume', {
+                actions: true,
+            });
+        }
+        catch {
+            await this.runtime.pauseOrResume(this.result, this.channel.leaseToken, paused ? 'pause' : 'resume');
+        }
+    }
+    updateCaptions(enabled) {
+        this.send('media.state', {
+            microphone: this.mode === 'voice' ? 'active' : 'unavailable',
+            playback: this.mode === 'voice' ? 'active' : 'paused',
+            captions: enabled,
+        });
+    }
+    updateVisualPause(paused) {
+        if (!this.visualConsentGranted || !this.channel?.isOpen)
+            return;
+        this.scopes = paused
+            ? this.scopes.filter((scope) => scope !== 'visual_context')
+            : [...new Set([...this.scopes, 'visual_context'])];
+        this.send('consent.update', { scopes: this.scopes, locale: this.locale });
+        const record = this.readResume();
+        if (record) {
+            this.storeResume({ ...record, scopes: [...this.scopes] });
+        }
+    }
+    async switchToText() {
+        if (this.mode === 'text' || this.isVoicePresence())
+            return;
+        this.media?.switchToTextOnly();
+        this.mode = 'text';
+        this.manualTurn = false;
+        this.pushActive = false;
+        this.send('session.mode', { mode: 'text' });
+        this.send('media.state', {
+            microphone: 'unavailable',
+            playback: 'paused',
+            captions: true,
+        });
+        const record = this.readResume();
+        if (record) {
+            this.storeResume({ ...record, mode: 'text', manualTurn: false });
+        }
+        this.view?.setMuted(false);
+        this.view?.configureVoiceControls(false, false, false);
+        this.view?.setStatus(this.view.message('textMode'));
+    }
+    async submitFeedback(outcome) {
+        if (!this.result)
+            return;
+        try {
+            await this.runtime.feedback(this.result, { rating: null, outcome });
+        }
+        catch {
+            // Feedback is optional and never reopens a terminal session.
+        }
+    }
+    retry() {
+        const resume = this.readResume();
+        if (resume && this.lock.acquire()) {
+            this.view?.showConnecting(true, resume.mode);
+            return this.resume(resume);
+        }
+        if (this.lastLaunch) {
+            return this.launch(this.lastLaunch.mode, this.lastLaunch.scopes);
+        }
+    }
+    scheduleReconnect() {
+        if (this.ended ||
+            this.reconnecting ||
+            this.destroyed ||
+            !navigator.onLine) {
+            return;
+        }
+        const record = this.readResume();
+        if (!record || this.reconnectAttempts >= 5) {
+            this.view?.showError(this.view.message('reconnectFailed'), false);
+            return;
+        }
+        this.reconnectAttempts += 1;
+        const delay = Math.min(8000, 500 * 2 ** (this.reconnectAttempts - 1));
+        this.view?.showConnecting(true, record.mode);
+        this.cleanupTransport();
+        setTimeout(() => {
+            if (!this.ended && navigator.onLine)
+                void this.resume(record);
+        }, delay + Math.floor(Math.random() * 250));
+    }
+    createMedia() {
+        return new RealtimeMedia(this.runtime, {
+            onLocalStream: (stream) => {
+                if (this.view instanceof VoicePresenceView) {
+                    this.view.setLocalStream(stream);
+                }
+            },
+            onRemoteStream: (stream) => this.view?.setRemoteStream(stream),
+            onConnectionState: (state) => {
+                if (state === 'failed')
+                    this.scheduleReconnect();
+            },
+            onMicrophoneUnavailable: () => {
+                if (this.isVoicePresence()) {
+                    this.send('experience.end', { reason: 'microphone_revoked' });
+                    this.finishFromServer('MICROPHONE_REVOKED');
+                }
+                else {
+                    void this.switchToText();
+                }
+            },
+        });
+    }
+    finishFromServer(reasonCode) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.clearResume();
+        this.cleanupTransport();
+        this.lock.release();
+        this.view?.showEnded(reasonCode === 'VISITOR_INACTIVITY_LIMIT'
+            ? this.view.message('idleEnded')
+            : reasonCode === 'CREDIT_LIMIT_REACHED' ||
+                reasonCode === 'CREDITS_UNAVAILABLE'
+                ? this.view.message('limitReached')
+                : undefined);
+        this.state('ended');
+    }
+    cleanupTransport(options = {}) {
+        if (!options.preserveConnectionRequest) {
+            this.connectionAbort?.abort();
+            this.connectionAbort = null;
+        }
+        this.presentation?.destroy();
+        this.presentation = null;
+        this.context?.stop();
+        this.context = null;
+        if (!options.preserveControlChannel) {
+            this.channel?.close();
+            this.channel = null;
+        }
+        this.media?.close();
+        this.media = null;
+        this.pendingAction = false;
+        this.pendingConfirmation = null;
+        this.pushActive = false;
+    }
+    async requestRuntimeEnd(result, fencingToken, fallbackChannel, terminalMessageId) {
+        if (terminalMessageId &&
+            fallbackChannel &&
+            await fallbackChannel.waitForAck(terminalMessageId, 2000)) {
+            return;
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        try {
+            await this.runtime.end(result, fencingToken, controller.signal);
+        }
+        catch {
+            try {
+                fallbackChannel?.send('session.end', { reason: 'visitor' });
+            }
+            catch {
+                // Runtime reconciliation finalizes sessions whose client disappeared.
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    send(type, payload) {
+        if (!this.channel?.isOpen)
+            return null;
+        try {
+            return this.channel.send(type, payload);
+        }
+        catch {
+            this.scheduleReconnect();
+            return null;
+        }
+    }
+    replayContext() {
+        const meta = this.app.getSessionMeta();
+        const sessionId = String(meta.sessionID ?? '');
+        return /^\d{1,32}$/.test(sessionId)
+            ? { replay: { sessionId, tabId: this.tabId } }
+            : {};
+    }
+    visitorId() {
+        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))
+                return stored;
+            const created = randomId('visitor');
+            localStorage.setItem(key, created);
+            return created;
+        }
+        catch {
+            return randomId('visitor');
+        }
+    }
+    readResume() {
+        try {
+            return parseResumeRecord(sessionStorage.getItem(this.storageKey));
+        }
+        catch {
+            return null;
+        }
+    }
+    writeResume(result, mode, scopes, visualConsentGranted = scopes.includes('visual_context'), clientSequence = 0) {
+        this.storeResume({
+            sessionId: result.sessionId,
+            resumeCredential: result.resumeCredential,
+            tabId: this.tabId,
+            clientSequence,
+            mode,
+            scopes: [...scopes],
+            locale: this.locale,
+            expiresAt: Date.now() + STORAGE_TTL_MS,
+            visualConsentGranted,
+            manualTurn: mode === 'voice' && this.manualTurn,
+            protocolVersion: result.protocolVersion,
+            experienceMode: result.experienceMode,
+            fallbackIntent: this.activeFallback,
+        });
+    }
+    updateResumeManualTurn() {
+        const record = this.readResume();
+        if (record)
+            this.storeResume({ ...record, manualTurn: this.manualTurn });
+    }
+    updateResumeSequence(clientSequence) {
+        const record = this.readResume();
+        if (record && record.clientSequence !== clientSequence) {
+            this.storeResume({ ...record, clientSequence });
+        }
+    }
+    storeResume(record) {
+        try {
+            sessionStorage.setItem(this.storageKey, JSON.stringify(record));
+        }
+        catch {
+            // Resume is an enhancement; active in-memory control remains valid.
+        }
+    }
+    clearResume() {
+        try {
+            sessionStorage.removeItem(this.storageKey);
+        }
+        catch {
+            // Ignore unavailable storage.
+        }
+    }
+    publicError(error) {
+        if (error instanceof RuntimeClientError)
+            return error.message;
+        if (error instanceof DOMException && error.name === 'NotAllowedError') {
+            return this.isVoicePresence()
+                ? 'Microphone access was not granted. Allow microphone access to use voice assist.'
+                : 'Microphone access was not granted. You can continue with text.';
+        }
+        return 'AI Live Assist is temporarily unavailable.';
+    }
+    retryable(error) {
+        return error instanceof RuntimeClientError ? error.retryable : false;
+    }
+    string(value) {
+        return typeof value === 'string' ? value.slice(0, 2000) : '';
+    }
+    state(value) {
+        try {
+            this.options.onStateChange?.(value);
+        }
+        catch {
+            // Consumer callbacks cannot interrupt safety state transitions.
+        }
+    }
+    sendPresentationResult(value) {
+        this.send('presentation.result', { ...value });
+    }
+    isVoicePresence() {
+        return (this.bootstrap?.experienceMode ?? 'standard') === 'voice_presence';
+    }
+    lowPowerMode() {
+        const connection = navigator.connection;
+        const configured = this.bootstrap?.appearance?.voicePresence?.visual.lowPowerMode;
+        if (configured === 'always')
+            return true;
+        if (configured === 'never')
+            return false;
+        return connection?.saveData === true || connection?.effectiveType === '2g';
+    }
+    bindWindowLifecycle() {
+        window.addEventListener('pagehide', this.onPageHide);
+        window.addEventListener('pageshow', this.onPageShow);
+        window.addEventListener('online', this.onOnline);
+        window.addEventListener('offline', this.onOffline);
+        window.addEventListener('focus', this.onWindowFocus);
+        document.addEventListener('visibilitychange', this.onVisibilityChange);
+        document.addEventListener('pointerdown', this.onVisitorControl, true);
+        document.addEventListener('keydown', this.onVisitorControl, true);
+    }
+    requestFocusedHandoff() {
+        if (document.visibilityState === 'hidden' ||
+            this.destroyed ||
+            this.ended ||
+            this.result ||
+            this.reconnecting ||
+            !this.bootstrap ||
+            !this.view ||
+            !this.isVoicePresence()) {
+            return;
+        }
+        this.lock.requestTakeover();
+    }
+    handoffToFocusedTab(requesterId, requestId) {
+        if (this.destroyed ||
+            this.ended ||
+            !this.isVoicePresence()) {
+            return;
+        }
+        if (this.reconnecting) {
+            this.pendingFocusedHandoff = { requesterId, requestId };
+            return;
+        }
+        if (!this.result)
+            return;
+        this.pendingFocusedHandoff = null;
+        const record = this.readResume();
+        if (!record || !record.tabId)
+            return;
+        this.cleanupTransport();
+        this.result = null;
+        this.clearResume();
+        if (!this.lock.handoff(requesterId, requestId, record)) {
+            this.storeResume(record);
+            if (this.lock.acquire()) {
+                this.view?.showConnecting(true, record.mode);
+                void this.resume(record);
+            }
+        }
+    }
+    async acceptFocusedTabHandoff(payload) {
+        const record = parseResumeRecord(JSON.stringify(payload));
+        if (!record ||
+            !record.tabId ||
+            record.protocolVersion !== 2 ||
+            record.experienceMode !== 'voice_presence') {
+            this.lock.release();
+            return;
+        }
+        this.tabId = record.tabId;
+        this.storeResume(record);
+        this.ended = false;
+        this.view?.showActiveElsewhere(false);
+        if (!this.bootstrap || !this.view || this.reconnecting || this.destroyed)
+            return;
+        this.view.showConnecting(true, record.mode);
+        await this.resume(record);
+    }
+}