@omote/core 0.6.6 → 0.9.1

package/dist/index.d.mts

@@ -1,8 +1,60 @@
 import { EventEmitter, OmoteEvents } from './events/index.mjs';
 export { AnimationEvent, BackendEvent, EmotionEvent, GazeEvent, STTFinalEvent, STTPartialEvent, SessionStateEvent, TTSEndEvent, TTSMarkEvent, TTSStartEvent, VisemeEvent } from './events/index.mjs';
-export { D as DEFAULT_LOGGING_CONFIG, I as ILogger, e as LOG_LEVEL_PRIORITY, b as LogEntry, L as LogFormatter, a as LogLevel, c as LogSink, d as LoggingConfig, f as configureLogging, i as createLogger, g as getLoggingConfig, n as noopLogger, r as resetLoggingConfig, s as setLogLevel, h as setLoggingEnabled } from './Logger-I_k4sGhM.mjs';
+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-BeUI6jG7.mjs';
 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';
 
+/**
+ * Audio format conversion utilities
+ *
+ * Bridges the gap between TTS engines (Float32 at various sample rates)
+ * and playback pipelines (Uint8Array PCM16 at 16kHz).
+ *
+ * @module audio/audioConvert
+ */
+/**
+ * Convert Float32 [-1,1] samples to PCM16 Uint8Array (little-endian).
+ *
+ * @param samples - Float32Array of normalized audio samples
+ * @returns Uint8Array of PCM16 bytes (2 bytes per sample, little-endian)
+ */
+declare function float32ToPcm16(samples: Float32Array): Uint8Array;
+/**
+ * Linear interpolation resampler.
+ * Good enough for speech (no sinc filtering needed).
+ *
+ * @param samples - Input audio samples
+ * @param fromRate - Source sample rate (e.g., 24000)
+ * @param toRate - Target sample rate (e.g., 16000)
+ * @returns Resampled Float32Array
+ */
+declare function resampleLinear(samples: Float32Array, fromRate: number, toRate: number): Float32Array;
+/**
+ * Convenience: resample + encode in one call.
+ * Converts TTS output (Float32 at TTS rate) to pipeline format (PCM16 Uint8Array at 16kHz).
+ *
+ * @param audio - Float32Array from TTS engine
+ * @param sourceRate - TTS engine's output sample rate (default: 24000)
+ * @param targetRate - Pipeline's expected sample rate (default: 16000)
+ * @returns Uint8Array PCM16 at target rate
+ */
+declare function ttsToPlaybackFormat(audio: Float32Array, sourceRate?: number, targetRate?: number): Uint8Array;
+
+/**
+ * Shared audio utility functions
+ *
+ * @module audio
+ */
+/**
+ * Safely convert an ArrayBuffer of PCM16 bytes to Float32 samples.
+ * Handles odd-length buffers by truncating to the nearest even byte boundary.
+ */
+declare function pcm16ToFloat32(buffer: ArrayBuffer): Float32Array;
+/**
+ * Convert Int16Array samples to Float32Array.
+ * Each sample is divided by 32768 to normalize to [-1, 1] range.
+ */
+declare function int16ToFloat32(int16: Int16Array): Float32Array;
+
 /**
  * Microphone capture - renderer-agnostic audio input
  *
@@ -119,6 +171,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
      *
@@ -377,19 +431,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
  *
@@ -427,9 +468,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
  */
@@ -458,15 +498,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 */
@@ -538,213 +585,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;
-
-/**
- * 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;
-}
-/**
- * Full face frame with scaled blendshapes
- */
-interface FullFaceFrame$1 {
-    /** Scaled 52 ARKit blendshapes (ExpressionProfile applied) */
-    blendshapes: Float32Array;
-    /** Raw A2E output (52 blendshapes, before profile scaling) */
-    rawBlendshapes: Float32Array;
-    /** AudioContext timestamp for this frame */
-    timestamp: number;
-}
-/**
- * Events emitted by FullFacePipeline
- */
-interface FullFacePipelineEvents {
-    /** New merged frame ready for display */
-    full_frame_ready: FullFaceFrame$1;
-    /** 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;
-}
+declare function applyProfile(raw: Float32Array, profile: ExpressionProfile, out?: Float32Array): Float32Array;
 
 /**
  * PlaybackPipeline - Audio playback + A2E lip sync with ExpressionProfile scaling
@@ -770,7 +611,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;
@@ -791,6 +632,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) */
@@ -809,10 +652,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> {
@@ -830,6 +669,7 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
     private staleWarningEmitted;
     private readonly staleThresholdMs;
     private frameLoopCount;
+    private sessionStartTime;
     private profile;
     private readonly neutralTransitionEnabled;
     private readonly neutralTransitionMs;
@@ -838,6 +678,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) */
@@ -849,6 +691,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
@@ -888,103 +732,161 @@ declare class PlaybackPipeline extends EventEmitter<PlaybackPipelineEvents> {
 }
 
 /**
- * Interruption Handler
+ * TTSBackend — Streaming text-to-speech backend interface.
  *
- * 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
+ * Any TTS engine (Kokoro, ElevenLabs, etc.) can implement this contract
+ * to integrate with TTSPlayback and VoicePipeline.
  *
- * Industry standards applied:
- * - vadThreshold: 0.5 (Silero VAD default)
- * - minSpeechDurationMs: 200ms (Google/Amazon barge-in standard)
- * - silenceTimeoutMs: 500ms (OpenAI Realtime API standard)
+ * @category Inference
  */
-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 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
- *
- * This module provides a way to dynamically load the appropriate ONNX Runtime bundle
- * based on the platform's capabilities. This is critical for iOS support because:
+ * Streaming TTS backend interface.
  *
- * 1. iOS Safari has WebGPU API but ONNX Runtime's WebGPU backend crashes
- * 2. Loading the WebGPU bundle wastes bandwidth and can cause issues
- * 3. WASM-only bundle is smaller and more reliable on iOS
+ * Implementations must provide:
+ * - `stream()` for sentence-by-sentence audio generation
+ * - `sampleRate` for format conversion
+ * - `load()` for model initialization
  *
- * Usage:
+ * @example
  * ```typescript
- * const ort = await getOnnxRuntime('wasm'); // Load WASM-only bundle
- * const ort = await getOnnxRuntime('webgpu'); // Load WebGPU bundle (includes WASM)
- * ```
+ * const kokoro: TTSBackend = new KokoroTTSInference({ defaultVoice: 'af_heart' });
+ * await kokoro.load();
  *
- * @module inference/onnxLoader
+ * for await (const chunk of kokoro.stream("Hello world!", { voice: 'af_heart' })) {
+ *   // chunk.audio is Float32Array at kokoro.sampleRate
+ * }
+ * ```
  */
+interface TTSBackend {
+    /** Stream audio chunks for given text. Each chunk: Float32Array at engine's native rate. */
+    stream(text: string, options?: TTSStreamOptions): AsyncGenerator<TTSChunk>;
+    /** Engine's native output sample rate (e.g., 24000 for Kokoro). */
+    readonly sampleRate: number;
+    /** Load model if not already loaded. */
+    load(): Promise<unknown>;
+    /** Whether model is loaded and ready. */
+    readonly isLoaded: boolean;
+    /** Release resources. */
+    dispose(): Promise<void>;
+}
+/**
+ * Options for TTSBackend.stream()
+ */
+interface TTSStreamOptions {
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Voice override per-call */
+    voice?: string;
+    /** Speed multiplier override per-call */
+    speed?: number;
+}
+/**
+ * A single chunk of TTS audio output
+ */
+interface TTSChunk {
+    /** Audio samples at engine's native sample rate */
+    audio: Float32Array;
+    /** Duration in seconds */
+    duration: number;
+    /** Sentence/segment text that produced this audio */
+    text?: string;
+}
 
 /**
- * Check if WebGPU is available and likely to work
+ * TTSPlayback — Composes TTSBackend + PlaybackPipeline for text → lip sync.
  *
- * This is more thorough than just checking navigator.gpu exists.
- * It actually requests an adapter to verify the GPU is accessible.
+ * Handles format conversion (Float32 @ TTS rate → PCM16 @ 16kHz)
+ * and sentence prefetch for gapless playback.
  *
- * @returns true if WebGPU is available and working
+ * @category Audio
+ */
+
+interface TTSPlaybackConfig {
+    /** TTS backend (e.g., KokoroTTSInference) */
+    tts: TTSBackend;
+    /** A2E inference backend (from createA2E) */
+    lam: A2EBackend;
+    /** Per-character expression weight scaling */
+    profile?: ExpressionProfile;
+    /** Prefetch next sentence while current plays. Default: true */
+    prefetch?: boolean;
+    /** 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;
+}
+interface TTSPlaybackEvents {
+    /** New frame ready for display */
+    'frame': FullFaceFrame;
+    /** Raw A2E frame */
+    'frame:raw': Float32Array;
+    /** Playback started */
+    'playback:start': {
+        time: number;
+    };
+    /** Playback completed */
+    'playback:complete': void;
+    /** Playback stopped (user-initiated) */
+    'playback:stop': void;
+    /** Error */
+    'error': Error;
+    [key: string]: unknown;
+}
+declare class TTSPlayback extends EventEmitter<TTSPlaybackEvents> {
+    private readonly config;
+    private _pipeline;
+    private initialized;
+    constructor(config: TTSPlaybackConfig);
+    /** Access underlying PlaybackPipeline for event subscriptions. */
+    get pipeline(): PlaybackPipeline | null;
+    /** Load TTS model + initialize PlaybackPipeline. */
+    initialize(): Promise<void>;
+    /**
+     * Synthesize text and play with lip sync.
+     * Streams sentences with prefetch for minimal gaps.
+     *
+     * @returns Resolves when playback completes
+     */
+    speak(text: string, options?: {
+        signal?: AbortSignal;
+        voice?: string;
+    }): Promise<void>;
+    /** Dispose of all resources. */
+    dispose(): Promise<void>;
+    private speakWithPrefetch;
+    private speakSequential;
+}
+
+/**
+ * Lazy ONNX Runtime loader with conditional WebGPU/WASM bundle loading
+ *
+ * This module provides a way to dynamically load the appropriate ONNX Runtime bundle
+ * based on the platform's capabilities. This is critical for iOS support because:
+ *
+ * 1. iOS Safari has WebGPU API but ONNX Runtime's WebGPU backend crashes
+ * 2. Loading the WebGPU bundle wastes bandwidth and can cause issues
+ * 3. WASM-only bundle is smaller and more reliable on iOS
+ *
+ * Usage:
+ * ```typescript
+ * const ort = await getOnnxRuntime('wasm'); // Load WASM-only bundle
+ * const ort = await getOnnxRuntime('webgpu'); // Load WebGPU bundle (includes WASM)
+ * ```
+ *
+ * @module inference/onnxLoader
+ */
+
+/**
+ * Check if WebGPU is available and likely to work
+ *
+ * This is more thorough than just checking navigator.gpu exists.
+ * It actually requests an adapter to verify the GPU is accessible.
+ *
+ * @returns true if WebGPU is available and working
  */
 declare function isWebGPUAvailable(): Promise<boolean>;
 
@@ -1082,116 +984,6 @@ declare class SenseVoiceInference {
     dispose(): Promise<void>;
 }
 
-/**
- * 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;
-}
-
 /**
  * Silero VAD (Voice Activity Detection) inference
  *
@@ -1459,6 +1251,7 @@ declare class SileroVADWorker {
     private config;
     private isLoading;
     private _isLoaded;
+    private poisoned;
     private state;
     private context;
     private readonly chunkSize;
@@ -1526,426 +1319,395 @@ declare class SileroVADWorker {
 }
 
 /**
- * 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
+ * Unified Inference Worker — single Web Worker hosting all ONNX models
  *
- * @category Inference
- *
- * @example Basic usage (auto-detect)
- * ```typescript
- * import { createSileroVAD } from '@omote/core';
+ * Runs all model loading and inference off the main thread, preventing
+ * InferenceSession.create() from blocking the renderer (5-30s).
  *
- * const vad = createSileroVAD({
- *   modelUrl: '/models/silero-vad.onnx',
- *   threshold: 0.5,
- * });
+ * 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.
  *
- * await vad.load();
- * const result = await vad.process(audioChunk);
- * if (result.isSpeech) {
- *   console.log('Speech detected!', result.probability);
- * }
- * ```
+ * This worker hosts SenseVoice + A2E + Silero VAD + Kokoro TTS in a single
+ * ORT instance. Same total model memory, but inference runs off-main-thread.
  *
- * @example Force worker usage
+ * Consumer usage:
  * ```typescript
- * const vad = createSileroVAD({
- *   modelUrl: '/models/silero-vad.onnx',
- *   useWorker: true, // Force Worker even on mobile
- * });
- * ```
+ * const worker = new UnifiedInferenceWorker();
+ * await worker.init();
  *
- * @example Force main thread
- * ```typescript
- * const vad = createSileroVAD({
- *   modelUrl: '/models/silero-vad.onnx',
- *   useWorker: false, // Force main thread
- * });
+ * const asr = createSenseVoice({ modelUrl: '...', unifiedWorker: worker });
+ * const lam = createA2E({ modelUrl: '...', unifiedWorker: worker });
+ * const vad = createSileroVAD({ modelUrl: '...', unifiedWorker: worker });
  * ```
+ *
+ * @category Inference
  */
 
+/** Health state of the unified worker */
+type WorkerHealthState = 'healthy' | 'unhealthy' | 'recovering';
 /**
- * Common interface for both SileroVADInference and SileroVADWorker
+ * Unified Inference Worker — single Web Worker for all ONNX models
  *
- * This interface defines the shared API that both implementations provide,
- * allowing consumers to use either interchangeably.
+ * 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.
  */
-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;
+declare class UnifiedInferenceWorker {
+    private worker;
+    private pendingRequests;
+    private initialized;
+    private healthState;
+    private consecutiveFailures;
+    private _generation;
+    private recovering;
+    private _workerBackend;
     /**
-     * Get chunk duration in milliseconds
+     * Initialize the worker (load ORT WASM from CDN)
      */
-    getChunkDurationMs(): number;
-}
-/**
- * Configuration for the Silero VAD factory
- *
- * Extends SileroVADConfig with worker-specific options.
- */
-interface SileroVADFactoryConfig extends Omit<SileroVADConfig, 'modelUrl'> {
-    /** Path or URL to the ONNX model. Default: HuggingFace CDN */
-    modelUrl?: string;
+    init(): Promise<void>;
+    loadSenseVoice(config: {
+        modelUrl: string;
+        tokensUrl: string;
+        language: number;
+        textNorm: number;
+    }): Promise<SenseVoiceModelInfo>;
+    transcribe(audio: Float32Array): Promise<SenseVoiceResult>;
+    disposeSenseVoice(): Promise<void>;
+    loadLAM(config: {
+        modelUrl: string;
+        externalDataUrl: string | null;
+        numIdentityClasses?: number;
+    }): Promise<A2EModelInfo>;
+    inferLAM(audio: Float32Array, identityIndex?: number): Promise<{
+        blendshapes: Float32Array;
+        numFrames: number;
+        numBlendshapes: number;
+        inferenceTimeMs: number;
+    }>;
+    disposeLAM(): Promise<void>;
+    loadKokoro(config: {
+        modelUrl: string;
+    }): Promise<{
+        loadTimeMs: number;
+    }>;
+    inferKokoro(tokens: number[], style: Float32Array, speed: number): Promise<{
+        audio: Float32Array;
+        inferenceTimeMs: number;
+    }>;
+    disposeKokoro(): Promise<void>;
+    loadVAD(config: {
+        modelUrl: string;
+        sampleRate: number;
+    }): Promise<VADWorkerModelInfo>;
+    processVAD(audio: Float32Array, state: Float32Array, context: Float32Array): Promise<{
+        probability: number;
+        state: Float32Array;
+        inferenceTimeMs: number;
+    }>;
+    resetVAD(): Promise<Float32Array>;
+    disposeVAD(): Promise<void>;
+    dispose(): Promise<void>;
+    /** Check if the worker is initialized and healthy */
+    get isReady(): boolean;
+    /** Current health state of the worker */
+    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;
+    private createWorker;
+    private handleWorkerMessage;
+    private sendMessage;
     /**
-     * Force worker usage (true), main thread (false), or auto-detect (undefined).
-     *
-     * Auto-detection behavior:
-     * - Desktop: Uses Worker (better responsiveness, off-main-thread)
-     * - Mobile: Uses main thread (avoids 5MB memory overhead)
-     *
-     * You can override this to:
-     * - `true`: Force Worker even on mobile (if you have memory headroom)
-     * - `false`: Force main thread even on desktop (for debugging)
-     *
-     * Default: undefined (auto-detect)
+     * Ping the worker to check if it's alive. If ping succeeds, worker was just
+     * busy with long inference. If ping fails, worker is truly stuck — recover.
      */
-    useWorker?: boolean;
+    private runHealthCheck;
     /**
-     * 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
+     * Terminate the stuck worker, create a new one, and re-initialize ORT.
+     * Model sessions are lost — adapters must reload via generation check.
      */
-    fallbackOnError?: boolean;
+    private recoverWorker;
+    private rejectAllPending;
+    private cleanup;
+}
+
+/**
+ * Shared base config for all inference factory functions.
+ *
+ * @category Inference
+ */
+
+/** Base config shared across all inference factory functions */
+interface InferenceFactoryConfig {
+    /**
+     * Worker mode:
+     * - 'auto' (default): Use Worker if supported, else main thread
+     * - true: Force Worker (throws if unsupported)
+     * - false: Force main thread
+     */
+    useWorker?: boolean | 'auto';
     /**
      * Unified inference worker instance.
-     * When provided, uses SileroVADUnifiedAdapter (shared single-ORT worker).
+     * When provided, routes inference through the shared worker,
+     * keeping all inference off the main thread.
      * Takes precedence over useWorker setting.
      */
     unifiedWorker?: UnifiedInferenceWorker;
 }
-/**
- * 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;
 
 /**
- * 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.
+ * Factory function for A2E inference
  *
- * 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)
+ * Creates an A2EBackend instance with zero-config defaults (HuggingFace CDN).
+ * Supports unified worker mode for iOS off-main-thread inference.
  *
  * @category Inference
  *
- * @example
+ * @example Auto-detect (recommended, zero-config)
  * ```typescript
- * import { Wav2ArkitCpuWorker } from '@omote/core';
+ * import { createA2E } from '@omote/core';
  *
- * const lam = new Wav2ArkitCpuWorker({
- *   modelUrl: '/models/wav2arkit_cpu.onnx',
- * });
- * await lam.load();
+ * const a2e = createA2E(); // uses HF CDN defaults (192MB fp16)
+ * await a2e.load();
+ * const { blendshapes } = await a2e.infer(audioSamples);
+ * ```
  *
- * const { blendshapes } = await lam.infer(audioSamples);
- * // blendshapes: Float32Array[] in LAM_BLENDSHAPES order, 30fps
+ * @example Custom model URL
+ * ```typescript
+ * const a2e = createA2E({ modelUrl: '/models/lam.onnx' });
  * ```
  */
 
 /**
- * Configuration for Wav2ArkitCpu Worker
+ * Configuration for the A2E factory
  */
-interface Wav2ArkitCpuWorkerConfig {
-    /** Path or URL to the wav2arkit_cpu ONNX model (.onnx graph file) */
-    modelUrl: string;
+interface CreateA2EConfig extends InferenceFactoryConfig {
+    /** URL for the ONNX model. Default: HuggingFace CDN */
+    modelUrl?: string;
     /**
-     * Path or URL to external model data file (.onnx.data weights).
-     * Default: `${modelUrl}.data` (e.g., /models/wav2arkit_cpu.onnx.data)
+     * URL for external model data file (.onnx.data weights).
+     * Default: `${modelUrl}.data`
      *
      * Set to `false` to skip external data loading (single-file models only).
      */
     externalDataUrl?: string | false;
+    /** Backend preference (default: 'auto') */
+    backend?: BackendPreference;
+    /** Number of identity classes (default: 12) */
+    numIdentityClasses?: number;
 }
 /**
- * Wav2ArkitCpu Worker - Lip sync inference in a Web Worker
+ * Create an A2E instance
  *
- * Runs wav2arkit_cpu inference off the main thread to prevent UI blocking.
- * Feature parity with Wav2ArkitCpuInference but runs in dedicated worker.
+ * @param config - Factory configuration
+ * @returns An A2EBackend instance
+ */
+declare function createA2E(config?: CreateA2EConfig): A2EBackend;
+
+/**
+ * Shared types for orchestration layer
  *
- * @see Wav2ArkitCpuInference for main-thread version
+ * @category Orchestration
  */
-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>;
+
+/**
+ * Generic frame source -- any object that emits 'frame' events with blendshapes.
+ *
+ * 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: (...args: any[]) => 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;
+}
+/**
+ * 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;
+        /** 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>;
+}
+
+/**
+ * TTSSpeaker — Shared helper for OmoteAvatar TTS integration.
+ *
+ * Encapsulates createA2E + TTSPlayback lifecycle so that renderer adapters
+ * (Three.js, Babylon.js) and the R3F hook can delegate with ~15 lines each.
+ *
+ * @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;
     /**
-     * Run inference on raw audio
+     * Connect a TTS backend.
      *
-     * Accepts variable-length audio (not fixed to 16000 samples).
-     * Output frames = ceil(30 * numSamples / 16000).
+     * When config includes `lam`, `unifiedWorker`, or `models`, the full lip sync
+     * pipeline is created (LAM + TTSPlayback + PlaybackPipeline).
      *
-     * @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
+     * 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.
      */
-    private queueInference;
+    connect(tts: TTSBackend, config?: TTSSpeakerConfig): Promise<void>;
     /**
-     * Dispose of the worker and free resources
+     * 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>;
-    /**
-     * Check if Web Workers are supported
-     */
-    static isSupported(): boolean;
 }
 
 /**
- * Unified Inference Worker — single Web Worker hosting all WASM models
+ * createTTSPlayer — Zero-config TTS player for audio-only playback.
  *
- * 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.
+ * Speaks text through speakers without an avatar. No LAM download, no lip sync.
  *
- * 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.
- *
- * Consumer usage:
+ * @example
  * ```typescript
- * const worker = new UnifiedInferenceWorker();
- * await worker.init();
+ * import { createTTSPlayer } from '@omote/core';
  *
- * const asr = createSenseVoice({ modelUrl: '...', unifiedWorker: worker });
- * const lam = createA2E({ gpuModelUrl: '...', cpuModelUrl: '...', unifiedWorker: worker });
- * const vad = createSileroVAD({ modelUrl: '...', unifiedWorker: worker });
+ * 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 Inference
+ * @category Audio
  */
 
-/**
- * Unified Inference Worker — single Web Worker for all WASM models
- *
- * Hosts SenseVoice, Wav2ArkitCpu, and Silero VAD in one ORT instance.
- * Eliminates the multi-worker memory problem on iOS.
- */
-declare class UnifiedInferenceWorker {
-    private worker;
-    private pendingRequests;
-    private initialized;
-    private poisoned;
-    /**
-     * Initialize the worker (load ORT WASM from CDN)
-     */
-    init(): Promise<void>;
-    loadSenseVoice(config: {
-        modelUrl: string;
-        tokensUrl: string;
-        language: number;
-        textNorm: number;
-    }): 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>;
-    loadVAD(config: {
-        modelUrl: string;
-        sampleRate: number;
-    }): Promise<VADWorkerModelInfo>;
-    processVAD(audio: Float32Array, state: Float32Array, context: Float32Array): Promise<{
-        probability: number;
-        state: Float32Array;
-        inferenceTimeMs: number;
-    }>;
-    resetVAD(): Promise<Float32Array>;
-    disposeVAD(): Promise<void>;
-    dispose(): Promise<void>;
-    /** Check if the worker is initialized and not poisoned */
-    get isReady(): boolean;
-    /** Check if Web Workers are supported */
-    static isSupported(): boolean;
-    private assertReady;
-    private createWorker;
-    private handleWorkerMessage;
-    private sendMessage;
-    private rejectAllPending;
-    private cleanup;
-}
-/**
- * SenseVoice adapter backed by UnifiedInferenceWorker
- *
- * Implements SenseVoiceBackend, delegating all inference to the shared worker.
- */
-declare class SenseVoiceUnifiedAdapter implements SenseVoiceBackend {
-    private worker;
-    private config;
-    private _isLoaded;
-    private languageId;
-    private textNormId;
-    private inferenceQueue;
-    constructor(worker: UnifiedInferenceWorker, config: SenseVoiceWorkerConfig);
-    get isLoaded(): boolean;
-    get backend(): 'wasm' | null;
-    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
-    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
-    dispose(): Promise<void>;
+interface CreateTTSPlayerConfig {
+    /** Voice to use (default: 'af_heart') */
+    voice?: string;
+    /** Model URL override */
+    modelUrl?: string;
+    /** Voice data base URL override */
+    voiceBaseUrl?: string;
 }
 /**
- * Wav2ArkitCpu adapter backed by UnifiedInferenceWorker
+ * Zero-config TTS player. Speak text through speakers without an avatar.
  *
- * Implements A2EBackend, delegating all inference to the shared worker.
+ * Uses Kokoro TTS (82M q8, ~92MB) with automatic worker selection.
+ * No LAM model is downloaded — audio plays directly through AudioScheduler.
  */
-declare class Wav2ArkitCpuUnifiedAdapter implements A2EBackend {
-    readonly modelId: "wav2arkit_cpu";
-    readonly chunkSize: number;
-    private worker;
-    private config;
-    private _isLoaded;
-    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>;
-}
+declare function createTTSPlayer(config?: CreateTTSPlayerConfig): TTSPlayer;
 /**
- * Silero VAD adapter backed by UnifiedInferenceWorker
- *
- * Implements SileroVADBackend, delegating all inference to the shared worker.
+ * Thin wrapper: TTSSpeaker in audio-only mode + delegated load().
  */
-declare class SileroVADUnifiedAdapter implements SileroVADBackend {
-    private worker;
-    private config;
-    private _isLoaded;
-    private state;
-    private context;
-    private readonly chunkSize;
-    private readonly contextSize;
-    private inferenceQueue;
-    private preSpeechBuffer;
-    private wasSpeaking;
-    constructor(worker: UnifiedInferenceWorker, config: SileroVADConfig);
+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;
-    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>;
 }
 
 /**
@@ -1986,69 +1748,521 @@ declare class SileroVADUnifiedAdapter implements SileroVADBackend {
  */
 
 /**
- * Common interface for both SenseVoiceInference and SenseVoiceWorker
+ * 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;
+    /** 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 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;
+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;
     /**
-     * Load the ONNX model
-     * @param onProgress - Optional progress callback (fires once at 100% for worker)
-     * @returns Model loading information
+     * 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
-     * @returns Transcription result
+     *
+     * @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>;
     /**
-     * Dispose of the model and free resources
+     * Queue inference to serialize worker calls
      */
-    dispose(): Promise<void>;
-}
-/**
- * Configuration for the SenseVoice factory
- */
-interface CreateSenseVoiceConfig {
-    /** 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';
+    private queueInference;
     /**
-     * Worker mode:
-     * - 'auto' (default): Use Worker if supported, else main thread
-     * - true: Force Worker (throws if unsupported)
-     * - false: Force main thread
+     * Dispose of the worker and free resources
      */
-    useWorker?: boolean | 'auto';
+    dispose(): Promise<void>;
     /**
-     * Unified inference worker instance.
-     * When provided, uses SenseVoiceUnifiedAdapter (shared single-ORT worker).
-     * Takes precedence over useWorker setting.
+     * Check if Web Workers are supported
      */
-    unifiedWorker?: UnifiedInferenceWorker;
+    static isSupported(): boolean;
 }
-/**
- * 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;
 
 /**
  * Shared blendshape constants and utilities for lip sync inference
  *
- * Contains LAM_BLENDSHAPES (canonical ordering), symmetrization, and
- * index remapping used by both Wav2Vec2Inference and Wav2ArkitCpuInference.
+ * 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.
@@ -2056,12 +2270,12 @@ declare function createSenseVoice(config?: CreateSenseVoiceConfig): SenseVoiceBa
  * @category Inference
  */
 /**
- * LAM model blendshape names in order (52 total)
- * NOTE: This is alphabetical ordering used by LAM, different from standard ARKit order
+ * ARKit blendshape names in alphabetical order (52 total)
+ * This is the canonical ordering used by all A2E models in the SDK.
  */
-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"];
+/** @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.
  *
@@ -2077,28 +2291,30 @@ declare const ARKIT_BLENDSHAPES: readonly ["browDownLeft", "browDownRight", "bro
 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;
     /**
@@ -2109,7 +2325,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;
     /**
@@ -2119,28 +2335,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;
@@ -2151,7 +2348,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)
@@ -2161,186 +2358,26 @@ declare class Wav2Vec2Inference implements A2EBackend {
     get isLoaded(): boolean;
     /** True if inference timed out and the session is permanently unusable */
     get isSessionPoisoned(): boolean;
-    /**
-     * Load the ONNX model
-     */
-    load(): Promise<ModelInfo>;
-    /**
-     * Run inference on raw audio
-     * @param audioSamples - Float32Array of raw audio at 16kHz
-     * @param identityIndex - Optional identity index (0-11, default 0 = neutral)
-     *
-     * Audio will be zero-padded or truncated to chunkSize samples.
-     */
-    infer(audioSamples: Float32Array, identityIndex?: number): Promise<Wav2Vec2Result>;
-    /**
-     * Queue inference to serialize ONNX session calls
-     */
-    private queueInference;
-    /**
-     * Get blendshape value by name for a specific frame
-     */
-    getBlendshape(blendshapes: Float32Array, name: typeof LAM_BLENDSHAPES[number]): number;
-    /**
-     * Dispose of the model and free resources
-     */
-    dispose(): Promise<void>;
-}
-
-/**
- * Default and user-configurable model URLs for all ONNX models
- *
- * Out of the box, models are served from HuggingFace CDN (`/resolve/main/`
- * endpoint with `Access-Control-Allow-Origin: *`). For production apps that
- * need faster or more reliable delivery, call {@link configureModelUrls} once
- * at startup to point any or all models at your own CDN.
- *
- * @category Inference
- *
- * @example Use HuggingFace defaults (zero-config)
- * ```typescript
- * import { createA2E } from '@omote/core';
- * const a2e = createA2E(); // fetches from HuggingFace CDN
- * ```
- *
- * @example Self-host on your own CDN
- * ```typescript
- * import { configureModelUrls, createA2E } from '@omote/core';
- *
- * configureModelUrls({
- *   lam: 'https://cdn.example.com/models/model_fp16.onnx',
- *   senseVoice: 'https://cdn.example.com/models/sensevoice.int8.onnx',
- *   // omitted keys keep HuggingFace defaults
- * });
- *
- * const a2e = createA2E(); // now fetches from your CDN
- * ```
- */
-/** Model URL keys that can be configured */
-type ModelUrlKey = 'lam' | 'wav2arkitCpu' | 'senseVoice' | 'sileroVad';
-/**
- * Resolved model URLs — user overrides take priority, HuggingFace CDN is fallback.
- *
- * All SDK factories (`createA2E`, `createSenseVoice`, `createSileroVAD`) and
- * orchestrators (`VoicePipeline`) read from this object. Call
- * {@link configureModelUrls} before constructing any pipelines to point
- * models at your own CDN.
- */
-declare const DEFAULT_MODEL_URLS: Readonly<Record<ModelUrlKey, string>>;
-/**
- * Configure custom model URLs. Overrides persist for the lifetime of the page.
- * Omitted keys keep their HuggingFace CDN defaults.
- *
- * Call this **once** at app startup, before constructing any pipelines.
- *
- * @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',
- *   senseVoice: 'https://cdn.example.com/models/sensevoice.int8.onnx',
- *   sileroVad: 'https://cdn.example.com/models/silero-vad.onnx',
- * });
- * ```
- *
- * @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)
+     * @param identityIndex - Optional identity index (0-11, default 0 = neutral)
+     *
+     * Audio will be zero-padded or truncated to chunkSize samples.
      */
-    infer(audioSamples: Float32Array, _identityIndex?: number): Promise<A2EResult>;
+    infer(audioSamples: Float32Array, identityIndex?: number): Promise<A2EResult>;
     /**
      * Queue inference to serialize ONNX session calls
      */
     private queueInference;
+    /**
+     * Get blendshape value by name for a specific frame
+     */
+    getBlendshape(blendshapes: Float32Array, name: typeof LAM_BLENDSHAPES[number]): number;
     /**
      * Dispose of the model and free resources
      */
@@ -2348,92 +2385,78 @@ declare class Wav2ArkitCpuInference implements A2EBackend {
 }
 
 /**
- * Factory function for A2E with automatic GPU/CPU model selection
- *
- * Provides a unified API that always tries Wav2Vec2 (LAM fp16) first:
- * - All platforms: Tries Wav2Vec2Inference (192MB fp16, external data format)
- * - Fallback: Gracefully falls back to wav2arkit_cpu if GPU model fails to load
+ * Default and user-configurable model URLs for all ONNX models
  *
- * The fp16 external data format (385KB graph + 192MB weights) enables iOS support:
- * - URL pass-through: ORT streams weights directly into WASM memory (~2MB JS heap)
- * - Basic graph optimization: avoids ~750-950MB peak from 'all' optimization
- * - If iOS OOMs during session creation, A2EWithFallback catches it and loads
- *   wav2arkit_cpu (1.86MB graph + 402MB weights) as a safe fallback.
+ * Out of the box, models are served from HuggingFace CDN (`/resolve/main/`
+ * endpoint with `Access-Control-Allow-Origin: *`). For production apps that
+ * need faster or more reliable delivery, call {@link configureModelUrls} once
+ * at startup to point any or all models at your own CDN.
  *
  * @category Inference
  *
- * @example Auto-detect (recommended, zero-config)
+ * @example Use HuggingFace defaults (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);
+ * const a2e = createA2E(); // fetches from HuggingFace CDN
  * ```
  *
- * @example Force CPU model
+ * @example Self-host on your own CDN
  * ```typescript
- * const a2e = createA2E({ mode: 'cpu' });
+ * import { configureModelUrls, createA2E } from '@omote/core';
+ *
+ * configureModelUrls({
+ *   lam: 'https://cdn.example.com/models/model_fp16.onnx',
+ *   senseVoice: 'https://cdn.example.com/models/sensevoice.int8.onnx',
+ *   // omitted keys keep HuggingFace defaults
+ * });
+ *
+ * const a2e = createA2E(); // now fetches from your CDN
  * ```
  */
-
+/** Model URL keys that can be configured */
+type ModelUrlKey = 'lam' | 'senseVoice' | 'sileroVad' | 'kokoroTTS' | 'kokoroVoices';
 /**
- * Configuration for the A2E factory
+ * Resolved model URLs — user overrides take priority, HuggingFace CDN is fallback.
+ *
+ * All SDK factories (`createA2E`, `createSenseVoice`, `createSileroVAD`) and
+ * orchestrators (`VoicePipeline`) read from this object. Call
+ * {@link configureModelUrls} before constructing any pipelines to point
+ * models at your own CDN.
  */
-interface CreateA2EConfig {
-    /** 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;
-    /**
-     * Use Web Worker for CPU model inference (default: false)
-     *
-     * When true, Wav2ArkitCpuWorker is used instead of Wav2ArkitCpuInference,
-     * running inference off the main thread to prevent UI blocking during
-     * model loading and inference.
-     *
-     * Only applies when the CPU model is selected (mode: 'cpu', auto on Safari/iOS,
-     * or fallback from GPU).
-     */
-    useWorker?: boolean;
-    /**
-     * Unified inference worker instance.
-     * When provided and CPU model is selected, uses Wav2ArkitCpuUnifiedAdapter.
-     * Takes precedence over useWorker setting for the CPU model path.
-     * GPU model (Wav2Vec2) always stays on main thread (WebGPU).
-     */
-    unifiedWorker?: UnifiedInferenceWorker;
-}
+declare const DEFAULT_MODEL_URLS: Readonly<Record<ModelUrlKey, string>>;
 /**
- * Create an A2E instance with automatic GPU/CPU model selection
+ * Configure custom model URLs. Overrides persist for the lifetime of the page.
+ * Omitted keys keep their HuggingFace CDN defaults.
  *
- * @param config - Factory configuration
- * @returns An A2EBackend instance (either GPU or CPU model)
+ * Call this **once** at app startup, before constructing any pipelines.
+ *
+ * @example Self-host all models
+ * ```typescript
+ * configureModelUrls({
+ *   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',
+ * });
+ * ```
+ *
+ * @example Override only one model
+ * ```typescript
+ * configureModelUrls({
+ *   lam: '/models/model_fp16.onnx', // self-hosted, same origin
+ * });
+ * ```
  */
-declare function createA2E(config?: CreateA2EConfig): A2EBackend;
+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>>;
 
 /**
  * A2EProcessor — Engine-agnostic audio-to-expression processor
@@ -2484,9 +2507,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) */
@@ -2495,6 +2515,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;
@@ -2510,6 +2531,8 @@ declare class A2EProcessor {
     private _latestFrame;
     private dripInterval;
     private lastPulledFrame;
+    private lastDequeuedTime;
+    private decayBuffer;
     private inferenceRunning;
     private pendingChunks;
     private getFrameCallCount;
@@ -2655,110 +2678,273 @@ declare class BlendshapeSmoother {
 }
 
 /**
- * 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.
+ * SenseVoice adapter backed by UnifiedInferenceWorker
  *
- * @category Inference
+ * Implements SenseVoiceBackend, delegating all inference to the shared worker.
  */
 
-/**
- * Progress event emitted during model download / compile
- */
-interface A2EProgressEvent {
-    phase: 'download' | 'compile';
-    progress: number;
+declare class SenseVoiceUnifiedAdapter implements SenseVoiceBackend {
+    private worker;
+    private config;
+    private _isLoaded;
+    private loadedGeneration;
+    private languageId;
+    private textNormId;
+    /** Per-adapter inference queue — ensures sequential state updates. */
+    private inferenceQueue;
+    constructor(worker: UnifiedInferenceWorker, config: SenseVoiceWorkerConfig);
+    get isLoaded(): boolean;
+    get backend(): 'wasm' | null;
+    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
+    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
+    dispose(): Promise<void>;
+    private assertLoaded;
 }
+
 /**
- * Configuration for the A2EOrchestrator
+ * A2E adapter backed by UnifiedInferenceWorker
+ *
+ * Implements A2EBackend, delegating all inference to the shared worker.
+ * Used on iOS to run A2E inference off the main thread via the unified worker.
  */
-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>;
+
+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;
+    constructor(worker: UnifiedInferenceWorker, config: {
+        modelUrl: string;
+        externalDataUrl?: string | false;
+        numIdentityClasses?: number;
+        chunkSize?: number;
+    });
+    get isLoaded(): boolean;
+    get backend(): RuntimeBackend | null;
+    load(): Promise<A2EModelInfo>;
+    infer(audioSamples: Float32Array, identityIndex?: number): Promise<A2EResult>;
+    dispose(): Promise<void>;
+    private assertLoaded;
 }
+
 /**
- * Renderer-agnostic A2E orchestrator.
+ * Kokoro TTS inference using ONNX Runtime Web
+ *
+ * Pure ONNX pipeline for browser-based text-to-speech. No transformers.js dependency.
+ * Uses eSpeak-NG WASM for phonemization and Kokoro-82M (q8, 92MB) for synthesis.
+ *
+ * Pipeline: Text → Normalize → Phonemize (eSpeak WASM) → Tokenize → Voice Style → ONNX → Audio
  *
- * Manages mic capture + delegates inference to {@link A2EProcessor}.
- * Adapters read `latestWeights` each frame to apply to their meshes.
+ * @category Inference
  *
- * @example Quick start (used by @omote/three and @omote/babylon adapters)
+ * @example Basic usage
  * ```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();
+ * import { KokoroTTSInference } from '@omote/core';
+ *
+ * const tts = new KokoroTTSInference({ defaultVoice: 'af_heart' });
+ * await tts.load();
+ *
+ * const { audio, duration } = await tts.synthesize("Hello world");
+ * // audio: Float32Array @ 24kHz
+ * ```
+ *
+ * @example Streaming (sentence-by-sentence)
+ * ```typescript
+ * for await (const chunk of tts.stream("First sentence. Second sentence.")) {
+ *   playbackPipeline.feedBuffer(chunk.audio);
+ * }
  * ```
+ *
+ * @module inference/KokoroTTSInference
  */
-declare class A2EOrchestrator {
-    private config;
-    private a2e;
-    private processor;
-    private stream;
-    private audioContext;
-    private scriptProcessor;
-    private nativeSampleRate;
-    private _isReady;
-    private _isStreaming;
+
+interface KokoroTTSConfig {
+    /** ONNX model URL (default: HF CDN q8, 92MB) */
+    modelUrl?: string;
+    /** Voice files base URL (default: HF CDN voices directory) */
+    voiceBaseUrl?: string;
+    /** Default voice (default: 'af_heart') */
+    defaultVoice?: string;
+    /** Backend preference (default: 'wasm' — WebGPU crashes on int64 input_ids) */
+    backend?: BackendPreference;
+    /** Speech speed multiplier (default: 1.0) */
+    speed?: number;
+}
+interface KokoroTTSResult {
+    /** Audio samples at 24kHz */
+    audio: Float32Array;
+    /** Duration in seconds */
+    duration: number;
+    /** Inference time in ms */
+    inferenceTimeMs: number;
+}
+interface KokoroStreamChunk {
+    /** Audio for this sentence */
+    audio: Float32Array;
+    /** Original text segment */
+    text: string;
+    /** Phonemes for this segment */
+    phonemes: string;
+    /** Duration in seconds */
+    duration: number;
+}
+interface KokoroTTSModelInfo {
+    /** Resolved backend */
+    backend: string;
+    /** Model load time in ms */
+    loadTimeMs: number;
+    /** Default voice */
+    defaultVoice: string;
+}
+interface SynthesizeOptions {
+    /** Voice to use (overrides defaultVoice) */
+    voice?: string;
+    /** 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;
+    private readonly voiceBaseUrl;
+    private ort;
+    private session;
     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;
+    private isLoading;
+    private poisoned;
+    private inferenceQueue;
+    private phonemizerReady;
+    private defaultVoiceLoaded;
+    /** Cached voice data (voice name → Float32Array) */
+    private loadedVoices;
+    constructor(config?: KokoroTTSConfig);
+    get isLoaded(): boolean;
+    get sampleRate(): number;
     /**
-     * Load the A2E model and create the processor
+     * Load the ONNX model, phonemizer WASM, and default voice.
+     * Safe to call multiple times (no-ops after first successful load).
      */
-    load(): Promise<void>;
+    load(): Promise<KokoroTTSModelInfo>;
     /**
-     * Start mic capture and inference loop
+     * Lazily initialize phonemizer and default voice on first use.
+     * Moves 100-200ms of main-thread blocking out of load() into first synthesis.
      */
-    start(): Promise<void>;
+    private ensureReady;
     /**
-     * Stop mic capture and inference loop
+     * Synthesize speech from text (one-shot, full audio output).
+     *
+     * @param text - Input text to synthesize
+     * @param options - Voice and speed overrides
+     * @returns Audio Float32Array at 24kHz with duration
      */
-    stop(): void;
+    synthesize(text: string, options?: SynthesizeOptions): Promise<KokoroTTSResult>;
+    /**
+     * Stream synthesis sentence-by-sentence (async generator).
+     * Splits text on sentence boundaries and yields audio for each.
+     *
+     * Compatible with both `SynthesizeOptions` (legacy) and `TTSStreamOptions` (TTSBackend).
+     *
+     * @param text - Input text (can be multiple sentences)
+     * @param options - Voice, speed, and abort signal overrides
+     */
+    stream(text: string, options?: SynthesizeOptions & TTSStreamOptions): AsyncGenerator<KokoroStreamChunk & TTSChunk>;
+    /**
+     * Preload a voice (fetches and caches the .bin file).
+     */
+    preloadVoice(voiceName: string): Promise<void>;
+    /**
+     * List available voice names.
+     */
+    listVoices(): string[];
+    /**
+     * Release the ONNX session and clear cached voices.
+     */
+    dispose(): Promise<void>;
+    private ensureVoice;
+    private queueInference;
+    private runInference;
+}
+
+/**
+ * Kokoro TTS adapter backed by UnifiedInferenceWorker
+ *
+ * Implements TTSBackend, delegating ONNX inference to the shared worker.
+ * Phonemization, tokenization, and voice loading stay on main thread (fast, <10ms).
+ * Only the heavy `session.run()` (~1-2s per sentence) goes to the worker.
+ */
+
+declare class KokoroTTSUnifiedAdapter implements TTSBackend {
+    private worker;
+    private readonly config;
+    private readonly modelUrl;
+    private readonly voiceBaseUrl;
+    private _isLoaded;
+    private loadedGeneration;
+    /** Per-adapter inference queue — ensures sequential state updates. */
+    private inferenceQueue;
+    private loadedVoices;
+    private phonemizerReady;
+    private defaultVoiceLoaded;
+    constructor(worker: UnifiedInferenceWorker, config?: KokoroTTSConfig);
+    get isLoaded(): boolean;
+    get sampleRate(): number;
+    load(): Promise<KokoroTTSModelInfo>;
+    stream(text: string, options?: SynthesizeOptions & TTSStreamOptions): AsyncGenerator<KokoroStreamChunk & TTSChunk>;
+    dispose(): Promise<void>;
+    private ensureVoice;
+    private assertLoaded;
+    private runWorkerInference;
+}
+
+/**
+ * Silero VAD adapter backed by UnifiedInferenceWorker
+ *
+ * Implements SileroVADBackend, delegating all inference to the shared worker.
+ */
+
+declare class SileroVADUnifiedAdapter implements SileroVADBackend {
+    private worker;
+    private config;
+    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;
 }
 
 /**
@@ -2961,14 +3147,208 @@ declare class SafariSpeechRecognition {
      */
     private setupEventHandlers;
     /**
-     * Emit result to all registered callbacks
+     * Emit result to all registered callbacks
+     */
+    private emitResult;
+    /**
+     * Emit error to all registered callbacks
+     */
+    private emitError;
+}
+
+/**
+ * Kokoro TTS Web Worker implementation
+ *
+ * Moves the heavy ONNX `session.run()` to a dedicated Web Worker to prevent
+ * main thread blocking (~1-2s per sentence on WASM). Phonemizer, tokenizer,
+ * and voice logic stay on the main thread (fast, <10ms combined).
+ *
+ * Architecture:
+ * ```
+ * Main Thread (KokoroTTSWorker):        Worker (WORKER_SCRIPT):
+ *   stream(text) →
+ *     splitSentences(text)
+ *     for each sentence:
+ *       phonemize(sentence)  → phonemes
+ *       tokenize(phonemes)   → tokens
+ *       ensureVoice()        → style
+ *       postMessage(tokens, style, speed)  ──→  session.run(feeds)
+ *       await result                       ←──  postMessage(audio)
+ *       yield {audio, text, phonemes, duration}
+ * ```
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { KokoroTTSWorker } from '@omote/core';
+ *
+ * const tts = new KokoroTTSWorker({ defaultVoice: 'af_heart' });
+ * await tts.load();
+ *
+ * for await (const chunk of tts.stream("Hello world!")) {
+ *   playbackPipeline.feedBuffer(chunk.audio);
+ * }
+ * ```
+ *
+ * @module inference/KokoroTTSWorker
+ */
+
+/**
+ * Kokoro TTS Worker — off-main-thread ONNX inference for non-blocking TTS.
+ *
+ * Phonemizer/tokenizer/voice logic run on the main thread (fast, <10ms).
+ * Only the heavy ONNX `session.run()` is delegated to the worker.
+ *
+ * Implements the same TTSBackend interface as KokoroTTSInference.
+ *
+ * @see KokoroTTSInference for main-thread version
+ */
+declare class KokoroTTSWorker implements TTSBackend {
+    private readonly config;
+    private readonly modelUrl;
+    private readonly voiceBaseUrl;
+    private worker;
+    private _isLoaded;
+    private isLoading;
+    private poisoned;
+    /** Serializes all worker calls (stream sentence chunks + synthesize) */
+    private inferenceQueue;
+    /** Cached voice data (voice name → Float32Array) */
+    private loadedVoices;
+    /** Pending message handlers */
+    private pendingResolvers;
+    constructor(config?: KokoroTTSConfig);
+    get isLoaded(): boolean;
+    get sampleRate(): number;
+    load(): Promise<KokoroTTSModelInfo>;
+    synthesize(text: string, options?: SynthesizeOptions): Promise<KokoroTTSResult>;
+    stream(text: string, options?: SynthesizeOptions & TTSStreamOptions): AsyncGenerator<KokoroStreamChunk & TTSChunk>;
+    preloadVoice(voiceName: string): Promise<void>;
+    listVoices(): string[];
+    dispose(): Promise<void>;
+    static isSupported(): boolean;
+    private ensureVoice;
+    private createWorker;
+    private handleWorkerMessage;
+    private sendMessage;
+    /**
+     * Queue worker inference through the serialization queue.
+     * Sends pre-computed tokens + style to worker, returns audio.
      */
-    private emitResult;
+    private runWorkerInference;
     /**
-     * Emit error to all registered callbacks
+     * One-shot synthesis (phonemize + tokenize + worker inference).
      */
-    private emitError;
+    private queueInference;
+}
+
+/**
+ * Factory function for Kokoro TTS with automatic Worker vs main thread selection
+ *
+ * Provides a unified API that automatically selects the optimal implementation:
+ * - Desktop: Uses KokoroTTSWorker (off-main-thread inference, no render hitching)
+ * - iOS: Uses KokoroTTSInference (main thread, shared ORT instance to avoid OOM)
+ *
+ * @category Inference
+ *
+ * @example Auto-detect (recommended)
+ * ```typescript
+ * import { createKokoroTTS } from '@omote/core';
+ *
+ * const tts = createKokoroTTS({ defaultVoice: 'af_heart' });
+ * await tts.load();
+ *
+ * for await (const chunk of tts.stream("Hello world!")) {
+ *   playbackPipeline.feedBuffer(chunk.audio);
+ * }
+ * ```
+ *
+ * @example Force worker
+ * ```typescript
+ * const tts = createKokoroTTS({ defaultVoice: 'af_heart', useWorker: true });
+ * ```
+ *
+ * @example Force main thread
+ * ```typescript
+ * const tts = createKokoroTTS({ defaultVoice: 'af_heart', useWorker: false });
+ * ```
+ */
+
+/**
+ * Configuration for the Kokoro TTS factory
+ */
+interface CreateKokoroTTSConfig extends KokoroTTSConfig, InferenceFactoryConfig {
 }
+/**
+ * Create a Kokoro TTS instance with automatic implementation selection.
+ *
+ * @param config - Factory configuration
+ * @returns A TTSBackend instance (either Worker or main thread)
+ */
+declare function createKokoroTTS(config?: CreateKokoroTTSConfig): TTSBackend;
+
+/** Available Kokoro v1.0 voices */
+declare const KOKORO_VOICES: {
+    readonly af_heart: "af_heart";
+    readonly af_alloy: "af_alloy";
+    readonly af_aoede: "af_aoede";
+    readonly af_bella: "af_bella";
+    readonly af_jessica: "af_jessica";
+    readonly af_kore: "af_kore";
+    readonly af_nicole: "af_nicole";
+    readonly af_nova: "af_nova";
+    readonly af_river: "af_river";
+    readonly af_sarah: "af_sarah";
+    readonly af_sky: "af_sky";
+    readonly am_adam: "am_adam";
+    readonly am_echo: "am_echo";
+    readonly am_eric: "am_eric";
+    readonly am_fenrir: "am_fenrir";
+    readonly am_liam: "am_liam";
+    readonly am_michael: "am_michael";
+    readonly am_onyx: "am_onyx";
+    readonly am_puck: "am_puck";
+    readonly am_santa: "am_santa";
+    readonly bf_alice: "bf_alice";
+    readonly bf_emma: "bf_emma";
+    readonly bf_isabella: "bf_isabella";
+    readonly bf_lily: "bf_lily";
+    readonly bm_daniel: "bm_daniel";
+    readonly bm_fable: "bm_fable";
+    readonly bm_george: "bm_george";
+    readonly bm_lewis: "bm_lewis";
+};
+type KokoroVoiceName = keyof typeof KOKORO_VOICES;
+/**
+ * List all available voice names.
+ */
+declare function listVoices(): string[];
+
+/**
+ * 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
@@ -3009,6 +3389,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
  *
@@ -3507,7 +3889,48 @@ declare const MetricNames: {
     readonly CACHE_HITS: "omote.cache.hits";
     /** Counter: Cache misses */
     readonly CACHE_MISSES: "omote.cache.misses";
+    /** 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)
  */
@@ -3585,6 +4008,7 @@ declare class OmoteTelemetry {
     private exporter;
     private activeTraceId;
     private metricsIntervalId;
+    private spanStack;
     private counters;
     private histograms;
     constructor(config: TelemetryConfig);
@@ -3682,6 +4106,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;
 }
 
 /**
@@ -4294,6 +4726,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.
@@ -4336,6 +4769,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
  *
@@ -4555,6 +5095,172 @@ 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
+ *
+ * Extracted from r3f's useOmoteAvatar + useGazeTracking.
+ * Owns FaceCompositor, emotion resolution, eye angle math, head smoothing.
+ * Pure function: input → output. No renderer side effects.
+ *
+ * @category Character
+ */
+
+/**
+ * Convert an emotion label string or EmotionWeights object to EmotionWeights.
+ * Cached to avoid per-frame string allocation.
+ */
+declare function resolveEmotion(emotion: string | EmotionWeights | null | undefined): EmotionWeights | undefined;
+/** Simple 3D vector (renderer-agnostic) */
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Quaternion (renderer-agnostic, for head rotation) */
+interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+interface CharacterControllerConfig {
+    /** FaceCompositor configuration */
+    compositor?: FaceCompositorConfig;
+    /** Gaze tracking config */
+    gaze?: {
+        enabled?: boolean;
+        yawInfluence?: number;
+        pitchInfluence?: number;
+        smoothing?: number;
+    };
+}
+interface CharacterUpdateInput {
+    /** Time since last frame in seconds */
+    deltaTime: number;
+    /** Scaled blendshapes from pipeline frame (or null when no frame) */
+    baseBlendshapes: Float32Array | null;
+    /** Raw blendshapes before profile scaling (optional) */
+    rawBlendshapes?: Float32Array | null;
+    /** Current emotion (string preset or weights object) */
+    emotion?: string | EmotionWeights | null;
+    /** Whether the avatar is currently speaking */
+    isSpeaking: boolean;
+    /** Current conversational state */
+    state: ConversationalState;
+    /** Audio energy level (0-1, drives emphasis/gesture intensity) */
+    audioEnergy?: number;
+    /** Camera world position (renderer provides in its own coords) */
+    cameraWorldPos?: Vec3;
+    /** Head bone world position (renderer provides in its own coords) */
+    headWorldPos?: Vec3;
+    /** Head bone world quaternion (for eye gaze local-space transform) */
+    headWorldQuat?: Quat;
+    /** Current avatar Y rotation in radians (for gaze compensation) */
+    avatarRotationY?: number;
+}
+interface CharacterUpdateOutput {
+    /** 52 ARKit blendshape values, clamped [0,1] — apply to morph targets */
+    blendshapes: Float32Array;
+    /** Head rotation delta (radians) — apply to head bone */
+    headDelta: {
+        yaw: number;
+        pitch: number;
+    };
+    /** Normalized eye targets for eye blendshapes */
+    eyeTargets: {
+        x: number;
+        y: number;
+    };
+}
+declare class CharacterController {
+    private readonly _compositor;
+    private readonly gazeEnabled;
+    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;
+    private gazeHeadYaw;
+    private gazeHeadPitch;
+    constructor(config?: CharacterControllerConfig);
+    /**
+     * Call each frame. Pure function: input → output. No renderer side effects.
+     *
+     * Composes A2E blendshapes, emotion, procedural life, gaze tracking
+     * into a single output frame.
+     */
+    update(input: CharacterUpdateInput): CharacterUpdateOutput;
+    /** Set emotion (string preset or weights object). */
+    setEmotion(emotion: string | EmotionWeights): void;
+    /** Update character profile at runtime. */
+    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;
+    /**
+     * Compute normalized eye targets from camera and head positions.
+     * Pure atan2/asin math — no renderer dependency.
+     */
+    private computeEyeTargets;
+    /**
+     * Compute smoothed head rotation. Returns target yaw/pitch values.
+     * Renderer is responsible for applying these to the head bone.
+     */
+    private computeHeadGaze;
+}
+
 /**
  * MicLipSync - Microphone → VAD → A2E → blendshapes
  *
@@ -4576,7 +5282,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 {
@@ -4615,8 +5321,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;
@@ -4646,47 +5354,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
  *
@@ -4700,19 +5367,28 @@ interface ResponseHandler {
  * @category Orchestration
  */
 
-interface VoicePipelineConfig {
-    /** URLs and options for model loading */
-    models: {
+/** Shared config options for all VoicePipeline modes */
+interface VoicePipelineBaseConfig {
+    /** Pre-built backends — skip internal factory creation. Takes precedence over `models`. */
+    backends?: {
+        asr: SenseVoiceBackend;
+        lam: A2EBackend;
+        vad: SileroVADBackend;
+        tts?: TTSBackend;
+    };
+    /** External unified worker (reuse across pipelines). Takes precedence over internal creation. */
+    unifiedWorker?: UnifiedInferenceWorker;
+    /** URLs and options for model loading. Required if `backends` not provided. */
+    models?: {
         senseVoice: {
             modelUrl: string;
             tokensUrl?: string;
             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;
@@ -4720,14 +5396,10 @@ interface VoicePipelineConfig {
             preSpeechBufferChunks?: number;
         };
     };
-    /** Consumer's response handler */
-    onResponse: ResponseHandler;
     /** 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) */
@@ -4763,6 +5435,40 @@ interface VoicePipelineConfig {
     /** Duration of neutral fade-out (default: 250ms) */
     neutralTransitionMs?: number;
 }
+/** Cloud TTS mode: consumer handles response + audio streaming */
+interface VoicePipelineCloudConfig extends VoicePipelineBaseConfig {
+    mode: 'cloud';
+    /** Consumer's response handler (streams audio back) */
+    onResponse: ResponseHandler;
+}
+/** Local TTS mode: SDK handles synthesis internally via TTSBackend */
+interface VoicePipelineLocalConfig extends VoicePipelineBaseConfig {
+    mode: 'local';
+    /**
+     * TTS backend (e.g., KokoroTTSInference). Provide either `tts` or `ttsConfig`.
+     *
+     * When `tts` is provided, VoicePipeline uses it as-is. On iOS, this means
+     * inference runs on the main thread (may cause UI freezes).
+     *
+     * Prefer `ttsConfig` for automatic unified worker integration on iOS.
+     */
+    tts?: TTSBackend;
+    /**
+     * Kokoro TTS configuration. When provided, VoicePipeline creates the TTS
+     * internally and passes the unified worker on iOS for off-main-thread inference.
+     *
+     * Takes precedence over `tts` if both are provided.
+     */
+    ttsConfig?: {
+        defaultVoice?: string;
+        speed?: number;
+        modelUrl?: string;
+        voiceBaseUrl?: string;
+    };
+    /** Optional text transform (e.g., LLM call). Receives transcript, returns response text. */
+    onTranscript?: (text: string) => string | Promise<string>;
+}
+type VoicePipelineConfig = VoicePipelineCloudConfig | VoicePipelineLocalConfig;
 interface VoicePipelineEvents {
     'state': VoicePipelineState;
     'loading:progress': LoadingProgress;
@@ -4787,6 +5493,7 @@ interface VoicePipelineEvents {
 }
 declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private readonly config;
+    private readonly isLocalMode;
     private _state;
     private stopped;
     private epoch;
@@ -4799,6 +5506,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;
@@ -4810,6 +5518,8 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private lastProgressiveSamples;
     private asrErrorCount;
     private responseAbortController;
+    private _unsubChunk;
+    private _unsubLevel;
     private _currentFrame;
     /** Current pipeline state */
     get state(): VoicePipelineState;
@@ -4821,6 +5531,15 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     get sessionId(): string | null;
     constructor(config: VoicePipelineConfig);
     loadModels(): Promise<void>;
+    /**
+     * Load from pre-built backends (dependency injection path).
+     * Loads any backends that aren't loaded yet.
+     */
+    private loadFromBackends;
+    /**
+     * Load from factories (original path). Loads SenseVoice, LAM, and VAD in parallel.
+     */
+    private loadFromFactories;
     start(): Promise<void>;
     stop(): void;
     setProfile(profile: ExpressionProfile): void;
@@ -4830,6 +5549,10 @@ declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
     private onSilenceDetected;
     private processEndOfSpeech;
     private callResponseHandler;
+    /** Cloud mode: delegate to consumer's onResponse handler */
+    private handleCloudResponse;
+    /** Local mode: synthesize text with TTSBackend, stream to PlaybackPipeline */
+    private handleLocalResponse;
     private handleInterruption;
     private startProgressiveTranscription;
     private stopProgressiveTranscription;
@@ -4840,4 +5563,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, type CharacterProfile, ConsoleExporter, type ConversationalState, type CreateA2EConfig, 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 InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, 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 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 TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TranscriptResult, type Transition, UnifiedInferenceWorker, type VADBackend, type VADModelInfo, type VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, VoicePipeline, type VoicePipelineConfig, type VoicePipelineEvents, type VoicePipelineState, type Wav2ArkitCpuConfig, Wav2ArkitCpuInference, Wav2ArkitCpuUnifiedAdapter, Wav2ArkitCpuWorker, type Wav2ArkitCpuWorkerConfig, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, applyProfile, blendEmotions, calculatePeak, calculateRMS, configureCacheLimit, configureModelUrls, configureTelemetry, createA2E, createEmotionVector, createSenseVoice, createSileroVAD, fetchWithCache, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getModelCache, getOptimalWasmThreads, getRecommendedBackend, getTelemetry, hasWebGPUApi, isAndroid, isIOS, isIOSSafari, isMobile, isSafari, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpBlendshapes, lerpEmotion, preloadModels, resetModelUrls, resolveBackend, shouldEnableWasmProxy, shouldUseCpuA2E, shouldUseNativeASR, shouldUseServerA2E, supportsVADWorker };
+/**
+ * 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 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, 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 };