@oxvo/ai-live-assist 7.3.4 → 7.4.23

package/cjs/dialogFocusScope.d.ts

@@ -0,0 +1,37 @@
+type DialogPresentation = {
+    surface: HTMLElement;
+    initialFocus: () => HTMLElement | null;
+    fallbackFocus: () => HTMLElement | null;
+    onEscape: () => void;
+};
+/**
+ * Owns keyboard focus for one safety presentation at a time. Presentation
+ * replacement is generation-guarded so stale microtasks cannot focus or
+ * restore an earlier prompt.
+ */
+export declare class DialogFocusScope {
+    private readonly root;
+    private readonly host;
+    private current;
+    private restoreTarget;
+    private generation;
+    private redirectGeneration;
+    private containmentBound;
+    private destroyed;
+    constructor(root: ShadowRoot, host: HTMLElement);
+    present(value: DialogPresentation): void;
+    dismiss(surface: HTMLElement, options?: {
+        restore?: boolean;
+    }): void;
+    clear(options?: {
+        restore?: boolean;
+    }): void;
+    destroy(): void;
+    private bindContainment;
+    private unbindContainment;
+    private focusPresentation;
+    private onFocusIn;
+    private activeFocusTarget;
+    private onKeyDown;
+}
+export {};

package/cjs/dialogFocusScope.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogFocusScope = void 0;
+const focusableSelector = [
+    "button:not([disabled])",
+    "input:not([disabled])",
+    "textarea:not([disabled])",
+    "select:not([disabled])",
+    "summary",
+    "a[href]",
+    '[tabindex]:not([tabindex="-1"])',
+].join(",");
+const isVisibleFocusTarget = (element) => {
+    if (!element?.isConnected ||
+        element.hidden ||
+        element.getAttribute("aria-hidden") === "true" ||
+        element.closest("[hidden],[inert]") ||
+        ("disabled" in element && element.disabled === true)) {
+        return false;
+    }
+    try {
+        const computed = getComputedStyle(element);
+        return computed.display !== "none" && computed.visibility !== "hidden";
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Owns keyboard focus for one safety presentation at a time. Presentation
+ * replacement is generation-guarded so stale microtasks cannot focus or
+ * restore an earlier prompt.
+ */
+class DialogFocusScope {
+    constructor(root, host) {
+        this.root = root;
+        this.host = host;
+        this.current = null;
+        this.restoreTarget = null;
+        this.generation = 0;
+        this.redirectGeneration = null;
+        this.containmentBound = false;
+        this.destroyed = false;
+        this.onFocusIn = (event) => {
+            const presentation = this.current;
+            if (!presentation || this.destroyed)
+                return;
+            const eventPath = event.composedPath?.() ?? [];
+            const eventTarget = event.target;
+            if (eventPath.includes(presentation.surface) ||
+                (eventTarget instanceof Node &&
+                    presentation.surface.contains(eventTarget))) {
+                return;
+            }
+            const generation = this.generation;
+            if (this.redirectGeneration === generation)
+                return;
+            this.redirectGeneration = generation;
+            queueMicrotask(() => {
+                if (this.redirectGeneration === generation) {
+                    this.redirectGeneration = null;
+                }
+                if (this.destroyed ||
+                    generation !== this.generation ||
+                    this.current !== presentation ||
+                    presentation.surface.contains(this.root.activeElement)) {
+                    return;
+                }
+                this.focusPresentation(presentation);
+            });
+        };
+        this.onKeyDown = (event) => {
+            const presentation = this.current;
+            if (!presentation || event.currentTarget !== presentation.surface)
+                return;
+            if (event.key === "Escape") {
+                event.preventDefault();
+                event.stopPropagation();
+                presentation.onEscape();
+                return;
+            }
+            if (event.key !== "Tab")
+                return;
+            const focusable = [
+                ...presentation.surface.querySelectorAll(focusableSelector),
+            ].filter(isVisibleFocusTarget);
+            const first = focusable[0];
+            const last = focusable.at(-1);
+            if (!first || !last)
+                return;
+            const active = this.root.activeElement;
+            if (!presentation.surface.contains(active)) {
+                event.preventDefault();
+                (event.shiftKey ? last : first).focus({ preventScroll: true });
+                return;
+            }
+            if (event.shiftKey && active === first) {
+                event.preventDefault();
+                last.focus({ preventScroll: true });
+            }
+            else if (!event.shiftKey && active === last) {
+                event.preventDefault();
+                first.focus({ preventScroll: true });
+            }
+        };
+    }
+    present(value) {
+        if (this.destroyed)
+            return;
+        if (!this.current && !isVisibleFocusTarget(this.restoreTarget)) {
+            this.restoreTarget = this.activeFocusTarget(value);
+        }
+        this.current?.surface.removeEventListener("keydown", this.onKeyDown);
+        this.current = value;
+        this.generation += 1;
+        this.redirectGeneration = null;
+        const generation = this.generation;
+        value.surface.addEventListener("keydown", this.onKeyDown);
+        this.bindContainment();
+        const immediateTarget = value.initialFocus();
+        if (isVisibleFocusTarget(immediateTarget)) {
+            immediateTarget.focus({ preventScroll: true });
+        }
+        queueMicrotask(() => {
+            if (this.destroyed ||
+                generation !== this.generation ||
+                this.current !== value) {
+                return;
+            }
+            if (value.surface.contains(this.root.activeElement))
+                return;
+            const target = value.initialFocus();
+            if (isVisibleFocusTarget(target))
+                target.focus({ preventScroll: true });
+        });
+    }
+    dismiss(surface, options = {}) {
+        if (this.current?.surface !== surface)
+            return;
+        const presentation = this.current;
+        presentation.surface.removeEventListener("keydown", this.onKeyDown);
+        this.current = null;
+        this.generation += 1;
+        this.redirectGeneration = null;
+        this.unbindContainment();
+        const generation = this.generation;
+        if (options.restore === false) {
+            this.restoreTarget = null;
+            return;
+        }
+        const restoreTarget = this.restoreTarget;
+        queueMicrotask(() => {
+            if (this.destroyed ||
+                generation !== this.generation ||
+                this.current) {
+                return;
+            }
+            const fallback = presentation.fallbackFocus();
+            const target = isVisibleFocusTarget(restoreTarget)
+                ? restoreTarget
+                : isVisibleFocusTarget(fallback)
+                    ? fallback
+                    : null;
+            this.restoreTarget = null;
+            target?.focus({ preventScroll: true });
+        });
+    }
+    clear(options = {}) {
+        const surface = this.current?.surface;
+        if (surface) {
+            this.dismiss(surface, options);
+            return;
+        }
+        this.generation += 1;
+        this.restoreTarget = null;
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.current?.surface.removeEventListener("keydown", this.onKeyDown);
+        this.unbindContainment();
+        this.current = null;
+        this.restoreTarget = null;
+        this.redirectGeneration = null;
+        this.generation += 1;
+    }
+    bindContainment() {
+        if (this.containmentBound)
+            return;
+        this.containmentBound = true;
+        this.root.addEventListener("focusin", this.onFocusIn, true);
+        document.addEventListener("focusin", this.onFocusIn, true);
+    }
+    unbindContainment() {
+        if (!this.containmentBound)
+            return;
+        this.containmentBound = false;
+        this.root.removeEventListener("focusin", this.onFocusIn, true);
+        document.removeEventListener("focusin", this.onFocusIn, true);
+    }
+    focusPresentation(presentation) {
+        const preferred = presentation.initialFocus();
+        if (isVisibleFocusTarget(preferred)) {
+            preferred.focus({ preventScroll: true });
+            return;
+        }
+        const first = [
+            ...presentation.surface.querySelectorAll(focusableSelector),
+        ].find(isVisibleFocusTarget);
+        first?.focus({ preventScroll: true });
+    }
+    activeFocusTarget(value) {
+        const shadowActive = this.root.activeElement;
+        if (shadowActive instanceof HTMLElement)
+            return shadowActive;
+        const documentActive = document.activeElement;
+        if (documentActive instanceof HTMLElement &&
+            documentActive !== document.body &&
+            documentActive !== document.documentElement &&
+            documentActive !== this.host) {
+            return documentActive;
+        }
+        return value.fallbackFocus();
+    }
+}
+exports.DialogFocusScope = DialogFocusScope;

package/cjs/experienceState.js

@@ -19,7 +19,7 @@ const transitions = new Map([
     ["connecting", new Set(["active.ready", "active.reconnecting", "recoverable_error", "terminal_error", "ending"])],
     ["active.reconnecting", new Set(["connecting", "active.ready", "recoverable_error", "terminal_error", "ending"])],
     ["recoverable_error", new Set(["launcher", "preflight", "requesting_microphone", "connecting", "active.reconnecting", "ending", "terminal_error"])],
-    ["terminal_error", new Set(["launcher", "ended"])],
+    ["terminal_error", new Set(["launcher", "ended", "ending"])],
     ["ending", new Set(["ended", "terminal_error"])],
     ["ended", new Set(["launcher"])],
 ]);

package/cjs/index.d.ts

@@ -2,7 +2,7 @@ import type { App, Options as BrowserOptions } from '@oxvo/browser';
 import AiLiveAssist from './AiLiveAssist.js';
 import type { PluginOptions } from './types.js';
 import { VERSION } from './version.js';
-export type { PluginOptions } from './types.js';
+export type { AiGuideControllerState, AiGuideOpenInput, MessengerCompanionConfig, PluginOptions, } from './types.js';
 export { AiLiveAssist, VERSION };
 export default function aiLiveAssist(options?: PluginOptions): (app: App | null) => AiLiveAssist | undefined;
 export declare function installAiLiveAssist(input: {

package/cjs/index.js

@@ -18,8 +18,8 @@ function aiLiveAssist(options = {}) {
         if (document.querySelector('[data-oxvo-ai-live-assist-root]')) {
             return undefined;
         }
-        if (!app.checkRequiredVersion?.('7.3.0')) {
-            console.warn('OXVO AI Guide requires @oxvo/browser version 7.3.0 or newer.');
+        if (!app.checkRequiredVersion?.('7.4.23')) {
+            console.warn('OXVO AI Guide requires @oxvo/browser version 7.4.23 or newer.');
             return undefined;
         }
         const instance = new AiLiveAssist_js_1.default(app, options);

package/cjs/media.d.ts

@@ -6,9 +6,11 @@ type MediaCallbacks = {
     onConnectionState: (state: RTCPeerConnectionState) => void;
     onMicrophoneUnavailable: () => void;
 };
+type MediaLifecycleCheck = () => boolean;
 export declare class RealtimeMedia {
     private readonly client;
     private readonly callbacks;
+    private readonly isCurrent;
     private connection;
     private localStream;
     private dataChannel;
@@ -16,10 +18,16 @@ export declare class RealtimeMedia {
     private pushActive;
     private muted;
     private replacingDevice;
-    constructor(client: RuntimeClient, callbacks: MediaCallbacks);
-    prepare(mode: AssistMode): Promise<void>;
-    connect(result: LaunchResult, mode: AssistMode, signal: AbortSignal): Promise<number>;
+    private closed;
+    private generation;
+    private deviceGeneration;
+    private signal;
+    private readonly lifetimeAbort;
+    constructor(client: RuntimeClient, callbacks: MediaCallbacks, isCurrent?: MediaLifecycleCheck);
+    prepare(mode: AssistMode, signal: AbortSignal): Promise<void>;
+    connect(result: LaunchResult, mode: AssistMode, signal: AbortSignal, offerIdempotencyKey?: string, expectedSessionState?: 'active_text' | 'active_voice'): Promise<number>;
     setMuted(muted: boolean): void;
+    get isMuted(): boolean;
     setManualTurn(manual: boolean): void;
     beginPushToTalk(): void;
     endPushToTalk(): void;
@@ -30,5 +38,8 @@ export declare class RealtimeMedia {
     private onDeviceChange;
     private replaceUnavailableDevice;
     private waitForIce;
+    private active;
+    private assertActive;
+    private assertReplacementActive;
 }
 export {};

package/cjs/media.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RealtimeMedia = void 0;
+const abortError = () => new DOMException('The operation was aborted.', 'AbortError');
+const stopStream = (stream) => {
+    for (const track of stream?.getTracks() ?? [])
+        track.stop();
+};
 class RealtimeMedia {
-    constructor(client, callbacks) {
+    constructor(client, callbacks, isCurrent = () => true) {
         this.client = client;
         this.callbacks = callbacks;
+        this.isCurrent = isCurrent;
         this.connection = null;
         this.localStream = null;
         this.dataChannel = null;
@@ -12,17 +18,32 @@ class RealtimeMedia {
         this.pushActive = false;
         this.muted = false;
         this.replacingDevice = false;
+        this.closed = false;
+        this.generation = 0;
+        this.deviceGeneration = 0;
+        this.signal = null;
+        this.lifetimeAbort = new AbortController();
         this.onDeviceChange = () => {
+            if (!this.connection && this.localStream) {
+                const track = this.localStream.getAudioTracks()[0];
+                if (!track || track.readyState !== 'live') {
+                    this.callbacks.onMicrophoneUnavailable();
+                }
+                return;
+            }
             void this.replaceUnavailableDevice();
         };
     }
-    async prepare(mode) {
+    async prepare(mode, signal) {
+        this.signal = signal;
+        const generation = this.generation;
+        this.assertActive(signal, generation);
         if (mode !== 'voice')
             return;
         if (!navigator.mediaDevices?.getUserMedia) {
             throw new Error('Microphone access is not available in this browser.');
         }
-        this.localStream = await navigator.mediaDevices.getUserMedia({
+        const stream = await navigator.mediaDevices.getUserMedia({
             audio: {
                 autoGainControl: true,
                 echoCancellation: true,
@@ -30,12 +51,23 @@ class RealtimeMedia {
             },
             video: false,
         });
+        try {
+            this.assertActive(signal, generation);
+        }
+        catch (error) {
+            stopStream(stream);
+            throw error;
+        }
+        this.localStream = stream;
         navigator.mediaDevices.addEventListener?.('devicechange', this.onDeviceChange);
         this.bindTrackEnd();
         this.applyTrackState();
         this.callbacks.onLocalStream(this.localStream);
     }
-    async connect(result, mode, signal) {
+    async connect(result, mode, signal, offerIdempotencyKey, expectedSessionState) {
+        this.signal = signal;
+        const generation = this.generation;
+        this.assertActive(signal, generation);
         const connection = new RTCPeerConnection({ bundlePolicy: 'max-bundle' });
         this.connection = connection;
         this.dataChannel = connection.createDataChannel('oai-events', {
@@ -54,27 +86,49 @@ class RealtimeMedia {
             connection.addTransceiver('audio', { direction: 'recvonly' });
         }
         connection.addEventListener('track', (event) => {
+            if (!this.active(signal, generation) ||
+                this.connection !== connection) {
+                return;
+            }
             const stream = event.streams[0];
             if (stream)
                 this.callbacks.onRemoteStream(stream);
         });
         connection.addEventListener('connectionstatechange', () => {
+            if (!this.active(signal, generation) ||
+                this.connection !== connection) {
+                return;
+            }
             this.callbacks.onConnectionState(connection.connectionState);
         });
         const offer = await connection.createOffer();
+        this.assertActive(signal, generation);
         await connection.setLocalDescription(offer);
+        this.assertActive(signal, generation);
         await this.waitForIce(connection, signal);
+        this.assertActive(signal, generation);
         const localSdp = connection.localDescription?.sdp;
         if (!localSdp)
             throw new Error('The browser could not create a realtime offer.');
-        const response = await this.client.offer(result, localSdp, signal);
+        const response = offerIdempotencyKey
+            ? await this.client.offer(result, localSdp, signal, offerIdempotencyKey)
+            : await this.client.offer(result, localSdp, signal);
+        this.assertActive(signal, generation);
+        if (expectedSessionState &&
+            response.sessionState !== expectedSessionState) {
+            throw new Error('The realtime session activated in an unexpected mode.');
+        }
         await connection.setRemoteDescription({ type: 'answer', sdp: response.answerSdp });
+        this.assertActive(signal, generation);
         return response.fencingToken;
     }
     setMuted(muted) {
         this.muted = muted;
         this.applyTrackState();
     }
+    get isMuted() {
+        return this.muted;
+    }
     setManualTurn(manual) {
         this.manualTurn = manual;
         this.pushActive = false;
@@ -91,23 +145,28 @@ class RealtimeMedia {
         this.applyTrackState();
     }
     switchToTextOnly() {
+        this.deviceGeneration += 1;
         for (const sender of this.connection?.getSenders() ?? []) {
             if (sender.track?.kind === 'audio') {
                 sender.track.stop();
                 void sender.replaceTrack(null);
             }
         }
-        for (const track of this.localStream?.getTracks() ?? [])
-            track.stop();
+        stopStream(this.localStream);
         this.localStream = null;
         this.callbacks.onLocalStream(null);
         navigator.mediaDevices?.removeEventListener?.('devicechange', this.onDeviceChange);
     }
     close() {
+        if (!this.closed) {
+            this.closed = true;
+            this.generation += 1;
+            this.deviceGeneration += 1;
+            this.lifetimeAbort.abort();
+        }
         this.dataChannel?.close();
         this.dataChannel = null;
-        for (const track of this.localStream?.getTracks() ?? [])
-            track.stop();
+        stopStream(this.localStream);
         this.localStream = null;
         this.callbacks.onLocalStream(null);
         navigator.mediaDevices?.removeEventListener?.('devicechange', this.onDeviceChange);
@@ -126,8 +185,16 @@ class RealtimeMedia {
         }
     }
     async replaceUnavailableDevice() {
-        if (this.replacingDevice || !this.connection || !this.localStream)
+        const signal = this.signal;
+        const generation = this.generation;
+        const deviceGeneration = this.deviceGeneration;
+        if (!signal ||
+            !this.active(signal, generation) ||
+            this.replacingDevice ||
+            !this.connection ||
+            !this.localStream) {
             return;
+        }
         const current = this.localStream.getAudioTracks()[0];
         if (!current) {
             this.callbacks.onMicrophoneUnavailable();
@@ -136,6 +203,7 @@ class RealtimeMedia {
         if (current.readyState === 'live') {
             try {
                 const devices = await navigator.mediaDevices.enumerateDevices();
+                this.assertReplacementActive(signal, generation, deviceGeneration);
                 const currentId = current.getSettings().deviceId;
                 if (!currentId ||
                     devices.some((device) => device.kind === 'audioinput' && device.deviceId === currentId)) {
@@ -147,8 +215,11 @@ class RealtimeMedia {
             }
         }
         this.replacingDevice = true;
+        let replacement = null;
         try {
-            const replacement = await navigator.mediaDevices.getUserMedia({
+            const connection = this.connection;
+            const priorStream = this.localStream;
+            replacement = await navigator.mediaDevices.getUserMedia({
                 audio: {
                     autoGainControl: true,
                     echoCancellation: true,
@@ -156,28 +227,41 @@ class RealtimeMedia {
                 },
                 video: false,
             });
+            this.assertReplacementActive(signal, generation, deviceGeneration);
             const track = replacement.getAudioTracks()[0];
-            const sender = this.connection
+            const sender = connection
                 .getSenders()
                 .find((candidate) => candidate.track?.kind === 'audio');
             if (!track || !sender)
                 throw new Error('No replacement microphone track.');
             await sender.replaceTrack(track);
-            for (const prior of this.localStream.getTracks())
-                prior.stop();
-            this.localStream = replacement;
+            this.assertReplacementActive(signal, generation, deviceGeneration);
+            if (this.connection !== connection || this.localStream !== priorStream) {
+                throw abortError();
+            }
+            stopStream(priorStream);
+            const activeReplacement = replacement;
+            this.localStream = activeReplacement;
+            replacement = null;
             this.bindTrackEnd();
             this.applyTrackState();
-            this.callbacks.onLocalStream(replacement);
+            this.callbacks.onLocalStream(activeReplacement);
         }
-        catch {
-            this.callbacks.onMicrophoneUnavailable();
+        catch (error) {
+            stopStream(replacement);
+            if (!(error instanceof DOMException && error.name === 'AbortError') &&
+                this.active(signal, generation)) {
+                this.callbacks.onMicrophoneUnavailable();
+            }
         }
         finally {
             this.replacingDevice = false;
         }
     }
     waitForIce(connection, signal) {
+        if (signal.aborted || this.lifetimeAbort.signal.aborted) {
+            return Promise.reject(abortError());
+        }
         if (connection.iceGatheringState === 'complete')
             return Promise.resolve();
         return new Promise((resolve, reject) => {
@@ -188,12 +272,13 @@ class RealtimeMedia {
             };
             const onAbort = () => {
                 cleanup();
-                reject(new DOMException('The operation was aborted.', 'AbortError'));
+                reject(abortError());
             };
             const cleanup = () => {
                 clearTimeout(timeout);
                 connection.removeEventListener('icegatheringstatechange', onState);
                 signal.removeEventListener('abort', onAbort);
+                this.lifetimeAbort.signal.removeEventListener('abort', onAbort);
             };
             function finish() {
                 cleanup();
@@ -201,7 +286,31 @@ class RealtimeMedia {
             }
             connection.addEventListener('icegatheringstatechange', onState);
             signal.addEventListener('abort', onAbort, { once: true });
+            this.lifetimeAbort.signal.addEventListener('abort', onAbort, { once: true });
         });
     }
+    active(signal, generation) {
+        if (signal.aborted ||
+            this.lifetimeAbort.signal.aborted ||
+            this.closed ||
+            generation !== this.generation) {
+            return false;
+        }
+        try {
+            return this.isCurrent();
+        }
+        catch {
+            return false;
+        }
+    }
+    assertActive(signal, generation) {
+        if (!this.active(signal, generation))
+            throw abortError();
+    }
+    assertReplacementActive(signal, generation, deviceGeneration) {
+        this.assertActive(signal, generation);
+        if (deviceGeneration !== this.deviceGeneration)
+            throw abortError();
+    }
 }
 exports.RealtimeMedia = RealtimeMedia;