@spatialwalk/avatarkit 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/playground/apps/web/src/composables/useRealtimeAvatar.d.ts

@@ -0,0 +1,452 @@
+import { AvatarController } from '@spatialwalk/avatarkit';
+export interface RealtimeAvatarState {
+    isConnected: boolean;
+    isConnecting: boolean;
+    vadActive: boolean;
+    vadBlocked: boolean;
+    isSpeaking: boolean;
+    vadInitializing: boolean;
+    isPlaying: boolean;
+    isPaused: boolean;
+    currentReqId: string | null;
+    playbackProgress: number;
+    messages: Array<{
+        role: 'user' | 'assistant';
+        text: string;
+    }>;
+}
+export interface UseRealtimeAvatarOptions {
+    wsUrl: string;
+    characterId: string;
+    avatarController: AvatarController;
+    enableVAD?: boolean;
+    debug?: boolean;
+}
+export declare function useRealtimeAvatar(options: UseRealtimeAvatarOptions): {
+    state: {
+        isConnected: boolean;
+        isConnecting: boolean;
+        vadActive: boolean;
+        vadBlocked: boolean;
+        isSpeaking: boolean;
+        vadInitializing: boolean;
+        isPlaying: boolean;
+        isPaused: boolean;
+        currentReqId: string | null;
+        playbackProgress: number;
+        messages: {
+            role: "user" | "assistant";
+            text: string;
+        }[];
+    };
+    subtitle: {
+        state: {
+            source: import('./useSubtitle').SubtitleSource;
+            text: string;
+            isStreaming: boolean;
+        };
+        reset: () => void;
+        startStream: (source: import('./useSubtitle').SubtitleSource) => void;
+        appendText: (text: string, isPlaying: boolean) => void;
+        setText: (text: string, source?: import('./useSubtitle').SubtitleSource) => void;
+        endStream: () => void;
+        transitionToLLM: (accumulatedText: string) => void;
+    };
+    telemetry: import('vue').ComputedRef<{
+        sessionId: number;
+        audioQueueMs: number;
+        animQueueFrames: number;
+        lastAudioPacketAgeMs: number;
+        lastAnimPacketAgeMs: number;
+    }>;
+    debugDataCollector: {
+        currentRoundData: import('vue').Ref<{
+            reqId: string;
+            audioChunks: {
+                data: {
+                    [x: number]: number;
+                    readonly BYTES_PER_ELEMENT: number;
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                    findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                    forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                    indexOf: (searchElement: number, fromIndex?: number) => number;
+                    join: (separator?: string) => string;
+                    lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                    readonly length: number;
+                    map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    reduce: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reduceRight: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reverse: () => Uint8Array<ArrayBufferLike>;
+                    set: (array: ArrayLike<number>, offset?: number) => void;
+                    slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                    some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                    subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    toLocaleString: {
+                        (): string;
+                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                    };
+                    toString: () => string;
+                    valueOf: () => Uint8Array<ArrayBufferLike>;
+                    entries: () => ArrayIterator<[number, number]>;
+                    keys: () => ArrayIterator<number>;
+                    values: () => ArrayIterator<number>;
+                    includes: (searchElement: number, fromIndex?: number) => boolean;
+                    at: (index: number) => number | undefined;
+                    findLast: {
+                        <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                        (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                    };
+                    findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                    toReversed: () => Uint8Array<ArrayBuffer>;
+                    toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                    with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                    [Symbol.iterator]: () => ArrayIterator<number>;
+                    readonly [Symbol.toStringTag]: "Uint8Array";
+                };
+                isLast: boolean;
+            }[];
+            flameKeyframes: {
+                translation: number[];
+                rotation: number[];
+                neckPose: number[];
+                jawPose: number[];
+                eyePose: number[];
+                eyeLid: number[];
+                expression: number[];
+            }[];
+            startTime: number;
+            endTime?: number | undefined;
+        } | null, import('./useDebugDataCollector').DebugData | {
+            reqId: string;
+            audioChunks: {
+                data: {
+                    [x: number]: number;
+                    readonly BYTES_PER_ELEMENT: number;
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                    findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                    forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                    indexOf: (searchElement: number, fromIndex?: number) => number;
+                    join: (separator?: string) => string;
+                    lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                    readonly length: number;
+                    map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    reduce: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reduceRight: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reverse: () => Uint8Array<ArrayBufferLike>;
+                    set: (array: ArrayLike<number>, offset?: number) => void;
+                    slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                    some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                    subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    toLocaleString: {
+                        (): string;
+                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                    };
+                    toString: () => string;
+                    valueOf: () => Uint8Array<ArrayBufferLike>;
+                    entries: () => ArrayIterator<[number, number]>;
+                    keys: () => ArrayIterator<number>;
+                    values: () => ArrayIterator<number>;
+                    includes: (searchElement: number, fromIndex?: number) => boolean;
+                    at: (index: number) => number | undefined;
+                    findLast: {
+                        <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                        (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                    };
+                    findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                    toReversed: () => Uint8Array<ArrayBuffer>;
+                    toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                    with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                    [Symbol.iterator]: () => ArrayIterator<number>;
+                    readonly [Symbol.toStringTag]: "Uint8Array";
+                };
+                isLast: boolean;
+            }[];
+            flameKeyframes: {
+                translation: number[];
+                rotation: number[];
+                neckPose: number[];
+                jawPose: number[];
+                eyePose: number[];
+                eyeLid: number[];
+                expression: number[];
+            }[];
+            startTime: number;
+            endTime?: number | undefined;
+        } | null>;
+        allRoundsData: import('vue').Ref<{
+            reqId: string;
+            audioChunks: {
+                data: {
+                    [x: number]: number;
+                    readonly BYTES_PER_ELEMENT: number;
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                    findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                    forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                    indexOf: (searchElement: number, fromIndex?: number) => number;
+                    join: (separator?: string) => string;
+                    lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                    readonly length: number;
+                    map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    reduce: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reduceRight: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reverse: () => Uint8Array<ArrayBufferLike>;
+                    set: (array: ArrayLike<number>, offset?: number) => void;
+                    slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                    some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                    subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    toLocaleString: {
+                        (): string;
+                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                    };
+                    toString: () => string;
+                    valueOf: () => Uint8Array<ArrayBufferLike>;
+                    entries: () => ArrayIterator<[number, number]>;
+                    keys: () => ArrayIterator<number>;
+                    values: () => ArrayIterator<number>;
+                    includes: (searchElement: number, fromIndex?: number) => boolean;
+                    at: (index: number) => number | undefined;
+                    findLast: {
+                        <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                        (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                    };
+                    findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                    toReversed: () => Uint8Array<ArrayBuffer>;
+                    toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                    with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                    [Symbol.iterator]: () => ArrayIterator<number>;
+                    readonly [Symbol.toStringTag]: "Uint8Array";
+                };
+                isLast: boolean;
+            }[];
+            flameKeyframes: {
+                translation: number[];
+                rotation: number[];
+                neckPose: number[];
+                jawPose: number[];
+                eyePose: number[];
+                eyeLid: number[];
+                expression: number[];
+            }[];
+            startTime: number;
+            endTime?: number | undefined;
+        }[], import('./useDebugDataCollector').DebugData[] | {
+            reqId: string;
+            audioChunks: {
+                data: {
+                    [x: number]: number;
+                    readonly BYTES_PER_ELEMENT: number;
+                    readonly buffer: {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => ArrayBuffer;
+                        readonly maxByteLength: number;
+                        readonly resizable: boolean;
+                        resize: (newByteLength?: number) => void;
+                        readonly detached: boolean;
+                        transfer: (newByteLength?: number) => ArrayBuffer;
+                        transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                        readonly [Symbol.toStringTag]: "ArrayBuffer";
+                    } | {
+                        readonly byteLength: number;
+                        slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                        readonly growable: boolean;
+                        readonly maxByteLength: number;
+                        grow: (newByteLength?: number) => void;
+                        readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                    };
+                    readonly byteLength: number;
+                    readonly byteOffset: number;
+                    copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                    findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                    forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                    indexOf: (searchElement: number, fromIndex?: number) => number;
+                    join: (separator?: string) => string;
+                    lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                    readonly length: number;
+                    map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                    reduce: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reduceRight: {
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                        (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                        <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                    };
+                    reverse: () => Uint8Array<ArrayBufferLike>;
+                    set: (array: ArrayLike<number>, offset?: number) => void;
+                    slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                    some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                    sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                    subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                    toLocaleString: {
+                        (): string;
+                        (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                    };
+                    toString: () => string;
+                    valueOf: () => Uint8Array<ArrayBufferLike>;
+                    entries: () => ArrayIterator<[number, number]>;
+                    keys: () => ArrayIterator<number>;
+                    values: () => ArrayIterator<number>;
+                    includes: (searchElement: number, fromIndex?: number) => boolean;
+                    at: (index: number) => number | undefined;
+                    findLast: {
+                        <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                        (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                    };
+                    findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                    toReversed: () => Uint8Array<ArrayBuffer>;
+                    toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                    with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                    [Symbol.iterator]: () => ArrayIterator<number>;
+                    readonly [Symbol.toStringTag]: "Uint8Array";
+                };
+                isLast: boolean;
+            }[];
+            flameKeyframes: {
+                translation: number[];
+                rotation: number[];
+                neckPose: number[];
+                jawPose: number[];
+                eyePose: number[];
+                eyeLid: number[];
+                expression: number[];
+            }[];
+            startTime: number;
+            endTime?: number | undefined;
+        }[]>;
+        startNewRound: (reqId: string) => void;
+        addAudioChunk: (audio: Uint8Array, isLast?: boolean) => void;
+        addFlameKeyframes: (keyframes: import('../../../../generated/realtime/v1/messages').Flame[]) => void;
+        endCurrentRound: () => void;
+        reset: () => void;
+    } | null;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    sendText: (text: string) => Promise<void>;
+    preloadVAD: () => Promise<void>;
+    startVAD: () => Promise<void>;
+    startVADWithVideo: () => Promise<MediaStream | null>;
+    stopVAD: () => Promise<void>;
+    toggleVAD: () => Promise<void>;
+    manualInterrupt: () => Promise<void>;
+    pause: () => void;
+    resume: () => Promise<void>;
+    updateVADConfig: (config: {
+        speechThreshold?: number;
+        exitThreshold?: number;
+        minSilenceDurationMs?: number;
+    }) => void;
+    updateNoiseGateConfig: (config: {
+        openThresholdDb?: number;
+        closeThresholdDb?: number;
+        attackMs?: number;
+        releaseMs?: number;
+        holdMs?: number;
+        highPassHz?: number;
+    }) => void;
+    dispose: () => void;
+};

package/dist/playground/apps/web/src/composables/useSubtitle.d.ts

@@ -0,0 +1,19 @@
+export type SubtitleSource = 'none' | 'asr' | 'llm';
+export interface SubtitleState {
+    source: SubtitleSource;
+    text: string;
+    isStreaming: boolean;
+}
+export declare function useSubtitle(): {
+    state: {
+        source: SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    };
+    reset: () => void;
+    startStream: (source: SubtitleSource) => void;
+    appendText: (text: string, isPlaying: boolean) => void;
+    setText: (text: string, source?: SubtitleSource) => void;
+    endStream: () => void;
+    transitionToLLM: (accumulatedText: string) => void;
+};

package/dist/playground/apps/web/src/composables/useVAD.d.ts

@@ -0,0 +1,49 @@
+export interface VADState {
+    isInitialized: boolean;
+    isActive: boolean;
+    isSpeaking: boolean;
+    volume: number;
+    isInitializing: boolean;
+    rmsDb?: number;
+    gateOpen?: boolean;
+    isPaused: boolean;
+}
+export interface UseVADOptions {
+    onSpeechReady?: (audio: Uint8Array, duration: number) => void;
+    onSpeechStart?: () => void;
+    onSpeechEnd?: () => void;
+    debug?: boolean;
+}
+export declare function useVAD(options?: UseVADOptions): {
+    state: {
+        isInitialized: boolean;
+        isActive: boolean;
+        isSpeaking: boolean;
+        volume: number;
+        isInitializing: boolean;
+        rmsDb?: number | undefined;
+        gateOpen?: boolean | undefined;
+        isPaused: boolean;
+    };
+    initialize: () => Promise<void>;
+    start: () => Promise<void>;
+    startWithVideo: () => Promise<MediaStream | null>;
+    stop: () => Promise<void>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    smartResume: () => Promise<void>;
+    dispose: () => void;
+    updateConfig: (config: {
+        speechThreshold?: number;
+        exitThreshold?: number;
+        minSilenceDurationMs?: number;
+    }) => void;
+    updateNoiseGateConfig: (config: {
+        openThresholdDb?: number;
+        closeThresholdDb?: number;
+        attackMs?: number;
+        releaseMs?: number;
+        holdMs?: number;
+        highPassHz?: number;
+    }) => void;
+};

package/dist/playground/apps/web/src/composables/useVideoCapture.d.ts

@@ -0,0 +1,57 @@
+export declare function useVideoCapture(): {
+    isCapturing: import('vue').Ref<boolean, boolean>;
+    videoStream: import('vue').Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: {
+            (event: Event): boolean;
+            (event: Event): boolean;
+        };
+    } | null, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: {
+            (event: Event): boolean;
+            (event: Event): boolean;
+        };
+    } | null>;
+    error: import('vue').Ref<string | null, string | null>;
+    startCapture: (silent?: boolean) => Promise<void>;
+    setVideoStream: (stream: MediaStream) => void;
+    stopCapture: () => void;
+    getMediaStream: () => MediaStream | null;
+};

package/dist/playground/apps/web/src/config/app-config.d.ts

@@ -0,0 +1,29 @@
+import { CameraConfig } from '../types/avatar';
+export declare const APP_CONFIG: {
+    rendering: {
+        backgroundColor: [number, number, number, number];
+        backgroundMode: "stretch" | "cover";
+    };
+    camera: CameraConfig;
+    animation: {
+        fps: number;
+    };
+    avatar: {
+        baseAssetsPath: string;
+        wasmPath: string;
+    };
+    flame: {
+        cdnBaseUrl: string;
+        resources: {
+            flameModel: string;
+            flameTemplate: string;
+            teethPb: string;
+            teethNpz: string;
+        };
+    };
+    wasm: {
+        logLevel: "basic" | "verbose";
+        enableValidation: boolean;
+        enablePerformanceMetrics: boolean;
+    };
+};

package/dist/playground/apps/web/src/config/realtime-config.d.ts

@@ -0,0 +1,47 @@
+export declare const REALTIME_CONFIG: {
+    readonly characterList: {
+        readonly pageSize: 20;
+    };
+    readonly audio: {
+        readonly recording: {
+            readonly sampleRate: 16000;
+            readonly channelCount: 1;
+            readonly echoCancellation: true;
+            readonly noiseSuppression: true;
+            readonly format: "pcm_s16le";
+        };
+        readonly playback: {
+            readonly sampleRate: 24000;
+            readonly channelCount: 1;
+            readonly bitsPerSample: 16;
+            readonly codec: "pcm_s16le";
+        };
+    };
+    readonly sync: {
+        readonly maxBufferTime: 5000;
+        readonly alignmentTolerance: 100;
+    };
+    readonly connection: {
+        readonly reconnectAttempts: 3;
+        readonly maxReconnectAttempts: 5;
+        readonly heartbeatInterval: 30000;
+    };
+    readonly vad: {
+        readonly sampleRate: 16000;
+        readonly speechThreshold: 0.3;
+        readonly exitThreshold: 0.1;
+        readonly minSilenceDurationMs: 400;
+        readonly modelBaseUrl: "https://cdn.spatialwalk.top/public";
+        readonly modelName: "onnx-community/silero-vad";
+        readonly permissionRequestTimeoutMs: 5000;
+        readonly noiseGate: {
+            readonly enabled: true;
+            readonly openThresholdDb: -50;
+            readonly closeThresholdDb: -55;
+            readonly attackMs: 5;
+            readonly releaseMs: 50;
+            readonly holdMs: 100;
+            readonly highPassHz: 100;
+        };
+    };
+};