@omote/core 0.4.1 → 0.4.3

package/dist/index.js

@@ -42,12 +42,15 @@ __export(index_exports, {
   ConversationOrchestrator: () => ConversationOrchestrator,
   DEFAULT_ANIMATION_CONFIG: () => DEFAULT_ANIMATION_CONFIG,
   DEFAULT_LOGGING_CONFIG: () => DEFAULT_LOGGING_CONFIG,
+  EMOTION_ARKIT_MAP: () => EMOTION_ARKIT_MAP,
   EMOTION_NAMES: () => EMOTION_NAMES,
   EMOTION_VECTOR_SIZE: () => EMOTION_VECTOR_SIZE,
   EmotionController: () => EmotionController,
   EmotionPresets: () => EmotionPresets,
+  EmotionToBlendshapeMapper: () => EmotionToBlendshapeMapper,
   EmphasisDetector: () => EmphasisDetector,
   EventEmitter: () => EventEmitter,
+  FullFacePipeline: () => FullFacePipeline,
   INFERENCE_LATENCY_BUCKETS: () => INFERENCE_LATENCY_BUCKETS,
   InterruptionHandler: () => InterruptionHandler,
   LAMPipeline: () => LAMPipeline,
@@ -59,6 +62,8 @@ __export(index_exports, {
   ModelCache: () => ModelCache,
   OTLPExporter: () => OTLPExporter,
   OmoteTelemetry: () => OmoteTelemetry,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  ProceduralLifeLayer: () => ProceduralLifeLayer,
   RingBuffer: () => RingBuffer,
   SafariSpeechRecognition: () => SafariSpeechRecognition,
   SenseVoiceInference: () => SenseVoiceInference,
@@ -66,6 +71,7 @@ __export(index_exports, {
   SileroVADWorker: () => SileroVADWorker,
   SyncedAudioPipeline: () => SyncedAudioPipeline,
   TenantManager: () => TenantManager,
+  UPPER_FACE_BLENDSHAPES: () => UPPER_FACE_BLENDSHAPES,
   WAV2ARKIT_BLENDSHAPES: () => WAV2ARKIT_BLENDSHAPES,
   Wav2ArkitCpuInference: () => Wav2ArkitCpuInference,
   Wav2Vec2Inference: () => Wav2Vec2Inference,
@@ -104,6 +110,7 @@ __export(index_exports, {
   isIOSSafari: () => isIOSSafari,
   isMobile: () => isMobile,
   isOnnxRuntimeLoaded: () => isOnnxRuntimeLoaded,
+  isProtocolEvent: () => isProtocolEvent,
   isSafari: () => isSafari,
   isSpeechRecognitionAvailable: () => isSpeechRecognitionAvailable,
   isWebGPUAvailable: () => isWebGPUAvailable,
@@ -1024,6 +1031,327 @@ var UPPER_FACE_BLENDSHAPES = [
   "cheekSquintLeft",
   "cheekSquintRight"
 ];
+var EMOTION_ARKIT_MAP = {
+  happy: {
+    // AU6 - Cheek raiser (primary Duchenne smile marker)
+    cheekSquintLeft: 0.5,
+    cheekSquintRight: 0.5,
+    // Slight eye squint from genuine smile (orbicularis oculi activation)
+    eyeSquintLeft: 0.2,
+    eyeSquintRight: 0.2
+  },
+  angry: {
+    // AU4 - Brow lowerer (intense, primary anger marker)
+    browDownLeft: 0.7,
+    browDownRight: 0.7,
+    // AU5 - Upper lid raiser (wide eyes, part of the "glare")
+    eyeWideLeft: 0.4,
+    eyeWideRight: 0.4,
+    // AU7 - Lid tightener (tense stare, combines with AU5 for angry glare)
+    eyeSquintLeft: 0.3,
+    eyeSquintRight: 0.3
+  },
+  sad: {
+    // AU1 - Inner brow raiser (primary sadness marker)
+    browInnerUp: 0.6,
+    // AU4 - Brow lowerer (brows drawn together)
+    browDownLeft: 0.3,
+    browDownRight: 0.3
+  },
+  neutral: {}
+  // All zeros - no expression overlay
+};
+var DEFAULT_CONFIG = {
+  smoothingFactor: 0.15,
+  confidenceThreshold: 0.3,
+  intensity: 1,
+  blendMode: "dominant",
+  minBlendProbability: 0.1,
+  energyModulation: false,
+  minEnergyScale: 0.3,
+  maxEnergyScale: 1
+};
+function createZeroBlendshapes() {
+  const result = {};
+  for (const name of UPPER_FACE_BLENDSHAPES) {
+    result[name] = 0;
+  }
+  return result;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+var EmotionToBlendshapeMapper = class {
+  /**
+   * Create a new EmotionToBlendshapeMapper
+   *
+   * @param config - Optional configuration
+   */
+  constructor(config) {
+    this.currentEnergy = 1;
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    this.targetBlendshapes = createZeroBlendshapes();
+    this.currentBlendshapes = createZeroBlendshapes();
+  }
+  /**
+   * 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, audioEnergy) {
+    this.targetBlendshapes = createZeroBlendshapes();
+    if (audioEnergy !== void 0) {
+      this.currentEnergy = clamp01(audioEnergy);
+    }
+    if (!frame) {
+      return { ...this.targetBlendshapes };
+    }
+    if (this.config.blendMode === "weighted") {
+      this.mapFrameWeighted(frame);
+    } else {
+      this.mapFrameDominant(frame);
+    }
+    if (this.config.energyModulation) {
+      this.applyEnergyModulation();
+    }
+    return { ...this.targetBlendshapes };
+  }
+  /**
+   * Map using dominant emotion only (original behavior)
+   */
+  mapFrameDominant(frame) {
+    if (frame.confidence < this.config.confidenceThreshold) {
+      return;
+    }
+    const emotion = frame.emotion;
+    const mapping = EMOTION_ARKIT_MAP[emotion];
+    if (!mapping) {
+      return;
+    }
+    const scale = this.config.intensity * frame.confidence;
+    for (const [name, value] of Object.entries(mapping)) {
+      const blendshapeName = name;
+      if (value !== void 0) {
+        this.targetBlendshapes[blendshapeName] = clamp01(value * scale);
+      }
+    }
+  }
+  /**
+   * Map using weighted blend of all emotions by probability
+   * Creates more nuanced expressions (e.g., bittersweet = happy + sad)
+   */
+  mapFrameWeighted(frame) {
+    if (!frame.probabilities) {
+      this.mapFrameDominant(frame);
+      return;
+    }
+    for (const [emotion, probability] of Object.entries(frame.probabilities)) {
+      if (probability < this.config.minBlendProbability) {
+        continue;
+      }
+      const mapping = EMOTION_ARKIT_MAP[emotion];
+      if (!mapping) {
+        continue;
+      }
+      const scale = this.config.intensity * probability;
+      for (const [name, value] of Object.entries(mapping)) {
+        const blendshapeName = name;
+        if (value !== void 0) {
+          this.targetBlendshapes[blendshapeName] += value * scale;
+        }
+      }
+    }
+    for (const name of UPPER_FACE_BLENDSHAPES) {
+      this.targetBlendshapes[name] = clamp01(this.targetBlendshapes[name]);
+    }
+  }
+  /**
+   * Apply energy modulation to scale emotion intensity by audio energy
+   * Louder speech = stronger expressions
+   */
+  applyEnergyModulation() {
+    const { minEnergyScale, maxEnergyScale } = this.config;
+    const energyScale = minEnergyScale + this.currentEnergy * (maxEnergyScale - minEnergyScale);
+    for (const name of UPPER_FACE_BLENDSHAPES) {
+      this.targetBlendshapes[name] = clamp01(this.targetBlendshapes[name] * energyScale);
+    }
+  }
+  /**
+   * 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) {
+    const factor = this.config.smoothingFactor;
+    for (const name of UPPER_FACE_BLENDSHAPES) {
+      const target = this.targetBlendshapes[name];
+      const current = this.currentBlendshapes[name];
+      this.currentBlendshapes[name] = clamp01(current + factor * (target - current));
+    }
+  }
+  /**
+   * Get current smoothed blendshape values
+   *
+   * @returns Current upper face blendshapes (after smoothing)
+   */
+  getCurrentBlendshapes() {
+    return { ...this.currentBlendshapes };
+  }
+  /**
+   * Reset mapper to neutral state
+   *
+   * Sets both target and current blendshapes to zero.
+   */
+  reset() {
+    this.targetBlendshapes = createZeroBlendshapes();
+    this.currentBlendshapes = createZeroBlendshapes();
+    this.currentEnergy = 1;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   *
+   * @param config - Partial configuration to update
+   */
+  setConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+  }
+};
+
+// src/animation/audioEnergy.ts
+function calculateRMS(samples) {
+  if (samples.length === 0) return 0;
+  let sumSquares = 0;
+  for (let i = 0; i < samples.length; i++) {
+    sumSquares += samples[i] * samples[i];
+  }
+  return Math.sqrt(sumSquares / samples.length);
+}
+function calculatePeak(samples) {
+  let peak = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const abs = Math.abs(samples[i]);
+    if (abs > peak) peak = abs;
+  }
+  return peak;
+}
+var AudioEnergyAnalyzer = class {
+  /**
+   * @param smoothingFactor How much to smooth (0 = no smoothing, 1 = infinite smoothing). Default 0.85
+   * @param noiseFloor Minimum energy threshold to consider as signal. Default 0.01
+   */
+  constructor(smoothingFactor = 0.85, noiseFloor = 0.01) {
+    this.smoothedRMS = 0;
+    this.smoothedPeak = 0;
+    this.smoothingFactor = Math.max(0, Math.min(0.99, smoothingFactor));
+    this.noiseFloor = noiseFloor;
+  }
+  /**
+   * Process audio samples and return smoothed energy values
+   * @param samples Audio samples (Float32Array)
+   * @returns Object with rms and peak values
+   */
+  process(samples) {
+    const instantRMS = calculateRMS(samples);
+    const instantPeak = calculatePeak(samples);
+    const gatedRMS = instantRMS > this.noiseFloor ? instantRMS : 0;
+    const gatedPeak = instantPeak > this.noiseFloor ? instantPeak : 0;
+    if (gatedRMS > this.smoothedRMS) {
+      this.smoothedRMS = this.smoothedRMS * 0.5 + gatedRMS * 0.5;
+    } else {
+      this.smoothedRMS = this.smoothedRMS * this.smoothingFactor + gatedRMS * (1 - this.smoothingFactor);
+    }
+    if (gatedPeak > this.smoothedPeak) {
+      this.smoothedPeak = this.smoothedPeak * 0.3 + gatedPeak * 0.7;
+    } else {
+      this.smoothedPeak = this.smoothedPeak * this.smoothingFactor + gatedPeak * (1 - this.smoothingFactor);
+    }
+    const energy = this.smoothedRMS * 0.7 + this.smoothedPeak * 0.3;
+    return {
+      rms: this.smoothedRMS,
+      peak: this.smoothedPeak,
+      energy: Math.min(1, energy * 2)
+      // Scale up and clamp
+    };
+  }
+  /**
+   * Reset analyzer state
+   */
+  reset() {
+    this.smoothedRMS = 0;
+    this.smoothedPeak = 0;
+  }
+  /**
+   * Get current smoothed RMS value
+   */
+  get rms() {
+    return this.smoothedRMS;
+  }
+  /**
+   * Get current smoothed peak value
+   */
+  get peak() {
+    return this.smoothedPeak;
+  }
+};
+var EmphasisDetector = class {
+  /**
+   * @param historySize Number of frames to track. Default 10
+   * @param emphasisThreshold Minimum energy increase to count as emphasis. Default 0.15
+   */
+  constructor(historySize = 10, emphasisThreshold = 0.15) {
+    this.energyHistory = [];
+    this.historySize = historySize;
+    this.emphasisThreshold = emphasisThreshold;
+  }
+  /**
+   * Process energy value and detect emphasis
+   * @param energy Current energy value (0-1)
+   * @returns Object with isEmphasis flag and emphasisStrength
+   */
+  process(energy) {
+    this.energyHistory.push(energy);
+    if (this.energyHistory.length > this.historySize) {
+      this.energyHistory.shift();
+    }
+    if (this.energyHistory.length < 3) {
+      return { isEmphasis: false, emphasisStrength: 0 };
+    }
+    const prevFrames = this.energyHistory.slice(0, -1);
+    const avgPrev = prevFrames.reduce((a, b) => a + b, 0) / prevFrames.length;
+    const increase = energy - avgPrev;
+    const isEmphasis = increase > this.emphasisThreshold;
+    return {
+      isEmphasis,
+      emphasisStrength: isEmphasis ? Math.min(1, increase / 0.3) : 0
+    };
+  }
+  /**
+   * Reset detector state
+   */
+  reset() {
+    this.energyHistory = [];
+  }
+};
 
 // src/telemetry/exporters/console.ts
 var ConsoleExporter = class {
@@ -2925,7 +3253,7 @@ var CTC_VOCAB = [
   "Q",
   "Z"
 ];
-var Wav2Vec2Inference = class {
+var _Wav2Vec2Inference = class _Wav2Vec2Inference {
   constructor(config) {
     this.modelId = "wav2vec2";
     this.session = null;
@@ -2934,6 +3262,10 @@ var Wav2Vec2Inference = class {
     this.isLoading = false;
     // Inference queue for handling concurrent calls
     this.inferenceQueue = Promise.resolve();
+    // Session health: set to true if session.run() times out.
+    // A timed-out session may have a zombie GPU/WASM dispatch still running,
+    // so all future infer() calls reject immediately to prevent concurrent access.
+    this.poisoned = false;
     this.config = config;
     this.numIdentityClasses = config.numIdentityClasses ?? 12;
   }
@@ -2943,6 +3275,10 @@ var Wav2Vec2Inference = class {
   get isLoaded() {
     return this.session !== null;
   }
+  /** True if inference timed out and the session is permanently unusable */
+  get isSessionPoisoned() {
+    return this.poisoned;
+  }
   /**
    * Load the ONNX model
    */
@@ -3092,12 +3428,23 @@ var Wav2Vec2Inference = class {
       logger2.debug("Running warmup inference to initialize GPU context");
       const warmupStart = performance.now();
       const silentAudio = new Float32Array(16e3);
-      await this.infer(silentAudio, 0);
+      const WARMUP_TIMEOUT_MS = 15e3;
+      const warmupResult = await Promise.race([
+        this.infer(silentAudio, 0).then(() => "ok"),
+        new Promise((r) => setTimeout(() => r("timeout"), WARMUP_TIMEOUT_MS))
+      ]);
       const warmupTimeMs = performance.now() - warmupStart;
-      logger2.info("Warmup inference complete", {
-        warmupTimeMs: Math.round(warmupTimeMs),
-        backend: this._backend
-      });
+      if (warmupResult === "timeout") {
+        logger2.warn("Warmup inference timed out \u2014 GPU may be unresponsive. Continuing without warmup.", {
+          timeoutMs: WARMUP_TIMEOUT_MS,
+          backend: this._backend
+        });
+      } else {
+        logger2.info("Warmup inference complete", {
+          warmupTimeMs: Math.round(warmupTimeMs),
+          backend: this._backend
+        });
+      }
       telemetry?.recordHistogram("omote.model.warmup_time", warmupTimeMs, {
         model: "wav2vec2",
         backend: this._backend
@@ -3131,6 +3478,9 @@ var Wav2Vec2Inference = class {
     if (!this.session) {
       throw new Error("Model not loaded. Call load() first.");
     }
+    if (this.poisoned) {
+      throw new Error("Wav2Vec2 session timed out \u2014 inference unavailable until page reload");
+    }
     const audioSamplesCopy = new Float32Array(audioSamples);
     let audio;
     if (audioSamplesCopy.length === 16e3) {
@@ -3186,7 +3536,15 @@ var Wav2Vec2Inference = class {
         });
         try {
           const startTime = performance.now();
-          const results = await this.session.run(feeds);
+          const results = await Promise.race([
+            this.session.run(feeds),
+            new Promise(
+              (_, rej) => setTimeout(
+                () => rej(new Error(`Wav2Vec2 inference timed out after ${_Wav2Vec2Inference.INFERENCE_TIMEOUT_MS}ms`)),
+                _Wav2Vec2Inference.INFERENCE_TIMEOUT_MS
+              )
+            )
+          ]);
           const inferenceTimeMs = performance.now() - startTime;
           const asrOutput = results["asr_logits"];
           const blendshapeOutput = results["blendshapes"];
@@ -3240,50 +3598,411 @@ var Wav2Vec2Inference = class {
             inferenceTimeMs
           });
         } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("timed out")) {
+            this.poisoned = true;
+            logger2.error("CRITICAL: Inference session timed out \u2014 LAM is dead. Page reload required.", {
+              backend: this._backend,
+              timeoutMs: _Wav2Vec2Inference.INFERENCE_TIMEOUT_MS
+            });
+          } else {
+            logger2.error("Inference failed", { error: errMsg, backend: this._backend });
+          }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
             model: "wav2vec2",
             backend: this._backend,
             status: "error"
           });
-          reject(err);
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * Get blendshape value by name for a specific frame
+   */
+  getBlendshape(blendshapes, name) {
+    const index = LAM_BLENDSHAPES.indexOf(name);
+    if (index === -1) {
+      throw new Error(`Unknown blendshape: ${name}`);
+    }
+    return blendshapes[index];
+  }
+  /**
+   * Dispose of the model and free resources
+   */
+  async dispose() {
+    if (this.session) {
+      await this.session.release();
+      this.session = null;
+    }
+  }
+};
+_Wav2Vec2Inference.INFERENCE_TIMEOUT_MS = 5e3;
+/**
+ * Check if WebGPU is available and working
+ * (iOS returns false even if navigator.gpu exists due to ONNX Runtime bugs)
+ */
+_Wav2Vec2Inference.isWebGPUAvailable = isWebGPUAvailable;
+var Wav2Vec2Inference = _Wav2Vec2Inference;
+
+// src/audio/FullFacePipeline.ts
+var logger3 = createLogger("FullFacePipeline");
+function pcm16ToFloat322(buffer) {
+  const byteLen = buffer.byteLength & ~1;
+  const int16 = byteLen === buffer.byteLength ? new Int16Array(buffer) : new Int16Array(buffer, 0, byteLen / 2);
+  const float32 = new Float32Array(int16.length);
+  for (let i = 0; i < int16.length; i++) {
+    float32[i] = int16[i] / 32768;
+  }
+  return float32;
+}
+var BLENDSHAPE_INDEX_MAP = /* @__PURE__ */ new Map();
+LAM_BLENDSHAPES.forEach((name, index) => {
+  BLENDSHAPE_INDEX_MAP.set(name, index);
+});
+var UPPER_FACE_SET = new Set(UPPER_FACE_BLENDSHAPES);
+var EMOTION_LABEL_MAP = {
+  // Direct labels
+  happy: "happy",
+  sad: "sad",
+  angry: "angry",
+  neutral: "neutral",
+  // Natural language synonyms
+  excited: "happy",
+  joyful: "happy",
+  cheerful: "happy",
+  delighted: "happy",
+  amused: "happy",
+  melancholic: "sad",
+  sorrowful: "sad",
+  disappointed: "sad",
+  frustrated: "angry",
+  irritated: "angry",
+  furious: "angry",
+  annoyed: "angry",
+  // SenseVoice labels
+  fearful: "sad",
+  disgusted: "angry",
+  surprised: "happy"
+};
+var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.playbackStarted = false;
+    this.monitorInterval = null;
+    this.frameAnimationId = null;
+    // Emotion state
+    this.lastEmotionFrame = null;
+    this.currentAudioEnergy = 0;
+    // Stale frame detection
+    this.lastNewFrameTime = 0;
+    this.lastKnownLamFrame = null;
+    this.staleWarningEmitted = false;
+    const sampleRate = options.sampleRate ?? 16e3;
+    this.emotionBlendFactor = options.emotionBlendFactor ?? 0.8;
+    this.lamBlendFactor = options.lamBlendFactor ?? 0.2;
+    const autoDelay = options.lam.modelId === "wav2arkit_cpu" ? 750 : options.lam.backend === "wasm" ? 350 : 50;
+    const audioDelayMs = options.audioDelayMs ?? autoDelay;
+    this.scheduler = new AudioScheduler({
+      sampleRate,
+      initialLookaheadSec: audioDelayMs / 1e3
+    });
+    this.coalescer = new AudioChunkCoalescer({
+      sampleRate,
+      targetDurationMs: options.chunkTargetMs ?? 200
+    });
+    this.lamPipeline = new LAMPipeline({
+      sampleRate,
+      onError: (error) => {
+        logger3.error("LAM inference error", { message: error.message, stack: error.stack });
+        this.emit("error", error);
+      }
+    });
+    this.emotionMapper = new EmotionToBlendshapeMapper({
+      smoothingFactor: 0.15,
+      confidenceThreshold: 0.3,
+      intensity: 1,
+      energyModulation: true
+    });
+    this.energyAnalyzer = new AudioEnergyAnalyzer();
+  }
+  /**
+   * Initialize the pipeline
+   */
+  async initialize() {
+    await this.scheduler.initialize();
+  }
+  /**
+   * 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) {
+    const normalized = label.toLowerCase();
+    const mapped = EMOTION_LABEL_MAP[normalized] ?? "neutral";
+    const probabilities = {
+      neutral: 0.1,
+      happy: 0.1,
+      angry: 0.1,
+      sad: 0.1
+    };
+    probabilities[mapped] = 0.7;
+    const frame = {
+      emotion: mapped,
+      confidence: 0.7,
+      probabilities
+    };
+    this.lastEmotionFrame = frame;
+    logger3.info("Emotion label set", { label, mapped });
+  }
+  /**
+   * Clear any set emotion label.
+   * Falls back to prosody-only upper face animation.
+   */
+  clearEmotionLabel() {
+    this.lastEmotionFrame = null;
+  }
+  /**
+   * 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() {
+    this.stopMonitoring();
+    this.scheduler.reset();
+    this.coalescer.reset();
+    this.lamPipeline.reset();
+    this.playbackStarted = false;
+    this.lastEmotionFrame = null;
+    this.currentAudioEnergy = 0;
+    this.emotionMapper.reset();
+    this.energyAnalyzer.reset();
+    this.lastNewFrameTime = 0;
+    this.lastKnownLamFrame = null;
+    this.staleWarningEmitted = false;
+    this.scheduler.warmup();
+    this.startFrameLoop();
+    this.startMonitoring();
+  }
+  /**
+   * 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
+   */
+  async onAudioChunk(chunk) {
+    const combined = this.coalescer.add(chunk);
+    if (!combined) {
+      return;
+    }
+    const float32 = pcm16ToFloat322(combined);
+    const scheduleTime = await this.scheduler.schedule(float32);
+    if (!this.playbackStarted) {
+      this.playbackStarted = true;
+      this.emit("playback_start", scheduleTime);
+    }
+    const { energy } = this.energyAnalyzer.process(float32);
+    this.currentAudioEnergy = energy;
+    this.lamPipeline.push(float32, scheduleTime, this.options.lam).catch((err) => {
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Get emotion frame for current animation.
+   *
+   * Priority:
+   * 1. Explicit emotion label from setEmotionLabel()
+   * 2. Prosody fallback: subtle brow movement from audio energy
+   */
+  getEmotionFrame() {
+    if (this.lastEmotionFrame) {
+      return { frame: this.lastEmotionFrame, energy: this.currentAudioEnergy };
+    }
+    return { frame: null, energy: this.currentAudioEnergy };
+  }
+  /**
+   * Merge LAM blendshapes with emotion upper face blendshapes
+   */
+  mergeBlendshapes(lamFrame, emotionFrame, audioEnergy) {
+    const merged = new Float32Array(52);
+    let emotionBlendshapes;
+    if (emotionFrame) {
+      this.emotionMapper.mapFrame(emotionFrame, audioEnergy);
+      this.emotionMapper.update(33);
+      emotionBlendshapes = this.emotionMapper.getCurrentBlendshapes();
+    } else {
+      emotionBlendshapes = {};
+      for (const name of UPPER_FACE_BLENDSHAPES) {
+        emotionBlendshapes[name] = 0;
+      }
+    }
+    for (let i = 0; i < 52; i++) {
+      const name = LAM_BLENDSHAPES[i];
+      if (UPPER_FACE_SET.has(name)) {
+        const emotionValue = emotionBlendshapes[name] ?? 0;
+        const lamValue = lamFrame[i];
+        merged[i] = emotionValue * this.emotionBlendFactor + lamValue * this.lamBlendFactor;
+      } else {
+        merged[i] = lamFrame[i];
+      }
+    }
+    return { merged, emotionBlendshapes };
+  }
+  /**
+   * Start frame animation loop
+   */
+  startFrameLoop() {
+    const updateFrame = () => {
+      const currentTime = this.scheduler.getCurrentTime();
+      const lamFrame = this.lamPipeline.getFrameForTime(currentTime, this.options.lam);
+      if (lamFrame) {
+        if (lamFrame !== this.lastKnownLamFrame) {
+          this.lastNewFrameTime = performance.now();
+          this.lastKnownLamFrame = lamFrame;
+          this.staleWarningEmitted = false;
+        }
+        const { frame: emotionFrame, energy } = this.getEmotionFrame();
+        const { merged, emotionBlendshapes } = this.mergeBlendshapes(lamFrame, emotionFrame, energy);
+        const fullFrame = {
+          blendshapes: merged,
+          lamBlendshapes: lamFrame,
+          emotionBlendshapes,
+          emotion: emotionFrame,
+          timestamp: currentTime
+        };
+        this.emit("full_frame_ready", fullFrame);
+        this.emit("lam_frame_ready", lamFrame);
+        if (emotionFrame) {
+          this.emit("emotion_frame_ready", emotionFrame);
+        }
+      } else if (this.playbackStarted && !this.lastKnownLamFrame) {
+        const { frame: emotionFrame, energy } = this.getEmotionFrame();
+        if (emotionFrame && energy > 0.05) {
+          const startupFrame = new Float32Array(52);
+          const { merged, emotionBlendshapes } = this.mergeBlendshapes(startupFrame, emotionFrame, energy);
+          this.emit("full_frame_ready", {
+            blendshapes: merged,
+            lamBlendshapes: startupFrame,
+            emotionBlendshapes,
+            emotion: emotionFrame,
+            timestamp: currentTime
+          });
         }
-      });
-    });
+      }
+      if (this.playbackStarted && this.lastNewFrameTime > 0 && !this.staleWarningEmitted && performance.now() - this.lastNewFrameTime > _FullFacePipeline.STALE_FRAME_THRESHOLD_MS) {
+        this.staleWarningEmitted = true;
+        logger3.warn("LAM appears stalled \u2014 no new frames for 3+ seconds during playback", {
+          staleDurationMs: Math.round(performance.now() - this.lastNewFrameTime),
+          queuedFrames: this.lamPipeline.queuedFrameCount
+        });
+      }
+      this.frameAnimationId = requestAnimationFrame(updateFrame);
+    };
+    this.frameAnimationId = requestAnimationFrame(updateFrame);
   }
   /**
-   * Get blendshape value by name for a specific frame
+   * End of audio stream
    */
-  getBlendshape(blendshapes, name) {
-    const index = LAM_BLENDSHAPES.indexOf(name);
-    if (index === -1) {
-      throw new Error(`Unknown blendshape: ${name}`);
+  async end() {
+    const remaining = this.coalescer.flush();
+    if (remaining) {
+      const chunk = new Uint8Array(remaining);
+      await this.onAudioChunk(chunk);
     }
-    return blendshapes[index];
+    await this.lamPipeline.flush(this.options.lam);
   }
   /**
-   * Dispose of the model and free resources
+   * Stop playback immediately with smooth fade-out
    */
-  async dispose() {
-    if (this.session) {
-      await this.session.release();
-      this.session = null;
+  async stop(fadeOutMs = 50) {
+    this.stopMonitoring();
+    await this.scheduler.cancelAll(fadeOutMs);
+    this.coalescer.reset();
+    this.lamPipeline.reset();
+    this.playbackStarted = false;
+    this.lastEmotionFrame = null;
+    this.currentAudioEnergy = 0;
+    this.emotionMapper.reset();
+    this.energyAnalyzer.reset();
+    this.lastNewFrameTime = 0;
+    this.lastKnownLamFrame = null;
+    this.staleWarningEmitted = false;
+    this.emit("playback_complete", void 0);
+  }
+  /**
+   * Start monitoring for playback completion
+   */
+  startMonitoring() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+    }
+    this.monitorInterval = setInterval(() => {
+      if (this.scheduler.isComplete() && this.lamPipeline.queuedFrameCount === 0) {
+        this.emit("playback_complete", void 0);
+        this.stopMonitoring();
+      }
+    }, 100);
+  }
+  /**
+   * Stop monitoring
+   */
+  stopMonitoring() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+      this.monitorInterval = null;
+    }
+    if (this.frameAnimationId) {
+      cancelAnimationFrame(this.frameAnimationId);
+      this.frameAnimationId = null;
     }
   }
+  /**
+   * Get current pipeline state (for debugging/monitoring)
+   */
+  getState() {
+    return {
+      playbackStarted: this.playbackStarted,
+      coalescerFill: this.coalescer.fillLevel,
+      lamFill: this.lamPipeline.fillLevel,
+      queuedLAMFrames: this.lamPipeline.queuedFrameCount,
+      emotionLabel: this.lastEmotionFrame?.emotion ?? null,
+      currentAudioEnergy: this.currentAudioEnergy,
+      currentTime: this.scheduler.getCurrentTime(),
+      playbackEndTime: this.scheduler.getPlaybackEndTime()
+    };
+  }
+  /**
+   * Check if an explicit emotion label is currently set
+   */
+  get hasEmotionLabel() {
+    return this.lastEmotionFrame !== null;
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.stopMonitoring();
+    this.scheduler.dispose();
+    this.coalescer.reset();
+    this.lamPipeline.reset();
+    this.lastEmotionFrame = null;
+    this.currentAudioEnergy = 0;
+  }
 };
-/**
- * Check if WebGPU is available and working
- * (iOS returns false even if navigator.gpu exists due to ONNX Runtime bugs)
- */
-Wav2Vec2Inference.isWebGPUAvailable = isWebGPUAvailable;
-
-// src/audio/FullFacePipeline.ts
-var logger3 = createLogger("FullFacePipeline");
-var BLENDSHAPE_INDEX_MAP = /* @__PURE__ */ new Map();
-LAM_BLENDSHAPES.forEach((name, index) => {
-  BLENDSHAPE_INDEX_MAP.set(name, index);
-});
-var UPPER_FACE_SET = new Set(UPPER_FACE_BLENDSHAPES);
+_FullFacePipeline.STALE_FRAME_THRESHOLD_MS = 3e3;
+var FullFacePipeline = _FullFacePipeline;
 
 // src/inference/kaldiFbank.ts
 function fft(re, im) {
@@ -4153,20 +4872,21 @@ var LipSyncWithFallback = class {
     try {
       return await this.implementation.load();
     } catch (error) {
-      logger6.warn("GPU model load failed, falling back to CPU model", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      try {
-        await this.implementation.dispose();
-      } catch {
-      }
-      this.implementation = new Wav2ArkitCpuInference({
-        modelUrl: this.config.cpuModelUrl
-      });
-      this.hasFallenBack = true;
-      logger6.info("Fallback to Wav2ArkitCpuInference successful");
-      return await this.implementation.load();
+      return this.fallbackToCpu(error instanceof Error ? error.message : String(error));
+    }
+  }
+  async fallbackToCpu(reason) {
+    logger6.warn("GPU model load failed, falling back to CPU model", { reason });
+    try {
+      await this.implementation.dispose();
+    } catch {
     }
+    this.implementation = new Wav2ArkitCpuInference({
+      modelUrl: this.config.cpuModelUrl
+    });
+    this.hasFallenBack = true;
+    logger6.info("Fallback to Wav2ArkitCpuInference successful");
+    return await this.implementation.load();
   }
   async infer(audioSamples, identityIndex) {
     return this.implementation.infer(audioSamples, identityIndex);
@@ -7307,119 +8027,637 @@ var AnimationGraph = class extends EventEmitter {
   }
 };
 
-// src/animation/audioEnergy.ts
-function calculateRMS(samples) {
-  if (samples.length === 0) return 0;
-  let sumSquares = 0;
-  for (let i = 0; i < samples.length; i++) {
-    sumSquares += samples[i] * samples[i];
-  }
-  return Math.sqrt(sumSquares / samples.length);
+// src/animation/simplex2d.ts
+var perm = new Uint8Array(512);
+var grad2 = [
+  [1, 1],
+  [-1, 1],
+  [1, -1],
+  [-1, -1],
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1]
+];
+var p = [
+  151,
+  160,
+  137,
+  91,
+  90,
+  15,
+  131,
+  13,
+  201,
+  95,
+  96,
+  53,
+  194,
+  233,
+  7,
+  225,
+  140,
+  36,
+  103,
+  30,
+  69,
+  142,
+  8,
+  99,
+  37,
+  240,
+  21,
+  10,
+  23,
+  190,
+  6,
+  148,
+  247,
+  120,
+  234,
+  75,
+  0,
+  26,
+  197,
+  62,
+  94,
+  252,
+  219,
+  203,
+  117,
+  35,
+  11,
+  32,
+  57,
+  177,
+  33,
+  88,
+  237,
+  149,
+  56,
+  87,
+  174,
+  20,
+  125,
+  136,
+  171,
+  168,
+  68,
+  175,
+  74,
+  165,
+  71,
+  134,
+  139,
+  48,
+  27,
+  166,
+  77,
+  146,
+  158,
+  231,
+  83,
+  111,
+  229,
+  122,
+  60,
+  211,
+  133,
+  230,
+  220,
+  105,
+  92,
+  41,
+  55,
+  46,
+  245,
+  40,
+  244,
+  102,
+  143,
+  54,
+  65,
+  25,
+  63,
+  161,
+  1,
+  216,
+  80,
+  73,
+  209,
+  76,
+  132,
+  187,
+  208,
+  89,
+  18,
+  169,
+  200,
+  196,
+  135,
+  130,
+  116,
+  188,
+  159,
+  86,
+  164,
+  100,
+  109,
+  198,
+  173,
+  186,
+  3,
+  64,
+  52,
+  217,
+  226,
+  250,
+  124,
+  123,
+  5,
+  202,
+  38,
+  147,
+  118,
+  126,
+  255,
+  82,
+  85,
+  212,
+  207,
+  206,
+  59,
+  227,
+  47,
+  16,
+  58,
+  17,
+  182,
+  189,
+  28,
+  42,
+  223,
+  183,
+  170,
+  213,
+  119,
+  248,
+  152,
+  2,
+  44,
+  154,
+  163,
+  70,
+  221,
+  153,
+  101,
+  155,
+  167,
+  43,
+  172,
+  9,
+  129,
+  22,
+  39,
+  253,
+  19,
+  98,
+  108,
+  110,
+  79,
+  113,
+  224,
+  232,
+  178,
+  185,
+  112,
+  104,
+  218,
+  246,
+  97,
+  228,
+  251,
+  34,
+  242,
+  193,
+  238,
+  210,
+  144,
+  12,
+  191,
+  179,
+  162,
+  241,
+  81,
+  51,
+  145,
+  235,
+  249,
+  14,
+  239,
+  107,
+  49,
+  192,
+  214,
+  31,
+  181,
+  199,
+  106,
+  157,
+  184,
+  84,
+  204,
+  176,
+  115,
+  121,
+  50,
+  45,
+  127,
+  4,
+  150,
+  254,
+  138,
+  236,
+  205,
+  93,
+  222,
+  114,
+  67,
+  29,
+  24,
+  72,
+  243,
+  141,
+  128,
+  195,
+  78,
+  66,
+  215,
+  61,
+  156,
+  180
+];
+for (let i = 0; i < 256; i++) {
+  perm[i] = p[i];
+  perm[i + 256] = p[i];
 }
-function calculatePeak(samples) {
-  let peak = 0;
-  for (let i = 0; i < samples.length; i++) {
-    const abs = Math.abs(samples[i]);
-    if (abs > peak) peak = abs;
-  }
-  return peak;
+var F2 = 0.5 * (Math.sqrt(3) - 1);
+var G2 = (3 - Math.sqrt(3)) / 6;
+function dot2(g, x, y) {
+  return g[0] * x + g[1] * y;
 }
-var AudioEnergyAnalyzer = class {
-  /**
-   * @param smoothingFactor How much to smooth (0 = no smoothing, 1 = infinite smoothing). Default 0.85
-   * @param noiseFloor Minimum energy threshold to consider as signal. Default 0.01
-   */
-  constructor(smoothingFactor = 0.85, noiseFloor = 0.01) {
-    this.smoothedRMS = 0;
-    this.smoothedPeak = 0;
-    this.smoothingFactor = Math.max(0, Math.min(0.99, smoothingFactor));
-    this.noiseFloor = noiseFloor;
-  }
-  /**
-   * Process audio samples and return smoothed energy values
-   * @param samples Audio samples (Float32Array)
-   * @returns Object with rms and peak values
-   */
-  process(samples) {
-    const instantRMS = calculateRMS(samples);
-    const instantPeak = calculatePeak(samples);
-    const gatedRMS = instantRMS > this.noiseFloor ? instantRMS : 0;
-    const gatedPeak = instantPeak > this.noiseFloor ? instantPeak : 0;
-    if (gatedRMS > this.smoothedRMS) {
-      this.smoothedRMS = this.smoothedRMS * 0.5 + gatedRMS * 0.5;
-    } else {
-      this.smoothedRMS = this.smoothedRMS * this.smoothingFactor + gatedRMS * (1 - this.smoothingFactor);
-    }
-    if (gatedPeak > this.smoothedPeak) {
-      this.smoothedPeak = this.smoothedPeak * 0.3 + gatedPeak * 0.7;
-    } else {
-      this.smoothedPeak = this.smoothedPeak * this.smoothingFactor + gatedPeak * (1 - this.smoothingFactor);
-    }
-    const energy = this.smoothedRMS * 0.7 + this.smoothedPeak * 0.3;
+function simplex2d(x, y) {
+  const s = (x + y) * F2;
+  const i = Math.floor(x + s);
+  const j = Math.floor(y + s);
+  const t = (i + j) * G2;
+  const X0 = i - t;
+  const Y0 = j - t;
+  const x0 = x - X0;
+  const y0 = y - Y0;
+  const i1 = x0 > y0 ? 1 : 0;
+  const j1 = x0 > y0 ? 0 : 1;
+  const x1 = x0 - i1 + G2;
+  const y1 = y0 - j1 + G2;
+  const x2 = x0 - 1 + 2 * G2;
+  const y2 = y0 - 1 + 2 * G2;
+  const ii = i & 255;
+  const jj = j & 255;
+  const gi0 = perm[ii + perm[jj]] % 8;
+  const gi1 = perm[ii + i1 + perm[jj + j1]] % 8;
+  const gi2 = perm[ii + 1 + perm[jj + 1]] % 8;
+  let n0 = 0;
+  let t0 = 0.5 - x0 * x0 - y0 * y0;
+  if (t0 >= 0) {
+    t0 *= t0;
+    n0 = t0 * t0 * dot2(grad2[gi0], x0, y0);
+  }
+  let n1 = 0;
+  let t1 = 0.5 - x1 * x1 - y1 * y1;
+  if (t1 >= 0) {
+    t1 *= t1;
+    n1 = t1 * t1 * dot2(grad2[gi1], x1, y1);
+  }
+  let n2 = 0;
+  let t2 = 0.5 - x2 * x2 - y2 * y2;
+  if (t2 >= 0) {
+    t2 *= t2;
+    n2 = t2 * t2 * dot2(grad2[gi2], x2, y2);
+  }
+  return 70 * (n0 + n1 + n2);
+}
+
+// src/animation/ProceduralLifeLayer.ts
+var PHASE_OPEN = 0;
+var PHASE_CLOSING = 1;
+var PHASE_CLOSED = 2;
+var PHASE_OPENING = 3;
+var BLINK_CLOSE_DURATION = 0.06;
+var BLINK_HOLD_DURATION = 0.04;
+var BLINK_OPEN_DURATION = 0.15;
+var BLINK_ASYMMETRY_DELAY = 8e-3;
+var GAZE_BREAK_DURATION = 0.12;
+var GAZE_BREAK_HOLD_DURATION = 0.3;
+var GAZE_BREAK_RETURN_DURATION = 0.15;
+var EYE_NOISE_X_FREQ = 0.8;
+var EYE_NOISE_Y_FREQ = 0.6;
+var EYE_NOISE_X_PHASE = 73.1;
+var EYE_NOISE_Y_PHASE = 91.7;
+var BROW_INNER_UP_FREQ = 0.4;
+var BROW_OUTER_LEFT_FREQ = 0.35;
+var BROW_OUTER_RIGHT_FREQ = 0.38;
+var BROW_DOWN_FREQ = 0.3;
+var BROW_INNER_UP_PHASE = 0;
+var BROW_OUTER_LEFT_PHASE = 17.3;
+var BROW_OUTER_RIGHT_PHASE = 31.7;
+var BROW_DOWN_LEFT_PHASE = 47.1;
+var BROW_DOWN_RIGHT_PHASE = 59.3;
+var EMPHASIS_ENERGY_THRESHOLD = 0.3;
+var EMPHASIS_DECAY_RATE = 4;
+function clamp(v, min, max) {
+  return v < min ? min : v > max ? max : v;
+}
+function randomRange(min, max) {
+  return min + Math.random() * (max - min);
+}
+function smoothStep(t) {
+  return t * t * (3 - 2 * t);
+}
+function softClamp(v, max) {
+  return Math.tanh(v / max) * max;
+}
+var ProceduralLifeLayer = class {
+  constructor(config) {
+    // Blink state
+    this.blinkTimer = 0;
+    this.blinkPhase = PHASE_OPEN;
+    this.blinkProgress = 0;
+    this.asymmetryRight = 0.97;
+    this.smoothedBlinkLeft = 0;
+    this.smoothedBlinkRight = 0;
+    // Eye contact (smoothed)
+    this.smoothedEyeX = 0;
+    this.smoothedEyeY = 0;
+    // Eye micro-motion (continuous simplex noise, no discrete events)
+    this.eyeNoiseTime = 0;
+    // Gaze break state
+    this.gazeBreakTimer = 0;
+    this.gazeBreakPhase = PHASE_OPEN;
+    this.gazeBreakProgress = 0;
+    this.gazeBreakTargetX = 0;
+    this.gazeBreakTargetY = 0;
+    this.gazeBreakCurrentX = 0;
+    this.gazeBreakCurrentY = 0;
+    // Breathing / postural sway
+    this.microMotionTime = 0;
+    this.breathingPhase = 0;
+    // Brow noise
+    this.noiseTime = 0;
+    this.previousEnergy = 0;
+    this.emphasisLevel = 0;
+    this.blinkIntervalRange = config?.blinkIntervalRange ?? [2.5, 6];
+    this.gazeBreakIntervalRange = config?.gazeBreakIntervalRange ?? [3, 8];
+    this.gazeBreakAmplitudeRange = config?.gazeBreakAmplitudeRange ?? [0.15, 0.4];
+    this.eyeNoiseAmplitude = config?.eyeNoiseAmplitude ?? 0.06;
+    this.browNoiseAmplitude = config?.browNoiseAmplitude ?? 0.3;
+    this.browNoiseSpeechMultiplier = config?.browNoiseSpeechMultiplier ?? 2;
+    this.breathingRate = config?.breathingRate ?? 0.25;
+    this.posturalSwayAmplitude = config?.posturalSwayAmplitude ?? 2e-3;
+    this.eyeMaxDeviation = config?.eyeMaxDeviation ?? 0.8;
+    this.eyeSmoothing = config?.eyeSmoothing ?? 15;
+    this.blinkInterval = randomRange(...this.blinkIntervalRange);
+    this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
+  }
+  /**
+   * 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, input) {
+    const eyeTargetX = input?.eyeTargetX ?? 0;
+    const eyeTargetY = input?.eyeTargetY ?? 0;
+    const audioEnergy = input?.audioEnergy ?? 0;
+    const isSpeaking = input?.isSpeaking ?? false;
+    const safeDelta = Math.min(delta, 0.1);
+    const blendshapes = {};
+    this.updateBlinks(delta);
+    const blinkSmoothing = 45;
+    const blinkValues = this.getBlinkValues();
+    this.smoothedBlinkLeft += (blinkValues.left - this.smoothedBlinkLeft) * Math.min(1, safeDelta * blinkSmoothing);
+    this.smoothedBlinkRight += (blinkValues.right - this.smoothedBlinkRight) * Math.min(1, safeDelta * blinkSmoothing);
+    blendshapes["eyeBlinkLeft"] = this.smoothedBlinkLeft;
+    blendshapes["eyeBlinkRight"] = this.smoothedBlinkRight;
+    this.smoothedEyeX += (eyeTargetX - this.smoothedEyeX) * Math.min(1, safeDelta * this.eyeSmoothing);
+    this.smoothedEyeY += (eyeTargetY - this.smoothedEyeY) * Math.min(1, safeDelta * this.eyeSmoothing);
+    this.eyeNoiseTime += delta;
+    const microMotion = this.getEyeMicroMotion();
+    this.updateGazeBreaks(delta);
+    const finalEyeX = this.smoothedEyeX + this.gazeBreakCurrentX + microMotion.x;
+    const finalEyeY = this.smoothedEyeY + this.gazeBreakCurrentY + microMotion.y;
+    const clampedX = softClamp(finalEyeX, this.eyeMaxDeviation);
+    const clampedY = softClamp(finalEyeY, this.eyeMaxDeviation);
+    const deadZone = 0.02;
+    const lookRight = clampedX > deadZone ? clampedX : clampedX > 0 ? clampedX * (clampedX / deadZone) : 0;
+    const lookLeft = clampedX < -deadZone ? -clampedX : clampedX < 0 ? -clampedX * (-clampedX / deadZone) : 0;
+    const lookUp = clampedY > deadZone ? clampedY : clampedY > 0 ? clampedY * (clampedY / deadZone) : 0;
+    const lookDown = clampedY < -deadZone ? -clampedY : clampedY < 0 ? -clampedY * (-clampedY / deadZone) : 0;
+    blendshapes["eyeLookInLeft"] = lookRight;
+    blendshapes["eyeLookOutLeft"] = lookLeft;
+    blendshapes["eyeLookInRight"] = lookLeft;
+    blendshapes["eyeLookOutRight"] = lookRight;
+    blendshapes["eyeLookUpLeft"] = lookUp;
+    blendshapes["eyeLookUpRight"] = lookUp;
+    blendshapes["eyeLookDownLeft"] = lookDown;
+    blendshapes["eyeLookDownRight"] = lookDown;
+    this.updateBrowNoise(delta, audioEnergy, isSpeaking, blendshapes);
+    this.microMotionTime += delta;
+    this.breathingPhase += delta * this.breathingRate * Math.PI * 2;
+    const breathingY = Math.sin(this.breathingPhase) * 3e-3;
+    const swayAmp = this.posturalSwayAmplitude;
+    const swayX = Math.sin(this.microMotionTime * 0.7) * swayAmp + Math.sin(this.microMotionTime * 1.3) * swayAmp * 0.5;
+    const swayY = Math.sin(this.microMotionTime * 0.5) * swayAmp * 0.75 + Math.sin(this.microMotionTime * 0.9) * swayAmp * 0.5;
     return {
-      rms: this.smoothedRMS,
-      peak: this.smoothedPeak,
-      energy: Math.min(1, energy * 2)
-      // Scale up and clamp
+      blendshapes,
+      headDelta: {
+        yaw: swayX,
+        pitch: breathingY + swayY
+      }
     };
   }
   /**
-   * Reset analyzer state
+   * Reset all internal state to initial values.
    */
   reset() {
-    this.smoothedRMS = 0;
-    this.smoothedPeak = 0;
-  }
-  /**
-   * Get current smoothed RMS value
-   */
-  get rms() {
-    return this.smoothedRMS;
-  }
-  /**
-   * Get current smoothed peak value
-   */
-  get peak() {
-    return this.smoothedPeak;
-  }
-};
-var EmphasisDetector = class {
-  /**
-   * @param historySize Number of frames to track. Default 10
-   * @param emphasisThreshold Minimum energy increase to count as emphasis. Default 0.15
-   */
-  constructor(historySize = 10, emphasisThreshold = 0.15) {
-    this.energyHistory = [];
-    this.historySize = historySize;
-    this.emphasisThreshold = emphasisThreshold;
+    this.blinkTimer = 0;
+    this.blinkInterval = randomRange(...this.blinkIntervalRange);
+    this.blinkPhase = PHASE_OPEN;
+    this.blinkProgress = 0;
+    this.asymmetryRight = 0.97;
+    this.smoothedBlinkLeft = 0;
+    this.smoothedBlinkRight = 0;
+    this.smoothedEyeX = 0;
+    this.smoothedEyeY = 0;
+    this.eyeNoiseTime = 0;
+    this.gazeBreakTimer = 0;
+    this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
+    this.gazeBreakPhase = PHASE_OPEN;
+    this.gazeBreakProgress = 0;
+    this.gazeBreakTargetX = 0;
+    this.gazeBreakTargetY = 0;
+    this.gazeBreakCurrentX = 0;
+    this.gazeBreakCurrentY = 0;
+    this.microMotionTime = 0;
+    this.breathingPhase = 0;
+    this.noiseTime = 0;
+    this.previousEnergy = 0;
+    this.emphasisLevel = 0;
+  }
+  // =====================================================================
+  // PRIVATE: Blink system
+  // =====================================================================
+  updateBlinks(delta) {
+    this.blinkTimer += delta;
+    if (this.blinkTimer >= this.blinkInterval && this.blinkPhase === PHASE_OPEN) {
+      this.blinkPhase = PHASE_CLOSING;
+      this.blinkProgress = 0;
+      this.blinkTimer = 0;
+      this.blinkInterval = randomRange(...this.blinkIntervalRange);
+      this.asymmetryRight = 0.95 + Math.random() * 0.08;
+    }
+    if (this.blinkPhase > PHASE_OPEN) {
+      this.blinkProgress += delta;
+      if (this.blinkPhase === PHASE_CLOSING) {
+        if (this.blinkProgress >= BLINK_CLOSE_DURATION) {
+          this.blinkPhase = PHASE_CLOSED;
+          this.blinkProgress = 0;
+        }
+      } else if (this.blinkPhase === PHASE_CLOSED) {
+        if (this.blinkProgress >= BLINK_HOLD_DURATION) {
+          this.blinkPhase = PHASE_OPENING;
+          this.blinkProgress = 0;
+        }
+      } else if (this.blinkPhase === PHASE_OPENING) {
+        if (this.blinkProgress >= BLINK_OPEN_DURATION) {
+          this.blinkPhase = PHASE_OPEN;
+          this.blinkProgress = 0;
+        }
+      }
+    }
   }
-  /**
-   * Process energy value and detect emphasis
-   * @param energy Current energy value (0-1)
-   * @returns Object with isEmphasis flag and emphasisStrength
-   */
-  process(energy) {
-    this.energyHistory.push(energy);
-    if (this.energyHistory.length > this.historySize) {
-      this.energyHistory.shift();
+  getBlinkValues() {
+    if (this.blinkPhase === PHASE_OPEN) {
+      return { left: 0, right: 0 };
     }
-    if (this.energyHistory.length < 3) {
-      return { isEmphasis: false, emphasisStrength: 0 };
+    if (this.blinkPhase === PHASE_CLOSING) {
+      const t2 = Math.min(1, this.blinkProgress / BLINK_CLOSE_DURATION);
+      const eased2 = t2 * t2 * t2;
+      const tRight = Math.max(0, Math.min(1, (this.blinkProgress - BLINK_ASYMMETRY_DELAY) / BLINK_CLOSE_DURATION));
+      return {
+        left: eased2,
+        right: tRight * tRight * tRight * this.asymmetryRight
+      };
     }
-    const prevFrames = this.energyHistory.slice(0, -1);
-    const avgPrev = prevFrames.reduce((a, b) => a + b, 0) / prevFrames.length;
-    const increase = energy - avgPrev;
-    const isEmphasis = increase > this.emphasisThreshold;
+    if (this.blinkPhase === PHASE_CLOSED) {
+      return { left: 1, right: this.asymmetryRight };
+    }
+    const t = Math.min(1, this.blinkProgress / BLINK_OPEN_DURATION);
+    const eased = smoothStep(t);
     return {
-      isEmphasis,
-      emphasisStrength: isEmphasis ? Math.min(1, increase / 0.3) : 0
+      left: 1 - eased,
+      right: (1 - eased) * this.asymmetryRight
     };
   }
-  /**
-   * Reset detector state
-   */
-  reset() {
-    this.energyHistory = [];
+  // =====================================================================
+  // PRIVATE: Eye micro-motion (continuous simplex noise)
+  // =====================================================================
+  getEyeMicroMotion() {
+    const amp = this.eyeNoiseAmplitude;
+    const x = simplex2d(this.eyeNoiseTime * EYE_NOISE_X_FREQ, EYE_NOISE_X_PHASE) * amp;
+    const y = simplex2d(this.eyeNoiseTime * EYE_NOISE_Y_FREQ, EYE_NOISE_Y_PHASE) * amp * 0.7;
+    return { x, y };
+  }
+  // =====================================================================
+  // PRIVATE: Gaze breaks
+  // =====================================================================
+  updateGazeBreaks(delta) {
+    this.gazeBreakTimer += delta;
+    if (this.gazeBreakTimer >= this.gazeBreakInterval && this.gazeBreakPhase === PHASE_OPEN) {
+      this.gazeBreakPhase = PHASE_CLOSING;
+      this.gazeBreakProgress = 0;
+      this.gazeBreakTimer = 0;
+      const amp = randomRange(...this.gazeBreakAmplitudeRange);
+      this.gazeBreakTargetX = (Math.random() - 0.5) * 2 * amp;
+      this.gazeBreakTargetY = (Math.random() - 0.5) * amp * 0.4;
+      this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
+    }
+    if (this.gazeBreakPhase > PHASE_OPEN) {
+      this.gazeBreakProgress += delta;
+      if (this.gazeBreakPhase === 1) {
+        const t = Math.min(1, this.gazeBreakProgress / GAZE_BREAK_DURATION);
+        const eased = smoothStep(t);
+        this.gazeBreakCurrentX = this.gazeBreakTargetX * eased;
+        this.gazeBreakCurrentY = this.gazeBreakTargetY * eased;
+        if (this.gazeBreakProgress >= GAZE_BREAK_DURATION) {
+          this.gazeBreakPhase = 2;
+          this.gazeBreakProgress = 0;
+        }
+      } else if (this.gazeBreakPhase === 2) {
+        this.gazeBreakCurrentX = this.gazeBreakTargetX;
+        this.gazeBreakCurrentY = this.gazeBreakTargetY;
+        if (this.gazeBreakProgress >= GAZE_BREAK_HOLD_DURATION) {
+          this.gazeBreakPhase = 3;
+          this.gazeBreakProgress = 0;
+        }
+      } else if (this.gazeBreakPhase === 3) {
+        const t = Math.min(1, this.gazeBreakProgress / GAZE_BREAK_RETURN_DURATION);
+        const eased = smoothStep(t);
+        this.gazeBreakCurrentX = this.gazeBreakTargetX * (1 - eased);
+        this.gazeBreakCurrentY = this.gazeBreakTargetY * (1 - eased);
+        if (this.gazeBreakProgress >= GAZE_BREAK_RETURN_DURATION) {
+          this.gazeBreakPhase = PHASE_OPEN;
+          this.gazeBreakProgress = 0;
+          this.gazeBreakCurrentX = 0;
+          this.gazeBreakCurrentY = 0;
+        }
+      }
+    } else {
+      this.gazeBreakCurrentX = 0;
+      this.gazeBreakCurrentY = 0;
+    }
+  }
+  // =====================================================================
+  // PRIVATE: Brow noise (simplex-driven organic drift)
+  // =====================================================================
+  updateBrowNoise(delta, audioEnergy, isSpeaking, blendshapes) {
+    this.noiseTime += delta;
+    const energyDelta = audioEnergy - this.previousEnergy;
+    if (energyDelta > EMPHASIS_ENERGY_THRESHOLD) {
+      this.emphasisLevel = 1;
+    }
+    this.emphasisLevel = Math.max(0, this.emphasisLevel - delta * EMPHASIS_DECAY_RATE);
+    this.previousEnergy = audioEnergy;
+    const speechMul = isSpeaking && audioEnergy > 0 ? this.browNoiseSpeechMultiplier : 1;
+    const amp = this.browNoiseAmplitude * speechMul;
+    const innerUpNoise = simplex2d(this.noiseTime * BROW_INNER_UP_FREQ, BROW_INNER_UP_PHASE);
+    const innerUpBase = (innerUpNoise * 0.5 + 0.5) * amp * 0.83;
+    const innerUpEmphasis = this.emphasisLevel * 0.25;
+    blendshapes["browInnerUp"] = clamp(innerUpBase + innerUpEmphasis, 0, 1);
+    const outerLeftNoise = simplex2d(this.noiseTime * BROW_OUTER_LEFT_FREQ, BROW_OUTER_LEFT_PHASE);
+    blendshapes["browOuterUpLeft"] = clamp((outerLeftNoise * 0.5 + 0.5) * amp * 0.5, 0, 1);
+    const outerRightNoise = simplex2d(this.noiseTime * BROW_OUTER_RIGHT_FREQ, BROW_OUTER_RIGHT_PHASE);
+    blendshapes["browOuterUpRight"] = clamp((outerRightNoise * 0.5 + 0.5) * amp * 0.5, 0, 1);
+    const downLeftNoise = simplex2d(this.noiseTime * BROW_DOWN_FREQ, BROW_DOWN_LEFT_PHASE);
+    blendshapes["browDownLeft"] = clamp((downLeftNoise * 0.5 + 0.5) * amp * 0.33, 0, 1);
+    const downRightNoise = simplex2d(this.noiseTime * BROW_DOWN_FREQ, BROW_DOWN_RIGHT_PHASE);
+    blendshapes["browDownRight"] = clamp((downRightNoise * 0.5 + 0.5) * amp * 0.33, 0, 1);
   }
 };
+
+// ../types/dist/index.mjs
+var PROTOCOL_VERSION = 1;
+function isProtocolEvent(obj) {
+  return typeof obj === "object" && obj !== null && "v" in obj && "type" in obj && "ts" in obj;
+}
 //# sourceMappingURL=index.js.map