@omote/core 0.7.1 → 0.9.2

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter, OmoteEvents } from './events/index.js';
 export { AnimationEvent, BackendEvent, EmotionEvent, GazeEvent, STTFinalEvent, STTPartialEvent, SessionStateEvent, TTSEndEvent, TTSMarkEvent, TTSStartEvent, VisemeEvent } from './events/index.js';
-export { D as DEFAULT_LOGGING_CONFIG, I as ILogger, a as LOG_LEVEL_PRIORITY, b as LogEntry, L as LogFormatter, c as LogLevel, d as LogSink, e as LoggingConfig, g as configureLogging, h as createLogger, i as getLoggingConfig, n as noopLogger, r as resetLoggingConfig, s as setLogLevel, k as setLoggingEnabled } from './Logger-DSoGAYJu.js';
+export { C as Clock, D as DEFAULT_LOGGING_CONFIG, E as ErrorCode, a as ErrorCodes, I as ILogger, b as LOG_LEVEL_PRIORITY, c as LogEntry, L as LogFormatter, d as LogLevel, e as LogSink, f as LoggingConfig, h as configureClock, i as configureLogging, j as createLogger, l as getClock, m as getLoggingConfig, o as noopLogger, r as resetLoggingConfig, s as setLogLevel, p as setLoggingEnabled } from './ErrorCodes-AX3ADZri.js';
 export { ARKitToFLAMEMapping, ApiError, AudioChunkEvent, AvatarFormat, Character, CharacterAvatar, CharacterMemory, CharacterPersonality, CharacterSpec, CharacterVoice, CreateCharacterRequest, CreateCharacterResponse, CreateLAMJobRequest, CreateLAMJobResponse, CreateSessionRequest, CreateSessionResponse, GSplatConfig, LAMJob, LAMJobStatus, PROTOCOL_VERSION, PaginatedResponse, PlatformSession, ErrorEvent as ProtocolErrorEvent, ProtocolEvent, ResponseChunkEvent, ResponseEndEvent, ResponseStartEvent, SessionMessage, SessionStatus, isProtocolEvent } from '@omote/types';
 
 /**
@@ -163,6 +163,8 @@ interface AudioSchedulerOptions {
      * Default: 0.05 (50ms) for WebGPU, increase to 0.3-0.5 for WASM on iOS.
      */
     initialLookaheadSec?: number;
+    /** Error callback for critical scheduling issues */
+    onError?: (error: Error) => void;
 }
 declare class AudioScheduler {
     private readonly options;
@@ -171,6 +173,8 @@ declare class AudioScheduler {
     private scheduledSources;
     private isPlaying;
     constructor(options?: AudioSchedulerOptions);
+    /** Configured sample rate (default: 16000). */
+    get sampleRate(): number;
     /**
      * Initialize AudioContext with specified sample rate
      *
@@ -429,19 +433,6 @@ declare function shouldEnableWasmProxy(): boolean;
  * @returns true if running in Safari on any platform
  */
 declare function isSafari(): boolean;
-/**
- * Recommend using CPU-optimized A2E model (wav2arkit_cpu)
- *
- * All iOS browsers use WebKit and have tight memory limits — the 192MB fp16
- * LAM model causes silent crashes. wav2arkit_cpu uses URL pass-through
- * (ORT fetches the 402MB weights directly into WASM, no JS heap copy).
- *
- * macOS Safari also needs this due to ONNX Runtime JSEP/ASYNCIFY bugs
- * that crash WebKit's JIT compiler.
- *
- * @returns true if iOS (any browser) or Safari (any platform)
- */
-declare function shouldUseCpuA2E(): boolean;
 /**
  * Check if Web Speech API is available in the browser
  *
@@ -479,9 +470,8 @@ declare function shouldUseServerA2E(): boolean;
 /**
  * Common interface for audio-to-expression (A2E) inference backends
  *
- * Both Wav2Vec2Inference (GPU, 192MB fp16) and Wav2ArkitCpuInference (CPU, 404MB)
- * implement this interface, allowing FullFacePipeline and A2EProcessor to
- * work with either model transparently.
+ * Implemented by A2EInference and A2EUnifiedAdapter, allowing PlaybackPipeline
+ * and A2EProcessor to work with either implementation transparently.
  *
  * @category Inference
  */
@@ -510,15 +500,22 @@ interface A2EResult {
     inferenceTimeMs: number;
 }
 /**
- * Common interface for A2E (audio-to-expression) inference engines
+ * Common interface for A2E (audio-to-expression) inference engines.
+ *
+ * A2E is the SDK term for audio-to-expression inference. The underlying model
+ * is called **LAM** (Large Animation Model). "A2E" and "LAM" refer to the same
+ * pipeline — A2E is the interface abstraction, LAM is the model.
  *
  * Implemented by:
- * - Wav2Vec2Inference (WebGPU/WASM, 192MB fp16, A2E)
- * - Wav2ArkitCpuInference (WASM-only, 404MB, A2E only)
+ * - {@link A2EInference} (WebGPU/WASM, 192MB fp16)
+ * - A2EUnifiedAdapter (shared unified worker)
+ *
+ * @see {@link A2EInference} for direct usage
+ * @see {@link createA2E} for the recommended factory API
  */
 interface A2EBackend {
-    /** Model identifier for backend-specific tuning (e.g. audio delay) */
-    readonly modelId: 'wav2vec2' | 'wav2arkit_cpu';
+    /** Model identifier */
+    readonly modelId: 'a2e';
     /** Current backend type (webgpu, wasm, or null if not loaded) */
     readonly backend: RuntimeBackend | null;
     /** Whether the model is loaded and ready for inference */
@@ -590,7 +587,7 @@ declare const BLENDSHAPE_TO_GROUP: Map<string, BlendshapeGroup>;
  * 2. Otherwise, use the group scaler (default 1.0)
  * 3. Clamp result to [0, 1]
  */
-declare function applyProfile(raw: Float32Array, profile: ExpressionProfile): Float32Array;
+declare function applyProfile(raw: Float32Array, profile: ExpressionProfile, out?: Float32Array): Float32Array;
 
 /**
  * PlaybackPipeline - Audio playback + A2E lip sync with ExpressionProfile scaling
@@ -616,7 +613,7 @@ interface PlaybackPipelineConfig {
     audioDelayMs?: number;
     /** A2E inference chunk size in samples (default: 16000) */
     chunkSize?: number;
-    /** Identity/style index for Wav2Vec2 (default: 0) */
+    /** Identity/style index for A2E model (default: 0) */
     identityIndex?: number;
     /** Per-character expression weight scaling */
     profile?: ExpressionProfile;
@@ -637,6 +634,8 @@ interface FullFaceFrame {
     rawBlendshapes: Float32Array;
     /** AudioContext timestamp for this frame */
     timestamp: number;
+    /** Emotion label for this frame (from SenseVoice, text heuristics, or LLM tags) */
+    emotion?: string;
 }
 interface PlaybackPipelineEvents {
     /** New frame ready for display (scaled by ExpressionProfile) */
@@ -655,10 +654,6 @@ interface PlaybackPipelineEvents {
     'error': Error;
     /** State changed */
     'state': PlaybackState;
-    'full_frame_ready': FullFaceFrame;
-    'lam_frame_ready': Float32Array;
-    'playback_complete': void;
-    'playback_start': number;
     [key: string]: unknown;
 }
 declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
@@ -676,6 +671,7 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
     private staleWarningEmitted;
     private readonly staleThresholdMs;
     private frameLoopCount;
+    private sessionStartTime;
     private profile;
     private readonly neutralTransitionEnabled;
     private readonly neutralTransitionMs;
@@ -684,6 +680,8 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
     private neutralAnimationId;
     private _currentFrame;
     private _currentRawFrame;
+    private _emotion;
+    private readonly _profileBuffer;
     /** Current pipeline state */
     get state(): PlaybackState;
     /** Current scaled blendshapes (updated in-place for perf) */
@@ -695,6 +693,8 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
     initialize(): Promise<void>;
     /** Update ExpressionProfile at runtime */
     setProfile(profile: ExpressionProfile): void;
+    /** Set the emotion label to include in emitted frames */
+    setEmotion(emotion: string | null): void;
     /**
      * Start a new playback session.
      * Idempotent — calling during playback resets cleanly without emitting
@@ -733,201 +733,6 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
     private setState;
 }
 
-/**
- * FullFacePipeline - A2E expression pipeline with ExpressionProfile weight scaling
- *
- * Orchestrates full-face animation by:
- * 1. Scheduling audio for playback immediately (audio-first, never waits for A2E)
- * 2. Running A2E inference in background (fire-and-forget via A2EProcessor)
- * 3. Applying per-character ExpressionProfile scaling to raw A2E output
- *
- * The A2E model outputs all 52 ARKit blendshapes from audio — brows, eyes, cheeks,
- * mouth, jaw, everything. ExpressionProfile allows per-character weight scaling
- * by group (eyes, brows, jaw, mouth, cheeks, nose, tongue) with per-blendshape overrides.
- *
- * @deprecated Use {@link PlaybackPipeline} from `@omote/core` instead. PlaybackPipeline
- * is a superset with sync mode (`feedBuffer`), state tracking, and opt-in neutral transition.
- * FullFacePipeline will continue to work but is no longer actively developed.
- *
- * @category Audio
- *
- * @example Basic usage
- * ```typescript
- * import { FullFacePipeline } from '@omote/core';
- *
- * const pipeline = new FullFacePipeline({
- *   lam,
- *   profile: { mouth: 1.2, brows: 0.8 },
- * });
- * await pipeline.initialize();
- *
- * pipeline.on('full_frame_ready', (frame) => {
- *   applyToAvatar(frame.blendshapes);
- * });
- *
- * pipeline.start();
- * await pipeline.onAudioChunk(audioData);
- * ```
- */
-
-/**
- * Configuration for FullFacePipeline
- */
-interface FullFacePipelineOptions {
-    /** Sample rate in Hz (default: 16000) */
-    sampleRate?: number;
-    /** Target chunk duration in ms for coalescing (default: 200) */
-    chunkTargetMs?: number;
-    /**
-     * Audio playback delay in ms before first audio plays.
-     * Gives A2E inference time to pre-compute blendshapes before audio
-     * starts, preventing frame drops/desync. Must be ≥ chunkSize
-     * accumulation time + inference latency.
-     *
-     * Default: auto-calculated from chunkSize and backend type.
-     */
-    audioDelayMs?: number;
-    /**
-     * A2E inference chunk size in samples.
-     * Controls how many samples accumulate before each inference call.
-     * Smaller = lower latency (less delay before first frame), more overhead.
-     * Larger = higher latency, less overhead.
-     *
-     * Default: 16000 (1s) — the model's native window size.
-     * Smaller chunks get zero-padded, causing near-zero blendshape output.
-     */
-    chunkSize?: number;
-    /** A2E inference engine */
-    lam: A2EBackend;
-    /**
-     * Identity/style index for the A2E model (default: 0).
-     *
-     * The LAM model uses a 12-class one-hot identity vector as style conditioning.
-     * Different indices produce different expression intensity across face regions.
-     * Only affects Wav2Vec2Inference (GPU). Wav2ArkitCpuInference has identity 11 baked in.
-     */
-    identityIndex?: number;
-    /** Per-character expression weight scaling */
-    profile?: ExpressionProfile;
-    /**
-     * Time in ms with no new inference frames before logging a stale warning.
-     *
-     * Must be larger than the inter-batch gap (chunkSize/sampleRate + inference time).
-     * Default: 2000
-     */
-    staleThresholdMs?: number;
-}
-/**
- * Events emitted by FullFacePipeline
- */
-interface FullFacePipelineEvents {
-    /** New merged frame ready for display */
-    full_frame_ready: FullFaceFrame;
-    /** Raw LAM frame ready (for debugging/monitoring) */
-    lam_frame_ready: Float32Array;
-    /** Playback has completed */
-    playback_complete: void;
-    /** First frame ready, playback starting */
-    playback_start: number;
-    /** Error occurred */
-    error: Error;
-    /** Index signature for EventEmitter compatibility */
-    [key: string]: unknown;
-}
-/**
- * FullFacePipeline - A2E animation pipeline with ExpressionProfile scaling
- *
- * Audio-first design matching SyncedAudioPipeline:
- * - Audio is scheduled immediately (never waits for A2E)
- * - A2E runs in background (fire-and-forget via A2EProcessor)
- * - ExpressionProfile scales raw A2E output per-character
- */
-declare class FullFacePipeline extends EventEmitter<FullFacePipelineEvents> {
-    private readonly options;
-    private scheduler;
-    private coalescer;
-    private processor;
-    private playbackStarted;
-    private monitorInterval;
-    private frameAnimationId;
-    private lastNewFrameTime;
-    private lastKnownLamFrame;
-    private staleWarningEmitted;
-    private readonly staleThresholdMs;
-    private frameLoopCount;
-    private profile;
-    constructor(options: FullFacePipelineOptions);
-    /**
-     * Initialize the pipeline
-     */
-    initialize(): Promise<void>;
-    /**
-     * Update the ExpressionProfile at runtime (e.g., character switch).
-     */
-    setProfile(profile: ExpressionProfile): void;
-    /**
-     * Apply ExpressionProfile scaling to raw A2E blendshapes.
-     *
-     * Delegates to the standalone applyProfile() utility from expressionProfile.ts.
-     */
-    applyProfile(raw: Float32Array): Float32Array;
-    /**
-     * Start a new playback session
-     *
-     * Resets all state and prepares for incoming audio chunks.
-     * Audio will be scheduled immediately as chunks arrive (no buffering).
-     */
-    start(): void;
-    /**
-     * Receive audio chunk from network
-     *
-     * Audio-first design: schedules audio immediately, A2E runs in background.
-     * This prevents A2E inference (50-300ms) from blocking audio scheduling.
-     *
-     * @param chunk - Uint8Array containing Int16 PCM audio
-     */
-    onAudioChunk(chunk: Uint8Array): Promise<void>;
-    /**
-     * Start frame animation loop
-     *
-     * Polls A2EProcessor at render rate (60fps) for the latest inference frame
-     * matching the current AudioContext time. Between inference batches (~30fps
-     * bursts), getFrameForTime() holds the last frame.
-     */
-    private startFrameLoop;
-    /**
-     * End of audio stream
-     */
-    end(): Promise<void>;
-    /**
-     * Stop playback immediately with smooth fade-out
-     */
-    stop(fadeOutMs?: number): Promise<void>;
-    /**
-     * Start monitoring for playback completion
-     */
-    private startMonitoring;
-    /**
-     * Stop monitoring
-     */
-    private stopMonitoring;
-    /**
-     * Get current pipeline state (for debugging/monitoring)
-     */
-    getState(): {
-        playbackStarted: boolean;
-        coalescerFill: number;
-        processorFill: number;
-        queuedFrames: number;
-        currentTime: number;
-        playbackEndTime: number;
-    };
-    /**
-     * Cleanup resources
-     */
-    dispose(): void;
-}
-
 /**
  * TTSBackend — Streaming text-to-speech backend interface.
  *
@@ -1007,7 +812,7 @@ interface TTSPlaybackConfig {
     profile?: ExpressionProfile;
     /** Prefetch next sentence while current plays. Default: true */
     prefetch?: boolean;
-    /** Identity/style index for Wav2Vec2 (default: 0) */
+    /** Identity/style index for A2E model (default: 0) */
     identityIndex?: number;
     /** Audio playback delay in ms */
     audioDelayMs?: number;
@@ -1027,6 +832,8 @@ interface TTSPlaybackEvents {
     };
     /** Playback completed */
     'playback:complete': void;
+    /** Playback stopped (user-initiated) */
+    'playback:stop': void;
     /** Error */
     'error': Error;
     [key: string]: unknown;
@@ -1056,87 +863,6 @@ declare class TTSPlayback extends EventEmitter<TTSPlaybackEvents> {
     private speakSequential;
 }
 
-/**
- * Interruption Handler
- *
- * VAD-based barge-in detection for AI conversations:
- * - Monitors VAD probability for user speech
- * - Detects when user interrupts AI response
- * - Triggers interruption callbacks
- */
-
-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;
-}
-declare class InterruptionHandler extends EventEmitter<InterruptionEvents> {
-    private config;
-    private isSpeaking;
-    private speechStartTime;
-    private lastSpeechTime;
-    private silenceTimer;
-    private aiIsSpeaking;
-    private interruptionTriggeredThisSession;
-    constructor(config?: InterruptionConfig);
-    /**
-     * Process raw audio energy for interruption detection (no VAD required).
-     * Used during speaking state when the unified worker is busy with TTS.
-     * Echo-cancelled mic input means energy above threshold = user speech.
-     *
-     * @param rms - RMS energy of audio chunk (0-1)
-     * @param energyThreshold - Minimum energy to consider speech (default: 0.02)
-     */
-    processAudioEnergy(rms: number, energyThreshold?: number): void;
-    /**
-     * 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;
-    /** Notify that AI started/stopped 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 onSpeechDetected;
-    private onSilenceDetected;
-}
-
 /**
  * Lazy ONNX Runtime loader with conditional WebGPU/WASM bundle loading
  *
@@ -1240,6 +966,8 @@ declare class SenseVoiceInference {
     private inferenceQueue;
     private poisoned;
     private static readonly INFERENCE_TIMEOUT_MS;
+    private lastLfrFrames;
+    private webgpuShapeWarned;
     private tokenMap;
     private negMean;
     private invStddev;
@@ -1261,157 +989,47 @@ declare class SenseVoiceInference {
 }
 
 /**
- * SenseVoice ASR Web Worker implementation
+ * Silero VAD (Voice Activity Detection) inference
  *
- * Runs SenseVoice speech recognition in a dedicated Web Worker to prevent
- * main thread blocking. Uses inline worker script (Blob URL pattern) to
- * avoid separate file deployment.
+ * Neural network-based VAD running in browser via ONNX Runtime Web.
+ * Much more accurate than RMS-based energy detection.
  *
- * Key design decisions:
- * - WASM backend only (WebGPU doesn't work in Workers)
- * - All preprocessing (fbank, LFR, CMVN) and CTC decoding inlined in worker
- * - Audio copied (not transferred) to retain main thread access
- * - ONNX Runtime loaded from CDN in worker (no bundler complications)
- * - iOS: model URL passed as string to ORT (avoids 239MB JS heap allocation)
+ * 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 { SenseVoiceWorker } from '@omote/core';
+ * import { SileroVADInference } from '@omote/core';
  *
- * const asr = new SenseVoiceWorker({
- *   modelUrl: '/models/sensevoice/model.int8.onnx',
- *   tokensUrl: '/models/sensevoice/tokens.txt',
+ * const vad = new SileroVADInference({
+ *   modelUrl: '/models/silero-vad.onnx'
  * });
- * await asr.load();
+ * await vad.load();
  *
- * const { text, emotion, language } = await asr.transcribe(audioSamples);
- * console.log(text);       // "Hello world"
- * console.log(emotion);    // "NEUTRAL"
- * console.log(language);   // "en"
+ * // 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]
+ * }
  * ```
  */
 
-/**
- * Configuration for SenseVoice Worker
- */
-interface SenseVoiceWorkerConfig {
-    /** Path or URL to model.int8.onnx (239MB) */
-    modelUrl: string;
-    /** Path or URL to tokens.txt vocabulary file (default: sibling of modelUrl) */
-    tokensUrl?: string;
-    /** Language hint (default: 'auto' for auto-detection) */
-    language?: SenseVoiceLanguage;
-    /** Text normalization: 'with_itn' applies inverse text normalization (default: 'with_itn') */
-    textNorm?: 'with_itn' | 'without_itn';
-}
-/**
- * SenseVoice ASR Worker - Speech Recognition in a Web Worker
- *
- * Runs SenseVoice inference off the main thread to prevent UI blocking.
- * All preprocessing (fbank, LFR, CMVN) and CTC decoding run in the worker.
- *
- * @see SenseVoiceInference for main-thread version
- */
-declare class SenseVoiceWorker {
-    private worker;
-    private config;
-    private isLoading;
-    private _isLoaded;
-    private inferenceQueue;
-    private poisoned;
-    private pendingResolvers;
-    private languageId;
-    private textNormId;
-    constructor(config: SenseVoiceWorkerConfig);
-    get isLoaded(): boolean;
-    /**
-     * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
-     */
-    get backend(): 'wasm' | null;
-    /**
-     * 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
-     *
-     * @param onProgress - Optional progress callback. Fires once at 100% when load completes
-     *   (the worker downloads and loads the model internally, so granular progress is not available).
-     */
-    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
-    /**
-     * Transcribe audio samples to text
-     *
-     * @param audioSamples Float32Array of audio samples at 16kHz, [-1, 1] range
-     * @returns Transcription result with text, emotion, language, and event
-     */
-    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
-    /**
-     * 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;
-}
-
-/**
- * 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;
+type VADBackend = BackendPreference;
 /**
  * Configuration for Silero VAD
  */
@@ -1705,15 +1323,16 @@ declare class SileroVADWorker {
 }
 
 /**
- * Unified Inference Worker — single Web Worker hosting all WASM models
+ * Unified Inference Worker — single Web Worker hosting all ONNX models
  *
- * Solves the multi-worker ORT problem: three per-model workers each load their
- * own ORT WASM instance (~40MB each). On iOS this exceeds the ~1-1.5GB tab
- * limit, forcing main-thread fallback which blocks the render loop.
+ * Runs all model loading and inference off the main thread, preventing
+ * InferenceSession.create() from blocking the renderer (5-30s).
  *
- * This worker hosts SenseVoice + Wav2ArkitCpu + Silero VAD in a single
- * ORT WASM instance. Same total model memory (~643MB), but inference runs
- * off-main-thread. Works on iOS because there's only one ORT instance.
+ * Uses WebGPU when available (Chrome/Edge 113+), falls back to WASM.
+ * On iOS, uses a single WASM instance to stay within the ~1-1.5GB tab limit.
+ *
+ * This worker hosts SenseVoice + A2E + Silero VAD + Kokoro TTS in a single
+ * ORT instance. Same total model memory, but inference runs off-main-thread.
  *
  * Consumer usage:
  * ```typescript
@@ -1721,7 +1340,7 @@ declare class SileroVADWorker {
  * await worker.init();
  *
  * const asr = createSenseVoice({ modelUrl: '...', unifiedWorker: worker });
- * const lam = createA2E({ gpuModelUrl: '...', cpuModelUrl: '...', unifiedWorker: worker });
+ * const lam = createA2E({ modelUrl: '...', unifiedWorker: worker });
  * const vad = createSileroVAD({ modelUrl: '...', unifiedWorker: worker });
  * ```
  *
@@ -1731,10 +1350,11 @@ declare class SileroVADWorker {
 /** Health state of the unified worker */
 type WorkerHealthState = 'healthy' | 'unhealthy' | 'recovering';
 /**
- * Unified Inference Worker — single Web Worker for all WASM models
+ * Unified Inference Worker — single Web Worker for all ONNX models
  *
- * Hosts SenseVoice, Wav2ArkitCpu, and Silero VAD in one ORT instance.
- * Eliminates the multi-worker memory problem on iOS.
+ * Hosts SenseVoice, A2E (LAM), Kokoro TTS, and Silero VAD in one ORT instance.
+ * Uses WebGPU on Chrome/Edge 113+, falls back to WASM on Safari/iOS/Firefox.
+ * All model loading and inference runs off the main thread.
  */
 declare class UnifiedInferenceWorker {
     private worker;
@@ -1744,6 +1364,7 @@ declare class UnifiedInferenceWorker {
     private consecutiveFailures;
     private _generation;
     private recovering;
+    private _workerBackend;
     /**
      * Initialize the worker (load ORT WASM from CDN)
      */
@@ -1756,17 +1377,6 @@ declare class UnifiedInferenceWorker {
     }): Promise<SenseVoiceModelInfo>;
     transcribe(audio: Float32Array): Promise<SenseVoiceResult>;
     disposeSenseVoice(): Promise<void>;
-    loadA2E(config: {
-        modelUrl: string;
-        externalDataUrl: string | null;
-    }): Promise<A2EModelInfo>;
-    inferA2E(audio: Float32Array): Promise<{
-        blendshapes: Float32Array;
-        numFrames: number;
-        numBlendshapes: number;
-        inferenceTimeMs: number;
-    }>;
-    disposeA2E(): Promise<void>;
     loadLAM(config: {
         modelUrl: string;
         externalDataUrl: string | null;
@@ -1807,6 +1417,8 @@ declare class UnifiedInferenceWorker {
     get health(): WorkerHealthState;
     /** Generation counter — increments on worker recovery. Adapters compare to detect stale sessions. */
     get workerGeneration(): number;
+    /** The ORT backend the worker is using ('webgpu' on Chrome/Edge, 'wasm' on Safari/iOS/Firefox) */
+    get backend(): 'wasm' | 'webgpu';
     /** Check if Web Workers are supported */
     static isSupported(): boolean;
     private assertReady;
@@ -1852,143 +1464,865 @@ interface InferenceFactoryConfig {
 }
 
 /**
- * Factory function for SenseVoice ASR with automatic Worker vs main thread selection
+ * Factory function for A2E inference
  *
- * Provides a unified API that automatically selects the optimal implementation:
- * - Worker supported: Uses SenseVoiceWorker (off-main-thread inference)
- * - Worker unsupported: Uses SenseVoiceInference (main thread)
+ * Creates an A2EBackend instance with zero-config defaults (HuggingFace CDN).
+ * Supports unified worker mode for iOS off-main-thread inference.
  *
  * @category Inference
  *
- * @example Auto-detect (recommended)
+ * @example Auto-detect (recommended, zero-config)
  * ```typescript
- * import { createSenseVoice } from '@omote/core';
- *
- * const asr = createSenseVoice({
- *   modelUrl: '/models/sensevoice/model.int8.onnx',
- * });
- * await asr.load();
- * const { text, emotion } = await asr.transcribe(audioSamples);
- * ```
+ * import { createA2E } from '@omote/core';
  *
- * @example Force worker
- * ```typescript
- * const asr = createSenseVoice({
- *   modelUrl: '/models/sensevoice/model.int8.onnx',
- *   useWorker: true,
- * });
+ * const a2e = createA2E(); // uses HF CDN defaults (192MB fp16)
+ * await a2e.load();
+ * const { blendshapes } = await a2e.infer(audioSamples);
  * ```
  *
- * @example Force main thread
+ * @example Custom model URL
  * ```typescript
- * const asr = createSenseVoice({
- *   modelUrl: '/models/sensevoice/model.int8.onnx',
- *   useWorker: false,
- * });
+ * const a2e = createA2E({ modelUrl: '/models/lam.onnx' });
  * ```
  */
 
 /**
- * Common interface for both SenseVoiceInference and SenseVoiceWorker
+ * Configuration for the A2E factory
  */
-interface SenseVoiceBackend {
-    /** Whether the model is loaded and ready for inference */
-    readonly isLoaded: boolean;
-    /** Current backend type ('wasm' for worker, full backend for main thread, null if not loaded) */
-    readonly backend: 'wasm' | 'webgpu' | null;
-    /**
-     * Load the ONNX model
-     * @param onProgress - Optional progress callback (fires once at 100% for worker)
-     * @returns Model loading information
-     */
-    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
-    /**
-     * Transcribe audio samples to text
-     * @param audioSamples - Float32Array of audio samples at 16kHz
-     * @returns Transcription result
-     */
-    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
+interface CreateA2EConfig extends InferenceFactoryConfig {
+    /** URL for the ONNX model. Default: HuggingFace CDN */
+    modelUrl?: string;
     /**
-     * Dispose of the model and free resources
+     * URL for external model data file (.onnx.data weights).
+     * Default: `${modelUrl}.data`
+     *
+     * Set to `false` to skip external data loading (single-file models only).
      */
-    dispose(): Promise<void>;
-}
-/**
- * Configuration for the SenseVoice factory
- */
-interface CreateSenseVoiceConfig extends InferenceFactoryConfig {
-    /** Path or URL to model.int8.onnx (239MB). Default: HuggingFace CDN */
-    modelUrl?: string;
-    /** Path or URL to tokens.txt vocabulary file (default: sibling of modelUrl) */
-    tokensUrl?: string;
-    /** Language hint (default: 'auto') */
-    language?: SenseVoiceLanguage;
-    /** Text normalization (default: 'with_itn') */
-    textNorm?: 'with_itn' | 'without_itn';
+    externalDataUrl?: string | false;
+    /** Backend preference (default: 'auto') */
+    backend?: BackendPreference;
+    /** Number of identity classes (default: 12) */
+    numIdentityClasses?: number;
 }
 /**
- * Create a SenseVoice ASR instance with automatic implementation selection
+ * Create an A2E instance
  *
  * @param config - Factory configuration
- * @returns A SenseVoiceBackend instance (either Worker or main thread)
+ * @returns An A2EBackend instance
  */
-declare function createSenseVoice(config?: CreateSenseVoiceConfig): SenseVoiceBackend;
+declare function createA2E(config?: CreateA2EConfig): A2EBackend;
 
 /**
- * Shared blendshape constants and utilities for lip sync inference
- *
- * Contains LAM_BLENDSHAPES (canonical ordering), symmetrization, and
- * index remapping used by both Wav2Vec2Inference and Wav2ArkitCpuInference.
+ * Shared types for orchestration layer
  *
- * This module is the single source of truth for blendshape ordering to
- * avoid circular dependencies between inference classes.
+ * @category Orchestration
+ */
+
+/**
+ * Generic frame source -- any object that emits 'frame' events with blendshapes.
  *
- * @category Inference
+ * Implemented by PlaybackPipeline, MicLipSync, VoicePipeline, and any custom source.
+ * Used by OmoteAvatar (all renderer adapters) to receive animation frames.
  */
+interface FrameSource {
+    on(event: 'frame', callback: (frame: {
+        blendshapes: Float32Array;
+        emotion?: string;
+    }) => void): void;
+    off?(event: 'frame', callback: (frame: {
+        blendshapes: Float32Array;
+        emotion?: string;
+    }) => void): void;
+}
+type VoicePipelineState = 'idle' | 'loading' | 'ready' | 'listening' | 'thinking' | 'speaking' | 'error';
+interface LoadingProgress {
+    currentModel: string;
+    progress: number;
+    totalModels: number;
+    modelsLoaded: number;
+}
+interface TranscriptResult {
+    text: string;
+    emotion?: string;
+    language?: string;
+    event?: string;
+    isFinal: boolean;
+    inferenceTimeMs?: number;
+}
 /**
- * LAM model blendshape names in order (52 total)
- * NOTE: This is alphabetical ordering used by LAM, different from standard ARKit order
+ * Consumer's response handler. VoicePipeline calls this with transcribed text.
+ * Consumer must stream audio back for playback + lip sync.
  */
-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"];
-/** Alias for backwards compatibility */
-declare const ARKIT_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"];
+interface ResponseHandler {
+    (params: {
+        text: string;
+        emotion?: string;
+        event?: string;
+        /** Set avatar emotion during response streaming (e.g., from LLM emotion_update messages) */
+        setEmotion?: (emotion: string) => void;
+        /** Stream audio chunks to pipeline for playback + lip sync */
+        send: (chunk: Uint8Array) => Promise<void>;
+        /** Call when all audio has been sent */
+        done: () => Promise<void>;
+        /** Aborted on interruption or stop() */
+        signal: AbortSignal;
+        /** Session ID for backend correlation */
+        sessionId: string;
+    }): Promise<void>;
+}
+
 /**
- * Linearly interpolate between two blendshape weight arrays.
+ * TTSSpeaker — Shared helper for OmoteAvatar TTS integration.
  *
- * Pure math utility with zero renderer dependency — used by all renderer
- * adapters (@omote/three, @omote/babylon, @omote/r3f) for smooth frame
- * transitions.
+ * Encapsulates createA2E + TTSPlayback lifecycle so that renderer adapters
+ * (Three.js, Babylon.js) and the R3F hook can delegate with ~15 lines each.
  *
- * @param current - Current blendshape weights
- * @param target  - Target blendshape weights
+ * @category Audio
+ */
+
+interface TTSSpeakerConfig {
+    /** Per-character expression weight scaling */
+    profile?: ExpressionProfile;
+    /** Identity/style index for A2E model (default: 0) */
+    identityIndex?: number;
+    /** Audio playback delay in ms */
+    audioDelayMs?: number;
+    /** Enable neutral transition on playback complete */
+    neutralTransitionEnabled?: boolean;
+    /** Duration of neutral fade-out in ms */
+    neutralTransitionMs?: number;
+    /** Pre-built A2E backend (skip internal createA2E). */
+    lam?: A2EBackend;
+    /** LAM model config (only when lam not provided) */
+    models?: CreateA2EConfig;
+    /** Shared unified worker (recommended for iOS) */
+    unifiedWorker?: UnifiedInferenceWorker;
+}
+declare class TTSSpeaker {
+    private ttsPlayback;
+    private tts;
+    private ownedLam;
+    private ownedWorker;
+    private currentAbort;
+    private _isSpeaking;
+    private _audioOnly;
+    private scheduler;
+    /** Whether the speaker is currently playing audio. */
+    get isSpeaking(): boolean;
+    /** Whether this speaker is in audio-only mode (no lip sync). */
+    get audioOnly(): boolean;
+    /** The internal TTSPlayback (implements FrameSource). Null until connect() or in audio-only mode. */
+    get frameSource(): FrameSource | null;
+    /**
+     * Connect a TTS backend.
+     *
+     * When config includes `lam`, `unifiedWorker`, or `models`, the full lip sync
+     * pipeline is created (LAM + TTSPlayback + PlaybackPipeline).
+     *
+     * When config is omitted or has none of those, audio-only mode is used:
+     * TTS → AudioScheduler (speakers only, no blendshapes, no LAM download).
+     *
+     * @param tts - TTS backend to use for speech synthesis
+     * @param config - Optional configuration for A2E, expression profile, etc.
+     */
+    connect(tts: TTSBackend, config?: TTSSpeakerConfig): Promise<void>;
+    /**
+     * Synthesize and play text with lip sync.
+     * Auto-aborts previous speak if still in progress.
+     *
+     * @param text - Text to synthesize and play
+     * @param options - Optional voice override and abort signal
+     */
+    speak(text: string, options?: {
+        signal?: AbortSignal;
+        voice?: string;
+    }): Promise<void>;
+    /** Audio-only speak: TTS → resample → AudioScheduler (no blendshapes). */
+    private speakAudioOnly;
+    /** Poll scheduler until all audio has played. */
+    private waitForSchedulerComplete;
+    /**
+     * Stream text token-by-token with automatic sentence buffering.
+     * Designed for LLM token-by-token output. Sentences are detected at
+     * boundary characters (.!?\n) with a minimum length threshold, then
+     * synthesized and played with lip sync.
+     *
+     * Auto-aborts previous speak/streamText if still in progress.
+     *
+     * @param options - Optional voice override and abort signal
+     * @returns Sink with push() and end() methods
+     */
+    streamText(options: {
+        signal?: AbortSignal;
+        voice?: string;
+    }): Promise<{
+        push: (token: string) => void;
+        end: () => Promise<void>;
+    }>;
+    /** streamText in audio-only mode: TTS → AudioScheduler (no blendshapes). */
+    private streamTextAudioOnly;
+    /** Abort current speak if any. */
+    stop(): void;
+    /** Clean teardown of all owned resources. */
+    dispose(): Promise<void>;
+}
+
+/**
+ * createTTSPlayer — Zero-config TTS player for audio-only playback.
+ *
+ * Speaks text through speakers without an avatar. No LAM download, no lip sync.
+ *
+ * @example
+ * ```typescript
+ * import { createTTSPlayer } from '@omote/core';
+ *
+ * const player = createTTSPlayer();
+ * await player.load();
+ * await player.speak("Hello world!");
+ *
+ * // Streaming:
+ * const stream = await player.streamText({});
+ * stream.push("Hello ");
+ * stream.push("world!");
+ * await stream.end();
+ * ```
+ *
+ * @category Audio
+ */
+
+interface CreateTTSPlayerConfig {
+    /** Voice to use (default: 'af_heart') */
+    voice?: string;
+    /** Model URL override */
+    modelUrl?: string;
+    /** Voice data base URL override */
+    voiceBaseUrl?: string;
+}
+/**
+ * Zero-config TTS player. Speak text through speakers without an avatar.
+ *
+ * Uses Kokoro TTS (82M q8, ~92MB) with automatic worker selection.
+ * No LAM model is downloaded — audio plays directly through AudioScheduler.
+ */
+declare function createTTSPlayer(config?: CreateTTSPlayerConfig): TTSPlayer;
+/**
+ * Thin wrapper: TTSSpeaker in audio-only mode + delegated load().
+ */
+declare class TTSPlayer extends TTSSpeaker {
+    private backend;
+    constructor(tts: TTSBackend);
+    /** Load TTS model and connect in audio-only mode. */
+    load(): Promise<void>;
+    /** Whether the TTS model is loaded and ready. */
+    get isLoaded(): boolean;
+}
+
+/**
+ * Factory function for SenseVoice ASR with automatic Worker vs main thread selection
+ *
+ * Provides a unified API that automatically selects the optimal implementation:
+ * - Worker supported: Uses SenseVoiceWorker (off-main-thread inference)
+ * - Worker unsupported: Uses SenseVoiceInference (main thread)
+ *
+ * @category Inference
+ *
+ * @example Auto-detect (recommended)
+ * ```typescript
+ * import { createSenseVoice } from '@omote/core';
+ *
+ * const asr = createSenseVoice({
+ *   modelUrl: '/models/sensevoice/model.int8.onnx',
+ * });
+ * await asr.load();
+ * const { text, emotion } = await asr.transcribe(audioSamples);
+ * ```
+ *
+ * @example Force worker
+ * ```typescript
+ * const asr = createSenseVoice({
+ *   modelUrl: '/models/sensevoice/model.int8.onnx',
+ *   useWorker: true,
+ * });
+ * ```
+ *
+ * @example Force main thread
+ * ```typescript
+ * const asr = createSenseVoice({
+ *   modelUrl: '/models/sensevoice/model.int8.onnx',
+ *   useWorker: false,
+ * });
+ * ```
+ */
+
+/**
+ * Common interface for both SenseVoiceInference and SenseVoiceWorker
+ */
+interface SenseVoiceBackend {
+    /** Whether the model is loaded and ready for inference */
+    readonly isLoaded: boolean;
+    /** Current backend type ('wasm' for worker, full backend for main thread, null if not loaded) */
+    readonly backend: 'wasm' | 'webgpu' | null;
+    /**
+     * Load the ONNX model
+     * @param onProgress - Optional progress callback (fires once at 100% for worker)
+     * @returns Model loading information
+     */
+    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
+    /**
+     * Transcribe audio samples to text
+     * @param audioSamples - Float32Array of audio samples at 16kHz
+     * @returns Transcription result
+     */
+    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
+    /**
+     * Dispose of the model and free resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Configuration for the SenseVoice factory
+ */
+interface CreateSenseVoiceConfig extends InferenceFactoryConfig {
+    /** Path or URL to model.int8.onnx (239MB). Default: HuggingFace CDN */
+    modelUrl?: string;
+    /** Path or URL to tokens.txt vocabulary file (default: sibling of modelUrl) */
+    tokensUrl?: string;
+    /** Language hint (default: 'auto') */
+    language?: SenseVoiceLanguage;
+    /** Text normalization (default: 'with_itn') */
+    textNorm?: 'with_itn' | 'without_itn';
+}
+/**
+ * Create a SenseVoice ASR instance with automatic implementation selection
+ *
+ * @param config - Factory configuration
+ * @returns A SenseVoiceBackend instance (either Worker or main thread)
+ */
+declare function createSenseVoice(config?: CreateSenseVoiceConfig): SenseVoiceBackend;
+
+/**
+ * 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>;
+    /**
+     * 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 Omit<SileroVADConfig, 'modelUrl'>, InferenceFactoryConfig {
+    /** Path or URL to the ONNX model. Default: HuggingFace CDN */
+    modelUrl?: string;
+    /**
+     * 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;
+
+/**
+ * SpeechListener — Standalone listening primitive.
+ *
+ * Composes: MicrophoneCapture → SileroVAD → SenseVoice ASR → transcript events.
+ * Extracted from VoicePipeline's listening half so it can be used independently.
+ *
+ * Does NOT handle TTS, LAM, or response routing — those belong to TTSSpeaker
+ * and VoicePipeline respectively.
+ *
+ * @category Audio
+ */
+
+interface SpeechListenerConfig {
+    /** Pre-built backends — skip internal factory creation. */
+    backends?: {
+        asr: SenseVoiceBackend;
+        vad: SileroVADBackend;
+    };
+    /** External unified worker (reuse across pipelines). */
+    unifiedWorker?: UnifiedInferenceWorker;
+    /** URLs and options for model loading (when backends not provided). */
+    models?: {
+        senseVoice: {
+            modelUrl: string;
+            tokensUrl?: string;
+            language?: string;
+        };
+        vad: {
+            modelUrl: string;
+            threshold?: number;
+            preSpeechBufferChunks?: number;
+        };
+    };
+    /** Base silence timeout in ms (default: 500) */
+    silenceTimeoutMs?: number;
+    /** Extended silence timeout for long utterances (default: 700) */
+    silenceTimeoutExtendedMs?: number;
+    /** Enable adaptive timeout based on speech duration (default: true) */
+    adaptiveTimeout?: boolean;
+    /** Minimum audio duration in seconds (default: 0.3) */
+    minAudioDurationSec?: number;
+    /** Minimum audio energy (default: 0.02) */
+    minAudioEnergy?: number;
+    /** Enable audio normalization for quiet audio (default: true) */
+    normalizeAudio?: boolean;
+    /** Progressive transcription interval — desktop (default: 500ms) */
+    progressiveIntervalMs?: number;
+    /** Progressive transcription interval — iOS (default: 800ms) */
+    progressiveIntervalIosMs?: number;
+    /** Coverage threshold to use progressive result (default: 0.8) */
+    progressiveCoverageThreshold?: number;
+    /** Minimum samples before progressive transcription starts (default: 8000) */
+    progressiveMinSamples?: number;
+    /** Timeout for individual transcribe() calls (default: 10000ms) */
+    transcriptionTimeoutMs?: number;
+}
+type SpeechListenerState = 'idle' | 'loading' | 'ready' | 'listening' | 'processing' | 'paused';
+interface SpeechListenerEvents {
+    'state': SpeechListenerState;
+    'loading:progress': LoadingProgress;
+    'transcript': TranscriptResult;
+    'speech:start': void;
+    'speech:end': {
+        durationMs: number;
+    };
+    'audio:level': {
+        rms: number;
+        peak: number;
+    };
+    'audio:chunk': Float32Array;
+    'error': Error;
+    [key: string]: unknown;
+}
+declare class SpeechListener extends EventEmitter<SpeechListenerEvents> {
+    private readonly config;
+    private _state;
+    private epoch;
+    private asr;
+    private vad;
+    private ownedWorker;
+    private mic;
+    private omoteEvents;
+    private _unsubChunk;
+    private _unsubLevel;
+    private static readonly MAX_AUDIO_BUFFER_SAMPLES;
+    private audioBuffer;
+    private audioBufferSamples;
+    private speechStartTime;
+    private silenceTimer;
+    private isSpeechActive;
+    private progressiveTimer;
+    private progressivePromise;
+    private lastProgressiveResult;
+    private lastProgressiveSamples;
+    private asrErrorCount;
+    private progressiveErrorCount;
+    /** Current listener state */
+    get state(): SpeechListenerState;
+    constructor(config?: SpeechListenerConfig);
+    /**
+     * Load ASR + VAD models. Only loads speech recognition models,
+     * NOT TTS or LAM (those belong to TTSSpeaker).
+     */
+    loadModels(): Promise<void>;
+    /** Start listening — activates mic + VAD. */
+    start(): Promise<void>;
+    /** Stop listening — deactivates mic, clears buffers. */
+    stop(): void;
+    /** Pause VAD/ASR but keep mic active for audio:chunk events (for interruption detection). */
+    pause(): void;
+    /** Resume VAD/ASR from paused state. */
+    resume(): void;
+    /** Dispose all resources. */
+    dispose(): Promise<void>;
+    private processAudioChunk;
+    private getSilenceTimeout;
+    private onSilenceDetected;
+    private processEndOfSpeech;
+    private startProgressiveTranscription;
+    private stopProgressiveTranscription;
+    private transcribeWithTimeout;
+    private normalizeAudio;
+    private setState;
+    private emitProgress;
+    private clearSilenceTimer;
+}
+
+/**
+ * Interruption Handler
+ *
+ * VAD-based barge-in detection for AI conversations:
+ * - Monitors VAD probability for user speech
+ * - Detects when user interrupts AI response
+ * - Triggers interruption callbacks
+ */
+
+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;
+}
+declare class InterruptionHandler extends EventEmitter<InterruptionEvents> {
+    private config;
+    private isSpeaking;
+    private speechStartTime;
+    private lastSpeechTime;
+    private silenceTimer;
+    private aiIsSpeaking;
+    private interruptionTriggeredThisSession;
+    constructor(config?: InterruptionConfig);
+    /**
+     * Process raw audio energy for interruption detection (no VAD required).
+     * Used during speaking state when the unified worker is busy with TTS.
+     * Echo-cancelled mic input means energy above threshold = user speech.
+     *
+     * @param rms - RMS energy of audio chunk (0-1)
+     * @param energyThreshold - Minimum energy to consider speech (default: 0.02)
+     */
+    processAudioEnergy(rms: number, energyThreshold?: number): void;
+    /**
+     * 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;
+    /** Notify that AI started/stopped 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 onSpeechDetected;
+    private onSilenceDetected;
+}
+
+/**
+ * SenseVoice ASR Web Worker implementation
+ *
+ * Runs SenseVoice speech recognition in a dedicated Web Worker to prevent
+ * main thread blocking. Uses inline worker script (Blob URL pattern) to
+ * avoid separate file deployment.
+ *
+ * Key design decisions:
+ * - WASM backend only (WebGPU doesn't work in Workers)
+ * - All preprocessing (fbank, LFR, CMVN) and CTC decoding inlined in worker
+ * - Audio copied (not transferred) to retain main thread access
+ * - ONNX Runtime loaded from CDN in worker (no bundler complications)
+ * - iOS: model URL passed as string to ORT (avoids 239MB JS heap allocation)
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { SenseVoiceWorker } from '@omote/core';
+ *
+ * const asr = new SenseVoiceWorker({
+ *   modelUrl: '/models/sensevoice/model.int8.onnx',
+ *   tokensUrl: '/models/sensevoice/tokens.txt',
+ * });
+ * await asr.load();
+ *
+ * const { text, emotion, language } = await asr.transcribe(audioSamples);
+ * console.log(text);       // "Hello world"
+ * console.log(emotion);    // "NEUTRAL"
+ * console.log(language);   // "en"
+ * ```
+ */
+
+/**
+ * Configuration for SenseVoice Worker
+ */
+interface SenseVoiceWorkerConfig {
+    /** Path or URL to model.int8.onnx (239MB) */
+    modelUrl: string;
+    /** Path or URL to tokens.txt vocabulary file (default: sibling of modelUrl) */
+    tokensUrl?: string;
+    /** Language hint (default: 'auto' for auto-detection) */
+    language?: SenseVoiceLanguage;
+    /** Text normalization: 'with_itn' applies inverse text normalization (default: 'with_itn') */
+    textNorm?: 'with_itn' | 'without_itn';
+}
+/**
+ * SenseVoice ASR Worker - Speech Recognition in a Web Worker
+ *
+ * Runs SenseVoice inference off the main thread to prevent UI blocking.
+ * All preprocessing (fbank, LFR, CMVN) and CTC decoding run in the worker.
+ *
+ * @see SenseVoiceInference for main-thread version
+ */
+declare class SenseVoiceWorker {
+    private worker;
+    private config;
+    private isLoading;
+    private _isLoaded;
+    private inferenceQueue;
+    private poisoned;
+    private pendingResolvers;
+    private languageId;
+    private textNormId;
+    constructor(config: SenseVoiceWorkerConfig);
+    get isLoaded(): boolean;
+    /**
+     * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
+     */
+    get backend(): 'wasm' | null;
+    /**
+     * 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
+     *
+     * @param onProgress - Optional progress callback. Fires once at 100% when load completes
+     *   (the worker downloads and loads the model internally, so granular progress is not available).
+     */
+    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
+    /**
+     * Transcribe audio samples to text
+     *
+     * @param audioSamples Float32Array of audio samples at 16kHz, [-1, 1] range
+     * @returns Transcription result with text, emotion, language, and event
+     */
+    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
+    /**
+     * 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;
+}
+
+/**
+ * Shared blendshape constants and utilities for lip sync inference
+ *
+ * Contains ARKIT_BLENDSHAPES (canonical 52-blendshape ordering), symmetrization,
+ * and interpolation utilities used by A2EInference and all renderer adapters.
+ *
+ * This module is the single source of truth for blendshape ordering to
+ * avoid circular dependencies between inference classes.
+ *
+ * @category Inference
+ */
+/**
+ * ARKit blendshape names in alphabetical order (52 total)
+ * This is the canonical ordering used by all A2E models in the SDK.
+ */
+declare const ARKIT_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"];
+/** @deprecated Use ARKIT_BLENDSHAPES instead */
+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"];
+/**
+ * Linearly interpolate between two blendshape weight arrays.
+ *
+ * Pure math utility with zero renderer dependency — used by all renderer
+ * adapters (@omote/three, @omote/babylon, @omote/r3f) for smooth frame
+ * transitions.
+ *
+ * @param current - Current blendshape weights
+ * @param target  - Target blendshape weights
  * @param factor  - Interpolation factor (0 = no change, 1 = snap to target). Default: 0.3
  * @returns Interpolated weights as number[]
  */
 declare function lerpBlendshapes(current: Float32Array | number[], target: Float32Array | number[], factor?: number): number[];
 
 /**
- * Wav2Vec2 inference engine for Audio-to-Expression (A2E)
+ * A2E inference engine for Audio-to-Expression (LAM model)
  *
  * Runs entirely in the browser using WebGPU or WASM.
  * Takes raw 16kHz audio and outputs 52 ARKit blendshapes for lip sync.
+ * Uses the LAM (Large Animation Model) — see {@link A2EBackend} for the interface.
  *
+ * @see {@link createA2E} for the recommended zero-config factory
+ * @see {@link A2EBackend} for the common interface
  * @category Inference
  *
  * @example Basic usage
  * ```typescript
- * import { Wav2Vec2Inference } from '@omote/core';
+ * import { A2EInference } from '@omote/core';
  *
- * const wav2vec = new Wav2Vec2Inference({ modelUrl: '/models/model.onnx' });
- * await wav2vec.load();
+ * const a2e = new A2EInference({ modelUrl: '/models/lam.onnx' });
+ * await a2e.load();
  *
  * // Process 1 second of audio (16kHz = 16000 samples)
- * const result = await wav2vec.infer(audioSamples);
+ * const result = await a2e.infer(audioSamples);
  * console.log('Blendshapes:', result.blendshapes); // [30, 52] for 30fps
  * ```
  */
 
-type InferenceBackend = BackendPreference;
-interface Wav2Vec2InferenceConfig {
+interface A2EInferenceConfig {
     /** Path or URL to the ONNX model */
     modelUrl: string;
     /**
@@ -1999,7 +2333,7 @@ interface Wav2Vec2InferenceConfig {
      */
     externalDataUrl?: string | false;
     /** Preferred backend (auto will try WebGPU first, fallback to WASM) */
-    backend?: InferenceBackend;
+    backend?: BackendPreference;
     /** Number of identity classes (default: 12 for streaming model) */
     numIdentityClasses?: number;
     /**
@@ -2009,28 +2343,9 @@ interface Wav2Vec2InferenceConfig {
      */
     chunkSize?: number;
 }
-interface ModelInfo {
-    backend: 'webgpu' | 'wasm';
-    loadTimeMs: number;
-    inputNames: string[];
-    outputNames: string[];
-}
 
-/**
- * CTC vocabulary (32 tokens from wav2vec2-base-960h)
- * @deprecated ASR is handled by SenseVoice. This will be removed in a future release.
- */
-declare const CTC_VOCAB: string[];
-interface Wav2Vec2Result {
-    /** Blendshape weights [frames, 52] - 30fps */
-    blendshapes: Float32Array[];
-    /** Number of blendshape frames (30fps) */
-    numFrames: number;
-    /** Inference time in ms */
-    inferenceTimeMs: number;
-}
-declare class Wav2Vec2Inference implements A2EBackend {
-    readonly modelId: "wav2vec2";
+declare class A2EInference implements A2EBackend {
+    readonly modelId: "a2e";
     private session;
     private ort;
     private config;
@@ -2041,7 +2356,7 @@ declare class Wav2Vec2Inference implements A2EBackend {
     private inferenceQueue;
     private poisoned;
     private static readonly INFERENCE_TIMEOUT_MS;
-    constructor(config: Wav2Vec2InferenceConfig);
+    constructor(config: A2EInferenceConfig);
     /**
      * Check if WebGPU is available and working
      * (iOS returns false even if navigator.gpu exists due to ONNX Runtime bugs)
@@ -2054,7 +2369,7 @@ declare class Wav2Vec2Inference implements A2EBackend {
     /**
      * Load the ONNX model
      */
-    load(): Promise<ModelInfo>;
+    load(): Promise<A2EModelInfo>;
     /**
      * Run inference on raw audio
      * @param audioSamples - Float32Array of raw audio at 16kHz
@@ -2062,7 +2377,7 @@ declare class Wav2Vec2Inference implements A2EBackend {
      *
      * Audio will be zero-padded or truncated to chunkSize samples.
      */
-    infer(audioSamples: Float32Array, identityIndex?: number): Promise<Wav2Vec2Result>;
+    infer(audioSamples: Float32Array, identityIndex?: number): Promise<A2EResult>;
     /**
      * Queue inference to serialize ONNX session calls
      */
@@ -2107,7 +2422,7 @@ declare class Wav2Vec2Inference implements A2EBackend {
  * ```
  */
 /** Model URL keys that can be configured */
-type ModelUrlKey = 'lam' | 'lamIos' | 'wav2arkitCpu' | 'senseVoice' | 'sileroVad' | 'kokoroTTS' | 'kokoroVoices';
+type ModelUrlKey = 'lam' | 'senseVoice' | 'sileroVad' | 'kokoroTTS' | 'kokoroVoices';
 /**
  * Resolved model URLs — user overrides take priority, HuggingFace CDN is fallback.
  *
@@ -2126,8 +2441,7 @@ declare const DEFAULT_MODEL_URLS: Readonly<Record<ModelUrlKey, string>>;
  * @example Self-host all models
  * ```typescript
  * configureModelUrls({
- *   lam: 'https://cdn.example.com/models/model_fp16.onnx',
- *   wav2arkitCpu: 'https://cdn.example.com/models/wav2arkit_cpu.onnx',
+ *   lam: 'https://cdn.example.com/models/lam.onnx',
  *   senseVoice: 'https://cdn.example.com/models/sensevoice.int8.onnx',
  *   sileroVad: 'https://cdn.example.com/models/silero-vad.onnx',
  * });
@@ -2135,292 +2449,22 @@ declare const DEFAULT_MODEL_URLS: Readonly<Record<ModelUrlKey, string>>;
  *
  * @example Override only one model
  * ```typescript
- * configureModelUrls({
- *   lam: '/models/model_fp16.onnx', // self-hosted, same origin
- * });
- * ```
- */
-declare function configureModelUrls(urls: Partial<Record<ModelUrlKey, string>>): void;
-/**
- * Reset all model URL overrides back to HuggingFace CDN defaults.
- * Mainly useful for testing.
- */
-declare function resetModelUrls(): void;
-/**
- * Get the immutable HuggingFace CDN URLs (ignoring any overrides).
- * Useful for documentation or fallback logic.
- */
-declare const HF_CDN_URLS: Readonly<Record<ModelUrlKey, string>>;
-
-/**
- * CPU-optimized lip sync inference using wav2arkit_cpu model
- *
- * A Safari/iOS-compatible alternative to Wav2Vec2Inference (192MB fp16) designed
- * for platforms where WebGPU crashes due to ONNX Runtime JSEP bugs.
- *
- * The model uses ONNX external data format:
- * - wav2arkit_cpu.onnx (1.86MB graph structure)
- * - wav2arkit_cpu.onnx.data (402MB weights)
- * Both files are fetched and cached automatically.
- *
- * Key differences from Wav2Vec2Inference:
- * - WASM-only backend (CPU-optimized, single-threaded, no WebGPU)
- * - No identity input (baked to identity 11)
- * - No ASR output (lip sync only)
- * - Dynamic input length (not fixed to 16000 samples)
- * - Different native blendshape ordering (remapped to LAM_BLENDSHAPES)
- *
- * @category Inference
- *
- * @example
- * ```typescript
- * import { Wav2ArkitCpuInference } from '@omote/core';
- *
- * const lam = new Wav2ArkitCpuInference({
- *   modelUrl: '/models/wav2arkit_cpu.onnx',
- * });
- * await lam.load();
- *
- * const { blendshapes } = await lam.infer(audioSamples);
- * // blendshapes: Float32Array[] in LAM_BLENDSHAPES order, 30fps
- * ```
- */
-
-interface Wav2ArkitCpuConfig {
-    /** Path or URL to the wav2arkit_cpu ONNX model (.onnx graph file) */
-    modelUrl: string;
-    /**
-     * Path or URL to external model data file (.onnx.data weights).
-     * Default: `${modelUrl}.data` (e.g., /models/wav2arkit_cpu.onnx.data)
-     *
-     * Set to `false` to skip external data loading (single-file models only).
-     */
-    externalDataUrl?: string | false;
-    /** Preferred backend (default: 'wasm' — this model is CPU-optimized) */
-    backend?: BackendPreference;
-}
-declare class Wav2ArkitCpuInference implements A2EBackend {
-    readonly modelId: "wav2arkit_cpu";
-    readonly chunkSize: number;
-    private session;
-    private ort;
-    private config;
-    private _backend;
-    private isLoading;
-    private inferenceQueue;
-    private poisoned;
-    private static readonly INFERENCE_TIMEOUT_MS;
-    constructor(config: Wav2ArkitCpuConfig);
-    get backend(): RuntimeBackend | null;
-    get isLoaded(): boolean;
-    /**
-     * Load the ONNX model
-     */
-    load(): Promise<A2EModelInfo>;
-    /**
-     * Run inference on raw audio
-     *
-     * Accepts variable-length audio (not fixed to 16000 samples).
-     * Output frames = ceil(30 * numSamples / 16000).
-     *
-     * @param audioSamples - Float32Array of raw audio at 16kHz
-     * @param _identityIndex - Ignored (identity 11 is baked into the model)
-     */
-    infer(audioSamples: Float32Array, _identityIndex?: number): Promise<A2EResult>;
-    /**
-     * Queue inference to serialize ONNX session calls
-     */
-    private queueInference;
-    /**
-     * Dispose of the model and free resources
-     */
-    dispose(): Promise<void>;
-}
-
-/**
- * Web Worker-based wav2arkit_cpu lip sync inference
- *
- * Runs wav2arkit_cpu inference in a dedicated Web Worker to prevent main thread blocking.
- * Uses inline worker script (Blob URL pattern) to avoid separate file deployment.
- *
- * Key design decisions:
- * - WASM backend only (WebGPU doesn't work in Workers)
- * - Audio copied (not transferred) to retain main thread access
- * - ONNX Runtime loaded from CDN in worker (no bundler complications)
- * - Blendshape symmetrization inlined in worker (no module imports)
- * - iOS: passes model URLs as strings directly to ORT (avoids 400MB+ JS heap)
- *
- * @category Inference
- *
- * @example
- * ```typescript
- * import { Wav2ArkitCpuWorker } from '@omote/core';
- *
- * const lam = new Wav2ArkitCpuWorker({
- *   modelUrl: '/models/wav2arkit_cpu.onnx',
- * });
- * await lam.load();
- *
- * const { blendshapes } = await lam.infer(audioSamples);
- * // blendshapes: Float32Array[] in LAM_BLENDSHAPES order, 30fps
- * ```
- */
-
-/**
- * Configuration for Wav2ArkitCpu Worker
- */
-interface Wav2ArkitCpuWorkerConfig {
-    /** Path or URL to the wav2arkit_cpu ONNX model (.onnx graph file) */
-    modelUrl: string;
-    /**
-     * Path or URL to external model data file (.onnx.data weights).
-     * Default: `${modelUrl}.data` (e.g., /models/wav2arkit_cpu.onnx.data)
-     *
-     * Set to `false` to skip external data loading (single-file models only).
-     */
-    externalDataUrl?: string | false;
-}
-/**
- * Wav2ArkitCpu Worker - Lip sync inference in a Web Worker
- *
- * Runs wav2arkit_cpu inference off the main thread to prevent UI blocking.
- * Feature parity with Wav2ArkitCpuInference but runs in dedicated worker.
- *
- * @see Wav2ArkitCpuInference for main-thread version
- */
-declare class Wav2ArkitCpuWorker implements A2EBackend {
-    readonly modelId: "wav2arkit_cpu";
-    readonly chunkSize: number;
-    private worker;
-    private config;
-    private isLoading;
-    private _isLoaded;
-    private inferenceQueue;
-    private poisoned;
-    private pendingResolvers;
-    constructor(config: Wav2ArkitCpuWorkerConfig);
-    get isLoaded(): boolean;
-    /**
-     * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
-     */
-    get backend(): 'wasm' | null;
-    /**
-     * 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<A2EModelInfo>;
-    /**
-     * Run inference on raw audio
-     *
-     * Accepts variable-length audio (not fixed to 16000 samples).
-     * Output frames = ceil(30 * numSamples / 16000).
-     *
-     * @param audioSamples - Float32Array of raw audio at 16kHz
-     * @param _identityIndex - Ignored (identity 11 is baked into the model)
-     */
-    infer(audioSamples: Float32Array, _identityIndex?: number): Promise<A2EResult>;
-    /**
-     * 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 A2E with automatic GPU/CPU model selection
- *
- * Provides a unified API with platform-aware model selection:
- *
- * **Desktop (Chrome/Edge/Android):**
- *   Wav2Vec2 (WebGPU, 192MB fp16) → wav2arkit_cpu fallback
- *
- * **iOS/Safari:**
- *   LAM iOS (WASM, opset 18, ~192MB fp16, native LayerNorm) → wav2arkit_cpu fallback
- *
- * The iOS variant is the same LAM model re-exported at opset 18 with native
- * LayerNormalization ops (~256 fewer graph nodes than desktop's opset 14
- * decomposed LayerNorm). This dramatically reduces peak memory during ORT
- * graph parsing/optimization, fitting within iOS's ~1-1.5GB tab limit.
- *
- * Both variants use fp16 external data format (small graph + ~192MB weights).
- * On iOS, ORT streams weights directly into WASM memory via URL pass-through
- * (~2MB JS heap). If the model still OOMs, A2EWithFallback falls back to
- * wav2arkit_cpu (404MB fp32, lower quality).
- *
- * @category Inference
- *
- * @example Auto-detect (recommended, zero-config)
- * ```typescript
- * import { createA2E } from '@omote/core';
- *
- * const a2e = createA2E(); // uses HF CDN defaults (192MB fp16 GPU, 404MB CPU fallback)
- * await a2e.load();
- * const { blendshapes } = await a2e.infer(audioSamples);
- * ```
- *
- * @example Force CPU model
- * ```typescript
- * const a2e = createA2E({ mode: 'cpu' });
+ * configureModelUrls({
+ *   lam: '/models/model_fp16.onnx', // self-hosted, same origin
+ * });
  * ```
  */
-
+declare function configureModelUrls(urls: Partial<Record<ModelUrlKey, string>>): void;
 /**
- * Configuration for the A2E factory
+ * Reset all model URL overrides back to HuggingFace CDN defaults.
+ * Mainly useful for testing.
  */
-interface CreateA2EConfig extends InferenceFactoryConfig {
-    /** URL for the GPU model (Wav2Vec2, used on Chrome/Firefox/Edge). Default: HuggingFace CDN */
-    gpuModelUrl?: string;
-    /**
-     * URL for GPU model external data file (.onnx.data weights).
-     * Default: `${gpuModelUrl}.data`
-     *
-     * Set to `false` to skip external data loading (single-file models only).
-     */
-    gpuExternalDataUrl?: string | false;
-    /** URL for the CPU model (wav2arkit_cpu, used on Safari/iOS). Default: HuggingFace CDN */
-    cpuModelUrl?: string;
-    /**
-     * Model selection mode:
-     * - 'auto': Safari/iOS -> CPU, everything else -> GPU (default)
-     * - 'gpu': Force GPU model (Wav2Vec2Inference)
-     * - 'cpu': Force CPU model (Wav2ArkitCpuInference)
-     */
-    mode?: 'auto' | 'gpu' | 'cpu';
-    /** Backend preference for GPU model (default: 'auto') */
-    gpuBackend?: BackendPreference;
-    /** Number of identity classes for GPU model (default: 12) */
-    numIdentityClasses?: number;
-    /**
-     * Fall back to CPU model if GPU model fails to load (default: true)
-     * Only applies when mode is 'auto' or 'gpu'
-     */
-    fallbackOnError?: boolean;
-}
+declare function resetModelUrls(): void;
 /**
- * Create an A2E instance with automatic GPU/CPU model selection
- *
- * @param config - Factory configuration
- * @returns An A2EBackend instance (either GPU or CPU model)
+ * Get the immutable HuggingFace CDN URLs (ignoring any overrides).
+ * Useful for documentation or fallback logic.
  */
-declare function createA2E(config?: CreateA2EConfig): A2EBackend;
+declare const HF_CDN_URLS: Readonly<Record<ModelUrlKey, string>>;
 
 /**
  * A2EProcessor — Engine-agnostic audio-to-expression processor
@@ -2471,9 +2515,6 @@ interface A2EProcessorConfig {
      * The LAM model uses a one-hot identity vector (12 classes, indices 0-11) as
      * style conditioning alongside audio features. Different indices produce
      * different expression intensity across face regions (brows, eyes, cheeks).
-     *
-     * Only affects Wav2Vec2Inference (GPU model). Wav2ArkitCpuInference has
-     * identity 11 baked into the model weights.
      */
     identityIndex?: number;
     /** Callback fired with each blendshape frame (push mode) */
@@ -2482,6 +2523,7 @@ interface A2EProcessorConfig {
     onError?: (error: Error) => void;
 }
 declare class A2EProcessor {
+    private static readonly MAX_PENDING_CHUNKS;
     private readonly backend;
     private readonly sampleRate;
     private readonly chunkSize;
@@ -2497,6 +2539,8 @@ declare class A2EProcessor {
     private _latestFrame;
     private dripInterval;
     private lastPulledFrame;
+    private lastDequeuedTime;
+    private decayBuffer;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2641,154 +2685,6 @@ declare class BlendshapeSmoother {
     reset(): void;
 }
 
-/**
- * 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>;
-    /**
-     * 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 Omit<SileroVADConfig, 'modelUrl'>, InferenceFactoryConfig {
-    /** Path or URL to the ONNX model. Default: HuggingFace CDN */
-    modelUrl?: string;
-    /**
-     * 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;
-
 /**
  * SenseVoice adapter backed by UnifiedInferenceWorker
  *
@@ -2814,44 +2710,21 @@ declare class SenseVoiceUnifiedAdapter implements SenseVoiceBackend {
 }
 
 /**
- * Wav2ArkitCpu adapter backed by UnifiedInferenceWorker
- *
- * Implements A2EBackend, delegating all inference to the shared worker.
- */
-
-declare class Wav2ArkitCpuUnifiedAdapter implements A2EBackend {
-    readonly modelId: "wav2arkit_cpu";
-    readonly chunkSize: number;
-    private worker;
-    private config;
-    private _isLoaded;
-    private loadedGeneration;
-    /** Per-adapter inference queue — ensures sequential state updates. */
-    private inferenceQueue;
-    constructor(worker: UnifiedInferenceWorker, config: Wav2ArkitCpuWorkerConfig);
-    get isLoaded(): boolean;
-    get backend(): RuntimeBackend | null;
-    load(): Promise<A2EModelInfo>;
-    infer(audioSamples: Float32Array, _identityIndex?: number): Promise<A2EResult>;
-    dispose(): Promise<void>;
-    private assertLoaded;
-}
-
-/**
- * Wav2Vec2 (LAM) adapter backed by UnifiedInferenceWorker
+ * A2E adapter backed by UnifiedInferenceWorker
  *
  * Implements A2EBackend, delegating all inference to the shared worker.
- * Used on iOS to run LAM inference off the main thread via the unified worker.
+ * Used on iOS to run A2E inference off the main thread via the unified worker.
  */
 
-declare class Wav2Vec2UnifiedAdapter implements A2EBackend {
-    readonly modelId: "wav2vec2";
+declare class A2EUnifiedAdapter implements A2EBackend {
+    readonly modelId: "a2e";
     readonly chunkSize: number;
     private worker;
     private modelUrl;
     private externalDataUrl;
     private numIdentityClasses;
     private _isLoaded;
+    private _backend;
     private loadedGeneration;
     /** Per-adapter inference queue — ensures sequential state updates. */
     private inferenceQueue;
@@ -2944,6 +2817,11 @@ interface SynthesizeOptions {
     /** Speed multiplier (overrides config speed) */
     speed?: number;
 }
+/**
+ * Validate TTS input parameters at API boundaries.
+ * Returns trimmed text on success, throws on invalid input.
+ */
+declare function validateTTSInput(text: unknown, voiceName: string, speed: number, availableVoices?: string[]): string;
 declare class KokoroTTSInference implements TTSBackend {
     private readonly config;
     private readonly modelUrl;
@@ -3044,144 +2922,37 @@ declare class KokoroTTSUnifiedAdapter implements TTSBackend {
  */
 
 declare class SileroVADUnifiedAdapter implements SileroVADBackend {
-    private worker;
-    private config;
-    private _isLoaded;
-    private loadedGeneration;
-    private state;
-    private context;
-    private readonly chunkSize;
-    private readonly contextSize;
-    /**
-     * Per-adapter inference queue — ensures sequential state updates.
-     *
-     * The unified worker processes messages serially (single thread), but this queue
-     * guarantees per-adapter state consistency. Example: VAD LSTM state from call N
-     * must be applied before call N+1 starts. Without the queue, two rapid process()
-     * calls could both read the same stale state.
-     */
-    private inferenceQueue;
-    private preSpeechBuffer;
-    private wasSpeaking;
-    constructor(worker: UnifiedInferenceWorker, config: SileroVADConfig);
-    get isLoaded(): boolean;
-    get backend(): RuntimeBackend | null;
-    get sampleRate(): number;
-    get threshold(): number;
-    getChunkSize(): number;
-    getChunkDurationMs(): number;
-    load(): Promise<VADWorkerModelInfo>;
-    process(audioChunk: Float32Array): Promise<VADResult>;
-    reset(): Promise<void>;
-    dispose(): Promise<void>;
-    private assertLoaded;
-}
-
-/**
- * Renderer-agnostic A2E (audio-to-expression) orchestrator
- *
- * Manages the mic capture + A2E inference loop independently of any
- * 3D renderer. Adapter packages (@omote/three, @omote/babylon) wrap this
- * thinly and pipe `latestWeights` into their renderer-specific blendshape
- * controllers.
- *
- * Internally delegates all buffer accumulation, inference, and frame
- * drip-feeding to {@link A2EProcessor}. This class only handles mic capture
- * (getUserMedia, ScriptProcessorNode, resampling).
- *
- * @deprecated Use {@link MicLipSync} from `@omote/core` instead. MicLipSync provides
- * the same mic → A2E composition with proper MicrophoneCapture integration, VAD support,
- * ExpressionProfile scaling, and pause/resume. This class will be removed in a future version.
- *
- * @category Inference
- */
-
-/**
- * Progress event emitted during model download / compile
- */
-interface A2EProgressEvent {
-    phase: 'download' | 'compile';
-    progress: number;
-}
-/**
- * Configuration for the A2EOrchestrator
- */
-interface A2EOrchestratorConfig {
-    /** URL for the GPU model (Wav2Vec2, Chrome/Firefox/Edge) */
-    gpuModelUrl: string;
-    /** URL for GPU model external data file */
-    gpuExternalDataUrl?: string | false;
-    /** URL for the CPU model (wav2arkit_cpu, Safari/iOS) */
-    cpuModelUrl?: string;
-    /** Sample rate for mic capture (default: 16000) */
-    sampleRate?: number;
-    /** Chunk size in samples for mic capture (default: 16000 = 1s at 16kHz) */
-    chunkSize?: number;
-    /** Callback fired with new blendshape weights after each inference */
-    onFrame?: (weights: Float32Array) => void;
-    /** Callback fired during model loading progress */
-    onProgress?: (event: A2EProgressEvent) => void;
-    /** Callback fired on error */
-    onError?: (error: Error) => void;
-    /** Callback fired when model is loaded and ready */
-    onReady?: () => void;
-    /** Additional createA2E config options */
-    a2eConfig?: Partial<CreateA2EConfig>;
-}
-/**
- * Renderer-agnostic A2E orchestrator.
- *
- * Manages mic capture + delegates inference to {@link A2EProcessor}.
- * Adapters read `latestWeights` each frame to apply to their meshes.
- *
- * @example Quick start (used by @omote/three and @omote/babylon adapters)
- * ```typescript
- * const orchestrator = new A2EOrchestrator({
- *   gpuModelUrl: '/models/wav2vec2.onnx',
- *   cpuModelUrl: '/models/wav2arkit_cpu.onnx',
- *   onFrame: (weights) => controller.update(weights),
- * });
- * await orchestrator.load();
- * await orchestrator.start();
- * ```
- */
-declare class A2EOrchestrator {
+    private worker;
     private config;
-    private a2e;
-    private processor;
-    private stream;
-    private audioContext;
-    private scriptProcessor;
-    private nativeSampleRate;
-    private _isReady;
-    private _isStreaming;
-    private _backend;
-    private disposed;
-    constructor(config: A2EOrchestratorConfig);
-    /** Latest blendshape weights from inference (null if none yet) */
-    get latestWeights(): Float32Array | null;
-    /** Whether the model is loaded and ready for inference */
-    get isReady(): boolean;
-    /** Whether mic is active and inference loop is running */
-    get isStreaming(): boolean;
-    /** Current backend type (webgpu, wasm, or null) */
-    get backend(): string | null;
-    /**
-     * Load the A2E model and create the processor
-     */
-    load(): Promise<void>;
-    /**
-     * Start mic capture and inference loop
-     */
-    start(): Promise<void>;
-    /**
-     * Stop mic capture and inference loop
-     */
-    stop(): void;
+    private _isLoaded;
+    private loadedGeneration;
+    private state;
+    private context;
+    private readonly chunkSize;
+    private readonly contextSize;
     /**
-     * Dispose of all resources
+     * Per-adapter inference queue — ensures sequential state updates.
+     *
+     * The unified worker processes messages serially (single thread), but this queue
+     * guarantees per-adapter state consistency. Example: VAD LSTM state from call N
+     * must be applied before call N+1 starts. Without the queue, two rapid process()
+     * calls could both read the same stale state.
      */
+    private inferenceQueue;
+    private preSpeechBuffer;
+    private wasSpeaking;
+    constructor(worker: UnifiedInferenceWorker, config: SileroVADConfig);
+    get isLoaded(): boolean;
+    get backend(): RuntimeBackend | null;
+    get sampleRate(): number;
+    get threshold(): number;
+    getChunkSize(): number;
+    getChunkDurationMs(): number;
+    load(): Promise<VADWorkerModelInfo>;
+    process(audioChunk: Float32Array): Promise<VADResult>;
+    reset(): Promise<void>;
     dispose(): Promise<void>;
+    private assertLoaded;
 }
 
 /**
@@ -3555,6 +3326,10 @@ declare const KOKORO_VOICES: {
     readonly bm_fable: "bm_fable";
     readonly bm_george: "bm_george";
     readonly bm_lewis: "bm_lewis";
+    readonly ef_dora: "ef_dora";
+    readonly em_alex: "em_alex";
+    readonly em_santa: "em_santa";
+    readonly ff_siwis: "ff_siwis";
 };
 type KokoroVoiceName = keyof typeof KOKORO_VOICES;
 /**
@@ -3562,6 +3337,223 @@ type KokoroVoiceName = keyof typeof KOKORO_VOICES;
  */
 declare function listVoices(): string[];
 
+/**
+ * ElevenLabs TTS Backend — Cloud text-to-speech via ElevenLabs REST API.
+ *
+ * Implements the TTSBackend interface so it can be used anywhere Kokoro TTS is used
+ * (TTSPlayback, TTSSpeaker, VoicePipeline, PlaybackPipeline, etc.)
+ *
+ * Zero external dependencies — uses fetch() directly.
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { ElevenLabsTTSBackend } from '@omote/core';
+ *
+ * const tts = new ElevenLabsTTSBackend({
+ *   apiKey: 'your-api-key',
+ *   voiceId: 'voice-id',
+ * });
+ * await tts.load();
+ *
+ * for await (const chunk of tts.stream("Hello world!")) {
+ *   playbackPipeline.feedBuffer(chunk.audio);
+ * }
+ * ```
+ *
+ * @example With PlaybackPipeline
+ * ```typescript
+ * const speaker = new TTSSpeaker();
+ * await speaker.connect(tts, { lam: createA2E() });
+ * await speaker.speak("Hello!");
+ * ```
+ */
+
+interface ElevenLabsConfig {
+    /** ElevenLabs API key */
+    apiKey: string;
+    /** Voice ID to use */
+    voiceId: string;
+    /** Model ID (default: 'eleven_multilingual_v2') */
+    model?: string;
+    /**
+     * Output format (default: 'pcm_16000').
+     * Use 'pcm_16000' for lip sync compatibility (16kHz matches A2E input).
+     * Other options: 'pcm_22050', 'pcm_24000', 'pcm_44100'
+     */
+    outputFormat?: string;
+    /** Voice stability 0-1 (default: 0.5) */
+    stability?: number;
+    /** Voice similarity boost 0-1 (default: 0.75) */
+    similarityBoost?: number;
+    /** API base URL override (default: 'https://api.elevenlabs.io') */
+    baseUrl?: string;
+}
+declare class ElevenLabsTTSBackend implements TTSBackend {
+    private readonly apiKey;
+    private readonly voiceId;
+    private readonly model;
+    private readonly outputFormat;
+    private readonly stability;
+    private readonly similarityBoost;
+    private readonly baseUrl;
+    private readonly _sampleRate;
+    private _isLoaded;
+    constructor(config: ElevenLabsConfig);
+    get sampleRate(): number;
+    get isLoaded(): boolean;
+    /**
+     * No-op for cloud TTS (no model to load).
+     * Marks backend as ready.
+     */
+    load(): Promise<void>;
+    /**
+     * Stream audio from ElevenLabs for the given text.
+     *
+     * Uses the streaming endpoint. Yields a single chunk for non-streaming
+     * or multiple chunks as response data arrives.
+     */
+    stream(text: string, options?: TTSStreamOptions): AsyncGenerator<TTSChunk>;
+    dispose(): Promise<void>;
+    private getHttpErrorMessage;
+}
+
+/**
+ * AWS Polly TTS Backend — Cloud text-to-speech via consumer-provided AWS SDK call.
+ *
+ * Implements the TTSBackend interface. Keeps @omote/core free of AWS SDK dependencies
+ * by delegating the actual Polly API call to a consumer-provided function.
+ *
+ * @category Inference
+ *
+ * @example Basic usage with AWS SDK v3
+ * ```typescript
+ * import { PollyTTSBackend } from '@omote/core';
+ * import { PollyClient, SynthesizeSpeechCommand } from '@aws-sdk/client-polly';
+ *
+ * const polly = new PollyClient({ region: 'us-east-1' });
+ *
+ * const tts = new PollyTTSBackend({
+ *   synthesizeFn: async (text, voice, sampleRate) => {
+ *     const cmd = new SynthesizeSpeechCommand({
+ *       Text: text,
+ *       VoiceId: voice,
+ *       Engine: 'neural',
+ *       OutputFormat: 'pcm',
+ *       SampleRate: String(sampleRate),
+ *     });
+ *     const result = await polly.send(cmd);
+ *     const stream = result.AudioStream;
+ *     // Convert stream to ArrayBuffer (Node or browser)
+ *     const chunks: Uint8Array[] = [];
+ *     for await (const chunk of stream as AsyncIterable<Uint8Array>) {
+ *       chunks.push(chunk);
+ *     }
+ *     const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+ *     const merged = new Uint8Array(totalLength);
+ *     let offset = 0;
+ *     for (const chunk of chunks) {
+ *       merged.set(chunk, offset);
+ *       offset += chunk.length;
+ *     }
+ *     return {
+ *       audio: merged.buffer,
+ *       contentType: result.ContentType ?? 'audio/pcm',
+ *     };
+ *   },
+ * });
+ *
+ * await tts.load();
+ * for await (const chunk of tts.stream("Hello world!")) {
+ *   playbackPipeline.feedBuffer(chunk.audio);
+ * }
+ * ```
+ */
+
+/**
+ * Result from the consumer-provided synthesize function.
+ */
+interface PollySynthesizeResult {
+    /** Raw PCM audio bytes (Int16 LE) */
+    audio: ArrayBuffer;
+    /** Content type from Polly response (e.g., 'audio/pcm') */
+    contentType: string;
+}
+/**
+ * Configuration for PollyTTSBackend.
+ *
+ * The `synthesizeFn` callback lets consumers use their own AWS SDK setup
+ * (credentials, region, SDK version) without @omote/core depending on `@aws-sdk/client-polly`.
+ */
+interface PollyConfig {
+    /**
+     * Consumer-provided function that calls AWS Polly.
+     * Must return PCM audio (Int16 LE) at the requested sample rate.
+     *
+     * @param text - Text to synthesize
+     * @param voice - Polly voice ID (e.g., 'Joanna')
+     * @param sampleRate - Requested output sample rate (e.g., 16000)
+     * @returns PCM audio buffer and content type
+     */
+    synthesizeFn: (text: string, voice: string, sampleRate: number) => Promise<PollySynthesizeResult>;
+    /** Polly voice ID (default: 'Joanna') */
+    voice?: string;
+    /** Output sample rate in Hz (default: 16000) */
+    sampleRate?: number;
+    /** Polly engine type (default: 'neural') */
+    engine?: 'neural' | 'standard' | 'generative' | 'long-form';
+}
+declare class PollyTTSBackend implements TTSBackend {
+    private readonly synthesizeFn;
+    private readonly voice;
+    private readonly _sampleRate;
+    private readonly engine;
+    private _isLoaded;
+    constructor(config: PollyConfig);
+    get sampleRate(): number;
+    get isLoaded(): boolean;
+    /**
+     * No-op for cloud TTS (no model to load).
+     * Marks backend as ready.
+     */
+    load(): Promise<void>;
+    /**
+     * Synthesize audio via consumer's Polly function.
+     *
+     * Polly's SynthesizeSpeech is request/response (not streaming for PCM),
+     * so this yields a single chunk per call. For long text, consider splitting
+     * into sentences on the consumer side.
+     */
+    stream(text: string, options?: TTSStreamOptions): AsyncGenerator<TTSChunk>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * ORT CDN configuration
+ *
+ * Allows consumers to override the CDN base URL used for loading
+ * ONNX Runtime WASM/WebGPU binaries. By default, ORT loads from
+ * its bundled CDN path. Use {@link configureOrtCdn} to point at
+ * a self-hosted or enterprise CDN.
+ *
+ * @category Inference
+ */
+/**
+ * Override the CDN base URL for ONNX Runtime WASM/WebGPU binaries.
+ *
+ * Must be an HTTPS URL or a relative path (starts with `/` or `./`).
+ * Call this once at app startup, before loading any models.
+ *
+ * @param cdnPath - HTTPS URL or relative path to ORT binaries directory
+ * @throws If cdnPath is not HTTPS or a relative path
+ */
+declare function configureOrtCdn(cdnPath: string): void;
+/**
+ * Get the current ORT CDN base URL override, or null if using defaults.
+ */
+declare function getOrtCdnBase(): string | null;
+
 /**
  * Emotion - Helper for creating emotion vectors for avatar animation
  *
@@ -3601,6 +3593,8 @@ type EmotionName = typeof EMOTION_NAMES[number];
 type EmotionWeights = Partial<Record<EmotionName, number>>;
 /** Total emotion vector size */
 declare const EMOTION_VECTOR_SIZE = 26;
+/** Number of explicit emotion channels */
+declare const EXPLICIT_EMOTION_COUNT = 10;
 /**
  * Create an emotion vector from named weights
  *
@@ -4099,7 +4093,54 @@ declare const MetricNames: {
     readonly CACHE_HITS: "omote.cache.hits";
     /** Counter: Cache misses */
     readonly CACHE_MISSES: "omote.cache.misses";
+    /** Counter: Cache stale (version/etag mismatch) */
+    readonly CACHE_STALE: "omote.cache.stale";
+    /** Counter: Cache quota warning (>90% used) */
+    readonly CACHE_QUOTA_WARNING: "omote.cache.quota_warning";
+    /** Counter: Cache eviction (LRU) */
+    readonly CACHE_EVICTION: "omote.cache.eviction";
+    /** Histogram: VoicePipeline turn latency (speech end → transcript ready, excludes playback) */
+    readonly VOICE_TURN_LATENCY: "omote.voice.turn.latency";
+    /** Histogram: ASR transcription latency in ms */
+    readonly VOICE_TRANSCRIPTION_LATENCY: "omote.voice.transcription.latency";
+    /** Histogram: Response handler latency in ms */
+    readonly VOICE_RESPONSE_LATENCY: "omote.voice.response.latency";
+    /** Counter: Total transcriptions */
+    readonly VOICE_TRANSCRIPTIONS: "omote.voice.transcriptions";
+    /** Counter: Total interruptions */
+    readonly VOICE_INTERRUPTIONS: "omote.voice.interruptions";
+    /** Histogram: PlaybackPipeline session duration in ms */
+    readonly PLAYBACK_SESSION_DURATION: "omote.playback.session.duration";
+    /** Histogram: Audio chunk processing latency in ms */
+    readonly PLAYBACK_CHUNK_LATENCY: "omote.playback.chunk.latency";
+    /** Histogram: TTSSpeaker.connect() latency in ms */
+    readonly TTS_CONNECT_LATENCY: "omote.tts.connect.latency";
+    /** Histogram: TTSSpeaker.speak() latency in ms */
+    readonly TTS_SPEAK_LATENCY: "omote.tts.speak.latency";
+    /** Counter: TTSSpeaker.stop() aborted speak calls */
+    readonly TTS_SPEAK_ABORTED: "omote.tts.speak.aborted";
+    /** Counter: MicLipSync sessions started */
+    readonly MIC_SESSIONS: "omote.mic.sessions";
+    /** Histogram: CharacterController.update() latency in µs */
+    readonly AVATAR_FRAME_LATENCY: "omote.avatar.frame.latency_us";
+    /** Histogram: FaceCompositor.compose() latency in µs */
+    readonly COMPOSITOR_COMPOSE_LATENCY: "omote.compositor.compose.latency_us";
+    /** Counter: Frames exceeding budget threshold */
+    readonly AVATAR_FRAME_DROPS: "omote.avatar.frame.drops";
+};
+/**
+ * Centralized error type taxonomy for structured error reporting.
+ */
+declare const ErrorTypes: {
+    readonly INFERENCE: "inference_error";
+    readonly NETWORK: "network_error";
+    readonly TIMEOUT: "timeout";
+    readonly USER: "user_error";
+    readonly RUNTIME: "runtime_error";
+    readonly MEDIA: "media_error";
+    readonly MODEL: "model_error";
 };
+type ErrorType = typeof ErrorTypes[keyof typeof ErrorTypes];
 /**
  * Histogram buckets for inference latency (ms)
  */
@@ -4177,6 +4218,7 @@ declare class OmoteTelemetry {
     private exporter;
     private activeTraceId;
     private metricsIntervalId;
+    private spanStack;
     private counters;
     private histograms;
     constructor(config: TelemetryConfig);
@@ -4274,6 +4316,14 @@ declare class OmoteTelemetry {
      * Get current configuration
      */
     getConfig(): TelemetryConfig;
+    /**
+     * Get the active span context for log-to-span correlation.
+     * Returns the most recent (top of stack) active span, or null if none.
+     */
+    getActiveContext(): {
+        traceId: string;
+        spanId: string;
+    } | null;
 }
 
 /**
@@ -4886,6 +4936,7 @@ declare class ProceduralLifeLayer {
     private noiseTime;
     private previousEnergy;
     private emphasisLevel;
+    private readonly _outputBlendshapes;
     constructor(config?: LifeLayerConfig);
     /**
      * Update the life layer and produce output for this frame.
@@ -4928,6 +4979,113 @@ declare class ProceduralLifeLayer {
     private updateBrowNoise;
 }
 
+/**
+ * Body Animation — Renderer-agnostic interfaces and utilities.
+ *
+ * Defines the contract for body animation controllers that each renderer
+ * adapter (@omote/three, @omote/babylon, @omote/r3f) implements natively.
+ *
+ * Also provides the shared bone filtering logic used during animation
+ * retargeting — stripping head/neck/eye tracks so body animations don't
+ * conflict with the face pipeline (FaceCompositor, gaze, ProceduralLifeLayer).
+ *
+ * @module animation
+ */
+/**
+ * Renderer-agnostic animation controller interface.
+ *
+ * Each renderer adapter implements this against its native animation system:
+ * - @omote/three → THREE.AnimationMixer + AnimationAction
+ * - @omote/babylon → Babylon.js AnimationGroup
+ * - @omote/r3f → React hook wrapping the Three.js implementation
+ *
+ * Python/Node ports implement this against their own runtimes.
+ */
+interface AnimationController {
+    /** Play an animation by id. */
+    play(id: string, options?: {
+        fadeInDuration?: number;
+    }): void;
+    /** Stop all playing animations. */
+    stop(fadeOutDuration?: number): void;
+    /** Crossfade from current animation to target. */
+    crossfadeTo(id: string, duration?: number): void;
+    /** Check if a specific animation is currently playing. */
+    isPlaying(id: string): boolean;
+    /** Check if an animation with this id is loaded. */
+    hasAnimation(id: string): boolean;
+    /** List of loaded animation ids. */
+    readonly availableAnimations: string[];
+}
+/**
+ * Describes an external animation asset to load and configure.
+ * Renderer-agnostic — loaders are adapter-specific.
+ */
+interface AnimationSource {
+    /** Unique identifier for this animation. */
+    id: string;
+    /** URL to the animation file (FBX, GLB, etc.). */
+    url: string;
+    /** Clip name within the file (if it contains multiple clips). */
+    clipName?: string;
+    /** Playback options. */
+    options?: AnimationSourceOptions;
+}
+interface AnimationSourceOptions {
+    loop?: boolean;
+    timeScale?: number;
+    fadeInDuration?: number;
+    fadeOutDuration?: number;
+    clampWhenFinished?: boolean;
+}
+/**
+ * Configuration for filtering bone tracks from body animations.
+ *
+ * The face pipeline (FaceCompositor, gaze tracking, ProceduralLifeLayer) owns
+ * certain bones (head, neck, eyes). Body animations must strip these tracks
+ * to prevent conflicts.
+ */
+interface BoneFilterConfig {
+    /** Bone names owned by the face pipeline (e.g., ['Head', 'Neck', 'LeftEye', 'RightEye']). */
+    proceduralBones: string[];
+    /** Whether to strip .position tracks (keep only quaternion/rotation). */
+    filterPositionTracks: boolean;
+    /** Whether to strip morphTargetInfluences tracks. */
+    filterMorphTargets: boolean;
+}
+/** Mixamo bone name prefix (stripped during retargeting). */
+declare const MIXAMO_PREFIX = "mixamorig";
+/**
+ * Bones that need position tracks preserved during retargeting.
+ * Stripping finger/hand position tracks causes fingers to splay to bind pose.
+ */
+declare const PRESERVE_POSITION_BONES: Set<string>;
+/** Default bone filter for RPM/Mixamo avatars. */
+declare const DEFAULT_BONE_FILTER: BoneFilterConfig;
+/**
+ * A generic animation track descriptor. Renderers map their native track
+ * objects to this shape for filtering, then map back.
+ */
+interface TrackDescriptor {
+    /** Full track name, e.g. "mixamorigHips.quaternion" or "Head.position". */
+    name: string;
+}
+/**
+ * Filter animation tracks according to a BoneFilterConfig.
+ *
+ * This is the renderer-agnostic core of `retargetClip`. Renderer adapters
+ * call this with their native track names and use the result to decide
+ * which tracks to keep.
+ *
+ * @returns true if the track should be KEPT (not filtered out).
+ */
+declare function shouldKeepTrack(trackName: string, config: BoneFilterConfig): boolean;
+/**
+ * Strip Mixamo prefix from a track name.
+ * "mixamorigHips.quaternion" → "Hips.quaternion"
+ */
+declare function stripMixamoPrefix(trackName: string): string;
+
 /**
  * FACS (Facial Action Coding System) to ARKit Blendshape Mapping
  *
@@ -5147,6 +5305,41 @@ declare class FaceCompositor {
     private applyProfileArrays;
 }
 
+/**
+ * TextEmotionAnalyzer — Lightweight keyword heuristic for mapping AI response
+ * text to an emotion label.
+ *
+ * Returns null if no strong signal is detected (keeps current emotion).
+ *
+ * @category Face
+ */
+/**
+ * Analyze AI response text for emotional content.
+ *
+ * @param text - The AI response text to analyze
+ * @returns An emotion label string, or null if no strong signal detected
+ */
+declare function analyzeTextEmotion(text: string): string | null;
+
+/**
+ * EmotionTagParser — Strips `[tag]` emotion annotations from LLM response text.
+ *
+ * LLMs can self-annotate responses with emotion tags like `[excited]` or `[sad]`.
+ * This parser extracts the first valid tag and returns clean display text.
+ *
+ * @category Face
+ */
+/**
+ * Parse emotion tags from LLM response text.
+ *
+ * @param text - Raw LLM response text, possibly containing `[emotion]` tags
+ * @returns Object with clean display text and extracted emotion label (or null)
+ */
+declare function parseEmotionTags(text: string): {
+    cleanText: string;
+    emotion: string | null;
+};
+
 /**
  * CharacterController — Renderer-agnostic avatar composition loop
  *
@@ -5230,6 +5423,9 @@ declare class CharacterController {
     private readonly gazeYawInfluence;
     private readonly gazePitchInfluence;
     private readonly gazeSmoothing;
+    private readonly frameTimes;
+    private frameTimeIdx;
+    private frameTimeFill;
     private readonly zeroBase;
     private readonly outputBuffer;
     private readonly compositorInput;
@@ -5249,6 +5445,17 @@ declare class CharacterController {
     setProfile(profile: CharacterProfile): void;
     /** Access underlying FaceCompositor for advanced use. */
     get compositor(): FaceCompositor;
+    /**
+     * Get a snapshot of frame budget performance (rolling 2-second window).
+     * Useful for runtime diagnostics / dev overlays.
+     */
+    getPerformanceSnapshot(): {
+        avgFrameUs: number;
+        maxFrameUs: number;
+        p95FrameUs: number;
+        droppedFrames: number;
+        totalFrames: number;
+    };
     /** Reset all state (smoothing, life layer, emotions). */
     reset(): void;
     dispose(): void;
@@ -5285,7 +5492,7 @@ interface MicLipSyncConfig {
     micChunkSize?: number;
     /** Per-character expression weight scaling */
     profile?: ExpressionProfile;
-    /** Identity/style index for Wav2Vec2 (default: 0) */
+    /** Identity/style index for A2E model (default: 0) */
     identityIndex?: number;
 }
 interface MicLipSyncFrame {
@@ -5324,9 +5531,10 @@ declare class MicLipSync extends EventEmitter<MicLipSyncEvents> {
     private _state;
     private _isSpeaking;
     private _currentFrame;
-    private _currentRawFrame;
     private profile;
     private _firstFrameEmitted;
+    private readonly _profileBuffer;
+    private vadQueue;
     private speechStartTime;
     private vadChunkSize;
     private vadBuffer;
@@ -5356,47 +5564,6 @@ declare class MicLipSync extends EventEmitter<MicLipSyncEvents> {
     private setState;
 }
 
-/**
- * Shared types for orchestration layer
- *
- * @category Orchestration
- */
-
-type VoicePipelineState = 'idle' | 'loading' | 'ready' | 'listening' | 'thinking' | 'speaking' | 'error';
-interface LoadingProgress {
-    currentModel: string;
-    progress: number;
-    totalModels: number;
-    modelsLoaded: number;
-}
-interface TranscriptResult {
-    text: string;
-    emotion?: string;
-    language?: string;
-    event?: string;
-    isFinal: boolean;
-    inferenceTimeMs?: number;
-}
-/**
- * Consumer's response handler. VoicePipeline calls this with transcribed text.
- * Consumer must stream audio back for playback + lip sync.
- */
-interface ResponseHandler {
-    (params: {
-        text: string;
-        emotion?: string;
-        event?: string;
-        /** Stream audio chunks to pipeline for playback + lip sync */
-        send: (chunk: Uint8Array) => Promise<void>;
-        /** Call when all audio has been sent */
-        done: () => Promise<void>;
-        /** Aborted on interruption or stop() */
-        signal: AbortSignal;
-        /** Session ID for backend correlation */
-        sessionId: string;
-    }): Promise<void>;
-}
-
 /**
  * VoicePipeline - Full conversational agent loop
  *
@@ -5429,10 +5596,9 @@ interface VoicePipelineBaseConfig {
             language?: string;
         };
         lam: {
-            gpuModelUrl: string;
-            gpuExternalDataUrl?: string | false;
-            cpuModelUrl: string;
-            mode?: 'auto' | 'gpu' | 'cpu';
+            modelUrl: string;
+            externalDataUrl?: string | false;
+            backend?: 'auto' | 'webgpu' | 'wasm';
         };
         vad: {
             modelUrl: string;
@@ -5442,10 +5608,8 @@ interface VoicePipelineBaseConfig {
     };
     /** Per-character expression weight scaling */
     profile?: ExpressionProfile;
-    /** Identity/style index for Wav2Vec2 (default: 0) */
+    /** Identity/style index for A2E model (default: 0) */
     identityIndex?: number;
-    /** LAM load timeout in ms — CPU fallback on timeout (default: 30000) */
-    lamLoadTimeoutMs?: number;
     /** Base silence timeout in ms (default: 500) */
     silenceTimeoutMs?: number;
     /** Extended silence timeout for long utterances (default: 700) */
@@ -5514,13 +5678,7 @@ interface VoicePipelineLocalConfig extends VoicePipelineBaseConfig {
     /** Optional text transform (e.g., LLM call). Receives transcript, returns response text. */
     onTranscript?: (text: string) => string | Promise<string>;
 }
-/** Legacy config (no mode field) — treated as cloud mode. @deprecated Use mode: 'cloud' explicitly. */
-interface VoicePipelineLegacyConfig extends VoicePipelineBaseConfig {
-    mode?: undefined;
-    /** Consumer's response handler */
-    onResponse: ResponseHandler;
-}
-type VoicePipelineConfig = VoicePipelineCloudConfig | VoicePipelineLocalConfig | VoicePipelineLegacyConfig;
+type VoicePipelineConfig = VoicePipelineCloudConfig | VoicePipelineLocalConfig;
 interface VoicePipelineEvents {
     'state': VoicePipelineState;
     'loading:progress': LoadingProgress;
@@ -5558,6 +5716,7 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private interruption;
     private omoteEvents;
     private mic;
+    private static readonly MAX_AUDIO_BUFFER_SAMPLES;
     private audioBuffer;
     private audioBufferSamples;
     private speechStartTime;
@@ -5568,7 +5727,10 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private lastProgressiveResult;
     private lastProgressiveSamples;
     private asrErrorCount;
+    private progressiveErrorCount;
     private responseAbortController;
+    private _unsubChunk;
+    private _unsubLevel;
     private _currentFrame;
     /** Current pipeline state */
     get state(): VoicePipelineState;
@@ -5586,7 +5748,7 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
      */
     private loadFromBackends;
     /**
-     * Load from factories (original path). Now loads SenseVoice, LAM, and VAD in parallel.
+     * Load from factories (original path). Loads SenseVoice, LAM, and VAD in parallel.
      */
     private loadFromFactories;
     start(): Promise<void>;
@@ -5612,4 +5774,86 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private clearSilenceTimer;
 }
 
-export { type A2EBackend, type A2EModelInfo, A2EOrchestrator, type A2EOrchestratorConfig, A2EProcessor, type A2EProcessorConfig, type A2EProgressEvent, type A2EResult, ALL_AUS, ARKIT_BLENDSHAPES, type AUActivation, AU_TO_ARKIT, type ActiveSpan, type AnimationClip, AnimationGraph, type AnimationGraphConfig, type AnimationGraphEvents, type AnimationLayer, type AnimationOutput, type AnimationState, type AnimationStateName, type AnimationTrigger, AudioChunkCoalescer, type AudioChunkCoalescerOptions, AudioEnergyAnalyzer, AudioScheduler, type AudioSchedulerOptions, BLENDSHAPE_TO_GROUP, type BackendPreference, type BlendWeight, type BlendshapeGroup, BlendshapeSmoother, type BlendshapeSmootherConfig, CTC_VOCAB, type CacheConfig, type CacheSpanAttributes, CharacterController, type CharacterControllerConfig, type CharacterProfile, type CharacterUpdateInput, type CharacterUpdateOutput, ConsoleExporter, type ConversationalState, type CreateA2EConfig, type CreateKokoroTTSConfig, type CreateSenseVoiceConfig, DEFAULT_ANIMATION_CONFIG, DEFAULT_MODEL_URLS, EMOTION_NAMES, EMOTION_TO_AU, EMOTION_VECTOR_SIZE, type EmotionAnimationMap, EmotionController, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, EmotionResolver, type EmotionWeights, EmphasisDetector, EventEmitter, type ExpressionProfile, FaceCompositor, type FaceCompositorConfig, type FaceCompositorInput, type FaceCompositorOutput, type FetchWithCacheOptions, type FullFaceFrame, FullFacePipeline, type FullFacePipelineEvents, type FullFacePipelineOptions, HF_CDN_URLS, INFERENCE_LATENCY_BUCKETS, type InferenceFactoryConfig, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, KOKORO_VOICES, type KokoroStreamChunk, type KokoroTTSConfig, KokoroTTSInference, type KokoroTTSModelInfo, type KokoroTTSResult, KokoroTTSUnifiedAdapter, KokoroTTSWorker, type KokoroVoiceName, LAM_BLENDSHAPES, type LifeLayerConfig, type LifeLayerInput, type LifeLayerOutput, type LoadingProgress, MODEL_LOAD_TIME_BUCKETS, type MetricData, MetricNames, MicLipSync, type MicLipSyncConfig, type MicLipSyncEvents, type MicLipSyncFrame, type MicLipSyncState, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, type ModelUrlKey, OTLPExporter, type OTLPExporterConfig, OmoteEvents, OmoteTelemetry, PlaybackPipeline, type PlaybackPipelineConfig, type PlaybackPipelineEvents, type PlaybackState, ProceduralLifeLayer, type Quat, type QuotaInfo, type ResolvedEmotion, type ResponseHandler, RingBuffer, type RuntimeBackend, type SafariSpeechConfig, SafariSpeechRecognition, type SamplingConfig, type SenseVoiceBackend, type SenseVoiceConfig, SenseVoiceInference, type SenseVoiceLanguage, type SenseVoiceModelInfo, type SenseVoiceResult, SenseVoiceUnifiedAdapter, SenseVoiceWorker, type SenseVoiceWorkerConfig, type SileroVADBackend, type SileroVADConfig, type SileroVADFactoryConfig, SileroVADInference, SileroVADUnifiedAdapter, SileroVADWorker, type SpanAttributes, type SpanData, type SpeechErrorCallback, type SpeechRecognitionResult, type SpeechResultCallback, type SpeechSegment, type SynthesizeOptions, type TTSBackend, type TTSChunk, TTSPlayback, type TTSPlaybackConfig, type TTSPlaybackEvents, type TTSStreamOptions, type TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TranscriptResult, type Transition, UnifiedInferenceWorker, type VADBackend, type VADModelInfo, type VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type Vec3, VoicePipeline, type VoicePipelineCloudConfig, type VoicePipelineConfig, type VoicePipelineEvents, type VoicePipelineLocalConfig, type VoicePipelineState, type Wav2ArkitCpuConfig, Wav2ArkitCpuInference, Wav2ArkitCpuUnifiedAdapter, Wav2ArkitCpuWorker, type Wav2ArkitCpuWorkerConfig, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, Wav2Vec2UnifiedAdapter, type WorkerHealthState, applyProfile, blendEmotions, calculatePeak, calculateRMS, configureCacheLimit, configureModelUrls, configureTelemetry, createA2E, createEmotionVector, createKokoroTTS, createSenseVoice, createSileroVAD, fetchWithCache, float32ToPcm16, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getModelCache, getOptimalWasmThreads, getRecommendedBackend, getTelemetry, hasWebGPUApi, int16ToFloat32, isAndroid, isIOS, isIOSSafari, isMobile, isSafari, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpBlendshapes, lerpEmotion, listVoices as listKokoroVoices, pcm16ToFloat32, preloadModels, resampleLinear, resetModelUrls, resolveBackend, resolveEmotion, shouldEnableWasmProxy, shouldUseCpuA2E, shouldUseNativeASR, shouldUseServerA2E, supportsVADWorker, ttsToPlaybackFormat };
+/**
+ * VoiceOrchestrator — Shared voice wiring for OmoteAvatar adapters.
+ *
+ * Composes TTSSpeaker (local mode) or PlaybackPipeline (cloud mode) with
+ * SpeechListener and InterruptionHandler. Supports both local TTS and
+ * cloud TTS via discriminated union config.
+ *
+ * Extracted from the ~70 identical lines duplicated across three/babylon/r3f
+ * adapters into a single reusable class.
+ *
+ * @category Orchestration
+ */
+
+interface VoiceOrchestratorBaseConfig {
+    listener?: SpeechListenerConfig;
+    interruptionEnabled?: boolean;
+    profile?: ExpressionProfile;
+}
+interface VoiceOrchestratorLocalConfig extends VoiceOrchestratorBaseConfig {
+    mode?: 'local';
+    tts: TTSBackend;
+    speaker?: TTSSpeakerConfig;
+    onTranscript: (text: string, emotion?: string) => string | Promise<string> | AsyncGenerator<string>;
+}
+interface VoiceOrchestratorCloudConfig extends VoiceOrchestratorBaseConfig {
+    mode: 'cloud';
+    onResponse: ResponseHandler;
+    lam?: {
+        modelUrl?: string;
+        externalDataUrl?: string | false;
+    };
+}
+type VoiceOrchestratorConfig = VoiceOrchestratorLocalConfig | VoiceOrchestratorCloudConfig;
+interface VoiceOrchestratorEvents {
+    'state': ConversationalState;
+    'transcript': TranscriptResult;
+    [key: string]: unknown;
+}
+declare class VoiceOrchestrator extends EventEmitter<VoiceOrchestratorEvents> {
+    private speechListener;
+    private interruption;
+    private ttsSpeaker;
+    private playbackPipeline;
+    private ownedLam;
+    private transcriptUnsub;
+    private audioChunkUnsub;
+    private connectEpoch;
+    private responseAbortController;
+    private _state;
+    private _isSpeaking;
+    private _frameSource;
+    private _mode;
+    private _sessionId;
+    get state(): ConversationalState;
+    get isSpeaking(): boolean;
+    get frameSource(): FrameSource | null;
+    /** Access the internal SpeechListener. */
+    get listener(): SpeechListener | null;
+    /** Access the internal TTSSpeaker (local mode only). */
+    get speaker(): TTSSpeaker | null;
+    connect(config: VoiceOrchestratorConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    startListening(): Promise<void>;
+    stopListening(): void;
+    speak(text: string, options?: {
+        signal?: AbortSignal;
+        voice?: string;
+    }): Promise<void>;
+    streamText(options?: {
+        signal?: AbortSignal;
+        voice?: string;
+    }): Promise<{
+        push: (token: string) => void;
+        end: () => Promise<void>;
+    }>;
+    stopSpeaking(): void;
+    private wireLocalTranscript;
+    private wireCloudTranscript;
+    private handleInterruption;
+    private setState;
+}
+
+export { type A2EBackend, A2EInference, type A2EInferenceConfig, type A2EModelInfo, A2EProcessor, type A2EProcessorConfig, type A2EResult, A2EUnifiedAdapter, ALL_AUS, ARKIT_BLENDSHAPES, type AUActivation, AU_TO_ARKIT, type ActiveSpan, type AnimationClip, type AnimationController, AnimationGraph, type AnimationGraphConfig, type AnimationGraphEvents, type AnimationLayer, type AnimationOutput, type AnimationSource, type AnimationSourceOptions, type AnimationState, type AnimationStateName, type AnimationTrigger, AudioChunkCoalescer, type AudioChunkCoalescerOptions, AudioEnergyAnalyzer, AudioScheduler, type AudioSchedulerOptions, BLENDSHAPE_TO_GROUP, type BackendPreference, type BlendWeight, type BlendshapeGroup, BlendshapeSmoother, type BlendshapeSmootherConfig, type BoneFilterConfig, type CacheConfig, type CacheSpanAttributes, CharacterController, type CharacterControllerConfig, type CharacterProfile, type CharacterUpdateInput, type CharacterUpdateOutput, ConsoleExporter, type ConversationalState, type CreateA2EConfig, type CreateKokoroTTSConfig, type CreateSenseVoiceConfig, type CreateTTSPlayerConfig, DEFAULT_ANIMATION_CONFIG, DEFAULT_BONE_FILTER, DEFAULT_MODEL_URLS, EMOTION_NAMES, EMOTION_TO_AU, EMOTION_VECTOR_SIZE, EXPLICIT_EMOTION_COUNT, type ElevenLabsConfig, ElevenLabsTTSBackend, type EmotionAnimationMap, EmotionController, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, EmotionResolver, type EmotionWeights, EmphasisDetector, type ErrorType, ErrorTypes, EventEmitter, type ExpressionProfile, FaceCompositor, type FaceCompositorConfig, type FaceCompositorInput, type FaceCompositorOutput, type FetchWithCacheOptions, type FrameSource, type FullFaceFrame, HF_CDN_URLS, INFERENCE_LATENCY_BUCKETS, type InferenceFactoryConfig, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, KOKORO_VOICES, type KokoroStreamChunk, type KokoroTTSConfig, KokoroTTSInference, type KokoroTTSModelInfo, type KokoroTTSResult, KokoroTTSUnifiedAdapter, KokoroTTSWorker, type KokoroVoiceName, LAM_BLENDSHAPES, type LifeLayerConfig, type LifeLayerInput, type LifeLayerOutput, type LoadingProgress, MIXAMO_PREFIX, MODEL_LOAD_TIME_BUCKETS, type MetricData, MetricNames, MicLipSync, type MicLipSyncConfig, type MicLipSyncEvents, type MicLipSyncFrame, type MicLipSyncState, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, type ModelUrlKey, OTLPExporter, type OTLPExporterConfig, OmoteEvents, OmoteTelemetry, PRESERVE_POSITION_BONES, PlaybackPipeline, type PlaybackPipelineConfig, type PlaybackPipelineEvents, type PlaybackState, type PollyConfig, type PollySynthesizeResult, PollyTTSBackend, ProceduralLifeLayer, type Quat, type QuotaInfo, type ResolvedEmotion, type ResponseHandler, RingBuffer, type RuntimeBackend, type SafariSpeechConfig, SafariSpeechRecognition, type SamplingConfig, type SenseVoiceBackend, type SenseVoiceConfig, SenseVoiceInference, type SenseVoiceLanguage, type SenseVoiceModelInfo, type SenseVoiceResult, SenseVoiceUnifiedAdapter, SenseVoiceWorker, type SenseVoiceWorkerConfig, type SileroVADBackend, type SileroVADConfig, type SileroVADFactoryConfig, SileroVADInference, SileroVADUnifiedAdapter, SileroVADWorker, type SpanAttributes, type SpanData, type SpeechErrorCallback, SpeechListener, type SpeechListenerConfig, type SpeechListenerEvents, type SpeechListenerState, type SpeechRecognitionResult, type SpeechResultCallback, type SpeechSegment, type SynthesizeOptions, type TTSBackend, type TTSChunk, TTSPlayback, type TTSPlaybackConfig, type TTSPlaybackEvents, TTSPlayer, TTSSpeaker, type TTSSpeakerConfig, type TTSStreamOptions, type TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TrackDescriptor, type TranscriptResult, type Transition, UnifiedInferenceWorker, type VADBackend, type VADModelInfo, type VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type Vec3, VoiceOrchestrator, type VoiceOrchestratorCloudConfig, type VoiceOrchestratorConfig, type VoiceOrchestratorEvents, type VoiceOrchestratorLocalConfig, VoicePipeline, type VoicePipelineCloudConfig, type VoicePipelineConfig, type VoicePipelineEvents, type VoicePipelineLocalConfig, type VoicePipelineState, A2EInference as Wav2Vec2Inference, type WorkerHealthState, analyzeTextEmotion, applyProfile, blendEmotions, calculatePeak, calculateRMS, configureCacheLimit, configureModelUrls, configureOrtCdn, configureTelemetry, createA2E, createEmotionVector, createKokoroTTS, createSenseVoice, createSileroVAD, createTTSPlayer, fetchWithCache, float32ToPcm16, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getModelCache, getOptimalWasmThreads, getOrtCdnBase, getRecommendedBackend, getTelemetry, hasWebGPUApi, int16ToFloat32, isAndroid, isIOS, isIOSSafari, isMobile, isSafari, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpBlendshapes, lerpEmotion, listVoices as listKokoroVoices, parseEmotionTags, pcm16ToFloat32, preloadModels, resampleLinear, resetModelUrls, resolveBackend, resolveEmotion, shouldEnableWasmProxy, shouldKeepTrack, shouldUseNativeASR, shouldUseServerA2E, stripMixamoPrefix, supportsVADWorker, ttsToPlaybackFormat, validateTTSInput };