@omote/core 0.1.3 → 0.2.0

package/dist/index.mjs

@@ -220,6 +220,19 @@ var AudioScheduler = class {
   async initialize() {
     console.log("[AudioScheduler] Ready for lazy initialization");
   }
+  /**
+   * Eagerly create and warm up the AudioContext
+   *
+   * Call this when a playback session starts (e.g., when AI response begins).
+   * The AudioContext needs time to initialize the audio hardware — on Windows
+   * this can take 50-100ms. By warming up early (before audio data arrives),
+   * the context is fully ready when schedule() is first called.
+   *
+   * Must be called after a user gesture (click/tap) for autoplay policy.
+   */
+  async warmup() {
+    await this.ensureContext();
+  }
   /**
    * Ensure AudioContext is created and ready
    * Called lazily on first schedule() - requires user gesture
@@ -250,7 +263,7 @@ var AudioScheduler = class {
     const ctx = await this.ensureContext();
     const channels = this.options.channels ?? 1;
     if (!this.isPlaying) {
-      this.nextPlayTime = ctx.currentTime;
+      this.nextPlayTime = ctx.currentTime + 0.05;
       this.isPlaying = true;
     }
     const audioBuffer = ctx.createBuffer(channels, audioData.length, ctx.sampleRate);
@@ -324,8 +337,19 @@ var AudioScheduler = class {
   }
   /**
    * Reset scheduler state for new playback session
+   * Stops any orphaned sources that weren't cleaned up by cancelAll()
    */
   reset() {
+    if (this.context) {
+      const now = this.context.currentTime;
+      for (const { source, gainNode } of this.scheduledSources) {
+        try {
+          gainNode.gain.setValueAtTime(0, now);
+          source.stop(now);
+        } catch {
+        }
+      }
+    }
     this.nextPlayTime = 0;
     this.isPlaying = false;
     this.scheduledSources = [];
@@ -453,7 +477,7 @@ var LAMPipeline = class {
     newBuffer.set(this.buffer, 0);
     newBuffer.set(samples, this.buffer.length);
     this.buffer = newBuffer;
-    if (this.buffer.length >= this.REQUIRED_SAMPLES) {
+    while (this.buffer.length >= this.REQUIRED_SAMPLES) {
       await this.processBuffer(lam);
     }
   }
@@ -606,12 +630,20 @@ var LAMPipeline = class {
 };
 
 // src/audio/SyncedAudioPipeline.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;
+}
 var SyncedAudioPipeline = class extends EventEmitter {
   constructor(options) {
     super();
     this.options = options;
-    this.waitingForFirstLAM = false;
-    this.bufferedChunks = [];
+    this.playbackStarted = false;
     this.monitorInterval = null;
     this.frameAnimationId = null;
     const sampleRate = options.sampleRate ?? 16e3;
@@ -622,11 +654,6 @@ var SyncedAudioPipeline = class extends EventEmitter {
     });
     this.lamPipeline = new LAMPipeline({
       sampleRate,
-      onInference: (frameCount) => {
-        if (this.waitingForFirstLAM) {
-          this.onFirstLAMComplete();
-        }
-      },
       onError: (error) => {
         this.emit("error", error);
       }
@@ -642,25 +669,24 @@ var SyncedAudioPipeline = class extends EventEmitter {
    * Start a new playback session
    *
    * Resets all state and prepares for incoming audio chunks.
-   * Enables wait-for-first-LAM synchronization.
+   * Audio will be scheduled immediately as chunks arrive (no buffering).
    */
   start() {
+    this.stopMonitoring();
     this.scheduler.reset();
     this.coalescer.reset();
     this.lamPipeline.reset();
-    this.bufferedChunks = [];
-    this.waitingForFirstLAM = true;
+    this.playbackStarted = false;
+    this.scheduler.warmup();
     this.startFrameLoop();
     this.startMonitoring();
   }
   /**
    * Receive audio chunk from network
    *
-   * Implements wait-for-first-LAM pattern:
-   * - Chunks are coalesced into optimal buffers
-   * - Buffers are sent to LAM for processing
-   * - Audio scheduling waits until first LAM completes
-   * - Then all buffered audio is scheduled together with LAM frames
+   * Audio-first design: schedules audio immediately, LAM runs in background.
+   * This prevents LAM inference (50-300ms) from blocking audio scheduling,
+   * which caused audible stuttering with continuous audio streams.
    *
    * @param chunk - Uint8Array containing Int16 PCM audio
    */
@@ -669,51 +695,15 @@ var SyncedAudioPipeline = class extends EventEmitter {
     if (!combined) {
       return;
     }
-    const int16 = new Int16Array(combined);
-    const float32 = new Float32Array(int16.length);
-    for (let i = 0; i < int16.length; i++) {
-      float32[i] = int16[i] / 32768;
-    }
-    if (this.waitingForFirstLAM) {
-      this.bufferedChunks.push(combined);
-      const estimatedTime = this.scheduler.getCurrentTime();
-      await this.lamPipeline.push(float32, estimatedTime, this.options.lam);
-    } else {
-      const scheduleTime = await this.scheduler.schedule(float32);
-      await this.lamPipeline.push(float32, scheduleTime, this.options.lam);
+    const float32 = pcm16ToFloat32(combined);
+    const scheduleTime = await this.scheduler.schedule(float32);
+    if (!this.playbackStarted) {
+      this.playbackStarted = true;
+      this.emit("playback_start", scheduleTime);
     }
-  }
-  /**
-   * Handle first LAM inference completion
-   *
-   * This is the critical synchronization point:
-   * - LAM frames are now ready in the queue
-   * - Schedule all buffered audio chunks
-   * - Adjust LAM frame timestamps to match actual schedule time
-   * - Audio and LAM start playing together, perfectly synchronized
-   */
-  async onFirstLAMComplete() {
-    this.waitingForFirstLAM = false;
-    const beforeSchedule = this.scheduler.getCurrentTime();
-    let actualStartTime = beforeSchedule;
-    for (let i = 0; i < this.bufferedChunks.length; i++) {
-      const buffer = this.bufferedChunks[i];
-      const int16 = new Int16Array(buffer);
-      const float32 = new Float32Array(int16.length);
-      for (let j = 0; j < int16.length; j++) {
-        float32[j] = int16[j] / 32768;
-      }
-      const scheduleTime = await this.scheduler.schedule(float32);
-      if (i === 0) {
-        actualStartTime = scheduleTime;
-      }
-    }
-    const timeOffset = actualStartTime - beforeSchedule;
-    if (timeOffset !== 0) {
-      this.lamPipeline.adjustTimestamps(timeOffset);
-    }
-    this.bufferedChunks = [];
-    this.emit("playback_start", actualStartTime);
+    this.lamPipeline.push(float32, scheduleTime, this.options.lam).catch((err) => {
+      this.emit("error", err);
+    });
   }
   /**
    * End of audio stream
@@ -745,10 +735,9 @@ var SyncedAudioPipeline = class extends EventEmitter {
   async stop(fadeOutMs = 50) {
     this.stopMonitoring();
     await this.scheduler.cancelAll(fadeOutMs);
-    this.bufferedChunks = [];
     this.coalescer.reset();
     this.lamPipeline.reset();
-    this.waitingForFirstLAM = false;
+    this.playbackStarted = false;
     this.emit("playback_complete", void 0);
   }
   /**
@@ -805,8 +794,7 @@ var SyncedAudioPipeline = class extends EventEmitter {
    */
   getState() {
     return {
-      waitingForFirstLAM: this.waitingForFirstLAM,
-      bufferedChunks: this.bufferedChunks.length,
+      playbackStarted: this.playbackStarted,
       coalescerFill: this.coalescer.fillLevel,
       lamFill: this.lamPipeline.fillLevel,
       queuedFrames: this.lamPipeline.queuedFrameCount,
@@ -822,7 +810,6 @@ var SyncedAudioPipeline = class extends EventEmitter {
     this.scheduler.dispose();
     this.coalescer.reset();
     this.lamPipeline.reset();
-    this.bufferedChunks = [];
   }
 };
 
@@ -2049,7 +2036,7 @@ function hasWebGPUApi() {
   return "gpu" in navigator && navigator.gpu !== void 0;
 }
 function getRecommendedBackend() {
-  if (isIOS()) {
+  if (isSafari() || isIOS()) {
     return "wasm";
   }
   return "webgpu";
@@ -2093,6 +2080,14 @@ function shouldEnableWasmProxy() {
   }
   return true;
 }
+function isSafari() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  return /safari/.test(ua) && !/chrome|crios|fxios|chromium|edg/.test(ua);
+}
+function shouldUseCpuLipSync() {
+  return isSafari();
+}
 function isSpeechRecognitionAvailable() {
   if (typeof window === "undefined") return false;
   return "SpeechRecognition" in window || "webkitSpeechRecognition" in window;
@@ -2239,8 +2234,7 @@ function isOnnxRuntimeLoaded() {
   return ortInstance !== null;
 }
 
-// src/inference/Wav2Vec2Inference.ts
-var logger2 = createLogger("Wav2Vec2");
+// src/inference/blendshapeUtils.ts
 var LAM_BLENDSHAPES = [
   "browDownLeft",
   "browDownRight",
@@ -2295,40 +2289,7 @@ var LAM_BLENDSHAPES = [
   "noseSneerRight",
   "tongueOut"
 ];
-var CTC_VOCAB = [
-  "<pad>",
-  "<s>",
-  "</s>",
-  "<unk>",
-  "|",
-  "E",
-  "T",
-  "A",
-  "O",
-  "N",
-  "I",
-  "H",
-  "S",
-  "R",
-  "D",
-  "L",
-  "U",
-  "M",
-  "W",
-  "C",
-  "F",
-  "G",
-  "Y",
-  "P",
-  "B",
-  "V",
-  "K",
-  "'",
-  "X",
-  "J",
-  "Q",
-  "Z"
-];
+var ARKIT_BLENDSHAPES = LAM_BLENDSHAPES;
 var ARKIT_SYMMETRIC_PAIRS = [
   ["jawLeft", "jawRight"],
   ["mouthLeft", "mouthRight"],
@@ -2364,6 +2325,107 @@ function symmetrizeBlendshapes(frame) {
   }
   return result;
 }
+var WAV2ARKIT_BLENDSHAPES = [
+  "browDownLeft",
+  "browDownRight",
+  "browInnerUp",
+  "browOuterUpLeft",
+  "browOuterUpRight",
+  "cheekPuff",
+  "cheekSquintLeft",
+  "cheekSquintRight",
+  "eyeBlinkLeft",
+  "eyeBlinkRight",
+  "eyeLookDownLeft",
+  "eyeLookDownRight",
+  "eyeLookInLeft",
+  "eyeLookInRight",
+  "eyeLookOutLeft",
+  "eyeLookOutRight",
+  "eyeLookUpLeft",
+  "eyeLookUpRight",
+  "eyeSquintLeft",
+  "eyeSquintRight",
+  "eyeWideLeft",
+  "eyeWideRight",
+  "jawForward",
+  "jawLeft",
+  "jawOpen",
+  "mouthFrownLeft",
+  "mouthFrownRight",
+  "mouthFunnel",
+  "mouthLeft",
+  "mouthLowerDownLeft",
+  "mouthLowerDownRight",
+  "mouthPressLeft",
+  "mouthPressRight",
+  "mouthPucker",
+  "mouthRight",
+  "mouthRollLower",
+  "mouthRollUpper",
+  "mouthShrugLower",
+  "mouthShrugUpper",
+  "mouthSmileLeft",
+  "mouthSmileRight",
+  "mouthStretchLeft",
+  "mouthStretchRight",
+  "mouthUpperUpLeft",
+  "mouthUpperUpRight",
+  "noseSneerLeft",
+  "noseSneerRight",
+  "tongueOut",
+  "mouthClose",
+  "mouthDimpleLeft",
+  "mouthDimpleRight",
+  "jawRight"
+];
+var REMAP_WAV2ARKIT_TO_LAM = WAV2ARKIT_BLENDSHAPES.map(
+  (name) => LAM_BLENDSHAPES.indexOf(name)
+);
+function remapWav2ArkitToLam(frame) {
+  const result = new Float32Array(52);
+  for (let i = 0; i < 52; i++) {
+    result[REMAP_WAV2ARKIT_TO_LAM[i]] = frame[i];
+  }
+  return result;
+}
+
+// src/inference/Wav2Vec2Inference.ts
+var logger2 = createLogger("Wav2Vec2");
+var CTC_VOCAB = [
+  "<pad>",
+  "<s>",
+  "</s>",
+  "<unk>",
+  "|",
+  "E",
+  "T",
+  "A",
+  "O",
+  "N",
+  "I",
+  "H",
+  "S",
+  "R",
+  "D",
+  "L",
+  "U",
+  "M",
+  "W",
+  "C",
+  "F",
+  "G",
+  "Y",
+  "P",
+  "B",
+  "V",
+  "K",
+  "'",
+  "X",
+  "J",
+  "Q",
+  "Z"
+];
 var Wav2Vec2Inference = class {
   constructor(config) {
     this.session = null;
@@ -2602,6 +2664,7 @@ var Wav2Vec2Inference = class {
             blendshapes,
             asrLogits,
             text,
+            numFrames: numA2EFrames,
             numA2EFrames,
             numASRFrames,
             inferenceTimeMs
@@ -2968,8 +3031,293 @@ var WhisperInference = class _WhisperInference {
   }
 };
 
+// src/inference/Wav2ArkitCpuInference.ts
+var logger5 = createLogger("Wav2ArkitCpu");
+var Wav2ArkitCpuInference = class {
+  constructor(config) {
+    this.session = null;
+    this.ort = null;
+    this._backend = "wasm";
+    this.isLoading = false;
+    // Inference queue for handling concurrent calls
+    this.inferenceQueue = Promise.resolve();
+    this.config = config;
+  }
+  get backend() {
+    return this.session ? this._backend : null;
+  }
+  get isLoaded() {
+    return this.session !== null;
+  }
+  /**
+   * Load the ONNX model
+   */
+  async load() {
+    if (this.isLoading) {
+      throw new Error("Model is already loading");
+    }
+    if (this.session) {
+      throw new Error("Model already loaded. Call dispose() first.");
+    }
+    this.isLoading = true;
+    const startTime = performance.now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("Wav2ArkitCpu.load", {
+      "model.url": this.config.modelUrl,
+      "model.backend_requested": this.config.backend || "wasm"
+    });
+    try {
+      const preference = this.config.backend || "wasm";
+      logger5.info("Loading ONNX Runtime...", { preference });
+      const { ort, backend } = await getOnnxRuntimeForPreference(preference);
+      this.ort = ort;
+      this._backend = backend;
+      logger5.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) {
+        logger5.debug("Loading model from cache", { modelUrl });
+        modelBuffer = await cache.get(modelUrl);
+        if (!modelBuffer) {
+          logger5.warn("Cache corruption detected, clearing and retrying", { modelUrl });
+          await cache.delete(modelUrl);
+          modelBuffer = await fetchWithCache(modelUrl);
+        }
+      } else {
+        logger5.debug("Fetching and caching model", { modelUrl });
+        modelBuffer = await fetchWithCache(modelUrl);
+      }
+      if (!modelBuffer) {
+        throw new Error(`Failed to load model: ${modelUrl}`);
+      }
+      logger5.debug("Creating ONNX session", {
+        size: formatBytes(modelBuffer.byteLength),
+        backend: this._backend
+      });
+      const sessionOptions = getSessionOptions(this._backend);
+      const modelData = new Uint8Array(modelBuffer);
+      this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
+      const loadTimeMs = performance.now() - startTime;
+      logger5.info("Model loaded successfully", {
+        backend: this._backend,
+        loadTimeMs: Math.round(loadTimeMs),
+        inputs: this.session.inputNames,
+        outputs: this.session.outputNames
+      });
+      span?.setAttributes({
+        "model.backend": this._backend,
+        "model.load_time_ms": loadTimeMs,
+        "model.cached": isCached
+      });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
+        model: "wav2arkit_cpu",
+        backend: this._backend
+      });
+      logger5.debug("Running warmup inference");
+      const warmupStart = performance.now();
+      const silentAudio = new Float32Array(16e3);
+      await this.infer(silentAudio);
+      const warmupTimeMs = performance.now() - warmupStart;
+      logger5.info("Warmup inference complete", {
+        warmupTimeMs: Math.round(warmupTimeMs),
+        backend: this._backend
+      });
+      telemetry?.recordHistogram("omote.model.warmup_time", warmupTimeMs, {
+        model: "wav2arkit_cpu",
+        backend: this._backend
+      });
+      return {
+        backend: this._backend,
+        loadTimeMs,
+        inputNames: [...this.session.inputNames],
+        outputNames: [...this.session.outputNames]
+      };
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      telemetry?.incrementCounter("omote.errors.total", 1, {
+        model: "wav2arkit_cpu",
+        error_type: "load_failed"
+      });
+      throw error;
+    } finally {
+      this.isLoading = false;
+    }
+  }
+  /**
+   * Run inference on raw audio
+   *
+   * Accepts variable-length audio (not fixed to 16000 samples).
+   * Output frames = ceil(30 * numSamples / 16000).
+   *
+   * @param audioSamples - Float32Array of raw audio at 16kHz
+   * @param _identityIndex - Ignored (identity 11 is baked into the model)
+   */
+  async infer(audioSamples, _identityIndex) {
+    if (!this.session) {
+      throw new Error("Model not loaded. Call load() first.");
+    }
+    const audioCopy = new Float32Array(audioSamples);
+    const feeds = {
+      "audio_waveform": new this.ort.Tensor("float32", audioCopy, [1, audioCopy.length])
+    };
+    return this.queueInference(feeds, audioCopy.length);
+  }
+  /**
+   * Queue inference to serialize ONNX session calls
+   */
+  queueInference(feeds, inputSamples) {
+    return new Promise((resolve, reject) => {
+      this.inferenceQueue = this.inferenceQueue.then(async () => {
+        const telemetry = getTelemetry();
+        const span = telemetry?.startSpan("Wav2ArkitCpu.infer", {
+          "inference.backend": this._backend,
+          "inference.input_samples": inputSamples
+        });
+        try {
+          const startTime = performance.now();
+          const results = await this.session.run(feeds);
+          const inferenceTimeMs = performance.now() - startTime;
+          const blendshapeOutput = results["blendshapes"];
+          if (!blendshapeOutput) {
+            throw new Error("Missing blendshapes output from model");
+          }
+          const blendshapeData = blendshapeOutput.data;
+          const numFrames = blendshapeOutput.dims[1];
+          const numBlendshapes = blendshapeOutput.dims[2];
+          const blendshapes = [];
+          for (let f = 0; f < numFrames; f++) {
+            const rawFrame = blendshapeData.slice(f * numBlendshapes, (f + 1) * numBlendshapes);
+            const remapped = remapWav2ArkitToLam(rawFrame);
+            blendshapes.push(symmetrizeBlendshapes(remapped));
+          }
+          logger5.trace("Inference completed", {
+            inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
+            numFrames,
+            inputSamples
+          });
+          span?.setAttributes({
+            "inference.duration_ms": inferenceTimeMs,
+            "inference.frames": numFrames
+          });
+          span?.end();
+          telemetry?.recordHistogram("omote.inference.latency", inferenceTimeMs, {
+            model: "wav2arkit_cpu",
+            backend: this._backend
+          });
+          telemetry?.incrementCounter("omote.inference.total", 1, {
+            model: "wav2arkit_cpu",
+            backend: this._backend,
+            status: "success"
+          });
+          resolve({
+            blendshapes,
+            numFrames,
+            inferenceTimeMs
+          });
+        } catch (err) {
+          span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+          telemetry?.incrementCounter("omote.inference.total", 1, {
+            model: "wav2arkit_cpu",
+            backend: this._backend,
+            status: "error"
+          });
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * Dispose of the model and free resources
+   */
+  async dispose() {
+    if (this.session) {
+      await this.session.release();
+      this.session = null;
+    }
+  }
+};
+
+// src/inference/createLipSync.ts
+var logger6 = createLogger("createLipSync");
+function createLipSync(config) {
+  const mode = config.mode ?? "auto";
+  const fallbackOnError = config.fallbackOnError ?? true;
+  let useCpu;
+  if (mode === "cpu") {
+    useCpu = true;
+    logger6.info("Forcing CPU lip sync model (wav2arkit_cpu)");
+  } else if (mode === "gpu") {
+    useCpu = false;
+    logger6.info("Forcing GPU lip sync model (Wav2Vec2)");
+  } else {
+    useCpu = isSafari();
+    logger6.info("Auto-detected lip sync model", {
+      useCpu,
+      isSafari: isSafari()
+    });
+  }
+  if (useCpu) {
+    logger6.info("Creating Wav2ArkitCpuInference (1.8MB, WASM)");
+    return new Wav2ArkitCpuInference({
+      modelUrl: config.cpuModelUrl
+    });
+  }
+  const gpuInstance = new Wav2Vec2Inference({
+    modelUrl: config.gpuModelUrl,
+    backend: config.gpuBackend ?? "auto",
+    numIdentityClasses: config.numIdentityClasses
+  });
+  if (fallbackOnError) {
+    logger6.info("Creating Wav2Vec2Inference with CPU fallback");
+    return new LipSyncWithFallback(gpuInstance, config);
+  }
+  logger6.info("Creating Wav2Vec2Inference (no fallback)");
+  return gpuInstance;
+}
+var LipSyncWithFallback = class {
+  constructor(gpuInstance, config) {
+    this.hasFallenBack = false;
+    this.implementation = gpuInstance;
+    this.config = config;
+  }
+  get backend() {
+    return this.implementation.backend;
+  }
+  get isLoaded() {
+    return this.implementation.isLoaded;
+  }
+  async load() {
+    try {
+      return await this.implementation.load();
+    } catch (error) {
+      logger6.warn("GPU model load failed, falling back to CPU model", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      try {
+        await this.implementation.dispose();
+      } catch {
+      }
+      this.implementation = new Wav2ArkitCpuInference({
+        modelUrl: this.config.cpuModelUrl
+      });
+      this.hasFallenBack = true;
+      logger6.info("Fallback to Wav2ArkitCpuInference successful");
+      return await this.implementation.load();
+    }
+  }
+  async infer(audioSamples, identityIndex) {
+    return this.implementation.infer(audioSamples, identityIndex);
+  }
+  async dispose() {
+    return this.implementation.dispose();
+  }
+};
+
 // src/inference/SileroVADInference.ts
-var logger5 = createLogger("SileroVAD");
+var logger7 = createLogger("SileroVAD");
 var SileroVADInference = class {
   constructor(config) {
     this.session = null;
@@ -3041,23 +3389,23 @@ var SileroVADInference = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger5.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger7.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 });
+      logger7.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) {
-        logger5.debug("Loading model from cache", { modelUrl });
+        logger7.debug("Loading model from cache", { modelUrl });
         modelBuffer = await cache.get(modelUrl);
       } else {
-        logger5.debug("Fetching and caching model", { modelUrl });
+        logger7.debug("Fetching and caching model", { modelUrl });
         modelBuffer = await fetchWithCache(modelUrl);
       }
-      logger5.debug("Creating ONNX session", {
+      logger7.debug("Creating ONNX session", {
         size: formatBytes(modelBuffer.byteLength),
         backend: this._backend
       });
@@ -3066,7 +3414,7 @@ var SileroVADInference = class {
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       this.reset();
       const loadTimeMs = performance.now() - startTime;
-      logger5.info("Model loaded successfully", {
+      logger7.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -3219,7 +3567,7 @@ var SileroVADInference = class {
           this.preSpeechBuffer.shift();
         }
       }
-      logger5.trace("Skipping VAD inference - audio too quiet", {
+      logger7.trace("Skipping VAD inference - audio too quiet", {
         rms: Math.round(rms * 1e4) / 1e4,
         threshold: MIN_ENERGY_THRESHOLD
       });
@@ -3273,7 +3621,7 @@ var SileroVADInference = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger5.debug("Speech started with pre-speech buffer", {
+            logger7.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -3286,7 +3634,7 @@ var SileroVADInference = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger5.trace("VAD inference completed", {
+          logger7.trace("VAD inference completed", {
             probability: Math.round(probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100
@@ -3342,7 +3690,7 @@ var SileroVADInference = class {
 SileroVADInference.isWebGPUAvailable = isWebGPUAvailable;
 
 // src/inference/SileroVADWorker.ts
-var logger6 = createLogger("SileroVADWorker");
+var logger8 = createLogger("SileroVADWorker");
 var WASM_CDN_PATH2 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 var LOAD_TIMEOUT_MS = 1e4;
 var INFERENCE_TIMEOUT_MS = 1e3;
@@ -3605,7 +3953,7 @@ var SileroVADWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger6.error("Worker error", { error: error.message });
+      logger8.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -3681,9 +4029,9 @@ var SileroVADWorker = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger6.info("Creating VAD worker...");
+      logger8.info("Creating VAD worker...");
       this.worker = this.createWorker();
-      logger6.info("Loading model in worker...", {
+      logger8.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         sampleRate: this.config.sampleRate
       });
@@ -3699,7 +4047,7 @@ var SileroVADWorker = class {
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger6.info("VAD worker loaded successfully", {
+      logger8.info("VAD worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -3806,7 +4154,7 @@ var SileroVADWorker = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger6.debug("Speech started with pre-speech buffer", {
+            logger8.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -3819,7 +4167,7 @@ var SileroVADWorker = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger6.trace("VAD worker inference completed", {
+          logger8.trace("VAD worker inference completed", {
             probability: Math.round(result.probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
@@ -3887,18 +4235,18 @@ var SileroVADWorker = class {
 };
 
 // src/inference/createSileroVAD.ts
-var logger7 = createLogger("createSileroVAD");
+var logger9 = createLogger("createSileroVAD");
 function supportsVADWorker() {
   if (typeof Worker === "undefined") {
-    logger7.debug("Worker not supported: Worker constructor undefined");
+    logger9.debug("Worker not supported: Worker constructor undefined");
     return false;
   }
   if (typeof URL === "undefined" || typeof URL.createObjectURL === "undefined") {
-    logger7.debug("Worker not supported: URL.createObjectURL unavailable");
+    logger9.debug("Worker not supported: URL.createObjectURL unavailable");
     return false;
   }
   if (typeof Blob === "undefined") {
-    logger7.debug("Worker not supported: Blob constructor unavailable");
+    logger9.debug("Worker not supported: Blob constructor unavailable");
     return false;
   }
   return true;
@@ -3908,19 +4256,19 @@ function createSileroVAD(config) {
   let useWorker;
   if (config.useWorker !== void 0) {
     useWorker = config.useWorker;
-    logger7.debug("Worker preference explicitly set", { useWorker });
+    logger9.debug("Worker preference explicitly set", { useWorker });
   } else {
     const workerSupported = supportsVADWorker();
     const onMobile = isMobile();
     useWorker = workerSupported && !onMobile;
-    logger7.debug("Auto-detected Worker preference", {
+    logger9.debug("Auto-detected Worker preference", {
       useWorker,
       workerSupported,
       onMobile
     });
   }
   if (useWorker) {
-    logger7.info("Creating SileroVADWorker (off-main-thread)");
+    logger9.info("Creating SileroVADWorker (off-main-thread)");
     const worker = new SileroVADWorker({
       modelUrl: config.modelUrl,
       sampleRate: config.sampleRate,
@@ -3932,7 +4280,7 @@ function createSileroVAD(config) {
     }
     return worker;
   }
-  logger7.info("Creating SileroVADInference (main thread)");
+  logger9.info("Creating SileroVADInference (main thread)");
   return new SileroVADInference(config);
 }
 var VADWorkerWithFallback = class {
@@ -3958,7 +4306,7 @@ var VADWorkerWithFallback = class {
     try {
       return await this.implementation.load();
     } catch (error) {
-      logger7.warn("Worker load failed, falling back to main thread", {
+      logger9.warn("Worker load failed, falling back to main thread", {
         error: error instanceof Error ? error.message : String(error)
       });
       try {
@@ -3967,7 +4315,7 @@ var VADWorkerWithFallback = class {
       }
       this.implementation = new SileroVADInference(this.config);
       this.hasFallenBack = true;
-      logger7.info("Fallback to SileroVADInference successful");
+      logger9.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
     }
   }
@@ -3989,7 +4337,7 @@ var VADWorkerWithFallback = class {
 };
 
 // src/inference/Emotion2VecInference.ts
-var logger8 = createLogger("Emotion2Vec");
+var logger10 = createLogger("Emotion2Vec");
 var EMOTION2VEC_LABELS = ["neutral", "happy", "angry", "sad"];
 var Emotion2VecInference = class {
   constructor(config) {
@@ -4031,28 +4379,28 @@ var Emotion2VecInference = class {
       "model.backend_requested": this.config.backend
     });
     try {
-      logger8.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger10.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger8.info("ONNX Runtime loaded", { backend: this._backend });
-      logger8.info("Checking model cache...");
+      logger10.info("ONNX Runtime loaded", { backend: this._backend });
+      logger10.info("Checking model cache...");
       const cache = getModelCache();
       const modelUrl = this.config.modelUrl;
       const isCached = await cache.has(modelUrl);
-      logger8.info("Cache check complete", { modelUrl, isCached });
+      logger10.info("Cache check complete", { modelUrl, isCached });
       let modelBuffer;
       if (isCached) {
-        logger8.info("Loading model from cache...", { modelUrl });
+        logger10.info("Loading model from cache...", { modelUrl });
         modelBuffer = await cache.get(modelUrl);
-        logger8.info("Model loaded from cache", { size: formatBytes(modelBuffer.byteLength) });
+        logger10.info("Model loaded from cache", { size: formatBytes(modelBuffer.byteLength) });
       } else {
-        logger8.info("Fetching model (not cached)...", { modelUrl });
+        logger10.info("Fetching model (not cached)...", { modelUrl });
         modelBuffer = await fetchWithCache(modelUrl);
-        logger8.info("Model fetched and cached", { size: formatBytes(modelBuffer.byteLength) });
+        logger10.info("Model fetched and cached", { size: formatBytes(modelBuffer.byteLength) });
       }
-      logger8.info("Creating ONNX session (this may take a while for large models)...");
-      logger8.debug("Creating ONNX session", {
+      logger10.info("Creating ONNX session (this may take a while for large models)...");
+      logger10.debug("Creating ONNX session", {
         size: formatBytes(modelBuffer.byteLength),
         backend: this._backend
       });
@@ -4060,7 +4408,7 @@ var Emotion2VecInference = class {
       const modelData = new Uint8Array(modelBuffer);
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       const loadTimeMs = performance.now() - startTime;
-      logger8.info("Model loaded successfully", {
+      logger10.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -4172,7 +4520,7 @@ var Emotion2VecInference = class {
             });
           }
           const inferenceTimeMs = performance.now() - startTime;
-          logger8.debug("Emotion inference completed", {
+          logger10.debug("Emotion inference completed", {
             numFrames,
             dominant: dominant.emotion,
             confidence: Math.round(dominant.confidence * 100),
@@ -4249,7 +4597,7 @@ var Emotion2VecInference = class {
 Emotion2VecInference.isWebGPUAvailable = isWebGPUAvailable;
 
 // src/inference/SafariSpeechRecognition.ts
-var logger9 = createLogger("SafariSpeech");
+var logger11 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {
   constructor(config = {}) {
     this.recognition = null;
@@ -4268,7 +4616,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       interimResults: config.interimResults ?? true,
       maxAlternatives: config.maxAlternatives ?? 1
     };
-    logger9.debug("SafariSpeechRecognition created", {
+    logger11.debug("SafariSpeechRecognition created", {
       language: this.config.language,
       continuous: this.config.continuous
     });
@@ -4329,7 +4677,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger9.warn("Already listening");
+      logger11.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -4359,7 +4707,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = true;
       this.startTime = performance.now();
       this.accumulatedText = "";
-      logger9.info("Speech recognition started", {
+      logger11.info("Speech recognition started", {
         language: this.config.language
       });
       span?.end();
@@ -4374,7 +4722,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async stop() {
     if (!this.isListening || !this.recognition) {
-      logger9.warn("Not currently listening");
+      logger11.warn("Not currently listening");
       return {
         text: this.accumulatedText,
         language: this.config.language,
@@ -4403,7 +4751,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     if (this.recognition && this.isListening) {
       this.recognition.abort();
       this.isListening = false;
-      logger9.info("Speech recognition aborted");
+      logger11.info("Speech recognition aborted");
     }
   }
   /**
@@ -4434,7 +4782,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     this.isListening = false;
     this.resultCallbacks = [];
     this.errorCallbacks = [];
-    logger9.debug("SafariSpeechRecognition disposed");
+    logger11.debug("SafariSpeechRecognition disposed");
   }
   /**
    * Set up event handlers for the recognition instance
@@ -4462,7 +4810,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
               confidence: alternative.confidence
             };
             this.emitResult(speechResult);
-            logger9.trace("Speech result", {
+            logger11.trace("Speech result", {
               text: text.substring(0, 50),
               isFinal,
               confidence: alternative.confidence
@@ -4472,12 +4820,12 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
         span?.end();
       } catch (error) {
         span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-        logger9.error("Error processing speech result", { error });
+        logger11.error("Error processing speech result", { error });
       }
     };
     this.recognition.onerror = (event) => {
       const error = new Error(`Speech recognition error: ${event.error} - ${event.message}`);
-      logger9.error("Speech recognition error", { error: event.error, message: event.message });
+      logger11.error("Speech recognition error", { error: event.error, message: event.message });
       this.emitError(error);
       if (this.stopRejecter) {
         this.stopRejecter(error);
@@ -4487,7 +4835,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     };
     this.recognition.onend = () => {
       this.isListening = false;
-      logger9.info("Speech recognition ended", {
+      logger11.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
         durationMs: performance.now() - this.startTime
       });
@@ -4504,13 +4852,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       }
     };
     this.recognition.onstart = () => {
-      logger9.debug("Speech recognition started by browser");
+      logger11.debug("Speech recognition started by browser");
     };
     this.recognition.onspeechstart = () => {
-      logger9.debug("Speech detected");
+      logger11.debug("Speech detected");
     };
     this.recognition.onspeechend = () => {
-      logger9.debug("Speech ended");
+      logger11.debug("Speech ended");
     };
   }
   /**
@@ -4521,7 +4869,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger9.error("Error in result callback", { error });
+        logger11.error("Error in result callback", { error });
       }
     }
   }
@@ -4533,7 +4881,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(error);
       } catch (callbackError) {
-        logger9.error("Error in error callback", { error: callbackError });
+        logger11.error("Error in error callback", { error: callbackError });
       }
     }
   }
@@ -5956,12 +6304,12 @@ async function isHuggingFaceCDNReachable(testUrl = HF_CDN_TEST_URL) {
 }
 
 // src/utils/transformersCacheClear.ts
-var logger10 = createLogger("TransformersCache");
+var logger12 = createLogger("TransformersCache");
 async function clearTransformersCache(options) {
   const verbose = options?.verbose ?? true;
   const additionalPatterns = options?.additionalPatterns ?? [];
   if (!("caches" in window)) {
-    logger10.warn("Cache API not available in this environment");
+    logger12.warn("Cache API not available in this environment");
     return [];
   }
   try {
@@ -5979,18 +6327,18 @@ async function clearTransformersCache(options) {
       );
       if (shouldDelete) {
         if (verbose) {
-          logger10.info("Deleting cache", { cacheName });
+          logger12.info("Deleting cache", { cacheName });
         }
         const deleted = await caches.delete(cacheName);
         if (deleted) {
           deletedCaches.push(cacheName);
         } else if (verbose) {
-          logger10.warn("Failed to delete cache", { cacheName });
+          logger12.warn("Failed to delete cache", { cacheName });
         }
       }
     }
     if (verbose) {
-      logger10.info("Cache clearing complete", {
+      logger12.info("Cache clearing complete", {
         totalCaches: cacheNames.length,
         deletedCount: deletedCaches.length,
         deletedCaches
@@ -5998,35 +6346,35 @@ async function clearTransformersCache(options) {
     }
     return deletedCaches;
   } catch (error) {
-    logger10.error("Error clearing caches", { error });
+    logger12.error("Error clearing caches", { error });
     throw error;
   }
 }
 async function clearSpecificCache(cacheName) {
   if (!("caches" in window)) {
-    logger10.warn("Cache API not available in this environment");
+    logger12.warn("Cache API not available in this environment");
     return false;
   }
   try {
     const deleted = await caches.delete(cacheName);
-    logger10.info("Cache deletion attempt", { cacheName, deleted });
+    logger12.info("Cache deletion attempt", { cacheName, deleted });
     return deleted;
   } catch (error) {
-    logger10.error("Error deleting cache", { cacheName, error });
+    logger12.error("Error deleting cache", { cacheName, error });
     return false;
   }
 }
 async function listCaches() {
   if (!("caches" in window)) {
-    logger10.warn("Cache API not available in this environment");
+    logger12.warn("Cache API not available in this environment");
     return [];
   }
   try {
     const cacheNames = await caches.keys();
-    logger10.debug("Available caches", { cacheNames });
+    logger12.debug("Available caches", { cacheNames });
     return cacheNames;
   } catch (error) {
-    logger10.error("Error listing caches", { error });
+    logger12.error("Error listing caches", { error });
     return [];
   }
 }
@@ -6068,7 +6416,7 @@ async function validateCachedResponse(cacheName, requestUrl) {
       reason: valid ? "Valid response" : `Invalid: status=${response.status}, contentType=${contentType}, isHtml=${isHtml || looksLikeHtml}`
     };
   } catch (error) {
-    logger10.error("Error validating cached response", { cacheName, requestUrl, error });
+    logger12.error("Error validating cached response", { cacheName, requestUrl, error });
     return {
       exists: false,
       valid: false,
@@ -6105,7 +6453,7 @@ async function scanForInvalidCaches() {
         }
       }
     }
-    logger10.info("Cache scan complete", {
+    logger12.info("Cache scan complete", {
       totalCaches: cacheNames.length,
       scannedEntries,
       invalidCount: invalidEntries.length
@@ -6116,13 +6464,13 @@ async function scanForInvalidCaches() {
       invalidEntries
     };
   } catch (error) {
-    logger10.error("Error scanning caches", { error });
+    logger12.error("Error scanning caches", { error });
     throw error;
   }
 }
 async function nukeBrowserCaches(preventRecreation = false) {
   if (!("caches" in window)) {
-    logger10.warn("Cache API not available in this environment");
+    logger12.warn("Cache API not available in this environment");
     return 0;
   }
   try {
@@ -6134,17 +6482,17 @@ async function nukeBrowserCaches(preventRecreation = false) {
         deletedCount++;
       }
     }
-    logger10.info("All browser caches cleared", {
+    logger12.info("All browser caches cleared", {
       totalDeleted: deletedCount
     });
     if (preventRecreation) {
       const { env: env2 } = await import("./transformers.web-ALDLCPHT.mjs");
       env2.useBrowserCache = false;
-      logger10.warn("Browser cache creation disabled (env.useBrowserCache = false)");
+      logger12.warn("Browser cache creation disabled (env.useBrowserCache = false)");
     }
     return deletedCount;
   } catch (error) {
-    logger10.error("Error nuking caches", { error });
+    logger12.error("Error nuking caches", { error });
     throw error;
   }
 }
@@ -6670,6 +7018,7 @@ var EmphasisDetector = class {
   }
 };
 export {
+  ARKIT_BLENDSHAPES,
   AgentCoreAdapter,
   AnimationGraph,
   AudioChunkCoalescer,
@@ -6705,6 +7054,8 @@ export {
   SileroVADWorker,
   SyncedAudioPipeline,
   TenantManager,
+  WAV2ARKIT_BLENDSHAPES,
+  Wav2ArkitCpuInference,
   Wav2Vec2Inference,
   WhisperInference,
   blendEmotions,
@@ -6716,6 +7067,7 @@ export {
   configureLogging,
   configureTelemetry,
   createEmotionVector,
+  createLipSync,
   createLogger,
   createSessionWithFallback,
   createSileroVAD,
@@ -6740,6 +7092,7 @@ export {
   isIOSSafari,
   isMobile,
   isOnnxRuntimeLoaded,
+  isSafari,
   isSpeechRecognitionAvailable,
   isWebGPUAvailable,
   lerpEmotion,
@@ -6748,15 +7101,18 @@ export {
   nukeBrowserCaches,
   parseHuggingFaceUrl,
   preloadModels,
+  remapWav2ArkitToLam,
   resetLoggingConfig,
   resolveBackend,
   scanForInvalidCaches,
   setLogLevel,
   setLoggingEnabled,
   shouldEnableWasmProxy,
+  shouldUseCpuLipSync,
   shouldUseNativeASR,
   shouldUseServerLipSync,
   supportsVADWorker,
+  symmetrizeBlendshapes,
   validateCachedResponse
 };
 //# sourceMappingURL=index.mjs.map