@omote/core 0.4.7 → 0.5.2

package/dist/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  A2EOrchestrator: () => A2EOrchestrator,
+  A2EProcessor: () => A2EProcessor,
   ARKIT_BLENDSHAPES: () => ARKIT_BLENDSHAPES,
   AgentCoreAdapter: () => AgentCoreAdapter,
   AnimationGraph: () => AnimationGraph,
@@ -37,23 +39,22 @@ __export(index_exports, {
   AudioEnergyAnalyzer: () => AudioEnergyAnalyzer,
   AudioScheduler: () => AudioScheduler,
   AudioSyncManager: () => AudioSyncManager,
+  BLENDSHAPE_TO_GROUP: () => BLENDSHAPE_TO_GROUP,
+  BlendshapeSmoother: () => BlendshapeSmoother,
   CTC_VOCAB: () => CTC_VOCAB,
   ConsoleExporter: () => ConsoleExporter,
   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,
   LAM_BLENDSHAPES: () => LAM_BLENDSHAPES,
   LOG_LEVEL_PRIORITY: () => LOG_LEVEL_PRIORITY,
   MODEL_LOAD_TIME_BUCKETS: () => MODEL_LOAD_TIME_BUCKETS,
@@ -72,74 +73,55 @@ __export(index_exports, {
   SileroVADInference: () => SileroVADInference,
   SileroVADUnifiedAdapter: () => SileroVADUnifiedAdapter,
   SileroVADWorker: () => SileroVADWorker,
-  SyncedAudioPipeline: () => SyncedAudioPipeline,
   TenantManager: () => TenantManager,
-  UPPER_FACE_BLENDSHAPES: () => UPPER_FACE_BLENDSHAPES,
   UnifiedInferenceWorker: () => UnifiedInferenceWorker,
-  WAV2ARKIT_BLENDSHAPES: () => WAV2ARKIT_BLENDSHAPES,
   Wav2ArkitCpuInference: () => Wav2ArkitCpuInference,
   Wav2ArkitCpuUnifiedAdapter: () => Wav2ArkitCpuUnifiedAdapter,
   Wav2ArkitCpuWorker: () => Wav2ArkitCpuWorker,
   Wav2Vec2Inference: () => Wav2Vec2Inference,
-  applyCMVN: () => applyCMVN,
-  applyLFR: () => applyLFR,
   blendEmotions: () => blendEmotions,
   calculatePeak: () => calculatePeak,
   calculateRMS: () => calculateRMS,
-  computeKaldiFbank: () => computeKaldiFbank,
   configureCacheLimit: () => configureCacheLimit,
   configureLogging: () => configureLogging,
   configureTelemetry: () => configureTelemetry,
+  createA2E: () => createA2E,
   createEmotionVector: () => createEmotionVector,
-  createLipSync: () => createLipSync,
   createLogger: () => createLogger,
   createSenseVoice: () => createSenseVoice,
-  createSessionWithFallback: () => createSessionWithFallback,
   createSileroVAD: () => createSileroVAD,
-  ctcGreedyDecode: () => ctcGreedyDecode,
   fetchWithCache: () => fetchWithCache,
   formatBytes: () => formatBytes,
   getCacheConfig: () => getCacheConfig,
   getCacheKey: () => getCacheKey,
   getEmotionPreset: () => getEmotionPreset,
-  getLoadedBackend: () => getLoadedBackend,
   getLoggingConfig: () => getLoggingConfig,
   getModelCache: () => getModelCache,
-  getOnnxRuntime: () => getOnnxRuntime,
-  getOnnxRuntimeForPreference: () => getOnnxRuntimeForPreference,
   getOptimalWasmThreads: () => getOptimalWasmThreads,
   getRecommendedBackend: () => getRecommendedBackend,
-  getSessionOptions: () => getSessionOptions,
   getTelemetry: () => getTelemetry,
   hasWebGPUApi: () => hasWebGPUApi,
   isAndroid: () => isAndroid,
   isIOS: () => isIOS,
   isIOSSafari: () => isIOSSafari,
   isMobile: () => isMobile,
-  isOnnxRuntimeLoaded: () => isOnnxRuntimeLoaded,
   isProtocolEvent: () => isProtocolEvent,
   isSafari: () => isSafari,
   isSpeechRecognitionAvailable: () => isSpeechRecognitionAvailable,
   isWebGPUAvailable: () => isWebGPUAvailable,
+  lerpBlendshapes: () => lerpBlendshapes,
   lerpEmotion: () => lerpEmotion,
   noopLogger: () => noopLogger,
-  parseCMVNFromMetadata: () => parseCMVNFromMetadata,
-  parseTokensFile: () => parseTokensFile,
   preloadModels: () => preloadModels,
-  preloadOnnxRuntime: () => preloadOnnxRuntime,
-  remapWav2ArkitToLam: () => remapWav2ArkitToLam,
   resetLoggingConfig: () => resetLoggingConfig,
   resolveBackend: () => resolveBackend,
-  resolveLanguageId: () => resolveLanguageId,
-  resolveTextNormId: () => resolveTextNormId,
   setLogLevel: () => setLogLevel,
   setLoggingEnabled: () => setLoggingEnabled,
   shouldEnableWasmProxy: () => shouldEnableWasmProxy,
-  shouldUseCpuLipSync: () => shouldUseCpuLipSync,
+  shouldUseCpuA2E: () => shouldUseCpuA2E,
   shouldUseNativeASR: () => shouldUseNativeASR,
-  shouldUseServerLipSync: () => shouldUseServerLipSync,
-  supportsVADWorker: () => supportsVADWorker,
-  symmetrizeBlendshapes: () => symmetrizeBlendshapes
+  shouldUseServerA2E: () => shouldUseServerA2E,
+  supportsVADWorker: () => supportsVADWorker
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -649,730 +631,617 @@ var AudioChunkCoalescer = class {
   }
 };
 
-// src/audio/LAMPipeline.ts
-var LAMPipeline = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.REQUIRED_SAMPLES = 16e3;
-    // 1.0s at 16kHz (LAM requirement)
-    this.FRAME_RATE = 30;
-    // LAM outputs 30fps
-    this.buffer = new Float32Array(0);
-    this.bufferStartTime = 0;
-    this.frameQueue = [];
-    /**
-     * Last successfully retrieved frame
-     * Used as fallback when no new frame is available to prevent avatar freezing
-     */
-    this.lastFrame = null;
-  }
-  /**
-   * Push audio samples into the pipeline
-   *
-   * Accumulates samples and triggers LAM inference when buffer is full.
-   * Multiple calls may be needed to accumulate enough samples.
-   *
-   * @param samples - Float32Array of audio samples
-   * @param timestamp - AudioContext time when these samples start playing
-   * @param lam - LAM inference engine
-   */
-  async push(samples, timestamp, lam) {
-    if (this.buffer.length === 0) {
-      this.bufferStartTime = timestamp;
-    }
-    const newBuffer = new Float32Array(this.buffer.length + samples.length);
-    newBuffer.set(this.buffer, 0);
-    newBuffer.set(samples, this.buffer.length);
-    this.buffer = newBuffer;
-    while (this.buffer.length >= this.REQUIRED_SAMPLES) {
-      await this.processBuffer(lam);
-      if (this.buffer.length >= this.REQUIRED_SAMPLES) {
-        await new Promise((r) => setTimeout(r, 0));
-      }
-    }
-  }
-  /**
-   * Process accumulated buffer through LAM inference
-   */
-  async processBuffer(lam) {
-    try {
-      const toProcess = this.buffer.slice(0, this.REQUIRED_SAMPLES);
-      const processedStartTime = this.bufferStartTime;
-      this.buffer = this.buffer.slice(this.REQUIRED_SAMPLES);
-      const processedDuration = this.REQUIRED_SAMPLES / (this.options.sampleRate ?? 16e3);
-      this.bufferStartTime = processedStartTime + processedDuration;
-      const result = await lam.infer(toProcess);
-      const frameDuration = 1 / this.FRAME_RATE;
-      for (let i = 0; i < result.blendshapes.length; i++) {
-        const frame = result.blendshapes[i];
-        const timestamp = processedStartTime + i * frameDuration;
-        this.frameQueue.push({ frame, timestamp });
-      }
-      this.options.onInference?.(result.blendshapes.length);
-    } catch (error) {
-      this.options.onError?.(error);
-      this.buffer = new Float32Array(0);
-      this.bufferStartTime = 0;
-    }
-  }
-  /**
-   * Get the frame that should be displayed at the current time
-   *
-   * Automatically removes frames that have already been displayed.
-   * This prevents memory leaks from accumulating old frames.
-   *
-   * Discard Window (prevents premature frame discarding):
-   * - WebGPU: 0.5s (LAM inference 20-100ms + RAF jitter + React stalls)
-   * - WASM: 1.0s (LAM inference 50-500ms + higher variability)
-   *
-   * Last-Frame-Hold: Returns last valid frame instead of null to prevent
-   * avatar freezing when between frames (RAF at 60fps vs LAM at 30fps).
-   *
-   * @param currentTime - Current AudioContext time
-   * @param lam - LAM inference engine (optional, for backend detection)
-   * @returns Current frame, or last frame as fallback, or null if no frames yet
-   */
-  getFrameForTime(currentTime, lam) {
-    const discardWindow = lam?.backend === "wasm" ? 1 : 0.5;
-    let discardedCount = 0;
-    while (this.frameQueue.length > 0 && this.frameQueue[0].timestamp < currentTime - discardWindow) {
-      const discarded = this.frameQueue.shift();
-      discardedCount++;
-      if (discardedCount === 1) {
-        const ageMs = ((currentTime - discarded.timestamp) * 1e3).toFixed(0);
-        console.warn("[LAM] Frame(s) discarded as too old", {
-          ageMs,
-          discardWindowMs: discardWindow * 1e3,
-          queueLength: this.frameQueue.length,
-          backend: lam?.backend ?? "unknown"
-        });
-      }
-    }
-    if (this.frameQueue.length > 0 && this.frameQueue[0].timestamp <= currentTime) {
-      const { frame } = this.frameQueue.shift();
-      this.lastFrame = frame;
-      return frame;
-    }
-    return this.lastFrame;
-  }
-  /**
-   * Get all frames in the queue (for debugging/monitoring)
-   */
-  getQueuedFrames() {
-    return [...this.frameQueue];
-  }
-  /**
-   * Get current buffer fill level (0-1)
-   */
-  get fillLevel() {
-    return Math.min(1, this.buffer.length / this.REQUIRED_SAMPLES);
-  }
-  /**
-   * Get number of frames queued
-   */
-  get queuedFrameCount() {
-    return this.frameQueue.length;
-  }
-  /**
-   * Get buffered audio duration in seconds
-   */
-  get bufferedDuration() {
-    return this.buffer.length / (this.options.sampleRate ?? 16e3);
-  }
-  /**
-   * Flush remaining buffered audio
-   *
-   * Processes any remaining audio in the buffer, even if less than REQUIRED_SAMPLES.
-   * This ensures the final audio chunk generates blendshape frames.
-   *
-   * Should be called when audio stream ends to prevent losing the last 0-1 seconds.
-   *
-   * @param lam - LAM inference engine
-   */
-  async flush(lam) {
-    if (this.buffer.length === 0) {
-      return;
-    }
-    const padded = new Float32Array(this.REQUIRED_SAMPLES);
-    padded.set(this.buffer, 0);
-    const processedStartTime = this.bufferStartTime;
-    try {
-      const result = await lam.infer(padded);
-      const actualDuration = this.buffer.length / (this.options.sampleRate ?? 16e3);
-      const frameDuration = 1 / this.FRAME_RATE;
-      const actualFrameCount = Math.ceil(actualDuration * this.FRAME_RATE);
-      for (let i = 0; i < Math.min(actualFrameCount, result.blendshapes.length); i++) {
-        const frame = result.blendshapes[i];
-        const timestamp = processedStartTime + i * frameDuration;
-        this.frameQueue.push({ frame, timestamp });
-      }
-      this.buffer = new Float32Array(0);
-      this.bufferStartTime = 0;
-      this.options.onInference?.(Math.min(actualFrameCount, result.blendshapes.length));
-    } catch (error) {
-      this.options.onError?.(error);
-      this.buffer = new Float32Array(0);
-      this.bufferStartTime = 0;
-    }
-  }
-  /**
-   * Adjust all queued frame timestamps by an offset
-   *
-   * Used for synchronization when audio scheduling time differs from
-   * the estimated time used during LAM processing.
-   *
-   * @param offset - Time offset in seconds to add to all timestamps
-   */
-  adjustTimestamps(offset) {
-    for (const frame of this.frameQueue) {
-      frame.timestamp += offset;
-    }
-  }
-  /**
-   * Reset the pipeline
-   */
-  reset() {
-    this.buffer = new Float32Array(0);
-    this.bufferStartTime = 0;
-    this.frameQueue = [];
-    this.lastFrame = null;
-  }
+// src/logging/types.ts
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4,
+  verbose: 5
+};
+var DEFAULT_LOGGING_CONFIG = {
+  level: "info",
+  enabled: true,
+  format: "pretty",
+  timestamps: true,
+  includeModule: true
 };
 
-// src/audio/audioUtils.ts
-function pcm16ToFloat32(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;
-}
-function int16ToFloat32(int16) {
-  const float32 = new Float32Array(int16.length);
-  for (let i = 0; i < int16.length; i++) {
-    float32[i] = int16[i] / 32768;
-  }
-  return float32;
+// src/logging/formatters.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  magenta: "\x1B[35m"
+};
+var LEVEL_COLORS = {
+  error: COLORS.red,
+  warn: COLORS.yellow,
+  info: COLORS.blue,
+  debug: COLORS.cyan,
+  trace: COLORS.magenta,
+  verbose: COLORS.gray
+};
+var LEVEL_NAMES = {
+  error: "ERROR  ",
+  warn: "WARN   ",
+  info: "INFO   ",
+  debug: "DEBUG  ",
+  trace: "TRACE  ",
+  verbose: "VERBOSE"
+};
+var isBrowser = typeof window !== "undefined";
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return date.toISOString().substring(11, 23);
 }
-
-// src/audio/SyncedAudioPipeline.ts
-var SyncedAudioPipeline = class extends EventEmitter {
-  constructor(options) {
-    super();
-    this.options = options;
-    this.playbackStarted = false;
-    this.monitorInterval = null;
-    this.frameAnimationId = null;
-    const sampleRate = options.sampleRate ?? 16e3;
-    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) => {
-        this.emit("error", error);
+function safeStringify(data) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(data, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
       }
-    });
-  }
-  /**
-   * Initialize the pipeline
-   */
-  async initialize() {
-    await this.scheduler.initialize();
-  }
-  /**
-   * 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.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,
-   * which caused audible stuttering with continuous audio streams.
-   *
-   * @param chunk - Uint8Array containing Int16 PCM audio
-   */
-  async onAudioChunk(chunk) {
-    const combined = this.coalescer.add(chunk);
-    if (!combined) {
-      return;
+      seen.add(value);
     }
-    const float32 = pcm16ToFloat32(combined);
-    const scheduleTime = await this.scheduler.schedule(float32);
-    if (!this.playbackStarted) {
-      this.playbackStarted = true;
-      this.emit("playback_start", scheduleTime);
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      };
     }
-    this.lamPipeline.push(float32, scheduleTime, this.options.lam).catch((err) => {
-      this.emit("error", err);
-    });
-  }
-  /**
-   * End of audio stream
-   *
-   * Flushes any remaining buffered data.
-   */
-  async end() {
-    const remaining = this.coalescer.flush();
-    if (remaining) {
-      const chunk = new Uint8Array(remaining);
-      await this.onAudioChunk(chunk);
+    if (value instanceof Float32Array || value instanceof Int16Array) {
+      return `${value.constructor.name}(${value.length})`;
     }
-    await this.lamPipeline.flush(this.options.lam);
-  }
-  /**
-   * Stop playback immediately with smooth fade-out
-   *
-   * Gracefully cancels all audio playback and LAM processing:
-   * - Fades out audio over specified duration (default: 50ms)
-   * - Cancels pending LAM inferences
-   * - Clears all buffers and queues
-   * - Emits 'playback_complete' event
-   *
-   * Use this for interruptions (e.g., user barge-in during AI speech).
-   *
-   * @param fadeOutMs - Fade-out duration in milliseconds (default: 50ms)
-   * @returns Promise that resolves when fade-out completes
-   */
-  async stop(fadeOutMs = 50) {
-    this.stopMonitoring();
-    await this.scheduler.cancelAll(fadeOutMs);
-    this.coalescer.reset();
-    this.lamPipeline.reset();
-    this.playbackStarted = false;
-    this.emit("playback_complete", void 0);
+    if (ArrayBuffer.isView(value)) {
+      return `${value.constructor.name}(${value.byteLength})`;
+    }
+    return value;
+  });
+}
+var jsonFormatter = (entry) => {
+  const output = {
+    timestamp: entry.timestamp,
+    level: entry.level,
+    module: entry.module,
+    message: entry.message
+  };
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output.data = entry.data;
   }
-  /**
-   * Start frame animation loop
-   *
-   * Uses requestAnimationFrame to check for new LAM frames.
-   * Synchronized to AudioContext clock (not visual refresh rate).
-   *
-   * Frame Emission Strategy:
-   * - LAMPipeline uses last-frame-hold to prevent null returns
-   * - Always emit frames (even repeated frames) to maintain smooth animation
-   * - Renderer is responsible for detecting duplicate frames if needed
-   */
-  startFrameLoop() {
-    const updateFrame = () => {
-      const currentTime = this.scheduler.getCurrentTime();
-      const frame = this.lamPipeline.getFrameForTime(currentTime, this.options.lam);
-      if (frame) {
-        this.emit("frame_ready", frame);
-      }
-      this.frameAnimationId = requestAnimationFrame(updateFrame);
+  if (entry.error) {
+    output.error = {
+      name: entry.error.name,
+      message: entry.error.message,
+      stack: entry.error.stack
     };
-    this.frameAnimationId = requestAnimationFrame(updateFrame);
   }
-  /**
-   * Start monitoring for playback completion
-   */
-  startMonitoring() {
-    if (this.monitorInterval) {
-      clearInterval(this.monitorInterval);
-    }
-    this.monitorInterval = window.setInterval(() => {
-      if (this.scheduler.isComplete() && this.lamPipeline.queuedFrameCount === 0) {
-        this.emit("playback_complete", void 0);
-        this.stopMonitoring();
-      }
-    }, 100);
+  return safeStringify(output);
+};
+var prettyFormatter = (entry) => {
+  const time = formatTimestamp(entry.timestamp);
+  const level = LEVEL_NAMES[entry.level];
+  const module2 = entry.module;
+  const message = entry.message;
+  let output;
+  if (isBrowser) {
+    output = `${time} ${level} [${module2}] ${message}`;
+  } else {
+    const color = LEVEL_COLORS[entry.level];
+    output = `${COLORS.gray}${time}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${module2}]${COLORS.reset} ${message}`;
   }
-  /**
-   * Stop monitoring
-   */
-  stopMonitoring() {
-    if (this.monitorInterval) {
-      clearInterval(this.monitorInterval);
-      this.monitorInterval = null;
-    }
-    if (this.frameAnimationId) {
-      cancelAnimationFrame(this.frameAnimationId);
-      this.frameAnimationId = null;
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    const dataStr = safeStringify(entry.data);
+    if (dataStr.length > 80) {
+      output += "\n  " + JSON.stringify(entry.data, null, 2).replace(/\n/g, "\n  ");
+    } else {
+      output += " " + dataStr;
     }
   }
-  /**
-   * Get current pipeline state (for debugging/monitoring)
-   */
-  getState() {
-    return {
-      playbackStarted: this.playbackStarted,
-      coalescerFill: this.coalescer.fillLevel,
-      lamFill: this.lamPipeline.fillLevel,
-      queuedFrames: this.lamPipeline.queuedFrameCount,
-      currentTime: this.scheduler.getCurrentTime(),
-      playbackEndTime: this.scheduler.getPlaybackEndTime()
-    };
-  }
-  /**
-   * Cleanup resources
-   */
-  dispose() {
-    this.stopMonitoring();
-    this.scheduler.dispose();
-    this.coalescer.reset();
-    this.lamPipeline.reset();
+  if (entry.error) {
+    output += `
+  ${entry.error.name}: ${entry.error.message}`;
+    if (entry.error.stack) {
+      const stackLines = entry.error.stack.split("\n").slice(1, 4);
+      output += "\n  " + stackLines.join("\n  ");
+    }
   }
+  return output;
 };
-
-// src/animation/EmotionToBlendshapeMapper.ts
-var UPPER_FACE_BLENDSHAPES = [
-  // Brows (5)
-  "browDownLeft",
-  "browDownRight",
-  "browInnerUp",
-  "browOuterUpLeft",
-  "browOuterUpRight",
-  // Eyes (4)
-  "eyeSquintLeft",
-  "eyeSquintRight",
-  "eyeWideLeft",
-  "eyeWideRight",
-  // Cheeks (2)
-  "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;
+function getFormatter(format) {
+  return format === "json" ? jsonFormatter : prettyFormatter;
+}
+function createBrowserConsoleArgs(entry) {
+  const time = formatTimestamp(entry.timestamp);
+  const level = entry.level.toUpperCase().padEnd(7);
+  const module2 = entry.module;
+  const message = entry.message;
+  const styles = {
+    time: "color: gray;",
+    error: "color: red; font-weight: bold;",
+    warn: "color: orange; font-weight: bold;",
+    info: "color: blue;",
+    debug: "color: cyan;",
+    trace: "color: magenta;",
+    verbose: "color: gray;",
+    module: "color: teal; font-weight: bold;",
+    message: "color: inherit;"
+  };
+  let formatStr = "%c%s %c%s %c[%s]%c %s";
+  const args = [
+    styles.time,
+    time,
+    styles[entry.level],
+    level,
+    styles.module,
+    module2,
+    styles.message,
+    message
+  ];
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    formatStr += " %o";
+    args.push(entry.data);
   }
-  return result;
+  return [formatStr, ...args];
 }
-function clamp01(value) {
-  return Math.max(0, Math.min(1, value));
+
+// src/logging/Logger.ts
+var isBrowser2 = typeof window !== "undefined";
+var globalConfig = { ...DEFAULT_LOGGING_CONFIG };
+function configureLogging(config) {
+  globalConfig = { ...globalConfig, ...config };
 }
-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();
+function getLoggingConfig() {
+  return { ...globalConfig };
+}
+function resetLoggingConfig() {
+  globalConfig = { ...DEFAULT_LOGGING_CONFIG };
+}
+function setLogLevel(level) {
+  globalConfig.level = level;
+}
+function setLoggingEnabled(enabled) {
+  globalConfig.enabled = enabled;
+}
+var consoleSink = (entry) => {
+  const consoleMethod = entry.level === "error" ? "error" : entry.level === "warn" ? "warn" : "log";
+  if (globalConfig.format === "pretty" && isBrowser2) {
+    const args = createBrowserConsoleArgs(entry);
+    console[consoleMethod](...args);
+  } else {
+    const formatter = getFormatter(globalConfig.format);
+    const formatted = formatter(entry);
+    console[consoleMethod](formatted);
   }
-  /**
-   * 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 };
+};
+function getActiveSink() {
+  return globalConfig.sink || consoleSink;
+}
+function shouldLog(level) {
+  if (!globalConfig.enabled) return false;
+  return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level];
+}
+var Logger = class _Logger {
+  constructor(module2) {
+    this.module = module2;
   }
-  /**
-   * 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);
-      }
+  log(level, message, data) {
+    if (!shouldLog(level)) return;
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      module: this.module,
+      message,
+      data
+    };
+    if (data?.error instanceof Error) {
+      entry.error = data.error;
+      const { error, ...rest } = data;
+      entry.data = Object.keys(rest).length > 0 ? rest : void 0;
     }
+    getActiveSink()(entry);
   }
-  /**
-   * 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]);
-    }
+  error(message, data) {
+    this.log("error", message, data);
   }
-  /**
-   * 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);
-    }
+  warn(message, data) {
+    this.log("warn", message, data);
   }
-  /**
-   * 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));
-    }
+  info(message, data) {
+    this.log("info", message, data);
   }
-  /**
-   * Get current smoothed blendshape values
-   *
-   * @returns Current upper face blendshapes (after smoothing)
-   */
-  getCurrentBlendshapes() {
-    return { ...this.currentBlendshapes };
+  debug(message, data) {
+    this.log("debug", message, data);
   }
-  /**
-   * Reset mapper to neutral state
-   *
-   * Sets both target and current blendshapes to zero.
-   */
-  reset() {
-    this.targetBlendshapes = createZeroBlendshapes();
-    this.currentBlendshapes = createZeroBlendshapes();
-    this.currentEnergy = 1;
+  trace(message, data) {
+    this.log("trace", message, data);
   }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return { ...this.config };
+  verbose(message, data) {
+    this.log("verbose", message, data);
   }
-  /**
-   * Update configuration
-   *
-   * @param config - Partial configuration to update
-   */
-  setConfig(config) {
-    this.config = {
-      ...this.config,
-      ...config
-    };
+  child(subModule) {
+    return new _Logger(`${this.module}.${subModule}`);
   }
 };
-
-// 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;
+var loggerCache = /* @__PURE__ */ new Map();
+function createLogger(module2) {
+  let logger17 = loggerCache.get(module2);
+  if (!logger17) {
+    logger17 = new Logger(module2);
+    loggerCache.set(module2, logger17);
   }
-  return peak;
+  return logger17;
 }
-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
+var noopLogger = {
+  module: "noop",
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  trace: () => {
+  },
+  verbose: () => {
+  },
+  child: () => noopLogger
+};
+
+// src/inference/A2EProcessor.ts
+var logger = createLogger("A2EProcessor");
+var FRAME_RATE = 30;
+var DRIP_INTERVAL_MS = 33;
+var A2EProcessor = class {
+  constructor(config) {
+    this.writeOffset = 0;
+    this.bufferStartTime = 0;
+    // Frame queues (timestamped for pull mode, plain for drip mode)
+    this.timestampedQueue = [];
+    this.plainQueue = [];
+    // Push mode state
+    this._latestFrame = null;
+    this.dripInterval = null;
+    // Last-frame-hold for pull mode (prevents avatar freezing between frames)
+    this.lastPulledFrame = null;
+    // Inference serialization
+    this.inferenceRunning = false;
+    this.pendingChunks = [];
+    // Diagnostic: track getFrameForTime calls
+    this.getFrameCallCount = 0;
+    this.disposed = false;
+    this.backend = config.backend;
+    this.sampleRate = config.sampleRate ?? 16e3;
+    this.chunkSize = config.chunkSize ?? config.backend.chunkSize ?? 16e3;
+    this.onFrame = config.onFrame;
+    this.onError = config.onError;
+    this.bufferCapacity = this.chunkSize * 2;
+    this.buffer = new Float32Array(this.bufferCapacity);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Audio Input
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Push audio samples for inference (any source: mic, TTS, file).
+   *
+   * - With `timestamp`: frames stored with timestamps (pull mode)
+   * - Without `timestamp`: frames stored in plain queue (drip/push mode)
+   *
+   * Fire-and-forget: returns immediately, inference runs async.
    */
-  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);
+  pushAudio(samples, timestamp) {
+    if (this.disposed) return;
+    if (this.writeOffset === 0 && timestamp !== void 0) {
+      this.bufferStartTime = timestamp;
     }
-    if (gatedPeak > this.smoothedPeak) {
-      this.smoothedPeak = this.smoothedPeak * 0.3 + gatedPeak * 0.7;
-    } else {
-      this.smoothedPeak = this.smoothedPeak * this.smoothingFactor + gatedPeak * (1 - this.smoothingFactor);
+    if (this.writeOffset + samples.length > this.bufferCapacity) {
+      this.bufferCapacity = (this.writeOffset + samples.length) * 2;
+      const grown = new Float32Array(this.bufferCapacity);
+      grown.set(this.buffer.subarray(0, this.writeOffset));
+      this.buffer = grown;
+    }
+    this.buffer.set(samples, this.writeOffset);
+    this.writeOffset += samples.length;
+    logger.debug("pushAudio", {
+      samplesIn: samples.length,
+      writeOffset: this.writeOffset,
+      chunkSize: this.chunkSize,
+      willExtract: this.writeOffset >= this.chunkSize,
+      inferenceRunning: this.inferenceRunning,
+      pendingChunks: this.pendingChunks.length,
+      queuedFrames: this.timestampedQueue.length + this.plainQueue.length
+    });
+    while (this.writeOffset >= this.chunkSize) {
+      const chunk = this.buffer.slice(0, this.chunkSize);
+      this.buffer.copyWithin(0, this.chunkSize, this.writeOffset);
+      this.writeOffset -= this.chunkSize;
+      const chunkTimestamp = timestamp !== void 0 ? this.bufferStartTime : void 0;
+      this.pendingChunks.push({ chunk, timestamp: chunkTimestamp });
+      logger.info("Chunk queued for inference", {
+        chunkSize: chunk.length,
+        chunkTimestamp,
+        pendingChunks: this.pendingChunks.length,
+        remainderOffset: this.writeOffset
+      });
+      if (timestamp !== void 0) {
+        this.bufferStartTime += this.chunkSize / this.sampleRate;
+      }
     }
-    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
-    };
+    this.drainPendingChunks();
   }
   /**
-   * Reset analyzer state
+   * Flush remaining buffered audio (pads to chunkSize).
+   * Call at end of stream to process final partial chunk.
+   *
+   * Routes through the serialized pendingChunks pipeline to maintain
+   * correct frame ordering. Without this, flush() could push frames
+   * with the latest timestamp to the queue before drainPendingChunks()
+   * finishes pushing frames with earlier timestamps — causing
+   * getFrameForTime() to see out-of-order timestamps and stall.
    */
-  reset() {
-    this.smoothedRMS = 0;
-    this.smoothedPeak = 0;
+  async flush() {
+    if (this.disposed || this.writeOffset === 0) return;
+    const padded = new Float32Array(this.chunkSize);
+    padded.set(this.buffer.subarray(0, this.writeOffset), 0);
+    const chunkTimestamp = this.bufferStartTime > 0 ? this.bufferStartTime : void 0;
+    logger.info("flush: routing through drain pipeline", {
+      actualSamples: this.writeOffset,
+      chunkTimestamp: chunkTimestamp?.toFixed(3),
+      pendingChunks: this.pendingChunks.length,
+      inferenceRunning: this.inferenceRunning
+    });
+    this.writeOffset = 0;
+    this.bufferStartTime = 0;
+    this.pendingChunks.push({ chunk: padded, timestamp: chunkTimestamp });
+    this.drainPendingChunks();
   }
   /**
-   * Get current smoothed RMS value
+   * Reset buffer and frame queues
    */
-  get rms() {
-    return this.smoothedRMS;
+  reset() {
+    this.writeOffset = 0;
+    this.bufferStartTime = 0;
+    this.timestampedQueue = [];
+    this.plainQueue = [];
+    this._latestFrame = null;
+    this.lastPulledFrame = null;
+    this.pendingChunks = [];
+    this.inferenceRunning = false;
+    this.getFrameCallCount = 0;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Frame Output — Pull Mode (TTS playback)
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Get frame synced to external clock (e.g. AudioContext.currentTime).
+   *
+   * Discards frames that are too old, returns the current frame,
+   * or holds last frame as fallback to prevent avatar freezing.
+   *
+   * @param currentTime - Current playback time (seconds)
+   * @returns Blendshape frame, or null if no frames yet
+   */
+  getFrameForTime(currentTime) {
+    this.getFrameCallCount++;
+    const discardWindow = this.backend.backend === "wasm" ? 1 : 0.5;
+    let discardCount = 0;
+    while (this.timestampedQueue.length > 0 && this.timestampedQueue[0].timestamp < currentTime - discardWindow) {
+      this.timestampedQueue.shift();
+      discardCount++;
+    }
+    if (discardCount > 0) {
+      logger.warn("getFrameForTime DISCARDED stale frames", {
+        discardCount,
+        currentTime: currentTime.toFixed(3),
+        discardWindow,
+        remainingFrames: this.timestampedQueue.length,
+        nextFrameTs: this.timestampedQueue.length > 0 ? this.timestampedQueue[0].timestamp.toFixed(3) : "none"
+      });
+    }
+    if (this.timestampedQueue.length > 0 && this.timestampedQueue[0].timestamp <= currentTime) {
+      const { frame } = this.timestampedQueue.shift();
+      this.lastPulledFrame = frame;
+      return frame;
+    }
+    if (this.timestampedQueue.length > 0 && this.getFrameCallCount % 60 === 0) {
+      logger.warn("getFrameForTime: frames in queue but NOT consumable", {
+        queueLen: this.timestampedQueue.length,
+        frontTimestamp: this.timestampedQueue[0].timestamp.toFixed(4),
+        currentTime: currentTime.toFixed(4),
+        delta: (this.timestampedQueue[0].timestamp - currentTime).toFixed(4),
+        callCount: this.getFrameCallCount
+      });
+    }
+    return this.lastPulledFrame;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Frame Output — Push Mode (live mic, game loop)
+  // ═══════════════════════════════════════════════════════════════════════
+  /** Latest frame from drip-feed (live mic, game loop) */
+  get latestFrame() {
+    return this._latestFrame;
+  }
+  /** Start 30fps drip-feed timer (push mode) */
+  startDrip() {
+    if (this.dripInterval) return;
+    this.dripInterval = setInterval(() => {
+      const frame = this.plainQueue.shift();
+      if (frame) {
+        this._latestFrame = frame;
+        this.onFrame?.(frame);
+      }
+    }, DRIP_INTERVAL_MS);
+  }
+  /** Stop drip-feed timer */
+  stopDrip() {
+    if (this.dripInterval) {
+      clearInterval(this.dripInterval);
+      this.dripInterval = null;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // State
+  // ═══════════════════════════════════════════════════════════════════════
+  /** Number of frames waiting in queue (both modes combined) */
+  get queuedFrameCount() {
+    return this.timestampedQueue.length + this.plainQueue.length;
+  }
+  /** Buffer fill level as fraction of chunkSize (0-1) */
+  get fillLevel() {
+    return Math.min(1, this.writeOffset / this.chunkSize);
+  }
+  /** Dispose resources */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.stopDrip();
+    this.reset();
   }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private
+  // ═══════════════════════════════════════════════════════════════════════
   /**
-   * Get current smoothed peak value
+   * Process pending chunks sequentially.
+   * Fire-and-forget — called from pushAudio() without awaiting.
    */
-  get peak() {
-    return this.smoothedPeak;
+  drainPendingChunks() {
+    if (this.inferenceRunning || this.pendingChunks.length === 0) {
+      if (this.inferenceRunning && this.pendingChunks.length > 0) {
+        logger.debug("drainPendingChunks skipped (inference running)", {
+          pendingChunks: this.pendingChunks.length
+        });
+      }
+      return;
+    }
+    this.inferenceRunning = true;
+    logger.info("drainPendingChunks starting", { pendingChunks: this.pendingChunks.length });
+    const processNext = async () => {
+      while (this.pendingChunks.length > 0 && !this.disposed) {
+        const { chunk, timestamp } = this.pendingChunks.shift();
+        try {
+          const t0 = performance.now();
+          const result = await this.backend.infer(chunk);
+          const inferMs = Math.round(performance.now() - t0);
+          const actualDuration = chunk.length / this.sampleRate;
+          const actualFrameCount = Math.ceil(actualDuration * FRAME_RATE);
+          const framesToQueue = Math.min(actualFrameCount, result.blendshapes.length);
+          logger.info("Inference complete", {
+            inferMs,
+            modelFrames: result.blendshapes.length,
+            framesToQueue,
+            timestamp,
+            totalQueued: this.timestampedQueue.length + framesToQueue,
+            remainingPending: this.pendingChunks.length
+          });
+          for (let i = 0; i < framesToQueue; i++) {
+            if (timestamp !== void 0) {
+              this.timestampedQueue.push({
+                frame: result.blendshapes[i],
+                timestamp: timestamp + i / FRAME_RATE
+              });
+            } else {
+              this.plainQueue.push(result.blendshapes[i]);
+            }
+          }
+        } catch (err) {
+          this.handleError(err);
+        }
+        if (this.pendingChunks.length > 0) {
+          await new Promise((r) => setTimeout(r, 0));
+        }
+      }
+      this.inferenceRunning = false;
+      if (this.pendingChunks.length > 0) {
+        this.drainPendingChunks();
+      }
+    };
+    processNext().catch((err) => this.handleError(err));
+  }
+  handleError(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    logger.warn("A2EProcessor inference error", { error: error.message });
+    this.onError?.(error);
   }
 };
-var EmphasisDetector = class {
+
+// src/inference/BlendshapeSmoother.ts
+var NUM_BLENDSHAPES = 52;
+var BlendshapeSmoother = class {
+  constructor(config) {
+    /** Whether any target has been set */
+    this._hasTarget = false;
+    this.halflife = config?.halflife ?? 0.06;
+    this.values = new Float32Array(NUM_BLENDSHAPES);
+    this.velocities = new Float32Array(NUM_BLENDSHAPES);
+    this.targets = new Float32Array(NUM_BLENDSHAPES);
+  }
+  /** Whether a target frame has been set (false until first setTarget call) */
+  get hasTarget() {
+    return this._hasTarget;
+  }
   /**
-   * @param historySize Number of frames to track. Default 10
-   * @param emphasisThreshold Minimum energy increase to count as emphasis. Default 0.15
+   * Set new target frame from inference output.
+   * Springs will converge toward these values on subsequent update() calls.
    */
-  constructor(historySize = 10, emphasisThreshold = 0.15) {
-    this.energyHistory = [];
-    this.historySize = historySize;
-    this.emphasisThreshold = emphasisThreshold;
+  setTarget(frame) {
+    this.targets.set(frame);
+    this._hasTarget = true;
   }
   /**
-   * Process energy value and detect emphasis
-   * @param energy Current energy value (0-1)
-   * @returns Object with isEmphasis flag and emphasisStrength
+   * Advance all 52 springs by `dt` seconds and return the smoothed frame.
+   *
+   * Call this every render frame (e.g., inside requestAnimationFrame).
+   * Returns the internal values buffer — do NOT mutate the returned array.
+   *
+   * @param dt - Time step in seconds (e.g., 1/60 for 60fps)
+   * @returns Smoothed blendshape values (Float32Array of 52)
    */
-  process(energy) {
-    this.energyHistory.push(energy);
-    if (this.energyHistory.length > this.historySize) {
-      this.energyHistory.shift();
+  update(dt) {
+    if (!this._hasTarget) {
+      return this.values;
     }
-    if (this.energyHistory.length < 3) {
-      return { isEmphasis: false, emphasisStrength: 0 };
+    if (this.halflife <= 0) {
+      this.values.set(this.targets);
+      this.velocities.fill(0);
+      return this.values;
     }
-    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
-    };
+    const damping = Math.LN2 / this.halflife;
+    const eydt = Math.exp(-damping * dt);
+    for (let i = 0; i < NUM_BLENDSHAPES; i++) {
+      const j0 = this.values[i] - this.targets[i];
+      const j1 = this.velocities[i] + j0 * damping;
+      this.values[i] = eydt * (j0 + j1 * dt) + this.targets[i];
+      this.velocities[i] = eydt * (this.velocities[i] - j1 * damping * dt);
+      this.values[i] = Math.max(0, Math.min(1, this.values[i]));
+    }
+    return this.values;
   }
   /**
-   * Reset detector state
+   * Decay all spring targets to neutral (0).
+   *
+   * Call when inference stalls (no new frames for threshold duration).
+   * The springs will smoothly close the mouth / relax the face over
+   * the halflife period rather than freezing.
+   */
+  decayToNeutral() {
+    this.targets.fill(0);
+  }
+  /**
+   * Reset all state (values, velocities, targets).
+   * Call when starting a new playback session.
    */
   reset() {
-    this.energyHistory = [];
+    this.values.fill(0);
+    this.velocities.fill(0);
+    this.targets.fill(0);
+    this._hasTarget = false;
   }
 };
 
@@ -2485,340 +2354,76 @@ async function fetchWithCache(url, optionsOrProgress) {
     if (!response.ok) {
       throw new Error(`Failed to fetch ${url}: ${response.status}`);
     }
-    const contentLength = response.headers.get("content-length");
-    const total = contentLength ? parseInt(contentLength, 10) : 0;
-    const etag = response.headers.get("etag") ?? void 0;
-    const tooLargeForCache = total > MAX_CACHE_SIZE_BYTES;
-    if (tooLargeForCache) {
-      console.log(`[ModelCache] File too large for IndexedDB (${(total / 1024 / 1024).toFixed(0)}MB > 500MB), using HTTP cache only`);
-    }
-    if (!response.body) {
-      const data2 = await response.arrayBuffer();
-      if (!tooLargeForCache) {
-        await cache.set(cacheKey, data2, etag, version);
-      }
-      span?.setAttributes({
-        "fetch.size_bytes": data2.byteLength,
-        "fetch.cached_to_indexeddb": !tooLargeForCache
-      });
-      span?.end();
-      return data2;
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let loaded = 0;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      loaded += value.length;
-      onProgress?.(loaded, total || loaded);
-    }
-    const data = new Uint8Array(loaded);
-    let offset = 0;
-    for (const chunk of chunks) {
-      data.set(chunk, offset);
-      offset += chunk.length;
-    }
-    const buffer = data.buffer;
-    if (!tooLargeForCache) {
-      await cache.set(cacheKey, buffer, etag, version);
-      console.log(`[ModelCache] Cached: ${url} (${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB)`);
-    }
-    span?.setAttributes({
-      "fetch.size_bytes": buffer.byteLength,
-      "fetch.cached_to_indexeddb": !tooLargeForCache
-    });
-    span?.end();
-    return buffer;
-  } catch (error) {
-    span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-    throw error;
-  }
-}
-async function preloadModels(urls, onProgress) {
-  const cache = getModelCache();
-  for (let i = 0; i < urls.length; i++) {
-    const url = urls[i];
-    onProgress?.(i, urls.length, url);
-    if (await cache.has(url)) {
-      console.log(`[ModelCache] Already cached: ${url}`);
-      continue;
-    }
-    await fetchWithCache(url);
-  }
-  onProgress?.(urls.length, urls.length, "done");
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
-}
-
-// src/logging/types.ts
-var LOG_LEVEL_PRIORITY = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4,
-  verbose: 5
-};
-var DEFAULT_LOGGING_CONFIG = {
-  level: "info",
-  enabled: true,
-  format: "pretty",
-  timestamps: true,
-  includeModule: true
-};
-
-// src/logging/formatters.ts
-var COLORS = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  gray: "\x1B[90m",
-  white: "\x1B[37m",
-  magenta: "\x1B[35m"
-};
-var LEVEL_COLORS = {
-  error: COLORS.red,
-  warn: COLORS.yellow,
-  info: COLORS.blue,
-  debug: COLORS.cyan,
-  trace: COLORS.magenta,
-  verbose: COLORS.gray
-};
-var LEVEL_NAMES = {
-  error: "ERROR  ",
-  warn: "WARN   ",
-  info: "INFO   ",
-  debug: "DEBUG  ",
-  trace: "TRACE  ",
-  verbose: "VERBOSE"
-};
-var isBrowser = typeof window !== "undefined";
-function formatTimestamp(timestamp) {
-  const date = new Date(timestamp);
-  return date.toISOString().substring(11, 23);
-}
-function safeStringify(data) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return JSON.stringify(data, (key, value) => {
-    if (typeof value === "object" && value !== null) {
-      if (seen.has(value)) {
-        return "[Circular]";
-      }
-      seen.add(value);
-    }
-    if (value instanceof Error) {
-      return {
-        name: value.name,
-        message: value.message,
-        stack: value.stack
-      };
+    const contentLength = response.headers.get("content-length");
+    const total = contentLength ? parseInt(contentLength, 10) : 0;
+    const etag = response.headers.get("etag") ?? void 0;
+    const tooLargeForCache = total > MAX_CACHE_SIZE_BYTES;
+    if (tooLargeForCache) {
+      console.log(`[ModelCache] File too large for IndexedDB (${(total / 1024 / 1024).toFixed(0)}MB > 500MB), using HTTP cache only`);
     }
-    if (value instanceof Float32Array || value instanceof Int16Array) {
-      return `${value.constructor.name}(${value.length})`;
+    if (!response.body) {
+      const data2 = await response.arrayBuffer();
+      if (!tooLargeForCache) {
+        await cache.set(cacheKey, data2, etag, version);
+      }
+      span?.setAttributes({
+        "fetch.size_bytes": data2.byteLength,
+        "fetch.cached_to_indexeddb": !tooLargeForCache
+      });
+      span?.end();
+      return data2;
     }
-    if (ArrayBuffer.isView(value)) {
-      return `${value.constructor.name}(${value.byteLength})`;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      loaded += value.length;
+      onProgress?.(loaded, total || loaded);
     }
-    return value;
-  });
-}
-var jsonFormatter = (entry) => {
-  const output = {
-    timestamp: entry.timestamp,
-    level: entry.level,
-    module: entry.module,
-    message: entry.message
-  };
-  if (entry.data && Object.keys(entry.data).length > 0) {
-    output.data = entry.data;
-  }
-  if (entry.error) {
-    output.error = {
-      name: entry.error.name,
-      message: entry.error.message,
-      stack: entry.error.stack
-    };
-  }
-  return safeStringify(output);
-};
-var prettyFormatter = (entry) => {
-  const time = formatTimestamp(entry.timestamp);
-  const level = LEVEL_NAMES[entry.level];
-  const module2 = entry.module;
-  const message = entry.message;
-  let output;
-  if (isBrowser) {
-    output = `${time} ${level} [${module2}] ${message}`;
-  } else {
-    const color = LEVEL_COLORS[entry.level];
-    output = `${COLORS.gray}${time}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${module2}]${COLORS.reset} ${message}`;
-  }
-  if (entry.data && Object.keys(entry.data).length > 0) {
-    const dataStr = safeStringify(entry.data);
-    if (dataStr.length > 80) {
-      output += "\n  " + JSON.stringify(entry.data, null, 2).replace(/\n/g, "\n  ");
-    } else {
-      output += " " + dataStr;
+    const data = new Uint8Array(loaded);
+    let offset = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.length;
     }
-  }
-  if (entry.error) {
-    output += `
-  ${entry.error.name}: ${entry.error.message}`;
-    if (entry.error.stack) {
-      const stackLines = entry.error.stack.split("\n").slice(1, 4);
-      output += "\n  " + stackLines.join("\n  ");
+    const buffer = data.buffer;
+    if (!tooLargeForCache) {
+      await cache.set(cacheKey, buffer, etag, version);
+      console.log(`[ModelCache] Cached: ${url} (${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB)`);
     }
+    span?.setAttributes({
+      "fetch.size_bytes": buffer.byteLength,
+      "fetch.cached_to_indexeddb": !tooLargeForCache
+    });
+    span?.end();
+    return buffer;
+  } catch (error) {
+    span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+    throw error;
   }
-  return output;
-};
-function getFormatter(format) {
-  return format === "json" ? jsonFormatter : prettyFormatter;
-}
-function createBrowserConsoleArgs(entry) {
-  const time = formatTimestamp(entry.timestamp);
-  const level = entry.level.toUpperCase().padEnd(7);
-  const module2 = entry.module;
-  const message = entry.message;
-  const styles = {
-    time: "color: gray;",
-    error: "color: red; font-weight: bold;",
-    warn: "color: orange; font-weight: bold;",
-    info: "color: blue;",
-    debug: "color: cyan;",
-    trace: "color: magenta;",
-    verbose: "color: gray;",
-    module: "color: teal; font-weight: bold;",
-    message: "color: inherit;"
-  };
-  let formatStr = "%c%s %c%s %c[%s]%c %s";
-  const args = [
-    styles.time,
-    time,
-    styles[entry.level],
-    level,
-    styles.module,
-    module2,
-    styles.message,
-    message
-  ];
-  if (entry.data && Object.keys(entry.data).length > 0) {
-    formatStr += " %o";
-    args.push(entry.data);
-  }
-  return [formatStr, ...args];
-}
-
-// src/logging/Logger.ts
-var isBrowser2 = typeof window !== "undefined";
-var globalConfig = { ...DEFAULT_LOGGING_CONFIG };
-function configureLogging(config) {
-  globalConfig = { ...globalConfig, ...config };
-}
-function getLoggingConfig() {
-  return { ...globalConfig };
-}
-function resetLoggingConfig() {
-  globalConfig = { ...DEFAULT_LOGGING_CONFIG };
-}
-function setLogLevel(level) {
-  globalConfig.level = level;
-}
-function setLoggingEnabled(enabled) {
-  globalConfig.enabled = enabled;
-}
-var consoleSink = (entry) => {
-  const consoleMethod = entry.level === "error" ? "error" : entry.level === "warn" ? "warn" : "log";
-  if (globalConfig.format === "pretty" && isBrowser2) {
-    const args = createBrowserConsoleArgs(entry);
-    console[consoleMethod](...args);
-  } else {
-    const formatter = getFormatter(globalConfig.format);
-    const formatted = formatter(entry);
-    console[consoleMethod](formatted);
-  }
-};
-function getActiveSink() {
-  return globalConfig.sink || consoleSink;
-}
-function shouldLog(level) {
-  if (!globalConfig.enabled) return false;
-  return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[globalConfig.level];
 }
-var Logger = class _Logger {
-  constructor(module2) {
-    this.module = module2;
-  }
-  log(level, message, data) {
-    if (!shouldLog(level)) return;
-    const entry = {
-      timestamp: Date.now(),
-      level,
-      module: this.module,
-      message,
-      data
-    };
-    if (data?.error instanceof Error) {
-      entry.error = data.error;
-      const { error, ...rest } = data;
-      entry.data = Object.keys(rest).length > 0 ? rest : void 0;
+async function preloadModels(urls, onProgress) {
+  const cache = getModelCache();
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i];
+    onProgress?.(i, urls.length, url);
+    if (await cache.has(url)) {
+      console.log(`[ModelCache] Already cached: ${url}`);
+      continue;
     }
-    getActiveSink()(entry);
-  }
-  error(message, data) {
-    this.log("error", message, data);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  trace(message, data) {
-    this.log("trace", message, data);
-  }
-  verbose(message, data) {
-    this.log("verbose", message, data);
-  }
-  child(subModule) {
-    return new _Logger(`${this.module}.${subModule}`);
-  }
-};
-var loggerCache = /* @__PURE__ */ new Map();
-function createLogger(module2) {
-  let logger15 = loggerCache.get(module2);
-  if (!logger15) {
-    logger15 = new Logger(module2);
-    loggerCache.set(module2, logger15);
+    await fetchWithCache(url);
   }
-  return logger15;
+  onProgress?.(urls.length, urls.length, "done");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
 }
-var noopLogger = {
-  module: "noop",
-  error: () => {
-  },
-  warn: () => {
-  },
-  info: () => {
-  },
-  debug: () => {
-  },
-  trace: () => {
-  },
-  verbose: () => {
-  },
-  child: () => noopLogger
-};
 
 // src/utils/runtime.ts
 function isIOSSafari() {
@@ -2889,7 +2494,7 @@ function isSafari() {
   const ua = navigator.userAgent.toLowerCase();
   return /safari/.test(ua) && !/chrome|crios|fxios|chromium|edg/.test(ua);
 }
-function shouldUseCpuLipSync() {
+function shouldUseCpuA2E() {
   return isSafari() || isIOS();
 }
 function isSpeechRecognitionAvailable() {
@@ -2899,22 +2504,22 @@ function isSpeechRecognitionAvailable() {
 function shouldUseNativeASR() {
   return (isIOS() || isSafari()) && isSpeechRecognitionAvailable();
 }
-function shouldUseServerLipSync() {
+function shouldUseServerA2E() {
   return isIOS();
 }
 
 // src/inference/onnxLoader.ts
-var logger = createLogger("OnnxLoader");
+var logger2 = createLogger("OnnxLoader");
 var ortInstance = null;
 var loadedBackend = null;
 var WASM_CDN_PATH = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 async function isWebGPUAvailable() {
   if (isIOS()) {
-    logger.debug("WebGPU check: disabled on iOS (asyncify bundle crashes WebKit)");
+    logger2.debug("WebGPU check: disabled on iOS (asyncify bundle crashes WebKit)");
     return false;
   }
   if (!hasWebGPUApi()) {
-    logger.debug("WebGPU check: navigator.gpu not available", {
+    logger2.debug("WebGPU check: navigator.gpu not available", {
       isSecureContext: typeof window !== "undefined" ? window.isSecureContext : "N/A"
     });
     return false;
@@ -2922,19 +2527,19 @@ async function isWebGPUAvailable() {
   try {
     const adapter = await navigator.gpu.requestAdapter();
     if (!adapter) {
-      logger.debug("WebGPU check: No adapter available");
+      logger2.debug("WebGPU check: No adapter available");
       return false;
     }
     const device = await adapter.requestDevice();
     if (!device) {
-      logger.debug("WebGPU check: Could not create device");
+      logger2.debug("WebGPU check: Could not create device");
       return false;
     }
     device.destroy();
-    logger.debug("WebGPU check: Available and working");
+    logger2.debug("WebGPU check: Available and working");
     return true;
   } catch (err) {
-    logger.debug("WebGPU check: Error during availability check", { error: err });
+    logger2.debug("WebGPU check: Error during availability check", { error: err });
     return false;
   }
 }
@@ -2944,11 +2549,11 @@ function applyIOSWasmMemoryPatch() {
   iosWasmPatched = true;
   const OrigMemory = WebAssembly.Memory;
   const MAX_IOS_PAGES = 32768;
-  logger.info("Applying iOS WASM memory patch (max\u21922GB, shared preserved)");
+  logger2.info("Applying iOS WASM memory patch (max\u21922GB, shared preserved)");
   WebAssembly.Memory = function IOSPatchedMemory(descriptor) {
     const patched = { ...descriptor };
     if (patched.maximum !== void 0 && patched.maximum > MAX_IOS_PAGES) {
-      logger.info("iOS memory patch: capping maximum", {
+      logger2.info("iOS memory patch: capping maximum", {
         original: patched.maximum,
         capped: MAX_IOS_PAGES,
         shared: patched.shared,
@@ -2967,7 +2572,7 @@ function configureWasm(ort) {
   ort.env.wasm.numThreads = numThreads;
   ort.env.wasm.simd = true;
   ort.env.wasm.proxy = enableProxy;
-  logger.info("WASM configured", {
+  logger2.info("WASM configured", {
     numThreads,
     simd: true,
     proxy: enableProxy,
@@ -2979,12 +2584,12 @@ async function getOnnxRuntime(backend) {
     return ortInstance;
   }
   if (ortInstance && loadedBackend !== backend) {
-    logger.warn(
+    logger2.warn(
       `ONNX Runtime already loaded with ${loadedBackend} backend. Cannot switch to ${backend}. Returning existing instance.`
     );
     return ortInstance;
   }
-  logger.info(`Loading ONNX Runtime with ${backend} backend...`);
+  logger2.info(`Loading ONNX Runtime with ${backend} backend...`);
   applyIOSWasmMemoryPatch();
   try {
     if (backend === "wasm" && (isIOS() || isSafari())) {
@@ -2999,10 +2604,10 @@ async function getOnnxRuntime(backend) {
     }
     loadedBackend = backend;
     configureWasm(ortInstance);
-    logger.info(`ONNX Runtime loaded successfully`, { backend });
+    logger2.info(`ONNX Runtime loaded successfully`, { backend });
     return ortInstance;
   } catch (err) {
-    logger.error(`Failed to load ONNX Runtime with ${backend} backend`, {
+    logger2.error(`Failed to load ONNX Runtime with ${backend} backend`, {
       error: err
     });
     throw new Error(
@@ -3013,7 +2618,7 @@ async function getOnnxRuntime(backend) {
 async function getOnnxRuntimeForPreference(preference = "auto") {
   const webgpuAvailable = await isWebGPUAvailable();
   const backend = resolveBackend(preference, webgpuAvailable);
-  logger.info("Resolved backend preference", {
+  logger2.info("Resolved backend preference", {
     preference,
     webgpuAvailable,
     resolvedBackend: backend
@@ -3047,42 +2652,6 @@ function getSessionOptions(backend) {
     graphOptimizationLevel: "all"
   };
 }
-async function createSessionWithFallback(modelBuffer, preferredBackend) {
-  const ort = await getOnnxRuntime(preferredBackend);
-  const modelData = new Uint8Array(modelBuffer);
-  if (preferredBackend === "webgpu") {
-    try {
-      const options2 = getSessionOptions("webgpu");
-      const session2 = await ort.InferenceSession.create(modelData, options2);
-      logger.info("Session created with WebGPU backend");
-      return { session: session2, backend: "webgpu" };
-    } catch (err) {
-      logger.warn("WebGPU session creation failed, falling back to WASM", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  const options = getSessionOptions("wasm");
-  const session = await ort.InferenceSession.create(modelData, options);
-  logger.info("Session created with WASM backend");
-  return { session, backend: "wasm" };
-}
-function getLoadedBackend() {
-  return loadedBackend;
-}
-function isOnnxRuntimeLoaded() {
-  return ortInstance !== null;
-}
-async function preloadOnnxRuntime(preference = "auto") {
-  if (ortInstance) {
-    logger.info("ONNX Runtime already preloaded", { backend: loadedBackend });
-    return loadedBackend;
-  }
-  logger.info("Preloading ONNX Runtime...", { preference });
-  const { backend } = await getOnnxRuntimeForPreference(preference);
-  logger.info("ONNX Runtime preloaded", { backend });
-  return backend;
-}
 
 // src/inference/blendshapeUtils.ts
 var LAM_BLENDSHAPES = [
@@ -3232,16 +2801,19 @@ var WAV2ARKIT_BLENDSHAPES = [
 var REMAP_WAV2ARKIT_TO_LAM = WAV2ARKIT_BLENDSHAPES.map(
   (name) => LAM_BLENDSHAPES.indexOf(name)
 );
-function remapWav2ArkitToLam(frame) {
-  const result = new Float32Array(52);
-  for (let i = 0; i < 52; i++) {
-    result[REMAP_WAV2ARKIT_TO_LAM[i]] = frame[i];
+function lerpBlendshapes(current, target, factor = 0.3) {
+  const len = Math.max(current.length, target.length);
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) {
+    const c = current[i] ?? 0;
+    const t = target[i] ?? 0;
+    result[i] = c + (t - c) * factor;
   }
   return result;
 }
 
 // src/inference/Wav2Vec2Inference.ts
-var logger2 = createLogger("Wav2Vec2");
+var logger3 = createLogger("Wav2Vec2");
 var CTC_VOCAB = [
   "<pad>",
   "<s>",
@@ -3291,6 +2863,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
     this.poisoned = false;
     this.config = config;
     this.numIdentityClasses = config.numIdentityClasses ?? 12;
+    this.chunkSize = config.chunkSize ?? 16e3;
   }
   get backend() {
     return this.session ? this._backend : null;
@@ -3320,30 +2893,30 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
       "model.backend_requested": this.config.backend || "auto"
     });
     try {
-      logger2.info("Loading ONNX Runtime...", { preference: this.config.backend || "auto" });
+      logger3.info("Loading ONNX Runtime...", { preference: this.config.backend || "auto" });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend || "auto");
       this.ort = ort;
       this._backend = backend;
-      logger2.info("ONNX Runtime loaded", { backend: this._backend });
+      logger3.info("ONNX Runtime loaded", { backend: this._backend });
       const modelUrl = this.config.modelUrl;
       const dataUrl = this.config.externalDataUrl !== false ? typeof this.config.externalDataUrl === "string" ? this.config.externalDataUrl : `${modelUrl}.data` : null;
       const sessionOptions = getSessionOptions(this._backend);
       let isCached = false;
       if (isIOS()) {
-        logger2.info("iOS: passing model URLs directly to ORT (low-memory path)", {
+        logger3.info("iOS: passing model URLs directly to ORT (low-memory path)", {
           modelUrl,
           dataUrl
         });
         if (dataUrl) {
           const dataFilename = dataUrl.split("/").pop();
-          logger2.info("iOS: setting externalData", { dataFilename, dataUrl });
+          logger3.info("iOS: setting externalData", { dataFilename, dataUrl });
           sessionOptions.externalData = [{
             path: dataFilename,
             data: dataUrl
             // URL string — ORT fetches directly into WASM
           }];
         }
-        logger2.info("iOS: calling InferenceSession.create() with URL string", {
+        logger3.info("iOS: calling InferenceSession.create() with URL string", {
           modelUrl,
           sessionOptions: JSON.stringify(
             sessionOptions,
@@ -3353,14 +2926,14 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         try {
           this.session = await this.ort.InferenceSession.create(modelUrl, sessionOptions);
         } catch (sessionErr) {
-          logger2.error("iOS: InferenceSession.create() failed", {
+          logger3.error("iOS: InferenceSession.create() failed", {
             error: sessionErr instanceof Error ? sessionErr.message : String(sessionErr),
             errorType: sessionErr?.constructor?.name,
             stack: sessionErr instanceof Error ? sessionErr.stack : void 0
           });
           throw sessionErr;
         }
-        logger2.info("iOS: session created successfully", {
+        logger3.info("iOS: session created successfully", {
           inputNames: this.session.inputNames,
           outputNames: this.session.outputNames
         });
@@ -3369,15 +2942,15 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         isCached = await cache.has(modelUrl);
         let modelBuffer;
         if (isCached) {
-          logger2.debug("Loading model from cache", { modelUrl });
+          logger3.debug("Loading model from cache", { modelUrl });
           modelBuffer = await cache.get(modelUrl);
           if (!modelBuffer) {
-            logger2.warn("Cache corruption detected, clearing and retrying", { modelUrl });
+            logger3.warn("Cache corruption detected, clearing and retrying", { modelUrl });
             await cache.delete(modelUrl);
             modelBuffer = await fetchWithCache(modelUrl);
           }
         } else {
-          logger2.debug("Fetching and caching model", { modelUrl });
+          logger3.debug("Fetching and caching model", { modelUrl });
           modelBuffer = await fetchWithCache(modelUrl);
         }
         if (!modelBuffer) {
@@ -3388,31 +2961,31 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
           try {
             const isDataCached = await cache.has(dataUrl);
             if (isDataCached) {
-              logger2.debug("Loading external data from cache", { dataUrl });
+              logger3.debug("Loading external data from cache", { dataUrl });
               externalDataBuffer = await cache.get(dataUrl);
               if (!externalDataBuffer) {
-                logger2.warn("Cache corruption for external data, retrying", { dataUrl });
+                logger3.warn("Cache corruption for external data, retrying", { dataUrl });
                 await cache.delete(dataUrl);
                 externalDataBuffer = await fetchWithCache(dataUrl);
               }
             } else {
-              logger2.info("Fetching external model data", {
+              logger3.info("Fetching external model data", {
                 dataUrl,
                 note: "This may be a large download (383MB+)"
               });
               externalDataBuffer = await fetchWithCache(dataUrl);
             }
-            logger2.info("External data loaded", {
+            logger3.info("External data loaded", {
               size: formatBytes(externalDataBuffer.byteLength)
             });
           } catch (err) {
-            logger2.debug("No external data file found (single-file model)", {
+            logger3.debug("No external data file found (single-file model)", {
               dataUrl,
               error: err.message
             });
           }
         }
-        logger2.debug("Creating ONNX session", {
+        logger3.debug("Creating ONNX session", {
           graphSize: formatBytes(modelBuffer.byteLength),
           externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
           backend: this._backend
@@ -3427,12 +3000,12 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         const modelData = new Uint8Array(modelBuffer);
         this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
       }
-      logger2.info("ONNX session created successfully", {
+      logger3.info("ONNX session created successfully", {
         executionProvider: this._backend,
         backend: this._backend
       });
       const loadTimeMs = performance.now() - startTime;
-      logger2.info("Model loaded successfully", {
+      logger3.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         inputs: this.session.inputNames,
@@ -3448,13 +3021,13 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         model: "wav2vec2",
         backend: this._backend
       });
-      logger2.debug("Running warmup inference to initialize GPU context");
+      logger3.debug("Running warmup inference to initialize GPU context");
       const warmupStart = performance.now();
-      const warmupAudio = new Float32Array(16e3);
+      const warmupAudio = new Float32Array(this.chunkSize);
       const warmupIdentity = new Float32Array(this.numIdentityClasses);
       warmupIdentity[0] = 1;
       const warmupFeeds = {
-        "audio": new this.ort.Tensor("float32", warmupAudio, [1, 16e3]),
+        "audio": new this.ort.Tensor("float32", warmupAudio, [1, this.chunkSize]),
         "identity": new this.ort.Tensor("float32", warmupIdentity, [1, this.numIdentityClasses])
       };
       const WARMUP_TIMEOUT_MS = 15e3;
@@ -3464,12 +3037,12 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
       ]);
       const warmupTimeMs = performance.now() - warmupStart;
       if (warmupResult === "timeout") {
-        logger2.warn("Warmup inference timed out \u2014 GPU may be unresponsive. Continuing without warmup.", {
+        logger3.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", {
+        logger3.info("Warmup inference complete", {
           warmupTimeMs: Math.round(warmupTimeMs),
           backend: this._backend
         });
@@ -3497,11 +3070,10 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
   }
   /**
    * Run inference on raw audio
-   * @param audioSamples - Float32Array of raw audio at 16kHz (16000 samples = 1 second)
+   * @param audioSamples - Float32Array of raw audio at 16kHz
    * @param identityIndex - Optional identity index (0-11, default 0 = neutral)
    *
-   * Note: Model expects 1-second chunks (16000 samples) for optimal performance.
-   * Audio will be zero-padded or truncated to 16000 samples.
+   * Audio will be zero-padded or truncated to chunkSize samples.
    */
   async infer(audioSamples, identityIndex = 0) {
     if (!this.session) {
@@ -3512,20 +3084,20 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
     }
     const audioSamplesCopy = new Float32Array(audioSamples);
     let audio;
-    if (audioSamplesCopy.length === 16e3) {
+    if (audioSamplesCopy.length === this.chunkSize) {
       audio = audioSamplesCopy;
-    } else if (audioSamplesCopy.length < 16e3) {
-      audio = new Float32Array(16e3);
+    } else if (audioSamplesCopy.length < this.chunkSize) {
+      audio = new Float32Array(this.chunkSize);
       audio.set(audioSamplesCopy, 0);
     } else {
-      audio = audioSamplesCopy.slice(0, 16e3);
+      audio = audioSamplesCopy.slice(0, this.chunkSize);
     }
     const identity = new Float32Array(this.numIdentityClasses);
     identity[Math.max(0, Math.min(identityIndex, this.numIdentityClasses - 1))] = 1;
     const audioCopy = new Float32Array(audio);
     const identityCopy = new Float32Array(identity);
     const feeds = {
-      "audio": new this.ort.Tensor("float32", audioCopy, [1, 16e3]),
+      "audio": new this.ort.Tensor("float32", audioCopy, [1, this.chunkSize]),
       "identity": new this.ort.Tensor("float32", identityCopy, [1, this.numIdentityClasses])
     };
     return this.queueInference(feeds);
@@ -3561,7 +3133,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         const telemetry = getTelemetry();
         const span = telemetry?.startSpan("Wav2Vec2.infer", {
           "inference.backend": this._backend,
-          "inference.input_samples": 16e3
+          "inference.input_samples": this.chunkSize
         });
         try {
           const startTime = performance.now();
@@ -3600,7 +3172,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
             blendshapes.push(symmetrizeBlendshapes(rawFrame));
           }
           const text = this.decodeCTC(asrLogits);
-          logger2.trace("Inference completed", {
+          logger3.trace("Inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             numA2EFrames,
             numASRFrames,
@@ -3634,12 +3206,12 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
           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.", {
+            logger3.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 });
+            logger3.error("Inference failed", { error: errMsg, backend: this._backend });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -3680,56 +3252,79 @@ _Wav2Vec2Inference.INFERENCE_TIMEOUT_MS = 5e3;
 _Wav2Vec2Inference.isWebGPUAvailable = isWebGPUAvailable;
 var Wav2Vec2Inference = _Wav2Vec2Inference;
 
+// src/audio/audioUtils.ts
+function pcm16ToFloat32(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;
+}
+function int16ToFloat32(int16) {
+  const float32 = new Float32Array(int16.length);
+  for (let i = 0; i < int16.length; i++) {
+    float32[i] = int16[i] / 32768;
+  }
+  return float32;
+}
+
 // 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);
-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 {
+var logger4 = createLogger("FullFacePipeline");
+var BLENDSHAPE_TO_GROUP = /* @__PURE__ */ new Map();
+for (const name of LAM_BLENDSHAPES) {
+  if (name.startsWith("eye")) {
+    BLENDSHAPE_TO_GROUP.set(name, "eyes");
+  } else if (name.startsWith("brow")) {
+    BLENDSHAPE_TO_GROUP.set(name, "brows");
+  } else if (name.startsWith("jaw")) {
+    BLENDSHAPE_TO_GROUP.set(name, "jaw");
+  } else if (name.startsWith("mouth")) {
+    BLENDSHAPE_TO_GROUP.set(name, "mouth");
+  } else if (name.startsWith("cheek")) {
+    BLENDSHAPE_TO_GROUP.set(name, "cheeks");
+  } else if (name.startsWith("nose")) {
+    BLENDSHAPE_TO_GROUP.set(name, "nose");
+  } else if (name.startsWith("tongue")) {
+    BLENDSHAPE_TO_GROUP.set(name, "tongue");
+  }
+}
+var FullFacePipeline = class 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;
+    // Frame loop timing (for dt calculation)
+    this.lastFrameLoopTime = 0;
+    // Diagnostic logging counter
+    this.frameLoopCount = 0;
     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;
+    this.profile = options.profile ?? {};
+    this.staleThresholdMs = options.staleThresholdMs ?? 2e3;
+    this.smoother = new BlendshapeSmoother({
+      halflife: options.smoothingHalflife ?? 0.06
+    });
+    const isCpuModel = options.lam.modelId === "wav2arkit_cpu";
+    const chunkSize = options.chunkSize ?? options.lam.chunkSize ?? 16e3;
+    const chunkAccumulationMs = chunkSize / sampleRate * 1e3;
+    const inferenceEstimateMs = isCpuModel ? 300 : options.lam.backend === "wasm" ? 250 : 80;
+    const marginMs = 100;
+    const autoDelay = Math.ceil(chunkAccumulationMs + inferenceEstimateMs + marginMs);
     const audioDelayMs = options.audioDelayMs ?? autoDelay;
+    logger4.info("FullFacePipeline config", {
+      chunkSize,
+      audioDelayMs,
+      autoDelay,
+      backend: options.lam.backend,
+      modelId: options.lam.modelId
+    });
     this.scheduler = new AudioScheduler({
       sampleRate,
       initialLookaheadSec: audioDelayMs / 1e3
@@ -3738,20 +3333,15 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
       sampleRate,
       targetDurationMs: options.chunkTargetMs ?? 200
     });
-    this.lamPipeline = new LAMPipeline({
+    this.processor = new A2EProcessor({
+      backend: options.lam,
       sampleRate,
+      chunkSize,
       onError: (error) => {
-        logger3.error("LAM inference error", { message: error.message, stack: error.stack });
+        logger4.error("A2E 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
@@ -3760,40 +3350,33 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     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 });
+   * Update the ExpressionProfile at runtime (e.g., character switch).
+   */
+  setProfile(profile) {
+    this.profile = profile;
   }
   /**
-   * Clear any set emotion label.
-   * Falls back to prosody-only upper face animation.
+   * Apply ExpressionProfile scaling to raw A2E blendshapes.
+   *
+   * For each blendshape:
+   * 1. If an override exists for the blendshape name, use override as scaler
+   * 2. Otherwise, use the group scaler (default 1.0)
+   * 3. Clamp result to [0, 1]
    */
-  clearEmotionLabel() {
-    this.lastEmotionFrame = null;
+  applyProfile(raw) {
+    const scaled = new Float32Array(52);
+    for (let i = 0; i < 52; i++) {
+      const name = LAM_BLENDSHAPES[i];
+      let scaler;
+      if (this.profile.overrides && this.profile.overrides[name] !== void 0) {
+        scaler = this.profile.overrides[name];
+      } else {
+        const group = BLENDSHAPE_TO_GROUP.get(name);
+        scaler = group ? this.profile[group] ?? 1 : 1;
+      }
+      scaled[i] = Math.min(1, Math.max(0, raw[i] * scaler));
+    }
+    return scaled;
   }
   /**
    * Start a new playback session
@@ -3805,15 +3388,14 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     this.stopMonitoring();
     this.scheduler.reset();
     this.coalescer.reset();
-    this.lamPipeline.reset();
+    this.processor.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.lastFrameLoopTime = 0;
+    this.frameLoopCount = 0;
+    this.smoother.reset();
     this.scheduler.warmup();
     this.startFrameLoop();
     this.startMonitoring();
@@ -3821,8 +3403,8 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
   /**
    * 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.
+   * Audio-first design: schedules audio immediately, A2E runs in background.
+   * This prevents A2E inference (50-300ms) from blocking audio scheduling.
    *
    * @param chunk - Uint8Array containing Int16 PCM audio
    */
@@ -3837,100 +3419,77 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
       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);
+    logger4.info("onAudioChunk \u2192 pushAudio", {
+      float32Samples: float32.length,
+      scheduleTime: scheduleTime.toFixed(3),
+      currentTime: this.scheduler.getCurrentTime().toFixed(3),
+      deltaToPlayback: (scheduleTime - this.scheduler.getCurrentTime()).toFixed(3)
     });
-  }
-  /**
-   * 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 };
+    this.processor.pushAudio(float32, scheduleTime);
   }
   /**
    * Start frame animation loop
+   *
+   * Uses critically damped spring smoother to produce continuous output
+   * at render rate (60fps), even between inference batches (~30fps bursts).
+   * Springs interpolate toward the latest inference target, and decay
+   * to neutral when inference stalls.
    */
   startFrameLoop() {
+    this.lastFrameLoopTime = 0;
     const updateFrame = () => {
+      const now = performance.now() / 1e3;
+      const dt = this.lastFrameLoopTime > 0 ? now - this.lastFrameLoopTime : 1 / 60;
+      this.lastFrameLoopTime = now;
+      this.frameLoopCount++;
       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 lamFrame = this.processor.getFrameForTime(currentTime);
+      if (lamFrame && lamFrame !== this.lastKnownLamFrame) {
+        this.smoother.setTarget(lamFrame);
+        this.lastNewFrameTime = performance.now();
+        this.lastKnownLamFrame = lamFrame;
+        this.staleWarningEmitted = false;
+        logger4.info("New A2E frame", {
+          jawOpen: lamFrame[24]?.toFixed(3),
+          mouthClose: lamFrame[26]?.toFixed(3),
+          browInnerUp: lamFrame[2]?.toFixed(3),
+          browDownL: lamFrame[0]?.toFixed(3),
+          browOuterUpL: lamFrame[3]?.toFixed(3),
+          currentTime: currentTime.toFixed(3),
+          queuedFrames: this.processor.queuedFrameCount
+        });
+      }
+      if (this.frameLoopCount % 60 === 0) {
+        logger4.info("Frame loop heartbeat", {
+          frameLoopCount: this.frameLoopCount,
+          currentTime: currentTime.toFixed(3),
+          playbackEndTime: this.scheduler.getPlaybackEndTime().toFixed(3),
+          queuedFrames: this.processor.queuedFrameCount,
+          hasTarget: this.smoother.hasTarget,
+          playbackStarted: this.playbackStarted,
+          msSinceNewFrame: this.lastNewFrameTime > 0 ? Math.round(performance.now() - this.lastNewFrameTime) : -1,
+          processorFill: this.processor.fillLevel.toFixed(2)
+        });
+      }
+      if (this.playbackStarted && this.lastNewFrameTime > 0 && performance.now() - this.lastNewFrameTime > this.staleThresholdMs) {
+        this.smoother.decayToNeutral();
+        if (!this.staleWarningEmitted) {
+          this.staleWarningEmitted = true;
+          logger4.warn("A2E stalled \u2014 decaying to neutral", {
+            staleDurationMs: Math.round(performance.now() - this.lastNewFrameTime),
+            queuedFrames: this.processor.queuedFrameCount
+          });
         }
-        const { frame: emotionFrame, energy } = this.getEmotionFrame();
-        const { merged, emotionBlendshapes } = this.mergeBlendshapes(lamFrame, emotionFrame, energy);
+      }
+      if (lamFrame) {
+        const scaled = this.applyProfile(lamFrame);
         const fullFrame = {
-          blendshapes: merged,
-          lamBlendshapes: lamFrame,
-          emotionBlendshapes,
-          emotion: emotionFrame,
+          blendshapes: scaled,
+          rawBlendshapes: lamFrame,
           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);
     };
@@ -3945,7 +3504,7 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
       const chunk = new Uint8Array(remaining);
       await this.onAudioChunk(chunk);
     }
-    await this.lamPipeline.flush(this.options.lam);
+    await this.processor.flush();
   }
   /**
    * Stop playback immediately with smooth fade-out
@@ -3954,15 +3513,13 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     this.stopMonitoring();
     await this.scheduler.cancelAll(fadeOutMs);
     this.coalescer.reset();
-    this.lamPipeline.reset();
+    this.processor.reset();
+    this.smoother.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.lastFrameLoopTime = 0;
     this.emit("playback_complete", void 0);
   }
   /**
@@ -3973,7 +3530,7 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
       clearInterval(this.monitorInterval);
     }
     this.monitorInterval = setInterval(() => {
-      if (this.scheduler.isComplete() && this.lamPipeline.queuedFrameCount === 0) {
+      if (this.scheduler.isComplete() && this.processor.queuedFrameCount === 0) {
         this.emit("playback_complete", void 0);
         this.stopMonitoring();
       }
@@ -3999,20 +3556,12 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     return {
       playbackStarted: this.playbackStarted,
       coalescerFill: this.coalescer.fillLevel,
-      lamFill: this.lamPipeline.fillLevel,
-      queuedLAMFrames: this.lamPipeline.queuedFrameCount,
-      emotionLabel: this.lastEmotionFrame?.emotion ?? null,
-      currentAudioEnergy: this.currentAudioEnergy,
+      processorFill: this.processor.fillLevel,
+      queuedFrames: this.processor.queuedFrameCount,
       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
    */
@@ -4020,13 +3569,9 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     this.stopMonitoring();
     this.scheduler.dispose();
     this.coalescer.reset();
-    this.lamPipeline.reset();
-    this.lastEmotionFrame = null;
-    this.currentAudioEnergy = 0;
+    this.processor.dispose();
   }
 };
-_FullFacePipeline.STALE_FRAME_THRESHOLD_MS = 3e3;
-var FullFacePipeline = _FullFacePipeline;
 
 // src/inference/kaldiFbank.ts
 function fft(re, im) {
@@ -4313,7 +3858,7 @@ function ctcGreedyDecode(logits, seqLen, vocabSize, tokenMap) {
 }
 
 // src/inference/SenseVoiceInference.ts
-var logger4 = createLogger("SenseVoice");
+var logger5 = createLogger("SenseVoice");
 var _SenseVoiceInference = class _SenseVoiceInference {
   constructor(config) {
     this.session = null;
@@ -4366,26 +3911,26 @@ var _SenseVoiceInference = class _SenseVoiceInference {
       "model.backend_requested": this.config.backend
     });
     try {
-      logger4.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger5.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger4.info("ONNX Runtime loaded", { backend: this._backend });
-      logger4.debug("Fetching tokens vocabulary", { tokensUrl: this.config.tokensUrl });
+      logger5.info("ONNX Runtime loaded", { backend: this._backend });
+      logger5.debug("Fetching tokens vocabulary", { tokensUrl: this.config.tokensUrl });
       const tokensResponse = await fetch(this.config.tokensUrl);
       if (!tokensResponse.ok) {
         throw new Error(`Failed to fetch tokens.txt: ${tokensResponse.status} ${tokensResponse.statusText}`);
       }
       const tokensText = await tokensResponse.text();
       this.tokenMap = parseTokensFile(tokensText);
-      logger4.debug("Tokens loaded", { vocabSize: this.tokenMap.size });
+      logger5.debug("Tokens loaded", { vocabSize: this.tokenMap.size });
       const sessionOptions = getSessionOptions(this._backend);
       if (this._backend === "webgpu") {
         sessionOptions.graphOptimizationLevel = "basic";
       }
       let isCached = false;
       if (isIOS()) {
-        logger4.info("iOS: passing model URL directly to ORT (low-memory path)", {
+        logger5.info("iOS: passing model URL directly to ORT (low-memory path)", {
           modelUrl: this.config.modelUrl
         });
         this.session = await this.ort.InferenceSession.create(
@@ -4397,14 +3942,14 @@ var _SenseVoiceInference = class _SenseVoiceInference {
         isCached = await cache.has(this.config.modelUrl);
         let modelBuffer;
         if (isCached) {
-          logger4.debug("Loading model from cache", { modelUrl: this.config.modelUrl });
+          logger5.debug("Loading model from cache", { modelUrl: this.config.modelUrl });
           modelBuffer = await cache.get(this.config.modelUrl);
           onProgress?.(modelBuffer.byteLength, modelBuffer.byteLength);
         } else {
-          logger4.debug("Fetching and caching model", { modelUrl: this.config.modelUrl });
+          logger5.debug("Fetching and caching model", { modelUrl: this.config.modelUrl });
           modelBuffer = await fetchWithCache(this.config.modelUrl, onProgress);
         }
-        logger4.debug("Creating ONNX session", {
+        logger5.debug("Creating ONNX session", {
           size: formatBytes(modelBuffer.byteLength),
           backend: this._backend
         });
@@ -4417,15 +3962,15 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const cmvn = parseCMVNFromMetadata(metadata.neg_mean, metadata.inv_stddev);
           this.negMean = cmvn.negMean;
           this.invStddev = cmvn.invStddev;
-          logger4.debug("CMVN loaded from model metadata", { dim: this.negMean.length });
+          logger5.debug("CMVN loaded from model metadata", { dim: this.negMean.length });
         } else {
-          logger4.warn("CMVN not found in model metadata \u2014 features will not be normalized");
+          logger5.warn("CMVN not found in model metadata \u2014 features will not be normalized");
         }
       } catch (cmvnErr) {
-        logger4.warn("Failed to read CMVN from model metadata", { error: cmvnErr });
+        logger5.warn("Failed to read CMVN from model metadata", { error: cmvnErr });
       }
       const loadTimeMs = performance.now() - startTime;
-      logger4.info("SenseVoice model loaded", {
+      logger5.info("SenseVoice model loaded", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         vocabSize: this.tokenMap.size,
@@ -4536,7 +4081,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const vocabSize = logitsDims[2];
           const decoded = ctcGreedyDecode(logitsData, seqLen, vocabSize, this.tokenMap);
           const inferenceTimeMs = performance.now() - startTime;
-          logger4.trace("Transcription complete", {
+          logger5.trace("Transcription complete", {
             text: decoded.text.substring(0, 50),
             language: decoded.language,
             emotion: decoded.emotion,
@@ -4574,7 +4119,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger4.error("CRITICAL: Inference session timed out \u2014 SenseVoice is dead. Page reload required.", {
+            logger5.error("CRITICAL: Inference session timed out \u2014 SenseVoice is dead. Page reload required.", {
               backend: this._backend,
               timeoutMs: _SenseVoiceInference.INFERENCE_TIMEOUT_MS
             });
@@ -4582,7 +4127,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
             const oomError = new Error(
               `SenseVoice inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reloading the page.`
             );
-            logger4.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger5.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -4595,7 +4140,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
             reject(oomError);
             return;
           } else {
-            logger4.error("Inference failed", { error: errMsg, backend: this._backend });
+            logger5.error("Inference failed", { error: errMsg, backend: this._backend });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -4624,7 +4169,7 @@ _SenseVoiceInference.INFERENCE_TIMEOUT_MS = 1e4;
 var SenseVoiceInference = _SenseVoiceInference;
 
 // src/inference/SenseVoiceWorker.ts
-var logger5 = createLogger("SenseVoiceWorker");
+var logger6 = createLogger("SenseVoiceWorker");
 var WASM_CDN_PATH2 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS = 3e4;
 var INFERENCE_TIMEOUT_MS = 1e4;
@@ -5357,7 +4902,7 @@ var SenseVoiceWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger5.error("Worker error", { error: error.message });
+      logger6.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -5437,9 +4982,9 @@ var SenseVoiceWorker = class {
       "model.language": this.config.language
     });
     try {
-      logger5.info("Creating SenseVoice worker...");
+      logger6.info("Creating SenseVoice worker...");
       this.worker = this.createWorker();
-      logger5.info("Loading model in worker...", {
+      logger6.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         tokensUrl: this.config.tokensUrl,
         language: this.config.language,
@@ -5461,7 +5006,7 @@ var SenseVoiceWorker = class {
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
       onProgress?.(1, 1);
-      logger5.info("SenseVoice worker loaded successfully", {
+      logger6.info("SenseVoice worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -5540,7 +5085,7 @@ var SenseVoiceWorker = class {
             INFERENCE_TIMEOUT_MS
           );
           const totalTimeMs = performance.now() - startTime;
-          logger5.trace("Worker transcription complete", {
+          logger6.trace("Worker transcription complete", {
             text: result.text.substring(0, 50),
             language: result.language,
             emotion: result.emotion,
@@ -5576,11 +5121,11 @@ var SenseVoiceWorker = class {
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
-            logger5.error("CRITICAL: Worker inference timed out \u2014 SenseVoice worker is dead. Page reload required.", {
+            logger6.error("CRITICAL: Worker inference timed out \u2014 SenseVoice worker is dead. Page reload required.", {
               timeoutMs: INFERENCE_TIMEOUT_MS
             });
           } else {
-            logger5.error("Worker inference failed", { error: errMsg });
+            logger6.error("Worker inference failed", { error: errMsg });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -5618,7 +5163,7 @@ var SenseVoiceWorker = class {
 };
 
 // src/inference/UnifiedInferenceWorker.ts
-var logger6 = createLogger("UnifiedInferenceWorker");
+var logger7 = createLogger("UnifiedInferenceWorker");
 var WASM_CDN_PATH3 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var INIT_TIMEOUT_MS = 15e3;
 var SV_LOAD_TIMEOUT_MS = 3e4;
@@ -6314,7 +5859,7 @@ var UnifiedInferenceWorker = class {
     const telemetry = getTelemetry();
     const span = telemetry?.startSpan("UnifiedInferenceWorker.init");
     try {
-      logger6.info("Creating unified inference worker...");
+      logger7.info("Creating unified inference worker...");
       this.worker = this.createWorker();
       await this.sendMessage(
         { type: "init", wasmPaths: WASM_CDN_PATH3, isIOS: isIOS() },
@@ -6323,7 +5868,7 @@ var UnifiedInferenceWorker = class {
       );
       this.initialized = true;
       const loadTimeMs = performance.now() - startTime;
-      logger6.info("Unified worker initialized", { loadTimeMs: Math.round(loadTimeMs) });
+      logger7.info("Unified worker initialized", { loadTimeMs: Math.round(loadTimeMs) });
       span?.setAttributes({ "worker.init_time_ms": loadTimeMs });
       span?.end();
     } catch (error) {
@@ -6377,8 +5922,8 @@ var UnifiedInferenceWorker = class {
     if (!this.worker) return;
     await this.sendMessage({ type: "sv:dispose" }, "sv:disposed", DISPOSE_TIMEOUT_MS);
   }
-  // ── Wav2ArkitCpu (Lip Sync) ──────────────────────────────────────────
-  async loadLipSync(config) {
+  // ── Wav2ArkitCpu (A2E) ──────────────────────────────────────────────
+  async loadA2E(config) {
     this.assertReady();
     const startTime = performance.now();
     const result = await this.sendMessage(
@@ -6399,7 +5944,7 @@ var UnifiedInferenceWorker = class {
       outputNames: result.outputNames
     };
   }
-  async inferLipSync(audio) {
+  async inferA2E(audio) {
     this.assertReady();
     return this.sendMessage(
       { type: "cpu:infer", audio },
@@ -6407,7 +5952,7 @@ var UnifiedInferenceWorker = class {
       CPU_INFER_TIMEOUT_MS
     );
   }
-  async disposeLipSync() {
+  async disposeA2E() {
     if (!this.worker) return;
     await this.sendMessage({ type: "cpu:dispose" }, "cpu:disposed", DISPOSE_TIMEOUT_MS);
   }
@@ -6497,7 +6042,7 @@ var UnifiedInferenceWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger6.error("Unified worker error", { error: error.message });
+      logger7.error("Unified worker error", { error: error.message });
       this.rejectAllPending(`Worker error: ${error.message}`);
     };
     return worker;
@@ -6511,7 +6056,7 @@ var UnifiedInferenceWorker = class {
         this.pendingRequests.delete(requestId);
         pending.reject(new Error(data.error));
       } else {
-        logger6.error("Worker broadcast error", { error: data.error });
+        logger7.error("Worker broadcast error", { error: data.error });
         this.rejectAllPending(data.error);
       }
       return;
@@ -6533,7 +6078,7 @@ var UnifiedInferenceWorker = class {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(requestId);
         this.poisoned = true;
-        logger6.error("CRITICAL: Worker operation timed out \u2014 worker is dead", {
+        logger7.error("CRITICAL: Worker operation timed out \u2014 worker is dead", {
           type: message.type,
           timeoutMs
         });
@@ -6599,7 +6144,7 @@ var SenseVoiceUnifiedAdapter = class {
       });
       this._isLoaded = true;
       onProgress?.(1, 1);
-      logger6.info("SenseVoice loaded via unified worker", {
+      logger7.info("SenseVoice loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs),
         vocabSize: result.vocabSize
@@ -6640,6 +6185,7 @@ var SenseVoiceUnifiedAdapter = class {
 var Wav2ArkitCpuUnifiedAdapter = class {
   constructor(worker, config) {
     this.modelId = "wav2arkit_cpu";
+    this.chunkSize = 16e3;
     this._isLoaded = false;
     this.inferenceQueue = Promise.resolve();
     this.worker = worker;
@@ -6658,12 +6204,12 @@ var Wav2ArkitCpuUnifiedAdapter = class {
     });
     try {
       const externalDataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${this.config.modelUrl}.data` : null;
-      const result = await this.worker.loadLipSync({
+      const result = await this.worker.loadA2E({
         modelUrl: this.config.modelUrl,
         externalDataUrl: externalDataUrl || null
       });
       this._isLoaded = true;
-      logger6.info("Wav2ArkitCpu loaded via unified worker", {
+      logger7.info("Wav2ArkitCpu loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs)
       });
@@ -6690,7 +6236,7 @@ var Wav2ArkitCpuUnifiedAdapter = class {
         });
         try {
           const startTime = performance.now();
-          const result = await this.worker.inferLipSync(audioCopy);
+          const result = await this.worker.inferA2E(audioCopy);
           const inferenceTimeMs = performance.now() - startTime;
           const flatBuffer = result.blendshapes;
           const { numFrames, numBlendshapes } = result;
@@ -6713,7 +6259,7 @@ var Wav2ArkitCpuUnifiedAdapter = class {
   }
   async dispose() {
     if (this._isLoaded) {
-      await this.worker.disposeLipSync();
+      await this.worker.disposeA2E();
       this._isLoaded = false;
     }
   }
@@ -6769,7 +6315,7 @@ var SileroVADUnifiedAdapter = class {
         sampleRate: this.config.sampleRate
       });
       this._isLoaded = true;
-      logger6.info("SileroVAD loaded via unified worker", {
+      logger7.info("SileroVAD loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -6850,10 +6396,10 @@ var SileroVADUnifiedAdapter = class {
 };
 
 // src/inference/createSenseVoice.ts
-var logger7 = createLogger("createSenseVoice");
+var logger8 = createLogger("createSenseVoice");
 function createSenseVoice(config) {
   if (config.unifiedWorker) {
-    logger7.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
+    logger8.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
     return new SenseVoiceUnifiedAdapter(config.unifiedWorker, {
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6866,7 +6412,7 @@ function createSenseVoice(config) {
     if (!SenseVoiceWorker.isSupported()) {
       throw new Error("Web Workers are not supported in this environment");
     }
-    logger7.info("Creating SenseVoiceWorker (off-main-thread)");
+    logger8.info("Creating SenseVoiceWorker (off-main-thread)");
     return new SenseVoiceWorker({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6875,7 +6421,7 @@ function createSenseVoice(config) {
     });
   }
   if (useWorker === false) {
-    logger7.info("Creating SenseVoiceInference (main thread)");
+    logger8.info("Creating SenseVoiceInference (main thread)");
     return new SenseVoiceInference({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6884,7 +6430,7 @@ function createSenseVoice(config) {
     });
   }
   if (SenseVoiceWorker.isSupported() && !isIOS()) {
-    logger7.info("Auto-detected: creating SenseVoiceWorker (off-main-thread)");
+    logger8.info("Auto-detected: creating SenseVoiceWorker (off-main-thread)");
     return new SenseVoiceWorker({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6892,7 +6438,7 @@ function createSenseVoice(config) {
       textNorm: config.textNorm
     });
   }
-  logger7.info("Auto-detected: creating SenseVoiceInference (main thread)", {
+  logger8.info("Auto-detected: creating SenseVoiceInference (main thread)", {
     reason: isIOS() ? "iOS (shared ORT instance)" : "Worker unsupported"
   });
   return new SenseVoiceInference({
@@ -6904,10 +6450,11 @@ function createSenseVoice(config) {
 }
 
 // src/inference/Wav2ArkitCpuInference.ts
-var logger8 = createLogger("Wav2ArkitCpu");
+var logger9 = createLogger("Wav2ArkitCpu");
 var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
   constructor(config) {
     this.modelId = "wav2arkit_cpu";
+    this.chunkSize = 16e3;
     this.session = null;
     this.ort = null;
     this._backend = "wasm";
@@ -6945,16 +6492,16 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
     });
     try {
       const preference = this.config.backend || "wasm";
-      logger8.info("Loading ONNX Runtime...", { preference });
+      logger9.info("Loading ONNX Runtime...", { preference });
       const { ort, backend } = await getOnnxRuntimeForPreference(preference);
       this.ort = ort;
       this._backend = backend;
-      logger8.info("ONNX Runtime loaded", { backend: this._backend });
+      logger9.info("ONNX Runtime loaded", { backend: this._backend });
       const modelUrl = this.config.modelUrl;
       const dataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${modelUrl}.data` : null;
       const sessionOptions = getSessionOptions(this._backend);
       if (isIOS()) {
-        logger8.info("iOS: passing model URLs directly to ORT (low-memory path)", {
+        logger9.info("iOS: passing model URLs directly to ORT (low-memory path)", {
           modelUrl,
           dataUrl
         });
@@ -6972,15 +6519,15 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         const isCached = await cache.has(modelUrl);
         let modelBuffer;
         if (isCached) {
-          logger8.debug("Loading model from cache", { modelUrl });
+          logger9.debug("Loading model from cache", { modelUrl });
           modelBuffer = await cache.get(modelUrl);
           if (!modelBuffer) {
-            logger8.warn("Cache corruption detected, clearing and retrying", { modelUrl });
+            logger9.warn("Cache corruption detected, clearing and retrying", { modelUrl });
             await cache.delete(modelUrl);
             modelBuffer = await fetchWithCache(modelUrl);
           }
         } else {
-          logger8.debug("Fetching and caching model graph", { modelUrl });
+          logger9.debug("Fetching and caching model graph", { modelUrl });
           modelBuffer = await fetchWithCache(modelUrl);
         }
         if (!modelBuffer) {
@@ -6991,31 +6538,31 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
           try {
             const isDataCached = await cache.has(dataUrl);
             if (isDataCached) {
-              logger8.debug("Loading external data from cache", { dataUrl });
+              logger9.debug("Loading external data from cache", { dataUrl });
               externalDataBuffer = await cache.get(dataUrl);
               if (!externalDataBuffer) {
-                logger8.warn("Cache corruption for external data, retrying", { dataUrl });
+                logger9.warn("Cache corruption for external data, retrying", { dataUrl });
                 await cache.delete(dataUrl);
                 externalDataBuffer = await fetchWithCache(dataUrl);
               }
             } else {
-              logger8.info("Fetching external model data", {
+              logger9.info("Fetching external model data", {
                 dataUrl,
                 note: "This may be a large download (400MB+)"
               });
               externalDataBuffer = await fetchWithCache(dataUrl);
             }
-            logger8.info("External data loaded", {
+            logger9.info("External data loaded", {
               size: formatBytes(externalDataBuffer.byteLength)
             });
           } catch (err) {
-            logger8.debug("No external data file found (single-file model)", {
+            logger9.debug("No external data file found (single-file model)", {
               dataUrl,
               error: err.message
             });
           }
         }
-        logger8.debug("Creating ONNX session", {
+        logger9.debug("Creating ONNX session", {
           graphSize: formatBytes(modelBuffer.byteLength),
           externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
           backend: this._backend
@@ -7031,7 +6578,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
       }
       const loadTimeMs = performance.now() - startTime;
-      logger8.info("Model loaded successfully", {
+      logger9.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         inputs: this.session.inputNames,
@@ -7047,12 +6594,12 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         model: "wav2arkit_cpu",
         backend: this._backend
       });
-      logger8.debug("Running warmup inference");
+      logger9.debug("Running warmup inference");
       const warmupStart = performance.now();
       const silentAudio = new Float32Array(16e3);
       await this.infer(silentAudio);
       const warmupTimeMs = performance.now() - warmupStart;
-      logger8.info("Warmup inference complete", {
+      logger9.info("Warmup inference complete", {
         warmupTimeMs: Math.round(warmupTimeMs),
         backend: this._backend
       });
@@ -7139,7 +6686,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
             const symmetrized = symmetrizeBlendshapes(rawFrame);
             blendshapes.push(symmetrized);
           }
-          logger8.trace("Inference completed", {
+          logger9.trace("Inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             numFrames,
             inputSamples
@@ -7167,7 +6714,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger8.error("CRITICAL: Inference session timed out \u2014 Wav2ArkitCpu is dead. Page reload required.", {
+            logger9.error("CRITICAL: Inference session timed out \u2014 Wav2ArkitCpu is dead. Page reload required.", {
               backend: this._backend,
               timeoutMs: _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS
             });
@@ -7175,7 +6722,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
             const oomError = new Error(
               `Wav2ArkitCpu inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reloading the page.`
             );
-            logger8.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger9.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -7188,7 +6735,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
             reject(oomError);
             return;
           } else {
-            logger8.error("Inference failed", { error: errMsg, backend: this._backend });
+            logger9.error("Inference failed", { error: errMsg, backend: this._backend });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -7215,7 +6762,7 @@ _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS = 5e3;
 var Wav2ArkitCpuInference = _Wav2ArkitCpuInference;
 
 // src/inference/Wav2ArkitCpuWorker.ts
-var logger9 = createLogger("Wav2ArkitCpuWorker");
+var logger10 = createLogger("Wav2ArkitCpuWorker");
 var WASM_CDN_PATH4 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS2 = 6e4;
 var INFERENCE_TIMEOUT_MS2 = 5e3;
@@ -7461,6 +7008,7 @@ self.onerror = function(err) {
 var Wav2ArkitCpuWorker = class {
   constructor(config) {
     this.modelId = "wav2arkit_cpu";
+    this.chunkSize = 16e3;
     this.worker = null;
     this.isLoading = false;
     this._isLoaded = false;
@@ -7495,7 +7043,7 @@ var Wav2ArkitCpuWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger9.error("Worker error", { error: error.message });
+      logger10.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -7571,10 +7119,10 @@ var Wav2ArkitCpuWorker = class {
       "model.backend_requested": "wasm"
     });
     try {
-      logger9.info("Creating wav2arkit_cpu worker...");
+      logger10.info("Creating wav2arkit_cpu worker...");
       this.worker = this.createWorker();
       const externalDataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${this.config.modelUrl}.data` : null;
-      logger9.info("Loading model in worker...", {
+      logger10.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         externalDataUrl,
         isIOS: isIOS()
@@ -7592,7 +7140,7 @@ var Wav2ArkitCpuWorker = class {
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger9.info("Wav2ArkitCpu worker loaded successfully", {
+      logger10.info("Wav2ArkitCpu worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -7677,7 +7225,7 @@ var Wav2ArkitCpuWorker = class {
           for (let f = 0; f < numFrames; f++) {
             blendshapes.push(flatBuffer.slice(f * numBlendshapes, (f + 1) * numBlendshapes));
           }
-          logger9.trace("Worker inference completed", {
+          logger10.trace("Worker inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             workerTimeMs: Math.round(result.inferenceTimeMs * 100) / 100,
             numFrames,
@@ -7707,12 +7255,12 @@ var Wav2ArkitCpuWorker = class {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger9.error("CRITICAL: Worker inference timed out \u2014 Wav2ArkitCpu worker is dead. Page reload required.", {
+            logger10.error("CRITICAL: Worker inference timed out \u2014 Wav2ArkitCpu worker is dead. Page reload required.", {
               backend: "wasm",
               timeoutMs: INFERENCE_TIMEOUT_MS2
             });
           } else {
-            logger9.error("Worker inference failed", { error: errMsg, backend: "wasm" });
+            logger10.error("Worker inference failed", { error: errMsg, backend: "wasm" });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -7749,39 +7297,39 @@ var Wav2ArkitCpuWorker = class {
   }
 };
 
-// src/inference/createLipSync.ts
-var logger10 = createLogger("createLipSync");
-function createLipSync(config) {
+// src/inference/createA2E.ts
+var logger11 = createLogger("createA2E");
+function createA2E(config) {
   const mode = config.mode ?? "auto";
   const fallbackOnError = config.fallbackOnError ?? true;
   let useCpu;
   if (mode === "cpu") {
     useCpu = true;
-    logger10.info("Forcing CPU lip sync model (wav2arkit_cpu)");
+    logger11.info("Forcing CPU A2E model (wav2arkit_cpu)");
   } else if (mode === "gpu") {
     useCpu = false;
-    logger10.info("Forcing GPU lip sync model (Wav2Vec2)");
+    logger11.info("Forcing GPU A2E model (Wav2Vec2)");
   } else {
-    useCpu = shouldUseCpuLipSync();
-    logger10.info("Auto-detected lip sync model", {
+    useCpu = shouldUseCpuA2E();
+    logger11.info("Auto-detected A2E model", {
       useCpu,
       isSafari: isSafari()
     });
   }
   if (useCpu) {
     if (config.unifiedWorker) {
-      logger10.info("Creating Wav2ArkitCpuUnifiedAdapter (404MB, WASM, shared unified worker)");
+      logger11.info("Creating Wav2ArkitCpuUnifiedAdapter (404MB, WASM, shared unified worker)");
       return new Wav2ArkitCpuUnifiedAdapter(config.unifiedWorker, {
         modelUrl: config.cpuModelUrl
       });
     }
     if (config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
-      logger10.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
+      logger11.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
       return new Wav2ArkitCpuWorker({
         modelUrl: config.cpuModelUrl
       });
     }
-    logger10.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
+    logger11.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
     return new Wav2ArkitCpuInference({
       modelUrl: config.cpuModelUrl
     });
@@ -7793,13 +7341,13 @@ function createLipSync(config) {
     numIdentityClasses: config.numIdentityClasses
   });
   if (fallbackOnError) {
-    logger10.info("Creating Wav2Vec2Inference with CPU fallback");
-    return new LipSyncWithFallback(gpuInstance, config);
+    logger11.info("Creating Wav2Vec2Inference with CPU fallback");
+    return new A2EWithFallback(gpuInstance, config);
   }
-  logger10.info("Creating Wav2Vec2Inference (no fallback)");
+  logger11.info("Creating Wav2Vec2Inference (no fallback)");
   return gpuInstance;
 }
-var LipSyncWithFallback = class {
+var A2EWithFallback = class {
   constructor(gpuInstance, config) {
     this.hasFallenBack = false;
     this.implementation = gpuInstance;
@@ -7808,6 +7356,9 @@ var LipSyncWithFallback = class {
   get modelId() {
     return this.implementation.modelId;
   }
+  get chunkSize() {
+    return this.implementation.chunkSize;
+  }
   get backend() {
     return this.implementation.backend;
   }
@@ -7822,7 +7373,7 @@ var LipSyncWithFallback = class {
     }
   }
   async fallbackToCpu(reason) {
-    logger10.warn("GPU model load failed, falling back to CPU model", { reason });
+    logger11.warn("GPU model load failed, falling back to CPU model", { reason });
     try {
       await this.implementation.dispose();
     } catch {
@@ -7831,17 +7382,17 @@ var LipSyncWithFallback = class {
       this.implementation = new Wav2ArkitCpuUnifiedAdapter(this.config.unifiedWorker, {
         modelUrl: this.config.cpuModelUrl
       });
-      logger10.info("Fallback to Wav2ArkitCpuUnifiedAdapter successful");
+      logger11.info("Fallback to Wav2ArkitCpuUnifiedAdapter successful");
     } else if (this.config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
       this.implementation = new Wav2ArkitCpuWorker({
         modelUrl: this.config.cpuModelUrl
       });
-      logger10.info("Fallback to Wav2ArkitCpuWorker successful");
+      logger11.info("Fallback to Wav2ArkitCpuWorker successful");
     } else {
       this.implementation = new Wav2ArkitCpuInference({
         modelUrl: this.config.cpuModelUrl
       });
-      logger10.info("Fallback to Wav2ArkitCpuInference successful");
+      logger11.info("Fallback to Wav2ArkitCpuInference successful");
     }
     this.hasFallenBack = true;
     return await this.implementation.load();
@@ -7854,8 +7405,124 @@ var LipSyncWithFallback = class {
   }
 };
 
+// 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/inference/SileroVADInference.ts
-var logger11 = createLogger("SileroVAD");
+var logger12 = createLogger("SileroVAD");
 var SileroVADInference = class {
   constructor(config) {
     this.session = null;
@@ -7929,23 +7596,23 @@ var SileroVADInference = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger11.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger12.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger11.info("ONNX Runtime loaded", { backend: this._backend });
+      logger12.info("ONNX Runtime loaded", { backend: this._backend });
       const cache = getModelCache();
       const modelUrl = this.config.modelUrl;
       const isCached = await cache.has(modelUrl);
       let modelBuffer;
       if (isCached) {
-        logger11.debug("Loading model from cache", { modelUrl });
+        logger12.debug("Loading model from cache", { modelUrl });
         modelBuffer = await cache.get(modelUrl);
       } else {
-        logger11.debug("Fetching and caching model", { modelUrl });
+        logger12.debug("Fetching and caching model", { modelUrl });
         modelBuffer = await fetchWithCache(modelUrl);
       }
-      logger11.debug("Creating ONNX session", {
+      logger12.debug("Creating ONNX session", {
         size: formatBytes(modelBuffer.byteLength),
         backend: this._backend
       });
@@ -7954,7 +7621,7 @@ var SileroVADInference = class {
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       this.reset();
       const loadTimeMs = performance.now() - startTime;
-      logger11.info("Model loaded successfully", {
+      logger12.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -8009,7 +7676,7 @@ var SileroVADInference = class {
           []
         );
       } catch (e) {
-        logger11.warn("BigInt64Array not available, using bigint array fallback", {
+        logger12.warn("BigInt64Array not available, using bigint array fallback", {
           error: e instanceof Error ? e.message : String(e)
         });
         this.srTensor = new this.ort.Tensor(
@@ -8115,7 +7782,7 @@ var SileroVADInference = class {
           this.preSpeechBuffer.shift();
         }
       }
-      logger11.trace("Skipping VAD inference - audio too quiet", {
+      logger12.trace("Skipping VAD inference - audio too quiet", {
         rms: Math.round(rms * 1e4) / 1e4,
         threshold: MIN_ENERGY_THRESHOLD
       });
@@ -8169,7 +7836,7 @@ var SileroVADInference = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger11.debug("Speech started with pre-speech buffer", {
+            logger12.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -8182,7 +7849,7 @@ var SileroVADInference = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger11.trace("VAD inference completed", {
+          logger12.trace("VAD inference completed", {
             probability: Math.round(probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100
@@ -8213,7 +7880,7 @@ var SileroVADInference = class {
             const oomError = new Error(
               `SileroVAD inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reducing concurrent model sessions or reloading the page.`
             );
-            logger11.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger12.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -8256,7 +7923,7 @@ var SileroVADInference = class {
 SileroVADInference.isWebGPUAvailable = isWebGPUAvailable;
 
 // src/inference/SileroVADWorker.ts
-var logger12 = createLogger("SileroVADWorker");
+var logger13 = createLogger("SileroVADWorker");
 var WASM_CDN_PATH5 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS3 = 1e4;
 var INFERENCE_TIMEOUT_MS3 = 1e3;
@@ -8534,7 +8201,7 @@ var SileroVADWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger12.error("Worker error", { error: error.message });
+      logger13.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -8610,9 +8277,9 @@ var SileroVADWorker = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger12.info("Creating VAD worker...");
+      logger13.info("Creating VAD worker...");
       this.worker = this.createWorker();
-      logger12.info("Loading model in worker...", {
+      logger13.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         sampleRate: this.config.sampleRate
       });
@@ -8628,7 +8295,7 @@ var SileroVADWorker = class {
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger12.info("VAD worker loaded successfully", {
+      logger13.info("VAD worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -8735,7 +8402,7 @@ var SileroVADWorker = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger12.debug("Speech started with pre-speech buffer", {
+            logger13.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -8748,7 +8415,7 @@ var SileroVADWorker = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger12.trace("VAD worker inference completed", {
+          logger13.trace("VAD worker inference completed", {
             probability: Math.round(result.probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
@@ -8816,44 +8483,44 @@ var SileroVADWorker = class {
 };
 
 // src/inference/createSileroVAD.ts
-var logger13 = createLogger("createSileroVAD");
+var logger14 = createLogger("createSileroVAD");
 function supportsVADWorker() {
   if (typeof Worker === "undefined") {
-    logger13.debug("Worker not supported: Worker constructor undefined");
+    logger14.debug("Worker not supported: Worker constructor undefined");
     return false;
   }
   if (typeof URL === "undefined" || typeof URL.createObjectURL === "undefined") {
-    logger13.debug("Worker not supported: URL.createObjectURL unavailable");
+    logger14.debug("Worker not supported: URL.createObjectURL unavailable");
     return false;
   }
   if (typeof Blob === "undefined") {
-    logger13.debug("Worker not supported: Blob constructor unavailable");
+    logger14.debug("Worker not supported: Blob constructor unavailable");
     return false;
   }
   return true;
 }
 function createSileroVAD(config) {
   if (config.unifiedWorker) {
-    logger13.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
+    logger14.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
     return new SileroVADUnifiedAdapter(config.unifiedWorker, config);
   }
   const fallbackOnError = config.fallbackOnError ?? true;
   let useWorker;
   if (config.useWorker !== void 0) {
     useWorker = config.useWorker;
-    logger13.debug("Worker preference explicitly set", { useWorker });
+    logger14.debug("Worker preference explicitly set", { useWorker });
   } else {
     const workerSupported = supportsVADWorker();
     const onMobile = isMobile();
     useWorker = workerSupported && !onMobile;
-    logger13.debug("Auto-detected Worker preference", {
+    logger14.debug("Auto-detected Worker preference", {
       useWorker,
       workerSupported,
       onMobile
     });
   }
   if (useWorker) {
-    logger13.info("Creating SileroVADWorker (off-main-thread)");
+    logger14.info("Creating SileroVADWorker (off-main-thread)");
     const worker = new SileroVADWorker({
       modelUrl: config.modelUrl,
       sampleRate: config.sampleRate,
@@ -8865,7 +8532,7 @@ function createSileroVAD(config) {
     }
     return worker;
   }
-  logger13.info("Creating SileroVADInference (main thread)");
+  logger14.info("Creating SileroVADInference (main thread)");
   return new SileroVADInference(config);
 }
 var VADWorkerWithFallback = class {
@@ -8891,7 +8558,7 @@ var VADWorkerWithFallback = class {
     try {
       return await this.implementation.load();
     } catch (error) {
-      logger13.warn("Worker load failed, falling back to main thread", {
+      logger14.warn("Worker load failed, falling back to main thread", {
         error: error instanceof Error ? error.message : String(error)
       });
       try {
@@ -8900,7 +8567,7 @@ var VADWorkerWithFallback = class {
       }
       this.implementation = new SileroVADInference(this.config);
       this.hasFallenBack = true;
-      logger13.info("Fallback to SileroVADInference successful");
+      logger14.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
     }
   }
@@ -8921,8 +8588,175 @@ var VADWorkerWithFallback = class {
   }
 };
 
+// src/inference/A2EOrchestrator.ts
+var logger15 = createLogger("A2EOrchestrator");
+var A2EOrchestrator = class {
+  constructor(config) {
+    this.a2e = null;
+    this.processor = null;
+    // Mic capture state (lightweight — no dependency on MicrophoneCapture class
+    // which requires an external EventEmitter. We do raw Web Audio here.)
+    this.stream = null;
+    this.audioContext = null;
+    this.scriptProcessor = null;
+    this.nativeSampleRate = 0;
+    this._isReady = false;
+    this._isStreaming = false;
+    this._backend = null;
+    this.disposed = false;
+    this.config = {
+      sampleRate: 16e3,
+      ...config
+    };
+  }
+  /** Latest blendshape weights from inference (null if none yet) */
+  get latestWeights() {
+    return this.processor?.latestFrame ?? null;
+  }
+  /** Whether the model is loaded and ready for inference */
+  get isReady() {
+    return this._isReady;
+  }
+  /** Whether mic is active and inference loop is running */
+  get isStreaming() {
+    return this._isStreaming;
+  }
+  /** Current backend type (webgpu, wasm, or null) */
+  get backend() {
+    return this._backend;
+  }
+  /**
+   * Load the A2E model and create the processor
+   */
+  async load() {
+    if (this.disposed) throw new Error("A2EOrchestrator has been disposed");
+    logger15.info("Loading A2E model...");
+    this.a2e = createA2E({
+      gpuModelUrl: this.config.gpuModelUrl,
+      gpuExternalDataUrl: this.config.gpuExternalDataUrl,
+      cpuModelUrl: this.config.cpuModelUrl ?? this.config.gpuModelUrl,
+      ...this.config.a2eConfig
+    });
+    const info = await this.a2e.load();
+    this._backend = info.backend;
+    this.processor = new A2EProcessor({
+      backend: this.a2e,
+      sampleRate: this.config.sampleRate,
+      chunkSize: this.config.chunkSize,
+      onFrame: this.config.onFrame,
+      onError: this.config.onError
+    });
+    this._isReady = true;
+    logger15.info("A2E model loaded", {
+      backend: info.backend,
+      loadTimeMs: info.loadTimeMs,
+      modelId: this.a2e.modelId
+    });
+    this.config.onReady?.();
+  }
+  /**
+   * Start mic capture and inference loop
+   */
+  async start() {
+    if (this.disposed) throw new Error("A2EOrchestrator has been disposed");
+    if (!this._isReady || !this.processor) throw new Error("Model not loaded. Call load() first.");
+    if (this._isStreaming) return;
+    try {
+      this.stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          sampleRate: { ideal: this.config.sampleRate },
+          channelCount: 1,
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      this.audioContext = new AudioContext({ sampleRate: this.config.sampleRate });
+      if (this.audioContext.state === "suspended") {
+        await this.audioContext.resume();
+      }
+      this.nativeSampleRate = this.audioContext.sampleRate;
+      const source = this.audioContext.createMediaStreamSource(this.stream);
+      this.scriptProcessor = this.audioContext.createScriptProcessor(4096, 1, 1);
+      this.scriptProcessor.onaudioprocess = (e) => {
+        if (!this._isStreaming || !this.processor) return;
+        const input = e.inputBuffer.getChannelData(0);
+        let samples;
+        if (this.nativeSampleRate !== this.config.sampleRate) {
+          const ratio = this.config.sampleRate / this.nativeSampleRate;
+          const newLen = Math.round(input.length * ratio);
+          samples = new Float32Array(newLen);
+          for (let i = 0; i < newLen; i++) {
+            const srcIdx = i / ratio;
+            const lo = Math.floor(srcIdx);
+            const hi = Math.min(lo + 1, input.length - 1);
+            const frac = srcIdx - lo;
+            samples[i] = input[lo] * (1 - frac) + input[hi] * frac;
+          }
+        } else {
+          samples = new Float32Array(input);
+        }
+        this.processor.pushAudio(samples);
+      };
+      source.connect(this.scriptProcessor);
+      this.scriptProcessor.connect(this.audioContext.destination);
+      this._isStreaming = true;
+      this.processor.startDrip();
+      logger15.info("Mic capture started", { sampleRate: this.nativeSampleRate });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      logger15.error("Failed to start mic capture", { error: error.message });
+      this.config.onError?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Stop mic capture and inference loop
+   */
+  stop() {
+    this._isStreaming = false;
+    if (this.processor) {
+      this.processor.stopDrip();
+      this.processor.reset();
+    }
+    if (this.scriptProcessor) {
+      this.scriptProcessor.disconnect();
+      this.scriptProcessor.onaudioprocess = null;
+      this.scriptProcessor = null;
+    }
+    if (this.stream) {
+      this.stream.getTracks().forEach((t) => t.stop());
+      this.stream = null;
+    }
+    if (this.audioContext) {
+      this.audioContext.close().catch(() => {
+      });
+      this.audioContext = null;
+    }
+    logger15.info("Mic capture stopped");
+  }
+  /**
+   * Dispose of all resources
+   */
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.stop();
+    if (this.processor) {
+      this.processor.dispose();
+      this.processor = null;
+    }
+    if (this.a2e) {
+      await this.a2e.dispose();
+      this.a2e = null;
+    }
+    this._isReady = false;
+    this._backend = null;
+  }
+};
+
 // src/inference/SafariSpeechRecognition.ts
-var logger14 = createLogger("SafariSpeech");
+var logger16 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {
   constructor(config = {}) {
     this.recognition = null;
@@ -8941,7 +8775,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       interimResults: config.interimResults ?? true,
       maxAlternatives: config.maxAlternatives ?? 1
     };
-    logger14.debug("SafariSpeechRecognition created", {
+    logger16.debug("SafariSpeechRecognition created", {
       language: this.config.language,
       continuous: this.config.continuous
     });
@@ -9002,7 +8836,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger14.warn("Already listening");
+      logger16.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -9032,7 +8866,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = true;
       this.startTime = performance.now();
       this.accumulatedText = "";
-      logger14.info("Speech recognition started", {
+      logger16.info("Speech recognition started", {
         language: this.config.language
       });
       span?.end();
@@ -9047,7 +8881,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async stop() {
     if (!this.isListening || !this.recognition) {
-      logger14.warn("Not currently listening");
+      logger16.warn("Not currently listening");
       return {
         text: this.accumulatedText,
         language: this.config.language,
@@ -9076,7 +8910,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     if (this.recognition && this.isListening) {
       this.recognition.abort();
       this.isListening = false;
-      logger14.info("Speech recognition aborted");
+      logger16.info("Speech recognition aborted");
     }
   }
   /**
@@ -9107,7 +8941,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     this.isListening = false;
     this.resultCallbacks = [];
     this.errorCallbacks = [];
-    logger14.debug("SafariSpeechRecognition disposed");
+    logger16.debug("SafariSpeechRecognition disposed");
   }
   /**
    * Set up event handlers for the recognition instance
@@ -9135,7 +8969,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
               confidence: alternative.confidence
             };
             this.emitResult(speechResult);
-            logger14.trace("Speech result", {
+            logger16.trace("Speech result", {
               text: text.substring(0, 50),
               isFinal,
               confidence: alternative.confidence
@@ -9145,12 +8979,12 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
         span?.end();
       } catch (error) {
         span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-        logger14.error("Error processing speech result", { error });
+        logger16.error("Error processing speech result", { error });
       }
     };
     this.recognition.onerror = (event) => {
       const error = new Error(`Speech recognition error: ${event.error} - ${event.message}`);
-      logger14.error("Speech recognition error", { error: event.error, message: event.message });
+      logger16.error("Speech recognition error", { error: event.error, message: event.message });
       this.emitError(error);
       if (this.stopRejecter) {
         this.stopRejecter(error);
@@ -9160,7 +8994,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     };
     this.recognition.onend = () => {
       this.isListening = false;
-      logger14.info("Speech recognition ended", {
+      logger16.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
         durationMs: performance.now() - this.startTime
       });
@@ -9177,13 +9011,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       }
     };
     this.recognition.onstart = () => {
-      logger14.debug("Speech recognition started by browser");
+      logger16.debug("Speech recognition started by browser");
     };
     this.recognition.onspeechstart = () => {
-      logger14.debug("Speech detected");
+      logger16.debug("Speech detected");
     };
     this.recognition.onspeechend = () => {
-      logger14.debug("Speech ended");
+      logger16.debug("Speech ended");
     };
   }
   /**
@@ -9194,7 +9028,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger14.error("Error in result callback", { error });
+        logger16.error("Error in result callback", { error });
       }
     }
   }
@@ -9206,7 +9040,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(error);
       } catch (callbackError) {
-        logger14.error("Error in error callback", { error: callbackError });
+        logger16.error("Error in error callback", { error: callbackError });
       }
     }
   }
@@ -9619,13 +9453,14 @@ var AgentCoreAdapter = class extends EventEmitter {
     if (!this.lam) {
       throw new Error("LAM must be initialized before pipeline");
     }
-    this.pipeline = new SyncedAudioPipeline({
+    this.pipeline = new FullFacePipeline({
       lam: this.lam,
       sampleRate: 16e3,
       chunkTargetMs: 200
     });
     await this.pipeline.initialize();
-    this.pipeline.on("frame_ready", (frame) => {
+    this.pipeline.on("full_frame_ready", (fullFrame) => {
+      const frame = fullFrame.blendshapes;
       this.emit("animation", {
         blendshapes: frame,
         get: (name) => {
@@ -9804,9 +9639,9 @@ var AgentCoreAdapter = class extends EventEmitter {
       });
     }
   }
-  // REMOVED: processAudioForAnimation() - now handled by SyncedAudioPipeline
+  // REMOVED: processAudioForAnimation() - now handled by FullFacePipeline
   // The pipeline manages audio scheduling, LAM inference, and frame synchronization
-  // Frames are emitted via pipeline.on('frame_ready') event (see initPipeline())
+  // Frames are emitted via pipeline.on('full_frame_ready') event (see initPipeline())
   /**
    * Detect voice activity using Silero VAD
    * Falls back to simple RMS if VAD not available