@omote/core 0.4.2 → 0.4.3

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { EventEmitter, OmoteEvents, AnimationEvent } from './events/index.js';
 export { BackendEvent, EmotionEvent, GazeEvent, STTFinalEvent, STTPartialEvent, SessionStateEvent, TTSEndEvent, TTSMarkEvent, TTSStartEvent, VisemeEvent } from './events/index.js';
 import { InferenceSession, Tensor, Env } from 'onnxruntime-common';
 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.js';
+export { ARKitToFLAMEMapping, ApiError, AudioChunkEvent, AvatarFormat, Character, CharacterAvatar, CharacterMemory, CharacterPersonality, CharacterSpec, CharacterVoice, CreateCharacterRequest, CreateCharacterResponse, CreateLAMJobRequest, CreateLAMJobResponse, CreateSessionRequest, CreateSessionResponse, GSplatConfig, LAMJob, LAMJobStatus, PROTOCOL_VERSION, PaginatedResponse, PlatformSession, ErrorEvent as ProtocolErrorEvent, ProtocolEvent, ResponseChunkEvent, ResponseEndEvent, ResponseStartEvent, SessionMessage, SessionStatus, isProtocolEvent } from '@omote/types';
 
 /**
  * Microphone capture - renderer-agnostic audio input
@@ -758,6 +759,483 @@ declare class SyncedAudioPipeline extends EventEmitter<SyncedAudioPipelineEvents
     dispose(): void;
 }
 
+/**
+ * Emotion to ARKit Blendshape Mapper
+ *
+ * Converts Emotion2VecInference output to upper face ARKit blendshapes for
+ * expressive avatar animation. Maps 4 emotion categories (neutral, happy, angry, sad)
+ * to 11 upper face blendshapes (brows, eyes, cheeks).
+ *
+ * Supports two blend modes:
+ * - 'dominant': Uses only the strongest emotion (simpler, more stable)
+ * - 'weighted': Blends all emotions by probability (more nuanced, e.g., bittersweet)
+ *
+ * Also supports energy modulation to scale emotion intensity by audio energy,
+ * making expressions stronger during emphasized speech.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { EmotionToBlendshapeMapper } from '@omote/core';
+ * import { Emotion2VecInference } from '@omote/core';
+ *
+ * const emotion = new Emotion2VecInference({ modelUrl: '/models/emotion.onnx' });
+ * const mapper = new EmotionToBlendshapeMapper();
+ *
+ * // Process emotion frame
+ * const result = await emotion.infer(audioSamples);
+ * const blendshapes = mapper.mapFrame(result.dominant);
+ *
+ * // Apply to avatar
+ * for (const [name, value] of Object.entries(blendshapes)) {
+ *   avatar.setBlendshape(name, value);
+ * }
+ * ```
+ *
+ * @example Weighted blending for nuanced expressions
+ * ```typescript
+ * const mapper = new EmotionToBlendshapeMapper({
+ *   blendMode: 'weighted',
+ *   minBlendProbability: 0.1,
+ * });
+ *
+ * // Frame with mixed emotions: { happy: 0.6, sad: 0.3, neutral: 0.1 }
+ * // Result: bittersweet expression (smiling but worried brow)
+ * const blendshapes = mapper.mapFrame(emotionFrame);
+ * ```
+ *
+ * @example Energy-modulated emotion
+ * ```typescript
+ * import { AudioEnergyAnalyzer } from '@omote/core';
+ *
+ * const energyAnalyzer = new AudioEnergyAnalyzer();
+ * const mapper = new EmotionToBlendshapeMapper({ energyModulation: true });
+ *
+ * // In animation loop
+ * function animate(audioChunk: Float32Array, emotionFrame: EmotionFrame) {
+ *   const { energy } = energyAnalyzer.analyze(audioChunk);
+ *   mapper.mapFrame(emotionFrame, energy); // Louder = stronger emotion
+ *   mapper.update(16);
+ *   applyToAvatar(mapper.getCurrentBlendshapes());
+ * }
+ * ```
+ *
+ * @module animation
+ */
+declare const EMOTION2VEC_LABELS: readonly ["neutral", "happy", "angry", "sad"];
+type Emotion2VecLabel = (typeof EMOTION2VEC_LABELS)[number];
+interface EmotionFrame {
+    /** Primary emotion label */
+    emotion: Emotion2VecLabel;
+    /** Confidence for primary emotion (0-1) */
+    confidence: number;
+    /** All emotion probabilities */
+    probabilities: Record<Emotion2VecLabel, number>;
+}
+/**
+ * Upper face ARKit blendshape names (11 total)
+ *
+ * These blendshapes control the upper face (brows, eyes, cheeks) and are
+ * driven by emotion detection, complementing the mouth blendshapes from
+ * LAM lip sync.
+ */
+declare const UPPER_FACE_BLENDSHAPES: readonly ["browDownLeft", "browDownRight", "browInnerUp", "browOuterUpLeft", "browOuterUpRight", "eyeSquintLeft", "eyeSquintRight", "eyeWideLeft", "eyeWideRight", "cheekSquintLeft", "cheekSquintRight"];
+type UpperFaceBlendshapeName = (typeof UPPER_FACE_BLENDSHAPES)[number];
+/**
+ * Upper face blendshape values (0-1 for each)
+ */
+type UpperFaceBlendshapes = Record<UpperFaceBlendshapeName, number>;
+/**
+ * Blend mode for combining emotions
+ * - 'dominant': Use only the strongest emotion (default, more stable)
+ * - 'weighted': Blend all emotions by probability (more nuanced)
+ */
+type EmotionBlendMode = 'dominant' | 'weighted';
+/**
+ * Emotion to ARKit blendshape mapping
+ *
+ * Based on Paul Ekman's FACS (Facial Action Coding System) research:
+ *
+ * - Happy (AU6+AU12): Cheek raise + lip corner pull (Duchenne smile)
+ *   Upper face: cheekSquint (AU6) + slight eyeSquint from genuine smile
+ *
+ * - Angry (AU4+AU5+AU7+AU23): Brow lower + eye wide + lid tighten + lip press
+ *   Upper face: browDown (AU4) + eyeWide (AU5) + eyeSquint (AU7) creates the "glare"
+ *
+ * - Sad (AU1+AU4+AU15): Inner brow raise + brow furrow + lip corner depress
+ *   Upper face: browInnerUp (AU1) + browDown (AU4) creates the worried/sad brow
+ *
+ * - Neutral: All zeros (no expression overlay)
+ *
+ * @see https://imotions.com/blog/learning/research-fundamentals/facial-action-coding-system/
+ * @see https://melindaozel.com/arkit-to-facs-cheat-sheet/
+ */
+declare const EMOTION_ARKIT_MAP: Record<Emotion2VecLabel, Partial<UpperFaceBlendshapes>>;
+/**
+ * Configuration for EmotionToBlendshapeMapper
+ */
+interface EmotionBlendshapeConfig {
+    /**
+     * Smoothing factor for exponential moving average (0-1)
+     * Lower = slower, smoother transitions
+     * Higher = faster, more responsive
+     * @default 0.15
+     */
+    smoothingFactor?: number;
+    /**
+     * Minimum confidence threshold for emotion to take effect
+     * Emotions below this confidence are treated as neutral
+     * @default 0.3
+     */
+    confidenceThreshold?: number;
+    /**
+     * Global intensity multiplier for all blendshapes (0-2)
+     * @default 1.0
+     */
+    intensity?: number;
+    /**
+     * Blend mode for combining emotions
+     * - 'dominant': Use only the strongest emotion (default)
+     * - 'weighted': Blend all emotions by probability
+     * @default 'dominant'
+     */
+    blendMode?: EmotionBlendMode;
+    /**
+     * Minimum probability for an emotion to contribute in weighted blend mode
+     * Emotions with probability below this are ignored
+     * @default 0.1
+     */
+    minBlendProbability?: number;
+    /**
+     * Enable energy modulation - scale emotion intensity by audio energy
+     * When enabled, louder speech produces stronger expressions
+     * @default false
+     */
+    energyModulation?: boolean;
+    /**
+     * Minimum energy scale when energy modulation is enabled (0-1)
+     * At zero audio energy, emotion intensity is scaled by this factor
+     * @default 0.3
+     */
+    minEnergyScale?: number;
+    /**
+     * Maximum energy scale when energy modulation is enabled (0-2)
+     * At maximum audio energy, emotion intensity is scaled by this factor
+     * @default 1.0
+     */
+    maxEnergyScale?: number;
+}
+/**
+ * EmotionToBlendshapeMapper
+ *
+ * Converts emotion detection output to upper face ARKit blendshapes.
+ * Provides smooth transitions between emotion states using exponential
+ * moving average interpolation.
+ *
+ * Supports two blend modes:
+ * - 'dominant': Uses only the strongest emotion
+ * - 'weighted': Blends all emotions by probability for nuanced expressions
+ *
+ * Also supports energy modulation to scale emotion intensity by audio energy.
+ */
+declare class EmotionToBlendshapeMapper {
+    private config;
+    private targetBlendshapes;
+    private currentBlendshapes;
+    private currentEnergy;
+    /**
+     * Create a new EmotionToBlendshapeMapper
+     *
+     * @param config - Optional configuration
+     */
+    constructor(config?: EmotionBlendshapeConfig);
+    /**
+     * Map an emotion frame to target blendshapes
+     *
+     * This sets the target values that the mapper will smoothly interpolate
+     * towards. Call update() each frame to apply smoothing.
+     *
+     * @param frame - Emotion frame from Emotion2VecInference
+     * @param audioEnergy - Optional audio energy (0-1) for energy modulation
+     * @returns Target upper face blendshapes (before smoothing)
+     */
+    mapFrame(frame: EmotionFrame, audioEnergy?: number): UpperFaceBlendshapes;
+    /**
+     * Map using dominant emotion only (original behavior)
+     */
+    private mapFrameDominant;
+    /**
+     * Map using weighted blend of all emotions by probability
+     * Creates more nuanced expressions (e.g., bittersweet = happy + sad)
+     */
+    private mapFrameWeighted;
+    /**
+     * Apply energy modulation to scale emotion intensity by audio energy
+     * Louder speech = stronger expressions
+     */
+    private applyEnergyModulation;
+    /**
+     * Apply smoothing to interpolate current values towards target
+     *
+     * Uses exponential moving average:
+     * current = current + smoothingFactor * (target - current)
+     *
+     * @param _deltaMs - Delta time in milliseconds (reserved for future time-based smoothing)
+     */
+    update(_deltaMs: number): void;
+    /**
+     * Get current smoothed blendshape values
+     *
+     * @returns Current upper face blendshapes (after smoothing)
+     */
+    getCurrentBlendshapes(): UpperFaceBlendshapes;
+    /**
+     * Reset mapper to neutral state
+     *
+     * Sets both target and current blendshapes to zero.
+     */
+    reset(): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Required<EmotionBlendshapeConfig>;
+    /**
+     * Update configuration
+     *
+     * @param config - Partial configuration to update
+     */
+    setConfig(config: Partial<EmotionBlendshapeConfig>): void;
+}
+
+/**
+ * FullFacePipeline - Combined LAM lip sync + Emotion upper face pipeline
+ *
+ * Orchestrates full-face animation by combining:
+ * 1. LAM lip sync (52 ARKit blendshapes) via audio-first scheduling
+ * 2. Emotion labels (from backend LLM or `setEmotionLabel()`) for upper face
+ * 3. AudioEnergyAnalyzer for prosody-driven fallback when no emotion label is set
+ *
+ * Architecture: Audio-First, LAM-Background (same as SyncedAudioPipeline)
+ * - Audio chunks are scheduled for playback immediately (never waits for LAM)
+ * - LAM inference runs in background without blocking the audio path
+ * - Lip sync starts ~1 second after audio (LAM needs 16000 samples to infer)
+ *
+ * Merge Strategy:
+ * - Lower face (41 blendshapes): 100% from LAM (mouth, jaw, tongue, etc.)
+ * - Upper face (11 blendshapes): Emotion overlay with LAM as subtle fallback
+ *   Formula: emotion * emotionBlendFactor + lam * lamBlendFactor
+ *
+ * Emotion Sources (in priority order):
+ * 1. `setEmotionLabel()` — explicit label from backend LLM (recommended)
+ * 2. Prosody fallback — subtle brow movement from audio energy (automatic)
+ *
+ * @category Audio
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { FullFacePipeline } from '@omote/core';
+ *
+ * const pipeline = new FullFacePipeline({
+ *   lam,
+ *   emotionBlendFactor: 0.8,
+ *   lamBlendFactor: 0.2,
+ * });
+ * await pipeline.initialize();
+ *
+ * pipeline.on('full_frame_ready', (frame) => {
+ *   applyToAvatar(frame.blendshapes);
+ * });
+ *
+ * pipeline.start();
+ * pipeline.setEmotionLabel('happy'); // From backend LLM
+ * 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 LAM inference time to pre-compute blendshapes.
+     * Default: auto-detected from lam.backend (50ms WebGPU, 350ms WASM).
+     */
+    audioDelayMs?: number;
+    /** LAM inference engine */
+    lam: LipSyncBackend;
+    /**
+     * Emotion blend factor for upper face blendshapes (0-1)
+     * Higher values give more weight to emotion detection
+     * @default 0.8
+     */
+    emotionBlendFactor?: number;
+    /**
+     * LAM blend factor for upper face blendshapes (0-1)
+     * Provides subtle fallback from LAM when emotion is weak
+     * @default 0.2
+     */
+    lamBlendFactor?: number;
+}
+/**
+ * Full face frame with merged blendshapes and emotion data
+ */
+interface FullFaceFrame {
+    /** Merged 52 ARKit blendshapes (lower face from LAM + upper face from emotion) */
+    blendshapes: Float32Array;
+    /** Original LAM blendshapes (52) */
+    lamBlendshapes: Float32Array;
+    /** Emotion-driven upper face blendshapes (11) */
+    emotionBlendshapes: UpperFaceBlendshapes;
+    /** Raw emotion frame data */
+    emotion: EmotionFrame | null;
+    /** AudioContext timestamp for this frame */
+    timestamp: number;
+}
+/**
+ * Events emitted by FullFacePipeline
+ */
+interface FullFacePipelineEvents {
+    /** New merged frame ready for display */
+    full_frame_ready: FullFaceFrame;
+    /** Raw LAM frame ready (for debugging/monitoring) */
+    lam_frame_ready: Float32Array;
+    /** Emotion frame ready (for debugging/monitoring) */
+    emotion_frame_ready: EmotionFrame;
+    /** 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 - Unified LAM + Emotion animation pipeline
+ *
+ * Audio-first design matching SyncedAudioPipeline:
+ * - Audio is scheduled immediately (never waits for LAM)
+ * - LAM runs in background (fire-and-forget)
+ * - Emotion from setEmotionLabel() or prosody fallback
+ */
+declare class FullFacePipeline extends EventEmitter<FullFacePipelineEvents> {
+    private readonly options;
+    private scheduler;
+    private coalescer;
+    private lamPipeline;
+    private emotionMapper;
+    private energyAnalyzer;
+    private playbackStarted;
+    private monitorInterval;
+    private frameAnimationId;
+    private lastEmotionFrame;
+    private currentAudioEnergy;
+    private lastNewFrameTime;
+    private lastKnownLamFrame;
+    private staleWarningEmitted;
+    private static readonly STALE_FRAME_THRESHOLD_MS;
+    private emotionBlendFactor;
+    private lamBlendFactor;
+    constructor(options: FullFacePipelineOptions);
+    /**
+     * Initialize the pipeline
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set emotion label from backend (e.g., LLM response emotion).
+     *
+     * Converts a natural language emotion label into an EmotionFrame
+     * that drives upper face blendshapes for the duration of the utterance.
+     *
+     * Supported labels: happy, excited, joyful, sad, melancholic, angry,
+     * frustrated, neutral, etc.
+     *
+     * @param label - Emotion label string (case-insensitive)
+     */
+    setEmotionLabel(label: string): void;
+    /**
+     * Clear any set emotion label.
+     * Falls back to prosody-only upper face animation.
+     */
+    clearEmotionLabel(): void;
+    /**
+     * 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, LAM runs in background.
+     * This prevents LAM inference (50-300ms) from blocking audio scheduling.
+     *
+     * @param chunk - Uint8Array containing Int16 PCM audio
+     */
+    onAudioChunk(chunk: Uint8Array): Promise<void>;
+    /**
+     * Get emotion frame for current animation.
+     *
+     * Priority:
+     * 1. Explicit emotion label from setEmotionLabel()
+     * 2. Prosody fallback: subtle brow movement from audio energy
+     */
+    private getEmotionFrame;
+    /**
+     * Merge LAM blendshapes with emotion upper face blendshapes
+     */
+    mergeBlendshapes(lamFrame: Float32Array, emotionFrame: EmotionFrame | null, audioEnergy?: number): {
+        merged: Float32Array;
+        emotionBlendshapes: UpperFaceBlendshapes;
+    };
+    /**
+     * Start frame animation loop
+     */
+    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;
+        lamFill: number;
+        queuedLAMFrames: number;
+        emotionLabel: "neutral" | "happy" | "angry" | "sad" | null;
+        currentAudioEnergy: number;
+        currentTime: number;
+        playbackEndTime: number;
+    };
+    /**
+     * Check if an explicit emotion label is currently set
+     */
+    get hasEmotionLabel(): boolean;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+
 /**
  * Lazy ONNX Runtime loader with conditional WebGPU/WASM bundle loading
  *
@@ -1179,6 +1657,8 @@ declare class Wav2Vec2Inference implements LipSyncBackend {
     private isLoading;
     private numIdentityClasses;
     private inferenceQueue;
+    private poisoned;
+    private static readonly INFERENCE_TIMEOUT_MS;
     constructor(config: Wav2Vec2InferenceConfig);
     /**
      * Check if WebGPU is available and working
@@ -1187,6 +1667,8 @@ declare class Wav2Vec2Inference implements LipSyncBackend {
     static isWebGPUAvailable: typeof isWebGPUAvailable;
     get backend(): 'webgpu' | 'wasm' | null;
     get isLoaded(): boolean;
+    /** True if inference timed out and the session is permanently unusable */
+    get isSessionPoisoned(): boolean;
     /**
      * Load the ONNX model
      */
@@ -4069,4 +4551,157 @@ 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, 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 };
+/**
+ * ProceduralLifeLayer - Renderer-agnostic procedural animation system
+ *
+ * Outputs per-frame blendshape values and head deltas for organic life-like
+ * animation. No Three.js, no React, no R3F — just math.
+ *
+ * Implements research-based eye behavior, blinks, gaze breaks, microsaccades,
+ * breathing/postural sway, and simplex noise-driven brow drift.
+ *
+ * Research sources:
+ * - Blink frequency: 15-20/min (every 3-4s), PMC4043155
+ * - Saccade latency: ~200ms, duration 20-200ms
+ * - Microsaccades: ~1/second, amplitude 0.02-0.05, Scholarpedia
+ * - Fixation duration: 200-350ms, Nature Scientific Reports
+ * - Brow noise: NVIDIA Audio2Face, Unreal MetaHuman layered procedural animation
+ *
+ * @category Animation
+ *
+ * @example
+ * ```typescript
+ * import { ProceduralLifeLayer } from '@omote/core';
+ *
+ * const lifeLayer = new ProceduralLifeLayer();
+ *
+ * // In animation loop:
+ * const output = lifeLayer.update(delta, {
+ *   eyeTargetX: normalizedX, // -1..1 from camera math
+ *   eyeTargetY: normalizedY,
+ *   audioEnergy: energy,     // 0-1 from AudioEnergyAnalyzer
+ *   isSpeaking: true,
+ * });
+ *
+ * // Apply blendshapes to mesh
+ * for (const [name, value] of Object.entries(output.blendshapes)) {
+ *   const idx = mesh.morphTargetDictionary?.[name];
+ *   if (idx !== undefined) mesh.morphTargetInfluences![idx] = value;
+ * }
+ *
+ * // Apply head delta to head bone
+ * headBone.rotation.y += output.headDelta.yaw;
+ * headBone.rotation.x += output.headDelta.pitch;
+ * ```
+ */
+/**
+ * Configuration for ProceduralLifeLayer
+ */
+interface LifeLayerConfig {
+    /** Seconds between blinks [min, max]. Default: [2.5, 6] */
+    blinkIntervalRange?: [number, number];
+    /** Seconds between gaze breaks [min, max]. Default: [3, 8] */
+    gazeBreakIntervalRange?: [number, number];
+    /** Gaze break deviation range [min, max]. Default: [0.15, 0.4] */
+    gazeBreakAmplitudeRange?: [number, number];
+    /** Eye micro-motion noise amplitude (0 to disable). Default: 0.06 */
+    eyeNoiseAmplitude?: number;
+    /** Base simplex noise amplitude for brow drift. Default: 0.30 */
+    browNoiseAmplitude?: number;
+    /** Multiply brow noise when speaking. Default: 2.0 */
+    browNoiseSpeechMultiplier?: number;
+    /** Breathing rate in Hz (0.25 = 15 breaths/min). Default: 0.25 */
+    breathingRate?: number;
+    /** Postural sway amplitude in radians. Default: 0.002 */
+    posturalSwayAmplitude?: number;
+    /** Max eye movement from center (0-1). Default: 0.8 */
+    eyeMaxDeviation?: number;
+    /** Eye smoothing factor (higher = faster response). Default: 15 */
+    eyeSmoothing?: number;
+}
+/**
+ * Per-frame input to the life layer
+ */
+interface LifeLayerInput {
+    /** Normalized eye target X: -1 (left) to 1 (right). Consumer computes from camera. */
+    eyeTargetX?: number;
+    /** Normalized eye target Y: -1 (down) to 1 (up). Consumer computes from camera. */
+    eyeTargetY?: number;
+    /** Audio energy 0-1 (from AudioEnergyAnalyzer). Drives brow noise amplitude. */
+    audioEnergy?: number;
+    /** Whether avatar is speaking. Multiplies brow noise amplitude. */
+    isSpeaking?: boolean;
+}
+/**
+ * Per-frame output from the life layer
+ */
+interface LifeLayerOutput {
+    /** Blendshape values to SET directly on mesh (eyes, brows, cheeks). */
+    blendshapes: Record<string, number>;
+    /** Head rotation deltas in radians. Consumer adds to head bone rotation. */
+    headDelta: {
+        yaw: number;
+        pitch: number;
+    };
+}
+/**
+ * ProceduralLifeLayer - Renderer-agnostic procedural animation
+ *
+ * Generates per-frame blendshape values and head rotation deltas
+ * for natural eye behavior, blinks, brow movement, and breathing.
+ */
+declare class ProceduralLifeLayer {
+    private blinkIntervalRange;
+    private gazeBreakIntervalRange;
+    private gazeBreakAmplitudeRange;
+    private eyeNoiseAmplitude;
+    private browNoiseAmplitude;
+    private browNoiseSpeechMultiplier;
+    private breathingRate;
+    private posturalSwayAmplitude;
+    private eyeMaxDeviation;
+    private eyeSmoothing;
+    private blinkTimer;
+    private blinkInterval;
+    private blinkPhase;
+    private blinkProgress;
+    private asymmetryRight;
+    private smoothedBlinkLeft;
+    private smoothedBlinkRight;
+    private smoothedEyeX;
+    private smoothedEyeY;
+    private eyeNoiseTime;
+    private gazeBreakTimer;
+    private gazeBreakInterval;
+    private gazeBreakPhase;
+    private gazeBreakProgress;
+    private gazeBreakTargetX;
+    private gazeBreakTargetY;
+    private gazeBreakCurrentX;
+    private gazeBreakCurrentY;
+    private microMotionTime;
+    private breathingPhase;
+    private noiseTime;
+    private previousEnergy;
+    private emphasisLevel;
+    constructor(config?: LifeLayerConfig);
+    /**
+     * Update the life layer and produce output for this frame.
+     *
+     * @param delta - Time since last frame in seconds
+     * @param input - Per-frame input (eye target, audio energy, speaking state)
+     * @returns Blendshape values and head rotation deltas
+     */
+    update(delta: number, input?: LifeLayerInput): LifeLayerOutput;
+    /**
+     * Reset all internal state to initial values.
+     */
+    reset(): void;
+    private updateBlinks;
+    private getBlinkValues;
+    private getEyeMicroMotion;
+    private updateGazeBreaks;
+    private updateBrowNoise;
+}
+
+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_ARKIT_MAP, EMOTION_NAMES, EMOTION_VECTOR_SIZE, type Emotion2VecLabel, type EmotionAnimationMap, type EmotionBlendMode, type EmotionBlendshapeConfig, EmotionController, type EmotionFrame, type EmotionLabel, type EmotionName, type EmotionPresetName, EmotionPresets, EmotionToBlendshapeMapper, type EmotionWeights, EmphasisDetector, EventEmitter, type FetchWithCacheOptions, type FullFaceFrame, FullFacePipeline, type FullFacePipelineEvents, type FullFacePipelineOptions, INFERENCE_LATENCY_BUCKETS, type InferenceSpanAttributes, type InterruptionConfig, type InterruptionEvents, InterruptionHandler, type KaldiFbankOptions, type LAMFrame, LAMPipeline, type LAMPipelineOptions, LAM_BLENDSHAPES, type LifeLayerConfig, type LifeLayerInput, type LifeLayerOutput, 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, ProceduralLifeLayer, 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, UPPER_FACE_BLENDSHAPES, type UpperFaceBlendshapeName, type UpperFaceBlendshapes, 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 };