@omote/core 0.5.7 → 0.6.4

package/dist/index.mjs

@@ -762,6 +762,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 = {}) {
@@ -2534,7 +2552,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
             } else {
               logger3.info("Fetching external model data", {
                 dataUrl,
-                note: "This may be a large download (383MB+)"
+                note: "This may be a large download"
               });
               externalDataBuffer = await fetchWithCache(dataUrl);
             }
@@ -2542,6 +2560,9 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
               size: formatBytes(externalDataBuffer.byteLength)
             });
           } catch (err) {
+            if (typeof this.config.externalDataUrl === "string") {
+              throw new Error(`Failed to fetch external data: ${dataUrl} \u2014 ${err.message}`);
+            }
             logger3.debug("No external data file found (single-file model)", {
               dataUrl,
               error: err.message
@@ -2665,28 +2686,6 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
     };
     return this.queueInference(feeds);
   }
-  /**
-   * Decode CTC logits to text using greedy decoding
-   */
-  decodeCTC(logits) {
-    const tokens = [];
-    let prevToken = -1;
-    for (const frame of logits) {
-      let maxIdx = 0;
-      let maxVal = frame[0];
-      for (let i = 1; i < frame.length; i++) {
-        if (frame[i] > maxVal) {
-          maxVal = frame[i];
-          maxIdx = i;
-        }
-      }
-      if (maxIdx !== prevToken && maxIdx !== 0) {
-        tokens.push(maxIdx);
-      }
-      prevToken = maxIdx;
-    }
-    return tokens.map((t) => CTC_VOCAB[t] === "|" ? " " : CTC_VOCAB[t]).join("");
-  }
   /**
    * Queue inference to serialize ONNX session calls
    */
@@ -2714,37 +2713,25 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
             })
           ]);
           const inferenceTimeMs = performance.now() - startTime;
-          const asrOutput = results["asr_logits"];
           const blendshapeOutput = results["blendshapes"];
-          if (!asrOutput || !blendshapeOutput) {
-            throw new Error("Missing outputs from model");
+          if (!blendshapeOutput) {
+            throw new Error("Missing blendshapes output from model");
           }
-          const asrData = asrOutput.data;
           const blendshapeData = blendshapeOutput.data;
-          const numASRFrames = asrOutput.dims[1];
           const numA2EFrames = blendshapeOutput.dims[1];
-          const asrVocabSize = asrOutput.dims[2];
           const numBlendshapes = blendshapeOutput.dims[2];
-          const asrLogits = [];
           const blendshapes = [];
-          for (let f = 0; f < numASRFrames; f++) {
-            asrLogits.push(asrData.slice(f * asrVocabSize, (f + 1) * asrVocabSize));
-          }
           for (let f = 0; f < numA2EFrames; f++) {
             const rawFrame = blendshapeData.slice(f * numBlendshapes, (f + 1) * numBlendshapes);
             blendshapes.push(symmetrizeBlendshapes(rawFrame));
           }
-          const text = this.decodeCTC(asrLogits);
           logger3.trace("Inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
-            numA2EFrames,
-            numASRFrames,
-            textLength: text.length
+            numA2EFrames
           });
           span?.setAttributes({
             "inference.duration_ms": inferenceTimeMs,
-            "inference.a2e_frames": numA2EFrames,
-            "inference.asr_frames": numASRFrames
+            "inference.a2e_frames": numA2EFrames
           });
           span?.end();
           telemetry?.recordHistogram("omote.inference.latency", inferenceTimeMs, {
@@ -2758,11 +2745,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
           });
           resolve({
             blendshapes,
-            asrLogits,
-            text,
             numFrames: numA2EFrames,
-            numA2EFrames,
-            numASRFrames,
             inferenceTimeMs
           });
         } catch (err) {
@@ -2815,19 +2798,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")) {
@@ -2846,6 +2817,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();
@@ -2910,25 +2899,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
@@ -3113,6 +3087,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 = {}) {
@@ -3500,7 +3797,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;
@@ -3553,26 +3850,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(
@@ -3585,14 +3882,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
         });
@@ -3605,15 +3902,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,
@@ -3724,7 +4021,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,
@@ -3762,7 +4059,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
             });
@@ -3770,7 +4067,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
             });
@@ -3783,7 +4080,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, {
@@ -3812,7 +4109,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;
@@ -4551,7 +4848,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}`));
       }
@@ -4631,9 +4928,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,
@@ -4655,7 +4952,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),
@@ -4734,7 +5031,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,
@@ -4770,11 +5067,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, {
@@ -4811,8 +5108,53 @@ var SenseVoiceWorker = class {
   }
 };
 
+// src/inference/defaultModelUrls.ts
+var HF = "https://huggingface.co";
+var HF_MODEL_URLS = {
+  /** LAM A2E model — fp16 external data (385KB graph + 192MB weights, WebGPU) — 52 ARKit blendshapes */
+  lam: `${HF}/omote-ai/lam-a2e/resolve/main/model_fp16.onnx`,
+  /** wav2arkit_cpu A2E model graph (1.86MB, WASM) — Safari/iOS fallback */
+  wav2arkitCpu: `${HF}/myned-ai/wav2arkit_cpu/resolve/main/wav2arkit_cpu.onnx`,
+  /** SenseVoice ASR model (228MB int8, WASM) — speech recognition + emotion + language */
+  senseVoice: `${HF}/omote-ai/sensevoice-asr/resolve/main/model.int8.onnx`,
+  /** Silero VAD model (~2MB, WASM) — voice activity detection */
+  sileroVad: `${HF}/deepghs/silero-vad-onnx/resolve/main/silero_vad.onnx`
+};
+var _overrides = {};
+var DEFAULT_MODEL_URLS = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      const key = prop;
+      return _overrides[key] ?? HF_MODEL_URLS[key];
+    },
+    ownKeys() {
+      return Object.keys(HF_MODEL_URLS);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop in HF_MODEL_URLS) {
+        return { configurable: true, enumerable: true, value: this.get(_target, prop, _target) };
+      }
+      return void 0;
+    }
+  }
+);
+function configureModelUrls(urls) {
+  for (const [key, url] of Object.entries(urls)) {
+    if (key in HF_MODEL_URLS && typeof url === "string") {
+      _overrides[key] = url;
+    }
+  }
+}
+function resetModelUrls() {
+  for (const key of Object.keys(_overrides)) {
+    delete _overrides[key];
+  }
+}
+var HF_CDN_URLS = HF_MODEL_URLS;
+
 // 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;
@@ -5514,7 +5856,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() },
@@ -5523,7 +5865,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) {
@@ -5697,7 +6039,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;
@@ -5711,7 +6053,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;
@@ -5733,7 +6075,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
         });
@@ -5799,7 +6141,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
@@ -5864,7 +6206,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)
       });
@@ -5970,7 +6312,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,
@@ -6051,12 +6393,13 @@ var SileroVADUnifiedAdapter = class {
 };
 
 // src/inference/createSenseVoice.ts
-var logger8 = createLogger("createSenseVoice");
-function createSenseVoice(config) {
+var logger9 = createLogger("createSenseVoice");
+function createSenseVoice(config = {}) {
+  const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.senseVoice;
   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,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       textNorm: config.textNorm
@@ -6067,37 +6410,37 @@ 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,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       textNorm: config.textNorm
     });
   }
   if (useWorker === false) {
-    logger8.info("Creating SenseVoiceInference (main thread)");
+    logger9.info("Creating SenseVoiceInference (main thread)");
     return new SenseVoiceInference({
-      modelUrl: config.modelUrl,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       textNorm: config.textNorm
     });
   }
   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,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       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({
-    modelUrl: config.modelUrl,
+    modelUrl,
     tokensUrl: config.tokensUrl,
     language: config.language,
     textNorm: config.textNorm
@@ -6105,7 +6448,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";
@@ -6147,16 +6490,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
         });
@@ -6178,15 +6521,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) {
@@ -6197,31 +6540,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
@@ -6237,7 +6580,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,
@@ -6253,12 +6596,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
       });
@@ -6345,7 +6688,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
@@ -6373,7 +6716,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
             });
@@ -6381,7 +6724,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
             });
@@ -6394,7 +6737,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, {
@@ -6421,7 +6764,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;
@@ -6708,7 +7051,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}`));
       }
@@ -6784,10 +7127,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()
@@ -6805,7 +7148,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),
@@ -6890,7 +7233,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,
@@ -6920,12 +7263,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, {
@@ -6963,53 +7306,56 @@ var Wav2ArkitCpuWorker = class {
 };
 
 // src/inference/createA2E.ts
-var logger11 = createLogger("createA2E");
-function createA2E(config) {
+var logger12 = createLogger("createA2E");
+function createA2E(config = {}) {
   const mode = config.mode ?? "auto";
   const fallbackOnError = config.fallbackOnError ?? true;
+  const gpuModelUrl = config.gpuModelUrl ?? DEFAULT_MODEL_URLS.lam;
+  const cpuModelUrl = config.cpuModelUrl ?? DEFAULT_MODEL_URLS.wav2arkitCpu;
   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
+        modelUrl: 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
+        modelUrl: cpuModelUrl
       });
     }
-    logger11.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
+    logger12.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
     return new Wav2ArkitCpuInference({
-      modelUrl: config.cpuModelUrl
+      modelUrl: cpuModelUrl
     });
   }
+  const gpuExternalDataUrl = config.gpuExternalDataUrl !== void 0 ? config.gpuExternalDataUrl : void 0;
   const gpuInstance = new Wav2Vec2Inference({
-    modelUrl: config.gpuModelUrl,
-    externalDataUrl: config.gpuExternalDataUrl,
+    modelUrl: gpuModelUrl,
+    externalDataUrl: gpuExternalDataUrl,
     backend: config.gpuBackend ?? "auto",
     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 {
@@ -7017,6 +7363,7 @@ var A2EWithFallback = class {
     this.hasFallenBack = false;
     this.implementation = gpuInstance;
     this.config = config;
+    this.resolvedCpuModelUrl = config.cpuModelUrl ?? DEFAULT_MODEL_URLS.wav2arkitCpu;
   }
   get modelId() {
     return this.implementation.modelId;
@@ -7038,26 +7385,26 @@ 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 {
     }
     if (this.config.unifiedWorker) {
       this.implementation = new Wav2ArkitCpuUnifiedAdapter(this.config.unifiedWorker, {
-        modelUrl: this.config.cpuModelUrl
+        modelUrl: this.resolvedCpuModelUrl
       });
-      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
+        modelUrl: this.resolvedCpuModelUrl
       });
-      logger11.info("Fallback to Wav2ArkitCpuWorker successful");
+      logger12.info("Fallback to Wav2ArkitCpuWorker successful");
     } else {
       this.implementation = new Wav2ArkitCpuInference({
-        modelUrl: this.config.cpuModelUrl
+        modelUrl: this.resolvedCpuModelUrl
       });
-      logger11.info("Fallback to Wav2ArkitCpuInference successful");
+      logger12.info("Fallback to Wav2ArkitCpuInference successful");
     }
     this.hasFallenBack = true;
     return await this.implementation.load();
@@ -7261,7 +7608,7 @@ var EmphasisDetector = class {
 };
 
 // src/inference/SileroVADInference.ts
-var logger12 = createLogger("SileroVAD");
+var logger13 = createLogger("SileroVAD");
 var SileroVADInference = class {
   constructor(config) {
     this.session = null;
@@ -7335,23 +7682,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
       });
@@ -7360,7 +7707,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,
@@ -7415,7 +7762,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(
@@ -7521,7 +7868,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
       });
@@ -7575,7 +7922,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())
             });
@@ -7588,7 +7935,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
@@ -7619,7 +7966,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
             });
@@ -7662,7 +8009,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;
@@ -7947,7 +8294,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}`));
       }
@@ -8023,9 +8370,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
       });
@@ -8041,7 +8388,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),
@@ -8148,7 +8495,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())
             });
@@ -8161,7 +8508,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,
@@ -8229,63 +8576,65 @@ 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) {
+function createSileroVAD(config = {}) {
+  const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.sileroVad;
+  const resolvedConfig = { ...config, modelUrl };
   if (config.unifiedWorker) {
-    logger14.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
-    return new SileroVADUnifiedAdapter(config.unifiedWorker, config);
+    logger15.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
+    return new SileroVADUnifiedAdapter(config.unifiedWorker, resolvedConfig);
   }
   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,
+      modelUrl,
       sampleRate: config.sampleRate,
       threshold: config.threshold,
       preSpeechBufferChunks: config.preSpeechBufferChunks
     });
     if (fallbackOnError) {
-      return new VADWorkerWithFallback(worker, config);
+      return new VADWorkerWithFallback(worker, resolvedConfig);
     }
     return worker;
   }
-  logger14.info("Creating SileroVADInference (main thread)");
-  return new SileroVADInference(config);
+  logger15.info("Creating SileroVADInference (main thread)");
+  return new SileroVADInference(resolvedConfig);
 }
 var VADWorkerWithFallback = class {
-  constructor(worker, config) {
+  constructor(worker, resolvedConfig) {
     this.hasFallenBack = false;
     this.implementation = worker;
-    this.config = config;
+    this.resolvedConfig = resolvedConfig;
   }
   get backend() {
     if (!this.isLoaded) return null;
@@ -8304,16 +8653,16 @@ 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 {
         await this.implementation.dispose();
       } catch {
       }
-      this.implementation = new SileroVADInference(this.config);
+      this.implementation = new SileroVADInference(this.resolvedConfig);
       this.hasFallenBack = true;
-      logger14.info("Fallback to SileroVADInference successful");
+      logger15.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
     }
   }
@@ -8335,7 +8684,7 @@ var VADWorkerWithFallback = class {
 };
 
 // src/inference/A2EOrchestrator.ts
-var logger15 = createLogger("A2EOrchestrator");
+var logger16 = createLogger("A2EOrchestrator");
 var A2EOrchestrator = class {
   constructor(config) {
     this.a2e = null;
@@ -8376,7 +8725,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,
@@ -8393,7 +8742,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
@@ -8448,10 +8797,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;
     }
@@ -8479,7 +8828,7 @@ var A2EOrchestrator = class {
       });
       this.audioContext = null;
     }
-    logger15.info("Mic capture stopped");
+    logger16.info("Mic capture stopped");
   }
   /**
    * Dispose of all resources
@@ -8502,7 +8851,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;
@@ -8521,7 +8870,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
     });
@@ -8582,7 +8931,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger16.warn("Already listening");
+      logger17.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -8612,7 +8961,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();
@@ -8627,7 +8976,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,
@@ -8656,7 +9005,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");
     }
   }
   /**
@@ -8687,7 +9036,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
@@ -8715,7 +9064,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
@@ -8725,12 +9074,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);
@@ -8740,7 +9089,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
       });
@@ -8757,13 +9106,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");
     };
   }
   /**
@@ -8774,7 +9123,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger16.error("Error in result callback", { error });
+        logger17.error("Error in result callback", { error });
       }
     }
   }
@@ -8786,7 +9135,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 });
       }
     }
   }
@@ -9356,338 +9705,32 @@ 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
+import { createNoise2D } from "simplex-noise";
+var simplex2d = createNoise2D();
+var LIFE_BS_INDEX = /* @__PURE__ */ new Map();
+for (let i = 0; i < LAM_BLENDSHAPES.length; i++) {
+  LIFE_BS_INDEX.set(LAM_BLENDSHAPES[i], i);
+}
 var PHASE_OPEN = 0;
 var PHASE_CLOSING = 1;
 var PHASE_CLOSED = 2;
 var PHASE_OPENING = 3;
-var BLINK_CLOSE_DURATION = 0.06;
+var BLINK_CLOSE_DURATION = 0.092;
 var BLINK_HOLD_DURATION = 0.04;
-var BLINK_OPEN_DURATION = 0.15;
+var BLINK_OPEN_DURATION = 0.242;
 var BLINK_ASYMMETRY_DELAY = 8e-3;
+var BLINK_IBI_MU = Math.log(5.97);
+var BLINK_IBI_SIGMA = 0.89;
 var GAZE_BREAK_DURATION = 0.12;
 var GAZE_BREAK_HOLD_DURATION = 0.3;
 var GAZE_BREAK_RETURN_DURATION = 0.15;
+var GAZE_STATE_PARAMS = {
+  idle: { interval: [2, 5], amplitude: [0.15, 0.4] },
+  listening: { interval: [4, 10], amplitude: [0.1, 0.25] },
+  thinking: { interval: [1, 3], amplitude: [0.2, 0.5] },
+  speaking: { interval: [2, 6], amplitude: [0.15, 0.35] }
+};
 var EYE_NOISE_X_FREQ = 0.8;
 var EYE_NOISE_Y_FREQ = 0.6;
 var EYE_NOISE_X_PHASE = 73.1;
@@ -9715,6 +9758,12 @@ function smoothStep(t) {
 function softClamp(v, max) {
   return Math.tanh(v / max) * max;
 }
+function sampleLogNormal(mu, sigma) {
+  const u1 = Math.random();
+  const u2 = Math.random();
+  const z = Math.sqrt(-2 * Math.log(u1 || 1e-10)) * Math.cos(2 * Math.PI * u2);
+  return Math.exp(mu + sigma * z);
+}
 var ProceduralLifeLayer = class {
   constructor(config) {
     // Blink state
@@ -9727,7 +9776,7 @@ var ProceduralLifeLayer = class {
     // Eye contact (smoothed)
     this.smoothedEyeX = 0;
     this.smoothedEyeY = 0;
-    // Eye micro-motion (continuous simplex noise, no discrete events)
+    // Eye micro-motion
     this.eyeNoiseTime = 0;
     // Gaze break state
     this.gazeBreakTimer = 0;
@@ -9737,6 +9786,8 @@ var ProceduralLifeLayer = class {
     this.gazeBreakTargetY = 0;
     this.gazeBreakCurrentX = 0;
     this.gazeBreakCurrentY = 0;
+    // Conversational state for gaze
+    this.currentState = null;
     // Breathing / postural sway
     this.microMotionTime = 0;
     this.breathingPhase = 0;
@@ -9745,6 +9796,7 @@ var ProceduralLifeLayer = class {
     this.previousEnergy = 0;
     this.emphasisLevel = 0;
     this.blinkIntervalRange = config?.blinkIntervalRange ?? [2.5, 6];
+    this.useLogNormalBlinks = !config?.blinkIntervalRange;
     this.gazeBreakIntervalRange = config?.gazeBreakIntervalRange ?? [3, 8];
     this.gazeBreakAmplitudeRange = config?.gazeBreakAmplitudeRange ?? [0.15, 0.4];
     this.eyeNoiseAmplitude = config?.eyeNoiseAmplitude ?? 0.06;
@@ -9754,7 +9806,7 @@ var ProceduralLifeLayer = class {
     this.posturalSwayAmplitude = config?.posturalSwayAmplitude ?? 2e-3;
     this.eyeMaxDeviation = config?.eyeMaxDeviation ?? 0.8;
     this.eyeSmoothing = config?.eyeSmoothing ?? 15;
-    this.blinkInterval = randomRange(...this.blinkIntervalRange);
+    this.blinkInterval = this.nextBlinkInterval();
     this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
   }
   /**
@@ -9769,6 +9821,7 @@ var ProceduralLifeLayer = class {
     const eyeTargetY = input?.eyeTargetY ?? 0;
     const audioEnergy = input?.audioEnergy ?? 0;
     const isSpeaking = input?.isSpeaking ?? false;
+    this.currentState = input?.state ?? null;
     const safeDelta = Math.min(delta, 0.1);
     const blendshapes = {};
     this.updateBlinks(delta);
@@ -9807,6 +9860,12 @@ var ProceduralLifeLayer = class {
     const swayAmp = this.posturalSwayAmplitude;
     const swayX = Math.sin(this.microMotionTime * 0.7) * swayAmp + Math.sin(this.microMotionTime * 1.3) * swayAmp * 0.5;
     const swayY = Math.sin(this.microMotionTime * 0.5) * swayAmp * 0.75 + Math.sin(this.microMotionTime * 0.9) * swayAmp * 0.5;
+    const breathVal = Math.sin(this.breathingPhase);
+    if (breathVal > 0) {
+      blendshapes["jawOpen"] = breathVal * 0.015;
+      blendshapes["noseSneerLeft"] = breathVal * 8e-3;
+      blendshapes["noseSneerRight"] = breathVal * 8e-3;
+    }
     return {
       blendshapes,
       headDelta: {
@@ -9815,12 +9874,35 @@ var ProceduralLifeLayer = class {
       }
     };
   }
+  /**
+   * Write life layer output directly to a Float32Array[52] in LAM_BLENDSHAPES order.
+   *
+   * Includes micro-jitter (0.4% amplitude simplex noise on all channels) to
+   * break uncanny stillness on undriven channels.
+   *
+   * @param delta - Time since last frame in seconds
+   * @param input - Per-frame input
+   * @param out - Pre-allocated Float32Array(52) to write into
+   */
+  updateToArray(delta, input, out) {
+    out.fill(0);
+    const result = this.update(delta, input);
+    for (const [name, value] of Object.entries(result.blendshapes)) {
+      const idx = LIFE_BS_INDEX.get(name);
+      if (idx !== void 0) {
+        out[idx] = value;
+      }
+    }
+    for (let i = 0; i < 52; i++) {
+      out[i] += simplex2d(this.noiseTime * 0.3, i * 7.13) * 4e-3;
+    }
+  }
   /**
    * Reset all internal state to initial values.
    */
   reset() {
     this.blinkTimer = 0;
-    this.blinkInterval = randomRange(...this.blinkIntervalRange);
+    this.blinkInterval = this.nextBlinkInterval();
     this.blinkPhase = PHASE_OPEN;
     this.blinkProgress = 0;
     this.asymmetryRight = 0.97;
@@ -9837,6 +9919,7 @@ var ProceduralLifeLayer = class {
     this.gazeBreakTargetY = 0;
     this.gazeBreakCurrentX = 0;
     this.gazeBreakCurrentY = 0;
+    this.currentState = null;
     this.microMotionTime = 0;
     this.breathingPhase = 0;
     this.noiseTime = 0;
@@ -9844,6 +9927,21 @@ var ProceduralLifeLayer = class {
     this.emphasisLevel = 0;
   }
   // =====================================================================
+  // PRIVATE: Blink interval sampling
+  // =====================================================================
+  /**
+   * Sample next blink interval.
+   * Uses log-normal distribution (PMC3565584) when using default config,
+   * or uniform random when custom blinkIntervalRange is provided.
+   */
+  nextBlinkInterval() {
+    if (this.useLogNormalBlinks) {
+      const sample = sampleLogNormal(BLINK_IBI_MU, BLINK_IBI_SIGMA);
+      return clamp(sample, 1.5, 12);
+    }
+    return randomRange(...this.blinkIntervalRange);
+  }
+  // =====================================================================
   // PRIVATE: Blink system
   // =====================================================================
   updateBlinks(delta) {
@@ -9852,7 +9950,7 @@ var ProceduralLifeLayer = class {
       this.blinkPhase = PHASE_CLOSING;
       this.blinkProgress = 0;
       this.blinkTimer = 0;
-      this.blinkInterval = randomRange(...this.blinkIntervalRange);
+      this.blinkInterval = this.nextBlinkInterval();
       this.asymmetryRight = 0.95 + Math.random() * 0.08;
     }
     if (this.blinkPhase > PHASE_OPEN) {
@@ -9908,18 +10006,32 @@ var ProceduralLifeLayer = class {
     return { x, y };
   }
   // =====================================================================
-  // PRIVATE: Gaze breaks
+  // PRIVATE: Gaze breaks (state-dependent)
   // =====================================================================
+  /**
+   * Get active gaze parameters — uses state-dependent params when
+   * conversational state is provided, otherwise falls back to config ranges.
+   */
+  getActiveGazeParams() {
+    if (this.currentState && GAZE_STATE_PARAMS[this.currentState]) {
+      return GAZE_STATE_PARAMS[this.currentState];
+    }
+    return {
+      interval: this.gazeBreakIntervalRange,
+      amplitude: this.gazeBreakAmplitudeRange
+    };
+  }
   updateGazeBreaks(delta) {
     this.gazeBreakTimer += delta;
     if (this.gazeBreakTimer >= this.gazeBreakInterval && this.gazeBreakPhase === PHASE_OPEN) {
       this.gazeBreakPhase = PHASE_CLOSING;
       this.gazeBreakProgress = 0;
       this.gazeBreakTimer = 0;
-      const amp = randomRange(...this.gazeBreakAmplitudeRange);
+      const params = this.getActiveGazeParams();
+      const amp = randomRange(...params.amplitude);
       this.gazeBreakTargetX = (Math.random() - 0.5) * 2 * amp;
       this.gazeBreakTargetY = (Math.random() - 0.5) * amp * 0.4;
-      this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
+      this.gazeBreakInterval = randomRange(...params.interval);
     }
     if (this.gazeBreakPhase > PHASE_OPEN) {
       this.gazeBreakProgress += delta;
@@ -9984,6 +10096,971 @@ var ProceduralLifeLayer = class {
   }
 };
 
+// src/face/FACSMapping.ts
+var EMOTION_TO_AU = {
+  joy: [
+    { au: "AU6", intensity: 0.7, region: "upper" },
+    // cheek raise (Duchenne)
+    { au: "AU12", intensity: 0.8, region: "lower" }
+    // lip corner pull (smile)
+  ],
+  anger: [
+    { au: "AU4", intensity: 0.8, region: "upper" },
+    // brow lower
+    { au: "AU5", intensity: 0.4, region: "upper" },
+    // upper lid raise
+    { au: "AU7", intensity: 0.3, region: "upper" },
+    // lid tighten
+    { au: "AU23", intensity: 0.6, region: "lower" }
+    // lip tighten
+  ],
+  sadness: [
+    { au: "AU1", intensity: 0.7, region: "upper" },
+    // inner brow raise
+    { au: "AU4", intensity: 0.3, region: "upper" },
+    // brow lower (furrow)
+    { au: "AU15", intensity: 0.5, region: "lower" }
+    // lip corner depress
+  ],
+  fear: [
+    { au: "AU1", intensity: 0.6, region: "upper" },
+    // inner brow raise
+    { au: "AU2", intensity: 0.5, region: "upper" },
+    // outer brow raise
+    { au: "AU4", intensity: 0.3, region: "upper" },
+    // brow lower
+    { au: "AU5", intensity: 0.5, region: "upper" },
+    // upper lid raise
+    { au: "AU20", intensity: 0.4, region: "lower" }
+    // lip stretch
+  ],
+  disgust: [
+    { au: "AU9", intensity: 0.7, region: "upper" },
+    // nose wrinkle
+    { au: "AU10", intensity: 0.5, region: "lower" },
+    // upper lip raise
+    { au: "AU15", intensity: 0.4, region: "lower" }
+    // lip corner depress
+  ],
+  amazement: [
+    { au: "AU1", intensity: 0.6, region: "upper" },
+    // inner brow raise
+    { au: "AU2", intensity: 0.7, region: "upper" },
+    // outer brow raise
+    { au: "AU5", intensity: 0.6, region: "upper" },
+    // upper lid raise
+    { au: "AU26", intensity: 0.4, region: "lower" }
+    // jaw drop
+  ],
+  grief: [
+    { au: "AU1", intensity: 0.8, region: "upper" },
+    // inner brow raise
+    { au: "AU4", intensity: 0.5, region: "upper" },
+    // brow lower
+    { au: "AU6", intensity: 0.3, region: "upper" },
+    // cheek raise (grief cry)
+    { au: "AU15", intensity: 0.6, region: "lower" }
+    // lip corner depress
+  ],
+  cheekiness: [
+    { au: "AU2", intensity: 0.4, region: "upper" },
+    // outer brow raise
+    { au: "AU6", intensity: 0.4, region: "upper" },
+    // cheek raise
+    { au: "AU12", intensity: 0.6, region: "lower" }
+    // lip corner pull (smirk)
+  ],
+  pain: [
+    { au: "AU4", intensity: 0.7, region: "upper" },
+    // brow lower
+    { au: "AU6", intensity: 0.4, region: "upper" },
+    // cheek raise (orbicularis)
+    { au: "AU7", intensity: 0.7, region: "upper" },
+    // lid tighten (squint)
+    { au: "AU9", intensity: 0.5, region: "upper" }
+    // nose wrinkle
+  ],
+  outofbreath: [
+    { au: "AU1", intensity: 0.3, region: "upper" },
+    // inner brow raise
+    { au: "AU25", intensity: 0.3, region: "lower" },
+    // lips part
+    { au: "AU26", intensity: 0.5, region: "lower" }
+    // jaw drop
+  ]
+};
+var AU_TO_ARKIT = {
+  "AU1": [{ blendshape: "browInnerUp", weight: 1 }],
+  "AU2": [{ blendshape: "browOuterUpLeft", weight: 1 }, { blendshape: "browOuterUpRight", weight: 1 }],
+  "AU4": [{ blendshape: "browDownLeft", weight: 1 }, { blendshape: "browDownRight", weight: 1 }],
+  "AU5": [{ blendshape: "eyeWideLeft", weight: 1 }, { blendshape: "eyeWideRight", weight: 1 }],
+  "AU6": [{ blendshape: "cheekSquintLeft", weight: 1 }, { blendshape: "cheekSquintRight", weight: 1 }],
+  "AU7": [{ blendshape: "eyeSquintLeft", weight: 1 }, { blendshape: "eyeSquintRight", weight: 1 }],
+  "AU9": [{ blendshape: "noseSneerLeft", weight: 1 }, { blendshape: "noseSneerRight", weight: 1 }],
+  "AU10": [{ blendshape: "mouthUpperUpLeft", weight: 1 }, { blendshape: "mouthUpperUpRight", weight: 1 }],
+  "AU12": [{ blendshape: "mouthSmileLeft", weight: 1 }, { blendshape: "mouthSmileRight", weight: 1 }],
+  "AU15": [{ blendshape: "mouthFrownLeft", weight: 1 }, { blendshape: "mouthFrownRight", weight: 1 }],
+  "AU20": [{ blendshape: "mouthStretchLeft", weight: 1 }, { blendshape: "mouthStretchRight", weight: 1 }],
+  "AU23": [{ blendshape: "mouthPressLeft", weight: 1 }, { blendshape: "mouthPressRight", weight: 1 }],
+  "AU25": [{ blendshape: "jawOpen", weight: 0.3 }],
+  "AU26": [{ blendshape: "jawOpen", weight: 1 }]
+};
+var ALL_AUS = [...new Set(
+  Object.values(EMOTION_TO_AU).flatMap((activations) => activations.map((a) => a.au))
+)];
+
+// src/face/EmotionResolver.ts
+var BS_INDEX = /* @__PURE__ */ new Map();
+for (let i = 0; i < LAM_BLENDSHAPES.length; i++) {
+  BS_INDEX.set(LAM_BLENDSHAPES[i], i);
+}
+var EmotionResolver = class {
+  constructor() {
+    this.upperBuffer = new Float32Array(52);
+    this.lowerBuffer = new Float32Array(52);
+  }
+  /**
+   * Resolve emotion weights to upper/lower face blendshape contributions.
+   *
+   * @param weights - Emotion channel weights from EmotionController
+   * @param intensity - Global intensity multiplier (0-2). Default: 1.0
+   * @returns Upper and lower face blendshape arrays (52 channels each)
+   */
+  resolve(weights, intensity = 1) {
+    const upper = this.upperBuffer;
+    const lower = this.lowerBuffer;
+    upper.fill(0);
+    lower.fill(0);
+    for (const emotionName of EMOTION_NAMES) {
+      const emotionWeight = weights[emotionName];
+      if (!emotionWeight || emotionWeight < 0.01) continue;
+      const auActivations = EMOTION_TO_AU[emotionName];
+      if (!auActivations) continue;
+      for (const activation of auActivations) {
+        const arkitMappings = AU_TO_ARKIT[activation.au];
+        if (!arkitMappings) continue;
+        const target = activation.region === "upper" ? upper : lower;
+        const scale = emotionWeight * activation.intensity * intensity;
+        for (const mapping of arkitMappings) {
+          const idx = BS_INDEX.get(mapping.blendshape);
+          if (idx !== void 0) {
+            target[idx] += mapping.weight * scale;
+          }
+        }
+      }
+    }
+    for (let i = 0; i < 52; i++) {
+      if (upper[i] > 1) upper[i] = 1;
+      if (lower[i] > 1) lower[i] = 1;
+    }
+    return {
+      upper: new Float32Array(upper),
+      lower: new Float32Array(lower)
+    };
+  }
+};
+
+// src/face/FaceCompositor.ts
+function smoothstep(t) {
+  return t * t * (3 - 2 * t);
+}
+var BS_INDEX2 = /* @__PURE__ */ new Map();
+for (let i = 0; i < LAM_BLENDSHAPES.length; i++) {
+  BS_INDEX2.set(LAM_BLENDSHAPES[i], i);
+}
+var IDX_MOUTH_CLOSE = BS_INDEX2.get("mouthClose");
+var IS_EYE_CHANNEL = new Array(52).fill(false);
+for (const name of LAM_BLENDSHAPES) {
+  if (name.startsWith("eyeBlink") || name.startsWith("eyeLook")) {
+    IS_EYE_CHANNEL[BS_INDEX2.get(name)] = true;
+  }
+}
+var FaceCompositor = class {
+  constructor(config) {
+    this.emotionResolver = new EmotionResolver();
+    // Pre-allocated buffers
+    this.smoothedUpper = new Float32Array(52);
+    this.smoothedLower = new Float32Array(52);
+    this.lifeBuffer = new Float32Array(52);
+    // Profile arrays (pre-expanded to 52 channels)
+    this.multiplier = new Float32Array(52).fill(1);
+    this.offset = new Float32Array(52);
+    this.lifeLayer = config?.lifeLayer ?? new ProceduralLifeLayer();
+    this.emotionSmoothing = config?.emotionSmoothing ?? 0.12;
+    if (config?.profile) {
+      this.applyProfileArrays(config.profile);
+    }
+  }
+  /**
+   * Compose a single output frame from the 5-stage signal chain.
+   *
+   * @param base - A2E raw output (Float32Array[52], LAM_BLENDSHAPES order)
+   * @param input - Per-frame input (deltaTime, emotion, life layer params)
+   * @returns Float32Array[52] with all values clamped to [0, 1]
+   */
+  compose(base, input) {
+    const out = new Float32Array(52);
+    out.set(base);
+    const emotion = input.emotion ?? this.stickyEmotion;
+    if (emotion) {
+      const resolved = this.emotionResolver.resolve(
+        emotion,
+        input.emotionIntensity ?? 1
+      );
+      const k = this.emotionSmoothing;
+      for (let i = 0; i < 52; i++) {
+        this.smoothedUpper[i] += (resolved.upper[i] - this.smoothedUpper[i]) * k;
+        this.smoothedLower[i] += (resolved.lower[i] - this.smoothedLower[i]) * k;
+      }
+      const mc = base[IDX_MOUTH_CLOSE];
+      const bilabialSuppress = mc <= 0.3 ? 1 : mc >= 0.7 ? 0.1 : 1 - 0.9 * smoothstep((mc - 0.3) * 2.5);
+      for (let i = 0; i < 52; i++) {
+        out[i] += this.smoothedUpper[i];
+      }
+      for (let i = 0; i < 52; i++) {
+        out[i] *= 1 + this.smoothedLower[i] * bilabialSuppress;
+      }
+    }
+    this.lifeLayer.updateToArray(input.deltaTime, input, this.lifeBuffer);
+    for (let i = 0; i < 52; i++) {
+      if (IS_EYE_CHANNEL[i]) {
+        out[i] = this.lifeBuffer[i];
+      } else {
+        out[i] += this.lifeBuffer[i];
+      }
+    }
+    for (let i = 0; i < 52; i++) {
+      out[i] = out[i] * this.multiplier[i] + this.offset[i];
+    }
+    for (let i = 0; i < 52; i++) {
+      if (out[i] < 0) out[i] = 0;
+      else if (out[i] > 1) out[i] = 1;
+    }
+    return out;
+  }
+  /**
+   * Set sticky emotion (used when input.emotion is not provided).
+   */
+  setEmotion(weights) {
+    this.stickyEmotion = weights;
+  }
+  /**
+   * Update character profile at runtime.
+   */
+  setProfile(profile) {
+    this.multiplier.fill(1);
+    this.offset.fill(0);
+    this.applyProfileArrays(profile);
+  }
+  /**
+   * Reset all smoothing state and life layer.
+   */
+  reset() {
+    this.smoothedUpper.fill(0);
+    this.smoothedLower.fill(0);
+    this.lifeBuffer.fill(0);
+    this.stickyEmotion = void 0;
+    this.lifeLayer.reset();
+  }
+  /** Expand partial profile maps into dense Float32Arrays */
+  applyProfileArrays(profile) {
+    if (profile.multiplier) {
+      for (const [name, value] of Object.entries(profile.multiplier)) {
+        const idx = BS_INDEX2.get(name);
+        if (idx !== void 0 && value !== void 0) {
+          this.multiplier[idx] = value;
+        }
+      }
+    }
+    if (profile.offset) {
+      for (const [name, value] of Object.entries(profile.offset)) {
+        const idx = BS_INDEX2.get(name);
+        if (idx !== void 0 && value !== void 0) {
+          this.offset[idx] = value;
+        }
+      }
+    }
+  }
+};
+
+// 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) {
@@ -9992,7 +11069,9 @@ function isProtocolEvent(obj) {
 export {
   A2EOrchestrator,
   A2EProcessor,
+  ALL_AUS,
   ARKIT_BLENDSHAPES,
+  AU_TO_ARKIT,
   AnimationGraph,
   AudioChunkCoalescer,
   AudioEnergyAnalyzer,
@@ -10003,24 +11082,31 @@ export {
   ConsoleExporter,
   DEFAULT_ANIMATION_CONFIG,
   DEFAULT_LOGGING_CONFIG,
+  DEFAULT_MODEL_URLS,
   EMOTION_NAMES,
+  EMOTION_TO_AU,
   EMOTION_VECTOR_SIZE,
   EmotionController,
   EmotionPresets,
+  EmotionResolver,
   EmphasisDetector,
   EventEmitter,
+  FaceCompositor,
   FullFacePipeline,
+  HF_CDN_URLS,
   INFERENCE_LATENCY_BUCKETS,
   InterruptionHandler,
   LAM_BLENDSHAPES,
   LOG_LEVEL_PRIORITY,
   MODEL_LOAD_TIME_BUCKETS,
   MetricNames,
+  MicLipSync,
   MicrophoneCapture,
   ModelCache,
   OTLPExporter,
   OmoteTelemetry,
   PROTOCOL_VERSION,
+  PlaybackPipeline,
   ProceduralLifeLayer,
   RingBuffer,
   SafariSpeechRecognition,
@@ -10031,15 +11117,18 @@ export {
   SileroVADUnifiedAdapter,
   SileroVADWorker,
   UnifiedInferenceWorker,
+  VoicePipeline,
   Wav2ArkitCpuInference,
   Wav2ArkitCpuUnifiedAdapter,
   Wav2ArkitCpuWorker,
   Wav2Vec2Inference,
+  applyProfile,
   blendEmotions,
   calculatePeak,
   calculateRMS,
   configureCacheLimit,
   configureLogging,
+  configureModelUrls,
   configureTelemetry,
   createA2E,
   createEmotionVector,
@@ -10070,6 +11159,7 @@ export {
   noopLogger,
   preloadModels,
   resetLoggingConfig,
+  resetModelUrls,
   resolveBackend,
   setLogLevel,
   setLoggingEnabled,