@omote/core 0.4.4 → 0.4.6

package/dist/index.mjs

@@ -312,7 +312,14 @@ var AudioScheduler = class {
     source.connect(gainNode);
     const scheduleTime = this.nextPlayTime;
     source.start(scheduleTime);
-    this.scheduledSources.push({ source, gainNode });
+    const entry = { source, gainNode };
+    this.scheduledSources.push(entry);
+    source.onended = () => {
+      const idx = this.scheduledSources.indexOf(entry);
+      if (idx !== -1) {
+        this.scheduledSources.splice(idx, 1);
+      }
+    };
     const duration = audioData.length / ctx.sampleRate;
     this.nextPlayTime = scheduleTime + duration;
     return scheduleTime;
@@ -668,7 +675,7 @@ var LAMPipeline = class {
   }
 };
 
-// src/audio/SyncedAudioPipeline.ts
+// src/audio/audioUtils.ts
 function pcm16ToFloat32(buffer) {
   const byteLen = buffer.byteLength & ~1;
   const int16 = byteLen === buffer.byteLength ? new Int16Array(buffer) : new Int16Array(buffer, 0, byteLen / 2);
@@ -678,6 +685,15 @@ function pcm16ToFloat32(buffer) {
   }
   return float32;
 }
+function int16ToFloat32(int16) {
+  const float32 = new Float32Array(int16.length);
+  for (let i = 0; i < int16.length; i++) {
+    float32[i] = int16[i] / 32768;
+  }
+  return float32;
+}
+
+// src/audio/SyncedAudioPipeline.ts
 var SyncedAudioPipeline = class extends EventEmitter {
   constructor(options) {
     super();
@@ -2385,7 +2401,7 @@ function isIOSSafari() {
 function isIOS() {
   if (typeof navigator === "undefined") return false;
   const ua = navigator.userAgent.toLowerCase();
-  return /iphone|ipad|ipod/.test(ua);
+  return /iphone|ipad|ipod/.test(ua) || /macintosh/.test(ua) && navigator.maxTouchPoints > 1;
 }
 function isAndroid() {
   if (typeof navigator === "undefined") return false;
@@ -3006,10 +3022,16 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
       });
       logger2.debug("Running warmup inference to initialize GPU context");
       const warmupStart = performance.now();
-      const silentAudio = new Float32Array(16e3);
+      const warmupAudio = new Float32Array(16e3);
+      const warmupIdentity = new Float32Array(this.numIdentityClasses);
+      warmupIdentity[0] = 1;
+      const warmupFeeds = {
+        "audio": new this.ort.Tensor("float32", warmupAudio, [1, 16e3]),
+        "identity": new this.ort.Tensor("float32", warmupIdentity, [1, this.numIdentityClasses])
+      };
       const WARMUP_TIMEOUT_MS = 15e3;
       const warmupResult = await Promise.race([
-        this.infer(silentAudio, 0).then(() => "ok"),
+        this.session.run(warmupFeeds).then(() => "ok"),
         new Promise((r) => setTimeout(() => r("timeout"), WARMUP_TIMEOUT_MS))
       ]);
       const warmupTimeMs = performance.now() - warmupStart;
@@ -3115,14 +3137,18 @@ var _Wav2Vec2Inference = class _Wav2Vec2Inference {
         });
         try {
           const startTime = performance.now();
+          let timeoutId;
           const results = await Promise.race([
-            this.session.run(feeds),
-            new Promise(
-              (_, rej) => setTimeout(
+            this.session.run(feeds).then((r) => {
+              clearTimeout(timeoutId);
+              return r;
+            }),
+            new Promise((_, rej) => {
+              timeoutId = setTimeout(
                 () => rej(new Error(`Wav2Vec2 inference timed out after ${_Wav2Vec2Inference.INFERENCE_TIMEOUT_MS}ms`)),
                 _Wav2Vec2Inference.INFERENCE_TIMEOUT_MS
-              )
-            )
+              );
+            })
           ]);
           const inferenceTimeMs = performance.now() - startTime;
           const asrOutput = results["asr_logits"];
@@ -3228,15 +3254,6 @@ var Wav2Vec2Inference = _Wav2Vec2Inference;
 
 // src/audio/FullFacePipeline.ts
 var logger3 = createLogger("FullFacePipeline");
-function pcm16ToFloat322(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 BLENDSHAPE_INDEX_MAP = /* @__PURE__ */ new Map();
 LAM_BLENDSHAPES.forEach((name, index) => {
   BLENDSHAPE_INDEX_MAP.set(name, index);
@@ -3386,7 +3403,7 @@ var _FullFacePipeline = class _FullFacePipeline extends EventEmitter {
     if (!combined) {
       return;
     }
-    const float32 = pcm16ToFloat322(combined);
+    const float32 = pcm16ToFloat32(combined);
     const scheduleTime = await this.scheduler.schedule(float32);
     if (!this.playbackStarted) {
       this.playbackStarted = true;
@@ -3869,13 +3886,18 @@ function ctcGreedyDecode(logits, seqLen, vocabSize, tokenMap) {
 
 // src/inference/SenseVoiceInference.ts
 var logger4 = createLogger("SenseVoice");
-var SenseVoiceInference = class {
+var _SenseVoiceInference = class _SenseVoiceInference {
   constructor(config) {
     this.session = null;
     this.ort = null;
     this._backend = "wasm";
     this.isLoading = false;
     this.inferenceQueue = Promise.resolve();
+    // Session health: set to true if session.run() times out.
+    // A timed-out session may have a zombie WASM dispatch still running,
+    // so all future transcribe() calls reject immediately to prevent concurrent access.
+    this.poisoned = false;
+    // 10s for SenseVoice (heavier preprocessing)
     // Preprocessing state (loaded once)
     this.tokenMap = null;
     this.negMean = null;
@@ -4023,6 +4045,9 @@ var SenseVoiceInference = class {
     if (!this.session || !this.ort || !this.tokenMap) {
       throw new Error("Model not loaded. Call load() first.");
     }
+    if (this.poisoned) {
+      throw new Error("SenseVoice session timed out \u2014 inference unavailable until page reload");
+    }
     const audio = new Float32Array(audioSamples);
     return this.queueInference(audio);
   }
@@ -4060,7 +4085,19 @@ var SenseVoiceInference = class {
             language: new ort.Tensor("int32", new Int32Array([this.languageId]), [1]),
             text_norm: new ort.Tensor("int32", new Int32Array([this.textNormId]), [1])
           };
-          const results = await this.session.run(feeds);
+          let timeoutId;
+          const results = await Promise.race([
+            this.session.run(feeds).then((r) => {
+              clearTimeout(timeoutId);
+              return r;
+            }),
+            new Promise((_, rej) => {
+              timeoutId = setTimeout(
+                () => rej(new Error(`SenseVoice inference timed out after ${_SenseVoiceInference.INFERENCE_TIMEOUT_MS}ms`)),
+                _SenseVoiceInference.INFERENCE_TIMEOUT_MS
+              );
+            })
+          ]);
           const logitsOutput = results["logits"];
           if (!logitsOutput) {
             throw new Error('Model output missing "logits" tensor');
@@ -4106,6 +4143,32 @@ var SenseVoiceInference = class {
             preprocessTimeMs
           });
         } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("timed out")) {
+            this.poisoned = true;
+            logger4.error("CRITICAL: Inference session timed out \u2014 SenseVoice is dead. Page reload required.", {
+              backend: this._backend,
+              timeoutMs: _SenseVoiceInference.INFERENCE_TIMEOUT_MS
+            });
+          } else if (typeof err === "number") {
+            const oomError = new Error(
+              `SenseVoice inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reloading the page.`
+            );
+            logger4.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+              pointer: `0x${err.toString(16)}`,
+              backend: this._backend
+            });
+            span?.endWithError(oomError);
+            telemetry?.incrementCounter("omote.inference.total", 1, {
+              model: "sensevoice",
+              backend: this._backend,
+              status: "error"
+            });
+            reject(oomError);
+            return;
+          } else {
+            logger4.error("Inference failed", { error: errMsg, backend: this._backend });
+          }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
             model: "sensevoice",
@@ -4129,241 +4192,3082 @@ var SenseVoiceInference = class {
     this.invStddev = null;
   }
 };
+_SenseVoiceInference.INFERENCE_TIMEOUT_MS = 1e4;
+var SenseVoiceInference = _SenseVoiceInference;
 
-// src/inference/Wav2ArkitCpuInference.ts
-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();
-    this.config = config;
-  }
-  get backend() {
-    return this.session ? this._backend : null;
-  }
-  get isLoaded() {
-    return this.session !== null;
+// src/inference/SenseVoiceWorker.ts
+var logger5 = createLogger("SenseVoiceWorker");
+var WASM_CDN_PATH2 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
+var LOAD_TIMEOUT_MS = 3e4;
+var INFERENCE_TIMEOUT_MS = 1e4;
+function resolveUrl(url) {
+  if (/^https?:\/\//i.test(url) || /^blob:/i.test(url)) return url;
+  try {
+    return new URL(url, globalThis.location?.origin ?? "https://localhost").href;
+  } catch {
+    return url;
   }
-  /**
-   * Load the ONNX model
-   */
-  async load() {
-    if (this.isLoading) {
-      throw new Error("Model is already loading");
+}
+var WORKER_SCRIPT = `
+// SenseVoice ASR Worker Script
+// Loaded via Blob URL - no separate file needed
+
+var ort = null;
+var session = null;
+var tokenMap = null;
+var negMean = null;
+var invStddev = null;
+var languageId = 0;
+var textNormId = 14;
+var vocabSize = 0;
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// kaldiFbank.ts \u2014 inlined as plain JavaScript
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+/**
+ * In-place Radix-2 Cooley-Tukey FFT
+ */
+function fft(re, im) {
+  var n = re.length;
+
+  // Bit-reversal permutation
+  for (var i = 1, j = 0; i < n; i++) {
+    var bit = n >> 1;
+    while (j & bit) {
+      j ^= bit;
+      bit >>= 1;
     }
-    if (this.session) {
-      throw new Error("Model already loaded. Call dispose() first.");
+    j ^= bit;
+    if (i < j) {
+      var tmp = re[i]; re[i] = re[j]; re[j] = tmp;
+      tmp = im[i]; im[i] = im[j]; im[j] = tmp;
     }
-    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 modelUrl = this.config.modelUrl;
-      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,
-          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();
-        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 graph", { modelUrl });
-          modelBuffer = await fetchWithCache(modelUrl);
-        }
-        if (!modelBuffer) {
-          throw new Error(`Failed to load model: ${modelUrl}`);
-        }
-        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);
-            }
-            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
-            });
-          }
-        }
-        logger5.debug("Creating ONNX session", {
-          graphSize: formatBytes(modelBuffer.byteLength),
-          externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
-          backend: this._backend
-        });
-        if (externalDataBuffer) {
-          const dataFilename = dataUrl.split("/").pop();
-          sessionOptions.externalData = [{
-            path: dataFilename,
-            data: new Uint8Array(externalDataBuffer)
-          }];
-        }
-        const modelData = new Uint8Array(modelBuffer);
-        this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
+  }
+
+  // Butterfly passes
+  for (var len = 2; len <= n; len *= 2) {
+    var halfLen = len / 2;
+    var angle = -2 * Math.PI / len;
+    var wRe = Math.cos(angle);
+    var wIm = Math.sin(angle);
+
+    for (var i = 0; i < n; i += len) {
+      var curRe = 1;
+      var curIm = 0;
+      for (var j = 0; j < halfLen; j++) {
+        var a = i + j;
+        var b = a + halfLen;
+        var tRe = curRe * re[b] - curIm * im[b];
+        var tIm = curRe * im[b] + curIm * re[b];
+        re[b] = re[a] - tRe;
+        im[b] = im[a] - tIm;
+        re[a] += tRe;
+        im[a] += tIm;
+        var nextRe = curRe * wRe - curIm * wIm;
+        curIm = curRe * wIm + curIm * wRe;
+        curRe = nextRe;
       }
-      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": !isIOS()
-      });
-      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.");
+}
+
+/** HTK mel scale */
+function htkMel(freq) {
+  return 1127.0 * Math.log(1.0 + freq / 700.0);
+}
+
+function htkMelInverse(mel) {
+  return 700.0 * (Math.exp(mel / 1127.0) - 1.0);
+}
+
+/**
+ * Build triangular mel filterbank matrix
+ */
+function buildMelFilterbank(numBins, fftSize, sampleRate, lowFreq, highFreq) {
+  var numFftBins = fftSize / 2 + 1;
+  var lowMel = htkMel(lowFreq);
+  var highMel = htkMel(highFreq);
+
+  // numBins + 2 equally spaced points in mel space
+  var melPoints = new Float64Array(numBins + 2);
+  for (var i = 0; i < numBins + 2; i++) {
+    melPoints[i] = lowMel + (highMel - lowMel) * i / (numBins + 1);
+  }
+
+  // Convert mel points to FFT bin indices (float, not rounded)
+  var binFreqs = new Float64Array(numBins + 2);
+  for (var i = 0; i < numBins + 2; i++) {
+    binFreqs[i] = htkMelInverse(melPoints[i]) * fftSize / sampleRate;
+  }
+
+  var filters = [];
+
+  for (var m = 0; m < numBins; m++) {
+    var left = binFreqs[m];
+    var center = binFreqs[m + 1];
+    var right = binFreqs[m + 2];
+
+    var startBin = Math.max(0, Math.ceil(left));
+    var endBin = Math.min(numFftBins - 1, Math.floor(right));
+
+    var weights = new Float32Array(endBin - startBin + 1);
+    for (var k = startBin; k <= endBin; k++) {
+      if (k <= center) {
+        weights[k - startBin] = (center - left) > 0 ? (k - left) / (center - left) : 0;
+      } else {
+        weights[k - startBin] = (right - center) > 0 ? (right - k) / (right - center) : 0;
+      }
     }
-    const audioCopy = new Float32Array(audioSamples);
-    const feeds = {
-      "audio_waveform": new this.ort.Tensor("float32", audioCopy, [1, audioCopy.length])
-    };
-    return this.queueInference(feeds, audioCopy.length);
+
+    filters.push({ startBin: startBin, weights: weights });
+  }
+
+  return filters;
+}
+
+/** Create Hamming window */
+function createHammingWindow(length) {
+  var w = new Float32Array(length);
+  for (var i = 0; i < length; i++) {
+    w[i] = 0.54 - 0.46 * Math.cos(2 * Math.PI * i / (length - 1));
+  }
+  return w;
+}
+
+/**
+ * Compute Kaldi-compatible log mel filterbank features
+ */
+function computeKaldiFbank(audio, sampleRate, numMelBins, opts) {
+  var frameLengthMs = (opts && opts.frameLengthMs !== undefined) ? opts.frameLengthMs : 25;
+  var frameShiftMs = (opts && opts.frameShiftMs !== undefined) ? opts.frameShiftMs : 10;
+  var lowFreq = (opts && opts.lowFreq !== undefined) ? opts.lowFreq : 20;
+  var highFreq = (opts && opts.highFreq !== undefined) ? opts.highFreq : (sampleRate / 2);
+  var dither = (opts && opts.dither !== undefined) ? opts.dither : 0;
+  var preemphasis = (opts && opts.preemphasis !== undefined) ? opts.preemphasis : 0.97;
+
+  var frameLengthSamples = Math.round(sampleRate * frameLengthMs / 1000);
+  var frameShiftSamples = Math.round(sampleRate * frameShiftMs / 1000);
+
+  // Kaldi signal scaling: float [-1,1] -> int16 range
+  var scaled = new Float32Array(audio.length);
+  for (var i = 0; i < audio.length; i++) {
+    scaled[i] = audio[i] * 32768;
+  }
+
+  // Optional dithering
+  if (dither > 0) {
+    for (var i = 0; i < scaled.length; i++) {
+      var u1 = Math.random();
+      var u2 = Math.random();
+      scaled[i] += dither * Math.sqrt(-2 * Math.log(u1 + 1e-10)) * Math.cos(2 * Math.PI * u2);
+    }
+  }
+
+  // Number of frames (snip_edges=true: only complete frames)
+  var numFrames = Math.max(0, Math.floor((scaled.length - frameLengthSamples) / frameShiftSamples) + 1);
+  if (numFrames === 0) {
+    return new Float32Array(0);
+  }
+
+  // FFT size: next power of 2
+  var fftSize = 1;
+  while (fftSize < frameLengthSamples) fftSize *= 2;
+
+  var numFftBins = fftSize / 2 + 1;
+
+  // Pre-compute window and filterbank
+  var window = createHammingWindow(frameLengthSamples);
+  var filters = buildMelFilterbank(numMelBins, fftSize, sampleRate, lowFreq, highFreq);
+
+  // Allocate output
+  var output = new Float32Array(numFrames * numMelBins);
+
+  // FFT buffers (reused per frame)
+  var fftRe = new Float64Array(fftSize);
+  var fftIm = new Float64Array(fftSize);
+
+  for (var f = 0; f < numFrames; f++) {
+    var offset = f * frameShiftSamples;
+
+    // Clear FFT buffers
+    fftRe.fill(0);
+    fftIm.fill(0);
+
+    // Extract frame with preemphasis and windowing
+    for (var i = 0; i < frameLengthSamples; i++) {
+      var sample = scaled[offset + i];
+      // Preemphasis: y[n] = x[n] - coeff * x[n-1]
+      if (preemphasis > 0 && i > 0) {
+        sample -= preemphasis * scaled[offset + i - 1];
+      } else if (preemphasis > 0 && i === 0 && offset > 0) {
+        sample -= preemphasis * scaled[offset - 1];
+      }
+      // Apply window
+      fftRe[i] = sample * window[i];
+    }
+
+    // FFT
+    fft(fftRe, fftIm);
+
+    // Power spectrum -> mel filterbank -> log
+    var outOffset = f * numMelBins;
+    for (var m = 0; m < numMelBins; m++) {
+      var filter = filters[m];
+      var energy = 0;
+      for (var k = 0; k < filter.weights.length; k++) {
+        var bin = filter.startBin + k;
+        if (bin < numFftBins) {
+          var powerSpec = fftRe[bin] * fftRe[bin] + fftIm[bin] * fftIm[bin];
+          energy += filter.weights[k] * powerSpec;
+        }
+      }
+      output[outOffset + m] = Math.log(Math.max(energy, 1e-10));
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Apply Low Frame Rate stacking for SenseVoice
+ */
+function applyLFR(features, featureDim, lfrM, lfrN) {
+  var numFrames = features.length / featureDim;
+  if (numFrames === 0) return new Float32Array(0);
+
+  var leftPad = Math.floor((lfrM - 1) / 2); // 3 for lfrM=7
+  var paddedLen = numFrames + leftPad;
+  var numOutputFrames = Math.ceil(paddedLen / lfrN);
+  var outputDim = featureDim * lfrM;
+
+  var output = new Float32Array(numOutputFrames * outputDim);
+
+  for (var i = 0; i < numOutputFrames; i++) {
+    var startFrame = i * lfrN - leftPad;
+
+    for (var j = 0; j < lfrM; j++) {
+      var srcFrame = startFrame + j;
+      // Clamp to valid range
+      if (srcFrame < 0) srcFrame = 0;
+      if (srcFrame >= numFrames) srcFrame = numFrames - 1;
+
+      var srcOffset = srcFrame * featureDim;
+      var dstOffset = i * outputDim + j * featureDim;
+      for (var k = 0; k < featureDim; k++) {
+        output[dstOffset + k] = features[srcOffset + k];
+      }
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Apply CMVN normalization in-place
+ */
+function applyCMVN(features, dim, negMeanVec, invStddevVec) {
+  for (var i = 0; i < features.length; i++) {
+    var d = i % dim;
+    features[i] = (features[i] + negMeanVec[d]) * invStddevVec[d];
+  }
+  return features;
+}
+
+/**
+ * Parse CMVN vectors from comma-separated strings (stored in ONNX metadata)
+ */
+function parseCMVNFromMetadata(negMeanStr, invStddevStr) {
+  var negMeanArr = new Float32Array(
+    negMeanStr.split(',').map(function(s) { return parseFloat(s.trim()); })
+  );
+  var invStddevArr = new Float32Array(
+    invStddevStr.split(',').map(function(s) { return parseFloat(s.trim()); })
+  );
+  return { negMean: negMeanArr, invStddev: invStddevArr };
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// ctcDecoder.ts \u2014 inlined as plain JavaScript
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+/** SenseVoice language ID -> string mapping */
+var LANGUAGE_IDS = {
+  0: 'auto',
+  3: 'zh',
+  4: 'en',
+  7: 'yue',
+  11: 'ja',
+  12: 'ko',
+  13: 'nospeech'
+};
+
+/** SenseVoice text normalization ID -> string mapping */
+var TEXT_NORM_IDS = {
+  14: 'with_itn',
+  15: 'without_itn'
+};
+
+/** Resolve language string to SenseVoice language ID */
+function resolveLanguageId(language) {
+  var map = {
+    auto: 0,
+    zh: 3,
+    en: 4,
+    yue: 7,
+    ja: 11,
+    ko: 12
+  };
+  return map[language] !== undefined ? map[language] : 0;
+}
+
+/** Resolve text norm string to SenseVoice text norm ID */
+function resolveTextNormId(textNorm) {
+  return textNorm === 'without_itn' ? 15 : 14;
+}
+
+/**
+ * Parse tokens.txt into a token ID -> string map
+ */
+function parseTokensFile(content) {
+  var map = new Map();
+  var lines = content.split('\\n');
+  for (var idx = 0; idx < lines.length; idx++) {
+    var trimmed = lines[idx].trim();
+    if (!trimmed) continue;
+    // Find the last space - token string may contain spaces
+    var lastSpace = trimmed.lastIndexOf(' ');
+    if (lastSpace === -1) continue;
+    var token = trimmed.substring(0, lastSpace);
+    var id = parseInt(trimmed.substring(lastSpace + 1), 10);
+    if (!isNaN(id)) {
+      map.set(id, token);
+    }
+  }
+  return map;
+}
+
+/**
+ * SenseVoice structured token pattern matching
+ */
+function parseStructuredToken(token) {
+  var match = token.match(/^<\\|(.+)\\|>$/);
+  if (!match) return null;
+
+  var value = match[1];
+
+  // Language tokens
+  if (value === 'zh' || value === 'en' || value === 'ja' || value === 'ko' || value === 'yue' || value === 'nospeech') {
+    return { type: 'language', value: value };
+  }
+
+  // Emotion tokens
+  var emotions = ['HAPPY', 'SAD', 'ANGRY', 'NEUTRAL', 'FEARFUL', 'DISGUSTED', 'SURPRISED', 'EMO_UNKNOWN'];
+  if (emotions.indexOf(value) !== -1) {
+    return { type: 'emotion', value: value };
+  }
+
+  // Audio event tokens
+  var events = ['Speech', 'BGM', 'Applause', 'Laughter', 'Crying', 'Coughing', 'Sneezing', 'EVENT_UNKNOWN'];
+  if (events.indexOf(value) !== -1) {
+    return { type: 'event', value: value };
+  }
+
+  // ITN tokens
+  if (value === 'withitn' || value === 'woitn' || value === 'with_itn' || value === 'without_itn') {
+    return { type: 'textnorm', value: value };
+  }
+
+  return null;
+}
+
+/**
+ * CTC greedy decode
+ */
+function ctcGreedyDecode(logits, seqLen, vocabSz, tokenMapLocal) {
+  // Step 1: Argmax per time step
+  var tokenIds = [];
+  for (var t = 0; t < seqLen; t++) {
+    var offset = t * vocabSz;
+    var maxIdx = 0;
+    var maxVal = logits[offset];
+    for (var v = 1; v < vocabSz; v++) {
+      if (logits[offset + v] > maxVal) {
+        maxVal = logits[offset + v];
+        maxIdx = v;
+      }
+    }
+    tokenIds.push(maxIdx);
+  }
+
+  // Step 2: Collapse consecutive duplicates
+  var collapsed = [];
+  var prev = -1;
+  for (var idx = 0; idx < tokenIds.length; idx++) {
+    var id = tokenIds[idx];
+    if (id !== prev) {
+      collapsed.push(id);
+      prev = id;
+    }
+  }
+
+  // Step 3: Remove blank tokens (ID 0) and special tokens (<s>=1, </s>=2)
+  var filtered = collapsed.filter(function(id) { return id !== 0 && id !== 1 && id !== 2; });
+
+  // Step 4: Convert to token strings and parse structured tokens
+  var language = undefined;
+  var emotion = undefined;
+  var event = undefined;
+  var textTokens = [];
+
+  for (var idx = 0; idx < filtered.length; idx++) {
+    var id = filtered[idx];
+    var token = tokenMapLocal.get(id);
+    if (!token) continue;
+
+    var structured = parseStructuredToken(token);
+    if (structured) {
+      if (structured.type === 'language') language = structured.value;
+      else if (structured.type === 'emotion') emotion = structured.value;
+      else if (structured.type === 'event') event = structured.value;
+      // Skip textnorm tokens
+    } else {
+      textTokens.push(token);
+    }
+  }
+
+  // Step 5: Join tokens, handle SentencePiece boundary marker
+  var text = textTokens.join('');
+  // Replace SentencePiece word boundary (U+2581) with space
+  text = text.replace(/\\u2581/g, ' ').trim();
+
+  return { text: text, language: language, emotion: emotion, event: event };
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// Worker globals and message handler
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+/**
+ * Load ONNX Runtime from CDN
+ */
+async function loadOrt(wasmPaths) {
+  if (ort) return;
+
+  // Import ONNX Runtime from CDN
+  var ortUrl = wasmPaths + 'ort.wasm.min.js';
+
+  // Load the script by fetching and executing it
+  var response = await fetch(ortUrl);
+  var scriptText = await response.text();
+
+  // Create a blob URL for the script
+  var blob = new Blob([scriptText], { type: 'application/javascript' });
+  var blobUrl = URL.createObjectURL(blob);
+
+  // Import the module
+  importScripts(blobUrl);
+  URL.revokeObjectURL(blobUrl);
+
+  // ort is now available as global
+  ort = self.ort;
+
+  // Configure WASM settings
+  ort.env.wasm.wasmPaths = wasmPaths;
+  ort.env.wasm.numThreads = 1; // Single thread in worker
+  ort.env.wasm.simd = true;
+  ort.env.wasm.proxy = false; // No proxy in worker
+}
+
+/**
+ * Load the SenseVoice model and tokens
+ */
+async function loadModel(modelUrl, tokensUrl, isIOSDevice, lang, textNorm) {
+  // 1. Fetch and parse tokens.txt
+  var tokensResponse = await fetch(tokensUrl);
+  if (!tokensResponse.ok) {
+    throw new Error('Failed to fetch tokens.txt: ' + tokensResponse.status + ' ' + tokensResponse.statusText);
+  }
+  var tokensText = await tokensResponse.text();
+  tokenMap = parseTokensFile(tokensText);
+
+  // 2. Store language/textNorm IDs
+  languageId = lang;
+  textNormId = textNorm;
+
+  // 3. Create inference session
+  var sessionOptions = {
+    executionProviders: ['wasm'],
+    graphOptimizationLevel: 'all',
+  };
+
+  if (isIOSDevice) {
+    // iOS: pass URL string directly to ORT to avoid 239MB JS heap allocation
+    // ORT fetches into WASM memory, keeping JS heap at ~2MB
+    session = await ort.InferenceSession.create(modelUrl, sessionOptions);
+  } else {
+    // Desktop: fetch ArrayBuffer for potential caching
+    var modelResponse = await fetch(modelUrl);
+    if (!modelResponse.ok) {
+      throw new Error('Failed to fetch model: ' + modelResponse.status + ' ' + modelResponse.statusText);
+    }
+    var modelBuffer = await modelResponse.arrayBuffer();
+    var modelData = new Uint8Array(modelBuffer);
+    session = await ort.InferenceSession.create(modelData, sessionOptions);
+  }
+
+  // 4. Try to read CMVN from model metadata
+  try {
+    var metadata = session.handler && session.handler.metadata;
+    if (metadata && metadata.neg_mean && metadata.inv_stddev) {
+      var cmvn = parseCMVNFromMetadata(metadata.neg_mean, metadata.inv_stddev);
+      negMean = cmvn.negMean;
+      invStddev = cmvn.invStddev;
+    }
+  } catch (cmvnErr) {
+    // CMVN not available \u2014 features will not be normalized
+  }
+
+  // 5. Determine vocab size from tokenMap
+  vocabSize = 0;
+  tokenMap.forEach(function(val, key) {
+    if (key >= vocabSize) vocabSize = key + 1;
+  });
+
+  return {
+    vocabSize: vocabSize,
+    inputNames: session.inputNames.slice(),
+    outputNames: session.outputNames.slice(),
+  };
+}
+
+/**
+ * Run transcription on audio samples
+ */
+async function runTranscription(audio) {
+  var preprocessStart = performance.now();
+
+  // 1. Compute Kaldi fbank features [T, 80]
+  var fbank = computeKaldiFbank(audio, 16000, 80);
+  var numFrames = fbank.length / 80;
+
+  if (numFrames === 0) {
+    return {
+      text: '',
+      language: undefined,
+      emotion: undefined,
+      event: undefined,
+      inferenceTimeMs: performance.now() - preprocessStart,
+      preprocessTimeMs: performance.now() - preprocessStart,
+    };
+  }
+
+  // 2. Apply LFR stacking [T_reduced, 560]
+  var lfrFeatures = applyLFR(fbank, 80, 7, 6);
+  var numLfrFrames = lfrFeatures.length / 560;
+
+  // 3. Apply CMVN normalization (in-place)
+  if (negMean && invStddev) {
+    applyCMVN(lfrFeatures, 560, negMean, invStddev);
+  }
+
+  var preprocessTimeMs = performance.now() - preprocessStart;
+
+  // 4. Build ORT tensors
+  var feeds = {
+    x: new ort.Tensor('float32', lfrFeatures, [1, numLfrFrames, 560]),
+    x_length: new ort.Tensor('int32', new Int32Array([numLfrFrames]), [1]),
+    language: new ort.Tensor('int32', new Int32Array([languageId]), [1]),
+    text_norm: new ort.Tensor('int32', new Int32Array([textNormId]), [1]),
+  };
+
+  // 5. Run inference
+  var results = await session.run(feeds);
+
+  var logitsOutput = results['logits'];
+  if (!logitsOutput) {
+    throw new Error('Model output missing "logits" tensor');
+  }
+
+  var logitsData = logitsOutput.data;
+  var logitsDims = logitsOutput.dims;
+  var seqLen = logitsDims[1];
+  var modelVocabSize = logitsDims[2];
+
+  // 6. CTC decode
+  var decoded = ctcGreedyDecode(logitsData, seqLen, modelVocabSize, tokenMap);
+
+  var totalTimeMs = performance.now() - preprocessStart;
+
+  return {
+    text: decoded.text,
+    language: decoded.language,
+    emotion: decoded.emotion,
+    event: decoded.event,
+    inferenceTimeMs: totalTimeMs,
+    preprocessTimeMs: preprocessTimeMs,
+  };
+}
+
+// Message handler
+self.onmessage = async function(e) {
+  var msg = e.data;
+
+  try {
+    switch (msg.type) {
+      case 'load': {
+        var startTime = performance.now();
+        await loadOrt(msg.wasmPaths);
+        var info = await loadModel(msg.modelUrl, msg.tokensUrl, msg.isIOS, msg.language, msg.textNorm);
+        var loadTimeMs = performance.now() - startTime;
+
+        self.postMessage({
+          type: 'loaded',
+          vocabSize: info.vocabSize,
+          inputNames: info.inputNames,
+          outputNames: info.outputNames,
+          loadTimeMs: loadTimeMs,
+        });
+        break;
+      }
+
+      case 'transcribe': {
+        var result = await runTranscription(msg.audio);
+
+        self.postMessage({
+          type: 'result',
+          text: result.text,
+          language: result.language,
+          emotion: result.emotion,
+          event: result.event,
+          inferenceTimeMs: result.inferenceTimeMs,
+          preprocessTimeMs: result.preprocessTimeMs,
+        });
+        break;
+      }
+
+      case 'dispose': {
+        if (session) {
+          await session.release();
+          session = null;
+        }
+        ort = null;
+        tokenMap = null;
+        negMean = null;
+        invStddev = null;
+        self.postMessage({ type: 'disposed' });
+        break;
+      }
+
+      default:
+        self.postMessage({
+          type: 'error',
+          error: 'Unknown message type: ' + msg.type,
+        });
+    }
+  } catch (err) {
+    var errorMsg = err.message || String(err);
+    // Handle raw C++ exception pointers from ORT WASM
+    if (typeof err === 'number') {
+      errorMsg = 'Raw C++ exception pointer (0x' + err.toString(16) + '). Likely OOM in WASM.';
+    }
+    self.postMessage({
+      type: 'error',
+      error: errorMsg,
+    });
+  }
+};
+
+// Error handler
+self.onerror = function(err) {
+  self.postMessage({
+    type: 'error',
+    error: 'Worker error: ' + (err.message || String(err)),
+  });
+};
+`;
+var SenseVoiceWorker = class {
+  constructor(config) {
+    this.worker = null;
+    this.isLoading = false;
+    this._isLoaded = false;
+    // Inference queue for serialization
+    this.inferenceQueue = Promise.resolve();
+    // Session health: set to true if worker operation times out
+    this.poisoned = false;
+    // Pending message handlers
+    this.pendingResolvers = /* @__PURE__ */ new Map();
+    const modelDir = config.modelUrl.substring(0, config.modelUrl.lastIndexOf("/"));
+    const tokensUrl = config.tokensUrl ?? `${modelDir}/tokens.txt`;
+    this.config = {
+      modelUrl: config.modelUrl,
+      tokensUrl,
+      language: config.language ?? "auto",
+      textNorm: config.textNorm ?? "with_itn"
+    };
+    this.languageId = resolveLanguageId(this.config.language);
+    this.textNormId = resolveTextNormId(this.config.textNorm);
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  /**
+   * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
+   */
+  get backend() {
+    return this._isLoaded ? "wasm" : null;
+  }
+  /**
+   * Create the worker from inline script
+   */
+  createWorker() {
+    const blob = new Blob([WORKER_SCRIPT], { type: "application/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    const worker = new Worker(blobUrl);
+    URL.revokeObjectURL(blobUrl);
+    worker.onmessage = (event) => {
+      this.handleWorkerMessage(event.data);
+    };
+    worker.onerror = (error) => {
+      logger5.error("Worker error", { error: error.message });
+      for (const [, resolver] of this.pendingResolvers) {
+        resolver.reject(new Error(`Worker error: ${error.message}`));
+      }
+      this.pendingResolvers.clear();
+    };
+    return worker;
+  }
+  /**
+   * Handle messages from worker
+   */
+  handleWorkerMessage(result) {
+    const resolver = this.pendingResolvers.get(result.type);
+    if (resolver) {
+      this.pendingResolvers.delete(result.type);
+      if (result.type === "error") {
+        resolver.reject(new Error(result.error));
+      } else {
+        resolver.resolve(result);
+      }
+    }
+  }
+  /**
+   * Send message to worker and wait for response
+   */
+  sendMessage(message, expectedType, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!this.worker) {
+        reject(new Error("Worker not initialized"));
+        return;
+      }
+      const timeoutId = setTimeout(() => {
+        this.pendingResolvers.delete(expectedType);
+        this.poisoned = true;
+        reject(new Error(`Worker operation timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingResolvers.set(expectedType, {
+        resolve: (value) => {
+          clearTimeout(timeoutId);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      });
+      this.pendingResolvers.set("error", {
+        resolve: () => {
+        },
+        // Never called for errors
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          this.pendingResolvers.delete(expectedType);
+          reject(error);
+        }
+      });
+      this.worker.postMessage(message);
+    });
+  }
+  /**
+   * Load the ONNX model in the worker
+   *
+   * @param onProgress - Optional progress callback. Fires once at 100% when load completes
+   *   (the worker downloads and loads the model internally, so granular progress is not available).
+   */
+  async load(onProgress) {
+    if (this.isLoading) {
+      throw new Error("Model is already loading");
+    }
+    if (this._isLoaded) {
+      throw new Error("Model already loaded. Call dispose() first.");
+    }
+    this.isLoading = true;
+    const startTime = performance.now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("SenseVoiceWorker.load", {
+      "model.url": this.config.modelUrl,
+      "model.language": this.config.language
+    });
+    try {
+      logger5.info("Creating SenseVoice worker...");
+      this.worker = this.createWorker();
+      logger5.info("Loading model in worker...", {
+        modelUrl: this.config.modelUrl,
+        tokensUrl: this.config.tokensUrl,
+        language: this.config.language,
+        textNorm: this.config.textNorm
+      });
+      const result = await this.sendMessage(
+        {
+          type: "load",
+          modelUrl: resolveUrl(this.config.modelUrl),
+          tokensUrl: resolveUrl(this.config.tokensUrl),
+          wasmPaths: WASM_CDN_PATH2,
+          isIOS: isIOS(),
+          language: this.languageId,
+          textNorm: this.textNormId
+        },
+        "loaded",
+        LOAD_TIMEOUT_MS
+      );
+      this._isLoaded = true;
+      const loadTimeMs = performance.now() - startTime;
+      onProgress?.(1, 1);
+      logger5.info("SenseVoice worker loaded successfully", {
+        backend: "wasm",
+        loadTimeMs: Math.round(loadTimeMs),
+        workerLoadTimeMs: Math.round(result.loadTimeMs),
+        vocabSize: result.vocabSize,
+        language: this.config.language,
+        textNorm: this.config.textNorm
+      });
+      span?.setAttributes({
+        "model.backend": "wasm",
+        "model.load_time_ms": loadTimeMs,
+        "model.worker_load_time_ms": result.loadTimeMs,
+        "model.vocab_size": result.vocabSize
+      });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
+        model: "sensevoice-worker",
+        backend: "wasm"
+      });
+      return {
+        backend: "wasm",
+        loadTimeMs,
+        inputNames: result.inputNames,
+        outputNames: result.outputNames,
+        vocabSize: result.vocabSize
+      };
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      telemetry?.incrementCounter("omote.errors.total", 1, {
+        model: "sensevoice-worker",
+        error_type: "load_failed"
+      });
+      if (this.worker) {
+        this.worker.terminate();
+        this.worker = null;
+      }
+      throw error;
+    } finally {
+      this.isLoading = false;
+    }
+  }
+  /**
+   * Transcribe audio samples to text
+   *
+   * @param audioSamples Float32Array of audio samples at 16kHz, [-1, 1] range
+   * @returns Transcription result with text, emotion, language, and event
+   */
+  async transcribe(audioSamples) {
+    if (!this._isLoaded || !this.worker) {
+      throw new Error("Worker not loaded. Call load() first.");
+    }
+    if (this.poisoned) {
+      throw new Error("SenseVoice worker timed out \u2014 inference unavailable until page reload");
+    }
+    const audio = new Float32Array(audioSamples);
+    return this.queueInference(audio);
+  }
+  /**
+   * Queue inference to serialize worker calls
+   */
+  queueInference(audio) {
+    return new Promise((resolve, reject) => {
+      this.inferenceQueue = this.inferenceQueue.then(async () => {
+        const telemetry = getTelemetry();
+        const span = telemetry?.startSpan("SenseVoiceWorker.transcribe", {
+          "inference.backend": "wasm",
+          "inference.input_samples": audio.length
+        });
+        try {
+          const startTime = performance.now();
+          const result = await this.sendMessage(
+            {
+              type: "transcribe",
+              audio
+            },
+            "result",
+            INFERENCE_TIMEOUT_MS
+          );
+          const totalTimeMs = performance.now() - startTime;
+          logger5.trace("Worker transcription complete", {
+            text: result.text.substring(0, 50),
+            language: result.language,
+            emotion: result.emotion,
+            event: result.event,
+            preprocessTimeMs: Math.round(result.preprocessTimeMs * 100) / 100,
+            inferenceTimeMs: Math.round(result.inferenceTimeMs * 100) / 100,
+            roundTripMs: Math.round(totalTimeMs * 100) / 100
+          });
+          span?.setAttributes({
+            "inference.duration_ms": totalTimeMs,
+            "inference.worker_duration_ms": result.inferenceTimeMs,
+            "inference.preprocess_ms": result.preprocessTimeMs,
+            "inference.text_length": result.text.length
+          });
+          span?.end();
+          telemetry?.recordHistogram("omote.inference.latency", totalTimeMs, {
+            model: "sensevoice-worker",
+            backend: "wasm"
+          });
+          telemetry?.incrementCounter("omote.inference.total", 1, {
+            model: "sensevoice-worker",
+            backend: "wasm",
+            status: "success"
+          });
+          resolve({
+            text: result.text,
+            language: result.language,
+            emotion: result.emotion,
+            event: result.event,
+            inferenceTimeMs: result.inferenceTimeMs,
+            preprocessTimeMs: result.preprocessTimeMs
+          });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("timed out")) {
+            logger5.error("CRITICAL: Worker inference timed out \u2014 SenseVoice worker is dead. Page reload required.", {
+              timeoutMs: INFERENCE_TIMEOUT_MS
+            });
+          } else {
+            logger5.error("Worker inference failed", { error: errMsg });
+          }
+          span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+          telemetry?.incrementCounter("omote.inference.total", 1, {
+            model: "sensevoice-worker",
+            backend: "wasm",
+            status: "error"
+          });
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * Dispose of the worker and free resources
+   */
+  async dispose() {
+    if (this.worker) {
+      try {
+        await this.sendMessage({ type: "dispose" }, "disposed", INFERENCE_TIMEOUT_MS);
+      } catch {
+      }
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this._isLoaded = false;
+    this.poisoned = false;
+    this.pendingResolvers.clear();
+  }
+  /**
+   * Check if Web Workers are supported
+   */
+  static isSupported() {
+    return typeof Worker !== "undefined";
+  }
+};
+
+// src/inference/UnifiedInferenceWorker.ts
+var logger6 = createLogger("UnifiedInferenceWorker");
+var WASM_CDN_PATH3 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
+var INIT_TIMEOUT_MS = 15e3;
+var SV_LOAD_TIMEOUT_MS = 3e4;
+var SV_INFER_TIMEOUT_MS = 1e4;
+var CPU_LOAD_TIMEOUT_MS = 6e4;
+var CPU_INFER_TIMEOUT_MS = 5e3;
+var VAD_LOAD_TIMEOUT_MS = 1e4;
+var VAD_INFER_TIMEOUT_MS = 1e3;
+var DISPOSE_TIMEOUT_MS = 5e3;
+function resolveUrl2(url) {
+  if (/^https?:\/\//i.test(url) || /^blob:/i.test(url)) return url;
+  try {
+    return new URL(url, globalThis.location?.origin ?? "https://localhost").href;
+  } catch {
+    return url;
+  }
+}
+var requestCounter = 0;
+function nextRequestId() {
+  return `req_${++requestCounter}_${Date.now()}`;
+}
+var WORKER_SCRIPT2 = `
+// Unified Inference Worker Script
+// Hosts SenseVoice + Wav2ArkitCpu + Silero VAD in a single ORT instance
+
+var ort = null;
+
+// SenseVoice state
+var svSession = null;
+var svTokenMap = null;
+var svNegMean = null;
+var svInvStddev = null;
+var svLanguageId = 0;
+var svTextNormId = 14;
+var svVocabSize = 0;
+
+// Wav2ArkitCpu state
+var cpuSession = null;
+
+// Silero VAD state
+var vadSession = null;
+var vadSampleRate = 16000;
+var vadChunkSize = 512;
+var vadContextSize = 64;
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// kaldiFbank.ts \u2014 inlined as plain JavaScript
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+function fft(re, im) {
+  var n = re.length;
+  for (var i = 1, j = 0; i < n; i++) {
+    var bit = n >> 1;
+    while (j & bit) { j ^= bit; bit >>= 1; }
+    j ^= bit;
+    if (i < j) {
+      var tmp = re[i]; re[i] = re[j]; re[j] = tmp;
+      tmp = im[i]; im[i] = im[j]; im[j] = tmp;
+    }
+  }
+  for (var len = 2; len <= n; len *= 2) {
+    var halfLen = len / 2;
+    var angle = -2 * Math.PI / len;
+    var wRe = Math.cos(angle);
+    var wIm = Math.sin(angle);
+    for (var i = 0; i < n; i += len) {
+      var curRe = 1, curIm = 0;
+      for (var j = 0; j < halfLen; j++) {
+        var a = i + j, b = a + halfLen;
+        var tRe = curRe * re[b] - curIm * im[b];
+        var tIm = curRe * im[b] + curIm * re[b];
+        re[b] = re[a] - tRe; im[b] = im[a] - tIm;
+        re[a] += tRe; im[a] += tIm;
+        var nextRe = curRe * wRe - curIm * wIm;
+        curIm = curRe * wIm + curIm * wRe;
+        curRe = nextRe;
+      }
+    }
+  }
+}
+
+function htkMel(freq) { return 1127.0 * Math.log(1.0 + freq / 700.0); }
+function htkMelInverse(mel) { return 700.0 * (Math.exp(mel / 1127.0) - 1.0); }
+
+function buildMelFilterbank(numBins, fftSize, sampleRate, lowFreq, highFreq) {
+  var numFftBins = fftSize / 2 + 1;
+  var lowMel = htkMel(lowFreq);
+  var highMel = htkMel(highFreq);
+  var melPoints = new Float64Array(numBins + 2);
+  for (var i = 0; i < numBins + 2; i++) {
+    melPoints[i] = lowMel + (highMel - lowMel) * i / (numBins + 1);
+  }
+  var binFreqs = new Float64Array(numBins + 2);
+  for (var i = 0; i < numBins + 2; i++) {
+    binFreqs[i] = htkMelInverse(melPoints[i]) * fftSize / sampleRate;
+  }
+  var filters = [];
+  for (var m = 0; m < numBins; m++) {
+    var left = binFreqs[m], center = binFreqs[m + 1], right = binFreqs[m + 2];
+    var startBin = Math.max(0, Math.ceil(left));
+    var endBin = Math.min(numFftBins - 1, Math.floor(right));
+    var weights = new Float32Array(endBin - startBin + 1);
+    for (var k = startBin; k <= endBin; k++) {
+      if (k <= center) {
+        weights[k - startBin] = (center - left) > 0 ? (k - left) / (center - left) : 0;
+      } else {
+        weights[k - startBin] = (right - center) > 0 ? (right - k) / (right - center) : 0;
+      }
+    }
+    filters.push({ startBin: startBin, weights: weights });
+  }
+  return filters;
+}
+
+function createHammingWindow(length) {
+  var w = new Float32Array(length);
+  for (var i = 0; i < length; i++) {
+    w[i] = 0.54 - 0.46 * Math.cos(2 * Math.PI * i / (length - 1));
+  }
+  return w;
+}
+
+function computeKaldiFbank(audio, sampleRate, numMelBins, opts) {
+  var frameLengthMs = (opts && opts.frameLengthMs !== undefined) ? opts.frameLengthMs : 25;
+  var frameShiftMs = (opts && opts.frameShiftMs !== undefined) ? opts.frameShiftMs : 10;
+  var lowFreq = (opts && opts.lowFreq !== undefined) ? opts.lowFreq : 20;
+  var highFreq = (opts && opts.highFreq !== undefined) ? opts.highFreq : (sampleRate / 2);
+  var dither = (opts && opts.dither !== undefined) ? opts.dither : 0;
+  var preemphasis = (opts && opts.preemphasis !== undefined) ? opts.preemphasis : 0.97;
+
+  var frameLengthSamples = Math.round(sampleRate * frameLengthMs / 1000);
+  var frameShiftSamples = Math.round(sampleRate * frameShiftMs / 1000);
+
+  var scaled = new Float32Array(audio.length);
+  for (var i = 0; i < audio.length; i++) { scaled[i] = audio[i] * 32768; }
+
+  if (dither > 0) {
+    for (var i = 0; i < scaled.length; i++) {
+      var u1 = Math.random(), u2 = Math.random();
+      scaled[i] += dither * Math.sqrt(-2 * Math.log(u1 + 1e-10)) * Math.cos(2 * Math.PI * u2);
+    }
+  }
+
+  var numFrames = Math.max(0, Math.floor((scaled.length - frameLengthSamples) / frameShiftSamples) + 1);
+  if (numFrames === 0) return new Float32Array(0);
+
+  var fftSize = 1;
+  while (fftSize < frameLengthSamples) fftSize *= 2;
+  var numFftBins = fftSize / 2 + 1;
+
+  var window = createHammingWindow(frameLengthSamples);
+  var filters = buildMelFilterbank(numMelBins, fftSize, sampleRate, lowFreq, highFreq);
+  var output = new Float32Array(numFrames * numMelBins);
+  var fftRe = new Float64Array(fftSize);
+  var fftIm = new Float64Array(fftSize);
+
+  for (var f = 0; f < numFrames; f++) {
+    var offset = f * frameShiftSamples;
+    fftRe.fill(0); fftIm.fill(0);
+    for (var i = 0; i < frameLengthSamples; i++) {
+      var sample = scaled[offset + i];
+      if (preemphasis > 0 && i > 0) {
+        sample -= preemphasis * scaled[offset + i - 1];
+      } else if (preemphasis > 0 && i === 0 && offset > 0) {
+        sample -= preemphasis * scaled[offset - 1];
+      }
+      fftRe[i] = sample * window[i];
+    }
+    fft(fftRe, fftIm);
+    var outOffset = f * numMelBins;
+    for (var m = 0; m < numMelBins; m++) {
+      var filter = filters[m];
+      var energy = 0;
+      for (var k = 0; k < filter.weights.length; k++) {
+        var bin = filter.startBin + k;
+        if (bin < numFftBins) {
+          var powerSpec = fftRe[bin] * fftRe[bin] + fftIm[bin] * fftIm[bin];
+          energy += filter.weights[k] * powerSpec;
+        }
+      }
+      output[outOffset + m] = Math.log(Math.max(energy, 1e-10));
+    }
+  }
+  return output;
+}
+
+function applyLFR(features, featureDim, lfrM, lfrN) {
+  var numFrames = features.length / featureDim;
+  if (numFrames === 0) return new Float32Array(0);
+  var leftPad = Math.floor((lfrM - 1) / 2);
+  var paddedLen = numFrames + leftPad;
+  var numOutputFrames = Math.ceil(paddedLen / lfrN);
+  var outputDim = featureDim * lfrM;
+  var output = new Float32Array(numOutputFrames * outputDim);
+  for (var i = 0; i < numOutputFrames; i++) {
+    var startFrame = i * lfrN - leftPad;
+    for (var j = 0; j < lfrM; j++) {
+      var srcFrame = startFrame + j;
+      if (srcFrame < 0) srcFrame = 0;
+      if (srcFrame >= numFrames) srcFrame = numFrames - 1;
+      var srcOffset = srcFrame * featureDim;
+      var dstOffset = i * outputDim + j * featureDim;
+      for (var k = 0; k < featureDim; k++) {
+        output[dstOffset + k] = features[srcOffset + k];
+      }
+    }
+  }
+  return output;
+}
+
+function applyCMVN(features, dim, negMeanVec, invStddevVec) {
+  for (var i = 0; i < features.length; i++) {
+    var d = i % dim;
+    features[i] = (features[i] + negMeanVec[d]) * invStddevVec[d];
+  }
+  return features;
+}
+
+function parseCMVNFromMetadata(negMeanStr, invStddevStr) {
+  var negMeanArr = new Float32Array(
+    negMeanStr.split(',').map(function(s) { return parseFloat(s.trim()); })
+  );
+  var invStddevArr = new Float32Array(
+    invStddevStr.split(',').map(function(s) { return parseFloat(s.trim()); })
+  );
+  return { negMean: negMeanArr, invStddev: invStddevArr };
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// ctcDecoder.ts \u2014 inlined as plain JavaScript
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+var LANGUAGE_IDS = { 0: 'auto', 3: 'zh', 4: 'en', 7: 'yue', 11: 'ja', 12: 'ko', 13: 'nospeech' };
+var TEXT_NORM_IDS = { 14: 'with_itn', 15: 'without_itn' };
+
+function resolveLanguageIdW(language) {
+  var map = { auto: 0, zh: 3, en: 4, yue: 7, ja: 11, ko: 12 };
+  return map[language] !== undefined ? map[language] : 0;
+}
+
+function resolveTextNormIdW(textNorm) {
+  return textNorm === 'without_itn' ? 15 : 14;
+}
+
+function parseTokensFile(content) {
+  var map = new Map();
+  var lines = content.split('\\n');
+  for (var idx = 0; idx < lines.length; idx++) {
+    var trimmed = lines[idx].trim();
+    if (!trimmed) continue;
+    var lastSpace = trimmed.lastIndexOf(' ');
+    if (lastSpace === -1) continue;
+    var token = trimmed.substring(0, lastSpace);
+    var id = parseInt(trimmed.substring(lastSpace + 1), 10);
+    if (!isNaN(id)) map.set(id, token);
+  }
+  return map;
+}
+
+function parseStructuredToken(token) {
+  var match = token.match(/^<\\|(.+)\\|>$/);
+  if (!match) return null;
+  var value = match[1];
+  if (value === 'zh' || value === 'en' || value === 'ja' || value === 'ko' || value === 'yue' || value === 'nospeech') {
+    return { type: 'language', value: value };
+  }
+  var emotions = ['HAPPY', 'SAD', 'ANGRY', 'NEUTRAL', 'FEARFUL', 'DISGUSTED', 'SURPRISED', 'EMO_UNKNOWN'];
+  if (emotions.indexOf(value) !== -1) return { type: 'emotion', value: value };
+  var events = ['Speech', 'BGM', 'Applause', 'Laughter', 'Crying', 'Coughing', 'Sneezing', 'EVENT_UNKNOWN'];
+  if (events.indexOf(value) !== -1) return { type: 'event', value: value };
+  if (value === 'withitn' || value === 'woitn' || value === 'with_itn' || value === 'without_itn') {
+    return { type: 'textnorm', value: value };
+  }
+  return null;
+}
+
+function ctcGreedyDecode(logits, seqLen, vocabSz, tokenMapLocal) {
+  var tokenIds = [];
+  for (var t = 0; t < seqLen; t++) {
+    var offset = t * vocabSz;
+    var maxIdx = 0, maxVal = logits[offset];
+    for (var v = 1; v < vocabSz; v++) {
+      if (logits[offset + v] > maxVal) { maxVal = logits[offset + v]; maxIdx = v; }
+    }
+    tokenIds.push(maxIdx);
+  }
+  var collapsed = [], prev = -1;
+  for (var idx = 0; idx < tokenIds.length; idx++) {
+    var id = tokenIds[idx];
+    if (id !== prev) { collapsed.push(id); prev = id; }
+  }
+  var filtered = collapsed.filter(function(id) { return id !== 0 && id !== 1 && id !== 2; });
+  var language = undefined, emotion = undefined, event = undefined;
+  var textTokens = [];
+  for (var idx = 0; idx < filtered.length; idx++) {
+    var id = filtered[idx];
+    var token = tokenMapLocal.get(id);
+    if (!token) continue;
+    var structured = parseStructuredToken(token);
+    if (structured) {
+      if (structured.type === 'language') language = structured.value;
+      else if (structured.type === 'emotion') emotion = structured.value;
+      else if (structured.type === 'event') event = structured.value;
+    } else {
+      textTokens.push(token);
+    }
+  }
+  var text = textTokens.join('');
+  text = text.replace(/\\u2581/g, ' ').trim();
+  return { text: text, language: language, emotion: emotion, event: event };
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// blendshapeUtils.ts \u2014 inlined
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+var SYMMETRIC_INDEX_PAIRS = [
+  [23, 25], [32, 38], [43, 44], [29, 30], [27, 28], [45, 46],
+  [35, 36], [47, 48], [33, 34], [49, 50], [6, 7], [0, 1],
+  [3, 4], [8, 9], [16, 17], [10, 11], [12, 13], [14, 15],
+  [18, 19], [20, 21],
+];
+
+function symmetrizeBlendshapes(frame) {
+  var result = new Float32Array(frame);
+  for (var p = 0; p < SYMMETRIC_INDEX_PAIRS.length; p++) {
+    var lIdx = SYMMETRIC_INDEX_PAIRS[p][0], rIdx = SYMMETRIC_INDEX_PAIRS[p][1];
+    var avg = (frame[lIdx] + frame[rIdx]) / 2;
+    result[lIdx] = avg;
+    result[rIdx] = avg;
+  }
+  return result;
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// Shared ORT loader
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+async function loadOrt(wasmPaths, isIOSDevice) {
+  if (ort) return;
+  var ortUrl = wasmPaths + 'ort.wasm.min.js';
+  var response = await fetch(ortUrl);
+  var scriptText = await response.text();
+  var blob = new Blob([scriptText], { type: 'application/javascript' });
+  var blobUrl = URL.createObjectURL(blob);
+  importScripts(blobUrl);
+  URL.revokeObjectURL(blobUrl);
+  ort = self.ort;
+  ort.env.wasm.wasmPaths = wasmPaths;
+  ort.env.wasm.numThreads = isIOSDevice ? 1 : 4;
+  ort.env.wasm.simd = true;
+  ort.env.wasm.proxy = false;
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// SenseVoice handlers
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+async function svLoad(msg) {
+  var tokensResponse = await fetch(msg.tokensUrl);
+  if (!tokensResponse.ok) throw new Error('Failed to fetch tokens.txt: ' + tokensResponse.status);
+  var tokensText = await tokensResponse.text();
+  svTokenMap = parseTokensFile(tokensText);
+  svLanguageId = msg.language;
+  svTextNormId = msg.textNorm;
+
+  var sessionOptions = { executionProviders: ['wasm'], graphOptimizationLevel: 'all' };
+  if (msg.isIOS) {
+    svSession = await ort.InferenceSession.create(msg.modelUrl, sessionOptions);
+  } else {
+    var modelResponse = await fetch(msg.modelUrl);
+    if (!modelResponse.ok) throw new Error('Failed to fetch model: ' + modelResponse.status);
+    var modelBuffer = await modelResponse.arrayBuffer();
+    svSession = await ort.InferenceSession.create(new Uint8Array(modelBuffer), sessionOptions);
+  }
+
+  try {
+    var metadata = svSession.handler && svSession.handler.metadata;
+    if (metadata && metadata.neg_mean && metadata.inv_stddev) {
+      var cmvn = parseCMVNFromMetadata(metadata.neg_mean, metadata.inv_stddev);
+      svNegMean = cmvn.negMean;
+      svInvStddev = cmvn.invStddev;
+    }
+  } catch (e) { /* CMVN not available */ }
+
+  svVocabSize = 0;
+  svTokenMap.forEach(function(val, key) { if (key >= svVocabSize) svVocabSize = key + 1; });
+
+  return {
+    vocabSize: svVocabSize,
+    inputNames: svSession.inputNames.slice(),
+    outputNames: svSession.outputNames.slice(),
+  };
+}
+
+async function svTranscribe(audio) {
+  var preprocessStart = performance.now();
+  var fbank = computeKaldiFbank(audio, 16000, 80);
+  var numFrames = fbank.length / 80;
+  if (numFrames === 0) {
+    return { text: '', inferenceTimeMs: performance.now() - preprocessStart, preprocessTimeMs: performance.now() - preprocessStart };
+  }
+  var lfrFeatures = applyLFR(fbank, 80, 7, 6);
+  var numLfrFrames = lfrFeatures.length / 560;
+  if (svNegMean && svInvStddev) applyCMVN(lfrFeatures, 560, svNegMean, svInvStddev);
+  var preprocessTimeMs = performance.now() - preprocessStart;
+
+  var feeds = {
+    x: new ort.Tensor('float32', lfrFeatures, [1, numLfrFrames, 560]),
+    x_length: new ort.Tensor('int32', new Int32Array([numLfrFrames]), [1]),
+    language: new ort.Tensor('int32', new Int32Array([svLanguageId]), [1]),
+    text_norm: new ort.Tensor('int32', new Int32Array([svTextNormId]), [1]),
+  };
+  var results = await svSession.run(feeds);
+  var logitsOutput = results['logits'];
+  if (!logitsOutput) throw new Error('Model output missing "logits" tensor');
+
+  var decoded = ctcGreedyDecode(logitsOutput.data, logitsOutput.dims[1], logitsOutput.dims[2], svTokenMap);
+  var totalTimeMs = performance.now() - preprocessStart;
+
+  return {
+    text: decoded.text, language: decoded.language, emotion: decoded.emotion, event: decoded.event,
+    inferenceTimeMs: totalTimeMs, preprocessTimeMs: preprocessTimeMs,
+  };
+}
+
+async function svDispose() {
+  if (svSession) { await svSession.release(); svSession = null; }
+  svTokenMap = null; svNegMean = null; svInvStddev = null;
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// Wav2ArkitCpu handlers
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+async function cpuLoad(msg) {
+  var sessionOptions = { executionProviders: ['wasm'], graphOptimizationLevel: 'all' };
+  var dataFilename = msg.externalDataUrl ? msg.externalDataUrl.split('/').pop() : null;
+
+  if (msg.isIOS) {
+    if (msg.externalDataUrl && dataFilename) {
+      sessionOptions.externalData = [{ path: dataFilename, data: msg.externalDataUrl }];
+    }
+    cpuSession = await ort.InferenceSession.create(msg.modelUrl, sessionOptions);
+  } else {
+    var graphResponse = await fetch(msg.modelUrl);
+    if (!graphResponse.ok) throw new Error('Failed to fetch model graph: ' + graphResponse.status);
+    var graphBuffer = await graphResponse.arrayBuffer();
+    if (msg.externalDataUrl && dataFilename) {
+      var dataResponse = await fetch(msg.externalDataUrl);
+      if (!dataResponse.ok) throw new Error('Failed to fetch external data: ' + dataResponse.status);
+      var dataBuffer = await dataResponse.arrayBuffer();
+      sessionOptions.externalData = [{ path: dataFilename, data: new Uint8Array(dataBuffer) }];
+    }
+    cpuSession = await ort.InferenceSession.create(new Uint8Array(graphBuffer), sessionOptions);
+  }
+
+  // Warmup
+  var warmupAudio = new Float32Array(16000);
+  var warmupTensor = new ort.Tensor('float32', warmupAudio, [1, warmupAudio.length]);
+  await cpuSession.run({ audio_waveform: warmupTensor });
+
+  return {
+    inputNames: cpuSession.inputNames.slice(),
+    outputNames: cpuSession.outputNames.slice(),
+  };
+}
+
+async function cpuInfer(audio) {
+  var tensor = new ort.Tensor('float32', audio, [1, audio.length]);
+  var results = await cpuSession.run({ audio_waveform: tensor });
+  var blendshapeOutput = results['blendshapes'];
+  if (!blendshapeOutput) throw new Error('Missing blendshapes output from model');
+
+  var blendshapeData = blendshapeOutput.data;
+  var numFrames = blendshapeOutput.dims[1];
+  var numBlendshapes = blendshapeOutput.dims[2];
+
+  var flatBuffer = new Float32Array(numFrames * numBlendshapes);
+  for (var f = 0; f < numFrames; f++) {
+    var offset = f * numBlendshapes;
+    var rawFrame = blendshapeData.slice(offset, offset + numBlendshapes);
+    var symmetrized = symmetrizeBlendshapes(rawFrame);
+    flatBuffer.set(symmetrized, offset);
+  }
+  return { flatBuffer: flatBuffer, numFrames: numFrames, numBlendshapes: numBlendshapes };
+}
+
+async function cpuDispose() {
+  if (cpuSession) { await cpuSession.release(); cpuSession = null; }
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// Silero VAD handlers
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+async function vadLoad(msg) {
+  vadSampleRate = msg.sampleRate;
+  vadChunkSize = vadSampleRate === 16000 ? 512 : 256;
+  vadContextSize = vadSampleRate === 16000 ? 64 : 32;
+
+  var response = await fetch(msg.modelUrl);
+  if (!response.ok) throw new Error('Failed to fetch VAD model: ' + response.status);
+  var modelBuffer = await response.arrayBuffer();
+  vadSession = await ort.InferenceSession.create(new Uint8Array(modelBuffer), {
+    executionProviders: ['wasm'],
+    graphOptimizationLevel: 'all',
+  });
+
+  return {
+    inputNames: vadSession.inputNames.slice(),
+    outputNames: vadSession.outputNames.slice(),
+  };
+}
+
+async function vadProcess(audio, state, context) {
+  var inputSize = vadContextSize + vadChunkSize;
+  var inputBuffer = new Float32Array(inputSize);
+  inputBuffer.set(context, 0);
+  inputBuffer.set(audio, vadContextSize);
+
+  var inputTensor = new ort.Tensor('float32', new Float32Array(inputBuffer), [1, inputSize]);
+  var stateTensor = new ort.Tensor('float32', new Float32Array(state), [2, 1, 128]);
+  var srTensor;
+  try {
+    srTensor = new ort.Tensor('int64', new BigInt64Array([BigInt(vadSampleRate)]), []);
+  } catch (e) {
+    srTensor = new ort.Tensor('int64', [BigInt(vadSampleRate)], []);
+  }
+
+  var feeds = { 'input': inputTensor, 'state': stateTensor, 'sr': srTensor };
+  var results = await vadSession.run(feeds);
+  var outputTensor = results['output'];
+  var newStateTensor = results['stateN'] || results['state'];
+  if (!outputTensor) throw new Error('Missing output tensor from VAD model');
+
+  return { probability: outputTensor.data[0], newState: new Float32Array(newStateTensor.data) };
+}
+
+function vadCreateInitialState() {
+  return new Float32Array(2 * 1 * 128);
+}
+
+async function vadDispose() {
+  if (vadSession) { await vadSession.release(); vadSession = null; }
+}
+
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+// Message handler
+// \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+
+self.onmessage = async function(e) {
+  var msg = e.data;
+  var requestId = msg.requestId;
+
+  try {
+    switch (msg.type) {
+      case 'init': {
+        var startTime = performance.now();
+        await loadOrt(msg.wasmPaths, msg.isIOS);
+        self.postMessage({ type: 'init:done', requestId: requestId, loadTimeMs: performance.now() - startTime });
+        break;
+      }
+
+      case 'sv:load': {
+        var startTime = performance.now();
+        var info = await svLoad(msg);
+        self.postMessage({
+          type: 'sv:loaded', requestId: requestId, vocabSize: info.vocabSize,
+          inputNames: info.inputNames, outputNames: info.outputNames,
+          loadTimeMs: performance.now() - startTime,
+        });
+        break;
+      }
+
+      case 'sv:transcribe': {
+        var result = await svTranscribe(msg.audio);
+        self.postMessage({
+          type: 'sv:result', requestId: requestId,
+          text: result.text, language: result.language, emotion: result.emotion, event: result.event,
+          inferenceTimeMs: result.inferenceTimeMs, preprocessTimeMs: result.preprocessTimeMs,
+        });
+        break;
+      }
+
+      case 'sv:dispose': {
+        await svDispose();
+        self.postMessage({ type: 'sv:disposed', requestId: requestId });
+        break;
+      }
+
+      case 'cpu:load': {
+        var startTime = performance.now();
+        var info = await cpuLoad(msg);
+        self.postMessage({
+          type: 'cpu:loaded', requestId: requestId,
+          inputNames: info.inputNames, outputNames: info.outputNames,
+          loadTimeMs: performance.now() - startTime,
+        });
+        break;
+      }
+
+      case 'cpu:infer': {
+        var startTime = performance.now();
+        var result = await cpuInfer(msg.audio);
+        var inferenceTimeMs = performance.now() - startTime;
+        self.postMessage({
+          type: 'cpu:result', requestId: requestId,
+          blendshapes: result.flatBuffer, numFrames: result.numFrames,
+          numBlendshapes: result.numBlendshapes, inferenceTimeMs: inferenceTimeMs,
+        }, [result.flatBuffer.buffer]);
+        break;
+      }
+
+      case 'cpu:dispose': {
+        await cpuDispose();
+        self.postMessage({ type: 'cpu:disposed', requestId: requestId });
+        break;
+      }
+
+      case 'vad:load': {
+        var startTime = performance.now();
+        var info = await vadLoad(msg);
+        self.postMessage({
+          type: 'vad:loaded', requestId: requestId,
+          inputNames: info.inputNames, outputNames: info.outputNames,
+          loadTimeMs: performance.now() - startTime,
+        });
+        break;
+      }
+
+      case 'vad:process': {
+        var startTime = performance.now();
+        var result = await vadProcess(msg.audio, msg.state, msg.context);
+        self.postMessage({
+          type: 'vad:result', requestId: requestId,
+          probability: result.probability, state: result.newState,
+          inferenceTimeMs: performance.now() - startTime,
+        });
+        break;
+      }
+
+      case 'vad:reset': {
+        var state = vadCreateInitialState();
+        self.postMessage({ type: 'vad:reset', requestId: requestId, state: state });
+        break;
+      }
+
+      case 'vad:dispose': {
+        await vadDispose();
+        self.postMessage({ type: 'vad:disposed', requestId: requestId });
+        break;
+      }
+
+      case 'dispose-all': {
+        await svDispose();
+        await cpuDispose();
+        await vadDispose();
+        ort = null;
+        self.postMessage({ type: 'dispose-all:done', requestId: requestId });
+        break;
+      }
+
+      default:
+        self.postMessage({ type: 'error', requestId: requestId, error: 'Unknown message type: ' + msg.type });
+    }
+  } catch (err) {
+    var errorMsg = err.message || String(err);
+    if (typeof err === 'number') {
+      errorMsg = 'Raw C++ exception pointer (0x' + err.toString(16) + '). Likely OOM in WASM.';
+    }
+    self.postMessage({ type: 'error', requestId: requestId, error: errorMsg });
+  }
+};
+
+self.onerror = function(err) {
+  self.postMessage({ type: 'error', requestId: null, error: 'Worker error: ' + (err.message || String(err)) });
+};
+`;
+var UnifiedInferenceWorker = class {
+  constructor() {
+    this.worker = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.initialized = false;
+    this.poisoned = false;
+  }
+  /**
+   * Initialize the worker (load ORT WASM from CDN)
+   */
+  async init() {
+    if (this.initialized) return;
+    const startTime = performance.now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("UnifiedInferenceWorker.init");
+    try {
+      logger6.info("Creating unified inference worker...");
+      this.worker = this.createWorker();
+      await this.sendMessage(
+        { type: "init", wasmPaths: WASM_CDN_PATH3, isIOS: isIOS() },
+        "init:done",
+        INIT_TIMEOUT_MS
+      );
+      this.initialized = true;
+      const loadTimeMs = performance.now() - startTime;
+      logger6.info("Unified worker initialized", { loadTimeMs: Math.round(loadTimeMs) });
+      span?.setAttributes({ "worker.init_time_ms": loadTimeMs });
+      span?.end();
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      this.cleanup();
+      throw error;
+    }
+  }
+  // ── SenseVoice ────────────────────────────────────────────────────────
+  async loadSenseVoice(config) {
+    this.assertReady();
+    const startTime = performance.now();
+    const result = await this.sendMessage(
+      {
+        type: "sv:load",
+        modelUrl: resolveUrl2(config.modelUrl),
+        tokensUrl: resolveUrl2(config.tokensUrl),
+        isIOS: isIOS(),
+        language: config.language,
+        textNorm: config.textNorm
+      },
+      "sv:loaded",
+      SV_LOAD_TIMEOUT_MS
+    );
+    const loadTimeMs = performance.now() - startTime;
+    return {
+      backend: "wasm",
+      loadTimeMs,
+      inputNames: result.inputNames,
+      outputNames: result.outputNames,
+      vocabSize: result.vocabSize
+    };
+  }
+  async transcribe(audio) {
+    this.assertReady();
+    const result = await this.sendMessage(
+      { type: "sv:transcribe", audio },
+      "sv:result",
+      SV_INFER_TIMEOUT_MS
+    );
+    return {
+      text: result.text,
+      language: result.language,
+      emotion: result.emotion,
+      event: result.event,
+      inferenceTimeMs: result.inferenceTimeMs,
+      preprocessTimeMs: result.preprocessTimeMs
+    };
+  }
+  async disposeSenseVoice() {
+    if (!this.worker) return;
+    await this.sendMessage({ type: "sv:dispose" }, "sv:disposed", DISPOSE_TIMEOUT_MS);
+  }
+  // ── Wav2ArkitCpu (Lip Sync) ──────────────────────────────────────────
+  async loadLipSync(config) {
+    this.assertReady();
+    const startTime = performance.now();
+    const result = await this.sendMessage(
+      {
+        type: "cpu:load",
+        modelUrl: resolveUrl2(config.modelUrl),
+        externalDataUrl: config.externalDataUrl ? resolveUrl2(config.externalDataUrl) : null,
+        isIOS: isIOS()
+      },
+      "cpu:loaded",
+      CPU_LOAD_TIMEOUT_MS
+    );
+    const loadTimeMs = performance.now() - startTime;
+    return {
+      backend: "wasm",
+      loadTimeMs,
+      inputNames: result.inputNames,
+      outputNames: result.outputNames
+    };
+  }
+  async inferLipSync(audio) {
+    this.assertReady();
+    return this.sendMessage(
+      { type: "cpu:infer", audio },
+      "cpu:result",
+      CPU_INFER_TIMEOUT_MS
+    );
+  }
+  async disposeLipSync() {
+    if (!this.worker) return;
+    await this.sendMessage({ type: "cpu:dispose" }, "cpu:disposed", DISPOSE_TIMEOUT_MS);
+  }
+  // ── Silero VAD ────────────────────────────────────────────────────────
+  async loadVAD(config) {
+    this.assertReady();
+    const startTime = performance.now();
+    const chunkSize = config.sampleRate === 16e3 ? 512 : 256;
+    const result = await this.sendMessage(
+      {
+        type: "vad:load",
+        modelUrl: resolveUrl2(config.modelUrl),
+        sampleRate: config.sampleRate
+      },
+      "vad:loaded",
+      VAD_LOAD_TIMEOUT_MS
+    );
+    const loadTimeMs = performance.now() - startTime;
+    return {
+      backend: "wasm",
+      loadTimeMs,
+      inputNames: result.inputNames,
+      outputNames: result.outputNames,
+      sampleRate: config.sampleRate,
+      chunkSize
+    };
+  }
+  async processVAD(audio, state, context) {
+    this.assertReady();
+    return this.sendMessage(
+      { type: "vad:process", audio, state, context },
+      "vad:result",
+      VAD_INFER_TIMEOUT_MS
+    );
+  }
+  async resetVAD() {
+    this.assertReady();
+    const result = await this.sendMessage(
+      { type: "vad:reset" },
+      "vad:reset",
+      VAD_INFER_TIMEOUT_MS
+    );
+    return result.state;
+  }
+  async disposeVAD() {
+    if (!this.worker) return;
+    await this.sendMessage({ type: "vad:dispose" }, "vad:disposed", DISPOSE_TIMEOUT_MS);
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  async dispose() {
+    if (this.worker) {
+      try {
+        await this.sendMessage({ type: "dispose-all" }, "dispose-all:done", DISPOSE_TIMEOUT_MS);
+      } catch {
+      }
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initialized = false;
+    this.poisoned = false;
+    this.rejectAllPending("Worker disposed");
+    this.pendingRequests.clear();
+  }
+  /** Check if the worker is initialized and not poisoned */
+  get isReady() {
+    return this.initialized && !this.poisoned && this.worker !== null;
+  }
+  /** Check if Web Workers are supported */
+  static isSupported() {
+    return typeof Worker !== "undefined";
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  assertReady() {
+    if (!this.initialized || !this.worker) {
+      throw new Error("UnifiedInferenceWorker not initialized. Call init() first.");
+    }
+    if (this.poisoned) {
+      throw new Error("UnifiedInferenceWorker timed out \u2014 unavailable until page reload");
+    }
+  }
+  createWorker() {
+    const blob = new Blob([WORKER_SCRIPT2], { type: "application/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    const worker = new Worker(blobUrl);
+    URL.revokeObjectURL(blobUrl);
+    worker.onmessage = (event) => {
+      this.handleWorkerMessage(event.data);
+    };
+    worker.onerror = (error) => {
+      logger6.error("Unified worker error", { error: error.message });
+      this.rejectAllPending(`Worker error: ${error.message}`);
+    };
+    return worker;
+  }
+  handleWorkerMessage(data) {
+    const requestId = data.requestId;
+    if (data.type === "error") {
+      if (requestId && this.pendingRequests.has(requestId)) {
+        const pending = this.pendingRequests.get(requestId);
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(requestId);
+        pending.reject(new Error(data.error));
+      } else {
+        logger6.error("Worker broadcast error", { error: data.error });
+        this.rejectAllPending(data.error);
+      }
+      return;
+    }
+    if (requestId && this.pendingRequests.has(requestId)) {
+      const pending = this.pendingRequests.get(requestId);
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(requestId);
+      pending.resolve(data);
+    }
+  }
+  sendMessage(message, expectedType, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!this.worker) {
+        reject(new Error("Worker not initialized"));
+        return;
+      }
+      const requestId = nextRequestId();
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        this.poisoned = true;
+        logger6.error("CRITICAL: Worker operation timed out \u2014 worker is dead", {
+          type: message.type,
+          timeoutMs
+        });
+        reject(new Error(`Worker operation '${message.type}' timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingRequests.set(requestId, {
+        resolve,
+        reject,
+        timeout
+      });
+      this.worker.postMessage({ ...message, requestId });
+    });
+  }
+  rejectAllPending(reason) {
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(reason));
+    }
+    this.pendingRequests.clear();
+  }
+  cleanup() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.initialized = false;
+    this.rejectAllPending("Worker cleanup");
+    this.pendingRequests.clear();
+  }
+};
+var SenseVoiceUnifiedAdapter = class {
+  constructor(worker, config) {
+    this._isLoaded = false;
+    this.inferenceQueue = Promise.resolve();
+    this.worker = worker;
+    const modelDir = config.modelUrl.substring(0, config.modelUrl.lastIndexOf("/"));
+    this.config = {
+      modelUrl: config.modelUrl,
+      tokensUrl: config.tokensUrl ?? `${modelDir}/tokens.txt`,
+      language: config.language ?? "auto",
+      textNorm: config.textNorm ?? "with_itn"
+    };
+    this.languageId = resolveLanguageId(this.config.language);
+    this.textNormId = resolveTextNormId(this.config.textNorm);
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  get backend() {
+    return this._isLoaded ? "wasm" : null;
+  }
+  async load(onProgress) {
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("SenseVoiceUnifiedAdapter.load", {
+      "model.url": this.config.modelUrl
+    });
+    try {
+      const result = await this.worker.loadSenseVoice({
+        modelUrl: this.config.modelUrl,
+        tokensUrl: this.config.tokensUrl,
+        language: this.languageId,
+        textNorm: this.textNormId
+      });
+      this._isLoaded = true;
+      onProgress?.(1, 1);
+      logger6.info("SenseVoice loaded via unified worker", {
+        backend: "wasm",
+        loadTimeMs: Math.round(result.loadTimeMs),
+        vocabSize: result.vocabSize
+      });
+      span?.setAttributes({ "model.backend": "wasm", "model.load_time_ms": result.loadTimeMs });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+        model: "sensevoice-unified",
+        backend: "wasm"
+      });
+      return result;
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  async transcribe(audioSamples) {
+    if (!this._isLoaded) throw new Error("Model not loaded. Call load() first.");
+    const audio = new Float32Array(audioSamples);
+    return new Promise((resolve, reject) => {
+      this.inferenceQueue = this.inferenceQueue.then(async () => {
+        try {
+          const result = await this.worker.transcribe(audio);
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+  async dispose() {
+    if (this._isLoaded) {
+      await this.worker.disposeSenseVoice();
+      this._isLoaded = false;
+    }
+  }
+};
+var Wav2ArkitCpuUnifiedAdapter = class {
+  constructor(worker, config) {
+    this.modelId = "wav2arkit_cpu";
+    this._isLoaded = false;
+    this.inferenceQueue = Promise.resolve();
+    this.worker = worker;
+    this.config = config;
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  get backend() {
+    return this._isLoaded ? "wasm" : null;
+  }
+  async load() {
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("Wav2ArkitCpuUnifiedAdapter.load", {
+      "model.url": this.config.modelUrl
+    });
+    try {
+      const externalDataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${this.config.modelUrl}.data` : null;
+      const result = await this.worker.loadLipSync({
+        modelUrl: this.config.modelUrl,
+        externalDataUrl: externalDataUrl || null
+      });
+      this._isLoaded = true;
+      logger6.info("Wav2ArkitCpu loaded via unified worker", {
+        backend: "wasm",
+        loadTimeMs: Math.round(result.loadTimeMs)
+      });
+      span?.setAttributes({ "model.backend": "wasm", "model.load_time_ms": result.loadTimeMs });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+        model: "wav2arkit_cpu-unified",
+        backend: "wasm"
+      });
+      return result;
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  async infer(audioSamples, _identityIndex) {
+    if (!this._isLoaded) throw new Error("Model not loaded. Call load() first.");
+    const audioCopy = new Float32Array(audioSamples);
+    return new Promise((resolve, reject) => {
+      this.inferenceQueue = this.inferenceQueue.then(async () => {
+        const telemetry = getTelemetry();
+        const span = telemetry?.startSpan("Wav2ArkitCpuUnifiedAdapter.infer", {
+          "inference.input_samples": audioCopy.length
+        });
+        try {
+          const startTime = performance.now();
+          const result = await this.worker.inferLipSync(audioCopy);
+          const inferenceTimeMs = performance.now() - startTime;
+          const flatBuffer = result.blendshapes;
+          const { numFrames, numBlendshapes } = result;
+          const blendshapes = [];
+          for (let f = 0; f < numFrames; f++) {
+            blendshapes.push(flatBuffer.slice(f * numBlendshapes, (f + 1) * numBlendshapes));
+          }
+          span?.setAttributes({
+            "inference.duration_ms": inferenceTimeMs,
+            "inference.frames": numFrames
+          });
+          span?.end();
+          resolve({ blendshapes, numFrames, inferenceTimeMs });
+        } catch (err) {
+          span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+          reject(err);
+        }
+      });
+    });
+  }
+  async dispose() {
+    if (this._isLoaded) {
+      await this.worker.disposeLipSync();
+      this._isLoaded = false;
+    }
+  }
+};
+var SileroVADUnifiedAdapter = class {
+  constructor(worker, config) {
+    this._isLoaded = false;
+    // Inference queue
+    this.inferenceQueue = Promise.resolve();
+    // Pre-speech buffer
+    this.preSpeechBuffer = [];
+    this.wasSpeaking = false;
+    this.worker = worker;
+    const sr = config.sampleRate ?? 16e3;
+    this.config = {
+      modelUrl: config.modelUrl,
+      backend: config.backend ?? "wasm",
+      sampleRate: sr,
+      threshold: config.threshold ?? 0.5,
+      preSpeechBufferChunks: config.preSpeechBufferChunks ?? 10
+    };
+    this.chunkSize = sr === 16e3 ? 512 : 256;
+    this.contextSize = sr === 16e3 ? 64 : 32;
+    this.state = new Float32Array(2 * 1 * 128);
+    this.context = new Float32Array(this.contextSize);
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  get backend() {
+    return this._isLoaded ? "wasm" : null;
+  }
+  get sampleRate() {
+    return this.config.sampleRate;
+  }
+  get threshold() {
+    return this.config.threshold;
+  }
+  getChunkSize() {
+    return this.chunkSize;
+  }
+  getChunkDurationMs() {
+    return this.chunkSize / this.config.sampleRate * 1e3;
+  }
+  async load() {
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("SileroVADUnifiedAdapter.load", {
+      "model.url": this.config.modelUrl
+    });
+    try {
+      const result = await this.worker.loadVAD({
+        modelUrl: this.config.modelUrl,
+        sampleRate: this.config.sampleRate
+      });
+      this._isLoaded = true;
+      logger6.info("SileroVAD loaded via unified worker", {
+        backend: "wasm",
+        loadTimeMs: Math.round(result.loadTimeMs),
+        sampleRate: this.config.sampleRate,
+        chunkSize: this.chunkSize
+      });
+      span?.setAttributes({ "model.backend": "wasm", "model.load_time_ms": result.loadTimeMs });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+        model: "silero-vad-unified",
+        backend: "wasm"
+      });
+      return result;
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  async process(audioChunk) {
+    if (!this._isLoaded) throw new Error("Model not loaded. Call load() first.");
+    if (audioChunk.length !== this.chunkSize) {
+      throw new Error(
+        `Audio chunk must be exactly ${this.chunkSize} samples (got ${audioChunk.length}). Use getChunkSize() to get required size.`
+      );
+    }
+    const audioChunkCopy = new Float32Array(audioChunk);
+    return new Promise((resolve, reject) => {
+      this.inferenceQueue = this.inferenceQueue.then(async () => {
+        try {
+          const startTime = performance.now();
+          const result = await this.worker.processVAD(audioChunkCopy, this.state, this.context);
+          this.state = result.state;
+          this.context = audioChunkCopy.slice(-this.contextSize);
+          const inferenceTimeMs = performance.now() - startTime;
+          const isSpeech = result.probability > this.config.threshold;
+          let preSpeechChunks;
+          if (isSpeech && !this.wasSpeaking) {
+            preSpeechChunks = [...this.preSpeechBuffer];
+            this.preSpeechBuffer = [];
+          } else if (!isSpeech && !this.wasSpeaking) {
+            this.preSpeechBuffer.push(new Float32Array(audioChunkCopy));
+            if (this.preSpeechBuffer.length > this.config.preSpeechBufferChunks) {
+              this.preSpeechBuffer.shift();
+            }
+          } else if (!isSpeech && this.wasSpeaking) {
+            this.preSpeechBuffer = [];
+          }
+          this.wasSpeaking = isSpeech;
+          resolve({
+            probability: result.probability,
+            isSpeech,
+            inferenceTimeMs,
+            preSpeechChunks
+          });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+  }
+  async reset() {
+    if (!this._isLoaded) throw new Error("Model not loaded. Call load() first.");
+    const newState = await this.worker.resetVAD();
+    this.state = newState;
+    this.context = new Float32Array(this.contextSize);
+    this.preSpeechBuffer = [];
+    this.wasSpeaking = false;
+  }
+  async dispose() {
+    if (this._isLoaded) {
+      await this.worker.disposeVAD();
+      this._isLoaded = false;
+    }
+    this.state = new Float32Array(2 * 1 * 128);
+    this.context = new Float32Array(this.contextSize);
+    this.preSpeechBuffer = [];
+    this.wasSpeaking = false;
+  }
+};
+
+// src/inference/createSenseVoice.ts
+var logger7 = createLogger("createSenseVoice");
+function createSenseVoice(config) {
+  if (config.unifiedWorker) {
+    logger7.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
+    return new SenseVoiceUnifiedAdapter(config.unifiedWorker, {
+      modelUrl: config.modelUrl,
+      tokensUrl: config.tokensUrl,
+      language: config.language,
+      textNorm: config.textNorm
+    });
+  }
+  const useWorker = config.useWorker ?? "auto";
+  if (useWorker === true) {
+    if (!SenseVoiceWorker.isSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    logger7.info("Creating SenseVoiceWorker (off-main-thread)");
+    return new SenseVoiceWorker({
+      modelUrl: config.modelUrl,
+      tokensUrl: config.tokensUrl,
+      language: config.language,
+      textNorm: config.textNorm
+    });
+  }
+  if (useWorker === false) {
+    logger7.info("Creating SenseVoiceInference (main thread)");
+    return new SenseVoiceInference({
+      modelUrl: config.modelUrl,
+      tokensUrl: config.tokensUrl,
+      language: config.language,
+      textNorm: config.textNorm
+    });
+  }
+  if (SenseVoiceWorker.isSupported() && !isIOS()) {
+    logger7.info("Auto-detected: creating SenseVoiceWorker (off-main-thread)");
+    return new SenseVoiceWorker({
+      modelUrl: config.modelUrl,
+      tokensUrl: config.tokensUrl,
+      language: config.language,
+      textNorm: config.textNorm
+    });
+  }
+  logger7.info("Auto-detected: creating SenseVoiceInference (main thread)", {
+    reason: isIOS() ? "iOS (shared ORT instance)" : "Worker unsupported"
+  });
+  return new SenseVoiceInference({
+    modelUrl: config.modelUrl,
+    tokensUrl: config.tokensUrl,
+    language: config.language,
+    textNorm: config.textNorm
+  });
+}
+
+// src/inference/Wav2ArkitCpuInference.ts
+var logger8 = createLogger("Wav2ArkitCpu");
+var _Wav2ArkitCpuInference = class _Wav2ArkitCpuInference {
+  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();
+    // Session health: set to true if session.run() times out.
+    // A timed-out session may have a zombie WASM dispatch still running,
+    // so all future infer() calls reject immediately to prevent concurrent access.
+    this.poisoned = false;
+    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";
+      logger8.info("Loading ONNX Runtime...", { preference });
+      const { ort, backend } = await getOnnxRuntimeForPreference(preference);
+      this.ort = ort;
+      this._backend = backend;
+      logger8.info("ONNX Runtime loaded", { backend: this._backend });
+      const modelUrl = this.config.modelUrl;
+      const dataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${modelUrl}.data` : null;
+      const sessionOptions = getSessionOptions(this._backend);
+      if (isIOS()) {
+        logger8.info("iOS: passing model URLs directly to ORT (low-memory path)", {
+          modelUrl,
+          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();
+        const isCached = await cache.has(modelUrl);
+        let modelBuffer;
+        if (isCached) {
+          logger8.debug("Loading model from cache", { modelUrl });
+          modelBuffer = await cache.get(modelUrl);
+          if (!modelBuffer) {
+            logger8.warn("Cache corruption detected, clearing and retrying", { modelUrl });
+            await cache.delete(modelUrl);
+            modelBuffer = await fetchWithCache(modelUrl);
+          }
+        } else {
+          logger8.debug("Fetching and caching model graph", { modelUrl });
+          modelBuffer = await fetchWithCache(modelUrl);
+        }
+        if (!modelBuffer) {
+          throw new Error(`Failed to load model: ${modelUrl}`);
+        }
+        let externalDataBuffer = null;
+        if (dataUrl) {
+          try {
+            const isDataCached = await cache.has(dataUrl);
+            if (isDataCached) {
+              logger8.debug("Loading external data from cache", { dataUrl });
+              externalDataBuffer = await cache.get(dataUrl);
+              if (!externalDataBuffer) {
+                logger8.warn("Cache corruption for external data, retrying", { dataUrl });
+                await cache.delete(dataUrl);
+                externalDataBuffer = await fetchWithCache(dataUrl);
+              }
+            } else {
+              logger8.info("Fetching external model data", {
+                dataUrl,
+                note: "This may be a large download (400MB+)"
+              });
+              externalDataBuffer = await fetchWithCache(dataUrl);
+            }
+            logger8.info("External data loaded", {
+              size: formatBytes(externalDataBuffer.byteLength)
+            });
+          } catch (err) {
+            logger8.debug("No external data file found (single-file model)", {
+              dataUrl,
+              error: err.message
+            });
+          }
+        }
+        logger8.debug("Creating ONNX session", {
+          graphSize: formatBytes(modelBuffer.byteLength),
+          externalDataSize: externalDataBuffer ? formatBytes(externalDataBuffer.byteLength) : "none",
+          backend: this._backend
+        });
+        if (externalDataBuffer) {
+          const dataFilename = dataUrl.split("/").pop();
+          sessionOptions.externalData = [{
+            path: dataFilename,
+            data: new Uint8Array(externalDataBuffer)
+          }];
+        }
+        const modelData = new Uint8Array(modelBuffer);
+        this.session = await this.ort.InferenceSession.create(modelData, sessionOptions);
+      }
+      const loadTimeMs = performance.now() - startTime;
+      logger8.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": !isIOS()
+      });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
+        model: "wav2arkit_cpu",
+        backend: this._backend
+      });
+      logger8.debug("Running warmup inference");
+      const warmupStart = performance.now();
+      const silentAudio = new Float32Array(16e3);
+      await this.infer(silentAudio);
+      const warmupTimeMs = performance.now() - warmupStart;
+      logger8.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.");
+    }
+    if (this.poisoned) {
+      throw new Error("Wav2ArkitCpu session timed out \u2014 inference unavailable until page reload");
+    }
+    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();
+          let timeoutId;
+          const results = await Promise.race([
+            this.session.run(feeds).then((r) => {
+              clearTimeout(timeoutId);
+              return r;
+            }),
+            new Promise((_, rej) => {
+              timeoutId = setTimeout(
+                () => rej(new Error(`Wav2ArkitCpu inference timed out after ${_Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS}ms`)),
+                _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS
+              );
+            })
+          ]);
+          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 symmetrized = symmetrizeBlendshapes(rawFrame);
+            blendshapes.push(symmetrized);
+          }
+          logger8.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) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("timed out")) {
+            this.poisoned = true;
+            logger8.error("CRITICAL: Inference session timed out \u2014 Wav2ArkitCpu is dead. Page reload required.", {
+              backend: this._backend,
+              timeoutMs: _Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS
+            });
+          } else if (typeof err === "number") {
+            const oomError = new Error(
+              `Wav2ArkitCpu inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reloading the page.`
+            );
+            logger8.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+              pointer: `0x${err.toString(16)}`,
+              backend: this._backend
+            });
+            span?.endWithError(oomError);
+            telemetry?.incrementCounter("omote.inference.total", 1, {
+              model: "wav2arkit_cpu",
+              backend: this._backend,
+              status: "error"
+            });
+            reject(oomError);
+            return;
+          } else {
+            logger8.error("Inference failed", { error: errMsg, backend: this._backend });
+          }
+          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;
+    }
+  }
+};
+_Wav2ArkitCpuInference.INFERENCE_TIMEOUT_MS = 5e3;
+var Wav2ArkitCpuInference = _Wav2ArkitCpuInference;
+
+// src/inference/Wav2ArkitCpuWorker.ts
+var logger9 = createLogger("Wav2ArkitCpuWorker");
+var WASM_CDN_PATH4 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
+var LOAD_TIMEOUT_MS2 = 6e4;
+var INFERENCE_TIMEOUT_MS2 = 5e3;
+function resolveUrl3(url) {
+  if (/^https?:\/\//i.test(url) || /^blob:/i.test(url)) return url;
+  try {
+    return new URL(url, globalThis.location?.origin ?? "https://localhost").href;
+  } catch {
+    return url;
+  }
+}
+var WORKER_SCRIPT3 = `
+// Wav2ArkitCpu Worker Script
+// Loaded via Blob URL - no separate file needed
+
+var ort = null;
+var session = null;
+
+// Precomputed symmetric index pairs from LAM_BLENDSHAPES alphabetical ordering
+// Used to average left/right blendshape pairs for symmetrized output
+const SYMMETRIC_INDEX_PAIRS = [
+  [23, 25], // jawLeft, jawRight
+  [32, 38], // mouthLeft, mouthRight
+  [43, 44], // mouthSmileLeft, mouthSmileRight
+  [29, 30], // mouthFrownLeft, mouthFrownRight
+  [27, 28], // mouthDimpleLeft, mouthDimpleRight
+  [45, 46], // mouthStretchLeft, mouthStretchRight
+  [35, 36], // mouthPressLeft, mouthPressRight
+  [47, 48], // mouthUpperUpLeft, mouthUpperUpRight
+  [33, 34], // mouthLowerDownLeft, mouthLowerDownRight
+  [49, 50], // noseSneerLeft, noseSneerRight
+  [6, 7],   // cheekSquintLeft, cheekSquintRight
+  [0, 1],   // browDownLeft, browDownRight
+  [3, 4],   // browOuterUpLeft, browOuterUpRight
+  [8, 9],   // eyeBlinkLeft, eyeBlinkRight
+  [16, 17], // eyeLookUpLeft, eyeLookUpRight
+  [10, 11], // eyeLookDownLeft, eyeLookDownRight
+  [12, 13], // eyeLookInLeft, eyeLookInRight
+  [14, 15], // eyeLookOutLeft, eyeLookOutRight
+  [18, 19], // eyeSquintLeft, eyeSquintRight
+  [20, 21], // eyeWideLeft, eyeWideRight
+];
+
+/**
+ * Symmetrize blendshapes by averaging left/right pairs
+ * Inlined from blendshapeUtils.ts for worker context
+ */
+function symmetrizeBlendshapes(frame) {
+  const result = new Float32Array(frame);
+  for (const [lIdx, rIdx] of SYMMETRIC_INDEX_PAIRS) {
+    const avg = (frame[lIdx] + frame[rIdx]) / 2;
+    result[lIdx] = avg;
+    result[rIdx] = avg;
+  }
+  return result;
+}
+
+/**
+ * Load ONNX Runtime from CDN
+ */
+async function loadOrt(wasmPaths) {
+  if (ort) return;
+
+  // Import ONNX Runtime from CDN
+  const ortUrl = wasmPaths + 'ort.wasm.min.js';
+
+  // Load the script by fetching and executing it
+  const response = await fetch(ortUrl);
+  const scriptText = await response.text();
+
+  // Create a blob URL for the script
+  const blob = new Blob([scriptText], { type: 'application/javascript' });
+  const blobUrl = URL.createObjectURL(blob);
+
+  // Import the module
+  importScripts(blobUrl);
+  URL.revokeObjectURL(blobUrl);
+
+  // ort is now available as global
+  ort = self.ort;
+
+  // Configure WASM settings
+  ort.env.wasm.wasmPaths = wasmPaths;
+  ort.env.wasm.numThreads = 1; // Single thread in worker
+  ort.env.wasm.simd = true;
+  ort.env.wasm.proxy = false; // No proxy in worker
+}
+
+/**
+ * Load the wav2arkit_cpu model
+ */
+async function loadModel(modelUrl, externalDataUrl, isIOS) {
+  const sessionOptions = {
+    executionProviders: ['wasm'],
+    graphOptimizationLevel: 'all',
+  };
+
+  const dataFilename = externalDataUrl ? externalDataUrl.split('/').pop() : null;
+
+  if (isIOS) {
+    // iOS: Pass URLs directly to ORT to avoid loading 402MB into JS heap.
+    // ORT fetches externally into WASM memory, cutting peak JS memory from
+    // ~800MB to ~2MB (just the graph).
+    if (externalDataUrl && dataFilename) {
+      sessionOptions.externalData = [{ path: dataFilename, data: externalDataUrl }];
+    }
+    session = await ort.InferenceSession.create(modelUrl, sessionOptions);
+  } else {
+    // Desktop: fetch model graph as ArrayBuffer
+    const graphResponse = await fetch(modelUrl);
+    if (!graphResponse.ok) {
+      throw new Error('Failed to fetch model graph: ' + graphResponse.status + ' ' + graphResponse.statusText);
+    }
+    const graphBuffer = await graphResponse.arrayBuffer();
+
+    // Fetch external data file if present
+    if (externalDataUrl && dataFilename) {
+      const dataResponse = await fetch(externalDataUrl);
+      if (!dataResponse.ok) {
+        throw new Error('Failed to fetch external data: ' + dataResponse.status + ' ' + dataResponse.statusText);
+      }
+      const dataBuffer = await dataResponse.arrayBuffer();
+      sessionOptions.externalData = [{ path: dataFilename, data: new Uint8Array(dataBuffer) }];
+    }
+
+    session = await ort.InferenceSession.create(new Uint8Array(graphBuffer), sessionOptions);
+  }
+
+  // Warmup inference with 16000 silent samples
+  const warmupAudio = new Float32Array(16000);
+  const warmupTensor = new ort.Tensor('float32', warmupAudio, [1, warmupAudio.length]);
+  await session.run({ audio_waveform: warmupTensor });
+
+  return {
+    inputNames: session.inputNames.slice(),
+    outputNames: session.outputNames.slice(),
+  };
+}
+
+/**
+ * Run lip sync inference
+ */
+async function runInference(audio) {
+  const tensor = new ort.Tensor('float32', audio, [1, audio.length]);
+  const results = await session.run({ audio_waveform: tensor });
+
+  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];
+
+  // Symmetrize each frame and flatten into a single Float32Array for transfer
+  const flatBuffer = new Float32Array(numFrames * numBlendshapes);
+  for (let f = 0; f < numFrames; f++) {
+    const offset = f * numBlendshapes;
+    const rawFrame = blendshapeData.slice(offset, offset + numBlendshapes);
+    const symmetrized = symmetrizeBlendshapes(rawFrame);
+    flatBuffer.set(symmetrized, offset);
+  }
+
+  return { flatBuffer, numFrames, numBlendshapes };
+}
+
+// Message handler
+self.onmessage = async function(e) {
+  const msg = e.data;
+
+  try {
+    switch (msg.type) {
+      case 'load': {
+        const startTime = performance.now();
+        await loadOrt(msg.wasmPaths);
+        const { inputNames, outputNames } = await loadModel(msg.modelUrl, msg.externalDataUrl, msg.isIOS);
+        const loadTimeMs = performance.now() - startTime;
+
+        self.postMessage({
+          type: 'loaded',
+          inputNames,
+          outputNames,
+          loadTimeMs,
+        });
+        break;
+      }
+
+      case 'infer': {
+        const startTime = performance.now();
+        const { flatBuffer, numFrames, numBlendshapes } = await runInference(msg.audio);
+        const inferenceTimeMs = performance.now() - startTime;
+
+        self.postMessage({
+          type: 'result',
+          blendshapes: flatBuffer,
+          numFrames,
+          numBlendshapes,
+          inferenceTimeMs,
+        }, [flatBuffer.buffer]);
+        break;
+      }
+
+      case 'dispose': {
+        if (session) {
+          await session.release();
+          session = null;
+        }
+        ort = null;
+        self.postMessage({ type: 'disposed' });
+        break;
+      }
+
+      default:
+        self.postMessage({
+          type: 'error',
+          error: 'Unknown message type: ' + msg.type,
+        });
+    }
+  } catch (err) {
+    let errorMessage;
+    if (typeof err === 'number') {
+      // ORT WASM throws raw C++ exception pointers as bare numbers
+      errorMessage = 'ORT WASM C++ exception pointer (0x' + err.toString(16) + ') \u2014 likely OOM';
+    } else {
+      errorMessage = err.message || String(err);
+    }
+    self.postMessage({
+      type: 'error',
+      error: errorMessage,
+    });
+  }
+};
+
+// Error handler
+self.onerror = function(err) {
+  self.postMessage({
+    type: 'error',
+    error: 'Worker error: ' + (err.message || String(err)),
+  });
+};
+`;
+var Wav2ArkitCpuWorker = class {
+  constructor(config) {
+    this.modelId = "wav2arkit_cpu";
+    this.worker = null;
+    this.isLoading = false;
+    this._isLoaded = false;
+    // Inference queue for serialization
+    this.inferenceQueue = Promise.resolve();
+    // Session health: set to true if worker inference times out.
+    // A timed-out worker may have a zombie WASM dispatch still running,
+    // so all future infer() calls reject immediately to prevent concurrent access.
+    this.poisoned = false;
+    // Pending message handlers
+    this.pendingResolvers = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  /**
+   * Backend type (always 'wasm' for Worker, WebGPU not supported in Workers)
+   */
+  get backend() {
+    return this._isLoaded ? "wasm" : null;
   }
   /**
-   * Queue inference to serialize ONNX session calls
+   * Create the worker from inline script
    */
-  queueInference(feeds, inputSamples) {
+  createWorker() {
+    const blob = new Blob([WORKER_SCRIPT3], { type: "application/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    const worker = new Worker(blobUrl);
+    URL.revokeObjectURL(blobUrl);
+    worker.onmessage = (event) => {
+      this.handleWorkerMessage(event.data);
+    };
+    worker.onerror = (error) => {
+      logger9.error("Worker error", { error: error.message });
+      for (const [, resolver] of this.pendingResolvers) {
+        resolver.reject(new Error(`Worker error: ${error.message}`));
+      }
+      this.pendingResolvers.clear();
+    };
+    return worker;
+  }
+  /**
+   * Handle messages from worker
+   */
+  handleWorkerMessage(result) {
+    const resolver = this.pendingResolvers.get(result.type);
+    if (resolver) {
+      this.pendingResolvers.delete(result.type);
+      if (result.type === "error") {
+        resolver.reject(new Error(result.error));
+      } else {
+        resolver.resolve(result);
+      }
+    }
+  }
+  /**
+   * Send message to worker and wait for response
+   */
+  sendMessage(message, expectedType, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!this.worker) {
+        reject(new Error("Worker not initialized"));
+        return;
+      }
+      const timeoutId = setTimeout(() => {
+        this.pendingResolvers.delete(expectedType);
+        reject(new Error(`Worker operation timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingResolvers.set(expectedType, {
+        resolve: (value) => {
+          clearTimeout(timeoutId);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      });
+      this.pendingResolvers.set("error", {
+        resolve: () => {
+        },
+        // Never called for errors
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          this.pendingResolvers.delete(expectedType);
+          reject(error);
+        }
+      });
+      this.worker.postMessage(message);
+    });
+  }
+  /**
+   * Load the ONNX model in the worker
+   */
+  async load() {
+    if (this.isLoading) {
+      throw new Error("Model is already loading");
+    }
+    if (this._isLoaded) {
+      throw new Error("Model already loaded. Call dispose() first.");
+    }
+    this.isLoading = true;
+    const startTime = performance.now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("Wav2ArkitCpuWorker.load", {
+      "model.url": this.config.modelUrl,
+      "model.backend_requested": "wasm"
+    });
+    try {
+      logger9.info("Creating wav2arkit_cpu worker...");
+      this.worker = this.createWorker();
+      const externalDataUrl = this.config.externalDataUrl !== false ? this.config.externalDataUrl || `${this.config.modelUrl}.data` : null;
+      logger9.info("Loading model in worker...", {
+        modelUrl: this.config.modelUrl,
+        externalDataUrl,
+        isIOS: isIOS()
+      });
+      const result = await this.sendMessage(
+        {
+          type: "load",
+          modelUrl: resolveUrl3(this.config.modelUrl),
+          externalDataUrl: externalDataUrl ? resolveUrl3(externalDataUrl) : null,
+          wasmPaths: WASM_CDN_PATH4,
+          isIOS: isIOS()
+        },
+        "loaded",
+        LOAD_TIMEOUT_MS2
+      );
+      this._isLoaded = true;
+      const loadTimeMs = performance.now() - startTime;
+      logger9.info("Wav2ArkitCpu worker loaded successfully", {
+        backend: "wasm",
+        loadTimeMs: Math.round(loadTimeMs),
+        workerLoadTimeMs: Math.round(result.loadTimeMs),
+        inputs: result.inputNames,
+        outputs: result.outputNames
+      });
+      span?.setAttributes({
+        "model.backend": "wasm",
+        "model.load_time_ms": loadTimeMs,
+        "model.worker_load_time_ms": result.loadTimeMs
+      });
+      span?.end();
+      telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
+        model: "wav2arkit_cpu-worker",
+        backend: "wasm"
+      });
+      return {
+        backend: "wasm",
+        loadTimeMs,
+        inputNames: result.inputNames,
+        outputNames: result.outputNames
+      };
+    } catch (error) {
+      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      telemetry?.incrementCounter("omote.errors.total", 1, {
+        model: "wav2arkit_cpu-worker",
+        error_type: "load_failed"
+      });
+      if (this.worker) {
+        this.worker.terminate();
+        this.worker = null;
+      }
+      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._isLoaded || !this.worker) {
+      throw new Error("Model not loaded. Call load() first.");
+    }
+    if (this.poisoned) {
+      throw new Error("Wav2ArkitCpu worker session timed out \u2014 inference unavailable until page reload");
+    }
+    const audioCopy = new Float32Array(audioSamples);
+    return this.queueInference(audioCopy);
+  }
+  /**
+   * Queue inference to serialize worker calls
+   */
+  queueInference(audioSamples) {
     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
+        const span = telemetry?.startSpan("Wav2ArkitCpuWorker.infer", {
+          "inference.backend": "wasm",
+          "inference.input_samples": audioSamples.length
         });
         try {
           const startTime = performance.now();
-          const results = await this.session.run(feeds);
+          const result = await this.sendMessage(
+            {
+              type: "infer",
+              audio: audioSamples
+            },
+            "result",
+            INFERENCE_TIMEOUT_MS2
+          );
           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 flatBuffer = result.blendshapes;
+          const { numFrames, numBlendshapes } = result;
           const blendshapes = [];
           for (let f = 0; f < numFrames; f++) {
-            const rawFrame = blendshapeData.slice(f * numBlendshapes, (f + 1) * numBlendshapes);
-            const symmetrized = symmetrizeBlendshapes(rawFrame);
-            blendshapes.push(symmetrized);
+            blendshapes.push(flatBuffer.slice(f * numBlendshapes, (f + 1) * numBlendshapes));
           }
-          logger5.trace("Inference completed", {
+          logger9.trace("Worker inference completed", {
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
+            workerTimeMs: Math.round(result.inferenceTimeMs * 100) / 100,
             numFrames,
-            inputSamples
+            inputSamples: audioSamples.length
           });
           span?.setAttributes({
             "inference.duration_ms": inferenceTimeMs,
+            "inference.worker_duration_ms": result.inferenceTimeMs,
             "inference.frames": numFrames
           });
           span?.end();
           telemetry?.recordHistogram("omote.inference.latency", inferenceTimeMs, {
-            model: "wav2arkit_cpu",
-            backend: this._backend
+            model: "wav2arkit_cpu-worker",
+            backend: "wasm"
           });
           telemetry?.incrementCounter("omote.inference.total", 1, {
-            model: "wav2arkit_cpu",
-            backend: this._backend,
+            model: "wav2arkit_cpu-worker",
+            backend: "wasm",
             status: "success"
           });
           resolve({
@@ -4372,10 +7276,20 @@ var Wav2ArkitCpuInference = class {
             inferenceTimeMs
           });
         } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("timed out")) {
+            this.poisoned = true;
+            logger9.error("CRITICAL: Worker inference timed out \u2014 Wav2ArkitCpu worker is dead. Page reload required.", {
+              backend: "wasm",
+              timeoutMs: INFERENCE_TIMEOUT_MS2
+            });
+          } else {
+            logger9.error("Worker inference failed", { error: errMsg, backend: "wasm" });
+          }
           span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           telemetry?.incrementCounter("omote.inference.total", 1, {
-            model: "wav2arkit_cpu",
-            backend: this._backend,
+            model: "wav2arkit_cpu-worker",
+            backend: "wasm",
             status: "error"
           });
           reject(err);
@@ -4384,37 +7298,62 @@ var Wav2ArkitCpuInference = class {
     });
   }
   /**
-   * Dispose of the model and free resources
+   * Dispose of the worker and free resources
    */
   async dispose() {
-    if (this.session) {
-      await this.session.release();
-      this.session = null;
+    if (this.worker) {
+      try {
+        await this.sendMessage({ type: "dispose" }, "disposed", INFERENCE_TIMEOUT_MS2);
+      } catch {
+      }
+      this.worker.terminate();
+      this.worker = null;
     }
+    this._isLoaded = false;
+    this.poisoned = false;
+    this.pendingResolvers.clear();
+  }
+  /**
+   * Check if Web Workers are supported
+   */
+  static isSupported() {
+    return typeof Worker !== "undefined";
   }
 };
 
 // src/inference/createLipSync.ts
-var logger6 = createLogger("createLipSync");
+var logger10 = 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)");
+    logger10.info("Forcing CPU lip sync model (wav2arkit_cpu)");
   } else if (mode === "gpu") {
     useCpu = false;
-    logger6.info("Forcing GPU lip sync model (Wav2Vec2)");
+    logger10.info("Forcing GPU lip sync model (Wav2Vec2)");
   } else {
     useCpu = shouldUseCpuLipSync();
-    logger6.info("Auto-detected lip sync model", {
+    logger10.info("Auto-detected lip sync model", {
       useCpu,
       isSafari: isSafari()
     });
   }
   if (useCpu) {
-    logger6.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
+    if (config.unifiedWorker) {
+      logger10.info("Creating Wav2ArkitCpuUnifiedAdapter (404MB, WASM, shared unified worker)");
+      return new Wav2ArkitCpuUnifiedAdapter(config.unifiedWorker, {
+        modelUrl: config.cpuModelUrl
+      });
+    }
+    if (config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
+      logger10.info("Creating Wav2ArkitCpuWorker (404MB, WASM, off-main-thread)");
+      return new Wav2ArkitCpuWorker({
+        modelUrl: config.cpuModelUrl
+      });
+    }
+    logger10.info("Creating Wav2ArkitCpuInference (404MB, WASM)");
     return new Wav2ArkitCpuInference({
       modelUrl: config.cpuModelUrl
     });
@@ -4426,10 +7365,10 @@ function createLipSync(config) {
     numIdentityClasses: config.numIdentityClasses
   });
   if (fallbackOnError) {
-    logger6.info("Creating Wav2Vec2Inference with CPU fallback");
+    logger10.info("Creating Wav2Vec2Inference with CPU fallback");
     return new LipSyncWithFallback(gpuInstance, config);
   }
-  logger6.info("Creating Wav2Vec2Inference (no fallback)");
+  logger10.info("Creating Wav2Vec2Inference (no fallback)");
   return gpuInstance;
 }
 var LipSyncWithFallback = class {
@@ -4455,16 +7394,28 @@ var LipSyncWithFallback = class {
     }
   }
   async fallbackToCpu(reason) {
-    logger6.warn("GPU model load failed, falling back to CPU model", { reason });
+    logger10.warn("GPU model load failed, falling back to CPU model", { reason });
     try {
       await this.implementation.dispose();
     } catch {
     }
-    this.implementation = new Wav2ArkitCpuInference({
-      modelUrl: this.config.cpuModelUrl
-    });
+    if (this.config.unifiedWorker) {
+      this.implementation = new Wav2ArkitCpuUnifiedAdapter(this.config.unifiedWorker, {
+        modelUrl: this.config.cpuModelUrl
+      });
+      logger10.info("Fallback to Wav2ArkitCpuUnifiedAdapter successful");
+    } else if (this.config.useWorker && Wav2ArkitCpuWorker.isSupported() && !isIOS()) {
+      this.implementation = new Wav2ArkitCpuWorker({
+        modelUrl: this.config.cpuModelUrl
+      });
+      logger10.info("Fallback to Wav2ArkitCpuWorker successful");
+    } else {
+      this.implementation = new Wav2ArkitCpuInference({
+        modelUrl: this.config.cpuModelUrl
+      });
+      logger10.info("Fallback to Wav2ArkitCpuInference successful");
+    }
     this.hasFallenBack = true;
-    logger6.info("Fallback to Wav2ArkitCpuInference successful");
     return await this.implementation.load();
   }
   async infer(audioSamples, identityIndex) {
@@ -4476,7 +7427,7 @@ var LipSyncWithFallback = class {
 };
 
 // src/inference/SileroVADInference.ts
-var logger7 = createLogger("SileroVAD");
+var logger11 = createLogger("SileroVAD");
 var SileroVADInference = class {
   constructor(config) {
     this.session = null;
@@ -4550,23 +7501,23 @@ var SileroVADInference = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger7.info("Loading ONNX Runtime...", { preference: this.config.backend });
+      logger11.info("Loading ONNX Runtime...", { preference: this.config.backend });
       const { ort, backend } = await getOnnxRuntimeForPreference(this.config.backend);
       this.ort = ort;
       this._backend = backend;
-      logger7.info("ONNX Runtime loaded", { backend: this._backend });
+      logger11.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) {
-        logger7.debug("Loading model from cache", { modelUrl });
+        logger11.debug("Loading model from cache", { modelUrl });
         modelBuffer = await cache.get(modelUrl);
       } else {
-        logger7.debug("Fetching and caching model", { modelUrl });
+        logger11.debug("Fetching and caching model", { modelUrl });
         modelBuffer = await fetchWithCache(modelUrl);
       }
-      logger7.debug("Creating ONNX session", {
+      logger11.debug("Creating ONNX session", {
         size: formatBytes(modelBuffer.byteLength),
         backend: this._backend
       });
@@ -4575,7 +7526,7 @@ var SileroVADInference = class {
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       this.reset();
       const loadTimeMs = performance.now() - startTime;
-      logger7.info("Model loaded successfully", {
+      logger11.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
         sampleRate: this.config.sampleRate,
@@ -4630,7 +7581,7 @@ var SileroVADInference = class {
           []
         );
       } catch (e) {
-        logger7.warn("BigInt64Array not available, using bigint array fallback", {
+        logger11.warn("BigInt64Array not available, using bigint array fallback", {
           error: e instanceof Error ? e.message : String(e)
         });
         this.srTensor = new this.ort.Tensor(
@@ -4722,23 +7673,13 @@ var SileroVADInference = class {
     }
     return segments;
   }
-  /**
-   * Calculate RMS energy of audio chunk
-   */
-  calculateRMS(samples) {
-    let sum = 0;
-    for (let i = 0; i < samples.length; i++) {
-      sum += samples[i] * samples[i];
-    }
-    return Math.sqrt(sum / samples.length);
-  }
   /**
    * Queue inference to serialize ONNX session calls
    */
   queueInference(audioChunk) {
     const audioChunkCopy = new Float32Array(audioChunk);
     const MIN_ENERGY_THRESHOLD = 1e-3;
-    const rms = this.calculateRMS(audioChunkCopy);
+    const rms = calculateRMS(audioChunkCopy);
     if (rms < MIN_ENERGY_THRESHOLD) {
       if (!this.wasSpeaking) {
         this.preSpeechBuffer.push(new Float32Array(audioChunkCopy));
@@ -4746,7 +7687,7 @@ var SileroVADInference = class {
           this.preSpeechBuffer.shift();
         }
       }
-      logger7.trace("Skipping VAD inference - audio too quiet", {
+      logger11.trace("Skipping VAD inference - audio too quiet", {
         rms: Math.round(rms * 1e4) / 1e4,
         threshold: MIN_ENERGY_THRESHOLD
       });
@@ -4793,19 +7734,19 @@ var SileroVADInference = class {
               [2, 1, 128]
             );
           }
-          this.context = audioChunk.slice(-this.contextSize);
+          this.context = audioChunkCopy.slice(-this.contextSize);
           const inferenceTimeMs = performance.now() - startTime;
           const isSpeech = probability > this.config.threshold;
           let preSpeechChunks;
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger7.debug("Speech started with pre-speech buffer", {
+            logger11.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
           } else if (!isSpeech && !this.wasSpeaking) {
-            this.preSpeechBuffer.push(new Float32Array(audioChunk));
+            this.preSpeechBuffer.push(new Float32Array(audioChunkCopy));
             if (this.preSpeechBuffer.length > this.config.preSpeechBufferChunks) {
               this.preSpeechBuffer.shift();
             }
@@ -4813,7 +7754,7 @@ var SileroVADInference = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger7.trace("VAD inference completed", {
+          logger11.trace("VAD inference completed", {
             probability: Math.round(probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100
@@ -4840,13 +7781,30 @@ var SileroVADInference = class {
             preSpeechChunks
           });
         } catch (err) {
-          span?.endWithError(err instanceof Error ? err : new Error(String(err)));
-          telemetry?.incrementCounter("omote.inference.total", 1, {
-            model: "silero-vad",
-            backend: this._backend,
-            status: "error"
-          });
-          reject(err);
+          if (typeof err === "number") {
+            const oomError = new Error(
+              `SileroVAD inference failed with raw C++ exception pointer (0x${err.toString(16)}). This is likely an OOM crash in WASM. Try reducing concurrent model sessions or reloading the page.`
+            );
+            logger11.error("ORT WASM OOM \u2014 raw C++ exception pointer", {
+              pointer: `0x${err.toString(16)}`,
+              backend: this._backend
+            });
+            span?.endWithError(oomError);
+            telemetry?.incrementCounter("omote.inference.total", 1, {
+              model: "silero-vad",
+              backend: this._backend,
+              status: "error"
+            });
+            reject(oomError);
+          } else {
+            span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+            telemetry?.incrementCounter("omote.inference.total", 1, {
+              model: "silero-vad",
+              backend: this._backend,
+              status: "error"
+            });
+            reject(err);
+          }
         }
       });
     });
@@ -4870,19 +7828,27 @@ var SileroVADInference = class {
 SileroVADInference.isWebGPUAvailable = isWebGPUAvailable;
 
 // src/inference/SileroVADWorker.ts
-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;
-var WORKER_SCRIPT = `
+var logger12 = createLogger("SileroVADWorker");
+var WASM_CDN_PATH5 = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.23.2/dist/";
+var LOAD_TIMEOUT_MS3 = 1e4;
+var INFERENCE_TIMEOUT_MS3 = 1e3;
+function resolveUrl4(url) {
+  if (/^https?:\/\//i.test(url) || /^blob:/i.test(url)) return url;
+  try {
+    return new URL(url, globalThis.location?.origin ?? "https://localhost").href;
+  } catch {
+    return url;
+  }
+}
+var WORKER_SCRIPT4 = `
 // Silero VAD Worker Script
 // Loaded via Blob URL - no separate file needed
 
-let ort = null;
-let session = null;
-let sampleRate = 16000;
-let chunkSize = 512;
-let contextSize = 64;
+var ort = null;
+var session = null;
+var sampleRate = 16000;
+var chunkSize = 512;
+var contextSize = 64;
 
 /**
  * Load ONNX Runtime from CDN
@@ -5132,7 +8098,7 @@ var SileroVADWorker = class {
    * Create the worker from inline script
    */
   createWorker() {
-    const blob = new Blob([WORKER_SCRIPT], { type: "application/javascript" });
+    const blob = new Blob([WORKER_SCRIPT4], { type: "application/javascript" });
     const blobUrl = URL.createObjectURL(blob);
     const worker = new Worker(blobUrl);
     URL.revokeObjectURL(blobUrl);
@@ -5140,7 +8106,7 @@ var SileroVADWorker = class {
       this.handleWorkerMessage(event.data);
     };
     worker.onerror = (error) => {
-      logger8.error("Worker error", { error: error.message });
+      logger12.error("Worker error", { error: error.message });
       for (const [, resolver] of this.pendingResolvers) {
         resolver.reject(new Error(`Worker error: ${error.message}`));
       }
@@ -5216,25 +8182,25 @@ var SileroVADWorker = class {
       "model.sample_rate": this.config.sampleRate
     });
     try {
-      logger8.info("Creating VAD worker...");
+      logger12.info("Creating VAD worker...");
       this.worker = this.createWorker();
-      logger8.info("Loading model in worker...", {
+      logger12.info("Loading model in worker...", {
         modelUrl: this.config.modelUrl,
         sampleRate: this.config.sampleRate
       });
       const result = await this.sendMessage(
         {
           type: "load",
-          modelUrl: this.config.modelUrl,
+          modelUrl: resolveUrl4(this.config.modelUrl),
           sampleRate: this.config.sampleRate,
-          wasmPaths: WASM_CDN_PATH2
+          wasmPaths: WASM_CDN_PATH5
         },
         "loaded",
-        LOAD_TIMEOUT_MS
+        LOAD_TIMEOUT_MS3
       );
       this._isLoaded = true;
       const loadTimeMs = performance.now() - startTime;
-      logger8.info("VAD worker loaded successfully", {
+      logger12.info("VAD worker loaded successfully", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
         workerLoadTimeMs: Math.round(result.loadTimeMs),
@@ -5285,7 +8251,7 @@ var SileroVADWorker = class {
     const result = await this.sendMessage(
       { type: "reset" },
       "reset",
-      INFERENCE_TIMEOUT_MS
+      INFERENCE_TIMEOUT_MS3
     );
     this.state = result.state;
     this.context = new Float32Array(this.contextSize);
@@ -5331,7 +8297,7 @@ var SileroVADWorker = class {
               context: this.context
             },
             "result",
-            INFERENCE_TIMEOUT_MS
+            INFERENCE_TIMEOUT_MS3
           );
           this.state = result.state;
           this.context = audioChunkCopy.slice(-this.contextSize);
@@ -5341,7 +8307,7 @@ var SileroVADWorker = class {
           if (isSpeech && !this.wasSpeaking) {
             preSpeechChunks = [...this.preSpeechBuffer];
             this.preSpeechBuffer = [];
-            logger8.debug("Speech started with pre-speech buffer", {
+            logger12.debug("Speech started with pre-speech buffer", {
               preSpeechChunks: preSpeechChunks.length,
               durationMs: Math.round(preSpeechChunks.length * this.getChunkDurationMs())
             });
@@ -5354,7 +8320,7 @@ var SileroVADWorker = class {
             this.preSpeechBuffer = [];
           }
           this.wasSpeaking = isSpeech;
-          logger8.trace("VAD worker inference completed", {
+          logger12.trace("VAD worker inference completed", {
             probability: Math.round(result.probability * 1e3) / 1e3,
             isSpeech,
             inferenceTimeMs: Math.round(inferenceTimeMs * 100) / 100,
@@ -5400,7 +8366,7 @@ var SileroVADWorker = class {
   async dispose() {
     if (this.worker) {
       try {
-        await this.sendMessage({ type: "dispose" }, "disposed", INFERENCE_TIMEOUT_MS);
+        await this.sendMessage({ type: "dispose" }, "disposed", INFERENCE_TIMEOUT_MS3);
       } catch {
       }
       this.worker.terminate();
@@ -5422,40 +8388,44 @@ var SileroVADWorker = class {
 };
 
 // src/inference/createSileroVAD.ts
-var logger9 = createLogger("createSileroVAD");
+var logger13 = createLogger("createSileroVAD");
 function supportsVADWorker() {
   if (typeof Worker === "undefined") {
-    logger9.debug("Worker not supported: Worker constructor undefined");
+    logger13.debug("Worker not supported: Worker constructor undefined");
     return false;
   }
   if (typeof URL === "undefined" || typeof URL.createObjectURL === "undefined") {
-    logger9.debug("Worker not supported: URL.createObjectURL unavailable");
+    logger13.debug("Worker not supported: URL.createObjectURL unavailable");
     return false;
   }
   if (typeof Blob === "undefined") {
-    logger9.debug("Worker not supported: Blob constructor unavailable");
+    logger13.debug("Worker not supported: Blob constructor unavailable");
     return false;
   }
   return true;
 }
 function createSileroVAD(config) {
+  if (config.unifiedWorker) {
+    logger13.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
+    return new SileroVADUnifiedAdapter(config.unifiedWorker, config);
+  }
   const fallbackOnError = config.fallbackOnError ?? true;
   let useWorker;
   if (config.useWorker !== void 0) {
     useWorker = config.useWorker;
-    logger9.debug("Worker preference explicitly set", { useWorker });
+    logger13.debug("Worker preference explicitly set", { useWorker });
   } else {
     const workerSupported = supportsVADWorker();
     const onMobile = isMobile();
     useWorker = workerSupported && !onMobile;
-    logger9.debug("Auto-detected Worker preference", {
+    logger13.debug("Auto-detected Worker preference", {
       useWorker,
       workerSupported,
       onMobile
     });
   }
   if (useWorker) {
-    logger9.info("Creating SileroVADWorker (off-main-thread)");
+    logger13.info("Creating SileroVADWorker (off-main-thread)");
     const worker = new SileroVADWorker({
       modelUrl: config.modelUrl,
       sampleRate: config.sampleRate,
@@ -5467,7 +8437,7 @@ function createSileroVAD(config) {
     }
     return worker;
   }
-  logger9.info("Creating SileroVADInference (main thread)");
+  logger13.info("Creating SileroVADInference (main thread)");
   return new SileroVADInference(config);
 }
 var VADWorkerWithFallback = class {
@@ -5493,7 +8463,7 @@ var VADWorkerWithFallback = class {
     try {
       return await this.implementation.load();
     } catch (error) {
-      logger9.warn("Worker load failed, falling back to main thread", {
+      logger13.warn("Worker load failed, falling back to main thread", {
         error: error instanceof Error ? error.message : String(error)
       });
       try {
@@ -5502,7 +8472,7 @@ var VADWorkerWithFallback = class {
       }
       this.implementation = new SileroVADInference(this.config);
       this.hasFallenBack = true;
-      logger9.info("Fallback to SileroVADInference successful");
+      logger13.info("Fallback to SileroVADInference successful");
       return await this.implementation.load();
     }
   }
@@ -5524,7 +8494,7 @@ var VADWorkerWithFallback = class {
 };
 
 // src/inference/SafariSpeechRecognition.ts
-var logger10 = createLogger("SafariSpeech");
+var logger14 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {
   constructor(config = {}) {
     this.recognition = null;
@@ -5543,7 +8513,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       interimResults: config.interimResults ?? true,
       maxAlternatives: config.maxAlternatives ?? 1
     };
-    logger10.debug("SafariSpeechRecognition created", {
+    logger14.debug("SafariSpeechRecognition created", {
       language: this.config.language,
       continuous: this.config.continuous
     });
@@ -5604,7 +8574,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger10.warn("Already listening");
+      logger14.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -5634,7 +8604,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = true;
       this.startTime = performance.now();
       this.accumulatedText = "";
-      logger10.info("Speech recognition started", {
+      logger14.info("Speech recognition started", {
         language: this.config.language
       });
       span?.end();
@@ -5649,7 +8619,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async stop() {
     if (!this.isListening || !this.recognition) {
-      logger10.warn("Not currently listening");
+      logger14.warn("Not currently listening");
       return {
         text: this.accumulatedText,
         language: this.config.language,
@@ -5678,7 +8648,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     if (this.recognition && this.isListening) {
       this.recognition.abort();
       this.isListening = false;
-      logger10.info("Speech recognition aborted");
+      logger14.info("Speech recognition aborted");
     }
   }
   /**
@@ -5709,7 +8679,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     this.isListening = false;
     this.resultCallbacks = [];
     this.errorCallbacks = [];
-    logger10.debug("SafariSpeechRecognition disposed");
+    logger14.debug("SafariSpeechRecognition disposed");
   }
   /**
    * Set up event handlers for the recognition instance
@@ -5737,7 +8707,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
               confidence: alternative.confidence
             };
             this.emitResult(speechResult);
-            logger10.trace("Speech result", {
+            logger14.trace("Speech result", {
               text: text.substring(0, 50),
               isFinal,
               confidence: alternative.confidence
@@ -5747,12 +8717,12 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
         span?.end();
       } catch (error) {
         span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-        logger10.error("Error processing speech result", { error });
+        logger14.error("Error processing speech result", { error });
       }
     };
     this.recognition.onerror = (event) => {
       const error = new Error(`Speech recognition error: ${event.error} - ${event.message}`);
-      logger10.error("Speech recognition error", { error: event.error, message: event.message });
+      logger14.error("Speech recognition error", { error: event.error, message: event.message });
       this.emitError(error);
       if (this.stopRejecter) {
         this.stopRejecter(error);
@@ -5762,7 +8732,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     };
     this.recognition.onend = () => {
       this.isListening = false;
-      logger10.info("Speech recognition ended", {
+      logger14.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
         durationMs: performance.now() - this.startTime
       });
@@ -5779,13 +8749,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       }
     };
     this.recognition.onstart = () => {
-      logger10.debug("Speech recognition started by browser");
+      logger14.debug("Speech recognition started by browser");
     };
     this.recognition.onspeechstart = () => {
-      logger10.debug("Speech detected");
+      logger14.debug("Speech detected");
     };
     this.recognition.onspeechend = () => {
-      logger10.debug("Speech ended");
+      logger14.debug("Speech ended");
     };
   }
   /**
@@ -5796,7 +8766,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger10.error("Error in result callback", { error });
+        logger14.error("Error in result callback", { error });
       }
     }
   }
@@ -5808,7 +8778,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(error);
       } catch (callbackError) {
-        logger10.error("Error in error callback", { error: callbackError });
+        logger14.error("Error in error callback", { error: callbackError });
       }
     }
   }
@@ -6073,7 +9043,7 @@ var AgentCoreAdapter = class extends EventEmitter {
         console.error("[AgentCore] VAD error during interruption detection:", error);
       });
     }
-    const float32 = audio instanceof Float32Array ? audio : this.int16ToFloat32(audio);
+    const float32 = audio instanceof Float32Array ? audio : int16ToFloat32(audio);
     this.audioBuffer.push(float32);
     this.scheduleTranscription();
   }
@@ -6405,7 +9375,7 @@ var AgentCoreAdapter = class extends EventEmitter {
    * Falls back to simple RMS if VAD not available
    */
   async detectVoiceActivity(audio) {
-    const float32 = audio instanceof Float32Array ? audio : this.int16ToFloat32(audio);
+    const float32 = audio instanceof Float32Array ? audio : int16ToFloat32(audio);
     if (this.vad) {
       const chunkSize = this.vad.getChunkSize();
       for (let i = 0; i + chunkSize <= float32.length; i += chunkSize) {
@@ -6424,13 +9394,6 @@ var AgentCoreAdapter = class extends EventEmitter {
     const rms = Math.sqrt(sum / float32.length);
     return rms > 0.02;
   }
-  int16ToFloat32(int16) {
-    const float32 = new Float32Array(int16.length);
-    for (let i = 0; i < int16.length; i++) {
-      float32[i] = int16[i] / 32768;
-    }
-    return float32;
-  }
   base64ToArrayBuffer(base64) {
     const binaryString = atob(base64);
     const bytes = new Uint8Array(binaryString.length);
@@ -8277,13 +11240,19 @@ export {
   RingBuffer,
   SafariSpeechRecognition,
   SenseVoiceInference,
+  SenseVoiceUnifiedAdapter,
+  SenseVoiceWorker,
   SileroVADInference,
+  SileroVADUnifiedAdapter,
   SileroVADWorker,
   SyncedAudioPipeline,
   TenantManager,
   UPPER_FACE_BLENDSHAPES,
+  UnifiedInferenceWorker,
   WAV2ARKIT_BLENDSHAPES,
   Wav2ArkitCpuInference,
+  Wav2ArkitCpuUnifiedAdapter,
+  Wav2ArkitCpuWorker,
   Wav2Vec2Inference,
   applyCMVN,
   applyLFR,
@@ -8297,6 +11266,7 @@ export {
   createEmotionVector,
   createLipSync,
   createLogger,
+  createSenseVoice,
   createSessionWithFallback,
   createSileroVAD,
   ctcGreedyDecode,