@omote/core 0.3.25 → 0.4.1

package/dist/events/index.mjs

@@ -1,7 +1,6 @@
 import {
   EventEmitter
 } from "../chunk-XK22BRG4.mjs";
-import "../chunk-NSSMTXJJ.mjs";
 export {
   EventEmitter
 };

package/dist/index.d.mts

@@ -863,133 +863,207 @@ declare function isOnnxRuntimeLoaded(): boolean;
 declare function preloadOnnxRuntime(preference?: BackendPreference): Promise<RuntimeBackend>;
 
 /**
- * Whisper Automatic Speech Recognition using transformers.js
- * Uses Xenova's proven pipeline API for reliable transcription
- */
-type WhisperModel = 'tiny' | 'base' | 'small' | 'medium';
-type WhisperDtype = 'fp32' | 'fp16' | 'q8' | 'int8' | 'uint8' | 'q4' | 'q4f16' | 'bnb4';
-interface WhisperConfig {
-    /** Model size: tiny (~75MB), base (~150MB), small (~500MB), medium (~1.5GB) */
-    model?: WhisperModel;
-    /** Use multilingual model (default: false, uses .en models) */
-    multilingual?: boolean;
-    /** Language code (e.g., 'en', 'es', 'fr') - for multilingual models */
-    language?: string;
-    /** Task: transcribe or translate (default: transcribe) */
-    task?: 'transcribe' | 'translate';
-    /** Model quantization format (default: 'q8' for balance of speed/quality) */
-    dtype?: WhisperDtype;
-    /** Use WebGPU acceleration if available (default: auto-detect) */
-    device?: 'auto' | 'webgpu' | 'wasm';
-    /** Local model path (e.g., '/models/whisper-tiny.en') - overrides HuggingFace CDN */
-    localModelPath?: string;
-    /** HuggingFace API token to bypass rate limits (get from https://huggingface.co/settings/tokens) */
-    token?: string;
-    /** Suppress non-speech tokens like [LAUGHTER], [CLICKING], etc. (default: true) */
-    suppressNonSpeech?: boolean;
+ * SenseVoice automatic speech recognition using ONNX Runtime Web
+ *
+ * Non-autoregressive CTC-based ASR that is 5x faster than Whisper-Small.
+ * Runs entirely in browser via WebGPU or WASM. No transformers.js dependency.
+ *
+ * Uses the sherpa-onnx SenseVoice export (model.int8.onnx, 239MB int8 quantized).
+ * Also provides emotion detection, language identification, and audio event detection
+ * from the same forward pass.
+ *
+ * @category Inference
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { SenseVoiceInference } from '@omote/core';
+ *
+ * const asr = new SenseVoiceInference({
+ *   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"
+ * ```
+ *
+ * @module inference/SenseVoiceInference
+ */
+
+type SenseVoiceLanguage = 'auto' | 'zh' | 'en' | 'ja' | 'ko' | 'yue';
+interface SenseVoiceConfig {
+    /** 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';
+    /** Preferred backend (default: 'auto') */
+    backend?: BackendPreference;
 }
-interface TranscriptionResult {
+interface SenseVoiceResult {
     /** Transcribed text */
     text: string;
-    /** Detected/used language */
-    language: string;
-    /** Inference time in ms */
+    /** Detected language (e.g., 'zh', 'en', 'ja', 'ko', 'yue') */
+    language?: string;
+    /** Detected emotion (e.g., 'HAPPY', 'SAD', 'ANGRY', 'NEUTRAL') */
+    emotion?: string;
+    /** Detected audio event (e.g., 'Speech', 'BGM', 'Laughter') */
+    event?: string;
+    /** Inference time in milliseconds (preprocessing + model + decode) */
     inferenceTimeMs: number;
-    /** Full chunks with timestamps (if requested) */
-    chunks?: Array<{
-        text: string;
-        timestamp: [number, number | null];
-    }>;
+    /** Preprocessing time in milliseconds (fbank + LFR + CMVN) */
+    preprocessTimeMs: number;
 }
-/**
- * Whisper ASR inference using transformers.js pipeline API
- *
- * Features:
- * - Automatic WebGPU/WASM backend selection
- * - Streaming support with chunk callbacks
- * - Proven implementation from Xenova's demo
- * - Handles all audio preprocessing automatically
- */
-declare class WhisperInference {
+interface SenseVoiceModelInfo {
+    backend: RuntimeBackend;
+    loadTimeMs: number;
+    inputNames: string[];
+    outputNames: string[];
+    vocabSize: number;
+}
+declare class SenseVoiceInference {
+    private session;
+    private ort;
     private config;
-    private pipeline;
-    private currentModel;
+    private _backend;
     private isLoading;
-    private actualBackend;
-    constructor(config?: WhisperConfig);
-    /**
-     * Check if WebGPU is available in this browser
-     */
-    static isWebGPUAvailable(): Promise<boolean>;
-    /**
-     * Load the Whisper model pipeline
-     */
-    load(onProgress?: (progress: {
-        status: string;
-        progress?: number;
-        file?: string;
-    }) => void): Promise<void>;
-    /**
-     * Transcribe audio to text
-     *
-     * @param audio Audio samples (Float32Array, 16kHz mono)
-     * @param options Transcription options
-     */
-    transcribe(audio: Float32Array, options?: {
-        /** Return timestamps for each chunk */
-        returnTimestamps?: boolean;
-        /** Chunk length in seconds (default: 30) */
-        chunkLengthS?: number;
-        /** Stride length in seconds for overlapping chunks (default: 5) */
-        strideLengthS?: number;
-        /** Language override */
-        language?: string;
-        /** Task override */
-        task?: 'transcribe' | 'translate';
-    }): Promise<TranscriptionResult>;
-    /**
-     * Transcribe with streaming chunks (progressive results)
-     *
-     * @param audio Audio samples
-     * @param onChunk Called when each chunk is finalized
-     * @param onUpdate Called after each generation step (optional)
-     */
-    transcribeStreaming(audio: Float32Array, onChunk: (chunk: {
-        text: string;
-        timestamp: [number, number | null];
-    }) => void, onUpdate?: (text: string) => void, options?: {
-        chunkLengthS?: number;
-        strideLengthS?: number;
-        language?: string;
-        task?: 'transcribe' | 'translate';
-    }): Promise<TranscriptionResult>;
-    /**
-     * Dispose of the model and free resources
-     */
-    dispose(): Promise<void>;
-    /**
-     * Check if model is loaded
-     */
+    private inferenceQueue;
+    private tokenMap;
+    private negMean;
+    private invStddev;
+    private languageId;
+    private textNormId;
+    constructor(config: SenseVoiceConfig);
+    get backend(): RuntimeBackend | null;
     get isLoaded(): boolean;
+    load(onProgress?: (loaded: number, total: number) => void): Promise<SenseVoiceModelInfo>;
     /**
-     * Get the backend being used (webgpu or wasm)
-     */
-    get backend(): string;
-    /**
-     * Get the full model name used by transformers.js
-     */
-    private getModelName;
-    /**
-     * Remove non-speech event tokens from transcription
-     *
-     * Whisper outputs special tokens for non-speech events like:
-     * [LAUGHTER], [APPLAUSE], [MUSIC], [BLANK_AUDIO], [CLICKING], etc.
+     * Transcribe audio samples to text
      *
-     * This method strips these tokens and cleans up extra whitespace.
+     * @param audioSamples Float32Array of audio samples at 16kHz, [-1, 1] range
+     * @returns Transcription result with text, emotion, language, and event
      */
-    private removeNonSpeechTokens;
+    transcribe(audioSamples: Float32Array): Promise<SenseVoiceResult>;
+    private queueInference;
+    dispose(): Promise<void>;
 }
 
+/**
+ * Kaldi-compatible filterbank (fbank) feature extraction
+ *
+ * Pure TypeScript implementation matching kaldi-native-fbank parameters
+ * used by SenseVoice. No external dependencies.
+ *
+ * Pipeline: audio → framing → windowing → FFT → power spectrum → mel filterbank → log
+ *
+ * @module inference/kaldiFbank
+ */
+interface KaldiFbankOptions {
+    /** Frame length in ms (default: 25) */
+    frameLengthMs?: number;
+    /** Frame shift in ms (default: 10) */
+    frameShiftMs?: number;
+    /** Low frequency cutoff in Hz (default: 20) */
+    lowFreq?: number;
+    /** High frequency cutoff in Hz (default: sampleRate / 2) */
+    highFreq?: number;
+    /** Dither amount (default: 0 for deterministic output) */
+    dither?: number;
+    /** Preemphasis coefficient (default: 0.97) */
+    preemphasis?: number;
+}
+/**
+ * Compute Kaldi-compatible log mel filterbank features
+ *
+ * @param audio Raw audio samples (float32, [-1, 1] range)
+ * @param sampleRate Sample rate in Hz (must be 16000 for SenseVoice)
+ * @param numMelBins Number of mel bins (80 for SenseVoice)
+ * @param opts Optional parameters
+ * @returns Flattened Float32Array of shape [numFrames, numMelBins]
+ */
+declare function computeKaldiFbank(audio: Float32Array, sampleRate: number, numMelBins: number, opts?: KaldiFbankOptions): Float32Array;
+/**
+ * Apply Low Frame Rate stacking for SenseVoice
+ *
+ * Concatenates lfrM consecutive frames with stride lfrN.
+ * Left-pads with copies of first frame, right-pads last group.
+ *
+ * @param features Flattened [numFrames, featureDim]
+ * @param featureDim Feature dimension per frame (e.g., 80)
+ * @param lfrM Number of frames to stack (default: 7)
+ * @param lfrN Stride (default: 6)
+ * @returns Flattened [numOutputFrames, featureDim * lfrM]
+ */
+declare function applyLFR(features: Float32Array, featureDim: number, lfrM?: number, lfrN?: number): Float32Array;
+/**
+ * Apply CMVN normalization in-place
+ *
+ * Formula: normalized[i] = (features[i] + negMean[i % dim]) * invStddev[i % dim]
+ *
+ * @param features Flattened feature array (modified in-place)
+ * @param dim Feature dimension (560 for SenseVoice after LFR)
+ * @param negMean Negative mean vector (dim-dimensional)
+ * @param invStddev Inverse standard deviation vector (dim-dimensional)
+ * @returns The same features array (for chaining)
+ */
+declare function applyCMVN(features: Float32Array, dim: number, negMean: Float32Array, invStddev: Float32Array): Float32Array;
+/**
+ * Parse CMVN vectors from comma-separated strings (stored in ONNX metadata)
+ *
+ * The sherpa-onnx SenseVoice export stores neg_mean and inv_stddev
+ * as comma-separated float strings in the model's metadata.
+ */
+declare function parseCMVNFromMetadata(negMeanStr: string, invStddevStr: string): {
+    negMean: Float32Array;
+    invStddev: Float32Array;
+};
+
+/**
+ * CTC greedy decoder for SenseVoice
+ *
+ * Decodes CTC logits into text with structured token parsing
+ * for language, emotion, and audio event detection.
+ *
+ * @module inference/ctcDecoder
+ */
+interface CTCDecodeResult {
+    /** Decoded text (speech content only) */
+    text: string;
+    /** Detected language (e.g., 'zh', 'en', 'ja', 'ko', 'yue') */
+    language?: string;
+    /** Detected emotion (e.g., 'HAPPY', 'SAD', 'ANGRY', 'NEUTRAL') */
+    emotion?: string;
+    /** Detected audio event (e.g., 'Speech', 'BGM', 'Laughter') */
+    event?: string;
+}
+/** Resolve language string to SenseVoice language ID */
+declare function resolveLanguageId(language: string): number;
+/** Resolve text norm string to SenseVoice text norm ID */
+declare function resolveTextNormId(textNorm: string): number;
+/**
+ * Parse tokens.txt into a token ID → string map
+ *
+ * Format: each line is "token_string token_id"
+ * e.g., "<unk> 0", "▁the 3", "s 4"
+ */
+declare function parseTokensFile(content: string): Map<number, string>;
+/**
+ * CTC greedy decode
+ *
+ * @param logits Raw logits from model output, flattened [seqLen, vocabSize]
+ * @param seqLen Sequence length (time steps)
+ * @param vocabSize Vocabulary size
+ * @param tokenMap Token ID → string map from tokens.txt
+ * @returns Decoded text and structured metadata
+ */
+declare function ctcGreedyDecode(logits: Float32Array, seqLen: number, vocabSize: number, tokenMap: Map<number, string>): CTCDecodeResult;
+
 /**
  * Shared blendshape constants and utilities for lip sync inference
  *
@@ -1234,6 +1308,16 @@ declare class Wav2ArkitCpuInference implements LipSyncBackend {
  * - Chrome/Firefox/Edge: Uses Wav2Vec2Inference (384MB, 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.
+ * 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)
@@ -2485,7 +2569,7 @@ declare class AgentCoreAdapter extends EventEmitter<AIAdapterEvents> implements
     private _state;
     private _sessionId;
     private _isConnected;
-    private whisper;
+    private asr;
     private vad;
     private lam;
     private emotionController;
@@ -2529,7 +2613,7 @@ declare class AgentCoreAdapter extends EventEmitter<AIAdapterEvents> implements
     healthCheck(): Promise<boolean>;
     private setState;
     private getAuthToken;
-    private initWhisper;
+    private initASR;
     private initLAM;
     private initPipeline;
     private connectWebSocket;
@@ -3223,148 +3307,6 @@ declare function preloadModels(urls: string[], onProgress?: (current: number, to
  */
 declare function formatBytes(bytes: number): string;
 
-/**
- * HuggingFace CDN Utilities
- *
- * Helper functions for working with HuggingFace CDN URLs.
- * Used by transformers.js models (Whisper, etc.) for model downloads.
- *
- * @category Cache
- */
-/**
- * Test URL for HuggingFace CDN reachability check.
- * Uses a small, stable file from a well-known public model.
- */
-declare const HF_CDN_TEST_URL = "https://huggingface.co/Xenova/whisper-tiny/resolve/main/config.json";
-/**
- * Parsed HuggingFace URL components
- */
-interface HuggingFaceUrlInfo {
-    /** Organization or username */
-    org: string;
-    /** Model name */
-    model: string;
-    /** Branch, tag, or commit */
-    branch: string;
-    /** File path within the repository */
-    file: string;
-}
-/**
- * Parse a HuggingFace CDN URL into its components
- *
- * @param url - The HuggingFace URL to parse
- * @returns Parsed URL info or null if not a valid HF URL
- *
- * @example
- * ```typescript
- * const info = parseHuggingFaceUrl(
- *   'https://huggingface.co/openai/whisper-tiny/resolve/main/model.onnx'
- * );
- * // Returns: { org: 'openai', model: 'whisper-tiny', branch: 'main', file: 'model.onnx' }
- * ```
- */
-declare function parseHuggingFaceUrl(url: string): HuggingFaceUrlInfo | null;
-/**
- * Check if HuggingFace CDN is reachable
- *
- * Performs a HEAD request to a known HuggingFace model file to verify
- * connectivity. Useful for offline detection or network diagnostics.
- *
- * @param testUrl - Optional custom URL to test (defaults to HF_CDN_TEST_URL)
- * @returns True if CDN is reachable, false otherwise
- *
- * @example
- * ```typescript
- * import { isHuggingFaceCDNReachable } from '@omote/core';
- *
- * const reachable = await isHuggingFaceCDNReachable();
- * if (!reachable) {
- *   console.log('HuggingFace CDN unreachable - running offline?');
- *   // Fall back to cached models or show error
- * }
- * ```
- */
-declare function isHuggingFaceCDNReachable(testUrl?: string): Promise<boolean>;
-
-/**
- * Utility to clear transformers.js Cache API storage
- *
- * Problem: transformers.js v4 uses Browser Cache API which persists across hard refreshes.
- * If an HTML error page gets cached (due to network errors, CDN issues, or dev server restarts),
- * it will be served instead of JSON files, causing JSON.parse() errors.
- *
- * Solution: Manually clear Cache API storage before loading models.
- *
- * @module utils/transformersCacheClear
- */
-/**
- * Clear all transformers.js and HuggingFace caches from Browser Cache API
- *
- * This clears:
- * - transformers-cache (default cache key)
- * - Any caches with 'transformers' or 'huggingface' in the name
- *
- * @param options Configuration options
- * @returns Promise resolving to array of deleted cache names
- */
-declare function clearTransformersCache(options?: {
-    /** Whether to log deletion details (default: true) */
-    verbose?: boolean;
-    /** Additional cache name patterns to clear (e.g., ['my-custom-cache']) */
-    additionalPatterns?: string[];
-}): Promise<string[]>;
-/**
- * Clear a specific cache by exact name
- *
- * @param cacheName Exact cache name to delete
- * @returns Promise resolving to true if deleted, false otherwise
- */
-declare function clearSpecificCache(cacheName: string): Promise<boolean>;
-/**
- * List all cache names currently stored
- *
- * @returns Promise resolving to array of cache names
- */
-declare function listCaches(): Promise<string[]>;
-/**
- * Check if a specific cached response is valid JSON/binary (not HTML error page)
- *
- * @param cacheName Cache name to check
- * @param requestUrl URL/key to check
- * @returns Promise resolving to validation result
- */
-declare function validateCachedResponse(cacheName: string, requestUrl: string): Promise<{
-    exists: boolean;
-    valid: boolean;
-    contentType: string | null;
-    isHtml: boolean;
-    reason?: string;
-}>;
-/**
- * Scan all caches for potentially invalid cached responses
- *
- * @returns Promise resolving to report of invalid entries
- */
-declare function scanForInvalidCaches(): Promise<{
-    totalCaches: number;
-    scannedEntries: number;
-    invalidEntries: Array<{
-        cacheName: string;
-        url: string;
-        reason: string;
-    }>;
-}>;
-/**
- * Clear all caches and optionally prevent re-creation (development mode)
- *
- * WARNING: This is aggressive and should only be used in development.
- * It clears ALL browser caches, not just transformers.js.
- *
- * @param preventRecreation If true, sets env.useBrowserCache = false
- * @returns Promise resolving to number of deleted caches
- */
-declare function nukeBrowserCaches(preventRecreation?: boolean): Promise<number>;
-
 /**
  * Telemetry Types
  *
@@ -4127,4 +4069,4 @@ declare class EmphasisDetector {
     reset(): void;
 }
 
-export { type AIAdapter, type AIAdapterEvents, type AISessionState, ARKIT_BLENDSHAPES, type ActiveSpan, AgentCoreAdapter, type AgentCoreConfig, type AnimationClip, AnimationEvent, AnimationGraph, type AnimationGraphConfig, type AnimationGraphEvents, type AnimationLayer, type AnimationOutput, type AnimationState, type AnimationStateName, type AnimationTrigger, AudioChunkCoalescer, type AudioChunkCoalescerOptions, AudioEnergyAnalyzer, AudioScheduler, type AudioSchedulerOptions, type AudioSyncConfig, type AudioSyncEvents, AudioSyncManager, type BackendPreference, type BlendWeight, CTC_VOCAB, type CacheConfig, type CacheSpanAttributes, ConsoleExporter, type ConversationMessage, ConversationOrchestrator, type ConversationSession, type CreateLipSyncConfig, DEFAULT_ANIMATION_CONFIG, EMOTION_NAMES, EMOTION_VECTOR_SIZE, type EmotionAnimationMap, EmotionController, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, type EmotionWeights, EmphasisDetector, EventEmitter, type FetchWithCacheOptions, HF_CDN_TEST_URL, type HuggingFaceUrlInfo, INFERENCE_LATENCY_BUCKETS, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, type LAMFrame, LAMPipeline, type LAMPipelineOptions, LAM_BLENDSHAPES, type LipSyncBackend, type LipSyncModelInfo, type LipSyncResult, MODEL_LOAD_TIME_BUCKETS, type MessageRole, type MetricData, MetricNames, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, OTLPExporter, type OTLPExporterConfig, OmoteEvents, OmoteTelemetry, type OrchestratorConfig, type OrchestratorEvents, type QuotaInfo, RingBuffer, type RuntimeBackend, type SafariSpeechConfig, SafariSpeechRecognition, type SamplingConfig, type SessionConfig, type SessionOptions, type SessionSnapshot, type SileroVADBackend, type SileroVADConfig, type SileroVADFactoryConfig, SileroVADInference, SileroVADWorker, type SpanAttributes, type SpanData, type SpeechErrorCallback, type SpeechRecognitionResult, type SpeechResultCallback, type SpeechSegment, SyncedAudioPipeline, type SyncedAudioPipelineEvents, type SyncedAudioPipelineOptions, type TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TenantConfig, TenantManager, type TenantQuota, type TenantUsage, type TokenRefreshCallback, type TranscriptionResult, type Transition, type VADBackend, type VADModelInfo, type VADResult$1 as VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type VoiceConfig, WAV2ARKIT_BLENDSHAPES, type Wav2ArkitCpuConfig, Wav2ArkitCpuInference, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, type WhisperConfig, WhisperInference, type WhisperModel, blendEmotions, calculatePeak, calculateRMS, clearSpecificCache, clearTransformersCache, configureCacheLimit, configureTelemetry, createEmotionVector, createLipSync, createSessionWithFallback, createSileroVAD, fetchWithCache, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getLoadedBackend, getModelCache, getOnnxRuntime, getOnnxRuntimeForPreference, getOptimalWasmThreads, getRecommendedBackend, getSessionOptions, getTelemetry, hasWebGPUApi, isAndroid, isHuggingFaceCDNReachable, isIOS, isIOSSafari, isMobile, isOnnxRuntimeLoaded, isSafari, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpEmotion, listCaches, nukeBrowserCaches, parseHuggingFaceUrl, preloadModels, preloadOnnxRuntime, remapWav2ArkitToLam, resolveBackend, scanForInvalidCaches, shouldEnableWasmProxy, shouldUseCpuLipSync, shouldUseNativeASR, shouldUseServerLipSync, supportsVADWorker, symmetrizeBlendshapes, validateCachedResponse };
+export { type AIAdapter, type AIAdapterEvents, type AISessionState, ARKIT_BLENDSHAPES, type ActiveSpan, AgentCoreAdapter, type AgentCoreConfig, type AnimationClip, AnimationEvent, AnimationGraph, type AnimationGraphConfig, type AnimationGraphEvents, type AnimationLayer, type AnimationOutput, type AnimationState, type AnimationStateName, type AnimationTrigger, AudioChunkCoalescer, type AudioChunkCoalescerOptions, AudioEnergyAnalyzer, AudioScheduler, type AudioSchedulerOptions, type AudioSyncConfig, type AudioSyncEvents, AudioSyncManager, type BackendPreference, type BlendWeight, type CTCDecodeResult, CTC_VOCAB, type CacheConfig, type CacheSpanAttributes, ConsoleExporter, type ConversationMessage, ConversationOrchestrator, type ConversationSession, type CreateLipSyncConfig, DEFAULT_ANIMATION_CONFIG, EMOTION_NAMES, EMOTION_VECTOR_SIZE, type EmotionAnimationMap, EmotionController, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, type EmotionWeights, EmphasisDetector, EventEmitter, type FetchWithCacheOptions, INFERENCE_LATENCY_BUCKETS, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, type KaldiFbankOptions, type LAMFrame, LAMPipeline, type LAMPipelineOptions, LAM_BLENDSHAPES, type LipSyncBackend, type LipSyncModelInfo, type LipSyncResult, MODEL_LOAD_TIME_BUCKETS, type MessageRole, type MetricData, MetricNames, MicrophoneCapture, type MicrophoneCaptureConfig, ModelCache, type ModelSpanAttributes, OTLPExporter, type OTLPExporterConfig, OmoteEvents, OmoteTelemetry, type OrchestratorConfig, type OrchestratorEvents, type QuotaInfo, RingBuffer, type RuntimeBackend, type SafariSpeechConfig, SafariSpeechRecognition, type SamplingConfig, type SenseVoiceConfig, SenseVoiceInference, type SenseVoiceLanguage, type SenseVoiceModelInfo, type SenseVoiceResult, type SessionConfig, type SessionOptions, type SessionSnapshot, type SileroVADBackend, type SileroVADConfig, type SileroVADFactoryConfig, SileroVADInference, SileroVADWorker, type SpanAttributes, type SpanData, type SpeechErrorCallback, type SpeechRecognitionResult, type SpeechResultCallback, type SpeechSegment, SyncedAudioPipeline, type SyncedAudioPipelineEvents, type SyncedAudioPipelineOptions, type TelemetryConfig, type TelemetryExporter, type TelemetryExporterInterface, type TenantConfig, TenantManager, type TenantQuota, type TenantUsage, type TokenRefreshCallback, type Transition, type VADBackend, type VADModelInfo, type VADResult$1 as VADResult, type VADWorkerConfig, type VADWorkerModelInfo, type ValidationResult, type VoiceConfig, WAV2ARKIT_BLENDSHAPES, type Wav2ArkitCpuConfig, Wav2ArkitCpuInference, Wav2Vec2Inference, type Wav2Vec2InferenceConfig, type Wav2Vec2Result, applyCMVN, applyLFR, blendEmotions, calculatePeak, calculateRMS, computeKaldiFbank, configureCacheLimit, configureTelemetry, createEmotionVector, createLipSync, createSessionWithFallback, createSileroVAD, ctcGreedyDecode, fetchWithCache, formatBytes, getCacheConfig, getCacheKey, getEmotionPreset, getLoadedBackend, getModelCache, getOnnxRuntime, getOnnxRuntimeForPreference, getOptimalWasmThreads, getRecommendedBackend, getSessionOptions, getTelemetry, hasWebGPUApi, isAndroid, isIOS, isIOSSafari, isMobile, isOnnxRuntimeLoaded, isSafari, isSpeechRecognitionAvailable, isWebGPUAvailable, lerpEmotion, parseCMVNFromMetadata, parseTokensFile, preloadModels, preloadOnnxRuntime, remapWav2ArkitToLam, resolveBackend, resolveLanguageId, resolveTextNormId, shouldEnableWasmProxy, shouldUseCpuLipSync, shouldUseNativeASR, shouldUseServerLipSync, supportsVADWorker, symmetrizeBlendshapes };