@omote/core 0.6.2 → 0.6.4

package/dist/index.mjs

@@ -2552,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);
             }
@@ -2560,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
@@ -2683,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
    */
@@ -2732,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, {
@@ -2776,11 +2745,7 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
           });
           resolve({
             blendshapes,
-            asrLogits,
-            text,
             numFrames: numA2EFrames,
-            numA2EFrames,
-            numASRFrames,
             inferenceTimeMs
           });
         } catch (err) {
@@ -5143,6 +5108,51 @@ 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 logger8 = createLogger("UnifiedInferenceWorker");
 var WASM_CDN_PATH3 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
@@ -6384,11 +6394,12 @@ var SileroVADUnifiedAdapter = class {
 
 // src/inference/createSenseVoice.ts
 var logger9 = createLogger("createSenseVoice");
-function createSenseVoice(config) {
+function createSenseVoice(config = {}) {
+  const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.senseVoice;
   if (config.unifiedWorker) {
     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
@@ -6401,7 +6412,7 @@ function createSenseVoice(config) {
     }
     logger9.info("Creating SenseVoiceWorker (off-main-thread)");
     return new SenseVoiceWorker({
-      modelUrl: config.modelUrl,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       textNorm: config.textNorm
@@ -6410,7 +6421,7 @@ function createSenseVoice(config) {
   if (useWorker === false) {
     logger9.info("Creating SenseVoiceInference (main thread)");
     return new SenseVoiceInference({
-      modelUrl: config.modelUrl,
+      modelUrl,
       tokensUrl: config.tokensUrl,
       language: config.language,
       textNorm: config.textNorm
@@ -6419,7 +6430,7 @@ function createSenseVoice(config) {
   if (SenseVoiceWorker.isSupported() && !isIOS()) {
     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
@@ -6429,7 +6440,7 @@ function createSenseVoice(config) {
     reason: isIOS() ? "iOS (shared ORT instance)" : "Worker unsupported"
   });
   return new SenseVoiceInference({
-    modelUrl: config.modelUrl,
+    modelUrl,
     tokensUrl: config.tokensUrl,
     language: config.language,
     textNorm: config.textNorm
@@ -7296,9 +7307,11 @@ var Wav2ArkitCpuWorker = class {
 
 // src/inference/createA2E.ts
 var logger12 = createLogger("createA2E");
-function createA2E(config) {
+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;
@@ -7317,23 +7330,24 @@ function createA2E(config) {
     if (config.unifiedWorker) {
       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()) {
       logger12.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
       return new Wav2ArkitCpuWorker({
-        modelUrl: config.cpuModelUrl
+        modelUrl: cpuModelUrl
       });
     }
     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
   });
@@ -7349,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;
@@ -7377,17 +7392,17 @@ var A2EWithFallback = class {
     }
     if (this.config.unifiedWorker) {
       this.implementation = new Wav2ArkitCpuUnifiedAdapter(this.config.unifiedWorker, {
-        modelUrl: this.config.cpuModelUrl
+        modelUrl: this.resolvedCpuModelUrl
       });
       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
       });
       logger12.info("Fallback to Wav2ArkitCpuWorker successful");
     } else {
       this.implementation = new Wav2ArkitCpuInference({
-        modelUrl: this.config.cpuModelUrl
+        modelUrl: this.resolvedCpuModelUrl
       });
       logger12.info("Fallback to Wav2ArkitCpuInference successful");
     }
@@ -8577,10 +8592,12 @@ function supportsVADWorker() {
   }
   return true;
 }
-function createSileroVAD(config) {
+function createSileroVAD(config = {}) {
+  const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.sileroVad;
+  const resolvedConfig = { ...config, modelUrl };
   if (config.unifiedWorker) {
     logger15.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
-    return new SileroVADUnifiedAdapter(config.unifiedWorker, config);
+    return new SileroVADUnifiedAdapter(config.unifiedWorker, resolvedConfig);
   }
   const fallbackOnError = config.fallbackOnError ?? true;
   let useWorker;
@@ -8600,24 +8617,24 @@ function createSileroVAD(config) {
   if (useWorker) {
     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;
   }
   logger15.info("Creating SileroVADInference (main thread)");
-  return new SileroVADInference(config);
+  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;
@@ -8643,7 +8660,7 @@ var VADWorkerWithFallback = class {
         await this.implementation.dispose();
       } catch {
       }
-      this.implementation = new SileroVADInference(this.config);
+      this.implementation = new SileroVADInference(this.resolvedConfig);
       this.hasFallenBack = true;
       logger15.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
@@ -9691,17 +9708,29 @@ var AnimationGraph = class extends EventEmitter {
 // 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;
@@ -9729,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
@@ -9741,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;
@@ -9751,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;
@@ -9759,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;
@@ -9768,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);
   }
   /**
@@ -9783,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);
@@ -9821,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: {
@@ -9829,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;
@@ -9851,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;
@@ -9858,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) {
@@ -9866,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) {
@@ -9922,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;
@@ -9998,6 +10096,293 @@ 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 {
@@ -10684,7 +11069,9 @@ function isProtocolEvent(obj) {
 export {
   A2EOrchestrator,
   A2EProcessor,
+  ALL_AUS,
   ARKIT_BLENDSHAPES,
+  AU_TO_ARKIT,
   AnimationGraph,
   AudioChunkCoalescer,
   AudioEnergyAnalyzer,
@@ -10695,13 +11082,18 @@ 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,
@@ -10736,6 +11128,7 @@ export {
   calculateRMS,
   configureCacheLimit,
   configureLogging,
+  configureModelUrls,
   configureTelemetry,
   createA2E,
   createEmotionVector,
@@ -10766,6 +11159,7 @@ export {
   noopLogger,
   preloadModels,
   resetLoggingConfig,
+  resetModelUrls,
   resolveBackend,
   setLogLevel,
   setLoggingEnabled,