@omote/core 0.3.1 → 0.3.25

package/dist/index.mjs

@@ -15,8 +15,8 @@ import {
 import {
   __webpack_exports__env,
   __webpack_exports__pipeline
-} from "./chunk-T465MTDX.mjs";
-import "./chunk-6W7G6WE7.mjs";
+} from "./chunk-B6TIE56N.mjs";
+import "./chunk-NSSMTXJJ.mjs";
 
 // src/audio/MicrophoneCapture.ts
 var MicrophoneCapture = class {
@@ -28,6 +28,8 @@ var MicrophoneCapture = class {
     this.buffer = new Float32Array(0);
     this._isRecording = false;
     this._loggedFirstChunk = false;
+    /** Actual AudioContext sample rate (may differ from target on Firefox) */
+    this._nativeSampleRate = 0;
     this.config = {
       sampleRate: config.sampleRate ?? 16e3,
       chunkSize: config.chunkSize ?? 1600
@@ -62,10 +64,29 @@ var MicrophoneCapture = class {
       if (this.context.state === "suspended") {
         await this.context.resume();
       }
-      const source = this.context.createMediaStreamSource(this.stream);
+      let source;
+      try {
+        source = this.context.createMediaStreamSource(this.stream);
+        this._nativeSampleRate = this.context.sampleRate;
+      } catch (sourceErr) {
+        console.warn(
+          "[MicrophoneCapture] Cannot connect stream at",
+          this.config.sampleRate + "Hz, falling back to native rate:",
+          sourceErr.message
+        );
+        await this.context.close();
+        this.context = new AudioContext();
+        if (this.context.state === "suspended") {
+          await this.context.resume();
+        }
+        source = this.context.createMediaStreamSource(this.stream);
+        this._nativeSampleRate = this.context.sampleRate;
+        console.log("[MicrophoneCapture] Using native rate:", this._nativeSampleRate, "Hz \u2192 resampling to", this.config.sampleRate, "Hz");
+      }
       this.processor = this.context.createScriptProcessor(4096, 1, 1);
       this.processor.onaudioprocess = (e) => {
-        const input = e.inputBuffer.getChannelData(0);
+        const raw = e.inputBuffer.getChannelData(0);
+        const input = this._nativeSampleRate !== this.config.sampleRate ? this.resample(raw, this._nativeSampleRate, this.config.sampleRate) : raw;
         let rms = 0;
         let peak = 0;
         for (let i = 0; i < input.length; i++) {
@@ -123,6 +144,25 @@ var MicrophoneCapture = class {
     this.buffer = new Float32Array(0);
     this._isRecording = false;
   }
+  /**
+   * Resample audio using linear interpolation.
+   * Used when the AudioContext runs at the device's native rate (e.g. 48kHz)
+   * and we need to downsample to the target rate (e.g. 16kHz).
+   */
+  resample(input, fromRate, toRate) {
+    if (fromRate === toRate) return input;
+    const ratio = fromRate / toRate;
+    const outputLength = Math.floor(input.length / ratio);
+    const output = new Float32Array(outputLength);
+    for (let i = 0; i < outputLength; i++) {
+      const srcIdx = i * ratio;
+      const lo = Math.floor(srcIdx);
+      const hi = Math.min(lo + 1, input.length - 1);
+      const frac = srcIdx - lo;
+      output[i] = input[lo] * (1 - frac) + input[hi] * frac;
+    }
+    return output;
+  }
   floatToPCM16(float32) {
     const pcm = new Int16Array(float32.length);
     for (let i = 0; i < float32.length; i++) {
@@ -263,7 +303,8 @@ var AudioScheduler = class {
     const ctx = await this.ensureContext();
     const channels = this.options.channels ?? 1;
     if (!this.isPlaying) {
-      this.nextPlayTime = ctx.currentTime + (this.options.initialDelayS ?? 0.05);
+      const lookahead = this.options.initialLookaheadSec ?? 0.05;
+      this.nextPlayTime = ctx.currentTime + lookahead;
       this.isPlaying = true;
     }
     const audioBuffer = ctx.createBuffer(channels, audioData.length, ctx.sampleRate);
@@ -446,8 +487,8 @@ var AudioChunkCoalescer = class {
 var LAMPipeline = class {
   constructor(options = {}) {
     this.options = options;
-    this.DEFAULT_CHUNK_SAMPLES = 16e3;
-    // 1.0s at 16kHz (Wav2Vec2 requirement)
+    this.REQUIRED_SAMPLES = 16e3;
+    // 1.0s at 16kHz (LAM requirement)
     this.FRAME_RATE = 30;
     // LAM outputs 30fps
     this.buffer = new Float32Array(0);
@@ -477,20 +518,22 @@ var LAMPipeline = class {
     newBuffer.set(this.buffer, 0);
     newBuffer.set(samples, this.buffer.length);
     this.buffer = newBuffer;
-    const chunkSize = lam.chunkSamples ?? this.DEFAULT_CHUNK_SAMPLES;
-    while (this.buffer.length >= chunkSize) {
-      await this.processBuffer(lam, chunkSize);
+    while (this.buffer.length >= this.REQUIRED_SAMPLES) {
+      await this.processBuffer(lam);
+      if (this.buffer.length >= this.REQUIRED_SAMPLES) {
+        await new Promise((r) => setTimeout(r, 0));
+      }
     }
   }
   /**
    * Process accumulated buffer through LAM inference
    */
-  async processBuffer(lam, chunkSize) {
+  async processBuffer(lam) {
     try {
-      const toProcess = this.buffer.slice(0, chunkSize);
+      const toProcess = this.buffer.slice(0, this.REQUIRED_SAMPLES);
       const processedStartTime = this.bufferStartTime;
-      this.buffer = this.buffer.slice(chunkSize);
-      const processedDuration = chunkSize / (this.options.sampleRate ?? 16e3);
+      this.buffer = this.buffer.slice(this.REQUIRED_SAMPLES);
+      const processedDuration = this.REQUIRED_SAMPLES / (this.options.sampleRate ?? 16e3);
       this.bufferStartTime = processedStartTime + processedDuration;
       const result = await lam.infer(toProcess);
       const frameDuration = 1 / this.FRAME_RATE;
@@ -509,22 +552,35 @@ var LAMPipeline = class {
   /**
    * Get the frame that should be displayed at the current time
    *
-   * Timestamp-synced playback for all backends. Audio playback is delayed
-   * for slow backends (WASM gets 1s head start via AudioScheduler) so
-   * frames are ready by the time their corresponding audio plays.
+   * Automatically removes frames that have already been displayed.
+   * This prevents memory leaks from accumulating old frames.
+   *
+   * Discard Window (prevents premature frame discarding):
+   * - WebGPU: 0.5s (LAM inference 20-100ms + RAF jitter + React stalls)
+   * - WASM: 1.0s (LAM inference 50-500ms + higher variability)
    *
-   * Discard window is generous for WASM to handle inference jitter.
-   * Late frames play at RAF rate (~60fps) until caught up, then settle
-   * to natural 30fps pacing via timestamp gating.
+   * Last-Frame-Hold: Returns last valid frame instead of null to prevent
+   * avatar freezing when between frames (RAF at 60fps vs LAM at 30fps).
    *
    * @param currentTime - Current AudioContext time
    * @param lam - LAM inference engine (optional, for backend detection)
    * @returns Current frame, or last frame as fallback, or null if no frames yet
    */
   getFrameForTime(currentTime, lam) {
-    const discardWindow = lam?.backend === "wasm" ? 10 : 0.5;
+    const discardWindow = lam?.backend === "wasm" ? 1 : 0.5;
+    let discardedCount = 0;
     while (this.frameQueue.length > 0 && this.frameQueue[0].timestamp < currentTime - discardWindow) {
-      this.frameQueue.shift();
+      const discarded = this.frameQueue.shift();
+      discardedCount++;
+      if (discardedCount === 1) {
+        const ageMs = ((currentTime - discarded.timestamp) * 1e3).toFixed(0);
+        console.warn("[LAM] Frame(s) discarded as too old", {
+          ageMs,
+          discardWindowMs: discardWindow * 1e3,
+          queueLength: this.frameQueue.length,
+          backend: lam?.backend ?? "unknown"
+        });
+      }
     }
     if (this.frameQueue.length > 0 && this.frameQueue[0].timestamp <= currentTime) {
       const { frame } = this.frameQueue.shift();
@@ -543,7 +599,7 @@ var LAMPipeline = class {
    * Get current buffer fill level (0-1)
    */
   get fillLevel() {
-    return Math.min(1, this.buffer.length / this.DEFAULT_CHUNK_SAMPLES);
+    return Math.min(1, this.buffer.length / this.REQUIRED_SAMPLES);
   }
   /**
    * Get number of frames queued
@@ -560,7 +616,7 @@ var LAMPipeline = class {
   /**
    * Flush remaining buffered audio
    *
-   * Processes any remaining audio in the buffer, even if less than the chunk size.
+   * Processes any remaining audio in the buffer, even if less than REQUIRED_SAMPLES.
    * This ensures the final audio chunk generates blendshape frames.
    *
    * Should be called when audio stream ends to prevent losing the last 0-1 seconds.
@@ -571,17 +627,12 @@ var LAMPipeline = class {
     if (this.buffer.length === 0) {
       return;
     }
+    const padded = new Float32Array(this.REQUIRED_SAMPLES);
+    padded.set(this.buffer, 0);
     const processedStartTime = this.bufferStartTime;
-    const sampleRate = this.options.sampleRate ?? 16e3;
-    const minSize = lam.chunkSamples ?? this.DEFAULT_CHUNK_SAMPLES;
-    const audioToInfer = this.buffer.length >= minSize ? this.buffer : (() => {
-      const padded = new Float32Array(minSize);
-      padded.set(this.buffer, 0);
-      return padded;
-    })();
     try {
-      const result = await lam.infer(audioToInfer);
-      const actualDuration = this.buffer.length / sampleRate;
+      const result = await lam.infer(padded);
+      const actualDuration = this.buffer.length / (this.options.sampleRate ?? 16e3);
       const frameDuration = 1 / this.FRAME_RATE;
       const actualFrameCount = Math.ceil(actualDuration * this.FRAME_RATE);
       for (let i = 0; i < Math.min(actualFrameCount, result.blendshapes.length); i++) {
@@ -640,13 +691,12 @@ var SyncedAudioPipeline = class extends EventEmitter {
     this.monitorInterval = null;
     this.frameAnimationId = null;
     const sampleRate = options.sampleRate ?? 16e3;
-    if (!options.lam.isLoaded) {
-      throw new Error(
-        "LipSyncBackend must be loaded before constructing SyncedAudioPipeline. Call lam.load() first so backend type is known for timing configuration."
-      );
-    }
-    const initialDelayS = options.lam.backend === "wasm" ? 1 : 0.05;
-    this.scheduler = new AudioScheduler({ sampleRate, initialDelayS });
+    const autoDelay = options.lam.modelId === "wav2arkit_cpu" ? 750 : options.lam.backend === "wasm" ? 350 : 50;
+    const audioDelayMs = options.audioDelayMs ?? autoDelay;
+    this.scheduler = new AudioScheduler({
+      sampleRate,
+      initialLookaheadSec: audioDelayMs / 1e3
+    });
     this.coalescer = new AudioChunkCoalescer({
       sampleRate,
       targetDurationMs: options.chunkTargetMs ?? 200
@@ -2014,9 +2064,7 @@ function formatBytes(bytes) {
 function isIOSSafari() {
   if (typeof navigator === "undefined") return false;
   const ua = navigator.userAgent.toLowerCase();
-  return /iphone|ipad|ipod/.test(ua) || // Safari on macOS could also have issues, but less severe
-  // Only force WASM on actual iOS devices
-  /safari/.test(ua) && /mobile/.test(ua) && !/chrome|crios|fxios/.test(ua);
+  return /iphone|ipad|ipod/.test(ua) && /safari/.test(ua) && !/chrome|crios|fxios|chromium|edg/.test(ua);
 }
 function isIOS() {
   if (typeof navigator === "undefined") return false;
@@ -2074,10 +2122,7 @@ function getOptimalWasmThreads() {
   return 4;
 }
 function shouldEnableWasmProxy() {
-  if (isMobile()) {
-    return false;
-  }
-  return true;
+  return false;
 }
 function isSafari() {
   if (typeof navigator === "undefined") return false;
@@ -2092,7 +2137,7 @@ function isSpeechRecognitionAvailable() {
   return "SpeechRecognition" in window || "webkitSpeechRecognition" in window;
 }
 function shouldUseNativeASR() {
-  return isIOS() && isSpeechRecognitionAvailable();
+  return (isIOS() || isSafari()) && isSpeechRecognitionAvailable();
 }
 function shouldUseServerLipSync() {
   return isIOS();
@@ -2105,11 +2150,13 @@ var loadedBackend = null;
 var WASM_CDN_PATH = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
 async function isWebGPUAvailable() {
   if (isIOS()) {
-    logger.debug("WebGPU check: iOS detected, returning false");
+    logger.debug("WebGPU check: disabled on iOS (asyncify bundle crashes WebKit)");
     return false;
   }
   if (!hasWebGPUApi()) {
-    logger.debug("WebGPU check: navigator.gpu not available");
+    logger.debug("WebGPU check: navigator.gpu not available", {
+      isSecureContext: typeof window !== "undefined" ? window.isSecureContext : "N/A"
+    });
     return false;
   }
   try {
@@ -2133,14 +2180,20 @@ async function isWebGPUAvailable() {
 }
 var iosWasmPatched = false;
 function applyIOSWasmMemoryPatch() {
-  if (iosWasmPatched || !isIOS()) return;
+  if (iosWasmPatched || !isIOSSafari()) return;
   iosWasmPatched = true;
   const OrigMemory = WebAssembly.Memory;
-  const MAX_IOS_PAGES = 16384;
-  logger.info("Applying iOS WASM memory patch (max capped to 1GB, shared preserved)");
+  const MAX_IOS_PAGES = 32768;
+  logger.info("Applying iOS WASM memory patch (max\u21922GB, shared preserved)");
   WebAssembly.Memory = function IOSPatchedMemory(descriptor) {
     const patched = { ...descriptor };
     if (patched.maximum !== void 0 && patched.maximum > MAX_IOS_PAGES) {
+      logger.info("iOS memory patch: capping maximum", {
+        original: patched.maximum,
+        capped: MAX_IOS_PAGES,
+        shared: patched.shared,
+        initial: patched.initial
+      });
       patched.maximum = MAX_IOS_PAGES;
     }
     return new OrigMemory(patched);
@@ -2174,7 +2227,10 @@ async function getOnnxRuntime(backend) {
   logger.info(`Loading ONNX Runtime with ${backend} backend...`);
   applyIOSWasmMemoryPatch();
   try {
-    if (backend === "wasm") {
+    if (backend === "wasm" && (isIOS() || isSafari())) {
+      const module = await import("onnxruntime-web/wasm");
+      ortInstance = module.default || module;
+    } else if (backend === "wasm") {
       const module = await import("onnxruntime-web");
       ortInstance = module.default || module;
     } else {
@@ -2249,6 +2305,16 @@ function getLoadedBackend() {
 function isOnnxRuntimeLoaded() {
   return ortInstance !== null;
 }
+async function preloadOnnxRuntime(preference = "auto") {
+  if (ortInstance) {
+    logger.info("ONNX Runtime already preloaded", { backend: loadedBackend });
+    return loadedBackend;
+  }
+  logger.info("Preloading ONNX Runtime...", { preference });
+  const { backend } = await getOnnxRuntimeForPreference(preference);
+  logger.info("ONNX Runtime preloaded", { backend });
+  return backend;
+}
 
 // src/inference/blendshapeUtils.ts
 var LAM_BLENDSHAPES = [
@@ -2444,6 +2510,7 @@ var CTC_VOCAB = [
 ];
 var Wav2Vec2Inference = class {
   constructor(config) {
+    this.modelId = "wav2vec2";
     this.session = null;
     this.ort = null;
     this._backend = "wasm";
@@ -2504,13 +2571,52 @@ var Wav2Vec2Inference = class {
         logger2.error(errorMsg, { modelUrl, isCached });
         throw new Error(errorMsg);
       }
+      let externalDataBuffer = null;
+      if (this.config.externalDataUrl !== false) {
+        const dataUrl = typeof this.config.externalDataUrl === "string" ? this.config.externalDataUrl : `${modelUrl}.data`;
+        try {
+          const isDataCached = await cache.has(dataUrl);
+          if (isDataCached) {
+            logger2.debug("Loading external data from cache", { dataUrl });
+            externalDataBuffer = await cache.get(dataUrl);
+            if (!externalDataBuffer) {
+              logger2.warn("Cache corruption for external data, retrying", { dataUrl });
+              await cache.delete(dataUrl);
+              externalDataBuffer = await fetchWithCache(dataUrl);
+            }
+          } else {
+            logger2.info("Fetching external model data", {
+              dataUrl,
+              note: "This may be a large download (383MB+)"
+            });
+            externalDataBuffer = await fetchWithCache(dataUrl);
+          }
+          logger2.info("External data loaded", {
+            size: formatBytes(externalDataBuffer.byteLength)
+          });
+        } catch (err) {
+          logger2.debug("No external data file found (single-file model)", {
+            dataUrl,
+            error: err.message
+          });
+        }
+      }
       logger2.debug("Creating ONNX session", {
-        size: formatBytes(modelBuffer.byteLength),
+        graphSize: formatBytes(modelBuffer.byteLength),
+        externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
         backend: this._backend
       });
       const sessionOptions = getSessionOptions(this._backend);
+      if (externalDataBuffer) {
+        const dataFilename = (typeof this.config.externalDataUrl === "string" ? this.config.externalDataUrl : `${modelUrl}.data`).split("/").pop();
+        sessionOptions.externalData = [{
+          path: dataFilename,
+          data: new Uint8Array(externalDataBuffer)
+        }];
+      }
       logger2.info("Creating session with execution provider", {
-        executionProvider: this._backend
+        executionProvider: this._backend,
+        hasExternalData: !!externalDataBuffer
       });
       const modelData = new Uint8Array(modelBuffer);
       this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
@@ -2756,7 +2862,7 @@ var WhisperInference = class _WhisperInference {
    * Check if WebGPU is available in this browser
    */
   static async isWebGPUAvailable() {
-    return isWebGPUAvailable();
+    return "gpu" in navigator;
   }
   /**
    * Load the Whisper model pipeline
@@ -3051,18 +3157,13 @@ var WhisperInference = class _WhisperInference {
 var logger5 = createLogger("Wav2ArkitCpu");
 var Wav2ArkitCpuInference = class {
   constructor(config) {
+    this.modelId = "wav2arkit_cpu";
     this.session = null;
     this.ort = null;
     this._backend = "wasm";
     this.isLoading = false;
     // Inference queue for handling concurrent calls
     this.inferenceQueue = Promise.resolve();
-    /**
-     * Preferred chunk size: 4000 samples (250ms at 16kHz).
-     * wav2arkit_cpu accepts variable-length input, so we use smaller chunks
-     * for lower latency on WASM (vs 16000 for Wav2Vec2's fixed requirement).
-     */
-    this.chunkSamples = 4e3;
     this.config = config;
   }
   get backend() {
@@ -3096,23 +3197,25 @@ var Wav2ArkitCpuInference = class {
       this._backend = backend;
       logger5.info("ONNX Runtime loaded", { backend: this._backend });
       const modelUrl = this.config.modelUrl;
-      const sessionOptions = { ...getSessionOptions(this._backend) };
-      let isCached = false;
-      if (isIOS() && this.config.modelDataUrl) {
-        const dataFilename = this.config.modelDataUrl.split("/").pop();
-        sessionOptions.externalData = [{
-          path: dataFilename,
-          data: this.config.modelDataUrl
-        }];
-        logger5.info("iOS: URL-based session creation (ORT handles fetch internally)", {
+      const dataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${modelUrl}.data` : null;
+      const sessionOptions = getSessionOptions(this._backend);
+      if (isIOS()) {
+        logger5.info("iOS: passing model URLs directly to ORT (low-memory path)", {
           modelUrl,
-          dataFile: dataFilename,
-          dataUrl: this.config.modelDataUrl
+          dataUrl
         });
+        if (dataUrl) {
+          const dataFilename = dataUrl.split("/").pop();
+          sessionOptions.externalData = [{
+            path: dataFilename,
+            data: dataUrl
+            // URL string — ORT fetches directly into WASM
+          }];
+        }
         this.session = await this.ort.InferenceSession.create(modelUrl, sessionOptions);
       } else {
         const cache = getModelCache();
-        isCached = await cache.has(modelUrl);
+        const isCached = await cache.has(modelUrl);
         let modelBuffer;
         if (isCached) {
           logger5.debug("Loading model from cache", { modelUrl });
@@ -3123,42 +3226,48 @@ var Wav2ArkitCpuInference = class {
             modelBuffer = await fetchWithCache(modelUrl);
           }
         } else {
-          logger5.debug("Fetching and caching model", { modelUrl });
+          logger5.debug("Fetching and caching model graph", { modelUrl });
           modelBuffer = await fetchWithCache(modelUrl);
         }
         if (!modelBuffer) {
           throw new Error(`Failed to load model: ${modelUrl}`);
         }
-        let externalDataBuffer;
-        if (this.config.modelDataUrl) {
-          const dataUrl = this.config.modelDataUrl;
-          const isDataCached = await cache.has(dataUrl);
-          if (isDataCached) {
-            logger5.debug("Loading external data from cache", { dataUrl });
-            externalDataBuffer = await cache.get(dataUrl);
-            if (!externalDataBuffer) {
-              logger5.warn("External data cache corruption, re-fetching", { dataUrl });
-              await cache.delete(dataUrl);
+        let externalDataBuffer = null;
+        if (dataUrl) {
+          try {
+            const isDataCached = await cache.has(dataUrl);
+            if (isDataCached) {
+              logger5.debug("Loading external data from cache", { dataUrl });
+              externalDataBuffer = await cache.get(dataUrl);
+              if (!externalDataBuffer) {
+                logger5.warn("Cache corruption for external data, retrying", { dataUrl });
+                await cache.delete(dataUrl);
+                externalDataBuffer = await fetchWithCache(dataUrl);
+              }
+            } else {
+              logger5.info("Fetching external model data", {
+                dataUrl,
+                note: "This may be a large download (400MB+)"
+              });
               externalDataBuffer = await fetchWithCache(dataUrl);
             }
-          } else {
-            logger5.info("Fetching external data (this may take a while on first load)", {
-              dataUrl
+            logger5.info("External data loaded", {
+              size: formatBytes(externalDataBuffer.byteLength)
+            });
+          } catch (err) {
+            logger5.debug("No external data file found (single-file model)", {
+              dataUrl,
+              error: err.message
             });
-            externalDataBuffer = await fetchWithCache(dataUrl);
           }
-          logger5.debug("External data loaded", {
-            size: formatBytes(externalDataBuffer.byteLength)
-          });
         }
         logger5.debug("Creating ONNX session", {
-          size: formatBytes(modelBuffer.byteLength),
-          hasExternalData: !!externalDataBuffer,
-          externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : void 0,
+          graphSize: formatBytes(modelBuffer.byteLength),
+          externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
           backend: this._backend
         });
         if (externalDataBuffer) {
-          const dataFilename = this.config.modelDataUrl.split("/").pop();
+          const dataFilename = dataUrl.split("/").pop();
           sessionOptions.externalData = [{
             path: dataFilename,
             data: new Uint8Array(externalDataBuffer)
@@ -3177,7 +3286,7 @@ var Wav2ArkitCpuInference = class {
       span?.setAttributes({
         "model.backend": this._backend,
         "model.load_time_ms": loadTimeMs,
-        "model.cached": isCached
+        "model.cached": !isIOS()
       });
       span?.end();
       telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
@@ -3258,11 +3367,11 @@ var Wav2ArkitCpuInference = class {
           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));
+            const symmetrized = symmetrizeBlendshapes(rawFrame);
+            blendshapes.push(symmetrized);
           }
           logger5.trace("Inference completed", {
-            inferenceTimeMs: Math.round(inferenceTimeMs),
+            inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
             numFrames,
             inputSamples
           });
@@ -3328,14 +3437,14 @@ function createLipSync(config) {
     });
   }
   if (useCpu) {
-    logger6.info("Creating Wav2ArkitCpuInference (WASM)");
+    logger6.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
     return new Wav2ArkitCpuInference({
-      modelUrl: config.cpuModelUrl,
-      modelDataUrl: config.cpuModelDataUrl
+      modelUrl: config.cpuModelUrl
     });
   }
   const gpuInstance = new Wav2Vec2Inference({
     modelUrl: config.gpuModelUrl,
+    externalDataUrl: config.gpuExternalDataUrl,
     backend: config.gpuBackend ?? "auto",
     numIdentityClasses: config.numIdentityClasses
   });
@@ -3352,15 +3461,15 @@ var LipSyncWithFallback = class {
     this.implementation = gpuInstance;
     this.config = config;
   }
+  get modelId() {
+    return this.implementation.modelId;
+  }
   get backend() {
     return this.implementation.backend;
   }
   get isLoaded() {
     return this.implementation.isLoaded;
   }
-  get chunkSamples() {
-    return this.implementation.chunkSamples;
-  }
   async load() {
     try {
       return await this.implementation.load();
@@ -3373,8 +3482,7 @@ var LipSyncWithFallback = class {
       } catch {
       }
       this.implementation = new Wav2ArkitCpuInference({
-        modelUrl: this.config.cpuModelUrl,
-        modelDataUrl: this.config.cpuModelDataUrl
+        modelUrl: this.config.cpuModelUrl
       });
       this.hasFallenBack = true;
       logger6.info("Fallback to Wav2ArkitCpuInference successful");
@@ -3404,6 +3512,8 @@ var SileroVADInference = class {
     // Pre-speech buffer for capturing beginning of speech
     this.preSpeechBuffer = [];
     this.wasSpeaking = false;
+    // Cached sample rate tensor (int64 scalar, never changes per instance)
+    this.srTensor = null;
     const sampleRate = config.sampleRate ?? 16e3;
     if (sampleRate !== 8e3 && sampleRate !== 16e3) {
       throw new Error("Silero VAD only supports 8000 or 16000 Hz sample rates");
@@ -3534,6 +3644,24 @@ var SileroVADInference = class {
     this.context = new Float32Array(this.contextSize);
     this.preSpeechBuffer = [];
     this.wasSpeaking = false;
+    if (!this.srTensor) {
+      try {
+        this.srTensor = new this.ort.Tensor(
+          "int64",
+          new BigInt64Array([BigInt(this.config.sampleRate)]),
+          []
+        );
+      } catch (e) {
+        logger7.warn("BigInt64Array not available, using bigint array fallback", {
+          error: e instanceof Error ? e.message : String(e)
+        });
+        this.srTensor = new this.ort.Tensor(
+          "int64",
+          [BigInt(this.config.sampleRate)],
+          []
+        );
+      }
+    }
   }
   /**
    * Process a single audio chunk
@@ -3665,20 +3793,7 @@ var SileroVADInference = class {
           inputBuffer.set(audioChunkCopy, this.contextSize);
           const inputBufferCopy = new Float32Array(inputBuffer);
           const inputTensor = new this.ort.Tensor("float32", inputBufferCopy, [1, inputSize]);
-          let srTensor;
-          try {
-            srTensor = new this.ort.Tensor(
-              "int64",
-              new BigInt64Array([BigInt(this.config.sampleRate)]),
-              []
-            );
-          } catch {
-            srTensor = new this.ort.Tensor(
-              "int64",
-              [BigInt(this.config.sampleRate)],
-              []
-            );
-          }
+          const srTensor = this.srTensor;
           const stateCopy = new Float32Array(this.state.data);
           const stateTensor = new this.ort.Tensor("float32", stateCopy, this.state.dims);
           const feeds = {
@@ -3767,6 +3882,7 @@ var SileroVADInference = class {
       this.session = null;
     }
     this.state = null;
+    this.srTensor = null;
   }
 };
 /**
@@ -6579,7 +6695,7 @@ async function nukeBrowserCaches(preventRecreation = false) {
       totalDeleted: deletedCount
     });
     if (preventRecreation) {
-      const { env } = await import("./transformers.web-MHLR33H6.mjs");
+      const { env } = await import("./transformers.web-T5LWC34T.mjs");
       env.useBrowserCache = false;
       logger12.warn("Browser cache creation disabled (env.useBrowserCache = false)");
     }
@@ -7194,6 +7310,7 @@ export {
   nukeBrowserCaches,
   parseHuggingFaceUrl,
   preloadModels,
+  preloadOnnxRuntime,
   remapWav2ArkitToLam,
   resetLoggingConfig,
   resolveBackend,