@omote/core 0.5.7 → 0.6.2

package/dist/index.js

@@ -56,11 +56,13 @@ __export(index_exports, {
   LOG_LEVEL_PRIORITY: () => LOG_LEVEL_PRIORITY,
   MODEL_LOAD_TIME_BUCKETS: () => MODEL_LOAD_TIME_BUCKETS,
   MetricNames: () => MetricNames,
+  MicLipSync: () => MicLipSync,
   MicrophoneCapture: () => MicrophoneCapture,
   ModelCache: () => ModelCache,
   OTLPExporter: () => OTLPExporter,
   OmoteTelemetry: () => OmoteTelemetry,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PlaybackPipeline: () => PlaybackPipeline,
   ProceduralLifeLayer: () => ProceduralLifeLayer,
   RingBuffer: () => RingBuffer,
   SafariSpeechRecognition: () => SafariSpeechRecognition,
@@ -71,10 +73,12 @@ __export(index_exports, {
   SileroVADUnifiedAdapter: () => SileroVADUnifiedAdapter,
   SileroVADWorker: () => SileroVADWorker,
   UnifiedInferenceWorker: () => UnifiedInferenceWorker,
+  VoicePipeline: () => VoicePipeline,
   Wav2ArkitCpuInference: () => Wav2ArkitCpuInference,
   Wav2ArkitCpuUnifiedAdapter: () => Wav2ArkitCpuUnifiedAdapter,
   Wav2ArkitCpuWorker: () => Wav2ArkitCpuWorker,
   Wav2Vec2Inference: () => Wav2Vec2Inference,
+  applyProfile: () => applyProfile,
   blendEmotions: () => blendEmotions,
   calculatePeak: () => calculatePeak,
   calculateRMS: () => calculateRMS,
@@ -867,12 +871,12 @@ var Logger = class _Logger {
 };
 var loggerCache = /* @__PURE__ */ new Map();
 function createLogger(module2) {
-  let logger17 = loggerCache.get(module2);
-  if (!logger17) {
-    logger17 = new Logger(module2);
-    loggerCache.set(module2, logger17);
+  let logger20 = loggerCache.get(module2);
+  if (!logger20) {
+    logger20 = new Logger(module2);
+    loggerCache.set(module2, logger20);
   }
-  return logger17;
+  return logger20;
 }
 var noopLogger = {
   module: "noop",
@@ -1168,6 +1172,24 @@ var A2EProcessor = class {
   }
 };
 
+// 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/telemetry/exporters/console.ts
 var ConsoleExporter = class {
   constructor(options = {}) {
@@ -3221,19 +3243,7 @@ _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;
-}
-
-// src/audio/FullFacePipeline.ts
-var logger4 = createLogger("FullFacePipeline");
+// src/audio/expressionProfile.ts
 var BLENDSHAPE_TO_GROUP = /* @__PURE__ */ new Map();
 for (const name of LAM_BLENDSHAPES) {
   if (name.startsWith("eye")) {
@@ -3252,6 +3262,24 @@ for (const name of LAM_BLENDSHAPES) {
     BLENDSHAPE_TO_GROUP.set(name, "tongue");
   }
 }
+function applyProfile(raw, profile) {
+  const scaled = new Float32Array(52);
+  for (let i = 0; i < 52; i++) {
+    const name = LAM_BLENDSHAPES[i];
+    let scaler;
+    if (profile.overrides && profile.overrides[name] !== void 0) {
+      scaler = profile.overrides[name];
+    } else {
+      const group = BLENDSHAPE_TO_GROUP.get(name);
+      scaler = group ? profile[group] ?? 1 : 1;
+    }
+    scaled[i] = Math.min(1, Math.max(0, raw[i] * scaler));
+  }
+  return scaled;
+}
+
+// src/audio/FullFacePipeline.ts
+var logger4 = createLogger("FullFacePipeline");
 var FullFacePipeline = class extends EventEmitter {
   constructor(options) {
     super();
@@ -3316,25 +3344,10 @@ var FullFacePipeline = class extends EventEmitter {
   /**
    * Apply ExpressionProfile scaling to raw A2E blendshapes.
    *
-   * For each blendshape:
-   * 1. If an override exists for the blendshape name, use override as scaler
-   * 2. Otherwise, use the group scaler (default 1.0)
-   * 3. Clamp result to [0, 1]
+   * Delegates to the standalone applyProfile() utility from expressionProfile.ts.
    */
   applyProfile(raw) {
-    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;
+    return applyProfile(raw, this.profile);
   }
   /**
    * Start a new playback session
@@ -3519,6 +3532,329 @@ var FullFacePipeline = class extends EventEmitter {
   }
 };
 
+// src/audio/PlaybackPipeline.ts
+var logger5 = createLogger("PlaybackPipeline");
+var PlaybackPipeline = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.config = config;
+    this._state = "idle";
+    this.playbackStarted = false;
+    this.monitorInterval = null;
+    this.frameAnimationId = null;
+    // Stale frame detection
+    this.lastNewFrameTime = 0;
+    this.lastKnownLamFrame = null;
+    this.staleWarningEmitted = false;
+    // Diagnostic counter
+    this.frameLoopCount = 0;
+    this.neutralTransitionFrame = null;
+    this.neutralTransitionStart = 0;
+    this.neutralAnimationId = null;
+    // Current frame refs
+    this._currentFrame = null;
+    this._currentRawFrame = null;
+    this.sampleRate = config.sampleRate ?? 16e3;
+    this.profile = config.profile ?? {};
+    this.staleThresholdMs = config.staleThresholdMs ?? 2e3;
+    this.neutralTransitionEnabled = config.neutralTransitionEnabled ?? false;
+    this.neutralTransitionMs = config.neutralTransitionMs ?? 250;
+    const isCpuModel = config.lam.modelId === "wav2arkit_cpu";
+    const chunkSize = config.chunkSize ?? config.lam.chunkSize ?? 16e3;
+    const chunkAccumulationMs = chunkSize / this.sampleRate * 1e3;
+    const inferenceEstimateMs = isCpuModel ? 300 : config.lam.backend === "wasm" ? 250 : 80;
+    const marginMs = 100;
+    const autoDelay = Math.ceil(chunkAccumulationMs + inferenceEstimateMs + marginMs);
+    const audioDelayMs = config.audioDelayMs ?? autoDelay;
+    logger5.info("PlaybackPipeline config", {
+      chunkSize,
+      audioDelayMs,
+      autoDelay,
+      backend: config.lam.backend,
+      modelId: config.lam.modelId,
+      neutralTransitionEnabled: this.neutralTransitionEnabled
+    });
+    this.scheduler = new AudioScheduler({
+      sampleRate: this.sampleRate,
+      initialLookaheadSec: audioDelayMs / 1e3
+    });
+    this.coalescer = new AudioChunkCoalescer({
+      sampleRate: this.sampleRate,
+      targetDurationMs: config.chunkTargetMs ?? 200
+    });
+    this.processor = new A2EProcessor({
+      backend: config.lam,
+      sampleRate: this.sampleRate,
+      chunkSize,
+      identityIndex: config.identityIndex,
+      onError: (error) => {
+        logger5.error("A2E inference error", { message: error.message, stack: error.stack });
+        this.emit("error", error);
+      }
+    });
+  }
+  /** Current pipeline state */
+  get state() {
+    return this._state;
+  }
+  /** Current scaled blendshapes (updated in-place for perf) */
+  get currentFrame() {
+    return this._currentFrame;
+  }
+  /** Raw A2E blendshapes (before profile scaling) */
+  get currentRawFrame() {
+    return this._currentRawFrame;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /** Initialize AudioContext (lazy, call after user gesture) */
+  async initialize() {
+    await this.scheduler.initialize();
+  }
+  /** Update ExpressionProfile at runtime */
+  setProfile(profile) {
+    this.profile = profile;
+  }
+  // ---------------------------------------------------------------------------
+  // Async mode (streaming TTS)
+  // ---------------------------------------------------------------------------
+  /**
+   * Start a new playback session.
+   * Idempotent — calling during playback resets cleanly without emitting
+   * spurious playback:complete.
+   */
+  start() {
+    this.stopInternal(false);
+    this.scheduler.reset();
+    this.coalescer.reset();
+    this.processor.reset();
+    this.playbackStarted = false;
+    this.lastNewFrameTime = 0;
+    this.lastKnownLamFrame = null;
+    this.staleWarningEmitted = false;
+    this.frameLoopCount = 0;
+    this._currentFrame = null;
+    this._currentRawFrame = null;
+    this.cancelNeutralTransition();
+    this.scheduler.warmup();
+    this.startFrameLoop();
+    this.startMonitoring();
+    this.setState("playing");
+  }
+  /** Feed a streaming audio chunk (PCM16 Uint8Array) */
+  async onAudioChunk(chunk) {
+    const combined = this.coalescer.add(chunk);
+    if (!combined) return;
+    const float32 = pcm16ToFloat32(combined);
+    const scheduleTime = await this.scheduler.schedule(float32);
+    if (!this.playbackStarted) {
+      this.playbackStarted = true;
+      this.emit("playback:start", { time: scheduleTime });
+      this.emit("playback_start", scheduleTime);
+    }
+    this.processor.pushAudio(float32, scheduleTime);
+  }
+  /** Signal end of audio stream (flushes remaining audio) */
+  async end() {
+    const remaining = this.coalescer.flush();
+    if (remaining) {
+      const chunk = new Uint8Array(remaining);
+      await this.onAudioChunk(chunk);
+    }
+    await this.processor.flush();
+  }
+  // ---------------------------------------------------------------------------
+  // Sync mode (full buffer)
+  // ---------------------------------------------------------------------------
+  /**
+   * Feed a complete audio buffer. Chunks into 200ms pieces, schedules each
+   * for playback, runs A2E inference, then waits for completion.
+   */
+  async feedBuffer(audio) {
+    const float32 = audio instanceof Float32Array ? audio : pcm16ToFloat32(audio);
+    this.start();
+    const chunkSamples = Math.floor(this.sampleRate * 0.2);
+    for (let i = 0; i < float32.length; i += chunkSamples) {
+      const chunk = float32.subarray(i, Math.min(i + chunkSamples, float32.length));
+      const scheduleTime = await this.scheduler.schedule(chunk);
+      this.processor.pushAudio(chunk, scheduleTime);
+      if (!this.playbackStarted) {
+        this.playbackStarted = true;
+        this.emit("playback:start", { time: scheduleTime });
+        this.emit("playback_start", scheduleTime);
+      }
+    }
+    await this.processor.flush();
+    return new Promise((resolve) => {
+      const unsub = this.on("playback:complete", () => {
+        unsub();
+        resolve();
+      });
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Control
+  // ---------------------------------------------------------------------------
+  /** Stop playback immediately with fade-out */
+  async stop(fadeOutMs = 50) {
+    this.setState("stopping");
+    this.stopInternal(true);
+    await this.scheduler.cancelAll(fadeOutMs);
+    this.coalescer.reset();
+    this.processor.reset();
+    this.playbackStarted = false;
+    this._currentFrame = null;
+    this._currentRawFrame = null;
+    this.emit("playback:stop", void 0);
+    this.setState("idle");
+  }
+  /** Cleanup all resources */
+  dispose() {
+    this.stopInternal(true);
+    this.cancelNeutralTransition();
+    this.scheduler.dispose();
+    this.coalescer.reset();
+    this.processor.dispose();
+    this._state = "idle";
+  }
+  /** Get pipeline debug state */
+  getDebugState() {
+    return {
+      state: this._state,
+      playbackStarted: this.playbackStarted,
+      coalescerFill: this.coalescer.fillLevel,
+      processorFill: this.processor.fillLevel,
+      queuedFrames: this.processor.queuedFrameCount,
+      currentTime: this.scheduler.getCurrentTime(),
+      playbackEndTime: this.scheduler.getPlaybackEndTime()
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: Frame loop
+  // ---------------------------------------------------------------------------
+  startFrameLoop() {
+    const updateFrame = () => {
+      this.frameLoopCount++;
+      const currentTime = this.scheduler.getCurrentTime();
+      const lamFrame = this.processor.getFrameForTime(currentTime);
+      if (lamFrame && lamFrame !== this.lastKnownLamFrame) {
+        this.lastNewFrameTime = performance.now();
+        this.lastKnownLamFrame = lamFrame;
+        this.staleWarningEmitted = false;
+      }
+      if (this.playbackStarted && this.lastNewFrameTime > 0 && performance.now() - this.lastNewFrameTime > this.staleThresholdMs) {
+        if (!this.staleWarningEmitted) {
+          this.staleWarningEmitted = true;
+          logger5.warn("A2E stalled \u2014 no new inference frames", {
+            staleDurationMs: Math.round(performance.now() - this.lastNewFrameTime),
+            queuedFrames: this.processor.queuedFrameCount
+          });
+        }
+      }
+      if (lamFrame) {
+        const scaled = applyProfile(lamFrame, this.profile);
+        this._currentFrame = scaled;
+        this._currentRawFrame = lamFrame;
+        const fullFrame = {
+          blendshapes: scaled,
+          rawBlendshapes: lamFrame,
+          timestamp: currentTime
+        };
+        this.emit("frame", fullFrame);
+        this.emit("frame:raw", lamFrame);
+        this.emit("full_frame_ready", fullFrame);
+        this.emit("lam_frame_ready", lamFrame);
+      }
+      this.frameAnimationId = requestAnimationFrame(updateFrame);
+    };
+    this.frameAnimationId = requestAnimationFrame(updateFrame);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: Playback monitoring
+  // ---------------------------------------------------------------------------
+  startMonitoring() {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+    }
+    this.monitorInterval = setInterval(() => {
+      if (this.scheduler.isComplete() && this.processor.queuedFrameCount === 0) {
+        this.onPlaybackComplete();
+      }
+    }, 100);
+  }
+  onPlaybackComplete() {
+    this.stopInternal(false);
+    this.playbackStarted = false;
+    this.emit("playback:complete", void 0);
+    this.emit("playback_complete", void 0);
+    if (this.neutralTransitionEnabled && this._currentFrame) {
+      this.startNeutralTransition(this._currentFrame);
+    } else {
+      this.setState("idle");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: Neutral transition (opt-in)
+  // ---------------------------------------------------------------------------
+  startNeutralTransition(fromFrame) {
+    this.neutralTransitionFrame = new Float32Array(fromFrame);
+    this.neutralTransitionStart = performance.now();
+    const animate = () => {
+      const elapsed = performance.now() - this.neutralTransitionStart;
+      const t = Math.min(1, elapsed / this.neutralTransitionMs);
+      const eased = 1 - Math.pow(1 - t, 3);
+      const blendshapes = new Float32Array(52);
+      for (let i = 0; i < 52; i++) {
+        blendshapes[i] = this.neutralTransitionFrame[i] * (1 - eased);
+      }
+      this._currentFrame = blendshapes;
+      const frame = {
+        blendshapes,
+        rawBlendshapes: blendshapes,
+        // raw = scaled during transition
+        timestamp: performance.now() / 1e3
+      };
+      this.emit("frame", frame);
+      this.emit("full_frame_ready", frame);
+      if (t >= 1) {
+        this.neutralTransitionFrame = null;
+        this._currentFrame = null;
+        this._currentRawFrame = null;
+        this.setState("idle");
+        return;
+      }
+      this.neutralAnimationId = requestAnimationFrame(animate);
+    };
+    this.neutralAnimationId = requestAnimationFrame(animate);
+  }
+  cancelNeutralTransition() {
+    if (this.neutralAnimationId) {
+      cancelAnimationFrame(this.neutralAnimationId);
+      this.neutralAnimationId = null;
+    }
+    this.neutralTransitionFrame = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: Helpers
+  // ---------------------------------------------------------------------------
+  stopInternal(emitEvents) {
+    if (this.monitorInterval) {
+      clearInterval(this.monitorInterval);
+      this.monitorInterval = null;
+    }
+    if (this.frameAnimationId) {
+      cancelAnimationFrame(this.frameAnimationId);
+      this.frameAnimationId = null;
+    }
+  }
+  setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    this.emit("state", state);
+  }
+};
+
 // src/audio/InterruptionHandler.ts
 var InterruptionHandler = class extends EventEmitter {
   constructor(config = {}) {
@@ -3906,7 +4242,7 @@ function ctcGreedyDecode(logits, seqLen, vocabSize, tokenMap) {
 }
 
 // src/inference/SenseVoiceInference.ts
-var logger5 = createLogger("SenseVoice");
+var logger6 = createLogger("SenseVoice");
 var _SenseVoiceInference = class _SenseVoiceInference {
   constructor(config) {
     this.session = null;
@@ -3959,26 +4295,26 @@ var _SenseVoiceInference = class _SenseVoiceInference {
       "model.backend_requested": this.config.backend
     });
     try {
-      logger5.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger6.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger5.info("ONNX Runtime loaded", { backend: this._backend });
-      logger5.debug("Fetching tokens vocabulary", { tokensUrl: this.config.tokensUrl });
+      logger6.info("ONNX Runtime loaded", { backend: this._backend });
+      logger6.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);
-      logger5.debug("Tokens loaded", { vocabSize: this.tokenMap.size });
+      logger6.debug("Tokens loaded", { vocabSize: this.tokenMap.size });
       const sessionOptions = getSessionOptions(this._backend);
       if (this._backend === "webgpu") {
         sessionOptions.graphOptimizationLevel = "basic";
       }
       let isCached = false;
       if (isIOS()) {
-        logger5.info("iOS: passing model URL directly to ORT (low-memory path)", {
+        logger6.info("iOS: passing model URL directly to ORT (low-memory path)", {
           modelUrl: this.config.modelUrl
         });
         this.session = await withTimeout(
@@ -3991,14 +4327,14 @@ var _SenseVoiceInference = class _SenseVoiceInference {
         isCached = await cache.has(this.config.modelUrl);
         let modelBuffer;
         if (isCached) {
-          logger5.debug("Loading model from cache", { modelUrl: this.config.modelUrl });
+          logger6.debug("Loading model from cache", { modelUrl: this.config.modelUrl });
           modelBuffer = await cache.get(this.config.modelUrl);
           onProgress?.(modelBuffer.byteLength, modelBuffer.byteLength);
         } else {
-          logger5.debug("Fetching and caching model", { modelUrl: this.config.modelUrl });
+          logger6.debug("Fetching and caching model", { modelUrl: this.config.modelUrl });
           modelBuffer = await fetchWithCache(this.config.modelUrl, onProgress);
         }
-        logger5.debug("Creating ONNX session", {
+        logger6.debug("Creating ONNX session", {
           size: formatBytes(modelBuffer.byteLength),
           backend: this._backend
         });
@@ -4011,15 +4347,15 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const cmvn = parseCMVNFromMetadata(metadata.neg_mean, metadata.inv_stddev);
           this.negMean = cmvn.negMean;
           this.invStddev = cmvn.invStddev;
-          logger5.debug("CMVN loaded from model metadata", { dim: this.negMean.length });
+          logger6.debug("CMVN loaded from model metadata", { dim: this.negMean.length });
         } else {
-          logger5.warn("CMVN not found in model metadata \u2014 features will not be normalized");
+          logger6.warn("CMVN not found in model metadata \u2014 features will not be normalized");
         }
       } catch (cmvnErr) {
-        logger5.warn("Failed to read CMVN from model metadata", { error: cmvnErr });
+        logger6.warn("Failed to read CMVN from model metadata", { error: cmvnErr });
       }
       const loadTimeMs = performance.now() - startTime;
-      logger5.info("SenseVoice model loaded", {
+      logger6.info("SenseVoice model loaded", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         vocabSize: this.tokenMap.size,
@@ -4130,7 +4466,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const vocabSize = logitsDims[2];
           const decoded = ctcGreedyDecode(logitsData, seqLen, vocabSize, this.tokenMap);
           const inferenceTimeMs = performance.now() - startTime;
-          logger5.trace("Transcription complete", {
+          logger6.trace("Transcription complete", {
             text: decoded.text.substring(0, 50),
             language: decoded.language,
             emotion: decoded.emotion,
@@ -4168,7 +4504,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger5.error("CRITICAL: Inference session timed out \u2014 SenseVoice is dead. Page reload required.", {
+            logger6.error("CRITICAL: Inference session timed out \u2014 SenseVoice is dead. Page reload required.", {
               backend: this._backend,
               timeoutMs: _SenseVoiceInference.INFERENCE_TIMEOUT_MS
             });
@@ -4176,7 +4512,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.`
             );
-            logger5.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger6.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -4189,7 +4525,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
             reject(oomError);
             return;
           } else {
-            logger5.error("Inference failed", { error: errMsg, backend: this._backend });
+            logger6.error("Inference failed", { error: errMsg, backend: this._backend });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -4218,7 +4554,7 @@ _SenseVoiceInference.INFERENCE_TIMEOUT_MS = 1e4;
 var SenseVoiceInference = _SenseVoiceInference;
 
 // src/inference/SenseVoiceWorker.ts
-var logger6 = createLogger("SenseVoiceWorker");
+var logger7 = createLogger("SenseVoiceWorker");
 var WASM_CDN_PATH2 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS = 3e5;
 var INFERENCE_TIMEOUT_MS = 1e4;
@@ -4957,7 +5293,7 @@ var SenseVoiceWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger6.error("Worker error", { error: error.message });
+      logger7.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -5037,9 +5373,9 @@ var SenseVoiceWorker = class {
       "model.language": this.config.language
     });
     try {
-      logger6.info("Creating SenseVoice worker...");
+      logger7.info("Creating SenseVoice worker...");
       this.worker = this.createWorker();
-      logger6.info("Loading model in worker...", {
+      logger7.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         tokensUrl: this.config.tokensUrl,
         language: this.config.language,
@@ -5061,7 +5397,7 @@ var SenseVoiceWorker = class {
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
       onProgress?.(1, 1);
-      logger6.info("SenseVoice worker loaded successfully", {
+      logger7.info("SenseVoice worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -5140,7 +5476,7 @@ var SenseVoiceWorker = class {
             INFERENCE_TIMEOUT_MS
           );
           const totalTimeMs = performance.now() - startTime;
-          logger6.trace("Worker transcription complete", {
+          logger7.trace("Worker transcription complete", {
             text: result.text.substring(0, 50),
             language: result.language,
             emotion: result.emotion,
@@ -5176,11 +5512,11 @@ var SenseVoiceWorker = class {
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
-            logger6.error("CRITICAL: Worker inference timed out \u2014 SenseVoice worker is dead. Page reload required.", {
+            logger7.error("CRITICAL: Worker inference timed out \u2014 SenseVoice worker is dead. Page reload required.", {
               timeoutMs: INFERENCE_TIMEOUT_MS
             });
           } else {
-            logger6.error("Worker inference failed", { error: errMsg });
+            logger7.error("Worker inference failed", { error: errMsg });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -5218,7 +5554,7 @@ var SenseVoiceWorker = class {
 };
 
 // src/inference/UnifiedInferenceWorker.ts
-var logger7 = createLogger("UnifiedInferenceWorker");
+var logger8 = createLogger("UnifiedInferenceWorker");
 var WASM_CDN_PATH3 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var INIT_TIMEOUT_MS = 6e4;
 var SV_LOAD_TIMEOUT_MS = 3e5;
@@ -5920,7 +6256,7 @@ var UnifiedInferenceWorker = class {
     const telemetry = getTelemetry();
     const span = telemetry?.startSpan("UnifiedInferenceWorker.init");
     try {
-      logger7.info("Creating unified inference worker...");
+      logger8.info("Creating unified inference worker...");
       this.worker = this.createWorker();
       await this.sendMessage(
         { type: "init", wasmPaths: WASM_CDN_PATH3, isIOS: isIOS() },
@@ -5929,7 +6265,7 @@ var UnifiedInferenceWorker = class {
       );
       this.initialized = true;
       const loadTimeMs = performance.now() - startTime;
-      logger7.info("Unified worker initialized", { loadTimeMs: Math.round(loadTimeMs) });
+      logger8.info("Unified worker initialized", { loadTimeMs: Math.round(loadTimeMs) });
       span?.setAttributes({ "worker.init_time_ms": loadTimeMs });
       span?.end();
     } catch (error) {
@@ -6103,7 +6439,7 @@ var UnifiedInferenceWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger7.error("Unified worker error", { error: error.message });
+      logger8.error("Unified worker error", { error: error.message });
       this.rejectAllPending(`Worker error: ${error.message}`);
     };
     return worker;
@@ -6117,7 +6453,7 @@ var UnifiedInferenceWorker = class {
         this.pendingRequests.delete(requestId);
         pending.reject(new Error(data.error));
       } else {
-        logger7.error("Worker broadcast error", { error: data.error });
+        logger8.error("Worker broadcast error", { error: data.error });
         this.rejectAllPending(data.error);
       }
       return;
@@ -6139,7 +6475,7 @@ var UnifiedInferenceWorker = class {
       const timeout = setTimeout(() => {
         this.pendingRequests.delete(requestId);
         this.poisoned = true;
-        logger7.error("CRITICAL: Worker operation timed out \u2014 worker is dead", {
+        logger8.error("CRITICAL: Worker operation timed out \u2014 worker is dead", {
           type: message.type,
           timeoutMs
         });
@@ -6205,7 +6541,7 @@ var SenseVoiceUnifiedAdapter = class {
       });
       this._isLoaded = true;
       onProgress?.(1, 1);
-      logger7.info("SenseVoice loaded via unified worker", {
+      logger8.info("SenseVoice loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs),
         vocabSize: result.vocabSize
@@ -6270,7 +6606,7 @@ var Wav2ArkitCpuUnifiedAdapter = class {
         externalDataUrl: externalDataUrl || null
       });
       this._isLoaded = true;
-      logger7.info("Wav2ArkitCpu loaded via unified worker", {
+      logger8.info("Wav2ArkitCpu loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs)
       });
@@ -6376,7 +6712,7 @@ var SileroVADUnifiedAdapter = class {
         sampleRate: this.config.sampleRate
       });
       this._isLoaded = true;
-      logger7.info("SileroVAD loaded via unified worker", {
+      logger8.info("SileroVAD loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(result.loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -6457,10 +6793,10 @@ var SileroVADUnifiedAdapter = class {
 };
 
 // src/inference/createSenseVoice.ts
-var logger8 = createLogger("createSenseVoice");
+var logger9 = createLogger("createSenseVoice");
 function createSenseVoice(config) {
   if (config.unifiedWorker) {
-    logger8.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
+    logger9.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
     return new SenseVoiceUnifiedAdapter(config.unifiedWorker, {
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6473,7 +6809,7 @@ function createSenseVoice(config) {
     if (!SenseVoiceWorker.isSupported()) {
       throw new Error("Web Workers are not supported in this environment");
     }
-    logger8.info("Creating SenseVoiceWorker (off-main-thread)");
+    logger9.info("Creating SenseVoiceWorker (off-main-thread)");
     return new SenseVoiceWorker({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6482,7 +6818,7 @@ function createSenseVoice(config) {
     });
   }
   if (useWorker === false) {
-    logger8.info("Creating SenseVoiceInference (main thread)");
+    logger9.info("Creating SenseVoiceInference (main thread)");
     return new SenseVoiceInference({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6491,7 +6827,7 @@ function createSenseVoice(config) {
     });
   }
   if (SenseVoiceWorker.isSupported() && !isIOS()) {
-    logger8.info("Auto-detected: creating SenseVoiceWorker (off-main-thread)");
+    logger9.info("Auto-detected: creating SenseVoiceWorker (off-main-thread)");
     return new SenseVoiceWorker({
       modelUrl: config.modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6499,7 +6835,7 @@ function createSenseVoice(config) {
       textNorm: config.textNorm
     });
   }
-  logger8.info("Auto-detected: creating SenseVoiceInference (main thread)", {
+  logger9.info("Auto-detected: creating SenseVoiceInference (main thread)", {
     reason: isIOS() ? "iOS (shared ORT instance)" : "Worker unsupported"
   });
   return new SenseVoiceInference({
@@ -6511,7 +6847,7 @@ function createSenseVoice(config) {
 }
 
 // src/inference/Wav2ArkitCpuInference.ts
-var logger9 = createLogger("Wav2ArkitCpu");
+var logger10 = createLogger("Wav2ArkitCpu");
 var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
   constructor(config) {
     this.modelId = "wav2arkit_cpu";
@@ -6553,16 +6889,16 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
     });
     try {
       const preference = this.config.backend || "wasm";
-      logger9.info("Loading ONNX Runtime...", { preference });
+      logger10.info("Loading ONNX Runtime...", { preference });
       const { ort, backend } = await getOnnxRuntimeForPreference(preference);
       this.ort = ort;
       this._backend = backend;
-      logger9.info("ONNX Runtime loaded", { backend: this._backend });
+      logger10.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()) {
-        logger9.info("iOS: passing model URLs directly to ORT (low-memory path)", {
+        logger10.info("iOS: passing model URLs directly to ORT (low-memory path)", {
           modelUrl,
           dataUrl
         });
@@ -6584,15 +6920,15 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         const isCached = await cache.has(modelUrl);
         let modelBuffer;
         if (isCached) {
-          logger9.debug("Loading model from cache", { modelUrl });
+          logger10.debug("Loading model from cache", { modelUrl });
           modelBuffer = await cache.get(modelUrl);
           if (!modelBuffer) {
-            logger9.warn("Cache corruption detected, clearing and retrying", { modelUrl });
+            logger10.warn("Cache corruption detected, clearing and retrying", { modelUrl });
             await cache.delete(modelUrl);
             modelBuffer = await fetchWithCache(modelUrl);
           }
         } else {
-          logger9.debug("Fetching and caching model graph", { modelUrl });
+          logger10.debug("Fetching and caching model graph", { modelUrl });
           modelBuffer = await fetchWithCache(modelUrl);
         }
         if (!modelBuffer) {
@@ -6603,31 +6939,31 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
           try {
             const isDataCached = await cache.has(dataUrl);
             if (isDataCached) {
-              logger9.debug("Loading external data from cache", { dataUrl });
+              logger10.debug("Loading external data from cache", { dataUrl });
               externalDataBuffer = await cache.get(dataUrl);
               if (!externalDataBuffer) {
-                logger9.warn("Cache corruption for external data, retrying", { dataUrl });
+                logger10.warn("Cache corruption for external data, retrying", { dataUrl });
                 await cache.delete(dataUrl);
                 externalDataBuffer = await fetchWithCache(dataUrl);
               }
             } else {
-              logger9.info("Fetching external model data", {
+              logger10.info("Fetching external model data", {
                 dataUrl,
                 note: "This may be a large download (400MB+)"
               });
               externalDataBuffer = await fetchWithCache(dataUrl);
             }
-            logger9.info("External data loaded", {
+            logger10.info("External data loaded", {
               size: formatBytes(externalDataBuffer.byteLength)
             });
           } catch (err) {
-            logger9.debug("No external data file found (single-file model)", {
+            logger10.debug("No external data file found (single-file model)", {
               dataUrl,
               error: err.message
             });
           }
         }
-        logger9.debug("Creating ONNX session", {
+        logger10.debug("Creating ONNX session", {
           graphSize: formatBytes(modelBuffer.byteLength),
           externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
           backend: this._backend
@@ -6643,7 +6979,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
       }
       const loadTimeMs = performance.now() - startTime;
-      logger9.info("Model loaded successfully", {
+      logger10.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         inputs: this.session.inputNames,
@@ -6659,12 +6995,12 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
         model: "wav2arkit_cpu",
         backend: this._backend
       });
-      logger9.debug("Running warmup inference");
+      logger10.debug("Running warmup inference");
       const warmupStart = performance.now();
       const silentAudio = new Float32Array(16e3);
       await this.infer(silentAudio);
       const warmupTimeMs = performance.now() - warmupStart;
-      logger9.info("Warmup inference complete", {
+      logger10.info("Warmup inference complete", {
         warmupTimeMs: Math.round(warmupTimeMs),
         backend: this._backend
       });
@@ -6751,7 +7087,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
             const symmetrized = symmetrizeBlendshapes(rawFrame);
             blendshapes.push(symmetrized);
           }
-          logger9.trace("Inference completed", {
+          logger10.trace("Inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             numFrames,
             inputSamples
@@ -6779,7 +7115,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger9.error("CRITICAL: Inference session timed out \u2014 Wav2ArkitCpu is dead. Page reload required.", {
+            logger10.error("CRITICAL: Inference session timed out \u2014 Wav2ArkitCpu is dead. Page reload required.", {
               backend: this._backend,
               timeoutMs: _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS
             });
@@ -6787,7 +7123,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.`
             );
-            logger9.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger10.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -6800,7 +7136,7 @@ var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
             reject(oomError);
             return;
           } else {
-            logger9.error("Inference failed", { error: errMsg, backend: this._backend });
+            logger10.error("Inference failed", { error: errMsg, backend: this._backend });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -6827,7 +7163,7 @@ _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS = 5e3;
 var Wav2ArkitCpuInference = _Wav2ArkitCpuInference;
 
 // src/inference/Wav2ArkitCpuWorker.ts
-var logger10 = createLogger("Wav2ArkitCpuWorker");
+var logger11 = createLogger("Wav2ArkitCpuWorker");
 var WASM_CDN_PATH4 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS2 = 42e4;
 var INFERENCE_TIMEOUT_MS2 = 5e3;
@@ -7114,7 +7450,7 @@ var Wav2ArkitCpuWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger10.error("Worker error", { error: error.message });
+      logger11.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -7190,10 +7526,10 @@ var Wav2ArkitCpuWorker = class {
       "model.backend_requested": "wasm"
     });
     try {
-      logger10.info("Creating wav2arkit_cpu worker...");
+      logger11.info("Creating wav2arkit_cpu worker...");
       this.worker = this.createWorker();
       const externalDataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${this.config.modelUrl}.data` : null;
-      logger10.info("Loading model in worker...", {
+      logger11.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         externalDataUrl,
         isIOS: isIOS()
@@ -7211,7 +7547,7 @@ var Wav2ArkitCpuWorker = class {
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger10.info("Wav2ArkitCpu worker loaded successfully", {
+      logger11.info("Wav2ArkitCpu worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -7296,7 +7632,7 @@ var Wav2ArkitCpuWorker = class {
           for (let f = 0; f < numFrames; f++) {
             blendshapes.push(flatBuffer.slice(f * numBlendshapes, (f + 1) * numBlendshapes));
           }
-          logger10.trace("Worker inference completed", {
+          logger11.trace("Worker inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             workerTimeMs: Math.round(result.inferenceTimeMs * 100) / 100,
             numFrames,
@@ -7326,12 +7662,12 @@ var Wav2ArkitCpuWorker = class {
           const errMsg = err instanceof Error ? err.message : String(err);
           if (errMsg.includes("timed out")) {
             this.poisoned = true;
-            logger10.error("CRITICAL: Worker inference timed out \u2014 Wav2ArkitCpu worker is dead. Page reload required.", {
+            logger11.error("CRITICAL: Worker inference timed out \u2014 Wav2ArkitCpu worker is dead. Page reload required.", {
               backend: "wasm",
               timeoutMs: INFERENCE_TIMEOUT_MS2
             });
           } else {
-            logger10.error("Worker inference failed", { error: errMsg, backend: "wasm" });
+            logger11.error("Worker inference failed", { error: errMsg, backend: "wasm" });
           }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
@@ -7369,38 +7705,38 @@ var Wav2ArkitCpuWorker = class {
 };
 
 // src/inference/createA2E.ts
-var logger11 = createLogger("createA2E");
+var logger12 = createLogger("createA2E");
 function createA2E(config) {
   const mode = config.mode ?? "auto";
   const fallbackOnError = config.fallbackOnError ?? true;
   let useCpu;
   if (mode === "cpu") {
     useCpu = true;
-    logger11.info("Forcing CPU A2E model (wav2arkit_cpu)");
+    logger12.info("Forcing CPU A2E model (wav2arkit_cpu)");
   } else if (mode === "gpu") {
     useCpu = false;
-    logger11.info("Forcing GPU A2E model (Wav2Vec2)");
+    logger12.info("Forcing GPU A2E model (Wav2Vec2)");
   } else {
     useCpu = shouldUseCpuA2E();
-    logger11.info("Auto-detected A2E model", {
+    logger12.info("Auto-detected A2E model", {
       useCpu,
       isSafari: isSafari()
     });
   }
   if (useCpu) {
     if (config.unifiedWorker) {
-      logger11.info("Creating Wav2ArkitCpuUnifiedAdapter (404MB, WASM, shared unified worker)");
+      logger12.info("Creating Wav2ArkitCpuUnifiedAdapter (404MB, WASM, shared unified worker)");
       return new Wav2ArkitCpuUnifiedAdapter(config.unifiedWorker, {
         modelUrl: config.cpuModelUrl
       });
     }
     if (config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
-      logger11.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
+      logger12.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
       return new Wav2ArkitCpuWorker({
         modelUrl: config.cpuModelUrl
       });
     }
-    logger11.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
+    logger12.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
     return new Wav2ArkitCpuInference({
       modelUrl: config.cpuModelUrl
     });
@@ -7412,10 +7748,10 @@ function createA2E(config) {
     numIdentityClasses: config.numIdentityClasses
   });
   if (fallbackOnError) {
-    logger11.info("Creating Wav2Vec2Inference with CPU fallback");
+    logger12.info("Creating Wav2Vec2Inference with CPU fallback");
     return new A2EWithFallback(gpuInstance, config);
   }
-  logger11.info("Creating Wav2Vec2Inference (no fallback)");
+  logger12.info("Creating Wav2Vec2Inference (no fallback)");
   return gpuInstance;
 }
 var A2EWithFallback = class {
@@ -7444,7 +7780,7 @@ var A2EWithFallback = class {
     }
   }
   async fallbackToCpu(reason) {
-    logger11.warn("GPU model load failed, falling back to CPU model", { reason });
+    logger12.warn("GPU model load failed, falling back to CPU model", { reason });
     try {
       await this.implementation.dispose();
     } catch {
@@ -7453,17 +7789,17 @@ var A2EWithFallback = class {
       this.implementation = new Wav2ArkitCpuUnifiedAdapter(this.config.unifiedWorker, {
         modelUrl: this.config.cpuModelUrl
       });
-      logger11.info("Fallback to Wav2ArkitCpuUnifiedAdapter successful");
+      logger12.info("Fallback to Wav2ArkitCpuUnifiedAdapter successful");
     } else if (this.config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
       this.implementation = new Wav2ArkitCpuWorker({
         modelUrl: this.config.cpuModelUrl
       });
-      logger11.info("Fallback to Wav2ArkitCpuWorker successful");
+      logger12.info("Fallback to Wav2ArkitCpuWorker successful");
     } else {
       this.implementation = new Wav2ArkitCpuInference({
         modelUrl: this.config.cpuModelUrl
       });
-      logger11.info("Fallback to Wav2ArkitCpuInference successful");
+      logger12.info("Fallback to Wav2ArkitCpuInference successful");
     }
     this.hasFallenBack = true;
     return await this.implementation.load();
@@ -7667,7 +8003,7 @@ var EmphasisDetector = class {
 };
 
 // src/inference/SileroVADInference.ts
-var logger12 = createLogger("SileroVAD");
+var logger13 = createLogger("SileroVAD");
 var SileroVADInference = class {
   constructor(config) {
     this.session = null;
@@ -7741,23 +8077,23 @@ var SileroVADInference = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger12.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger13.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger12.info("ONNX Runtime loaded", { backend: this._backend });
+      logger13.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) {
-        logger12.debug("Loading model from cache", { modelUrl });
+        logger13.debug("Loading model from cache", { modelUrl });
         modelBuffer = await cache.get(modelUrl);
       } else {
-        logger12.debug("Fetching and caching model", { modelUrl });
+        logger13.debug("Fetching and caching model", { modelUrl });
         modelBuffer = await fetchWithCache(modelUrl);
       }
-      logger12.debug("Creating ONNX session", {
+      logger13.debug("Creating ONNX session", {
         size: formatBytes(modelBuffer.byteLength),
         backend: this._backend
       });
@@ -7766,7 +8102,7 @@ var SileroVADInference = class {
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       this.reset();
       const loadTimeMs = performance.now() - startTime;
-      logger12.info("Model loaded successfully", {
+      logger13.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -7821,7 +8157,7 @@ var SileroVADInference = class {
           []
         );
       } catch (e) {
-        logger12.warn("BigInt64Array not available, using bigint array fallback", {
+        logger13.warn("BigInt64Array not available, using bigint array fallback", {
           error: e instanceof Error ? e.message : String(e)
         });
         this.srTensor = new this.ort.Tensor(
@@ -7927,7 +8263,7 @@ var SileroVADInference = class {
           this.preSpeechBuffer.shift();
         }
       }
-      logger12.trace("Skipping VAD inference - audio too quiet", {
+      logger13.trace("Skipping VAD inference - audio too quiet", {
         rms: Math.round(rms * 1e4) / 1e4,
         threshold: MIN_ENERGY_THRESHOLD
       });
@@ -7981,7 +8317,7 @@ var SileroVADInference = 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())
             });
@@ -7994,7 +8330,7 @@ var SileroVADInference = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger12.trace("VAD inference completed", {
+          logger13.trace("VAD inference completed", {
             probability: Math.round(probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100
@@ -8025,7 +8361,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.`
             );
-            logger12.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+            logger13.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
               pointer: `0x${err.toString(16)}`,
               backend: this._backend
             });
@@ -8068,7 +8404,7 @@ var SileroVADInference = class {
 SileroVADInference.isWebGPUAvailable = isWebGPUAvailable;
 
 // src/inference/SileroVADWorker.ts
-var logger13 = createLogger("SileroVADWorker");
+var logger14 = createLogger("SileroVADWorker");
 var WASM_CDN_PATH5 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS3 = 12e4;
 var INFERENCE_TIMEOUT_MS3 = 1e3;
@@ -8353,7 +8689,7 @@ var SileroVADWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger13.error("Worker error", { error: error.message });
+      logger14.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -8429,9 +8765,9 @@ var SileroVADWorker = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger13.info("Creating VAD worker...");
+      logger14.info("Creating VAD worker...");
       this.worker = this.createWorker();
-      logger13.info("Loading model in worker...", {
+      logger14.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         sampleRate: this.config.sampleRate
       });
@@ -8447,7 +8783,7 @@ var SileroVADWorker = class {
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger13.info("VAD worker loaded successfully", {
+      logger14.info("VAD worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -8554,7 +8890,7 @@ var SileroVADWorker = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger13.debug("Speech started with pre-speech buffer", {
+            logger14.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -8567,7 +8903,7 @@ var SileroVADWorker = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger13.trace("VAD worker inference completed", {
+          logger14.trace("VAD worker inference completed", {
             probability: Math.round(result.probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
@@ -8635,44 +8971,44 @@ var SileroVADWorker = class {
 };
 
 // src/inference/createSileroVAD.ts
-var logger14 = createLogger("createSileroVAD");
+var logger15 = createLogger("createSileroVAD");
 function supportsVADWorker() {
   if (typeof Worker === "undefined") {
-    logger14.debug("Worker not supported: Worker constructor undefined");
+    logger15.debug("Worker not supported: Worker constructor undefined");
     return false;
   }
   if (typeof URL === "undefined" || typeof URL.createObjectURL === "undefined") {
-    logger14.debug("Worker not supported: URL.createObjectURL unavailable");
+    logger15.debug("Worker not supported: URL.createObjectURL unavailable");
     return false;
   }
   if (typeof Blob === "undefined") {
-    logger14.debug("Worker not supported: Blob constructor unavailable");
+    logger15.debug("Worker not supported: Blob constructor unavailable");
     return false;
   }
   return true;
 }
 function createSileroVAD(config) {
   if (config.unifiedWorker) {
-    logger14.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
+    logger15.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;
-    logger14.debug("Worker preference explicitly set", { useWorker });
+    logger15.debug("Worker preference explicitly set", { useWorker });
   } else {
     const workerSupported = supportsVADWorker();
     const onMobile = isMobile();
     useWorker = workerSupported && !onMobile;
-    logger14.debug("Auto-detected Worker preference", {
+    logger15.debug("Auto-detected Worker preference", {
       useWorker,
       workerSupported,
       onMobile
     });
   }
   if (useWorker) {
-    logger14.info("Creating SileroVADWorker (off-main-thread)");
+    logger15.info("Creating SileroVADWorker (off-main-thread)");
     const worker = new SileroVADWorker({
       modelUrl: config.modelUrl,
       sampleRate: config.sampleRate,
@@ -8684,7 +9020,7 @@ function createSileroVAD(config) {
     }
     return worker;
   }
-  logger14.info("Creating SileroVADInference (main thread)");
+  logger15.info("Creating SileroVADInference (main thread)");
   return new SileroVADInference(config);
 }
 var VADWorkerWithFallback = class {
@@ -8710,7 +9046,7 @@ var VADWorkerWithFallback = class {
     try {
       return await this.implementation.load();
     } catch (error) {
-      logger14.warn("Worker load failed, falling back to main thread", {
+      logger15.warn("Worker load failed, falling back to main thread", {
         error: error instanceof Error ? error.message : String(error)
       });
       try {
@@ -8719,7 +9055,7 @@ var VADWorkerWithFallback = class {
       }
       this.implementation = new SileroVADInference(this.config);
       this.hasFallenBack = true;
-      logger14.info("Fallback to SileroVADInference successful");
+      logger15.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
     }
   }
@@ -8741,7 +9077,7 @@ var VADWorkerWithFallback = class {
 };
 
 // src/inference/A2EOrchestrator.ts
-var logger15 = createLogger("A2EOrchestrator");
+var logger16 = createLogger("A2EOrchestrator");
 var A2EOrchestrator = class {
   constructor(config) {
     this.a2e = null;
@@ -8782,7 +9118,7 @@ var A2EOrchestrator = class {
    */
   async load() {
     if (this.disposed) throw new Error("A2EOrchestrator has been disposed");
-    logger15.info("Loading A2E model...");
+    logger16.info("Loading A2E model...");
     this.a2e = createA2E({
       gpuModelUrl: this.config.gpuModelUrl,
       gpuExternalDataUrl: this.config.gpuExternalDataUrl,
@@ -8799,7 +9135,7 @@ var A2EOrchestrator = class {
       onError: this.config.onError
     });
     this._isReady = true;
-    logger15.info("A2E model loaded", {
+    logger16.info("A2E model loaded", {
       backend: info.backend,
       loadTimeMs: info.loadTimeMs,
       modelId: this.a2e.modelId
@@ -8854,10 +9190,10 @@ var A2EOrchestrator = class {
       this.scriptProcessor.connect(this.audioContext.destination);
       this._isStreaming = true;
       this.processor.startDrip();
-      logger15.info("Mic capture started", { sampleRate: this.nativeSampleRate });
+      logger16.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 });
+      logger16.error("Failed to start mic capture", { error: error.message });
       this.config.onError?.(error);
       throw error;
     }
@@ -8885,7 +9221,7 @@ var A2EOrchestrator = class {
       });
       this.audioContext = null;
     }
-    logger15.info("Mic capture stopped");
+    logger16.info("Mic capture stopped");
   }
   /**
    * Dispose of all resources
@@ -8908,7 +9244,7 @@ var A2EOrchestrator = class {
 };
 
 // src/inference/SafariSpeechRecognition.ts
-var logger16 = createLogger("SafariSpeech");
+var logger17 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {
   constructor(config = {}) {
     this.recognition = null;
@@ -8927,7 +9263,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       interimResults: config.interimResults ?? true,
       maxAlternatives: config.maxAlternatives ?? 1
     };
-    logger16.debug("SafariSpeechRecognition created", {
+    logger17.debug("SafariSpeechRecognition created", {
       language: this.config.language,
       continuous: this.config.continuous
     });
@@ -8988,7 +9324,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger16.warn("Already listening");
+      logger17.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -9018,7 +9354,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = true;
       this.startTime = performance.now();
       this.accumulatedText = "";
-      logger16.info("Speech recognition started", {
+      logger17.info("Speech recognition started", {
         language: this.config.language
       });
       span?.end();
@@ -9033,7 +9369,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async stop() {
     if (!this.isListening || !this.recognition) {
-      logger16.warn("Not currently listening");
+      logger17.warn("Not currently listening");
       return {
         text: this.accumulatedText,
         language: this.config.language,
@@ -9062,7 +9398,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     if (this.recognition && this.isListening) {
       this.recognition.abort();
       this.isListening = false;
-      logger16.info("Speech recognition aborted");
+      logger17.info("Speech recognition aborted");
     }
   }
   /**
@@ -9093,7 +9429,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     this.isListening = false;
     this.resultCallbacks = [];
     this.errorCallbacks = [];
-    logger16.debug("SafariSpeechRecognition disposed");
+    logger17.debug("SafariSpeechRecognition disposed");
   }
   /**
    * Set up event handlers for the recognition instance
@@ -9121,7 +9457,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
               confidence: alternative.confidence
             };
             this.emitResult(speechResult);
-            logger16.trace("Speech result", {
+            logger17.trace("Speech result", {
               text: text.substring(0, 50),
               isFinal,
               confidence: alternative.confidence
@@ -9131,12 +9467,12 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
         span?.end();
       } catch (error) {
         span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-        logger16.error("Error processing speech result", { error });
+        logger17.error("Error processing speech result", { error });
       }
     };
     this.recognition.onerror = (event) => {
       const error = new Error(`Speech recognition error: ${event.error} - ${event.message}`);
-      logger16.error("Speech recognition error", { error: event.error, message: event.message });
+      logger17.error("Speech recognition error", { error: event.error, message: event.message });
       this.emitError(error);
       if (this.stopRejecter) {
         this.stopRejecter(error);
@@ -9146,7 +9482,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     };
     this.recognition.onend = () => {
       this.isListening = false;
-      logger16.info("Speech recognition ended", {
+      logger17.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
         durationMs: performance.now() - this.startTime
       });
@@ -9163,13 +9499,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       }
     };
     this.recognition.onstart = () => {
-      logger16.debug("Speech recognition started by browser");
+      logger17.debug("Speech recognition started by browser");
     };
     this.recognition.onspeechstart = () => {
-      logger16.debug("Speech detected");
+      logger17.debug("Speech detected");
     };
     this.recognition.onspeechend = () => {
-      logger16.debug("Speech ended");
+      logger17.debug("Speech ended");
     };
   }
   /**
@@ -9180,7 +9516,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger16.error("Error in result callback", { error });
+        logger17.error("Error in result callback", { error });
       }
     }
   }
@@ -9192,7 +9528,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(error);
       } catch (callbackError) {
-        logger16.error("Error in error callback", { error: callbackError });
+        logger17.error("Error in error callback", { error: callbackError });
       }
     }
   }
@@ -9762,327 +10098,9 @@ var AnimationGraph = class extends EventEmitter {
   }
 };
 
-// src/animation/simplex2d.ts
-var perm = new Uint8Array(512);
-var grad2 = [
-  [1, 1],
-  [-1, 1],
-  [1, -1],
-  [-1, -1],
-  [1, 0],
-  [-1, 0],
-  [0, 1],
-  [0, -1]
-];
-var p = [
-  151,
-  160,
-  137,
-  91,
-  90,
-  15,
-  131,
-  13,
-  201,
-  95,
-  96,
-  53,
-  194,
-  233,
-  7,
-  225,
-  140,
-  36,
-  103,
-  30,
-  69,
-  142,
-  8,
-  99,
-  37,
-  240,
-  21,
-  10,
-  23,
-  190,
-  6,
-  148,
-  247,
-  120,
-  234,
-  75,
-  0,
-  26,
-  197,
-  62,
-  94,
-  252,
-  219,
-  203,
-  117,
-  35,
-  11,
-  32,
-  57,
-  177,
-  33,
-  88,
-  237,
-  149,
-  56,
-  87,
-  174,
-  20,
-  125,
-  136,
-  171,
-  168,
-  68,
-  175,
-  74,
-  165,
-  71,
-  134,
-  139,
-  48,
-  27,
-  166,
-  77,
-  146,
-  158,
-  231,
-  83,
-  111,
-  229,
-  122,
-  60,
-  211,
-  133,
-  230,
-  220,
-  105,
-  92,
-  41,
-  55,
-  46,
-  245,
-  40,
-  244,
-  102,
-  143,
-  54,
-  65,
-  25,
-  63,
-  161,
-  1,
-  216,
-  80,
-  73,
-  209,
-  76,
-  132,
-  187,
-  208,
-  89,
-  18,
-  169,
-  200,
-  196,
-  135,
-  130,
-  116,
-  188,
-  159,
-  86,
-  164,
-  100,
-  109,
-  198,
-  173,
-  186,
-  3,
-  64,
-  52,
-  217,
-  226,
-  250,
-  124,
-  123,
-  5,
-  202,
-  38,
-  147,
-  118,
-  126,
-  255,
-  82,
-  85,
-  212,
-  207,
-  206,
-  59,
-  227,
-  47,
-  16,
-  58,
-  17,
-  182,
-  189,
-  28,
-  42,
-  223,
-  183,
-  170,
-  213,
-  119,
-  248,
-  152,
-  2,
-  44,
-  154,
-  163,
-  70,
-  221,
-  153,
-  101,
-  155,
-  167,
-  43,
-  172,
-  9,
-  129,
-  22,
-  39,
-  253,
-  19,
-  98,
-  108,
-  110,
-  79,
-  113,
-  224,
-  232,
-  178,
-  185,
-  112,
-  104,
-  218,
-  246,
-  97,
-  228,
-  251,
-  34,
-  242,
-  193,
-  238,
-  210,
-  144,
-  12,
-  191,
-  179,
-  162,
-  241,
-  81,
-  51,
-  145,
-  235,
-  249,
-  14,
-  239,
-  107,
-  49,
-  192,
-  214,
-  31,
-  181,
-  199,
-  106,
-  157,
-  184,
-  84,
-  204,
-  176,
-  115,
-  121,
-  50,
-  45,
-  127,
-  4,
-  150,
-  254,
-  138,
-  236,
-  205,
-  93,
-  222,
-  114,
-  67,
-  29,
-  24,
-  72,
-  243,
-  141,
-  128,
-  195,
-  78,
-  66,
-  215,
-  61,
-  156,
-  180
-];
-for (let i = 0; i < 256; i++) {
-  perm[i] = p[i];
-  perm[i + 256] = p[i];
-}
-var F2 = 0.5 * (Math.sqrt(3) - 1);
-var G2 = (3 - Math.sqrt(3)) / 6;
-function dot2(g, x, y) {
-  return g[0] * x + g[1] * y;
-}
-function simplex2d(x, y) {
-  const s = (x + y) * F2;
-  const i = Math.floor(x + s);
-  const j = Math.floor(y + s);
-  const t = (i + j) * G2;
-  const X0 = i - t;
-  const Y0 = j - t;
-  const x0 = x - X0;
-  const y0 = y - Y0;
-  const i1 = x0 > y0 ? 1 : 0;
-  const j1 = x0 > y0 ? 0 : 1;
-  const x1 = x0 - i1 + G2;
-  const y1 = y0 - j1 + G2;
-  const x2 = x0 - 1 + 2 * G2;
-  const y2 = y0 - 1 + 2 * G2;
-  const ii = i & 255;
-  const jj = j & 255;
-  const gi0 = perm[ii + perm[jj]] % 8;
-  const gi1 = perm[ii + i1 + perm[jj + j1]] % 8;
-  const gi2 = perm[ii + 1 + perm[jj + 1]] % 8;
-  let n0 = 0;
-  let t0 = 0.5 - x0 * x0 - y0 * y0;
-  if (t0 >= 0) {
-    t0 *= t0;
-    n0 = t0 * t0 * dot2(grad2[gi0], x0, y0);
-  }
-  let n1 = 0;
-  let t1 = 0.5 - x1 * x1 - y1 * y1;
-  if (t1 >= 0) {
-    t1 *= t1;
-    n1 = t1 * t1 * dot2(grad2[gi1], x1, y1);
-  }
-  let n2 = 0;
-  let t2 = 0.5 - x2 * x2 - y2 * y2;
-  if (t2 >= 0) {
-    t2 *= t2;
-    n2 = t2 * t2 * dot2(grad2[gi2], x2, y2);
-  }
-  return 70 * (n0 + n1 + n2);
-}
-
 // src/animation/ProceduralLifeLayer.ts
+var import_simplex_noise = require("simplex-noise");
+var simplex2d = (0, import_simplex_noise.createNoise2D)();
 var PHASE_OPEN = 0;
 var PHASE_CLOSING = 1;
 var PHASE_CLOSED = 2;
@@ -10390,6 +10408,684 @@ var ProceduralLifeLayer = class {
   }
 };
 
+// src/orchestration/MicLipSync.ts
+var logger18 = createLogger("MicLipSync");
+var MicLipSync = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.omoteEvents = new EventEmitter();
+    this._state = "idle";
+    this._isSpeaking = false;
+    this._currentFrame = null;
+    this._currentRawFrame = null;
+    // VAD state
+    this.speechStartTime = 0;
+    this.vadChunkSize = 0;
+    this.vadBuffer = null;
+    this.vadBufferOffset = 0;
+    this.profile = config.profile ?? {};
+    this.vad = config.vad;
+    this.mic = new MicrophoneCapture(this.omoteEvents, {
+      sampleRate: config.sampleRate ?? 16e3,
+      chunkSize: config.micChunkSize ?? 512
+    });
+    this.processor = new A2EProcessor({
+      backend: config.lam,
+      sampleRate: config.sampleRate ?? 16e3,
+      identityIndex: config.identityIndex,
+      onFrame: (raw) => {
+        const scaled = applyProfile(raw, this.profile);
+        this._currentFrame = scaled;
+        this._currentRawFrame = raw;
+        this.emit("frame", { blendshapes: scaled, rawBlendshapes: raw });
+      },
+      onError: (error) => {
+        logger18.error("A2E inference error", { message: error.message });
+        this.emit("error", error);
+      }
+    });
+    this.omoteEvents.on("audio.chunk", ({ pcm }) => {
+      const float32 = int16ToFloat32(pcm);
+      this.processor.pushAudio(float32);
+      if (this.vad) {
+        this.processVAD(float32);
+      }
+    });
+    this.omoteEvents.on("audio.level", (level) => {
+      this.emit("audio:level", level);
+    });
+    if (this.vad) {
+      this.vadChunkSize = this.vad.getChunkSize();
+      this.vadBuffer = new Float32Array(this.vadChunkSize);
+      this.vadBufferOffset = 0;
+    }
+  }
+  /** Current state */
+  get state() {
+    return this._state;
+  }
+  /** Latest blendshape frame (null before first inference) */
+  get currentFrame() {
+    return this._currentFrame;
+  }
+  /** Whether speech is currently detected (requires VAD) */
+  get isSpeaking() {
+    return this._isSpeaking;
+  }
+  /** Current backend type */
+  get backend() {
+    return this.processor ? "active" : null;
+  }
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+  /** Start microphone capture and inference loop */
+  async start() {
+    if (this._state === "active") return;
+    await this.mic.start();
+    this.processor.startDrip();
+    this.emit("mic:start", void 0);
+    this.setState("active");
+  }
+  /** Stop microphone and inference */
+  stop() {
+    if (this._state === "idle") return;
+    this.processor.stopDrip();
+    this.mic.stop();
+    this._isSpeaking = false;
+    this.emit("mic:stop", void 0);
+    this.setState("idle");
+  }
+  /** Pause inference (mic stays open for faster resume) */
+  pause() {
+    if (this._state !== "active") return;
+    this.processor.stopDrip();
+    this.setState("paused");
+  }
+  /** Resume inference after pause */
+  resume() {
+    if (this._state !== "paused") return;
+    this.processor.startDrip();
+    this.setState("active");
+  }
+  /** Update ExpressionProfile at runtime */
+  setProfile(profile) {
+    this.profile = profile;
+  }
+  /** Dispose of all resources */
+  async dispose() {
+    this.stop();
+    this.processor.dispose();
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: VAD processing
+  // ---------------------------------------------------------------------------
+  async processVAD(samples) {
+    if (!this.vad || !this.vadBuffer) return;
+    for (let i = 0; i < samples.length; i++) {
+      this.vadBuffer[this.vadBufferOffset++] = samples[i];
+      if (this.vadBufferOffset >= this.vadChunkSize) {
+        try {
+          const result = await this.vad.process(this.vadBuffer);
+          const wasSpeaking = this._isSpeaking;
+          this._isSpeaking = result.isSpeech;
+          if (!wasSpeaking && result.isSpeech) {
+            this.speechStartTime = performance.now();
+            this.emit("speech:start", void 0);
+          } else if (wasSpeaking && !result.isSpeech) {
+            const durationMs = performance.now() - this.speechStartTime;
+            this.emit("speech:end", { durationMs });
+          }
+        } catch (err) {
+          logger18.warn("VAD process error", { error: String(err) });
+        }
+        this.vadBufferOffset = 0;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: State management
+  // ---------------------------------------------------------------------------
+  setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    this.emit("state", state);
+  }
+};
+
+// src/orchestration/VoicePipeline.ts
+var logger19 = createLogger("VoicePipeline");
+var VoicePipeline = class extends EventEmitter {
+  constructor(config) {
+    super();
+    // State
+    this._state = "idle";
+    this.stopped = false;
+    this.epoch = 0;
+    this._sessionId = null;
+    // Models
+    this.asr = null;
+    this.lam = null;
+    this.vad = null;
+    this.unifiedWorker = null;
+    // Pipelines
+    this.playback = null;
+    this.interruption = null;
+    this.omoteEvents = new EventEmitter();
+    this.mic = null;
+    // Audio accumulation
+    this.audioBuffer = [];
+    this.audioBufferSamples = 0;
+    this.speechStartTime = 0;
+    this.silenceTimer = null;
+    this.isSpeaking = false;
+    // Progressive transcription
+    this.progressiveTimer = null;
+    this.progressivePromise = null;
+    this.lastProgressiveResult = null;
+    this.lastProgressiveSamples = 0;
+    // ASR error recovery
+    this.asrErrorCount = 0;
+    // Response abort
+    this.responseAbortController = null;
+    // Frame refs
+    this._currentFrame = null;
+    this.config = config;
+  }
+  /** Current pipeline state */
+  get state() {
+    return this._state;
+  }
+  /** Latest blendshape frame */
+  get currentFrame() {
+    return this._currentFrame;
+  }
+  /** Whether user is currently speaking */
+  get isSpeechActive() {
+    return this.isSpeaking;
+  }
+  /** Session ID (generated on start(), null before) */
+  get sessionId() {
+    return this._sessionId;
+  }
+  // ---------------------------------------------------------------------------
+  // Model loading
+  // ---------------------------------------------------------------------------
+  async loadModels() {
+    this.setState("loading");
+    const timeoutMs = this.config.lamLoadTimeoutMs ?? 3e4;
+    try {
+      if (isIOS()) {
+        this.unifiedWorker = new UnifiedInferenceWorker();
+        await this.unifiedWorker.init();
+      }
+      this.emitProgress("Speech recognition", 0, 3, 0);
+      this.asr = createSenseVoice({
+        modelUrl: this.config.models.senseVoice.modelUrl,
+        tokensUrl: this.config.models.senseVoice.tokensUrl,
+        language: this.config.models.senseVoice.language,
+        unifiedWorker: this.unifiedWorker ?? void 0
+      });
+      await this.asr.load();
+      this.emitProgress("Speech recognition", 45, 3, 1);
+      this.emitProgress("Lip sync", 45, 3, 1);
+      let lam = createA2E({
+        gpuModelUrl: this.config.models.lam.gpuModelUrl,
+        gpuExternalDataUrl: this.config.models.lam.gpuExternalDataUrl,
+        cpuModelUrl: this.config.models.lam.cpuModelUrl,
+        mode: this.config.models.lam.mode,
+        unifiedWorker: this.unifiedWorker ?? void 0
+      });
+      let lamProgress = 45;
+      const lamTickInterval = setInterval(() => {
+        const remaining = 85 - lamProgress;
+        lamProgress += Math.max(0.5, remaining * 0.08);
+        this.emitProgress("Lip sync", Math.round(lamProgress), 3, 1);
+      }, 300);
+      try {
+        const lamLoadResult = await Promise.race([
+          lam.load().then(() => "ok"),
+          new Promise((r) => setTimeout(() => r("timeout"), timeoutMs))
+        ]);
+        if (lamLoadResult === "timeout") {
+          logger19.warn(`LAM GPU load timed out after ${timeoutMs}ms, falling back to CPU`);
+          await lam.dispose();
+          lam = createA2E({
+            gpuModelUrl: this.config.models.lam.gpuModelUrl,
+            cpuModelUrl: this.config.models.lam.cpuModelUrl,
+            mode: "cpu",
+            unifiedWorker: this.unifiedWorker ?? void 0
+          });
+          await lam.load();
+        }
+      } finally {
+        clearInterval(lamTickInterval);
+      }
+      this.lam = lam;
+      this.emitProgress("Lip sync", 85, 3, 2);
+      this.emitProgress("Voice detection", 85, 3, 2);
+      this.vad = createSileroVAD({
+        modelUrl: this.config.models.vad.modelUrl,
+        threshold: this.config.models.vad.threshold,
+        unifiedWorker: this.unifiedWorker ?? void 0
+      });
+      await this.vad.load();
+      this.emitProgress("Voice detection", 100, 3, 3);
+      this.playback = new PlaybackPipeline({
+        lam: this.lam,
+        profile: this.config.profile,
+        identityIndex: this.config.identityIndex,
+        neutralTransitionEnabled: this.config.neutralTransitionEnabled ?? true,
+        neutralTransitionMs: this.config.neutralTransitionMs,
+        audioDelayMs: this.config.audioDelayMs,
+        chunkTargetMs: this.config.chunkTargetMs
+      });
+      await this.playback.initialize();
+      this.playback.on("frame", (f) => {
+        this._currentFrame = f.blendshapes;
+        this.emit("frame", f);
+      });
+      this.playback.on("frame:raw", (f) => this.emit("frame:raw", f));
+      this.playback.on("playback:start", (t) => this.emit("playback:start", t));
+      this.playback.on("playback:complete", () => {
+        if (this.stopped) return;
+        this.emit("playback:complete", void 0);
+        this.vad?.reset();
+        this.epoch++;
+        this.setState("listening");
+      });
+      this.playback.on("error", (e) => this.emit("error", e));
+      this.interruption = new InterruptionHandler({
+        enabled: this.config.interruptionEnabled ?? true,
+        minSpeechDurationMs: this.config.interruptionMinSpeechMs ?? 200
+      });
+      this.interruption.on("interruption.triggered", () => {
+        this.handleInterruption();
+      });
+      this.setState("ready");
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger19.error("Model loading failed", { message: err.message });
+      this.emit("error", err);
+      this.setState("error");
+      throw err;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Conversation lifecycle
+  // ---------------------------------------------------------------------------
+  async start() {
+    if (this._state !== "ready") {
+      throw new Error(`Cannot start: state is '${this._state}', expected 'ready'`);
+    }
+    this.stopped = false;
+    this.epoch++;
+    this._sessionId = crypto.randomUUID();
+    this.asrErrorCount = 0;
+    this.mic = new MicrophoneCapture(this.omoteEvents, {
+      sampleRate: 16e3,
+      chunkSize: 512
+    });
+    this.omoteEvents.on("audio.chunk", ({ pcm }) => {
+      const float32 = int16ToFloat32(pcm);
+      this.processAudioChunk(float32);
+    });
+    this.omoteEvents.on("audio.level", (level) => {
+      this.emit("audio:level", level);
+    });
+    await this.mic.start();
+    this.setState("listening");
+  }
+  stop() {
+    this.stopped = true;
+    this.epoch++;
+    this.clearSilenceTimer();
+    this.stopProgressiveTranscription();
+    this.responseAbortController?.abort();
+    this.responseAbortController = null;
+    this.vad?.reset();
+    this.playback?.stop();
+    this.mic?.stop();
+    this.mic = null;
+    this.isSpeaking = false;
+    this.audioBuffer = [];
+    this.audioBufferSamples = 0;
+    this._currentFrame = null;
+    this.interruption?.setAISpeaking(false);
+    if (this._state !== "idle") {
+      this.setState("ready");
+    }
+  }
+  setProfile(profile) {
+    this.config.profile = profile;
+    this.playback?.setProfile(profile);
+  }
+  async dispose() {
+    this.stop();
+    this.epoch++;
+    await this.playback?.dispose();
+    await this.asr?.dispose();
+    await this.lam?.dispose();
+    await this.vad?.dispose();
+    this.playback = null;
+    this.asr = null;
+    this.lam = null;
+    this.vad = null;
+    this._state = "idle";
+  }
+  // ---------------------------------------------------------------------------
+  // Audio processing
+  // ---------------------------------------------------------------------------
+  async processAudioChunk(samples) {
+    if (!this.vad) return;
+    try {
+      const result = await this.vad.process(samples);
+      if (this._state === "speaking" && this.interruption) {
+        this.interruption.processVADResult(result.probability);
+        return;
+      }
+      if (this._state !== "listening" && this._state !== "thinking") return;
+      const wasSpeaking = this.isSpeaking;
+      if (result.isSpeech) {
+        if (!wasSpeaking) {
+          this.isSpeaking = true;
+          this.speechStartTime = performance.now();
+          this.audioBuffer = [];
+          this.audioBufferSamples = 0;
+          this.lastProgressiveResult = null;
+          this.lastProgressiveSamples = 0;
+          this.emit("speech:start", void 0);
+          this.startProgressiveTranscription();
+        }
+        this.audioBuffer.push(new Float32Array(samples));
+        this.audioBufferSamples += samples.length;
+        this.clearSilenceTimer();
+      } else if (wasSpeaking) {
+        this.audioBuffer.push(new Float32Array(samples));
+        this.audioBufferSamples += samples.length;
+        if (!this.silenceTimer) {
+          const timeoutMs = this.getSilenceTimeout();
+          this.silenceTimer = setTimeout(() => {
+            this.onSilenceDetected();
+          }, timeoutMs);
+        }
+      }
+    } catch (err) {
+      logger19.warn("VAD error", { error: String(err) });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Silence detection
+  // ---------------------------------------------------------------------------
+  getSilenceTimeout() {
+    const base = this.config.silenceTimeoutMs ?? 500;
+    const extended = this.config.silenceTimeoutExtendedMs ?? 700;
+    const adaptive = this.config.adaptiveTimeout ?? true;
+    if (!adaptive) return base;
+    const speechDurationMs = performance.now() - this.speechStartTime;
+    return speechDurationMs > 3e3 ? extended : base;
+  }
+  onSilenceDetected() {
+    const capturedEpoch = this.epoch;
+    this.isSpeaking = false;
+    const durationMs = performance.now() - this.speechStartTime;
+    this.emit("speech:end", { durationMs });
+    this.clearSilenceTimer();
+    this.processEndOfSpeech(capturedEpoch).catch((err) => {
+      logger19.error("End of speech processing failed", { error: String(err) });
+      if (this.epoch === capturedEpoch && !this.stopped) {
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        this.setState("listening");
+      }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // End of speech → transcription → response
+  // ---------------------------------------------------------------------------
+  async processEndOfSpeech(capturedEpoch) {
+    if (this.progressivePromise) {
+      try {
+        await this.progressivePromise;
+      } catch {
+      }
+    }
+    this.stopProgressiveTranscription();
+    if (this.epoch !== capturedEpoch || this.stopped) return;
+    const totalSamples = this.audioBufferSamples;
+    const fullAudio = new Float32Array(totalSamples);
+    let offset = 0;
+    for (const chunk of this.audioBuffer) {
+      fullAudio.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.audioBuffer = [];
+    this.audioBufferSamples = 0;
+    const minDuration = this.config.minAudioDurationSec ?? 0.3;
+    const minEnergy = this.config.minAudioEnergy ?? 0.02;
+    const durationSec = totalSamples / 16e3;
+    if (durationSec < minDuration) {
+      logger19.info("Audio too short, discarding", { durationSec });
+      this.setState("listening");
+      return;
+    }
+    let maxAbs = 0;
+    for (let i = 0; i < fullAudio.length; i++) {
+      const abs = Math.abs(fullAudio[i]);
+      if (abs > maxAbs) maxAbs = abs;
+    }
+    let rms = 0;
+    for (let i = 0; i < fullAudio.length; i++) {
+      rms += fullAudio[i] * fullAudio[i];
+    }
+    rms = Math.sqrt(rms / fullAudio.length);
+    if (rms < minEnergy) {
+      logger19.info("Audio too quiet, discarding", { rms });
+      this.setState("listening");
+      return;
+    }
+    const normalizedAudio = this.normalizeAudio(fullAudio);
+    this.setState("thinking");
+    let transcript = null;
+    const coverageThreshold = this.config.progressiveCoverageThreshold ?? 0.8;
+    if (this.lastProgressiveResult && this.lastProgressiveResult.text.trim().length > 0 && this.lastProgressiveSamples >= totalSamples * coverageThreshold) {
+      transcript = { ...this.lastProgressiveResult, isFinal: true };
+      logger19.info("Using progressive result", {
+        coverage: (this.lastProgressiveSamples / totalSamples).toFixed(2),
+        text: transcript.text
+      });
+    } else {
+      this.lastProgressiveResult = null;
+      transcript = await this.transcribeWithTimeout(normalizedAudio);
+      if (transcript) {
+        transcript.isFinal = true;
+      }
+    }
+    if (this.epoch !== capturedEpoch || this.stopped) return;
+    if (!transcript || !transcript.text.trim()) {
+      logger19.info("No transcript, resuming listening");
+      this.setState("listening");
+      return;
+    }
+    this.emit("transcript", transcript);
+    await this.callResponseHandler(transcript, capturedEpoch);
+  }
+  // ---------------------------------------------------------------------------
+  // Response handler
+  // ---------------------------------------------------------------------------
+  async callResponseHandler(transcript, capturedEpoch) {
+    if (this.epoch !== capturedEpoch || this.stopped) return;
+    this.setState("speaking");
+    this.interruption?.setAISpeaking(true);
+    const abortController = new AbortController();
+    this.responseAbortController = abortController;
+    try {
+      this.playback.start();
+      await this.config.onResponse({
+        text: transcript.text,
+        emotion: transcript.emotion,
+        event: transcript.event,
+        send: async (chunk) => {
+          if (abortController.signal.aborted) return;
+          await this.playback.onAudioChunk(chunk);
+        },
+        done: async () => {
+          if (abortController.signal.aborted) return;
+          await this.playback.end();
+        },
+        signal: abortController.signal,
+        sessionId: this._sessionId
+      });
+    } catch (error) {
+      if (abortController.signal.aborted) return;
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger19.error("Response handler error", { message: err.message });
+      this.emit("error", err);
+      if (this.epoch === capturedEpoch && !this.stopped) {
+        this.interruption?.setAISpeaking(false);
+        this.setState("listening");
+      }
+    } finally {
+      this.responseAbortController = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Interruption handling
+  // ---------------------------------------------------------------------------
+  handleInterruption() {
+    if (this._state !== "speaking") return;
+    logger19.info("Interruption triggered");
+    this.epoch++;
+    this.responseAbortController?.abort();
+    this.playback?.stop();
+    this.interruption?.setAISpeaking(false);
+    this.emit("interruption", void 0);
+    if (!this.stopped) {
+      this.setState("listening");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Progressive transcription
+  // ---------------------------------------------------------------------------
+  startProgressiveTranscription() {
+    this.stopProgressiveTranscription();
+    const intervalMs = isIOS() ? this.config.progressiveIntervalIosMs ?? 800 : this.config.progressiveIntervalMs ?? 500;
+    const minSamples = this.config.progressiveMinSamples ?? 8e3;
+    this.progressiveTimer = setInterval(() => {
+      if (this.audioBufferSamples < minSamples) return;
+      if (!this.asr) return;
+      const capturedEpoch = this.epoch;
+      const snapshot = new Float32Array(this.audioBufferSamples);
+      let offset = 0;
+      for (const chunk of this.audioBuffer) {
+        snapshot.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const snapshotSamples = this.audioBufferSamples;
+      this.progressivePromise = (async () => {
+        try {
+          const result = await this.transcribeWithTimeout(snapshot);
+          if (this.epoch !== capturedEpoch) return;
+          if (result && result.text.trim()) {
+            this.lastProgressiveResult = result;
+            this.lastProgressiveSamples = snapshotSamples;
+            this.emit("transcript", { ...result, isFinal: false });
+          }
+        } catch {
+        }
+      })();
+    }, intervalMs);
+  }
+  stopProgressiveTranscription() {
+    if (this.progressiveTimer) {
+      clearInterval(this.progressiveTimer);
+      this.progressiveTimer = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Transcription with timeout + ASR error recovery
+  // ---------------------------------------------------------------------------
+  async transcribeWithTimeout(audio) {
+    if (!this.asr) return null;
+    const timeoutMs = this.config.transcriptionTimeoutMs ?? 1e4;
+    const startTime = performance.now();
+    try {
+      const result = await Promise.race([
+        this.asr.transcribe(audio),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Transcription timed out after ${timeoutMs}ms`)), timeoutMs)
+        )
+      ]);
+      this.asrErrorCount = 0;
+      return {
+        text: result.text,
+        emotion: result.emotion,
+        language: result.language,
+        isFinal: false,
+        inferenceTimeMs: performance.now() - startTime
+      };
+    } catch (error) {
+      this.asrErrorCount++;
+      logger19.warn("Transcription failed", {
+        attempt: this.asrErrorCount,
+        error: String(error)
+      });
+      if (this.asrErrorCount >= 3) {
+        logger19.warn("3 consecutive ASR errors, recreating session");
+        try {
+          await this.asr.dispose();
+          this.asr = createSenseVoice({
+            modelUrl: this.config.models.senseVoice.modelUrl,
+            tokensUrl: this.config.models.senseVoice.tokensUrl,
+            language: this.config.models.senseVoice.language,
+            unifiedWorker: this.unifiedWorker ?? void 0
+          });
+          await this.asr.load();
+          this.asrErrorCount = 0;
+        } catch (recreateErr) {
+          logger19.error("ASR session recreation failed", { error: String(recreateErr) });
+        }
+      }
+      return null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Audio normalization
+  // ---------------------------------------------------------------------------
+  normalizeAudio(audio) {
+    if (!(this.config.normalizeAudio ?? true)) return audio;
+    let maxAbs = 0;
+    for (let i = 0; i < audio.length; i++) {
+      const abs = Math.abs(audio[i]);
+      if (abs > maxAbs) maxAbs = abs;
+    }
+    if (maxAbs >= 0.1 || maxAbs === 0) return audio;
+    const gain = 0.5 / maxAbs;
+    const normalized = new Float32Array(audio.length);
+    for (let i = 0; i < audio.length; i++) {
+      normalized[i] = audio[i] * gain;
+    }
+    return normalized;
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  setState(state) {
+    if (this._state === state) return;
+    logger19.info("State transition", { from: this._state, to: state });
+    this._state = state;
+    this.emit("state", state);
+  }
+  emitProgress(currentModel, progress, totalModels, modelsLoaded) {
+    this.emit("loading:progress", { currentModel, progress, totalModels, modelsLoaded });
+  }
+  clearSilenceTimer() {
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = null;
+    }
+  }
+};
+
 // ../types/dist/index.mjs
 var PROTOCOL_VERSION = 1;
 function isProtocolEvent(obj) {