@omote/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4173 @@
+import { InferenceSession, Tensor, Env } from 'onnxruntime-common';
+
+/**
+ * Type-safe event emitter for Omote core events
+ *
+ * @category Events
+ */
+type EventCallback<T = unknown> = (data: T) => void;
+declare class EventEmitter<TEvents extends {
+    [key: string]: unknown;
+}> {
+    private listeners;
+    on<K extends keyof TEvents>(event: K, callback: EventCallback<TEvents[K]>): () => void;
+    off<K extends keyof TEvents>(event: K, callback: EventCallback<TEvents[K]>): void;
+    emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
+    once<K extends keyof TEvents>(event: K, callback: EventCallback<TEvents[K]>): () => void;
+    removeAllListeners(event?: keyof TEvents): void;
+}
+
+/**
+ * Core Omote event types - the contract between core and renderers
+ *
+ * Renderers subscribe to these events and apply them to their specific
+ * rendering system (R3F, Three.js, Babylon, Unity, etc.)
+ */
+/** Animation frame with blendshape weights */
+interface AnimationEvent {
+    /** 52 ARKit blendshape weights (0-1 range) */
+    blendshapes: Float32Array;
+    /** Named blendshape access */
+    get(name: string): number;
+    /** Raw model output weights (for debugging) */
+    rawWeights?: Float32Array;
+    /** Timestamp in ms */
+    timestamp: number;
+    /** Inference latency in ms */
+    inferenceMs: number;
+    /** Frame index within the current batch (for LAM multi-frame output) */
+    frameIndex?: number;
+    /** Total frames in the current batch (for LAM multi-frame output) */
+    totalFrames?: number;
+}
+/** Viseme for lip sync */
+interface VisemeEvent {
+    /** Viseme ID or phoneme */
+    viseme: string;
+    /** Weight 0-1 */
+    weight: number;
+    /** Duration in ms */
+    duration: number;
+}
+/** Emotion state change */
+interface EmotionEvent {
+    /** Emotion weights by name */
+    values: Record<string, number>;
+    /** Transition duration in ms */
+    transitionMs: number;
+}
+/** Gaze target change */
+interface GazeEvent {
+    /** Target type */
+    target: 'camera' | 'wander' | 'position';
+    /** Position if target is 'position' */
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** Audio playback events */
+interface TTSStartEvent {
+    /** Audio duration in ms */
+    durationMs: number;
+    /** Text being spoken */
+    text: string;
+}
+interface TTSMarkEvent {
+    /** Mark name/type */
+    name: string;
+    /** Time offset in ms */
+    timeMs: number;
+}
+interface TTSEndEvent {
+    /** Whether playback completed normally */
+    completed: boolean;
+}
+/** STT transcription events */
+interface STTPartialEvent {
+    /** Partial transcription */
+    text: string;
+    /** Confidence 0-1 */
+    confidence: number;
+}
+interface STTFinalEvent {
+    /** Final transcription */
+    text: string;
+    /** Confidence 0-1 */
+    confidence: number;
+}
+/** Session state events */
+interface SessionStateEvent {
+    state: 'connecting' | 'connected' | 'ready' | 'streaming' | 'error' | 'disconnected';
+    error?: Error;
+}
+/** Backend info */
+interface BackendEvent {
+    type: 'webgpu' | 'wasm' | 'remote';
+    modelLoaded: boolean;
+    loadTimeMs?: number;
+}
+/** AI adapter state */
+type AISessionState$1 = 'idle' | 'listening' | 'thinking' | 'speaking' | 'interrupted' | 'error' | 'disconnected';
+/** AI state change event */
+interface AIStateChangeEvent {
+    state: AISessionState$1;
+    previousState: AISessionState$1;
+}
+/** User speech events */
+interface UserSpeechStartEvent {
+    timestamp: number;
+}
+interface UserSpeechEndEvent {
+    timestamp: number;
+    durationMs: number;
+}
+interface UserTranscriptEvent {
+    text: string;
+    confidence: number;
+}
+/** AI response events */
+interface AIThinkingStartEvent {
+    timestamp: number;
+}
+interface AIResponseStartEvent {
+    text?: string;
+    emotion?: string;
+}
+interface AIResponseChunkEvent {
+    text: string;
+    isLast: boolean;
+}
+interface AIResponseEndEvent {
+    fullText: string;
+    durationMs: number;
+}
+/** Audio output events (for lip sync processing) */
+interface AudioOutputChunkEvent {
+    audio: ArrayBuffer;
+    sampleRate: number;
+    timestamp: number;
+}
+interface AudioOutputEndEvent {
+    durationMs: number;
+}
+/** Adapter events */
+interface AdapterSwitchEvent {
+    from: string;
+    to: string;
+    reason: string;
+}
+interface AdapterFallbackEvent {
+    adapter: string;
+    reason: string;
+}
+interface InterruptionEvent {
+    timestamp: number;
+    action?: 'stop' | 'continue';
+}
+/**
+ * Complete event map for OmoteCore
+ */
+type OmoteEvents = {
+    'animation': AnimationEvent;
+    'animation.ready': {
+        backend: 'webgpu' | 'wasm';
+    };
+    'viseme': VisemeEvent;
+    'emotion': EmotionEvent;
+    'gaze': GazeEvent;
+    'tts.start': TTSStartEvent;
+    'tts.mark': TTSMarkEvent;
+    'tts.end': TTSEndEvent;
+    'stt.partial': STTPartialEvent;
+    'stt.final': STTFinalEvent;
+    'session.state': SessionStateEvent;
+    'backend': BackendEvent;
+    'audio.chunk': {
+        pcm: Int16Array;
+        timestamp: number;
+    };
+    'audio.level': {
+        rms: number;
+        peak: number;
+    };
+    'audio.output.chunk': AudioOutputChunkEvent;
+    'audio.output.end': AudioOutputEndEvent;
+    'ai.state.change': AIStateChangeEvent;
+    'ai.thinking.start': AIThinkingStartEvent;
+    'ai.response.start': AIResponseStartEvent;
+    'ai.response.chunk': AIResponseChunkEvent;
+    'ai.response.end': AIResponseEndEvent;
+    'user.speech.start': UserSpeechStartEvent;
+    'user.speech.end': UserSpeechEndEvent;
+    'user.transcript.partial': UserTranscriptEvent;
+    'user.transcript.final': UserTranscriptEvent;
+    'adapter.switch': AdapterSwitchEvent;
+    'adapter.fallback': AdapterFallbackEvent;
+    'adapter.recovered': {
+        adapter: string;
+    };
+    'interruption.detected': InterruptionEvent;
+    'interruption.handled': InterruptionEvent;
+    'memory.updated': {
+        messageCount: number;
+        tokenCount?: number;
+    };
+    'connection.opened': {
+        sessionId: string;
+        adapter?: string;
+    };
+    'connection.closed': {
+        reason: string;
+    };
+    'connection.error': {
+        error: Error;
+        recoverable: boolean;
+    };
+    'error': {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+};
+
+/**
+ * Microphone capture - renderer-agnostic audio input
+ *
+ * Captures audio from the microphone and emits PCM chunks.
+ * Works in any JavaScript environment with Web Audio API.
+ *
+ * @category Audio
+ */
+
+interface MicrophoneCaptureConfig {
+    /** Target sample rate (default: 16000 for speech processing) */
+    sampleRate?: number;
+    /** Chunk size in samples (default: 1600 = 100ms at 16kHz) */
+    chunkSize?: number;
+}
+declare class MicrophoneCapture {
+    private events;
+    private config;
+    private stream;
+    private context;
+    private processor;
+    private buffer;
+    private _isRecording;
+    private _loggedFirstChunk;
+    constructor(events: EventEmitter<OmoteEvents>, config?: MicrophoneCaptureConfig);
+    get isRecording(): boolean;
+    get isSupported(): boolean;
+    start(): Promise<void>;
+    stop(): void;
+    private floatToPCM16;
+}
+
+/**
+ * Ring buffer for audio sample accumulation
+ *
+ * Efficiently accumulates audio samples and provides
+ * contiguous buffers for inference without memory allocation churn.
+ *
+ * @category Audio
+ */
+declare class RingBuffer {
+    private readonly size;
+    private buffer;
+    private writeIndex;
+    private isFull;
+    constructor(size: number);
+    /**
+     * Write samples to the ring buffer
+     * Converts Int16Array PCM to Float32
+     */
+    write(pcm: Int16Array): void;
+    /**
+     * Write float samples directly
+     */
+    writeFloat(samples: Float32Array): void;
+    /**
+     * Get a contiguous copy of the buffer contents in chronological order
+     * Returns null if buffer isn't full yet
+     */
+    read(): Float32Array | null;
+    /**
+     * Check if buffer has enough samples
+     */
+    get hasData(): boolean;
+    /**
+     * Get current fill level (0-1)
+     */
+    get fillLevel(): number;
+    /**
+     * Reset the buffer
+     */
+    reset(): void;
+}
+
+/**
+ * AudioScheduler - Enterprise-grade Web Audio API scheduling
+ *
+ * Implements the lookahead scheduling pattern from Chris Wilson's
+ * "A Tale of Two Clocks" - the authoritative guide on Web Audio timing.
+ *
+ * Key Features:
+ * - Uses AudioContext.currentTime (hardware clock) for sample-accurate timing
+ * - Pre-schedules audio chunks for gapless playback
+ * - Tracks scheduled sources for cleanup
+ * - Provides playback state monitoring
+ *
+ * @see https://web.dev/articles/audio-scheduling
+ * @category Audio
+ */
+interface AudioSchedulerOptions {
+    /** Sample rate in Hz (default: 16000 for speech) */
+    sampleRate?: number;
+    /** Number of audio channels (default: 1 for mono) */
+    channels?: number;
+}
+declare class AudioScheduler {
+    private readonly options;
+    private context;
+    private nextPlayTime;
+    private scheduledSources;
+    private isPlaying;
+    constructor(options?: AudioSchedulerOptions);
+    /**
+     * Initialize AudioContext with specified sample rate
+     *
+     * Note: This is now a no-op. AudioContext is created lazily on first schedule()
+     * to avoid browser autoplay policy issues (requires user gesture).
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure AudioContext is created and ready
+     * Called lazily on first schedule() - requires user gesture
+     */
+    private ensureContext;
+    /**
+     * Schedule an audio chunk for playback
+     *
+     * Uses Web Audio's hardware-accurate clock for sample-perfect timing.
+     * Chunks are scheduled immediately, not when they should play - this
+     * ensures gapless playback even if main thread stalls.
+     *
+     * @param audioData - Float32Array of audio samples
+     * @returns Scheduled playback time in AudioContext seconds
+     */
+    schedule(audioData: Float32Array): Promise<number>;
+    /**
+     * Get current audio clock time
+     *
+     * This is the hardware-accurate time, NOT JavaScript time.
+     * Use this for synchronizing visual animations to audio.
+     *
+     * @returns Current time in AudioContext seconds
+     */
+    getCurrentTime(): number;
+    /**
+     * Get scheduled playback end time
+     */
+    getPlaybackEndTime(): number;
+    /**
+     * Check if all scheduled audio has finished playing
+     */
+    isComplete(): boolean;
+    /**
+     * Cancel all scheduled audio with smooth fade-out
+     *
+     * Applies a linear fade-out to all playing sources and stops them gracefully.
+     * Prevents audio clicks/pops by ramping gain to zero before stopping.
+     *
+     * @param fadeOutMs - Fade-out duration in milliseconds (default: 50ms)
+     * @returns Promise that resolves when fade-out completes
+     */
+    cancelAll(fadeOutMs?: number): Promise<void>;
+    /**
+     * Reset scheduler state for new playback session
+     */
+    reset(): void;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+
+/**
+ * AudioChunkCoalescer - Combine small network chunks into optimal buffers
+ *
+ * Network streaming often delivers audio in small chunks (e.g., 32ms from TTS APIs).
+ * Creating an AudioBufferSourceNode for each tiny chunk is inefficient and can cause
+ * overhead from object creation/GC.
+ *
+ * This class implements a double-buffering pattern: accumulate small chunks in a
+ * temporary buffer, then flush to playback queue when threshold is reached.
+ *
+ * Benefits:
+ * - Reduces AudioBufferSourceNode overhead (fewer nodes = less GC pressure)
+ * - Configurable buffer size for optimal playback chunk duration
+ * - Maintains sample-accurate timing despite buffering
+ *
+ * Based on patterns from HLS.js and production streaming implementations.
+ *
+ * @category Audio
+ */
+interface AudioChunkCoalescerOptions {
+    /**
+     * Target duration in milliseconds for combined chunks
+     * Default: 200ms (balances latency vs overhead)
+     *
+     * Smaller values = lower latency, more overhead
+     * Larger values = higher latency, less overhead
+     */
+    targetDurationMs?: number;
+    /**
+     * Sample rate in Hz
+     * Default: 16000 (speech quality)
+     */
+    sampleRate?: number;
+}
+declare class AudioChunkCoalescer {
+    private readonly options;
+    private tempBuffer;
+    private readonly targetBytes;
+    constructor(options?: AudioChunkCoalescerOptions);
+    /**
+     * Add a chunk to the temporary buffer
+     *
+     * @param chunk - Uint8Array containing Int16 PCM audio
+     * @returns Combined buffer if threshold reached, null otherwise
+     */
+    add(chunk: Uint8Array): ArrayBuffer | null;
+    /**
+     * Flush remaining buffered data
+     *
+     * Call this when the stream ends to ensure all audio is processed,
+     * even if it doesn't reach the target threshold.
+     *
+     * @returns Combined buffer, or null if buffer is empty
+     */
+    flush(): ArrayBuffer | null;
+    /**
+     * Get current buffer fill level (0-1)
+     */
+    get fillLevel(): number;
+    /**
+     * Get current buffered duration in milliseconds
+     */
+    getBufferedDurationMs(): number;
+    /**
+     * Get number of chunks currently buffered
+     */
+    get chunkCount(): number;
+    /**
+     * Reset the coalescer
+     */
+    reset(): void;
+}
+
+/**
+ * Runtime detection utilities for platform-specific inference configuration
+ *
+ * These utilities help determine the optimal backend (WebGPU vs WASM) based on
+ * the current platform's capabilities and known limitations.
+ *
+ * Key considerations:
+ * - iOS Safari: WebGPU crashes due to JSEP bugs (GitHub #22776, #26827)
+ * - Android Chrome: WebGPU works well (Chrome 121+)
+ * - Desktop: WebGPU preferred for performance
+ *
+ * @module utils/runtime
+ */
+/**
+ * Supported inference backends
+ */
+type RuntimeBackend = 'webgpu' | 'wasm';
+/**
+ * User-configurable backend preference
+ */
+type BackendPreference = 'auto' | 'webgpu' | 'wasm' | 'webgpu-only' | 'wasm-only';
+/**
+ * Detect iOS Safari browser
+ *
+ * iOS Safari has severe WebGPU issues:
+ * - JSEP compilation bugs cause OOM during session creation
+ * - Threading bugs require numThreads=1
+ * - Proxy mode triggers memory leaks
+ *
+ * @returns true if running in iOS Safari
+ */
+declare function isIOSSafari(): boolean;
+/**
+ * Detect any iOS device (regardless of browser)
+ *
+ * On iOS, all browsers use WebKit, so Chrome/Firefox on iOS
+ * have the same limitations as Safari.
+ *
+ * @returns true if running on any iOS device
+ */
+declare function isIOS(): boolean;
+/**
+ * Detect Android device
+ *
+ * Android Chrome 121+ has good WebGPU support with Qualcomm/ARM GPUs.
+ *
+ * @returns true if running on Android
+ */
+declare function isAndroid(): boolean;
+/**
+ * Detect any mobile device (iOS or Android)
+ *
+ * Mobile devices have different performance characteristics:
+ * - Lower memory limits
+ * - Thermal throttling
+ * - Different GPU architectures
+ *
+ * @returns true if running on mobile
+ */
+declare function isMobile(): boolean;
+/**
+ * Check if WebGPU API is available in the browser
+ *
+ * Note: This only checks if the API exists, not if it works reliably.
+ * iOS has navigator.gpu but ONNX Runtime's WebGPU backend crashes.
+ *
+ * @returns true if navigator.gpu exists
+ */
+declare function hasWebGPUApi(): boolean;
+/**
+ * Get the recommended backend for the current platform
+ *
+ * Decision tree:
+ * 1. iOS (any browser): Force WASM (WebGPU crashes)
+ * 2. Android: WebGPU preferred (works in Chrome 121+)
+ * 3. Desktop: WebGPU preferred (best performance)
+ *
+ * @returns 'wasm' for iOS, 'webgpu' for everything else
+ */
+declare function getRecommendedBackend(): RuntimeBackend;
+/**
+ * Resolve user preference to actual backend
+ *
+ * @param preference User's backend preference
+ * @param webgpuAvailable Whether WebGPU is available and working
+ * @returns The backend to use
+ */
+declare function resolveBackend(preference: BackendPreference, webgpuAvailable: boolean): RuntimeBackend;
+/**
+ * Get optimal WASM thread count for current platform
+ *
+ * @returns Recommended number of WASM threads
+ */
+declare function getOptimalWasmThreads(): number;
+/**
+ * Check if WASM proxy mode should be enabled
+ *
+ * Proxy mode offloads inference to a Web Worker, but has issues:
+ * - iOS: Triggers Safari 26 JSEP memory leak
+ * - Mobile: Generally unstable
+ *
+ * @returns true if proxy mode is safe to enable
+ */
+declare function shouldEnableWasmProxy(): boolean;
+/**
+ * Check if Web Speech API is available in the browser
+ *
+ * The Web Speech API provides native speech recognition in Safari and Chrome.
+ * On iOS Safari, this is significantly faster than Whisper WASM.
+ *
+ * @returns true if SpeechRecognition API is available
+ */
+declare function isSpeechRecognitionAvailable(): boolean;
+/**
+ * Recommend using native Safari Speech API over Whisper on iOS
+ *
+ * On iOS, Whisper ASR via WASM takes ~1.3s per inference (30% over target).
+ * Safari's native Web Speech API is:
+ * - Much faster (native implementation)
+ * - Battery-efficient (no WASM overhead)
+ * - No model download needed (saves 30-150MB)
+ *
+ * @returns true if on iOS with Speech API available
+ */
+declare function shouldUseNativeASR(): boolean;
+/**
+ * Recommend using server-side LAM over client-side on iOS
+ *
+ * On iOS, LAM lip sync via WASM takes ~332ms per second of audio (3.3x over target).
+ * Server-side inference with GPU can achieve ~50ms, providing:
+ * - Real-time lip sync (under 100ms target)
+ * - Reduced iOS device thermal/battery impact
+ * - Better user experience
+ *
+ * @returns true if on iOS (should use server-side lip sync)
+ */
+declare function shouldUseServerLipSync(): boolean;
+
+/**
+ * Lazy ONNX Runtime loader with conditional WebGPU/WASM bundle loading
+ *
+ * This module provides a way to dynamically load the appropriate ONNX Runtime bundle
+ * based on the platform's capabilities. This is critical for iOS support because:
+ *
+ * 1. iOS Safari has WebGPU API but ONNX Runtime's WebGPU backend crashes
+ * 2. Loading the WebGPU bundle wastes bandwidth and can cause issues
+ * 3. WASM-only bundle is smaller and more reliable on iOS
+ *
+ * Usage:
+ * ```typescript
+ * const ort = await getOnnxRuntime('wasm'); // Load WASM-only bundle
+ * const ort = await getOnnxRuntime('webgpu'); // Load WebGPU bundle (includes WASM)
+ * ```
+ *
+ * @module inference/onnxLoader
+ */
+
+type OrtModule = {
+    InferenceSession: typeof InferenceSession;
+    Tensor: typeof Tensor;
+    env: Env;
+};
+type SessionOptions = InferenceSession.SessionOptions;
+
+/**
+ * Check if WebGPU is available and likely to work
+ *
+ * This is more thorough than just checking navigator.gpu exists.
+ * It actually requests an adapter to verify the GPU is accessible.
+ *
+ * @returns true if WebGPU is available and working
+ */
+declare function isWebGPUAvailable(): Promise<boolean>;
+/**
+ * Load ONNX Runtime with the specified backend
+ *
+ * This lazily loads the appropriate bundle:
+ * - 'wasm': Loads onnxruntime-web (WASM-only, smaller)
+ * - 'webgpu': Loads onnxruntime-web/webgpu (includes WebGPU + WASM fallback)
+ *
+ * Once loaded, the same instance is reused for all subsequent calls.
+ * If you need to switch backends, you must reload the page.
+ *
+ * @param backend The backend to load ('webgpu' or 'wasm')
+ * @returns The ONNX Runtime module
+ */
+declare function getOnnxRuntime(backend: RuntimeBackend): Promise<OrtModule>;
+/**
+ * Get the appropriate ONNX Runtime based on user preference
+ *
+ * This resolves the user's preference against platform capabilities
+ * and loads the appropriate bundle.
+ *
+ * @param preference User's backend preference
+ * @returns The ONNX Runtime module and the resolved backend
+ */
+declare function getOnnxRuntimeForPreference(preference?: BackendPreference): Promise<{
+    ort: OrtModule;
+    backend: RuntimeBackend;
+}>;
+/**
+ * Get session options for creating an inference session
+ *
+ * This returns optimized session options based on the backend and platform.
+ *
+ * @param backend The backend being used
+ * @returns Session options for InferenceSession.create()
+ */
+declare function getSessionOptions(backend: RuntimeBackend): SessionOptions;
+/**
+ * Create an inference session with automatic fallback
+ *
+ * If WebGPU session creation fails, automatically falls back to WASM.
+ *
+ * @param modelBuffer The model data as ArrayBuffer
+ * @param preferredBackend The preferred backend
+ * @returns The created session and the backend used
+ */
+declare function createSessionWithFallback(modelBuffer: ArrayBuffer, preferredBackend: RuntimeBackend): Promise<{
+    session: InferenceSession;
+    backend: RuntimeBackend;
+}>;
+/**
+ * Get the currently loaded backend (if any)
+ */
+declare function getLoadedBackend(): RuntimeBackend | null;
+/**
+ * Check if ONNX Runtime has been loaded
+ */
+declare function isOnnxRuntimeLoaded(): boolean;
+
+/**
+ * Unified Wav2Vec2 inference engine for Audio-to-Expression + ASR
+ *
+ * Runs entirely in the browser using WebGPU or WASM.
+ * Takes raw 16kHz audio and outputs:
+ * - 52 ARKit blendshapes (lip sync)
+ * - 32-token CTC logits (speech recognition)
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { Wav2Vec2Inference } from '@omote/core';
+ *
+ * const wav2vec = new Wav2Vec2Inference({ modelUrl: '/models/unified_wav2vec2_asr_a2e.onnx' });
+ * await wav2vec.load();
+ *
+ * // Process 1 second of audio (16kHz = 16000 samples)
+ * const result = await wav2vec.infer(audioSamples);
+ *
+ * console.log('Blendshapes:', result.blendshapes); // [30, 52] for 30fps
+ * console.log('ASR text:', result.text); // Decoded transcription
+ * ```
+ */
+
+type InferenceBackend = BackendPreference;
+interface Wav2Vec2InferenceConfig {
+    /** Path or URL to the ONNX model */
+    modelUrl: string;
+    /** Preferred backend (auto will try WebGPU first, fallback to WASM) */
+    backend?: InferenceBackend;
+    /** Number of identity classes (default: 12 for streaming model) */
+    numIdentityClasses?: number;
+}
+interface ModelInfo {
+    backend: 'webgpu' | 'wasm';
+    loadTimeMs: number;
+    inputNames: string[];
+    outputNames: string[];
+}
+/**
+ * LAM model blendshape names in order (52 total)
+ * NOTE: This is alphabetical ordering used by LAM, different from standard ARKit order
+ */
+declare const LAM_BLENDSHAPES: readonly ["browDownLeft", "browDownRight", "browInnerUp", "browOuterUpLeft", "browOuterUpRight", "cheekPuff", "cheekSquintLeft", "cheekSquintRight", "eyeBlinkLeft", "eyeBlinkRight", "eyeLookDownLeft", "eyeLookDownRight", "eyeLookInLeft", "eyeLookInRight", "eyeLookOutLeft", "eyeLookOutRight", "eyeLookUpLeft", "eyeLookUpRight", "eyeSquintLeft", "eyeSquintRight", "eyeWideLeft", "eyeWideRight", "jawForward", "jawLeft", "jawOpen", "jawRight", "mouthClose", "mouthDimpleLeft", "mouthDimpleRight", "mouthFrownLeft", "mouthFrownRight", "mouthFunnel", "mouthLeft", "mouthLowerDownLeft", "mouthLowerDownRight", "mouthPressLeft", "mouthPressRight", "mouthPucker", "mouthRight", "mouthRollLower", "mouthRollUpper", "mouthShrugLower", "mouthShrugUpper", "mouthSmileLeft", "mouthSmileRight", "mouthStretchLeft", "mouthStretchRight", "mouthUpperUpLeft", "mouthUpperUpRight", "noseSneerLeft", "noseSneerRight", "tongueOut"];
+/** CTC vocabulary (32 tokens from wav2vec2-base-960h) */
+declare const CTC_VOCAB: string[];
+interface Wav2Vec2Result {
+    /** Blendshape weights [frames, 52] - 30fps */
+    blendshapes: Float32Array[];
+    /** Raw CTC logits [frames, 32] - 50fps */
+    asrLogits: Float32Array[];
+    /** Decoded text from CTC */
+    text: string;
+    /** Number of A2E frames (30fps) */
+    numA2EFrames: number;
+    /** Number of ASR frames (50fps) */
+    numASRFrames: number;
+    /** Inference time in ms */
+    inferenceTimeMs: number;
+}
+declare class Wav2Vec2Inference {
+    private session;
+    private ort;
+    private config;
+    private _backend;
+    private isLoading;
+    private numIdentityClasses;
+    private inferenceQueue;
+    constructor(config: Wav2Vec2InferenceConfig);
+    /**
+     * Check if WebGPU is available and working
+     * (iOS returns false even if navigator.gpu exists due to ONNX Runtime bugs)
+     */
+    static isWebGPUAvailable: typeof isWebGPUAvailable;
+    get backend(): 'webgpu' | 'wasm' | null;
+    get isLoaded(): boolean;
+    /**
+     * Load the ONNX model
+     */
+    load(): Promise<ModelInfo>;
+    /**
+     * Run inference on raw audio
+     * @param audioSamples - Float32Array of raw audio at 16kHz (16000 samples = 1 second)
+     * @param identityIndex - Optional identity index (0-11, default 0 = neutral)
+     *
+     * Note: Model expects 1-second chunks (16000 samples) for optimal performance.
+     * Audio will be zero-padded or truncated to 16000 samples.
+     */
+    infer(audioSamples: Float32Array, identityIndex?: number): Promise<Wav2Vec2Result>;
+    /**
+     * Decode CTC logits to text using greedy decoding
+     */
+    private decodeCTC;
+    /**
+     * Queue inference to serialize ONNX session calls
+     */
+    private queueInference;
+    /**
+     * Get blendshape value by name for a specific frame
+     */
+    getBlendshape(blendshapes: Float32Array, name: typeof LAM_BLENDSHAPES[number]): number;
+    /**
+     * Dispose of the model and free resources
+     */
+    dispose(): Promise<void>;
+}
+
+/**
+ * LAMPipeline - Coordinate LAM (Wav2Vec2) inference with frame synchronization
+ *
+ * Manages the buffering and processing pipeline for LAM lip sync:
+ * 1. Accumulates audio samples in a ring buffer
+ * 2. Triggers LAM inference when buffer reaches required size (16000 samples @ 16kHz = 1.0s)
+ * 3. Queues resulting blendshape frames with precise timestamps
+ * 4. Provides frames synchronized to AudioContext clock
+ *
+ * Key Design Decisions:
+ * - Ring buffer pattern for efficient sample accumulation (no allocation churn)
+ * - Frame queue with timestamps for deterministic playback
+ * - Timestamp-based frame retrieval (not callback) for renderer flexibility
+ *
+ * Based on patterns from Chrome Audio Worklet design and Web Audio clock management.
+ *
+ * @see https://developer.chrome.com/blog/audio-worklet-design-pattern
+ * @category Audio
+ */
+
+interface LAMFrame {
+    /** 52 ARKit blendshape weights */
+    frame: Float32Array;
+    /** AudioContext time when this frame should be displayed */
+    timestamp: number;
+}
+interface LAMPipelineOptions {
+    /**
+     * Sample rate in Hz (must match audio playback)
+     * Default: 16000
+     */
+    sampleRate?: number;
+    /**
+     * LAM inference callback
+     * Called each time LAM processes a buffer
+     */
+    onInference?: (frameCount: number) => void;
+    /**
+     * Error callback for inference failures
+     */
+    onError?: (error: Error) => void;
+}
+declare class LAMPipeline {
+    private readonly options;
+    private readonly REQUIRED_SAMPLES;
+    private readonly FRAME_RATE;
+    private buffer;
+    private bufferStartTime;
+    private frameQueue;
+    /**
+     * Last successfully retrieved frame
+     * Used as fallback when no new frame is available to prevent avatar freezing
+     */
+    private lastFrame;
+    constructor(options?: LAMPipelineOptions);
+    /**
+     * Push audio samples into the pipeline
+     *
+     * Accumulates samples and triggers LAM inference when buffer is full.
+     * Multiple calls may be needed to accumulate enough samples.
+     *
+     * @param samples - Float32Array of audio samples
+     * @param timestamp - AudioContext time when these samples start playing
+     * @param lam - LAM inference engine
+     */
+    push(samples: Float32Array, timestamp: number, lam: Wav2Vec2Inference): Promise<void>;
+    /**
+     * Process accumulated buffer through LAM inference
+     */
+    private processBuffer;
+    /**
+     * Get the frame that should be displayed at the current time
+     *
+     * Automatically removes frames that have already been displayed.
+     * This prevents memory leaks from accumulating old frames.
+     *
+     * Discard Window (prevents premature frame discarding):
+     * - WebGPU: 0.5s (LAM inference 20-100ms + RAF jitter + React stalls)
+     * - WASM: 1.0s (LAM inference 50-500ms + higher variability)
+     *
+     * Last-Frame-Hold: Returns last valid frame instead of null to prevent
+     * avatar freezing when between frames (RAF at 60fps vs LAM at 30fps).
+     *
+     * @param currentTime - Current AudioContext time
+     * @param lam - LAM inference engine (optional, for backend detection)
+     * @returns Current frame, or last frame as fallback, or null if no frames yet
+     */
+    getFrameForTime(currentTime: number, lam?: {
+        backend: 'webgpu' | 'wasm' | null;
+    }): Float32Array | null;
+    /**
+     * Get all frames in the queue (for debugging/monitoring)
+     */
+    getQueuedFrames(): LAMFrame[];
+    /**
+     * Get current buffer fill level (0-1)
+     */
+    get fillLevel(): number;
+    /**
+     * Get number of frames queued
+     */
+    get queuedFrameCount(): number;
+    /**
+     * Get buffered audio duration in seconds
+     */
+    get bufferedDuration(): number;
+    /**
+     * Flush remaining buffered audio
+     *
+     * Processes any remaining audio in the buffer, even if less than REQUIRED_SAMPLES.
+     * This ensures the final audio chunk generates blendshape frames.
+     *
+     * Should be called when audio stream ends to prevent losing the last 0-1 seconds.
+     *
+     * @param lam - LAM inference engine
+     */
+    flush(lam: Wav2Vec2Inference): Promise<void>;
+    /**
+     * Adjust all queued frame timestamps by an offset
+     *
+     * Used for synchronization when audio scheduling time differs from
+     * the estimated time used during LAM processing.
+     *
+     * @param offset - Time offset in seconds to add to all timestamps
+     */
+    adjustTimestamps(offset: number): void;
+    /**
+     * Reset the pipeline
+     */
+    reset(): void;
+}
+
+/**
+ * SyncedAudioPipeline - Enterprise-grade audio + LAM synchronization coordinator
+ *
+ * Orchestrates the complete pipeline for synchronized audio playback and lip sync:
+ * 1. Network chunks → Coalescer → Optimized buffers
+ * 2. Audio buffers → Scheduler → Gapless playback
+ * 3. Audio buffers → LAM Pipeline → Blendshape frames
+ * 4. Frames synchronized to AudioContext clock → Renderer
+ *
+ * Key Architecture Pattern: Wait-for-First-LAM
+ * - Buffers incoming audio chunks without scheduling playback
+ * - Waits for first LAM inference to complete (ensures LAM frames are ready)
+ * - Then schedules all buffered audio + LAM frames together
+ * - Result: Perfect synchronization from frame 1, no lag compensation needed
+ *
+ * This is a deterministic, enterprise-grade solution suitable for production use.
+ * No hacks, no lag detection, no frame skipping - just guaranteed synchronization.
+ *
+ * @see https://web.dev/articles/audio-scheduling (Web Audio clock patterns)
+ * @see https://developer.chrome.com/blog/audio-worklet-design-pattern (Ring buffer patterns)
+ * @category Audio
+ */
+
+interface SyncedAudioPipelineOptions {
+    /** Sample rate in Hz (default: 16000) */
+    sampleRate?: number;
+    /** Target chunk duration in ms for coalescing (default: 200) */
+    chunkTargetMs?: number;
+    /** LAM inference engine */
+    lam: Wav2Vec2Inference;
+}
+interface SyncedAudioPipelineEvents {
+    /** New frame ready for display */
+    frame_ready: Float32Array;
+    /** Playback has completed */
+    playback_complete: void;
+    /** First LAM inference completed, playback starting */
+    playback_start: number;
+    /** Error occurred */
+    error: Error;
+    /** Index signature for EventEmitter compatibility */
+    [key: string]: unknown;
+}
+declare class SyncedAudioPipeline extends EventEmitter<SyncedAudioPipelineEvents> {
+    private readonly options;
+    private scheduler;
+    private coalescer;
+    private lamPipeline;
+    private waitingForFirstLAM;
+    private bufferedChunks;
+    private monitorInterval;
+    private frameAnimationId;
+    constructor(options: SyncedAudioPipelineOptions);
+    /**
+     * Initialize the pipeline
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start a new playback session
+     *
+     * Resets all state and prepares for incoming audio chunks.
+     * Enables wait-for-first-LAM synchronization.
+     */
+    start(): void;
+    /**
+     * Receive audio chunk from network
+     *
+     * Implements wait-for-first-LAM pattern:
+     * - Chunks are coalesced into optimal buffers
+     * - Buffers are sent to LAM for processing
+     * - Audio scheduling waits until first LAM completes
+     * - Then all buffered audio is scheduled together with LAM frames
+     *
+     * @param chunk - Uint8Array containing Int16 PCM audio
+     */
+    onAudioChunk(chunk: Uint8Array): Promise<void>;
+    /**
+     * Handle first LAM inference completion
+     *
+     * This is the critical synchronization point:
+     * - LAM frames are now ready in the queue
+     * - Schedule all buffered audio chunks
+     * - Adjust LAM frame timestamps to match actual schedule time
+     * - Audio and LAM start playing together, perfectly synchronized
+     */
+    private onFirstLAMComplete;
+    /**
+     * End of audio stream
+     *
+     * Flushes any remaining buffered data.
+     */
+    end(): Promise<void>;
+    /**
+     * Stop playback immediately with smooth fade-out
+     *
+     * Gracefully cancels all audio playback and LAM processing:
+     * - Fades out audio over specified duration (default: 50ms)
+     * - Cancels pending LAM inferences
+     * - Clears all buffers and queues
+     * - Emits 'playback_complete' event
+     *
+     * Use this for interruptions (e.g., user barge-in during AI speech).
+     *
+     * @param fadeOutMs - Fade-out duration in milliseconds (default: 50ms)
+     * @returns Promise that resolves when fade-out completes
+     */
+    stop(fadeOutMs?: number): Promise<void>;
+    /**
+     * Start frame animation loop
+     *
+     * Uses requestAnimationFrame to check for new LAM frames.
+     * Synchronized to AudioContext clock (not visual refresh rate).
+     *
+     * Frame Emission Strategy:
+     * - LAMPipeline uses last-frame-hold to prevent null returns
+     * - Always emit frames (even repeated frames) to maintain smooth animation
+     * - Renderer is responsible for detecting duplicate frames if needed
+     */
+    private startFrameLoop;
+    /**
+     * Start monitoring for playback completion
+     */
+    private startMonitoring;
+    /**
+     * Stop monitoring
+     */
+    private stopMonitoring;
+    /**
+     * Get current pipeline state (for debugging/monitoring)
+     */
+    getState(): {
+        waitingForFirstLAM: boolean;
+        bufferedChunks: number;
+        coalescerFill: number;
+        lamFill: number;
+        queuedFrames: number;
+        currentTime: number;
+        playbackEndTime: number;
+    };
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+
+/**
+ * Whisper Automatic Speech Recognition using transformers.js
+ * Uses Xenova's proven pipeline API for reliable transcription
+ */
+type WhisperModel = 'tiny' | 'base' | 'small' | 'medium';
+type WhisperDtype = 'fp32' | 'fp16' | 'q8' | 'int8' | 'uint8' | 'q4' | 'q4f16' | 'bnb4';
+interface WhisperConfig {
+    /** Model size: tiny (~75MB), base (~150MB), small (~500MB), medium (~1.5GB) */
+    model?: WhisperModel;
+    /** Use multilingual model (default: false, uses .en models) */
+    multilingual?: boolean;
+    /** Language code (e.g., 'en', 'es', 'fr') - for multilingual models */
+    language?: string;
+    /** Task: transcribe or translate (default: transcribe) */
+    task?: 'transcribe' | 'translate';
+    /** Model quantization format (default: 'q8' for balance of speed/quality) */
+    dtype?: WhisperDtype;
+    /** Use WebGPU acceleration if available (default: auto-detect) */
+    device?: 'auto' | 'webgpu' | 'wasm';
+    /** Local model path (e.g., '/models/whisper-tiny.en') - overrides HuggingFace CDN */
+    localModelPath?: string;
+    /** HuggingFace API token to bypass rate limits (get from https://huggingface.co/settings/tokens) */
+    token?: string;
+    /** Suppress non-speech tokens like [LAUGHTER], [CLICKING], etc. (default: true) */
+    suppressNonSpeech?: boolean;
+}
+interface TranscriptionResult {
+    /** Transcribed text */
+    text: string;
+    /** Detected/used language */
+    language: string;
+    /** Inference time in ms */
+    inferenceTimeMs: number;
+    /** Full chunks with timestamps (if requested) */
+    chunks?: Array<{
+        text: string;
+        timestamp: [number, number | null];
+    }>;
+}
+/**
+ * Whisper ASR inference using transformers.js pipeline API
+ *
+ * Features:
+ * - Automatic WebGPU/WASM backend selection
+ * - Streaming support with chunk callbacks
+ * - Proven implementation from Xenova's demo
+ * - Handles all audio preprocessing automatically
+ */
+declare class WhisperInference {
+    private config;
+    private pipeline;
+    private currentModel;
+    private isLoading;
+    private actualBackend;
+    constructor(config?: WhisperConfig);
+    /**
+     * Check if WebGPU is available in this browser
+     */
+    static isWebGPUAvailable(): Promise<boolean>;
+    /**
+     * Load the Whisper model pipeline
+     */
+    load(onProgress?: (progress: {
+        status: string;
+        progress?: number;
+        file?: string;
+    }) => void): Promise<void>;
+    /**
+     * Transcribe audio to text
+     *
+     * @param audio Audio samples (Float32Array, 16kHz mono)
+     * @param options Transcription options
+     */
+    transcribe(audio: Float32Array, options?: {
+        /** Return timestamps for each chunk */
+        returnTimestamps?: boolean;
+        /** Chunk length in seconds (default: 30) */
+        chunkLengthS?: number;
+        /** Stride length in seconds for overlapping chunks (default: 5) */
+        strideLengthS?: number;
+        /** Language override */
+        language?: string;
+        /** Task override */
+        task?: 'transcribe' | 'translate';
+    }): Promise<TranscriptionResult>;
+    /**
+     * Transcribe with streaming chunks (progressive results)
+     *
+     * @param audio Audio samples
+     * @param onChunk Called when each chunk is finalized
+     * @param onUpdate Called after each generation step (optional)
+     */
+    transcribeStreaming(audio: Float32Array, onChunk: (chunk: {
+        text: string;
+        timestamp: [number, number | null];
+    }) => void, onUpdate?: (text: string) => void, options?: {
+        chunkLengthS?: number;
+        strideLengthS?: number;
+        language?: string;
+        task?: 'transcribe' | 'translate';
+    }): Promise<TranscriptionResult>;
+    /**
+     * Dispose of the model and free resources
+     */
+    dispose(): Promise<void>;
+    /**
+     * Check if model is loaded
+     */
+    get isLoaded(): boolean;
+    /**
+     * Get the backend being used (webgpu or wasm)
+     */
+    get backend(): string;
+    /**
+     * Get the full model name used by transformers.js
+     */
+    private getModelName;
+    /**
+     * Remove non-speech event tokens from transcription
+     *
+     * Whisper outputs special tokens for non-speech events like:
+     * [LAUGHTER], [APPLAUSE], [MUSIC], [BLANK_AUDIO], [CLICKING], etc.
+     *
+     * This method strips these tokens and cleans up extra whitespace.
+     */
+    private removeNonSpeechTokens;
+}
+
+/**
+ * Silero VAD (Voice Activity Detection) inference
+ *
+ * Neural network-based VAD running in browser via ONNX Runtime Web.
+ * Much more accurate than RMS-based energy detection.
+ *
+ * Uses lazy loading to conditionally load WebGPU or WASM-only bundle:
+ * - iOS: Loads WASM-only bundle (WebGPU crashes due to Safari bugs)
+ * - Android/Desktop: Loads WebGPU bundle (with WASM fallback)
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { SileroVADInference } from '@omote/core';
+ *
+ * const vad = new SileroVADInference({
+ *   modelUrl: '/models/silero-vad.onnx'
+ * });
+ * await vad.load();
+ *
+ * // Process 32ms chunks (512 samples at 16kHz)
+ * const probability = await vad.process(audioChunk);
+ * if (probability > 0.5) {
+ *   console.log('Speech detected!');
+ * }
+ * ```
+ *
+ * @example Streaming with state management
+ * ```typescript
+ * // State is automatically maintained between process() calls
+ * // Call reset() when starting a new audio stream
+ * vad.reset();
+ *
+ * for (const chunk of audioChunks) {
+ *   const prob = await vad.process(chunk);
+ *   // prob is speech probability [0, 1]
+ * }
+ * ```
+ */
+
+type VADBackend = BackendPreference;
+/**
+ * Configuration for Silero VAD
+ */
+interface SileroVADConfig {
+    /** Path or URL to the ONNX model */
+    modelUrl: string;
+    /** Preferred backend (auto will try WebGPU first, fallback to WASM) */
+    backend?: VADBackend;
+    /** Sample rate (8000 or 16000, default: 16000) */
+    sampleRate?: 8000 | 16000;
+    /** Speech probability threshold (default: 0.5) */
+    threshold?: number;
+    /**
+     * Number of audio chunks to keep in pre-speech buffer.
+     * When VAD triggers, these chunks are prepended to the speech buffer
+     * to capture the beginning of speech that occurred before detection.
+     *
+     * At 512 samples/chunk and 16kHz:
+     * - 10 chunks = 320ms of pre-speech audio
+     * - 15 chunks = 480ms of pre-speech audio
+     *
+     * Default: 10 chunks (320ms)
+     */
+    preSpeechBufferChunks?: number;
+}
+/**
+ * VAD model loading information
+ */
+interface VADModelInfo {
+    backend: 'webgpu' | 'wasm';
+    loadTimeMs: number;
+    inputNames: string[];
+    outputNames: string[];
+    sampleRate: number;
+    chunkSize: number;
+}
+/**
+ * Result from a single VAD inference
+ */
+interface VADResult$1 {
+    /** Speech probability (0-1) */
+    probability: number;
+    /** Whether speech is detected (probability > threshold) */
+    isSpeech: boolean;
+    /** Inference time in milliseconds */
+    inferenceTimeMs: number;
+    /**
+     * Pre-speech audio chunks (only present on first speech detection).
+     * These are the N chunks immediately before VAD triggered, useful for
+     * capturing the beginning of speech that occurred before detection.
+     *
+     * Only populated when transitioning from silence to speech.
+     */
+    preSpeechChunks?: Float32Array[];
+}
+/**
+ * Speech segment detected by VAD
+ */
+interface SpeechSegment {
+    /** Start time in seconds */
+    start: number;
+    /** End time in seconds */
+    end: number;
+    /** Average probability during segment */
+    avgProbability: number;
+}
+/**
+ * Silero VAD - Neural network voice activity detection
+ *
+ * Based on snakers4/silero-vad ONNX model.
+ * Processes 32ms chunks (512 samples at 16kHz) with LSTM state.
+ *
+ * @see https://github.com/snakers4/silero-vad
+ */
+declare class SileroVADInference {
+    private session;
+    private ort;
+    private config;
+    private _backend;
+    private isLoading;
+    private state;
+    private context;
+    private readonly chunkSize;
+    private readonly contextSize;
+    private inferenceQueue;
+    private preSpeechBuffer;
+    private wasSpeaking;
+    constructor(config: SileroVADConfig);
+    get backend(): RuntimeBackend | null;
+    get isLoaded(): boolean;
+    get sampleRate(): number;
+    get threshold(): number;
+    /**
+     * Get required chunk size in samples
+     */
+    getChunkSize(): number;
+    /**
+     * Get chunk duration in milliseconds
+     */
+    getChunkDurationMs(): number;
+    /**
+     * Check if WebGPU is available and working
+     * (iOS returns false even if navigator.gpu exists due to ONNX Runtime bugs)
+     */
+    static isWebGPUAvailable: typeof isWebGPUAvailable;
+    /**
+     * Load the ONNX model
+     */
+    load(): Promise<VADModelInfo>;
+    /**
+     * Reset state for new audio stream
+     */
+    reset(): void;
+    /**
+     * Process a single audio chunk
+     *
+     * @param audioChunk - Float32Array of exactly chunkSize samples (512 for 16kHz, 256 for 8kHz)
+     * @returns VAD result with speech probability
+     */
+    process(audioChunk: Float32Array): Promise<VADResult$1>;
+    /**
+     * Process audio and detect speech segments
+     *
+     * @param audio - Complete audio buffer
+     * @param options - Detection options
+     * @returns Array of speech segments
+     */
+    detectSpeech(audio: Float32Array, options?: {
+        /** Minimum speech duration in ms (default: 250) */
+        minSpeechDurationMs?: number;
+        /** Minimum silence duration to end segment in ms (default: 300) */
+        minSilenceDurationMs?: number;
+        /** Padding to add before/after speech in ms (default: 30) */
+        speechPadMs?: number;
+    }): Promise<SpeechSegment[]>;
+    /**
+     * Calculate RMS energy of audio chunk
+     */
+    private calculateRMS;
+    /**
+     * Queue inference to serialize ONNX session calls
+     */
+    private queueInference;
+    /**
+     * Dispose of the model and free resources
+     */
+    dispose(): Promise<void>;
+}
+
+/**
+ * Configuration for Silero VAD Worker
+ */
+interface VADWorkerConfig {
+    /** Path or URL to the ONNX model */
+    modelUrl: string;
+    /** Sample rate (8000 or 16000, default: 16000) */
+    sampleRate?: 8000 | 16000;
+    /** Speech probability threshold (default: 0.5) */
+    threshold?: number;
+    /**
+     * Number of audio chunks to keep in pre-speech buffer.
+     * When VAD triggers, these chunks are prepended to the speech buffer
+     * to capture the beginning of speech that occurred before detection.
+     *
+     * At 512 samples/chunk and 16kHz:
+     * - 10 chunks = 320ms of pre-speech audio
+     * - 15 chunks = 480ms of pre-speech audio
+     *
+     * Default: 10 chunks (320ms)
+     */
+    preSpeechBufferChunks?: number;
+}
+/**
+ * VAD model loading information from worker
+ */
+interface VADWorkerModelInfo {
+    backend: 'wasm';
+    loadTimeMs: number;
+    inputNames: string[];
+    outputNames: string[];
+    sampleRate: number;
+    chunkSize: number;
+}
+/**
+ * Result from a single VAD inference
+ */
+interface VADResult {
+    /** Speech probability (0-1) */
+    probability: number;
+    /** Whether speech is detected (probability > threshold) */
+    isSpeech: boolean;
+    /** Inference time in milliseconds */
+    inferenceTimeMs: number;
+    /**
+     * Pre-speech audio chunks (only present on first speech detection).
+     * These are the N chunks immediately before VAD triggered, useful for
+     * capturing the beginning of speech that occurred before detection.
+     *
+     * Only populated when transitioning from silence to speech.
+     */
+    preSpeechChunks?: Float32Array[];
+}
+/**
+ * Silero VAD Worker - Voice Activity Detection in a Web Worker
+ *
+ * Runs Silero VAD inference off the main thread to prevent UI blocking.
+ * Feature parity with SileroVADInference but runs in dedicated worker.
+ *
+ * @see SileroVADInference for main-thread version
+ */
+declare class SileroVADWorker {
+    private worker;
+    private config;
+    private isLoading;
+    private _isLoaded;
+    private state;
+    private context;
+    private readonly chunkSize;
+    private readonly contextSize;
+    private inferenceQueue;
+    private preSpeechBuffer;
+    private wasSpeaking;
+    private pendingResolvers;
+    private messageId;
+    constructor(config: VADWorkerConfig);
+    get isLoaded(): boolean;
+    /**
+     * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
+     */
+    get backend(): 'wasm' | null;
+    get sampleRate(): number;
+    get threshold(): number;
+    /**
+     * Get required chunk size in samples
+     */
+    getChunkSize(): number;
+    /**
+     * Get chunk duration in milliseconds
+     */
+    getChunkDurationMs(): number;
+    /**
+     * Create the worker from inline script
+     */
+    private createWorker;
+    /**
+     * Handle messages from worker
+     */
+    private handleWorkerMessage;
+    /**
+     * Send message to worker and wait for response
+     */
+    private sendMessage;
+    /**
+     * Load the ONNX model in the worker
+     */
+    load(): Promise<VADWorkerModelInfo>;
+    /**
+     * Reset state for new audio stream
+     */
+    reset(): Promise<void>;
+    /**
+     * Process a single audio chunk
+     *
+     * @param audioChunk - Float32Array of exactly chunkSize samples (512 for 16kHz, 256 for 8kHz)
+     * @returns VAD result with speech probability
+     */
+    process(audioChunk: Float32Array): Promise<VADResult>;
+    /**
+     * Queue inference to serialize worker calls
+     */
+    private queueInference;
+    /**
+     * Dispose of the worker and free resources
+     */
+    dispose(): Promise<void>;
+    /**
+     * Check if Web Workers are supported
+     */
+    static isSupported(): boolean;
+}
+
+/**
+ * Factory function for Silero VAD with automatic Worker vs main thread selection
+ *
+ * Provides a unified API that automatically selects the optimal implementation:
+ * - Desktop browsers: Uses SileroVADWorker (off-main-thread inference)
+ * - Mobile devices: Uses SileroVADInference (main thread, avoids memory overhead)
+ * - Fallback: Gracefully falls back to main thread if Worker fails
+ *
+ * @category Inference
+ *
+ * @example Basic usage (auto-detect)
+ * ```typescript
+ * import { createSileroVAD } from '@omote/core';
+ *
+ * const vad = createSileroVAD({
+ *   modelUrl: '/models/silero-vad.onnx',
+ *   threshold: 0.5,
+ * });
+ *
+ * await vad.load();
+ * const result = await vad.process(audioChunk);
+ * if (result.isSpeech) {
+ *   console.log('Speech detected!', result.probability);
+ * }
+ * ```
+ *
+ * @example Force worker usage
+ * ```typescript
+ * const vad = createSileroVAD({
+ *   modelUrl: '/models/silero-vad.onnx',
+ *   useWorker: true, // Force Worker even on mobile
+ * });
+ * ```
+ *
+ * @example Force main thread
+ * ```typescript
+ * const vad = createSileroVAD({
+ *   modelUrl: '/models/silero-vad.onnx',
+ *   useWorker: false, // Force main thread
+ * });
+ * ```
+ */
+
+/**
+ * Common interface for both SileroVADInference and SileroVADWorker
+ *
+ * This interface defines the shared API that both implementations provide,
+ * allowing consumers to use either interchangeably.
+ */
+interface SileroVADBackend {
+    /** Current backend type (webgpu, wasm, or null if not loaded) */
+    readonly backend: RuntimeBackend | null;
+    /** Whether the model is loaded and ready for inference */
+    readonly isLoaded: boolean;
+    /** Audio sample rate (8000 or 16000 Hz) */
+    readonly sampleRate: number;
+    /** Speech detection threshold (0-1) */
+    readonly threshold: number;
+    /**
+     * Load the ONNX model
+     * @returns Model loading information
+     */
+    load(): Promise<VADModelInfo | VADWorkerModelInfo>;
+    /**
+     * Process a single audio chunk
+     * @param audioChunk - Float32Array of exactly chunkSize samples
+     * @returns VAD result with speech probability
+     */
+    process(audioChunk: Float32Array): Promise<VADResult$1>;
+    /**
+     * Reset state for new audio stream
+     */
+    reset(): void | Promise<void>;
+    /**
+     * Dispose of the model and free resources
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get required chunk size in samples
+     */
+    getChunkSize(): number;
+    /**
+     * Get chunk duration in milliseconds
+     */
+    getChunkDurationMs(): number;
+}
+/**
+ * Configuration for the Silero VAD factory
+ *
+ * Extends SileroVADConfig with worker-specific options.
+ */
+interface SileroVADFactoryConfig extends SileroVADConfig {
+    /**
+     * Force worker usage (true), main thread (false), or auto-detect (undefined).
+     *
+     * Auto-detection behavior:
+     * - Desktop: Uses Worker (better responsiveness, off-main-thread)
+     * - Mobile: Uses main thread (avoids 5MB memory overhead)
+     *
+     * You can override this to:
+     * - `true`: Force Worker even on mobile (if you have memory headroom)
+     * - `false`: Force main thread even on desktop (for debugging)
+     *
+     * Default: undefined (auto-detect)
+     */
+    useWorker?: boolean;
+    /**
+     * Fallback to main thread on worker errors.
+     *
+     * When true (default), if the Worker fails to load or encounters an error,
+     * the factory will automatically create a main thread instance instead.
+     *
+     * When false, worker errors will propagate as exceptions.
+     *
+     * Default: true
+     */
+    fallbackOnError?: boolean;
+}
+/**
+ * Check if the current environment supports VAD Web Workers
+ *
+ * Requirements:
+ * - Worker constructor must exist
+ * - Blob URL support (for inline worker script)
+ *
+ * @returns true if VAD Worker is supported
+ */
+declare function supportsVADWorker(): boolean;
+/**
+ * Create a Silero VAD instance with automatic implementation selection
+ *
+ * This factory function automatically selects between:
+ * - **SileroVADWorker**: Off-main-thread inference (better for desktop)
+ * - **SileroVADInference**: Main thread inference (better for mobile)
+ *
+ * The selection is based on:
+ * 1. Explicit `useWorker` config (if provided)
+ * 2. Platform detection (mobile vs desktop)
+ * 3. Worker API availability
+ *
+ * Both implementations share the same interface (SileroVADBackend),
+ * so consumers can use either interchangeably.
+ *
+ * @param config - Factory configuration
+ * @returns A SileroVAD instance (either Worker or main thread)
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect (recommended)
+ * const vad = createSileroVAD({ modelUrl: '/models/silero-vad.onnx' });
+ *
+ * // Force Worker
+ * const vadWorker = createSileroVAD({ modelUrl: '/models/silero-vad.onnx', useWorker: true });
+ *
+ * // Force main thread
+ * const vadMain = createSileroVAD({ modelUrl: '/models/silero-vad.onnx', useWorker: false });
+ * ```
+ */
+declare function createSileroVAD(config: SileroVADFactoryConfig): SileroVADBackend;
+
+/**
+ * Safari Web Speech API wrapper for iOS speech recognition
+ *
+ * Provides a similar interface to WhisperInference for easy substitution on iOS.
+ * Uses the native Web Speech API which is significantly faster than Whisper WASM on iOS.
+ *
+ * Key differences from WhisperInference:
+ * - Real-time streaming (not batch processing)
+ * - No audio buffer input (microphone handled by browser)
+ * - transcribe() throws error (use start/stop pattern instead)
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { SafariSpeechRecognition, shouldUseNativeASR } from '@omote/core';
+ *
+ * // Use native ASR on iOS, Whisper elsewhere
+ * if (shouldUseNativeASR()) {
+ *   const speech = new SafariSpeechRecognition({ language: 'en-US' });
+ *
+ *   speech.onResult((result) => {
+ *     console.log('Transcript:', result.text);
+ *   });
+ *
+ *   await speech.start();
+ *   // ... user speaks ...
+ *   const finalResult = await speech.stop();
+ * }
+ * ```
+ *
+ * @example Platform-aware initialization
+ * ```typescript
+ * const asr = shouldUseNativeASR()
+ *   ? new SafariSpeechRecognition({ language: 'en-US' })
+ *   : new WhisperInference({ model: 'tiny' });
+ * ```
+ */
+/**
+ * Configuration for Safari Speech Recognition
+ */
+interface SafariSpeechConfig {
+    /** Language code (default: 'en-US') */
+    language?: string;
+    /** Continuous mode for ongoing conversation (default: true) */
+    continuous?: boolean;
+    /** Interim results before speech ends (default: true) */
+    interimResults?: boolean;
+    /** Max alternatives (default: 1) */
+    maxAlternatives?: number;
+}
+/**
+ * Result from speech recognition (matches WhisperInference TranscriptionResult)
+ */
+interface SpeechRecognitionResult {
+    /** Transcribed text */
+    text: string;
+    /** Detected/used language */
+    language: string;
+    /** Time since start in ms (not inference time - native API) */
+    inferenceTimeMs: number;
+    /** Whether this is a final result or interim */
+    isFinal: boolean;
+    /** Confidence score (0-1) if available */
+    confidence?: number;
+}
+/**
+ * Callback for receiving recognition results
+ */
+type SpeechResultCallback = (result: SpeechRecognitionResult) => void;
+/**
+ * Callback for receiving recognition errors
+ */
+type SpeechErrorCallback = (error: Error) => void;
+interface SpeechRecognitionEvent extends Event {
+    resultIndex: number;
+    results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionResultList {
+    length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResultItem;
+}
+interface SpeechRecognitionResultItem {
+    isFinal: boolean;
+    length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+}
+interface SpeechRecognitionAlternative {
+    transcript: string;
+    confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+    message: string;
+}
+interface SpeechRecognitionInterface extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    maxAlternatives: number;
+    start(): void;
+    stop(): void;
+    abort(): void;
+    onresult: ((event: SpeechRecognitionEvent) => void) | null;
+    onerror: ((event: SpeechRecognitionErrorEvent) => void) | null;
+    onend: (() => void) | null;
+    onstart: (() => void) | null;
+    onaudiostart: (() => void) | null;
+    onaudioend: (() => void) | null;
+    onspeechstart: (() => void) | null;
+    onspeechend: (() => void) | null;
+}
+declare global {
+    interface Window {
+        SpeechRecognition?: new () => SpeechRecognitionInterface;
+        webkitSpeechRecognition?: new () => SpeechRecognitionInterface;
+    }
+}
+/**
+ * Safari Web Speech API wrapper
+ *
+ * Provides native speech recognition on iOS Safari.
+ * Much faster than Whisper WASM and more battery-efficient.
+ */
+declare class SafariSpeechRecognition {
+    private config;
+    private recognition;
+    private isListening;
+    private startTime;
+    private accumulatedText;
+    private resultCallbacks;
+    private errorCallbacks;
+    private stopResolver;
+    private stopRejecter;
+    constructor(config?: SafariSpeechConfig);
+    /**
+     * Check if Web Speech API is available
+     */
+    static isAvailable(): boolean;
+    /**
+     * Check if currently listening
+     */
+    get listening(): boolean;
+    /**
+     * Get the language being used
+     */
+    get language(): string;
+    /**
+     * Register a callback for receiving results
+     */
+    onResult(callback: SpeechResultCallback): void;
+    /**
+     * Register a callback for receiving errors
+     */
+    onError(callback: SpeechErrorCallback): void;
+    /**
+     * Remove a result callback
+     */
+    offResult(callback: SpeechResultCallback): void;
+    /**
+     * Remove an error callback
+     */
+    offError(callback: SpeechErrorCallback): void;
+    /**
+     * Start listening for speech
+     *
+     * On iOS Safari, this will trigger the microphone permission prompt
+     * if not already granted.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop listening and return the final transcript
+     */
+    stop(): Promise<SpeechRecognitionResult>;
+    /**
+     * Abort recognition without waiting for final result
+     */
+    abort(): void;
+    /**
+     * NOT SUPPORTED: Transcribe audio buffer
+     *
+     * Safari Speech API does not support transcribing pre-recorded audio.
+     * It only works with live microphone input.
+     *
+     * For batch transcription on iOS, use server-side Whisper or a cloud ASR service.
+     *
+     * @throws Error always - this method is not supported
+     */
+    transcribe(_audio: Float32Array): Promise<SpeechRecognitionResult>;
+    /**
+     * Dispose of recognition resources
+     */
+    dispose(): void;
+    /**
+     * Set up event handlers for the recognition instance
+     */
+    private setupEventHandlers;
+    /**
+     * Emit result to all registered callbacks
+     */
+    private emitResult;
+    /**
+     * Emit error to all registered callbacks
+     */
+    private emitError;
+}
+
+/**
+ * Emotion - Helper for creating emotion vectors for avatar animation
+ *
+ * Provides 10 explicit emotion channels that can be used to control
+ * avatar expressions and emotional states.
+ *
+ * @category Emotion
+ *
+ * @example Creating emotion vectors
+ * ```typescript
+ * import { createEmotionVector, EmotionPresets } from '@omote/core';
+ *
+ * // Named weights
+ * const happy = createEmotionVector({ joy: 0.8, amazement: 0.2 });
+ *
+ * // Use preset
+ * const surprised = EmotionPresets.surprised;
+ * ```
+ *
+ * @example Smooth transitions
+ * ```typescript
+ * import { EmotionController } from '@omote/core';
+ *
+ * const controller = new EmotionController();
+ * controller.setPreset('happy');
+ * controller.transitionTo({ sadness: 0.7 }, 500);
+ *
+ * // In animation loop
+ * controller.update();
+ * const emotion = controller.emotion;
+ * ```
+ */
+/** The 10 explicit emotion channels */
+declare const EMOTION_NAMES: readonly ["amazement", "anger", "cheekiness", "disgust", "fear", "grief", "joy", "outofbreath", "pain", "sadness"];
+type EmotionName = typeof EMOTION_NAMES[number];
+/** Emotion weights by name */
+type EmotionWeights = Partial<Record<EmotionName, number>>;
+/** Total emotion vector size */
+declare const EMOTION_VECTOR_SIZE = 26;
+/**
+ * Create an emotion vector from named weights
+ *
+ * @param weights - Named emotion weights (0-1)
+ * @returns Float32Array of emotion values
+ *
+ * @example
+ * ```ts
+ * const emotion = createEmotionVector({ joy: 0.8, amazement: 0.3 });
+ * ```
+ */
+declare function createEmotionVector(weights?: EmotionWeights): Float32Array;
+/**
+ * Pre-built emotion presets for common expressions
+ */
+declare const EmotionPresets: {
+    /** Neutral/default - no emotional expression */
+    readonly neutral: Float32Array<ArrayBufferLike>;
+    /** Happy - joy with slight amazement */
+    readonly happy: Float32Array<ArrayBufferLike>;
+    /** Sad - grief and sadness */
+    readonly sad: Float32Array<ArrayBufferLike>;
+    /** Angry - anger with disgust */
+    readonly angry: Float32Array<ArrayBufferLike>;
+    /** Surprised - high amazement */
+    readonly surprised: Float32Array<ArrayBufferLike>;
+    /** Scared - fear with pain */
+    readonly scared: Float32Array<ArrayBufferLike>;
+    /** Disgusted - disgust with anger */
+    readonly disgusted: Float32Array<ArrayBufferLike>;
+    /** Excited - joy with amazement and cheekiness */
+    readonly excited: Float32Array<ArrayBufferLike>;
+    /** Tired - out of breath with sadness */
+    readonly tired: Float32Array<ArrayBufferLike>;
+    /** Playful - cheekiness with joy */
+    readonly playful: Float32Array<ArrayBufferLike>;
+    /** Pained - pain with grief */
+    readonly pained: Float32Array<ArrayBufferLike>;
+    /** Contemplative - slight sadness, calm */
+    readonly contemplative: Float32Array<ArrayBufferLike>;
+};
+type EmotionPresetName = keyof typeof EmotionPresets;
+/**
+ * Get an emotion preset by name
+ */
+declare function getEmotionPreset(name: EmotionPresetName): Float32Array;
+/**
+ * Blend multiple emotion vectors together
+ *
+ * @param emotions - Array of { vector, weight } pairs
+ * @returns Blended emotion vector
+ *
+ * @example
+ * ```ts
+ * const blended = blendEmotions([
+ *   { vector: EmotionPresets.happy, weight: 0.7 },
+ *   { vector: EmotionPresets.surprised, weight: 0.3 },
+ * ]);
+ * ```
+ */
+declare function blendEmotions(emotions: Array<{
+    vector: Float32Array;
+    weight: number;
+}>): Float32Array;
+/**
+ * Interpolate between two emotion vectors
+ *
+ * @param from - Starting emotion
+ * @param to - Target emotion
+ * @param t - Interpolation factor (0-1)
+ * @returns Interpolated emotion vector
+ */
+declare function lerpEmotion(from: Float32Array, to: Float32Array, t: number): Float32Array;
+/**
+ * EmotionController - Manages emotion state with smooth transitions
+ */
+declare class EmotionController {
+    private currentEmotion;
+    private targetEmotion;
+    private transitionProgress;
+    private transitionDuration;
+    private transitionStartTime;
+    /**
+     * Get the current emotion vector
+     */
+    get emotion(): Float32Array;
+    /**
+     * Set emotion immediately (no transition)
+     */
+    set(weights: EmotionWeights): void;
+    /**
+     * Set emotion from preset immediately
+     */
+    setPreset(preset: EmotionPresetName): void;
+    /**
+     * Transition to new emotion over time
+     *
+     * @param weights - Target emotion weights
+     * @param durationMs - Transition duration in milliseconds
+     */
+    transitionTo(weights: EmotionWeights, durationMs: number): void;
+    /**
+     * Transition to preset over time
+     */
+    transitionToPreset(preset: EmotionPresetName, durationMs: number): void;
+    /**
+     * Update transition progress (call each frame)
+     */
+    update(): void;
+    /**
+     * Check if currently transitioning
+     */
+    get isTransitioning(): boolean;
+    /**
+     * Reset to neutral
+     */
+    reset(): void;
+}
+
+/**
+ * AI Adapter Interface
+ *
+ * Common interface for AI backends (AWS AgentCore, OpenAI Realtime).
+ * Adapters handle the conversation flow and emit events for animation.
+ *
+ * @category AI
+ */
+
+/**
+ * Tenant configuration for multi-tenant isolation
+ */
+interface TenantConfig {
+    /** Unique tenant identifier */
+    tenantId: string;
+    /** Customer-specific API credentials */
+    credentials: {
+        apiKey?: string;
+        authToken?: string;
+        refreshToken?: string;
+    };
+    /** Character configuration for this tenant */
+    characterId: string;
+    /** Optional custom endpoint override */
+    endpoint?: string;
+}
+/**
+ * Voice configuration for TTS
+ */
+interface VoiceConfig {
+    /** TTS provider */
+    provider: 'elevenlabs' | 'openai';
+    /** Voice ID */
+    voiceId: string;
+    /** Stability (0-1, ElevenLabs) */
+    stability?: number;
+    /** Similarity boost (0-1, ElevenLabs) */
+    similarityBoost?: number;
+}
+/**
+ * Session configuration
+ */
+interface SessionConfig {
+    /** Session ID (generated or provided) */
+    sessionId: string;
+    /** Tenant this session belongs to */
+    tenant: TenantConfig;
+    /** Initial system prompt / personality */
+    systemPrompt?: string;
+    /** Voice configuration for TTS */
+    voice?: VoiceConfig;
+    /** Initial emotion state */
+    emotion?: string;
+    /** Language code */
+    language?: string;
+}
+/**
+ * Message role in conversation
+ */
+type MessageRole = 'user' | 'assistant' | 'system';
+/**
+ * Conversation message in session history
+ */
+interface ConversationMessage {
+    /** Message role */
+    role: MessageRole;
+    /** Text content */
+    content: string;
+    /** Timestamp (ms) */
+    timestamp: number;
+    /** Emotion detected/expressed */
+    emotion?: string;
+    /** Audio duration if applicable (ms) */
+    audioDurationMs?: number;
+}
+/**
+ * Session state
+ */
+type AISessionState = 'idle' | 'listening' | 'thinking' | 'speaking' | 'interrupted' | 'error' | 'disconnected';
+/**
+ * Events emitted by AI adapters
+ */
+interface AIAdapterEvents {
+    [key: string]: unknown;
+    'state.change': {
+        state: AISessionState;
+        previousState: AISessionState;
+    };
+    'user.speech.start': {
+        timestamp: number;
+    };
+    'user.speech.end': {
+        timestamp: number;
+        durationMs: number;
+    };
+    'user.transcript.partial': {
+        text: string;
+        confidence: number;
+    };
+    'user.transcript.final': {
+        text: string;
+        confidence: number;
+    };
+    'ai.thinking.start': {
+        timestamp: number;
+    };
+    'ai.response.start': {
+        text?: string;
+        emotion?: string;
+    };
+    'ai.response.chunk': {
+        text: string;
+        isLast: boolean;
+    };
+    'ai.response.end': {
+        fullText: string;
+        durationMs: number;
+    };
+    'audio.output.chunk': {
+        audio: ArrayBuffer;
+        sampleRate: number;
+        timestamp: number;
+    };
+    'audio.output.end': {
+        durationMs: number;
+    };
+    'animation': AnimationEvent;
+    'memory.updated': {
+        messageCount: number;
+        tokenCount?: number;
+    };
+    'connection.opened': {
+        sessionId: string;
+        adapter: string;
+    };
+    'connection.closed': {
+        reason: string;
+    };
+    'connection.error': {
+        error: Error;
+        recoverable: boolean;
+    };
+    'interruption.detected': {
+        timestamp: number;
+    };
+    'interruption.handled': {
+        action: 'stop' | 'continue';
+        timestamp: number;
+    };
+}
+/**
+ * Base interface for all AI adapters
+ */
+interface AIAdapter {
+    /** Adapter name for logging/debugging */
+    readonly name: string;
+    /** Current session state */
+    readonly state: AISessionState;
+    /** Current session ID (null if not connected) */
+    readonly sessionId: string | null;
+    /** Whether the adapter is connected */
+    readonly isConnected: boolean;
+    /**
+     * Initialize and connect the adapter
+     */
+    connect(config: SessionConfig): Promise<void>;
+    /**
+     * Disconnect and cleanup
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Push user audio for processing
+     * @param audio - PCM audio data (16kHz, mono)
+     */
+    pushAudio(audio: Int16Array | Float32Array): void;
+    /**
+     * Send text message directly (bypasses STT)
+     */
+    sendText(text: string): Promise<void>;
+    /**
+     * Handle user interruption
+     * Stops current AI speech and prepares for new input
+     */
+    interrupt(): void;
+    /**
+     * Get conversation history
+     */
+    getHistory(): ConversationMessage[];
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+    /**
+     * Check if adapter is available/healthy
+     */
+    healthCheck(): Promise<boolean>;
+    on<K extends keyof AIAdapterEvents>(event: K, callback: (data: AIAdapterEvents[K]) => void): () => void;
+    off<K extends keyof AIAdapterEvents>(event: K, callback: (data: AIAdapterEvents[K]) => void): void;
+    once<K extends keyof AIAdapterEvents>(event: K, callback: (data: AIAdapterEvents[K]) => void): () => void;
+}
+
+/**
+ * Conversation Session Interface
+ *
+ * Represents an active conversation with memory and state.
+ *
+ * @category AI
+ */
+
+/**
+ * Serializable session snapshot for persistence
+ */
+interface SessionSnapshot {
+    /** Session ID */
+    sessionId: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Character ID */
+    characterId: string;
+    /** Conversation history */
+    history: ConversationMessage[];
+    /** Custom context */
+    context: Record<string, string>;
+    /** Emotion state */
+    emotion: EmotionWeights;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last activity timestamp */
+    lastActivityAt: number;
+}
+/**
+ * Extended session with memory management
+ */
+interface ConversationSession {
+    /** Session identifier */
+    readonly sessionId: string;
+    /** Associated AI adapter */
+    readonly adapter: AIAdapter;
+    /** Session configuration */
+    readonly config: SessionConfig;
+    /** Current state */
+    readonly state: AISessionState;
+    /** Conversation history */
+    readonly history: ConversationMessage[];
+    /** Current emotion state */
+    readonly emotion: EmotionWeights;
+    /** Session creation timestamp */
+    readonly createdAt: number;
+    /** Last activity timestamp */
+    readonly lastActivityAt: number;
+    /**
+     * Start the session (connects adapter)
+     */
+    start(): Promise<void>;
+    /**
+     * End the session (disconnects adapter)
+     */
+    end(): Promise<void>;
+    /**
+     * Push audio input
+     */
+    pushAudio(audio: Int16Array | Float32Array): void;
+    /**
+     * Send text input directly
+     */
+    sendText(text: string): Promise<void>;
+    /**
+     * Interrupt current AI response
+     */
+    interrupt(): void;
+    /**
+     * Update emotion state
+     */
+    setEmotion(emotion: EmotionWeights): void;
+    /**
+     * Add a context item (custom memory)
+     */
+    addContext(key: string, value: string): void;
+    /**
+     * Remove a context item
+     */
+    removeContext(key: string): void;
+    /**
+     * Get all context items
+     */
+    getContext(): Record<string, string>;
+    /**
+     * Export session for persistence
+     */
+    export(): SessionSnapshot;
+    /**
+     * Import session from snapshot
+     */
+    import(snapshot: SessionSnapshot): void;
+}
+
+/**
+ * AWS AgentCore Adapter
+ *
+ * Primary AI adapter for the Omote Platform.
+ *
+ * Pipeline:
+ * User Audio -> Whisper ASR (local) -> Text
+ * Text -> AgentCore (WebSocket) -> Response Text + Audio chunks (TTS handled backend-side)
+ * Audio chunks -> LAM (local) -> Blendshapes -> Render
+ *
+ * @category AI
+ */
+
+/**
+ * AgentCore-specific configuration
+ */
+interface AgentCoreConfig {
+    /** AgentCore WebSocket endpoint */
+    endpoint: string;
+    /** AWS region */
+    region?: string;
+    /** Model URLs */
+    models?: {
+        lamUrl?: string;
+    };
+    /** Enable observability */
+    observability?: {
+        tracing?: boolean;
+        metrics?: boolean;
+    };
+}
+/**
+ * AWS AgentCore Adapter
+ */
+declare class AgentCoreAdapter extends EventEmitter<AIAdapterEvents> implements AIAdapter {
+    readonly name = "AgentCore";
+    private _state;
+    private _sessionId;
+    private _isConnected;
+    private whisper;
+    private vad;
+    private lam;
+    private emotionController;
+    private pipeline;
+    private ws;
+    private wsReconnectAttempts;
+    private readonly maxReconnectAttempts;
+    private audioBuffer;
+    private history;
+    private currentConfig;
+    private agentCoreConfig;
+    private isSpeaking;
+    private currentTtsAbortController;
+    private tokenCache;
+    constructor(config: AgentCoreConfig);
+    get state(): AISessionState;
+    get sessionId(): string | null;
+    get isConnected(): boolean;
+    /**
+     * Connect to AgentCore with session configuration
+     */
+    connect(config: SessionConfig): Promise<void>;
+    /**
+     * Disconnect and cleanup
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Push user audio for processing
+     */
+    pushAudio(audio: Int16Array | Float32Array): void;
+    /**
+     * Send text directly to AgentCore
+     */
+    sendText(text: string): Promise<void>;
+    /**
+     * Interrupt current AI response
+     */
+    interrupt(): void;
+    getHistory(): ConversationMessage[];
+    clearHistory(): void;
+    healthCheck(): Promise<boolean>;
+    private setState;
+    private getAuthToken;
+    private initWhisper;
+    private initLAM;
+    private initPipeline;
+    private connectWebSocket;
+    private handleAgentCoreMessage;
+    private scheduleTranscription;
+    /**
+     * Detect voice activity using Silero VAD
+     * Falls back to simple RMS if VAD not available
+     */
+    private detectVoiceActivity;
+    private int16ToFloat32;
+    private base64ToArrayBuffer;
+    private addToHistory;
+    private handleDisconnect;
+}
+
+/**
+ * Conversation Orchestrator
+ *
+ * Manages the conversation pipeline with AgentCore:
+ * - Handles session lifecycle and tenant isolation
+ * - Manages adapter events and state
+ *
+ * @category AI
+ */
+
+/**
+ * Orchestrator configuration
+ */
+interface OrchestratorConfig {
+    /** AgentCore adapter config */
+    adapter: AgentCoreConfig;
+    /** Connection timeout in ms */
+    connectionTimeoutMs?: number;
+    /** Max retry attempts */
+    maxRetries?: number;
+}
+/**
+ * Orchestrator events (extends AI adapter events)
+ */
+interface OrchestratorEvents extends AIAdapterEvents {
+    'session.created': {
+        sessionId: string;
+        tenantId: string;
+    };
+    'session.ended': {
+        sessionId: string;
+        reason: string;
+    };
+}
+/**
+ * Conversation Orchestrator
+ */
+declare class ConversationOrchestrator extends EventEmitter<OrchestratorEvents> {
+    private config;
+    private adapter;
+    private sessions;
+    private tenants;
+    private healthCheckInterval;
+    private readonly HEALTH_CHECK_INTERVAL_MS;
+    constructor(config: OrchestratorConfig);
+    /**
+     * Register a tenant
+     */
+    registerTenant(tenant: TenantConfig): void;
+    /**
+     * Unregister a tenant
+     */
+    unregisterTenant(tenantId: string): void;
+    /**
+     * Get tenant config
+     */
+    getTenant(tenantId: string): TenantConfig | undefined;
+    /**
+     * Create a new conversation session for a tenant
+     */
+    createSession(tenantId: string, options?: Partial<SessionConfig>): Promise<ConversationSession>;
+    /**
+     * End a session
+     */
+    endSession(sessionId: string): Promise<void>;
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId: string): ConversationSession | undefined;
+    /**
+     * Get all sessions for a tenant
+     */
+    getTenantSessions(tenantId: string): ConversationSession[];
+    /**
+     * Start health monitoring
+     */
+    startHealthMonitoring(): void;
+    /**
+     * Stop health monitoring
+     */
+    stopHealthMonitoring(): void;
+    /**
+     * Dispose all resources
+     */
+    dispose(): Promise<void>;
+    private generateSessionId;
+    private forwardAdapterEvents;
+    private performHealthCheck;
+}
+
+/**
+ * Tenant Manager
+ *
+ * Handles multi-tenant isolation for the Omote Platform:
+ * - Credential isolation per tenant
+ * - Session scoping per tenant
+ * - Quota management
+ * - Token refresh
+ *
+ * @category AI
+ */
+
+/**
+ * Tenant quota configuration
+ */
+interface TenantQuota {
+    /** Max concurrent sessions */
+    maxSessions: number;
+    /** Requests per minute */
+    requestsPerMinute: number;
+    /** Max tokens per conversation */
+    maxTokensPerConversation: number;
+    /** Max audio minutes per day */
+    maxAudioMinutesPerDay: number;
+}
+/**
+ * Tenant usage tracking
+ */
+interface TenantUsage {
+    /** Current active sessions */
+    currentSessions: number;
+    /** Requests in current minute */
+    requestsThisMinute: number;
+    /** Total tokens used */
+    tokensUsed: number;
+    /** Audio minutes used today */
+    audioMinutesToday: number;
+    /** Last reset timestamp */
+    lastMinuteReset: number;
+    /** Last daily reset timestamp */
+    lastDailyReset: number;
+}
+/**
+ * Token refresh callback
+ */
+type TokenRefreshCallback = () => Promise<string>;
+/**
+ * Tenant Manager
+ */
+declare class TenantManager {
+    private tenants;
+    private quotas;
+    private usage;
+    private tokenRefreshCallbacks;
+    /**
+     * Default quota for new tenants
+     */
+    static readonly DEFAULT_QUOTA: TenantQuota;
+    /**
+     * Register a tenant with quota
+     */
+    register(tenant: TenantConfig, quota?: TenantQuota, tokenRefreshCallback?: TokenRefreshCallback): void;
+    /**
+     * Unregister a tenant
+     */
+    unregister(tenantId: string): void;
+    /**
+     * Get tenant config
+     */
+    get(tenantId: string): TenantConfig | undefined;
+    /**
+     * Check if tenant exists
+     */
+    has(tenantId: string): boolean;
+    /**
+     * Get all tenant IDs
+     */
+    getTenantIds(): string[];
+    /**
+     * Check if tenant can create new session
+     */
+    canCreateSession(tenantId: string): boolean;
+    /**
+     * Check if tenant can make request
+     */
+    canMakeRequest(tenantId: string): boolean;
+    /**
+     * Check if tenant can use audio
+     */
+    canUseAudio(tenantId: string, minutes: number): boolean;
+    /**
+     * Increment session count
+     */
+    incrementSessions(tenantId: string): void;
+    /**
+     * Decrement session count
+     */
+    decrementSessions(tenantId: string): void;
+    /**
+     * Record a request
+     */
+    recordRequest(tenantId: string): void;
+    /**
+     * Record token usage
+     */
+    recordTokens(tenantId: string, tokens: number): void;
+    /**
+     * Record audio usage
+     */
+    recordAudioMinutes(tenantId: string, minutes: number): void;
+    /**
+     * Get fresh auth token for tenant
+     */
+    getAuthToken(tenantId: string): Promise<string>;
+    /**
+     * Update tenant credentials
+     */
+    updateCredentials(tenantId: string, credentials: Partial<TenantConfig['credentials']>): void;
+    /**
+     * Get usage stats for tenant
+     */
+    getUsage(tenantId: string): TenantUsage | undefined;
+    /**
+     * Get quota for tenant
+     */
+    getQuota(tenantId: string): TenantQuota | undefined;
+    /**
+     * Update quota for tenant
+     */
+    updateQuota(tenantId: string, quota: Partial<TenantQuota>): void;
+    /**
+     * Reset all usage stats for a tenant
+     */
+    resetUsage(tenantId: string): void;
+    private checkMinuteReset;
+    private checkDailyReset;
+}
+
+/**
+ * Audio Sync Manager
+ *
+ * Synchronizes TTS audio playback with lip sync animation:
+ * - Buffers audio for inference
+ * - Manages playback timing
+ * - Handles audio queue for streaming
+ *
+ * @category AI
+ */
+
+/**
+ * Audio sync events
+ */
+interface AudioSyncEvents {
+    [key: string]: unknown;
+    'buffer.ready': {
+        audio: Float32Array;
+    };
+    'playback.start': Record<string, never>;
+    'playback.end': Record<string, never>;
+    'sync.drift': {
+        driftMs: number;
+    };
+}
+/**
+ * Audio sync configuration
+ */
+interface AudioSyncConfig {
+    /** Target sample rate (default: 16000) */
+    sampleRate?: number;
+    /** Buffer size for inference (default: 16640) */
+    bufferSize?: number;
+    /** Overlap between buffers (default: 4160) */
+    overlapSize?: number;
+    /** Max drift before correction (default: 100ms) */
+    maxDriftMs?: number;
+}
+/**
+ * Audio Sync Manager
+ */
+declare class AudioSyncManager extends EventEmitter<AudioSyncEvents> {
+    private config;
+    private audioBuffer;
+    private bufferPosition;
+    private playbackQueue;
+    private isPlaying;
+    private audioContext;
+    private playbackStartTime;
+    private samplesPlayed;
+    constructor(config?: AudioSyncConfig);
+    /**
+     * Initialize audio context
+     */
+    initialize(): Promise<void>;
+    /**
+     * Push audio chunk for processing and playback
+     */
+    pushAudio(audio: Float32Array): void;
+    /**
+     * Buffer audio for inference
+     */
+    private bufferForInference;
+    /**
+     * Start audio playback
+     */
+    private startPlayback;
+    /**
+     * Process playback queue
+     */
+    private processPlaybackQueue;
+    /**
+     * Check for audio/animation drift
+     */
+    private checkDrift;
+    /**
+     * Clear playback queue
+     */
+    clearQueue(): void;
+    /**
+     * Stop playback
+     */
+    stop(): void;
+    /**
+     * Get current playback position in seconds
+     */
+    getPlaybackPosition(): number;
+    /**
+     * Check if currently playing
+     */
+    getIsPlaying(): boolean;
+    /**
+     * Dispose resources
+     */
+    dispose(): void;
+}
+
+/**
+ * Interruption Handler
+ *
+ * VAD-based interruption detection for AI conversations:
+ * - Monitors user audio for speech
+ * - Detects when user interrupts AI response
+ * - Triggers interruption callbacks
+ *
+ * @category AI
+ */
+
+/**
+ * Interruption events
+ */
+interface InterruptionEvents {
+    [key: string]: unknown;
+    'speech.detected': {
+        rms: number;
+    };
+    'speech.ended': {
+        durationMs: number;
+    };
+    'interruption.triggered': {
+        rms: number;
+        durationMs: number;
+    };
+}
+/**
+ * Interruption handler configuration
+ *
+ * Industry standards applied:
+ * - vadThreshold: 0.5 (Silero VAD default)
+ * - minSpeechDurationMs: 200ms (Google/Amazon barge-in standard)
+ * - silenceTimeoutMs: 500ms (OpenAI Realtime API standard)
+ */
+interface InterruptionConfig {
+    /** VAD probability threshold for speech detection (default: 0.5, Silero standard) */
+    vadThreshold?: number;
+    /** Minimum speech duration to trigger interruption (default: 200ms, Google/Amazon standard) */
+    minSpeechDurationMs?: number;
+    /** Silence duration to end speech (default: 500ms, OpenAI standard) */
+    silenceTimeoutMs?: number;
+    /** Enable interruption detection (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Interruption Handler
+ */
+declare class InterruptionHandler extends EventEmitter<InterruptionEvents> {
+    private config;
+    private isSpeaking;
+    private speechStartTime;
+    private lastSpeechTime;
+    private silenceTimer;
+    private aiIsSpeaking;
+    private interruptionTriggeredThisSession;
+    constructor(config?: InterruptionConfig);
+    /**
+     * Process VAD result for interruption detection
+     * @param vadProbability - Speech probability from VAD (0-1)
+     * @param audioEnergy - Optional RMS energy for logging (default: 0)
+     */
+    processVADResult(vadProbability: number, audioEnergy?: number): void;
+    /**
+     * @deprecated Use processVADResult() instead. This method uses naive RMS detection.
+     * Process audio samples for VAD (legacy - uses simple RMS)
+     */
+    processAudio(samples: Float32Array | Int16Array): void;
+    /**
+     * Notify that AI started speaking
+     */
+    setAISpeaking(speaking: boolean): void;
+    /**
+     * Enable/disable interruption detection
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<InterruptionConfig>): void;
+    /**
+     * Reset state
+     */
+    reset(): void;
+    /**
+     * Get current state
+     */
+    getState(): {
+        isSpeaking: boolean;
+        speechDurationMs: number;
+    };
+    private calculateRMS;
+    private onSpeechDetected;
+    private onSilenceDetected;
+}
+
+/**
+ * Model Cache
+ *
+ * Caches ONNX models in IndexedDB for faster subsequent loads.
+ * IndexedDB can handle large files (100s of MBs) unlike localStorage.
+ *
+ * @category Cache
+ */
+/**
+ * Configuration for cache size limits and eviction behavior
+ */
+interface CacheConfig {
+    /** Maximum total cache size in bytes (default: 1GB) */
+    maxSizeBytes?: number;
+    /** Maximum age in milliseconds before eviction (default: none) */
+    maxAgeMs?: number;
+    /** Callback when storage quota exceeds warning threshold */
+    onQuotaWarning?: (info: QuotaInfo) => void;
+}
+/**
+ * Storage quota information
+ */
+interface QuotaInfo {
+    /** Total bytes used across all origins */
+    usedBytes: number;
+    /** Total available quota in bytes */
+    quotaBytes: number;
+    /** Percentage of quota used (0-100) */
+    percentUsed: number;
+    /** Bytes used by omote cache specifically */
+    cacheBytes: number;
+}
+/**
+ * Configure cache size limits and eviction behavior
+ *
+ * @param config - Cache configuration options
+ *
+ * @example
+ * ```typescript
+ * import { configureCacheLimit } from '@omote/core';
+ *
+ * // Set 500MB limit with 24-hour max age
+ * configureCacheLimit({
+ *   maxSizeBytes: 500 * 1024 * 1024,
+ *   maxAgeMs: 24 * 60 * 60 * 1000,
+ *   onQuotaWarning: (info) => {
+ *     console.warn(`Storage ${info.percentUsed.toFixed(1)}% used`);
+ *   }
+ * });
+ * ```
+ */
+declare function configureCacheLimit(config: CacheConfig): void;
+/**
+ * Get current cache configuration
+ */
+declare function getCacheConfig(): CacheConfig;
+/**
+ * Result from getWithValidation() method
+ */
+interface ValidationResult {
+    /** The cached data, or null if not found */
+    data: ArrayBuffer | null;
+    /** True if the cached data is stale (etag mismatch) */
+    stale: boolean;
+}
+/**
+ * Generate a version-aware cache key
+ *
+ * @param url - The model URL
+ * @param version - Optional version string
+ * @returns The cache key (url#vX.X.X if version provided, url otherwise)
+ *
+ * @example
+ * ```typescript
+ * getCacheKey('http://example.com/model.onnx', '1.0.0')
+ * // Returns: 'http://example.com/model.onnx#v1.0.0'
+ *
+ * getCacheKey('http://example.com/model.onnx')
+ * // Returns: 'http://example.com/model.onnx'
+ * ```
+ */
+declare function getCacheKey(url: string, version?: string): string;
+interface CacheStats {
+    totalSize: number;
+    modelCount: number;
+    models: {
+        url: string;
+        size: number;
+        cachedAt: Date;
+    }[];
+}
+/**
+ * ModelCache - IndexedDB-based cache for ONNX models
+ */
+declare class ModelCache {
+    private db;
+    private dbPromise;
+    /**
+     * Initialize the cache database
+     */
+    private getDB;
+    /**
+     * Check if a model is cached
+     */
+    has(url: string): Promise<boolean>;
+    /**
+     * Get a cached model
+     *
+     * Updates lastAccessedAt timestamp for LRU tracking on cache hit.
+     */
+    get(url: string): Promise<ArrayBuffer | null>;
+    /**
+     * Get a cached model with ETag validation
+     *
+     * Validates the cached data against the server's current ETag.
+     * If the cached ETag differs from the server's, the data is marked as stale.
+     *
+     * @param url - The cache key
+     * @param originalUrl - The original URL for HEAD request (if different from cache key)
+     * @returns ValidationResult with data and stale flag
+     *
+     * @example
+     * ```typescript
+     * const result = await cache.getWithValidation('http://example.com/model.onnx');
+     * if (result.data && !result.stale) {
+     *   // Use cached data
+     * } else if (result.stale) {
+     *   // Refetch and update cache
+     * }
+     * ```
+     */
+    getWithValidation(url: string, originalUrl?: string): Promise<ValidationResult>;
+    /**
+     * Store a model in cache
+     *
+     * After storing, triggers LRU eviction if cache exceeds size limit.
+     *
+     * @param url - The cache key (use getCacheKey() for versioned keys)
+     * @param data - The model data
+     * @param etag - Optional ETag for staleness validation
+     * @param version - Optional version string for metadata
+     */
+    set(url: string, data: ArrayBuffer, etag?: string, version?: string): Promise<void>;
+    /**
+     * Check storage quota and trigger warnings/cleanup as needed
+     *
+     * - Logs warning if quota > 90% used
+     * - Triggers LRU cleanup if quota > 95% used
+     * - Calls onQuotaWarning callback if configured
+     */
+    private checkQuota;
+    /**
+     * Delete a cached model
+     */
+    delete(url: string): Promise<void>;
+    /**
+     * Clear all cached models
+     */
+    clear(): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Enforce cache size limit by evicting oldest entries (LRU)
+     *
+     * Called automatically after each set() operation.
+     * Can also be called manually to trigger cleanup.
+     */
+    enforceLimit(): Promise<void>;
+    /**
+     * Evict oldest entries (by lastAccessedAt) to free space
+     *
+     * @param bytesToFree - Minimum bytes to free
+     * @returns List of evicted URLs
+     *
+     * @example
+     * ```typescript
+     * const cache = getModelCache();
+     * const evicted = await cache.evictOldest(100 * 1024 * 1024); // Free 100MB
+     * console.log('Evicted:', evicted);
+     * ```
+     */
+    evictOldest(bytesToFree: number): Promise<string[]>;
+    /**
+     * Get storage quota information
+     *
+     * Uses navigator.storage.estimate() to get quota details.
+     * Returns null if the API is unavailable.
+     *
+     * @returns Quota info or null if unavailable
+     *
+     * @example
+     * ```typescript
+     * const cache = getModelCache();
+     * const quota = await cache.getQuotaInfo();
+     * if (quota) {
+     *   console.log(`Using ${quota.percentUsed.toFixed(1)}% of quota`);
+     * }
+     * ```
+     */
+    getQuotaInfo(): Promise<QuotaInfo | null>;
+}
+/**
+ * Get the global ModelCache instance
+ */
+declare function getModelCache(): ModelCache;
+/**
+ * Options for fetchWithCache
+ */
+interface FetchWithCacheOptions {
+    /** Optional version string for versioned caching */
+    version?: string;
+    /** If true, validates cached data against server ETag and refetches if stale */
+    validateStale?: boolean;
+    /** Progress callback during download */
+    onProgress?: (loaded: number, total: number) => void;
+}
+/**
+ * Fetch a model with caching
+ * Uses IndexedDB cache with network fallback
+ * Files larger than 500MB are not cached to IndexedDB to avoid memory pressure
+ * (structured clone during IndexedDB write temporarily doubles memory usage)
+ *
+ * @param url - The URL to fetch
+ * @param onProgress - Optional progress callback (legacy signature)
+ * @returns The fetched ArrayBuffer
+ *
+ * @example
+ * ```typescript
+ * // Simple usage (backwards compatible)
+ * const data = await fetchWithCache('http://example.com/model.onnx');
+ *
+ * // With progress callback (backwards compatible)
+ * const data = await fetchWithCache('http://example.com/model.onnx', (loaded, total) => {
+ *   console.log(`${loaded}/${total} bytes`);
+ * });
+ *
+ * // With options (new API)
+ * const data = await fetchWithCache('http://example.com/model.onnx', {
+ *   version: '1.0.0',
+ *   validateStale: true,
+ *   onProgress: (loaded, total) => console.log(`${loaded}/${total}`)
+ * });
+ * ```
+ */
+declare function fetchWithCache(url: string, optionsOrProgress?: FetchWithCacheOptions | ((loaded: number, total: number) => void)): Promise<ArrayBuffer>;
+/**
+ * Preload models into cache without creating sessions
+ */
+declare function preloadModels(urls: string[], onProgress?: (current: number, total: number, url: string) => void): Promise<void>;
+/**
+ * Format bytes as human readable string
+ */
+declare function formatBytes(bytes: number): string;
+
+/**
+ * HuggingFace CDN Utilities
+ *
+ * Helper functions for working with HuggingFace CDN URLs.
+ * Used by transformers.js models (Whisper, etc.) for model downloads.
+ *
+ * @category Cache
+ */
+/**
+ * Test URL for HuggingFace CDN reachability check.
+ * Uses a small, stable file from a well-known public model.
+ */
+declare const HF_CDN_TEST_URL = "https://huggingface.co/Xenova/whisper-tiny/resolve/main/config.json";
+/**
+ * Parsed HuggingFace URL components
+ */
+interface HuggingFaceUrlInfo {
+    /** Organization or username */
+    org: string;
+    /** Model name */
+    model: string;
+    /** Branch, tag, or commit */
+    branch: string;
+    /** File path within the repository */
+    file: string;
+}
+/**
+ * Parse a HuggingFace CDN URL into its components
+ *
+ * @param url - The HuggingFace URL to parse
+ * @returns Parsed URL info or null if not a valid HF URL
+ *
+ * @example
+ * ```typescript
+ * const info = parseHuggingFaceUrl(
+ *   'https://huggingface.co/openai/whisper-tiny/resolve/main/model.onnx'
+ * );
+ * // Returns: { org: 'openai', model: 'whisper-tiny', branch: 'main', file: 'model.onnx' }
+ * ```
+ */
+declare function parseHuggingFaceUrl(url: string): HuggingFaceUrlInfo | null;
+/**
+ * Check if HuggingFace CDN is reachable
+ *
+ * Performs a HEAD request to a known HuggingFace model file to verify
+ * connectivity. Useful for offline detection or network diagnostics.
+ *
+ * @param testUrl - Optional custom URL to test (defaults to HF_CDN_TEST_URL)
+ * @returns True if CDN is reachable, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isHuggingFaceCDNReachable } from '@omote/core';
+ *
+ * const reachable = await isHuggingFaceCDNReachable();
+ * if (!reachable) {
+ *   console.log('HuggingFace CDN unreachable - running offline?');
+ *   // Fall back to cached models or show error
+ * }
+ * ```
+ */
+declare function isHuggingFaceCDNReachable(testUrl?: string): Promise<boolean>;
+
+/**
+ * Utility to clear transformers.js Cache API storage
+ *
+ * Problem: transformers.js v4 uses Browser Cache API which persists across hard refreshes.
+ * If an HTML error page gets cached (due to network errors, CDN issues, or dev server restarts),
+ * it will be served instead of JSON files, causing JSON.parse() errors.
+ *
+ * Solution: Manually clear Cache API storage before loading models.
+ *
+ * @module utils/transformersCacheClear
+ */
+/**
+ * Clear all transformers.js and HuggingFace caches from Browser Cache API
+ *
+ * This clears:
+ * - transformers-cache (default cache key)
+ * - Any caches with 'transformers' or 'huggingface' in the name
+ *
+ * @param options Configuration options
+ * @returns Promise resolving to array of deleted cache names
+ */
+declare function clearTransformersCache(options?: {
+    /** Whether to log deletion details (default: true) */
+    verbose?: boolean;
+    /** Additional cache name patterns to clear (e.g., ['my-custom-cache']) */
+    additionalPatterns?: string[];
+}): Promise<string[]>;
+/**
+ * Clear a specific cache by exact name
+ *
+ * @param cacheName Exact cache name to delete
+ * @returns Promise resolving to true if deleted, false otherwise
+ */
+declare function clearSpecificCache(cacheName: string): Promise<boolean>;
+/**
+ * List all cache names currently stored
+ *
+ * @returns Promise resolving to array of cache names
+ */
+declare function listCaches(): Promise<string[]>;
+/**
+ * Check if a specific cached response is valid JSON/binary (not HTML error page)
+ *
+ * @param cacheName Cache name to check
+ * @param requestUrl URL/key to check
+ * @returns Promise resolving to validation result
+ */
+declare function validateCachedResponse(cacheName: string, requestUrl: string): Promise<{
+    exists: boolean;
+    valid: boolean;
+    contentType: string | null;
+    isHtml: boolean;
+    reason?: string;
+}>;
+/**
+ * Scan all caches for potentially invalid cached responses
+ *
+ * @returns Promise resolving to report of invalid entries
+ */
+declare function scanForInvalidCaches(): Promise<{
+    totalCaches: number;
+    scannedEntries: number;
+    invalidEntries: Array<{
+        cacheName: string;
+        url: string;
+        reason: string;
+    }>;
+}>;
+/**
+ * Clear all caches and optionally prevent re-creation (development mode)
+ *
+ * WARNING: This is aggressive and should only be used in development.
+ * It clears ALL browser caches, not just transformers.js.
+ *
+ * @param preventRecreation If true, sets env.useBrowserCache = false
+ * @returns Promise resolving to number of deleted caches
+ */
+declare function nukeBrowserCaches(preventRecreation?: boolean): Promise<number>;
+
+/**
+ * Logging types for Omote SDK
+ *
+ * 6-level logging system with structured output:
+ * - error: Critical failures that prevent operation
+ * - warn: Recoverable issues or degraded performance
+ * - info: Key lifecycle events (model loaded, inference complete)
+ * - debug: Detailed operational info for development
+ * - trace: Fine-grained tracing for performance analysis
+ * - verbose: Extremely detailed output (tensor shapes, intermediate values)
+ */
+type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'verbose';
+/**
+ * Numeric priority for log levels (lower = more severe)
+ */
+declare const LOG_LEVEL_PRIORITY: Record<LogLevel, number>;
+/**
+ * Structured log entry
+ */
+interface LogEntry {
+    /** Unix timestamp in milliseconds */
+    timestamp: number;
+    /** Log level */
+    level: LogLevel;
+    /** Module name (e.g., 'LocalInference', 'ModelCache') */
+    module: string;
+    /** Human-readable message */
+    message: string;
+    /** Optional structured data */
+    data?: Record<string, unknown>;
+    /** Optional error object */
+    error?: Error;
+}
+/**
+ * Log output sink interface
+ */
+interface LogSink {
+    (entry: LogEntry): void;
+}
+/**
+ * Log formatter interface
+ */
+interface LogFormatter {
+    (entry: LogEntry): string;
+}
+/**
+ * Global logging configuration
+ */
+interface LoggingConfig {
+    /** Minimum log level to output (default: 'info') */
+    level: LogLevel;
+    /** Enable/disable logging globally (default: true) */
+    enabled: boolean;
+    /** Output format: 'json' for structured, 'pretty' for human-readable */
+    format: 'json' | 'pretty';
+    /** Custom output sink (default: console) */
+    sink?: LogSink;
+    /** Include timestamps in output (default: true) */
+    timestamps?: boolean;
+    /** Include module name in output (default: true) */
+    includeModule?: boolean;
+}
+/**
+ * Logger interface for module-specific logging
+ */
+interface ILogger {
+    error(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    debug(message: string, data?: Record<string, unknown>): void;
+    trace(message: string, data?: Record<string, unknown>): void;
+    verbose(message: string, data?: Record<string, unknown>): void;
+    /** Create a child logger with a sub-module name */
+    child(subModule: string): ILogger;
+    /** Get the module name for this logger */
+    readonly module: string;
+}
+/**
+ * Default configuration
+ */
+declare const DEFAULT_LOGGING_CONFIG: LoggingConfig;
+
+/**
+ * Omote SDK Logger
+ *
+ * Unified logging system with:
+ * - 6 log levels (error, warn, info, debug, trace, verbose)
+ * - Structured JSON output for machine parsing
+ * - Pretty output for human readability
+ * - Module-based child loggers
+ * - Runtime configuration
+ * - Browser and Node.js compatible
+ */
+
+/**
+ * Configure global logging settings
+ */
+declare function configureLogging(config: Partial<LoggingConfig>): void;
+/**
+ * Get current logging configuration
+ */
+declare function getLoggingConfig(): LoggingConfig;
+/**
+ * Reset logging configuration to defaults
+ */
+declare function resetLoggingConfig(): void;
+/**
+ * Set log level at runtime
+ */
+declare function setLogLevel(level: LogLevel): void;
+/**
+ * Enable or disable logging
+ */
+declare function setLoggingEnabled(enabled: boolean): void;
+/**
+ * Create a logger for a specific module
+ *
+ * @param module - Module name (e.g., 'LocalInference', 'ModelCache')
+ * @returns Logger instance
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('LocalInference');
+ * logger.info('Model loaded', { backend: 'webgpu', loadTimeMs: 1234 });
+ * ```
+ */
+declare function createLogger(module: string): ILogger;
+/**
+ * No-op logger for when logging is completely disabled
+ */
+declare const noopLogger: ILogger;
+
+/**
+ * Telemetry Types
+ *
+ * Configuration and type definitions for OpenTelemetry instrumentation.
+ *
+ * @category Telemetry
+ */
+/**
+ * Supported telemetry exporters
+ */
+type TelemetryExporter = 'console' | 'otlp' | 'none';
+/**
+ * Sampling configuration
+ */
+interface SamplingConfig {
+    /** Sampling ratio (0.0 - 1.0). Default: 1.0 (sample everything) */
+    ratio?: number;
+    /** Always sample errors regardless of ratio */
+    alwaysSampleErrors?: boolean;
+}
+/**
+ * OTLP exporter configuration
+ */
+interface OTLPExporterConfig {
+    /** OTLP endpoint URL (e.g., 'https://tempo.example.com/v1/traces') */
+    endpoint: string;
+    /** Optional headers for authentication */
+    headers?: Record<string, string>;
+    /** Request timeout in ms. Default: 10000 */
+    timeoutMs?: number;
+}
+/**
+ * Main telemetry configuration
+ */
+interface TelemetryConfig {
+    /** Enable/disable telemetry. Default: false */
+    enabled?: boolean;
+    /** Service name for spans. Default: 'omote-sdk' */
+    serviceName?: string;
+    /** Service version. Default: SDK version */
+    serviceVersion?: string;
+    /** Exporter type. Default: 'none' */
+    exporter?: TelemetryExporter;
+    /** OTLP exporter config (required if exporter is 'otlp') */
+    exporterConfig?: OTLPExporterConfig;
+    /** Sampling configuration */
+    sampling?: SamplingConfig;
+    /** Enable metrics collection. Default: true when telemetry enabled */
+    metricsEnabled?: boolean;
+    /** Metrics export interval in ms. Default: 60000 */
+    metricsIntervalMs?: number;
+}
+/**
+ * Span attributes for model operations
+ */
+interface ModelSpanAttributes {
+    /** Model URL or identifier */
+    'model.url'?: string;
+    /** Model name (e.g., 'whisper', 'lam', 'silero-vad') */
+    'model.name'?: string;
+    /** Inference backend used */
+    'model.backend'?: 'webgpu' | 'wasm';
+    /** Whether model was loaded from cache */
+    'model.cached'?: boolean;
+    /** Model size in bytes */
+    'model.size_bytes'?: number;
+}
+/**
+ * Span attributes for inference operations
+ */
+interface InferenceSpanAttributes extends ModelSpanAttributes {
+    /** Number of input audio samples */
+    'inference.input_samples'?: number;
+    /** Input duration in ms */
+    'inference.input_duration_ms'?: number;
+    /** Number of output frames (for LAM) */
+    'inference.output_frames'?: number;
+    /** Inference duration in ms */
+    'inference.duration_ms'?: number;
+    /** Whether inference succeeded */
+    'inference.success'?: boolean;
+    /** Error type if failed */
+    'inference.error_type'?: string;
+}
+/**
+ * Span attributes for cache operations
+ */
+interface CacheSpanAttributes {
+    /** Cache key (URL) */
+    'cache.key'?: string;
+    /** Whether it was a cache hit */
+    'cache.hit'?: boolean;
+    /** Size of cached item in bytes */
+    'cache.size_bytes'?: number;
+    /** Cache operation type */
+    'cache.operation'?: 'get' | 'set' | 'delete';
+}
+/**
+ * Combined span attributes type
+ */
+type SpanAttributes = ModelSpanAttributes | InferenceSpanAttributes | CacheSpanAttributes | Record<string, string | number | boolean | undefined>;
+/**
+ * Metric names used by the SDK
+ */
+declare const MetricNames: {
+    /** Histogram: Inference latency in ms */
+    readonly INFERENCE_LATENCY: "omote.inference.latency";
+    /** Histogram: Model load time in ms */
+    readonly MODEL_LOAD_TIME: "omote.model.load_time";
+    /** Counter: Total inference operations */
+    readonly INFERENCE_TOTAL: "omote.inference.total";
+    /** Counter: Total errors */
+    readonly ERRORS_TOTAL: "omote.errors.total";
+    /** Counter: Cache hits */
+    readonly CACHE_HITS: "omote.cache.hits";
+    /** Counter: Cache misses */
+    readonly CACHE_MISSES: "omote.cache.misses";
+};
+/**
+ * Histogram buckets for inference latency (ms)
+ */
+declare const INFERENCE_LATENCY_BUCKETS: number[];
+/**
+ * Histogram buckets for model load time (ms)
+ */
+declare const MODEL_LOAD_TIME_BUCKETS: number[];
+
+/**
+ * Muse Telemetry
+ *
+ * Main orchestrator for SDK telemetry. Manages spans, metrics, and exporters.
+ *
+ * @category Telemetry
+ */
+
+/**
+ * Span context for tracing
+ */
+interface SpanContext {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+}
+/**
+ * Active span handle returned by startSpan
+ */
+interface ActiveSpan {
+    /** End the span with success status */
+    end(): void;
+    /** End the span with error status */
+    endWithError(error: Error): void;
+    /** Add attributes to the span */
+    setAttributes(attrs: Partial<SpanAttributes>): void;
+    /** Get the span context */
+    getContext(): SpanContext;
+}
+/**
+ * Configure global telemetry
+ *
+ * @example
+ * ```typescript
+ * // Development
+ * configureTelemetry({
+ *   enabled: true,
+ *   serviceName: 'omote-dev',
+ *   exporter: 'console',
+ * });
+ *
+ * // Production
+ * configureTelemetry({
+ *   enabled: true,
+ *   serviceName: 'omote-prod',
+ *   exporter: 'otlp',
+ *   exporterConfig: {
+ *     endpoint: 'https://tempo.example.com',
+ *   },
+ *   sampling: { ratio: 0.1 },
+ * });
+ * ```
+ */
+declare function configureTelemetry(config: TelemetryConfig): OmoteTelemetry;
+/**
+ * Get the global telemetry instance
+ */
+declare function getTelemetry(): OmoteTelemetry | null;
+/**
+ * Main telemetry class
+ *
+ * Manages spans, metrics, and exports to configured backends.
+ */
+declare class OmoteTelemetry {
+    private config;
+    private exporter;
+    private activeTraceId;
+    private metricsIntervalId;
+    private counters;
+    private histograms;
+    constructor(config: TelemetryConfig);
+    /**
+     * Initialize the configured exporter
+     */
+    private initExporter;
+    /**
+     * Start periodic metrics collection
+     */
+    private startMetricsCollection;
+    /**
+     * Check if this operation should be sampled
+     */
+    private shouldSample;
+    /**
+     * Start a new span
+     *
+     * @example
+     * ```typescript
+     * const span = telemetry.startSpan('Wav2Vec2.infer', {
+     *   'inference.input_samples': samples.length,
+     *   'model.backend': 'webgpu',
+     * });
+     *
+     * try {
+     *   const result = await doInference();
+     *   span.setAttributes({ 'inference.output_frames': result.frames });
+     *   span.end();
+     * } catch (error) {
+     *   span.endWithError(error);
+     * }
+     * ```
+     */
+    startSpan(name: string, attributes?: Partial<SpanAttributes>, parentContext?: SpanContext): ActiveSpan;
+    /**
+     * Wrap an async function with a span
+     *
+     * @example
+     * ```typescript
+     * const result = await telemetry.withSpan('Model.load', async (span) => {
+     *   const model = await loadModel();
+     *   span.setAttributes({ 'model.size_bytes': model.size });
+     *   return model;
+     * });
+     * ```
+     */
+    withSpan<T>(name: string, fn: (span: ActiveSpan) => Promise<T>, attributes?: Partial<SpanAttributes>, parentContext?: SpanContext): Promise<T>;
+    /**
+     * Increment a counter metric
+     *
+     * @example
+     * ```typescript
+     * telemetry.incrementCounter('omote.inference.total', 1, {
+     *   model: 'wav2vec2',
+     *   backend: 'webgpu',
+     *   status: 'success',
+     * });
+     * ```
+     */
+    incrementCounter(name: string, value?: number, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Record a histogram value
+     *
+     * @example
+     * ```typescript
+     * telemetry.recordHistogram('omote.inference.latency', durationMs, {
+     *   model: 'wav2vec2',
+     *   backend: 'webgpu',
+     * });
+     * ```
+     */
+    recordHistogram(name: string, value: number, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Generate unique key for metric with attributes
+     */
+    private getMetricKey;
+    /**
+     * Flush accumulated metrics to exporter
+     */
+    private flushMetrics;
+    /**
+     * Force flush all pending data
+     */
+    flush(): Promise<void>;
+    /**
+     * Shutdown telemetry
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): TelemetryConfig;
+}
+
+/**
+ * Console Exporter
+ *
+ * Exports telemetry data to the browser console for development/debugging.
+ *
+ * @category Telemetry
+ */
+
+/**
+ * Span data structure for export
+ */
+interface SpanData {
+    name: string;
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    status: 'ok' | 'error';
+    attributes: SpanAttributes;
+    error?: Error;
+}
+/**
+ * Metric data structure for export
+ */
+interface MetricData {
+    name: string;
+    type: 'counter' | 'histogram';
+    value: number;
+    attributes: Record<string, string | number | boolean>;
+    timestamp: number;
+}
+/**
+ * Exporter interface that all exporters must implement
+ */
+interface TelemetryExporterInterface {
+    /** Export a completed span */
+    exportSpan(span: SpanData): void;
+    /** Export a metric */
+    exportMetric(metric: MetricData): void;
+    /** Flush any buffered data */
+    flush(): Promise<void>;
+    /** Shutdown the exporter */
+    shutdown(): Promise<void>;
+}
+/**
+ * Console exporter for development/debugging
+ *
+ * Outputs spans and metrics to the browser console with formatting.
+ */
+declare class ConsoleExporter implements TelemetryExporterInterface {
+    private enabled;
+    private prefix;
+    constructor(options?: {
+        enabled?: boolean;
+        prefix?: string;
+    });
+    exportSpan(span: SpanData): void;
+    exportMetric(metric: MetricData): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+/**
+ * OTLP Exporter
+ *
+ * Exports telemetry data to OTLP-compatible backends (Jaeger, Tempo, etc.)
+ * using the OTLP/HTTP JSON protocol.
+ *
+ * @category Telemetry
+ */
+
+/**
+ * OTLP exporter for production telemetry
+ *
+ * Sends spans and metrics to OTLP-compatible backends like:
+ * - Jaeger
+ * - Grafana Tempo
+ * - Honeycomb
+ * - Datadog
+ * - AWS X-Ray (with collector)
+ */
+declare class OTLPExporter implements TelemetryExporterInterface {
+    private config;
+    private serviceName;
+    private serviceVersion;
+    private spanBuffer;
+    private metricBuffer;
+    private flushIntervalId;
+    private readonly BUFFER_SIZE;
+    private readonly FLUSH_INTERVAL_MS;
+    private isShutdown;
+    constructor(config: OTLPExporterConfig, serviceName?: string, serviceVersion?: string);
+    exportSpan(span: SpanData): void;
+    exportMetric(metric: MetricData): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private exportSpans;
+    private exportMetrics;
+    private sendRequest;
+}
+
+/**
+ * Animation Graph Types
+ *
+ * Renderer-agnostic animation state machine with emotion and audio-driven blending.
+ *
+ * @module animation
+ */
+/**
+ * Emotion labels for animation blending
+ * Note: These are the 8 emotion categories used for animation, separate from the
+ * internal EmotionName type used by EmotionController.
+ */
+type EmotionLabel = 'angry' | 'calm' | 'disgust' | 'fearful' | 'happy' | 'neutral' | 'sad' | 'surprised';
+/**
+ * High-level animation states
+ */
+type AnimationStateName = 'idle' | 'listening' | 'thinking' | 'speaking';
+/**
+ * Events that trigger state transitions
+ */
+type AnimationTrigger = 'user_speech_start' | 'user_speech_end' | 'transcript_ready' | 'ai_response_start' | 'ai_audio_start' | 'ai_response_end' | 'timeout' | 'interrupt';
+/**
+ * Animation layer types for blending
+ */
+type AnimationLayer = 'base' | 'emotion' | 'gesture' | 'additive';
+/**
+ * A single animation clip reference
+ */
+interface AnimationClip {
+    /** Unique identifier for the clip */
+    name: string;
+    /** Animation layer this clip belongs to */
+    layer: AnimationLayer;
+    /** Whether this clip loops */
+    loop: boolean;
+    /** Default duration in seconds (can be overridden by actual clip) */
+    duration?: number;
+}
+/**
+ * Blend weight for an animation clip
+ */
+interface BlendWeight {
+    /** Clip name */
+    clip: string;
+    /** Weight 0-1 */
+    weight: number;
+    /** Playback speed multiplier */
+    speed: number;
+    /** Current time in the animation (0-1 normalized) */
+    time: number;
+}
+/**
+ * Animation state definition
+ */
+interface AnimationState {
+    /** State name */
+    name: AnimationStateName;
+    /** Base animation clips for this state */
+    baseClips: string[];
+    /** Blend weights for base clips */
+    baseWeights: number[];
+    /** Whether emotion overlay is enabled in this state */
+    emotionBlendEnabled: boolean;
+    /** Whether gesture layer is enabled in this state */
+    gestureBlendEnabled: boolean;
+    /** Timeout in ms to auto-transition (0 = no timeout) */
+    timeout: number;
+    /** State to transition to on timeout */
+    timeoutTarget?: AnimationStateName;
+}
+/**
+ * Transition between states
+ */
+interface Transition {
+    /** Source state */
+    from: AnimationStateName;
+    /** Target state */
+    to: AnimationStateName;
+    /** Event that triggers this transition */
+    trigger: AnimationTrigger;
+    /** Blend duration in ms */
+    duration: number;
+    /** Optional condition function */
+    condition?: () => boolean;
+}
+/**
+ * Emotion to animation mapping
+ */
+interface EmotionAnimationMap {
+    /** Emotion label */
+    emotion: EmotionLabel;
+    /** Animation clip to blend */
+    clip: string;
+    /** Maximum blend weight for this emotion */
+    maxWeight: number;
+    /** Blend speed (weight change per second) */
+    blendSpeed: number;
+}
+/**
+ * Configuration for AnimationGraph
+ */
+interface AnimationGraphConfig {
+    /** Available animation states */
+    states: AnimationState[];
+    /** Transitions between states */
+    transitions: Transition[];
+    /** Emotion to animation mappings */
+    emotionMappings: EmotionAnimationMap[];
+    /** Gesture clips for audio-driven animation */
+    gestureClips: string[];
+    /** Initial state */
+    initialState: AnimationStateName;
+    /** Global blend speed for state transitions (weight/sec) */
+    transitionBlendSpeed: number;
+    /** Minimum audio energy to trigger gestures (0-1) */
+    gestureThreshold: number;
+    /** Gesture intensity multiplier */
+    gestureIntensity: number;
+}
+/**
+ * Current output of the animation graph
+ */
+interface AnimationOutput {
+    /** Current state name */
+    state: AnimationStateName;
+    /** All blend weights to apply */
+    blendWeights: BlendWeight[];
+    /** Active emotion (if any) */
+    activeEmotion: EmotionLabel | null;
+    /** Current gesture intensity (0-1) */
+    gestureIntensity: number;
+    /** Whether currently transitioning between states */
+    isTransitioning: boolean;
+    /** Transition progress (0-1) if transitioning */
+    transitionProgress: number;
+}
+/**
+ * Events emitted by AnimationGraph
+ */
+type AnimationGraphEvents = {
+    /** State changed */
+    'state.change': {
+        from: AnimationStateName;
+        to: AnimationStateName;
+        trigger: AnimationTrigger;
+    };
+    /** Transition started */
+    'transition.start': {
+        from: AnimationStateName;
+        to: AnimationStateName;
+        duration: number;
+    };
+    /** Transition completed */
+    'transition.end': {
+        state: AnimationStateName;
+    };
+    /** Emotion changed */
+    'emotion.change': {
+        emotion: EmotionLabel | null;
+        confidence: number;
+    };
+    /** Animation output updated (every frame) */
+    'output.update': AnimationOutput;
+    /** Index signature for EventEmitter compatibility */
+    [key: string]: unknown;
+};
+/**
+ * Default animation graph configuration
+ */
+declare const DEFAULT_ANIMATION_CONFIG: AnimationGraphConfig;
+
+/**
+ * Animation Graph
+ *
+ * State machine for character animation with emotion and audio-driven blending.
+ * Renderer-agnostic - outputs blend weights that any 3D engine can consume.
+ *
+ * @example
+ * ```typescript
+ * import { AnimationGraph, DEFAULT_ANIMATION_CONFIG } from '@omote/core';
+ *
+ * const graph = new AnimationGraph(DEFAULT_ANIMATION_CONFIG);
+ *
+ * // Connect to voice pipeline
+ * graph.on('output.update', (output) => {
+ *   // Apply blend weights to your 3D character
+ *   for (const { clip, weight } of output.blendWeights) {
+ *     mixer.getAction(clip).setEffectiveWeight(weight);
+ *   }
+ * });
+ *
+ * // Drive from voice state
+ * voiceState.on('listening', () => graph.trigger('user_speech_start'));
+ * voiceState.on('thinking', () => graph.trigger('transcript_ready'));
+ * voiceState.on('speaking', () => graph.trigger('ai_audio_start'));
+ *
+ * // Drive from emotion detection
+ * emotion.on('result', ({ emotion, confidence }) => {
+ *   graph.setEmotion(emotion, confidence);
+ * });
+ *
+ * // Update every frame
+ * function animate(deltaTime: number) {
+ *   graph.update(deltaTime);
+ * }
+ * ```
+ *
+ * @module animation
+ */
+
+/**
+ * Animation state machine with smooth blending
+ */
+declare class AnimationGraph extends EventEmitter<AnimationGraphEvents> {
+    private config;
+    private currentState;
+    private previousState;
+    private isTransitioning;
+    private transitionProgress;
+    private transitionDuration;
+    private transitionStartTime;
+    private currentEmotion;
+    private emotionConfidence;
+    private emotionBlendWeight;
+    private targetEmotionWeight;
+    private audioEnergy;
+    private gestureWeight;
+    private currentGestureClip;
+    private stateEnterTime;
+    private lastUpdateTime;
+    private cachedOutput;
+    constructor(config?: Partial<AnimationGraphConfig>);
+    /**
+     * Get current state name
+     */
+    get state(): AnimationStateName;
+    /**
+     * Get current animation output
+     */
+    get output(): AnimationOutput;
+    /**
+     * Trigger an animation event (may cause state transition)
+     */
+    trigger(event: AnimationTrigger): boolean;
+    /**
+     * Set current emotion (from DistilHuBERT or manual)
+     */
+    setEmotion(emotion: EmotionLabel, confidence: number): void;
+    /**
+     * Clear current emotion
+     */
+    clearEmotion(): void;
+    /**
+     * Set audio energy for gesture animation (0-1)
+     */
+    setAudioEnergy(energy: number): void;
+    /**
+     * Force transition to a specific state
+     */
+    setState(stateName: AnimationStateName, blendDuration?: number): void;
+    /**
+     * Update animation graph (call every frame)
+     * @param deltaMs Time since last update in milliseconds
+     */
+    update(deltaMs?: number): AnimationOutput;
+    /**
+     * Reset to initial state
+     */
+    reset(): void;
+    /**
+     * Get all clip names used by this graph
+     */
+    getRequiredClips(): string[];
+    private startTransition;
+    private updateTransition;
+    private checkTimeout;
+    private updateEmotionBlend;
+    private updateGesture;
+    private computeOutput;
+}
+
+/**
+ * Audio Energy Analysis
+ *
+ * Utilities for extracting energy/loudness from audio for gesture animation.
+ *
+ * @module animation
+ */
+/**
+ * Calculate RMS (Root Mean Square) energy from audio samples
+ * @param samples Audio samples (Float32Array, normalized -1 to 1)
+ * @returns RMS energy value (0 to 1)
+ */
+declare function calculateRMS(samples: Float32Array): number;
+/**
+ * Calculate peak amplitude from audio samples
+ * @param samples Audio samples (Float32Array, normalized -1 to 1)
+ * @returns Peak amplitude (0 to 1)
+ */
+declare function calculatePeak(samples: Float32Array): number;
+/**
+ * Smoothed energy analyzer for gesture animation
+ */
+declare class AudioEnergyAnalyzer {
+    private smoothedRMS;
+    private smoothedPeak;
+    private readonly smoothingFactor;
+    private readonly noiseFloor;
+    /**
+     * @param smoothingFactor How much to smooth (0 = no smoothing, 1 = infinite smoothing). Default 0.85
+     * @param noiseFloor Minimum energy threshold to consider as signal. Default 0.01
+     */
+    constructor(smoothingFactor?: number, noiseFloor?: number);
+    /**
+     * Process audio samples and return smoothed energy values
+     * @param samples Audio samples (Float32Array)
+     * @returns Object with rms and peak values
+     */
+    process(samples: Float32Array): {
+        rms: number;
+        peak: number;
+        energy: number;
+    };
+    /**
+     * Reset analyzer state
+     */
+    reset(): void;
+    /**
+     * Get current smoothed RMS value
+     */
+    get rms(): number;
+    /**
+     * Get current smoothed peak value
+     */
+    get peak(): number;
+}
+/**
+ * Extract emphasis points from audio (for gesture timing)
+ *
+ * Detects sudden increases in energy that correspond to speech emphasis.
+ */
+declare class EmphasisDetector {
+    private energyHistory;
+    private readonly historySize;
+    private readonly emphasisThreshold;
+    /**
+     * @param historySize Number of frames to track. Default 10
+     * @param emphasisThreshold Minimum energy increase to count as emphasis. Default 0.15
+     */
+    constructor(historySize?: number, emphasisThreshold?: number);
+    /**
+     * Process energy value and detect emphasis
+     * @param energy Current energy value (0-1)
+     * @returns Object with isEmphasis flag and emphasisStrength
+     */
+    process(energy: number): {
+        isEmphasis: boolean;
+        emphasisStrength: number;
+    };
+    /**
+     * Reset detector state
+     */
+    reset(): void;
+}
+
+export { type AIAdapter, type AIAdapterEvents, type AISessionState, type ActiveSpan, AgentCoreAdapter, type AgentCoreConfig, type AnimationClip, type AnimationEvent, AnimationGraph, type AnimationGraphConfig, type AnimationGraphEvents, type AnimationLayer, type AnimationOutput, type AnimationState, type AnimationStateName, type AnimationTrigger, AudioChunkCoalescer, type AudioChunkCoalescerOptions, AudioEnergyAnalyzer, AudioScheduler, type AudioSchedulerOptions, type AudioSyncConfig, type AudioSyncEvents, AudioSyncManager, type BackendEvent, type BackendPreference, type BlendWeight, CTC_VOCAB, type CacheConfig, type CacheSpanAttributes, ConsoleExporter, type ConversationMessage, ConversationOrchestrator, type ConversationSession, DEFAULT_ANIMATION_CONFIG, DEFAULT_LOGGING_CONFIG, EMOTION_NAMES, EMOTION_VECTOR_SIZE, type EmotionAnimationMap, EmotionController, type EmotionEvent, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, type EmotionWeights, EmphasisDetector, EventEmitter, type FetchWithCacheOptions, type GazeEvent, HF_CDN_TEST_URL, type HuggingFaceUrlInfo, type ILogger, INFERENCE_LATENCY_BUCKETS, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, type LAMFrame, LAMPipeline, type LAMPipelineOptions, LAM_BLENDSHAPES, LOG_LEVEL_PRIORITY, type LogEntry, type LogFormatter, type LogLevel, type LogSink, type LoggingConfig, MODEL_LOAD_TIME_BUCKETS, type MessageRole, type MetricData, MetricNames, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, OTLPExporter, type OTLPExporterConfig, type OmoteEvents, OmoteTelemetry, type OrchestratorConfig, type OrchestratorEvents, type QuotaInfo, RingBuffer, type RuntimeBackend, type STTFinalEvent, type STTPartialEvent, type SafariSpeechConfig, SafariSpeechRecognition, type SamplingConfig, type SessionConfig, type SessionOptions, type SessionSnapshot, type SessionStateEvent, type SileroVADBackend, type SileroVADConfig, type SileroVADFactoryConfig, SileroVADInference, SileroVADWorker, type SpanAttributes, type SpanData, type SpeechErrorCallback, type SpeechRecognitionResult, type SpeechResultCallback, type SpeechSegment, SyncedAudioPipeline, type SyncedAudioPipelineEvents, type SyncedAudioPipelineOptions, type TTSEndEvent, type TTSMarkEvent, type TTSStartEvent, type TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TenantConfig, TenantManager, type TenantQuota, type TenantUsage, type TokenRefreshCallback, type TranscriptionResult, type Transition, type VADBackend, type VADModelInfo, type VADResult$1 as VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type VisemeEvent, type VoiceConfig, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, type WhisperConfig, WhisperInference, type WhisperModel, blendEmotions, calculatePeak, calculateRMS, clearSpecificCache, clearTransformersCache, configureCacheLimit, configureLogging, configureTelemetry, createEmotionVector, createLogger, createSessionWithFallback, createSileroVAD, fetchWithCache, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getLoadedBackend, getLoggingConfig, getModelCache, getOnnxRuntime, getOnnxRuntimeForPreference, getOptimalWasmThreads, getRecommendedBackend, getSessionOptions, getTelemetry, hasWebGPUApi, isAndroid, isHuggingFaceCDNReachable, isIOS, isIOSSafari, isMobile, isOnnxRuntimeLoaded, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpEmotion, listCaches, noopLogger, nukeBrowserCaches, parseHuggingFaceUrl, preloadModels, resetLoggingConfig, resolveBackend, scanForInvalidCaches, setLogLevel, setLoggingEnabled, shouldEnableWasmProxy, shouldUseNativeASR, shouldUseServerLipSync, supportsVADWorker, validateCachedResponse };