@omote/core 0.5.7 → 0.6.4

package/dist/index.d.mts

@@ -380,7 +380,7 @@ declare function isSafari(): boolean;
 /**
  * Recommend using CPU-optimized A2E model (wav2arkit_cpu)
  *
- * All iOS browsers use WebKit and have tight memory limits — the 384MB
+ * 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).
  *
@@ -427,8 +427,8 @@ declare function shouldUseServerA2E(): boolean;
 /**
  * Common interface for audio-to-expression (A2E) inference backends
  *
- * Both Wav2Vec2Inference (GPU, 384MB) and Wav2ArkitCpuInference (CPU, 404MB)
- * implement this interface, allowing SyncedAudioPipeline and LAMPipeline to
+ * Both Wav2Vec2Inference (GPU, 192MB fp16) and Wav2ArkitCpuInference (CPU, 404MB)
+ * implement this interface, allowing FullFacePipeline and A2EProcessor to
  * work with either model transparently.
  *
  * @category Inference
@@ -461,7 +461,7 @@ interface A2EResult {
  * Common interface for A2E (audio-to-expression) inference engines
  *
  * Implemented by:
- * - Wav2Vec2Inference (WebGPU/WASM, 384MB, ASR + A2E)
+ * - Wav2Vec2Inference (WebGPU/WASM, 192MB fp16, A2E)
  * - Wav2ArkitCpuInference (WASM-only, 404MB, A2E only)
  */
 interface A2EBackend {
@@ -492,38 +492,13 @@ interface A2EBackend {
 }
 
 /**
- * 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
+ * ExpressionProfile - Per-character weight scaling for A2E blendshape 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.
+ * Maps blendshape groups (eyes, brows, jaw, mouth, cheeks, nose, tongue)
+ * to weight scalers. Used by PlaybackPipeline, MicLipSync, and VoicePipeline.
  *
  * @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);
- * ```
  */
-
 type BlendshapeGroup = 'eyes' | 'brows' | 'jaw' | 'mouth' | 'cheeks' | 'nose' | 'tongue';
 /**
  * Per-character weight scaling for A2E blendshape output.
@@ -555,6 +530,53 @@ interface ExpressionProfile {
  * Built once at module load from prefix matching.
  */
 declare const BLENDSHAPE_TO_GROUP: Map<string, BlendshapeGroup>;
+/**
+ * Apply ExpressionProfile scaling to raw A2E blendshapes.
+ *
+ * For each blendshape:
+ * 1. If an override exists for the blendshape name, use override as scaler
+ * 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
  */
@@ -605,7 +627,7 @@ interface FullFacePipelineOptions {
 /**
  * Full face frame with scaled blendshapes
  */
-interface FullFaceFrame {
+interface FullFaceFrame$1 {
     /** Scaled 52 ARKit blendshapes (ExpressionProfile applied) */
     blendshapes: Float32Array;
     /** Raw A2E output (52 blendshapes, before profile scaling) */
@@ -618,7 +640,7 @@ interface FullFaceFrame {
  */
 interface FullFacePipelineEvents {
     /** New merged frame ready for display */
-    full_frame_ready: FullFaceFrame;
+    full_frame_ready: FullFaceFrame$1;
     /** Raw LAM frame ready (for debugging/monitoring) */
     lam_frame_ready: Float32Array;
     /** Playback has completed */
@@ -664,10 +686,7 @@ declare class FullFacePipeline extends EventEmitter<FullFacePipelineEvents> {
     /**
      * Apply ExpressionProfile scaling to raw A2E blendshapes.
      *
-     * For each blendshape:
-     * 1. If an override exists for the blendshape name, use override as scaler
-     * 2. Otherwise, use the group scaler (default 1.0)
-     * 3. Clamp result to [0, 1]
+     * Delegates to the standalone applyProfile() utility from expressionProfile.ts.
      */
     applyProfile(raw: Float32Array): Float32Array;
     /**
@@ -727,6 +746,147 @@ declare class FullFacePipeline extends EventEmitter<FullFacePipelineEvents> {
     dispose(): void;
 }
 
+/**
+ * PlaybackPipeline - Audio playback + A2E lip sync with ExpressionProfile scaling
+ *
+ * Refactored superset of FullFacePipeline. Adds:
+ * - Sync mode (`feedBuffer`) for pre-recorded audio
+ * - State tracking (idle → playing → stopping)
+ * - Opt-in neutral transition animation on playback complete
+ * - Idempotent `start()` (no spurious playback:complete on restart)
+ *
+ * @category Audio
+ */
+
+type PlaybackState = 'idle' | 'playing' | 'stopping';
+interface PlaybackPipelineConfig {
+    /** A2E inference backend (from createA2E) */
+    lam: A2EBackend;
+    /** Sample rate in Hz (default: 16000) */
+    sampleRate?: number;
+    /** Target chunk duration for coalescing in ms (default: 200) */
+    chunkTargetMs?: number;
+    /** Audio playback delay in ms (default: auto-detected from backend) */
+    audioDelayMs?: number;
+    /** A2E inference chunk size in samples (default: 16000) */
+    chunkSize?: number;
+    /** Identity/style index for Wav2Vec2 (default: 0) */
+    identityIndex?: number;
+    /** Per-character expression weight scaling */
+    profile?: ExpressionProfile;
+    /** Enable neutral transition on playback complete (default: false) */
+    neutralTransitionEnabled?: boolean;
+    /** Duration of neutral fade-out in ms (default: 250). Only applies when neutralTransitionEnabled=true. */
+    neutralTransitionMs?: number;
+    /** Stale frame warning threshold in ms (default: 2000) */
+    staleThresholdMs?: number;
+}
+/**
+ * Full face frame with scaled blendshapes
+ */
+interface FullFaceFrame {
+    /** 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;
+}
+interface PlaybackPipelineEvents {
+    /** New frame ready for display (scaled by ExpressionProfile) */
+    'frame': FullFaceFrame;
+    /** Raw A2E frame (before profile scaling) */
+    'frame:raw': Float32Array;
+    /** Playback started (first audio scheduled) */
+    'playback:start': {
+        time: number;
+    };
+    /** Playback completed naturally */
+    'playback:complete': void;
+    /** Playback stopped (user-initiated) */
+    'playback:stop': void;
+    /** Error occurred */
+    '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> {
+    private readonly config;
+    private scheduler;
+    private coalescer;
+    private processor;
+    private readonly sampleRate;
+    private _state;
+    private playbackStarted;
+    private monitorInterval;
+    private frameAnimationId;
+    private lastNewFrameTime;
+    private lastKnownLamFrame;
+    private staleWarningEmitted;
+    private readonly staleThresholdMs;
+    private frameLoopCount;
+    private profile;
+    private readonly neutralTransitionEnabled;
+    private readonly neutralTransitionMs;
+    private neutralTransitionFrame;
+    private neutralTransitionStart;
+    private neutralAnimationId;
+    private _currentFrame;
+    private _currentRawFrame;
+    /** Current pipeline state */
+    get state(): PlaybackState;
+    /** Current scaled blendshapes (updated in-place for perf) */
+    get currentFrame(): Float32Array | null;
+    /** Raw A2E blendshapes (before profile scaling) */
+    get currentRawFrame(): Float32Array | null;
+    constructor(config: PlaybackPipelineConfig);
+    /** Initialize AudioContext (lazy, call after user gesture) */
+    initialize(): Promise<void>;
+    /** Update ExpressionProfile at runtime */
+    setProfile(profile: ExpressionProfile): void;
+    /**
+     * Start a new playback session.
+     * Idempotent — calling during playback resets cleanly without emitting
+     * spurious playback:complete.
+     */
+    start(): void;
+    /** Feed a streaming audio chunk (PCM16 Uint8Array) */
+    onAudioChunk(chunk: Uint8Array): Promise<void>;
+    /** Signal end of audio stream (flushes remaining audio) */
+    end(): Promise<void>;
+    /**
+     * Feed a complete audio buffer. Chunks into 200ms pieces, schedules each
+     * for playback, runs A2E inference, then waits for completion.
+     */
+    feedBuffer(audio: ArrayBuffer | Float32Array): Promise<void>;
+    /** Stop playback immediately with fade-out */
+    stop(fadeOutMs?: number): Promise<void>;
+    /** Cleanup all resources */
+    dispose(): void;
+    /** Get pipeline debug state */
+    getDebugState(): {
+        state: PlaybackState;
+        playbackStarted: boolean;
+        coalescerFill: number;
+        processorFill: number;
+        queuedFrames: number;
+        currentTime: number;
+        playbackEndTime: number;
+    };
+    private startFrameLoop;
+    private startMonitoring;
+    private onPlaybackComplete;
+    private startNeutralTransition;
+    private cancelNeutralTransition;
+    private stopInternal;
+    private setState;
+}
+
 /**
  * Interruption Handler
  *
@@ -1456,7 +1616,9 @@ interface SileroVADBackend {
  *
  * Extends SileroVADConfig with worker-specific options.
  */
-interface SileroVADFactoryConfig extends SileroVADConfig {
+interface SileroVADFactoryConfig extends Omit<SileroVADConfig, 'modelUrl'> {
+    /** Path or URL to the ONNX model. Default: HuggingFace CDN */
+    modelUrl?: string;
     /**
      * Force worker usage (true), main thread (false), or auto-detect (undefined).
      *
@@ -1529,7 +1691,7 @@ declare function supportsVADWorker(): boolean;
  * const vadMain = createSileroVAD({ modelUrl: '/models/silero-vad.onnx', useWorker: false });
  * ```
  */
-declare function createSileroVAD(config: SileroVADFactoryConfig): SileroVADBackend;
+declare function createSileroVAD(config?: SileroVADFactoryConfig): SileroVADBackend;
 
 /**
  * Web Worker-based wav2arkit_cpu lip sync inference
@@ -1852,8 +2014,8 @@ interface SenseVoiceBackend {
  * Configuration for the SenseVoice factory
  */
 interface CreateSenseVoiceConfig {
-    /** Path or URL to model.int8.onnx (239MB) */
-    modelUrl: string;
+    /** 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') */
@@ -1880,7 +2042,7 @@ interface CreateSenseVoiceConfig {
  * @param config - Factory configuration
  * @returns A SenseVoiceBackend instance (either Worker or main thread)
  */
-declare function createSenseVoice(config: CreateSenseVoiceConfig): SenseVoiceBackend;
+declare function createSenseVoice(config?: CreateSenseVoiceConfig): SenseVoiceBackend;
 
 /**
  * Shared blendshape constants and utilities for lip sync inference
@@ -1915,12 +2077,10 @@ declare const ARKIT_BLENDSHAPES: readonly ["browDownLeft", "browDownRight", "bro
 declare function lerpBlendshapes(current: Float32Array | number[], target: Float32Array | number[], factor?: number): number[];
 
 /**
- * Unified Wav2Vec2 inference engine for Audio-to-Expression + ASR
+ * Wav2Vec2 inference engine for Audio-to-Expression (A2E)
  *
  * Runs entirely in the browser using WebGPU or WASM.
- * Takes raw 16kHz audio and outputs:
- * - 52 ARKit blendshapes (lip sync)
- * - 32-token CTC logits (speech recognition)
+ * Takes raw 16kHz audio and outputs 52 ARKit blendshapes for lip sync.
  *
  * @category Inference
  *
@@ -1928,14 +2088,12 @@ declare function lerpBlendshapes(current: Float32Array | number[], target: Float
  * ```typescript
  * import { Wav2Vec2Inference } from '@omote/core';
  *
- * const wav2vec = new Wav2Vec2Inference({ modelUrl: '/models/unified_wav2vec2_asr_a2e.onnx' });
+ * const wav2vec = new Wav2Vec2Inference({ modelUrl: '/models/model.onnx' });
  * await wav2vec.load();
  *
  * // Process 1 second of audio (16kHz = 16000 samples)
  * const result = await wav2vec.infer(audioSamples);
- *
  * console.log('Blendshapes:', result.blendshapes); // [30, 52] for 30fps
- * console.log('ASR text:', result.text); // Decoded transcription
  * ```
  */
 
@@ -1968,21 +2126,16 @@ interface ModelInfo {
     outputNames: string[];
 }
 
-/** CTC vocabulary (32 tokens from wav2vec2-base-960h) */
+/**
+ * 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[];
-    /** Raw CTC logits [frames, 32] - 50fps */
-    asrLogits: Float32Array[];
-    /** Decoded text from CTC */
-    text: string;
-    /** Number of blendshape frames (30fps) — alias for numA2EFrames */
+    /** Number of blendshape frames (30fps) */
     numFrames: number;
-    /** Number of A2E frames (30fps) */
-    numA2EFrames: number;
-    /** Number of ASR frames (50fps) */
-    numASRFrames: number;
     /** Inference time in ms */
     inferenceTimeMs: number;
 }
@@ -2020,10 +2173,6 @@ declare class Wav2Vec2Inference implements A2EBackend {
      * Audio will be zero-padded or truncated to chunkSize samples.
      */
     infer(audioSamples: Float32Array, identityIndex?: number): Promise<Wav2Vec2Result>;
-    /**
-     * Decode CTC logits to text using greedy decoding
-     */
-    private decodeCTC;
     /**
      * Queue inference to serialize ONNX session calls
      */
@@ -2038,10 +2187,85 @@ declare class Wav2Vec2Inference implements A2EBackend {
     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 (384MB) designed
+ * 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:
@@ -2128,41 +2352,33 @@ declare class Wav2ArkitCpuInference implements A2EBackend {
  *
  * Provides a unified API that automatically selects the optimal model:
  * - Safari (macOS + iOS): Uses Wav2ArkitCpuInference (404MB, WASM)
- * - Chrome/Firefox/Edge: Uses Wav2Vec2Inference (384MB, WebGPU)
+ * - Chrome/Firefox/Edge: Uses Wav2Vec2Inference (192MB fp16, WebGPU)
  * - Fallback: Gracefully falls back to CPU model if GPU model fails to load
  *
  * Why two separate models?
  * Wav2Vec2 (LAM) cannot run on Safari/iOS for two reasons:
  * 1. Its dual-head transformer graph needs ~750-950MB peak during ORT session
  *    creation (graph optimization), exceeding iOS WebKit's ~1-1.5GB tab limit.
- * 2. It ships as a single 384MB .onnx file that must load into JS heap before
- *    ORT can consume it. iOS WebKit OOMs on this allocation.
+ * 2. It ships as a single 192MB .onnx file (fp16) that must load into JS heap
+ *    before ORT can consume it. iOS WebKit OOMs on this allocation.
  * wav2arkit_cpu solves both: external data format (1.86MB graph + 402MB weights)
  * lets ORT load only the tiny graph, then stream weights via URL pass-through
  * directly into WASM memory. JS heap stays at ~2MB.
  *
  * @category Inference
  *
- * @example Auto-detect (recommended)
+ * @example Auto-detect (recommended, zero-config)
  * ```typescript
  * import { createA2E } from '@omote/core';
  *
- * const a2e = createA2E({
- *   gpuModelUrl: '/models/unified_wav2vec2_asr_a2e.onnx',
- *   cpuModelUrl: '/models/wav2arkit_cpu.onnx',
- * });
- *
+ * const a2e = createA2E(); // uses HF CDN defaults (192MB fp16 GPU, 404MB CPU fallback)
  * await a2e.load();
  * const { blendshapes } = await a2e.infer(audioSamples);
  * ```
  *
  * @example Force CPU model
  * ```typescript
- * const a2e = createA2E({
- *   gpuModelUrl: '/models/unified_wav2vec2_asr_a2e.onnx',
- *   cpuModelUrl: '/models/wav2arkit_cpu.onnx',
- *   mode: 'cpu',
- * });
+ * const a2e = createA2E({ mode: 'cpu' });
  * ```
  */
 
@@ -2170,8 +2386,8 @@ declare class Wav2ArkitCpuInference implements A2EBackend {
  * Configuration for the A2E factory
  */
 interface CreateA2EConfig {
-    /** URL for the GPU model (Wav2Vec2, used on Chrome/Firefox/Edge) */
-    gpuModelUrl: string;
+    /** 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`
@@ -2179,8 +2395,8 @@ interface CreateA2EConfig {
      * 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) */
-    cpuModelUrl: string;
+    /** 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)
@@ -2222,7 +2438,7 @@ interface CreateA2EConfig {
  * @param config - Factory configuration
  * @returns An A2EBackend instance (either GPU or CPU model)
  */
-declare function createA2E(config: CreateA2EConfig): A2EBackend;
+declare function createA2E(config?: CreateA2EConfig): A2EBackend;
 
 /**
  * A2EProcessor — Engine-agnostic audio-to-expression processor
@@ -2455,6 +2671,10 @@ declare class BlendshapeSmoother {
  * drip-feeding to {@link A2EProcessor}. This class only handles mic capture
  * (getUserMedia, ScriptProcessorNode, resampling).
  *
+ * @deprecated Use {@link MicLipSync} from `@omote/core` instead. MicLipSync provides
+ * the same mic → A2E composition with proper MicrophoneCapture integration, VAD support,
+ * ExpressionProfile scaling, and pause/resume. This class will be removed in a future version.
+ *
  * @category Inference
  */
 
@@ -3947,10 +4167,12 @@ declare class EmphasisDetector {
  * breathing/postural sway, and simplex noise-driven brow drift.
  *
  * Research sources:
- * - Blink frequency: 15-20/min (every 3-4s), PMC4043155
+ * - Blink frequency: log-normal IBI (mean=5.97s, SD(log)=0.89), PMC3565584
+ * - Blink shape: asymmetric (92ms close, 242ms open, 3:1 ratio), PMC4043155
  * - Saccade latency: ~200ms, duration 20-200ms
  * - Microsaccades: ~1/second, amplitude 0.02-0.05, Scholarpedia
  * - Fixation duration: 200-350ms, Nature Scientific Reports
+ * - Conversational gaze: Kendon (1967), Argyle & Cook (1976)
  * - Brow noise: NVIDIA Audio2Face, Unreal MetaHuman layered procedural animation
  *
  * @category Animation
@@ -3967,6 +4189,7 @@ declare class EmphasisDetector {
  *   eyeTargetY: normalizedY,
  *   audioEnergy: energy,     // 0-1 from AudioEnergyAnalyzer
  *   isSpeaking: true,
+ *   state: 'speaking',       // conversational state for gaze behavior
  * });
  *
  * // Apply blendshapes to mesh
@@ -4005,6 +4228,8 @@ interface LifeLayerConfig {
     /** Eye smoothing factor (higher = faster response). Default: 15 */
     eyeSmoothing?: number;
 }
+/** Conversational state for state-dependent gaze behavior */
+type ConversationalState = 'idle' | 'listening' | 'thinking' | 'speaking';
 /**
  * Per-frame input to the life layer
  */
@@ -4017,6 +4242,8 @@ interface LifeLayerInput {
     audioEnergy?: number;
     /** Whether avatar is speaking. Multiplies brow noise amplitude. */
     isSpeaking?: boolean;
+    /** Conversational state for gaze behavior (idle/listening/thinking/speaking) */
+    state?: ConversationalState;
 }
 /**
  * Per-frame output from the life layer
@@ -4038,6 +4265,7 @@ interface LifeLayerOutput {
  */
 declare class ProceduralLifeLayer {
     private blinkIntervalRange;
+    private useLogNormalBlinks;
     private gazeBreakIntervalRange;
     private gazeBreakAmplitudeRange;
     private eyeNoiseAmplitude;
@@ -4065,6 +4293,7 @@ declare class ProceduralLifeLayer {
     private gazeBreakTargetY;
     private gazeBreakCurrentX;
     private gazeBreakCurrentY;
+    private currentState;
     private microMotionTime;
     private breathingPhase;
     private noiseTime;
@@ -4079,15 +4308,513 @@ declare class ProceduralLifeLayer {
      * @returns Blendshape values and head rotation deltas
      */
     update(delta: number, input?: LifeLayerInput): LifeLayerOutput;
+    /**
+     * Write life layer output directly to a Float32Array[52] in LAM_BLENDSHAPES order.
+     *
+     * Includes micro-jitter (0.4% amplitude simplex noise on all channels) to
+     * break uncanny stillness on undriven channels.
+     *
+     * @param delta - Time since last frame in seconds
+     * @param input - Per-frame input
+     * @param out - Pre-allocated Float32Array(52) to write into
+     */
+    updateToArray(delta: number, input: LifeLayerInput, out: Float32Array): void;
     /**
      * Reset all internal state to initial values.
      */
     reset(): void;
+    /**
+     * Sample next blink interval.
+     * Uses log-normal distribution (PMC3565584) when using default config,
+     * or uniform random when custom blinkIntervalRange is provided.
+     */
+    private nextBlinkInterval;
     private updateBlinks;
     private getBlinkValues;
     private getEyeMicroMotion;
+    /**
+     * Get active gaze parameters — uses state-dependent params when
+     * conversational state is provided, otherwise falls back to config ranges.
+     */
+    private getActiveGazeParams;
     private updateGazeBreaks;
     private updateBrowNoise;
 }
 
-export { type A2EBackend, type A2EModelInfo, A2EOrchestrator, type A2EOrchestratorConfig, A2EProcessor, type A2EProcessorConfig, type A2EProgressEvent, type A2EResult, ARKIT_BLENDSHAPES, 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, ConsoleExporter, type CreateA2EConfig, type CreateSenseVoiceConfig, DEFAULT_ANIMATION_CONFIG, EMOTION_NAMES, EMOTION_VECTOR_SIZE, type EmotionAnimationMap, EmotionController, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, type EmotionWeights, EmphasisDetector, EventEmitter, type ExpressionProfile, type FetchWithCacheOptions, type FullFaceFrame, FullFacePipeline, type FullFacePipelineEvents, type FullFacePipelineOptions, INFERENCE_LATENCY_BUCKETS, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, LAM_BLENDSHAPES, type LifeLayerConfig, type LifeLayerInput, type LifeLayerOutput, MODEL_LOAD_TIME_BUCKETS, type MetricData, MetricNames, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, OTLPExporter, type OTLPExporterConfig, OmoteEvents, OmoteTelemetry, ProceduralLifeLayer, type QuotaInfo, 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 Transition, UnifiedInferenceWorker, type VADBackend, type VADModelInfo, type VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type Wav2ArkitCpuConfig, Wav2ArkitCpuInference, Wav2ArkitCpuUnifiedAdapter, Wav2ArkitCpuWorker, type Wav2ArkitCpuWorkerConfig, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, blendEmotions, calculatePeak, calculateRMS, configureCacheLimit, 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, resolveBackend, shouldEnableWasmProxy, shouldUseCpuA2E, shouldUseNativeASR, shouldUseServerA2E, supportsVADWorker };
+/**
+ * FACS (Facial Action Coding System) to ARKit Blendshape Mapping
+ *
+ * Two static lookup tables that decompose emotions into FACS Action Units,
+ * then map AUs to ARKit blendshapes. Based on Ekman's FACS research.
+ *
+ * @category Face
+ */
+
+/**
+ * A single FACS Action Unit activation within an emotion
+ */
+interface AUActivation {
+    /** FACS Action Unit identifier (e.g. 'AU6', 'AU12') */
+    au: string;
+    /** Activation intensity 0-1 */
+    intensity: number;
+    /** Facial region: upper (brows/eyes/cheeks) or lower (mouth/jaw) */
+    region: 'upper' | 'lower';
+}
+/**
+ * Table 1: Emotion → FACS Action Units
+ *
+ * Maps each of the 10 SDK emotion channels to their FACS AU combinations
+ * with intensity and upper/lower face region tags.
+ *
+ * Sources:
+ * - Ekman & Friesen (1978) FACS Manual
+ * - Ekman (2003) Emotions Revealed
+ * - Lucey et al. (2010) Extended Cohn-Kanade dataset
+ */
+declare const EMOTION_TO_AU: Record<EmotionName, AUActivation[]>;
+/**
+ * Table 2: FACS Action Unit → ARKit Blendshapes
+ *
+ * Maps each AU to one or more ARKit blendshape channels with weight.
+ *
+ * Sources:
+ * - Apple ARKit face tracking documentation
+ * - Melinda Ozel's ARKit-to-FACS cheat sheet
+ */
+declare const AU_TO_ARKIT: Record<string, {
+    blendshape: string;
+    weight: number;
+}[]>;
+/**
+ * All AU identifiers referenced by EMOTION_TO_AU (for validation)
+ */
+declare const ALL_AUS: string[];
+
+/**
+ * EmotionResolver — Resolves EmotionWeights → split upper/lower face Float32Array[52]
+ *
+ * Uses FACS decomposition (EMOTION_TO_AU → AU_TO_ARKIT) to produce
+ * anatomically correct blendshape contributions, split by facial region
+ * for the FaceCompositor's modulation strategy:
+ *   - Upper face: additive overlay (independent of speech)
+ *   - Lower face: modulates speech output
+ *
+ * @category Face
+ */
+
+/**
+ * Resolved emotion split into upper and lower face contributions
+ */
+interface ResolvedEmotion {
+    /** 52 channels — only upper face (brows, eyes, cheeks, nose) non-zero */
+    upper: Float32Array;
+    /** 52 channels — only lower face (mouth, jaw) non-zero */
+    lower: Float32Array;
+}
+/**
+ * Resolves EmotionWeights into upper/lower face blendshape arrays
+ * using FACS Action Unit decomposition.
+ */
+declare class EmotionResolver {
+    private readonly upperBuffer;
+    private readonly lowerBuffer;
+    /**
+     * Resolve emotion weights to upper/lower face blendshape contributions.
+     *
+     * @param weights - Emotion channel weights from EmotionController
+     * @param intensity - Global intensity multiplier (0-2). Default: 1.0
+     * @returns Upper and lower face blendshape arrays (52 channels each)
+     */
+    resolve(weights: EmotionWeights, intensity?: number): ResolvedEmotion;
+}
+
+/**
+ * FaceCompositor — 5-stage signal processing chain for facial animation
+ *
+ * Composes A2E lip sync, emotion modulation, procedural life, and character
+ * profile into a single Float32Array[52] per frame.
+ *
+ * ```
+ * BASE (A2E) → EMOTION MODULATION → PROCEDURAL LIFE → CHARACTER PROFILE → OUTPUT [0,1]
+ * ```
+ *
+ * Replaces manual blendshape merging in consumer code with a single `compose()` call.
+ *
+ * @category Face
+ */
+
+/**
+ * Per-blendshape character profile (multiplier + offset)
+ *
+ * Superset of ExpressionProfile — gives per-channel control instead of per-group.
+ */
+interface CharacterProfile {
+    /** Per-blendshape multiplier (default: all 1.0) */
+    multiplier?: Partial<Record<string, number>>;
+    /** Per-blendshape offset (default: all 0.0) */
+    offset?: Partial<Record<string, number>>;
+}
+/**
+ * Configuration for FaceCompositor
+ */
+interface FaceCompositorConfig {
+    /** ProceduralLifeLayer instance (compositor creates default if omitted) */
+    lifeLayer?: ProceduralLifeLayer;
+    /** Character profile: per-BS multiplier + offset */
+    profile?: CharacterProfile;
+    /** Emotion smoothing factor per frame (0-1). Default: 0.12 */
+    emotionSmoothing?: number;
+}
+/**
+ * Per-frame input to the compositor
+ */
+interface FaceCompositorInput extends LifeLayerInput {
+    /** Delta time in seconds */
+    deltaTime: number;
+    /** Current emotion weights (from EmotionController.emotion or manual) */
+    emotion?: EmotionWeights;
+    /** Emotion intensity multiplier (0-2). Default: 1.0 */
+    emotionIntensity?: number;
+}
+/**
+ * FaceCompositor — 5-stage facial animation signal chain.
+ *
+ * @example
+ * ```typescript
+ * import { FaceCompositor, createA2E } from '@omote/core';
+ *
+ * const compositor = new FaceCompositor();
+ *
+ * // In animation loop:
+ * const output = compositor.compose(a2eFrame, {
+ *   deltaTime: 0.016,
+ *   emotion: { joy: 0.8 },
+ *   isSpeaking: true,
+ *   audioEnergy: 0.5,
+ * });
+ *
+ * // Apply output[0..51] to avatar morphTargetInfluences
+ * ```
+ */
+declare class FaceCompositor {
+    private readonly emotionResolver;
+    private readonly lifeLayer;
+    private readonly emotionSmoothing;
+    private readonly smoothedUpper;
+    private readonly smoothedLower;
+    private readonly lifeBuffer;
+    private readonly multiplier;
+    private readonly offset;
+    private stickyEmotion;
+    constructor(config?: FaceCompositorConfig);
+    /**
+     * Compose a single output frame from the 5-stage signal chain.
+     *
+     * @param base - A2E raw output (Float32Array[52], LAM_BLENDSHAPES order)
+     * @param input - Per-frame input (deltaTime, emotion, life layer params)
+     * @returns Float32Array[52] with all values clamped to [0, 1]
+     */
+    compose(base: Float32Array, input: FaceCompositorInput): Float32Array;
+    /**
+     * Set sticky emotion (used when input.emotion is not provided).
+     */
+    setEmotion(weights: EmotionWeights): void;
+    /**
+     * Update character profile at runtime.
+     */
+    setProfile(profile: CharacterProfile): void;
+    /**
+     * Reset all smoothing state and life layer.
+     */
+    reset(): void;
+    /** Expand partial profile maps into dense Float32Arrays */
+    private applyProfileArrays;
+}
+
+/**
+ * MicLipSync - Microphone → VAD → A2E → blendshapes
+ *
+ * Simple composition class for live mic lip sync ("mirror mode").
+ * Replaces A2EOrchestrator with proper MicrophoneCapture integration.
+ *
+ * @category Orchestration
+ */
+
+type MicLipSyncState = 'idle' | 'active' | 'paused';
+interface MicLipSyncConfig {
+    /** A2E inference backend (from createA2E) — required */
+    lam: A2EBackend;
+    /** VAD backend for speech boundary detection (optional) */
+    vad?: SileroVADBackend;
+    /** Mic sample rate (default: 16000) */
+    sampleRate?: number;
+    /** Mic chunk size in samples (default: 512, required by Silero VAD) */
+    micChunkSize?: number;
+    /** Per-character expression weight scaling */
+    profile?: ExpressionProfile;
+    /** Identity/style index for Wav2Vec2 (default: 0) */
+    identityIndex?: number;
+}
+interface MicLipSyncFrame {
+    blendshapes: Float32Array;
+    rawBlendshapes: Float32Array;
+}
+interface MicLipSyncEvents {
+    /** New blendshape frame ready */
+    'frame': MicLipSyncFrame;
+    /** Speech started (VAD) */
+    'speech:start': void;
+    /** Speech ended (VAD) */
+    'speech:end': {
+        durationMs: number;
+    };
+    /** Microphone started */
+    'mic:start': void;
+    /** Microphone stopped */
+    'mic:stop': void;
+    /** Audio level update */
+    'audio:level': {
+        rms: number;
+        peak: number;
+    };
+    /** State changed */
+    'state': MicLipSyncState;
+    /** Error occurred */
+    'error': Error;
+    [key: string]: unknown;
+}
+declare class MicLipSync extends EventEmitter<MicLipSyncEvents> {
+    private omoteEvents;
+    private mic;
+    private processor;
+    private vad?;
+    private _state;
+    private _isSpeaking;
+    private _currentFrame;
+    private _currentRawFrame;
+    private profile;
+    private speechStartTime;
+    private vadChunkSize;
+    private vadBuffer;
+    private vadBufferOffset;
+    /** Current state */
+    get state(): MicLipSyncState;
+    /** Latest blendshape frame (null before first inference) */
+    get currentFrame(): Float32Array | null;
+    /** Whether speech is currently detected (requires VAD) */
+    get isSpeaking(): boolean;
+    /** Current backend type */
+    get backend(): string | null;
+    constructor(config: MicLipSyncConfig);
+    /** Start microphone capture and inference loop */
+    start(): Promise<void>;
+    /** Stop microphone and inference */
+    stop(): void;
+    /** Pause inference (mic stays open for faster resume) */
+    pause(): void;
+    /** Resume inference after pause */
+    resume(): void;
+    /** Update ExpressionProfile at runtime */
+    setProfile(profile: ExpressionProfile): void;
+    /** Dispose of all resources */
+    dispose(): Promise<void>;
+    private processVAD;
+    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
+ *
+ * Composes: MicrophoneCapture → SileroVAD → SenseVoice ASR → PlaybackPipeline (A2E)
+ *
+ * State machine: idle → loading → ready → listening → thinking → speaking → listening → ...
+ *
+ * The consumer provides an `onResponse` callback that receives transcribed text
+ * and streams audio back for playback + lip sync. VoicePipeline is backend-agnostic.
+ *
+ * @category Orchestration
+ */
+
+interface VoicePipelineConfig {
+    /** URLs and options for model loading */
+    models: {
+        senseVoice: {
+            modelUrl: string;
+            tokensUrl?: string;
+            language?: string;
+        };
+        lam: {
+            gpuModelUrl: string;
+            gpuExternalDataUrl?: string | false;
+            cpuModelUrl: string;
+            mode?: 'auto' | 'gpu' | 'cpu';
+        };
+        vad: {
+            modelUrl: string;
+            threshold?: number;
+            preSpeechBufferChunks?: number;
+        };
+    };
+    /** Consumer's response handler */
+    onResponse: ResponseHandler;
+    /** Per-character expression weight scaling */
+    profile?: ExpressionProfile;
+    /** Identity/style index for Wav2Vec2 (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) */
+    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 SenseVoice.transcribe() calls (default: 10000ms) */
+    transcriptionTimeoutMs?: number;
+    /** Enable barge-in detection (default: true) */
+    interruptionEnabled?: boolean;
+    /** Minimum speech duration for interruption (default: 200ms) */
+    interruptionMinSpeechMs?: number;
+    /** Audio playback delay (default: auto-detected) */
+    audioDelayMs?: number;
+    /** Coalescer target duration (default: 200ms) */
+    chunkTargetMs?: number;
+    /** Enable neutral transition on playback complete (default: true) */
+    neutralTransitionEnabled?: boolean;
+    /** Duration of neutral fade-out (default: 250ms) */
+    neutralTransitionMs?: number;
+}
+interface VoicePipelineEvents {
+    'state': VoicePipelineState;
+    'loading:progress': LoadingProgress;
+    'transcript': TranscriptResult;
+    'frame': FullFaceFrame;
+    'frame:raw': Float32Array;
+    'speech:start': void;
+    'speech:end': {
+        durationMs: number;
+    };
+    'playback:start': {
+        time: number;
+    };
+    'playback:complete': void;
+    'interruption': void;
+    'audio:level': {
+        rms: number;
+        peak: number;
+    };
+    'error': Error;
+    [key: string]: unknown;
+}
+declare class VoicePipeline extends EventEmitter<VoicePipelineEvents> {
+    private readonly config;
+    private _state;
+    private stopped;
+    private epoch;
+    private _sessionId;
+    private asr;
+    private lam;
+    private vad;
+    private unifiedWorker;
+    private playback;
+    private interruption;
+    private omoteEvents;
+    private mic;
+    private audioBuffer;
+    private audioBufferSamples;
+    private speechStartTime;
+    private silenceTimer;
+    private isSpeaking;
+    private progressiveTimer;
+    private progressivePromise;
+    private lastProgressiveResult;
+    private lastProgressiveSamples;
+    private asrErrorCount;
+    private responseAbortController;
+    private _currentFrame;
+    /** Current pipeline state */
+    get state(): VoicePipelineState;
+    /** Latest blendshape frame */
+    get currentFrame(): Float32Array | null;
+    /** Whether user is currently speaking */
+    get isSpeechActive(): boolean;
+    /** Session ID (generated on start(), null before) */
+    get sessionId(): string | null;
+    constructor(config: VoicePipelineConfig);
+    loadModels(): Promise<void>;
+    start(): Promise<void>;
+    stop(): void;
+    setProfile(profile: ExpressionProfile): void;
+    dispose(): Promise<void>;
+    private processAudioChunk;
+    private getSilenceTimeout;
+    private onSilenceDetected;
+    private processEndOfSpeech;
+    private callResponseHandler;
+    private handleInterruption;
+    private startProgressiveTranscription;
+    private stopProgressiveTranscription;
+    private transcribeWithTimeout;
+    private normalizeAudio;
+    private setState;
+    private emitProgress;
+    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 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 };