@omote/core 0.9.1 → 0.9.3

package/dist/index.mjs

@@ -4,19 +4,22 @@ import {
 import {
   ConsoleExporter,
   DEFAULT_LOGGING_CONFIG,
+  ErrorCodes,
   LOG_LEVEL_PRIORITY,
   OTLPExporter,
   OmoteTelemetry,
+  configureClock,
   configureLogging,
   configureTelemetry,
   createLogger,
+  getClock,
   getLoggingConfig,
   getTelemetry,
   noopLogger,
   resetLoggingConfig,
   setLogLevel,
   setLoggingEnabled
-} from "./chunk-3NDJA3I4.mjs";
+} from "./chunk-X5OTUOE6.mjs";
 
 // src/audio/audioConvert.ts
 function float32ToPcm16(samples) {
@@ -168,7 +171,7 @@ var MicrophoneCapture = class {
           const pcm = this.floatToPCM16(chunk);
           this.events.emit("audio.chunk", {
             pcm,
-            timestamp: performance.now()
+            timestamp: getClock().now()
           });
           chunkCount++;
         }
@@ -399,11 +402,23 @@ var AudioScheduler = class {
     source.connect(gainNode);
     const scheduleTime = this.nextPlayTime;
     if (scheduleTime < ctx.currentTime) {
-      logger2.warn("Audio gap detected", {
-        scheduleTime,
-        currentTime: ctx.currentTime,
-        gapSec: ctx.currentTime - scheduleTime
-      });
+      const gap = ctx.currentTime - scheduleTime;
+      const gapMs = gap * 1e3;
+      if (gap > 0.5) {
+        logger2.error("Critical audio scheduling gap", {
+          code: ErrorCodes.AUD_SCHEDULE_GAP,
+          scheduleTime,
+          currentTime: ctx.currentTime,
+          gapMs: Math.round(gapMs)
+        });
+        this.options.onError?.(new Error(`Audio scheduling gap: ${gap.toFixed(3)}s`));
+      } else {
+        logger2.warn("Audio gap detected", {
+          scheduleTime,
+          currentTime: ctx.currentTime,
+          gapMs: Math.round(gapMs)
+        });
+      }
     }
     source.start(scheduleTime);
     const entry = { source, gainNode };
@@ -597,8 +612,8 @@ var AudioChunkCoalescer = class {
 var logger4 = createLogger("A2EProcessor");
 var FRAME_RATE = 30;
 var DRIP_INTERVAL_MS = 33;
-var HOLD_DURATION_MS = 100;
-var DECAY_DURATION_MS = 200;
+var HOLD_DURATION_MS = 400;
+var DECAY_DURATION_MS = 300;
 var _A2EProcessor = class _A2EProcessor {
   constructor(config) {
     this.writeOffset = 0;
@@ -762,7 +777,7 @@ var _A2EProcessor = class _A2EProcessor {
     if (this.timestampedQueue.length > 0 && this.timestampedQueue[0].timestamp <= currentTime) {
       const { frame } = this.timestampedQueue.shift();
       this.lastPulledFrame = frame;
-      this.lastDequeuedTime = performance.now();
+      this.lastDequeuedTime = getClock().now();
       return frame;
     }
     if (this.timestampedQueue.length > 0 && this.getFrameCallCount % 60 === 0) {
@@ -774,7 +789,7 @@ var _A2EProcessor = class _A2EProcessor {
       });
     }
     if (this.lastPulledFrame) {
-      const elapsed = performance.now() - this.lastDequeuedTime;
+      const elapsed = getClock().now() - this.lastDequeuedTime;
       if (elapsed < HOLD_DURATION_MS) {
         return this.lastPulledFrame;
       }
@@ -859,9 +874,9 @@ var _A2EProcessor = class _A2EProcessor {
       while (this.pendingChunks.length > 0 && !this.disposed) {
         const { chunk, timestamp } = this.pendingChunks.shift();
         try {
-          const t0 = performance.now();
+          const t0 = getClock().now();
           const result = await this.backend.infer(chunk, this.identityIndex);
-          const inferMs = Math.round(performance.now() - t0);
+          const inferMs = Math.round(getClock().now() - t0);
           const actualDuration = chunk.length / this.sampleRate;
           const actualFrameCount = Math.ceil(actualDuration * FRAME_RATE);
           const framesToQueue = Math.min(actualFrameCount, result.blendshapes.length);
@@ -900,7 +915,11 @@ var _A2EProcessor = class _A2EProcessor {
   }
   handleError(err) {
     const error = err instanceof Error ? err : new Error(String(err));
-    logger4.warn("A2EProcessor inference error", { error: error.message });
+    const isOOM = typeof err === "number" || error.message && /out of memory|oom|alloc/i.test(error.message);
+    logger4.warn("A2EProcessor inference error", {
+      error: error.message,
+      code: isOOM ? ErrorCodes.INF_OOM : ErrorCodes.INF_SESSION_POISON
+    });
     this.onError?.(error);
   }
 };
@@ -922,6 +941,12 @@ var MetricNames = {
   CACHE_HITS: "omote.cache.hits",
   /** Counter: Cache misses */
   CACHE_MISSES: "omote.cache.misses",
+  /** Counter: Cache stale (version/etag mismatch) */
+  CACHE_STALE: "omote.cache.stale",
+  /** Counter: Cache quota warning (>90% used) */
+  CACHE_QUOTA_WARNING: "omote.cache.quota_warning",
+  /** Counter: Cache eviction (LRU) */
+  CACHE_EVICTION: "omote.cache.eviction",
   // --- Pipeline ---
   /** Histogram: VoicePipeline turn latency (speech end → transcript ready, excludes playback) */
   VOICE_TURN_LATENCY: "omote.voice.turn.latency",
@@ -1221,14 +1246,14 @@ var PlaybackPipeline = class extends EventEmitter {
     this._currentRawFrame = null;
     this.cancelNeutralTransition();
     this.scheduler.warmup();
-    this.sessionStartTime = performance.now();
+    this.sessionStartTime = getClock().now();
     this.startFrameLoop();
     this.startMonitoring();
     this.setState("playing");
   }
   /** Feed a streaming audio chunk (PCM16 Uint8Array) */
   async onAudioChunk(chunk) {
-    const chunkStart = performance.now();
+    const chunkStart = getClock().now();
     const combined = this.coalescer.add(chunk);
     if (!combined) return;
     const float32 = pcm16ToFloat32(combined);
@@ -1238,7 +1263,7 @@ var PlaybackPipeline = class extends EventEmitter {
       this.emit("playback:start", { time: scheduleTime });
     }
     this.processor.pushAudio(float32, scheduleTime);
-    getTelemetry()?.recordHistogram(MetricNames.PLAYBACK_CHUNK_LATENCY, performance.now() - chunkStart);
+    getTelemetry()?.recordHistogram(MetricNames.PLAYBACK_CHUNK_LATENCY, getClock().now() - chunkStart);
   }
   /** Signal end of audio stream (flushes remaining audio) */
   async end() {
@@ -1341,15 +1366,15 @@ var PlaybackPipeline = class extends EventEmitter {
       const currentTime = this.scheduler.getCurrentTime();
       const lamFrame = this.processor.getFrameForTime(currentTime);
       if (lamFrame && lamFrame !== this.lastKnownLamFrame) {
-        this.lastNewFrameTime = performance.now();
+        this.lastNewFrameTime = getClock().now();
         this.lastKnownLamFrame = lamFrame;
         this.staleWarningEmitted = false;
       }
-      if (this.playbackStarted && this.lastNewFrameTime > 0 && performance.now() - this.lastNewFrameTime > this.staleThresholdMs) {
+      if (this.playbackStarted && this.lastNewFrameTime > 0 && getClock().now() - this.lastNewFrameTime > this.staleThresholdMs) {
         if (!this.staleWarningEmitted) {
           this.staleWarningEmitted = true;
           logger5.warn("A2E stalled \u2014 no new inference frames", {
-            staleDurationMs: Math.round(performance.now() - this.lastNewFrameTime),
+            staleDurationMs: Math.round(getClock().now() - this.lastNewFrameTime),
             queuedFrames: this.processor.queuedFrameCount
           });
         }
@@ -1389,7 +1414,7 @@ var PlaybackPipeline = class extends EventEmitter {
     if (this.sessionStartTime > 0) {
       getTelemetry()?.recordHistogram(
         MetricNames.PLAYBACK_SESSION_DURATION,
-        performance.now() - this.sessionStartTime
+        getClock().now() - this.sessionStartTime
       );
     }
     this.stopInternal();
@@ -1407,9 +1432,9 @@ var PlaybackPipeline = class extends EventEmitter {
   // ---------------------------------------------------------------------------
   startNeutralTransition(fromFrame) {
     this.neutralTransitionFrame = new Float32Array(fromFrame);
-    this.neutralTransitionStart = performance.now();
+    this.neutralTransitionStart = getClock().now();
     const animate = () => {
-      const elapsed = performance.now() - this.neutralTransitionStart;
+      const elapsed = getClock().now() - this.neutralTransitionStart;
       const t = Math.min(1, elapsed / this.neutralTransitionMs);
       const eased = 1 - Math.pow(1 - t, 3);
       logger5.trace("neutral transition", { t: Math.round(t * 1e3) / 1e3, eased: Math.round(eased * 1e3) / 1e3 });
@@ -1422,7 +1447,7 @@ var PlaybackPipeline = class extends EventEmitter {
         blendshapes,
         rawBlendshapes: blendshapes,
         // raw = scaled during transition
-        timestamp: performance.now() / 1e3,
+        timestamp: getClock().now() / 1e3,
         emotion: this._emotion ?? void 0
       };
       this.emit("frame", frame);
@@ -1653,7 +1678,7 @@ var ModelCache = class {
         logger7.warn("Failed to request persistent storage", { error: String(err) });
       }
     }
-    const dbOpenStart = performance.now();
+    const dbOpenStart = getClock().now();
     this.dbPromise = new Promise((resolve, reject) => {
       const request = indexedDB.open(DB_NAME, DB_VERSION);
       request.onerror = () => {
@@ -1662,7 +1687,7 @@ var ModelCache = class {
       };
       request.onsuccess = () => {
         this.db = request.result;
-        logger7.debug("IndexedDB opened", { durationMs: Math.round(performance.now() - dbOpenStart) });
+        logger7.debug("IndexedDB opened", { durationMs: Math.round(getClock().now() - dbOpenStart) });
         resolve(this.db);
       };
       request.onupgradeneeded = (event) => {
@@ -1736,16 +1761,16 @@ var ModelCache = class {
           }
           span?.end();
           if (hit) {
-            telemetry?.incrementCounter("omote.cache.hits", 1, {});
+            telemetry?.incrementCounter(MetricNames.CACHE_HITS, 1, {});
           } else {
-            telemetry?.incrementCounter("omote.cache.misses", 1, {});
+            telemetry?.incrementCounter(MetricNames.CACHE_MISSES, 1, {});
           }
           resolve(cached?.data ?? null);
         };
         request.onerror = () => {
           span?.setAttributes({ "cache.hit": false });
           span?.end();
-          telemetry?.incrementCounter("omote.cache.misses", 1, {});
+          telemetry?.incrementCounter(MetricNames.CACHE_MISSES, 1, {});
           resolve(null);
         };
       });
@@ -1789,14 +1814,14 @@ var ModelCache = class {
       if (!cached?.data) {
         span?.setAttributes({ "cache.hit": false });
         span?.end();
-        telemetry?.incrementCounter("omote.cache.misses", 1, {});
+        telemetry?.incrementCounter(MetricNames.CACHE_MISSES, 1, {});
         return { data: null, stale: false };
       }
       span?.setAttributes({ "cache.hit": true, "cache.size_bytes": cached.size });
       if (!cached.etag) {
         span?.setAttributes({ "cache.validated": false, "cache.stale": false });
         span?.end();
-        telemetry?.incrementCounter("omote.cache.hits", 1, {});
+        telemetry?.incrementCounter(MetricNames.CACHE_HITS, 1, {});
         return { data: cached.data, stale: false };
       }
       const fetchUrl = originalUrl || url;
@@ -1805,7 +1830,7 @@ var ModelCache = class {
         if (!response.ok) {
           span?.setAttributes({ "cache.validated": false, "cache.stale": false });
           span?.end();
-          telemetry?.incrementCounter("omote.cache.hits", 1, {});
+          telemetry?.incrementCounter(MetricNames.CACHE_HITS, 1, {});
           return { data: cached.data, stale: false };
         }
         const serverEtag = response.headers.get("etag");
@@ -1818,17 +1843,17 @@ var ModelCache = class {
         });
         span?.end();
         if (isStale) {
-          telemetry?.incrementCounter("omote.cache.stale", 1, {});
+          telemetry?.incrementCounter(MetricNames.CACHE_STALE, 1, {});
           logger7.debug("Stale cache detected", { url });
         } else {
-          telemetry?.incrementCounter("omote.cache.hits", 1, {});
+          telemetry?.incrementCounter(MetricNames.CACHE_HITS, 1, {});
         }
         return { data: cached.data, stale: isStale };
       } catch (fetchError) {
         logger7.warn("HEAD validation failed, using cached data", { error: String(fetchError) });
         span?.setAttributes({ "cache.validated": false, "cache.stale": false });
         span?.end();
-        telemetry?.incrementCounter("omote.cache.hits", 1, {});
+        telemetry?.incrementCounter(MetricNames.CACHE_HITS, 1, {});
         return { data: cached.data, stale: false };
       }
     } catch {
@@ -1909,7 +1934,7 @@ var ModelCache = class {
     const telemetry = getTelemetry();
     if (quota.percentUsed > 90) {
       logger7.warn("Storage quota warning", { percentUsed: quota.percentUsed.toFixed(1), used: formatBytes(quota.usedBytes), quota: formatBytes(quota.quotaBytes) });
-      telemetry?.incrementCounter("omote.cache.quota_warning", 1, {
+      telemetry?.incrementCounter(MetricNames.CACHE_QUOTA_WARNING, 1, {
         percent_used: String(Math.round(quota.percentUsed))
       });
       if (config.onQuotaWarning) {
@@ -2051,7 +2076,7 @@ var ModelCache = class {
       });
       span?.end();
       if (freedBytes > 0) {
-        telemetry?.incrementCounter("omote.cache.eviction", evictedUrls.length, {
+        telemetry?.incrementCounter(MetricNames.CACHE_EVICTION, evictedUrls.length, {
           bytes_freed: String(freedBytes)
         });
       }
@@ -2571,7 +2596,7 @@ var _A2EInference = class _A2EInference {
       throw new Error("Model already loaded. Call dispose() first.");
     }
     this.isLoading = true;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     const telemetry = getTelemetry();
     const span = telemetry?.startSpan("A2EInference.load", {
       "model.url": this.config.modelUrl,
@@ -2667,7 +2692,7 @@ var _A2EInference = class _A2EInference {
         executionProvider: this._backend,
         backend: this._backend
       });
-      const loadTimeMs = performance.now() - startTime;
+      const loadTimeMs = getClock().now() - startTime;
       logger10.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
@@ -2686,7 +2711,7 @@ var _A2EInference = class _A2EInference {
       });
       await new Promise((r) => setTimeout(r, 0));
       logger10.debug("Running warmup inference to initialize GPU context");
-      const warmupStart = performance.now();
+      const warmupStart = getClock().now();
       const warmupAudio = new Float32Array(this.chunkSize);
       const warmupIdentity = new Float32Array(this.numIdentityClasses);
       warmupIdentity[0] = 1;
@@ -2699,7 +2724,7 @@ var _A2EInference = class _A2EInference {
         this.session.run(warmupFeeds).then(() => "ok"),
         new Promise((r) => setTimeout(() => r("timeout"), WARMUP_TIMEOUT_MS))
       ]);
-      const warmupTimeMs = performance.now() - warmupStart;
+      const warmupTimeMs = getClock().now() - warmupStart;
       if (warmupResult === "timeout") {
         logger10.warn("Warmup inference timed out \u2014 GPU may be unresponsive. Continuing without warmup.", {
           timeoutMs: WARMUP_TIMEOUT_MS,
@@ -2779,7 +2804,7 @@ var _A2EInference = class _A2EInference {
           "inference.input_samples": this.chunkSize
         });
         try {
-          const startTime = performance.now();
+          const startTime = getClock().now();
           let timeoutId;
           const results = await Promise.race([
             this.session.run(feeds).then((r) => {
@@ -2793,7 +2818,7 @@ var _A2EInference = class _A2EInference {
               );
             })
           ]);
-          const inferenceTimeMs = performance.now() - startTime;
+          const inferenceTimeMs = getClock().now() - startTime;
           const blendshapeOutput = results["blendshapes"];
           if (!blendshapeOutput) {
             throw new Error("Missing blendshapes output from model");
@@ -3200,9 +3225,9 @@ var A2EUnifiedAdapter = class {
           "inference.input_samples": audio.length
         });
         try {
-          const startTime = performance.now();
+          const startTime = getClock().now();
           const result = await this.worker.inferLAM(audio, identityIndex);
-          const inferenceTimeMs = performance.now() - startTime;
+          const inferenceTimeMs = getClock().now() - startTime;
           const flatBuffer = result.blendshapes;
           const { numFrames, numBlendshapes } = result;
           const blendshapes = [];
@@ -3853,7 +3878,7 @@ var KokoroTTSInference = class {
       throw new Error("KokoroTTS is already loading");
     }
     this.isLoading = true;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     try {
       const backendPref = this.config.backend ?? "wasm";
       const ortResult = await getOnnxRuntimeForPreference(backendPref);
@@ -3877,7 +3902,7 @@ var KokoroTTSInference = class {
           "KokoroTTS InferenceSession.create"
         );
       }
-      const loadTimeMs = performance.now() - startTime;
+      const loadTimeMs = getClock().now() - startTime;
       logger17.info("Kokoro TTS loaded", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
@@ -3964,7 +3989,18 @@ var KokoroTTSInference = class {
         logger17.debug("stream aborted");
         return;
       }
-      const phonemes = await phonemize(sentence, language);
+      let phonemes;
+      try {
+        phonemes = await phonemize(sentence, language);
+      } catch (phonErr) {
+        logger17.error("Phonemizer failed (possible OOM)", {
+          code: ErrorCodes.TTS_PHONEMIZER_OOM,
+          error: String(phonErr),
+          textLength: sentence.length
+        });
+        yield { audio: new Float32Array(0), text: sentence, phonemes: "", duration: 0 };
+        continue;
+      }
       const tokens = tokenize(phonemes);
       const voiceData = await this.ensureVoice(voiceName);
       const style = getStyleForTokenCount(voiceData, tokens.length);
@@ -4024,16 +4060,27 @@ var KokoroTTSInference = class {
           "tts.speed": speed
         });
         try {
-          const startTime = performance.now();
+          const startTime = getClock().now();
           const language = getVoiceLanguage(voiceName);
-          const phonemes = await phonemize(text, language);
+          let phonemes;
+          try {
+            phonemes = await phonemize(text, language);
+          } catch (phonErr) {
+            logger17.error("Phonemizer failed (possible OOM)", {
+              code: ErrorCodes.TTS_PHONEMIZER_OOM,
+              error: String(phonErr),
+              textLength: text.length
+            });
+            resolve({ audio: new Float32Array(0), duration: 0, inferenceTimeMs: 0 });
+            return;
+          }
           logger17.trace("Phonemized", { text: text.substring(0, 50), phonemes: phonemes.substring(0, 50) });
           const tokens = tokenize(phonemes);
           logger17.trace("Tokenized", { numTokens: tokens.length });
           const voiceData = await this.ensureVoice(voiceName);
           const style = getStyleForTokenCount(voiceData, tokens.length);
           const audio = await this.runInference(tokens, style, speed);
-          const inferenceTimeMs = performance.now() - startTime;
+          const inferenceTimeMs = getClock().now() - startTime;
           const duration = audio.length / SAMPLE_RATE;
           logger17.trace("Synthesis complete", {
             duration: `${duration.toFixed(2)}s`,
@@ -4152,11 +4199,11 @@ var KokoroTTSUnifiedAdapter = class {
       "model.url": this.modelUrl
     });
     try {
-      const startTime = performance.now();
+      const startTime = getClock().now();
       await this.worker.loadKokoro({ modelUrl: this.modelUrl });
       this._isLoaded = true;
       this.loadedGeneration = this.worker.workerGeneration;
-      const loadTimeMs = performance.now() - startTime;
+      const loadTimeMs = getClock().now() - startTime;
       logger18.info("Kokoro TTS loaded via unified worker", {
         backend: "wasm",
         loadTimeMs: Math.round(loadTimeMs),
@@ -4231,11 +4278,11 @@ var KokoroTTSUnifiedAdapter = class {
   runWorkerInference(tokens, style, speed) {
     return new Promise((resolve, reject) => {
       this.inferenceQueue = this.inferenceQueue.then(async () => {
-        const startTime = performance.now();
+        const startTime = getClock().now();
         const telemetry = getTelemetry();
         try {
           const result = await this.worker.inferKokoro(tokens, style, speed);
-          const latencyMs = performance.now() - startTime;
+          const latencyMs = getClock().now() - startTime;
           telemetry?.recordHistogram("omote.inference.latency", latencyMs, {
             model: "kokoro-tts-unified",
             backend: "wasm"
@@ -4350,11 +4397,11 @@ var SileroVADUnifiedAdapter = class {
     return new Promise((resolve, reject) => {
       this.inferenceQueue = this.inferenceQueue.then(async () => {
         try {
-          const startTime = performance.now();
+          const startTime = getClock().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 inferenceTimeMs = getClock().now() - startTime;
           const isSpeech = result.probability > this.config.threshold;
           let preSpeechChunks;
           if (isSpeech && !this.wasSpeaking) {
@@ -4412,17 +4459,20 @@ var SileroVADUnifiedAdapter = class {
 var logger20 = createLogger("createA2E");
 function createA2E(config = {}) {
   const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.lam;
+  const platformInfo = {
+    modelUrl,
+    isIOS: isIOS(),
+    webgpu: typeof navigator !== "undefined" && "gpu" in navigator
+  };
   if (config.unifiedWorker) {
-    logger20.info("Creating A2EUnifiedAdapter (via unified worker)", {
-      modelUrl
-    });
+    logger20.info("Creating A2EUnifiedAdapter (via unified worker)", platformInfo);
     return new A2EUnifiedAdapter(config.unifiedWorker, {
       modelUrl,
       externalDataUrl: config.externalDataUrl,
       numIdentityClasses: config.numIdentityClasses
     });
   }
-  logger20.info("Creating A2EInference", { modelUrl });
+  logger20.info("Creating A2EInference", platformInfo);
   return new A2EInference({
     modelUrl,
     externalDataUrl: config.externalDataUrl,
@@ -4798,16 +4848,28 @@ async function loadOrt(wasmPaths, isIOSDevice) {
   // ort.webgpu.min.js crashes WebKit's JIT compiler.
   var isSafariWorker = typeof navigator !== 'undefined' && /safari/i.test(navigator.userAgent) && !/chrome|crios|fxios|chromium|edg/i.test(navigator.userAgent);
   var hasWebGPU = false;
-  if (!isIOSDevice && !isSafariWorker && typeof navigator !== 'undefined' && navigator.gpu) {
+  var webgpuReason = '';
+  if (isIOSDevice) {
+    webgpuReason = 'iOS device';
+  } else if (isSafariWorker) {
+    webgpuReason = 'Safari (JSEP/ASYNCIFY crash)';
+  } else if (typeof navigator === 'undefined' || !navigator.gpu) {
+    webgpuReason = 'navigator.gpu unavailable';
+  } else {
     try {
       var adapter = await navigator.gpu.requestAdapter();
       if (adapter) {
         hasWebGPU = true;
+      } else {
+        webgpuReason = 'requestAdapter returned null';
       }
     } catch (e) {
-      // WebGPU not available \u2014 fall through to WASM
+      webgpuReason = 'requestAdapter failed: ' + String(e);
     }
   }
+  if (!hasWebGPU && webgpuReason) {
+    console.warn('[UnifiedWorker] WebGPU unavailable: ' + webgpuReason + ', falling back to WASM');
+  }
 
   var ortUrl;
   if (hasWebGPU) {
@@ -5292,7 +5354,12 @@ var UnifiedInferenceWorker = class {
       span?.setAttributes({ "worker.init_time_ms": loadTimeMs, "worker.backend": this._workerBackend });
       span?.end();
     } catch (error) {
-      span?.endWithError(error instanceof Error ? error : new Error(String(error)));
+      const err = error instanceof Error ? error : new Error(String(error));
+      const isTimeout = err.message.includes("timed out");
+      if (isTimeout) {
+        logger21.error("Worker init timed out", { code: "OMOTE_INF_003", timeoutMs: INIT_TIMEOUT_MS });
+      }
+      span?.endWithError(err);
       this.cleanup();
       throw error;
     }
@@ -5676,7 +5743,7 @@ var TTSSpeaker = class {
   async connect(tts, config) {
     logger22.info("Connecting TTS...");
     const span = getTelemetry()?.startSpan("TTSSpeaker.connect");
-    const connectStart = performance.now();
+    const connectStart = getClock().now();
     this.tts = tts;
     if (!tts.isLoaded) {
       await tts.load();
@@ -5685,7 +5752,7 @@ var TTSSpeaker = class {
     if (!hasLam) {
       this._audioOnly = true;
       this.scheduler = new AudioScheduler({ sampleRate: tts.sampleRate });
-      getTelemetry()?.recordHistogram(MetricNames.TTS_CONNECT_LATENCY, performance.now() - connectStart);
+      getTelemetry()?.recordHistogram(MetricNames.TTS_CONNECT_LATENCY, getClock().now() - connectStart);
       span?.end();
       logger22.info("TTS connected (audio-only mode)");
       return;
@@ -5719,7 +5786,7 @@ var TTSSpeaker = class {
       neutralTransitionMs: config?.neutralTransitionMs
     });
     await this.ttsPlayback.initialize();
-    getTelemetry()?.recordHistogram(MetricNames.TTS_CONNECT_LATENCY, performance.now() - connectStart);
+    getTelemetry()?.recordHistogram(MetricNames.TTS_CONNECT_LATENCY, getClock().now() - connectStart);
     span?.end();
     logger22.info("TTS connected (lip sync mode)");
   }
@@ -5754,7 +5821,7 @@ var TTSSpeaker = class {
     const span = getTelemetry()?.startSpan("TTSSpeaker.speak", {
       "text.length": text.length
     });
-    const speakStart = performance.now();
+    const speakStart = getClock().now();
     try {
       if (this._audioOnly) {
         await this.speakAudioOnly(text, abort, options?.voice);
@@ -5764,7 +5831,7 @@ var TTSSpeaker = class {
           voice: options?.voice
         });
       }
-      getTelemetry()?.recordHistogram(MetricNames.TTS_SPEAK_LATENCY, performance.now() - speakStart);
+      getTelemetry()?.recordHistogram(MetricNames.TTS_SPEAK_LATENCY, getClock().now() - speakStart);
       span?.end();
     } catch (err) {
       span?.endWithError(err instanceof Error ? err : new Error(String(err)));
@@ -5894,42 +5961,42 @@ var TTSSpeaker = class {
       end: async () => {
         if (ended) return;
         ended = true;
-        if (abort.signal.aborted) {
-          this._isSpeaking = false;
-          if (this.currentAbort === abort) this.currentAbort = null;
-          return;
-        }
-        if (buffer.trim()) {
-          enqueueSentence(buffer.trim());
-          buffer = "";
-        }
-        await processChain;
-        if (abort.signal.aborted) {
-          this._isSpeaking = false;
-          if (this.currentAbort === abort) this.currentAbort = null;
-          return;
-        }
-        await pipeline.end();
-        await new Promise((resolve) => {
-          let resolved = false;
-          const done = () => {
-            if (resolved) return;
-            resolved = true;
-            unsubC();
-            unsubS();
-            abort.signal.removeEventListener("abort", done);
-            resolve();
-          };
+        const unsubs = [];
+        try {
           if (abort.signal.aborted) {
-            resolve();
             return;
           }
-          const unsubC = pipeline.on("playback:complete", done);
-          const unsubS = pipeline.on("playback:stop", done);
-          abort.signal.addEventListener("abort", done);
-        });
-        this._isSpeaking = false;
-        if (this.currentAbort === abort) this.currentAbort = null;
+          if (buffer.trim()) {
+            enqueueSentence(buffer.trim());
+            buffer = "";
+          }
+          await processChain;
+          if (abort.signal.aborted) {
+            return;
+          }
+          await pipeline.end();
+          await new Promise((resolve) => {
+            let resolved = false;
+            const done = () => {
+              if (resolved) return;
+              resolved = true;
+              resolve();
+            };
+            if (abort.signal.aborted) {
+              resolve();
+              return;
+            }
+            unsubs.push(pipeline.on("playback:complete", done));
+            unsubs.push(pipeline.on("playback:stop", done));
+            const onAbort = () => done();
+            abort.signal.addEventListener("abort", onAbort);
+            unsubs.push(() => abort.signal.removeEventListener("abort", onAbort));
+          });
+        } finally {
+          unsubs.forEach((fn) => fn());
+          this._isSpeaking = false;
+          if (this.currentAbort === abort) this.currentAbort = null;
+        }
       }
     };
   }
@@ -6620,14 +6687,14 @@ function createKokoroTTS(config = {}) {
       logger24.info("iOS + unified worker: creating KokoroTTSUnifiedAdapter (off-main-thread ONNX)");
       return new KokoroTTSUnifiedAdapter(config.unifiedWorker, config);
     }
-    logger24.info("iOS detected: creating KokoroTTSInference (main thread, shared ORT)");
+    logger24.info("iOS: creating KokoroTTSInference (main thread, shared ORT)");
     return new KokoroTTSInference(config);
   }
   if (!KokoroTTSWorker.isSupported()) {
     logger24.info("Worker not supported: creating KokoroTTSInference (main thread)");
     return new KokoroTTSInference(config);
   }
-  logger24.info("Auto-detected: creating KokoroTTSWorker (off-main-thread)");
+  logger24.info("Auto: creating KokoroTTSWorker (off-main-thread)");
   return new KokoroTTSWorker(config);
 }
 
@@ -6861,6 +6928,9 @@ var _SenseVoiceInference = class _SenseVoiceInference {
     // so all future transcribe() calls reject immediately to prevent concurrent access.
     this.poisoned = false;
     // 10s for SenseVoice (heavier preprocessing)
+    // WebGPU shape change tracking (for dynamic shape warning)
+    this.lastLfrFrames = 0;
+    this.webgpuShapeWarned = false;
     // Preprocessing state (loaded once)
     this.tokenMap = null;
     this.negMean = null;
@@ -6895,7 +6965,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
       throw new Error("Model already loaded. Call dispose() first.");
     }
     this.isLoading = true;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     const telemetry = getTelemetry();
     const span = telemetry?.startSpan("SenseVoice.load", {
       "model.url": this.config.modelUrl,
@@ -6962,7 +7032,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
       } catch (cmvnErr) {
         logger25.warn("Failed to read CMVN from model metadata", { error: cmvnErr });
       }
-      const loadTimeMs = performance.now() - startTime;
+      const loadTimeMs = getClock().now() - startTime;
       logger25.info("SenseVoice model loaded", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
@@ -7027,24 +7097,35 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           "inference.input_samples": audio.length
         });
         try {
-          const startTime = performance.now();
-          const preprocessStart = performance.now();
+          const startTime = getClock().now();
+          const preprocessStart = getClock().now();
           const fbank = computeKaldiFbank(audio, 16e3, 80);
           const numFrames = fbank.length / 80;
           if (numFrames === 0) {
             resolve({
               text: "",
-              inferenceTimeMs: performance.now() - startTime,
-              preprocessTimeMs: performance.now() - preprocessStart
+              inferenceTimeMs: getClock().now() - startTime,
+              preprocessTimeMs: getClock().now() - preprocessStart
             });
             return;
           }
           const lfrFeatures = applyLFR(fbank, 80, 7, 6);
           const numLfrFrames = lfrFeatures.length / 560;
+          if (this._backend === "webgpu" && this.lastLfrFrames !== 0 && numLfrFrames !== this.lastLfrFrames) {
+            if (!this.webgpuShapeWarned) {
+              this.webgpuShapeWarned = true;
+              logger25.warn("SenseVoice running on WebGPU with variable audio shapes \u2014 risk of kernel crash", {
+                code: ErrorCodes.INF_SHAPE_MISMATCH,
+                previousFrames: this.lastLfrFrames,
+                currentFrames: numLfrFrames
+              });
+            }
+          }
+          this.lastLfrFrames = numLfrFrames;
           if (this.negMean && this.invStddev) {
             applyCMVN(lfrFeatures, 560, this.negMean, this.invStddev);
           }
-          const preprocessTimeMs = performance.now() - preprocessStart;
+          const preprocessTimeMs = getClock().now() - preprocessStart;
           const ort = this.ort;
           const feeds = {
             x: new ort.Tensor("float32", lfrFeatures, [1, numLfrFrames, 560]),
@@ -7074,7 +7155,7 @@ var _SenseVoiceInference = class _SenseVoiceInference {
           const seqLen = logitsDims[1];
           const vocabSize = logitsDims[2];
           const decoded = ctcGreedyDecode(logitsData, seqLen, vocabSize, this.tokenMap);
-          const inferenceTimeMs = performance.now() - startTime;
+          const inferenceTimeMs = getClock().now() - startTime;
           logger25.trace("Transcription complete", {
             text: decoded.text.substring(0, 50),
             language: decoded.language,
@@ -8413,7 +8494,7 @@ var SileroVADInference = class {
       throw new Error("Model already loaded. Call dispose() first.");
     }
     this.isLoading = true;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     const telemetry = getTelemetry();
     const span = telemetry?.startSpan("SileroVAD.load", {
       "model.url": this.config.modelUrl,
@@ -8445,7 +8526,7 @@ var SileroVADInference = class {
       const modelData = new Uint8Array(modelBuffer);
       this.session = await ort.InferenceSession.create(modelData, sessionOptions);
       this.reset();
-      const loadTimeMs = performance.now() - startTime;
+      const loadTimeMs = getClock().now() - startTime;
       logger28.info("Model loaded successfully", {
         backend: this._backend,
         loadTimeMs: Math.round(loadTimeMs),
@@ -8625,7 +8706,7 @@ var SileroVADInference = class {
           "inference.chunk_size": this.chunkSize
         });
         try {
-          const startTime = performance.now();
+          const startTime = getClock().now();
           const inputSize = this.contextSize + this.chunkSize;
           const inputBuffer = new Float32Array(inputSize);
           inputBuffer.set(this.context, 0);
@@ -8655,7 +8736,7 @@ var SileroVADInference = class {
             );
           }
           this.context = audioChunkCopy.slice(-this.contextSize);
-          const inferenceTimeMs = performance.now() - startTime;
+          const inferenceTimeMs = getClock().now() - startTime;
           const isSpeech = probability > this.config.threshold;
           let preSpeechChunks;
           if (isSpeech && !this.wasSpeaking) {
@@ -9470,6 +9551,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     this.lastProgressiveSamples = 0;
     // ASR error recovery
     this.asrErrorCount = 0;
+    this.progressiveErrorCount = 0;
     this.config = config ?? {};
   }
   /** Current listener state */
@@ -9662,7 +9744,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
       if (result.isSpeech) {
         if (!wasSpeaking) {
           this.isSpeechActive = true;
-          this.speechStartTime = performance.now();
+          this.speechStartTime = getClock().now();
           this.audioBuffer = [];
           this.audioBufferSamples = 0;
           this.lastProgressiveResult = null;
@@ -9701,13 +9783,13 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     const extended = this.config.silenceTimeoutExtendedMs ?? 700;
     const adaptive = this.config.adaptiveTimeout ?? true;
     if (!adaptive) return base;
-    const speechDurationMs = performance.now() - this.speechStartTime;
+    const speechDurationMs = getClock().now() - this.speechStartTime;
     return speechDurationMs > 3e3 ? extended : base;
   }
   onSilenceDetected() {
     const capturedEpoch = this.epoch;
     this.isSpeechActive = false;
-    const durationMs = performance.now() - this.speechStartTime;
+    const durationMs = getClock().now() - this.speechStartTime;
     logger31.debug("Speech end", { durationMs: Math.round(durationMs) });
     this.emit("speech:end", { durationMs });
     this.clearSilenceTimer();
@@ -9804,7 +9886,15 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
             this.lastProgressiveSamples = snapshotSamples;
             this.emit("transcript", { ...result, isFinal: false });
           }
-        } catch {
+        } catch (err) {
+          this.progressiveErrorCount = (this.progressiveErrorCount ?? 0) + 1;
+          if (this.progressiveErrorCount % 10 === 1) {
+            logger31.warn("Progressive transcription error", {
+              code: ErrorCodes.SPH_ASR_ERROR,
+              error: String(err),
+              count: this.progressiveErrorCount
+            });
+          }
         }
       })();
     }, intervalMs);
@@ -9821,7 +9911,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
   async transcribeWithTimeout(audio) {
     if (!this.asr) return null;
     const timeoutMs = this.config.transcriptionTimeoutMs ?? 1e4;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     const span = getTelemetry()?.startSpan("SpeechListener.transcribe", {
       "inference.input_samples": audio.length,
       "inference.input_duration_ms": audio.length / 16e3 * 1e3
@@ -9835,7 +9925,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
         })
       ]);
       clearTimeout(timeoutId);
-      const latency = performance.now() - startTime;
+      const latency = getClock().now() - startTime;
       this.asrErrorCount = 0;
       getTelemetry()?.recordHistogram(MetricNames.VOICE_TRANSCRIPTION_LATENCY, latency);
       getTelemetry()?.incrementCounter(MetricNames.VOICE_TRANSCRIPTIONS);
@@ -10009,11 +10099,11 @@ var InterruptionHandler = class extends EventEmitter {
   getState() {
     return {
       isSpeaking: this.isSpeaking,
-      speechDurationMs: this.isSpeaking ? performance.now() - this.speechStartTime : 0
+      speechDurationMs: this.isSpeaking ? getClock().now() - this.speechStartTime : 0
     };
   }
   onSpeechDetected(rms) {
-    const now = performance.now();
+    const now = getClock().now();
     this.lastSpeechTime = now;
     if (this.silenceTimer) {
       clearTimeout(this.silenceTimer);
@@ -10230,7 +10320,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.setupEventHandlers();
       this.recognition.start();
       this.isListening = true;
-      this.startTime = performance.now();
+      this.startTime = getClock().now();
       this.accumulatedText = "";
       logger33.info("Speech recognition started", {
         language: this.config.language
@@ -10331,7 +10421,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
             const speechResult = {
               text: isFinal ? this.accumulatedText.trim() : text,
               language: this.config.language,
-              inferenceTimeMs: performance.now() - this.startTime,
+              inferenceTimeMs: getClock().now() - this.startTime,
               isFinal,
               confidence: alternative.confidence
             };
@@ -10363,13 +10453,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = false;
       logger33.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
-        durationMs: performance.now() - this.startTime
+        durationMs: getClock().now() - this.startTime
       });
       if (this.stopResolver) {
         const result = {
           text: this.accumulatedText.trim(),
           language: this.config.language,
-          inferenceTimeMs: performance.now() - this.startTime,
+          inferenceTimeMs: getClock().now() - this.startTime,
           isFinal: true
         };
         this.stopResolver(result);
@@ -10413,6 +10503,303 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
   }
 };
 
+// src/inference/ElevenLabsTTSBackend.ts
+var logger34 = createLogger("ElevenLabsTTS");
+var DEFAULT_MODEL = "eleven_multilingual_v2";
+var DEFAULT_OUTPUT_FORMAT = "pcm_16000";
+var DEFAULT_STABILITY = 0.5;
+var DEFAULT_SIMILARITY_BOOST = 0.75;
+var DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+var FORMAT_TO_SAMPLE_RATE = {
+  pcm_16000: 16e3,
+  pcm_22050: 22050,
+  pcm_24000: 24e3,
+  pcm_44100: 44100
+};
+var ElevenLabsTTSBackend = class {
+  constructor(config) {
+    this._isLoaded = false;
+    if (!config.apiKey) throw new Error("ElevenLabsTTS: apiKey is required");
+    if (!config.voiceId) throw new Error("ElevenLabsTTS: voiceId is required");
+    this.apiKey = config.apiKey;
+    this.voiceId = config.voiceId;
+    this.model = config.model ?? DEFAULT_MODEL;
+    this.outputFormat = config.outputFormat ?? DEFAULT_OUTPUT_FORMAT;
+    this.stability = config.stability ?? DEFAULT_STABILITY;
+    this.similarityBoost = config.similarityBoost ?? DEFAULT_SIMILARITY_BOOST;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    const rate = FORMAT_TO_SAMPLE_RATE[this.outputFormat];
+    if (!rate) {
+      throw new Error(
+        `ElevenLabsTTS: unsupported outputFormat "${this.outputFormat}". Supported: ${Object.keys(FORMAT_TO_SAMPLE_RATE).join(", ")}`
+      );
+    }
+    this._sampleRate = rate;
+  }
+  get sampleRate() {
+    return this._sampleRate;
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  // ─── Load ───────────────────────────────────────────────────────────────
+  /**
+   * No-op for cloud TTS (no model to load).
+   * Marks backend as ready.
+   */
+  async load() {
+    this._isLoaded = true;
+    logger34.info("ElevenLabs TTS ready", { voiceId: this.voiceId, model: this.model });
+  }
+  // ─── Stream ─────────────────────────────────────────────────────────────
+  /**
+   * Stream audio from ElevenLabs for the given text.
+   *
+   * Uses the streaming endpoint. Yields a single chunk for non-streaming
+   * or multiple chunks as response data arrives.
+   */
+  async *stream(text, options) {
+    if (!this._isLoaded) {
+      throw new Error("ElevenLabsTTS: not loaded. Call load() first.");
+    }
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+      throw new Error("ElevenLabsTTS: text must not be empty");
+    }
+    const startTime = getClock().now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("ElevenLabsTTS.stream", {
+      "tts.text_length": trimmed.length,
+      "tts.voice_id": this.voiceId,
+      "tts.model": this.model
+    });
+    const url = `${this.baseUrl}/v1/text-to-speech/${this.voiceId}?output_format=${this.outputFormat}`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "xi-api-key": this.apiKey,
+          "Content-Type": "application/json",
+          Accept: "audio/pcm"
+        },
+        body: JSON.stringify({
+          text: trimmed,
+          model_id: this.model,
+          voice_settings: {
+            stability: this.stability,
+            similarity_boost: this.similarityBoost
+          }
+        }),
+        signal: options?.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "unknown");
+        const msg = `ElevenLabsTTS: HTTP ${response.status} \u2014 ${this.getHttpErrorMessage(response.status, errorText)}`;
+        logger34.error(msg);
+        throw new Error(msg);
+      }
+      if (!response.body) {
+        const buffer = await response.arrayBuffer();
+        const audio = pcm16ToFloat32(buffer);
+        const duration = audio.length / this._sampleRate;
+        const latency2 = getClock().now() - startTime;
+        span?.setAttributes({ "tts.duration_s": duration, "tts.latency_ms": latency2 });
+        span?.end();
+        telemetry?.recordHistogram("omote.inference.latency", latency2, {
+          model: "elevenlabs-tts",
+          backend: "cloud"
+        });
+        yield { audio, duration, text: trimmed };
+        return;
+      }
+      const reader = response.body.getReader();
+      let totalSamples = 0;
+      try {
+        while (true) {
+          if (options?.signal?.aborted) {
+            reader.cancel();
+            logger34.debug("Stream aborted by signal");
+            return;
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value && value.byteLength > 0) {
+            const usableBytes = value.byteLength & ~1;
+            if (usableBytes === 0) continue;
+            const audio = pcm16ToFloat32(value.buffer.slice(value.byteOffset, value.byteOffset + usableBytes));
+            const duration = audio.length / this._sampleRate;
+            totalSamples += audio.length;
+            yield { audio, duration, text: trimmed };
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      const latency = getClock().now() - startTime;
+      const totalDuration = totalSamples / this._sampleRate;
+      logger34.debug("Stream complete", {
+        totalDuration: `${totalDuration.toFixed(2)}s`,
+        latencyMs: Math.round(latency),
+        totalSamples
+      });
+      span?.setAttributes({ "tts.duration_s": totalDuration, "tts.latency_ms": latency });
+      span?.end();
+      telemetry?.recordHistogram("omote.inference.latency", latency, {
+        model: "elevenlabs-tts",
+        backend: "cloud"
+      });
+      telemetry?.incrementCounter("omote.inference.total", 1, {
+        model: "elevenlabs-tts",
+        backend: "cloud",
+        status: "success"
+      });
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        logger34.debug("Stream aborted");
+        span?.end();
+        return;
+      }
+      const errMsg = err instanceof Error ? err.message : String(err);
+      logger34.error("Stream failed", { error: errMsg });
+      span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+      telemetry?.incrementCounter("omote.inference.total", 1, {
+        model: "elevenlabs-tts",
+        backend: "cloud",
+        status: "error"
+      });
+      throw err;
+    }
+  }
+  // ─── Dispose ────────────────────────────────────────────────────────────
+  async dispose() {
+    this._isLoaded = false;
+    logger34.info("ElevenLabs TTS disposed");
+  }
+  // ─── Private ────────────────────────────────────────────────────────────
+  getHttpErrorMessage(status, body) {
+    switch (status) {
+      case 401:
+        return "Unauthorized \u2014 check your API key";
+      case 403:
+        return "Forbidden \u2014 API key lacks required permissions";
+      case 429:
+        return "Rate limited \u2014 too many requests";
+      case 400:
+        return `Bad request \u2014 ${body}`;
+      default:
+        return body || `HTTP error ${status}`;
+    }
+  }
+};
+
+// src/inference/PollyTTSBackend.ts
+var logger35 = createLogger("PollyTTS");
+var DEFAULT_VOICE = "Joanna";
+var DEFAULT_SAMPLE_RATE = 16e3;
+var PollyTTSBackend = class {
+  constructor(config) {
+    this._isLoaded = false;
+    if (!config.synthesizeFn) {
+      throw new Error("PollyTTS: synthesizeFn is required");
+    }
+    this.synthesizeFn = config.synthesizeFn;
+    this.voice = config.voice ?? DEFAULT_VOICE;
+    this._sampleRate = config.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    this.engine = config.engine ?? "neural";
+  }
+  get sampleRate() {
+    return this._sampleRate;
+  }
+  get isLoaded() {
+    return this._isLoaded;
+  }
+  // ─── Load ───────────────────────────────────────────────────────────────
+  /**
+   * No-op for cloud TTS (no model to load).
+   * Marks backend as ready.
+   */
+  async load() {
+    this._isLoaded = true;
+    logger35.info("Polly TTS ready", { voice: this.voice, engine: this.engine, sampleRate: this._sampleRate });
+  }
+  // ─── Stream ─────────────────────────────────────────────────────────────
+  /**
+   * Synthesize audio via consumer's Polly function.
+   *
+   * Polly's SynthesizeSpeech is request/response (not streaming for PCM),
+   * so this yields a single chunk per call. For long text, consider splitting
+   * into sentences on the consumer side.
+   */
+  async *stream(text, options) {
+    if (!this._isLoaded) {
+      throw new Error("PollyTTS: not loaded. Call load() first.");
+    }
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+      throw new Error("PollyTTS: text must not be empty");
+    }
+    if (options?.signal?.aborted) {
+      return;
+    }
+    const voiceName = options?.voice ?? this.voice;
+    const startTime = getClock().now();
+    const telemetry = getTelemetry();
+    const span = telemetry?.startSpan("PollyTTS.stream", {
+      "tts.text_length": trimmed.length,
+      "tts.voice": voiceName,
+      "tts.engine": this.engine
+    });
+    try {
+      const result = await this.synthesizeFn(trimmed, voiceName, this._sampleRate);
+      if (options?.signal?.aborted) {
+        span?.end();
+        return;
+      }
+      const audio = pcm16ToFloat32(result.audio);
+      const duration = audio.length / this._sampleRate;
+      const latency = getClock().now() - startTime;
+      logger35.debug("Synthesis complete", {
+        voice: voiceName,
+        duration: `${duration.toFixed(2)}s`,
+        latencyMs: Math.round(latency),
+        numSamples: audio.length
+      });
+      span?.setAttributes({ "tts.duration_s": duration, "tts.latency_ms": latency });
+      span?.end();
+      telemetry?.recordHistogram("omote.inference.latency", latency, {
+        model: "polly-tts",
+        backend: "cloud"
+      });
+      telemetry?.incrementCounter("omote.inference.total", 1, {
+        model: "polly-tts",
+        backend: "cloud",
+        status: "success"
+      });
+      yield { audio, duration, text: trimmed };
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        logger35.debug("Synthesis aborted");
+        span?.end();
+        return;
+      }
+      const errMsg = err instanceof Error ? err.message : String(err);
+      logger35.error("Synthesis failed", { error: errMsg });
+      span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+      telemetry?.incrementCounter("omote.inference.total", 1, {
+        model: "polly-tts",
+        backend: "cloud",
+        status: "error"
+      });
+      throw err;
+    }
+  }
+  // ─── Dispose ────────────────────────────────────────────────────────────
+  async dispose() {
+    this._isLoaded = false;
+    logger35.info("Polly TTS disposed");
+  }
+};
+
 // src/inference/ortConfig.ts
 var ortCdnBase = null;
 function configureOrtCdn(cdnPath) {
@@ -10426,7 +10813,7 @@ function getOrtCdnBase() {
 }
 
 // src/emotion/Emotion.ts
-var logger34 = createLogger("EmotionController");
+var logger36 = createLogger("EmotionController");
 var EMOTION_NAMES = [
   "amazement",
   "anger",
@@ -10448,7 +10835,7 @@ function createEmotionVector(weights = {}) {
     if (idx >= 0) {
       vector[idx] = Math.max(0, Math.min(1, value));
     } else {
-      logger34.warn(`Invalid emotion name in createEmotionVector: "${name}"`);
+      logger36.warn(`Invalid emotion name in createEmotionVector: "${name}"`);
     }
   }
   return vector;
@@ -10531,7 +10918,7 @@ var EmotionController = class {
     this.targetEmotion.set(newEmotion);
     this.currentEmotion.set(newEmotion);
     this.transitionProgress = 1;
-    logger34.debug("set", { weights });
+    logger36.debug("set", { weights });
   }
   /**
    * Set emotion from preset immediately
@@ -10541,7 +10928,7 @@ var EmotionController = class {
     this.targetEmotion.set(newEmotion);
     this.currentEmotion.set(newEmotion);
     this.transitionProgress = 1;
-    logger34.debug("setPreset", { preset });
+    logger36.debug("setPreset", { preset });
   }
   /**
    * Transition to new emotion over time
@@ -10553,9 +10940,9 @@ var EmotionController = class {
     this.currentEmotion.set(this.emotion);
     this.targetEmotion.set(createEmotionVector(weights));
     this.transitionDuration = durationMs;
-    this.transitionStartTime = performance.now();
+    this.transitionStartTime = getClock().now();
     this.transitionProgress = 0;
-    logger34.debug("transitionTo", { weights, durationMs });
+    logger36.debug("transitionTo", { weights, durationMs });
   }
   /**
    * Transition to preset over time
@@ -10564,7 +10951,7 @@ var EmotionController = class {
     this.currentEmotion.set(this.emotion);
     this.targetEmotion.set(getEmotionPreset(preset));
     this.transitionDuration = durationMs;
-    this.transitionStartTime = performance.now();
+    this.transitionStartTime = getClock().now();
     this.transitionProgress = 0;
   }
   /**
@@ -10572,7 +10959,7 @@ var EmotionController = class {
    */
   update() {
     if (this.transitionProgress >= 1) return;
-    const elapsed = performance.now() - this.transitionStartTime;
+    const elapsed = getClock().now() - this.transitionStartTime;
     this.transitionProgress = Math.min(1, elapsed / this.transitionDuration);
   }
   /**
@@ -10588,7 +10975,7 @@ var EmotionController = class {
     this.currentEmotion.fill(0);
     this.targetEmotion.fill(0);
     this.transitionProgress = 1;
-    logger34.debug("reset");
+    logger36.debug("reset");
   }
 };
 
@@ -10669,7 +11056,7 @@ var DEFAULT_ANIMATION_CONFIG = {
 };
 
 // src/animation/AnimationGraph.ts
-var logger35 = createLogger("AnimationGraph");
+var logger37 = createLogger("AnimationGraph");
 var AnimationGraph = class extends EventEmitter {
   constructor(config = {}) {
     super();
@@ -10702,7 +11089,7 @@ var AnimationGraph = class extends EventEmitter {
     this.stateEnterTime = Date.now();
     this.lastUpdateTime = Date.now();
     this.cachedOutput = this.computeOutput();
-    logger35.info("constructor", {
+    logger37.info("constructor", {
       initialState: this.config.initialState,
       stateCount: this.config.states.length,
       transitionCount: this.config.transitions.length
@@ -10773,7 +11160,7 @@ var AnimationGraph = class extends EventEmitter {
   setState(stateName, blendDuration = 300) {
     const targetState = this.config.states.find((s) => s.name === stateName);
     if (!targetState) {
-      logger35.warn(`State '${stateName}' not found`);
+      logger37.warn(`State '${stateName}' not found`);
       return;
     }
     if (targetState.name === this.currentState.name && !this.isTransitioning) {
@@ -10851,7 +11238,7 @@ var AnimationGraph = class extends EventEmitter {
       (s) => s.name === transition.to
     );
     if (!targetState) {
-      logger35.warn(`Target state '${transition.to}' not found`);
+      logger37.warn(`Target state '${transition.to}' not found`);
       return;
     }
     const fromState = this.currentState.name;
@@ -10865,7 +11252,7 @@ var AnimationGraph = class extends EventEmitter {
     if (!this.currentState.emotionBlendEnabled) {
       this.targetEmotionWeight = 0;
     }
-    logger35.debug("state transition", {
+    logger37.debug("state transition", {
       from: fromState,
       to: targetState.name,
       trigger: event,
@@ -10902,7 +11289,7 @@ var AnimationGraph = class extends EventEmitter {
     if (this.currentState.timeout <= 0) return;
     const elapsed = now - this.stateEnterTime;
     if (elapsed >= this.currentState.timeout) {
-      logger35.debug("timeout transition", {
+      logger37.debug("timeout transition", {
         state: this.currentState.name,
         elapsed,
         timeout: this.currentState.timeout
@@ -11016,7 +11403,7 @@ var AnimationGraph = class extends EventEmitter {
 
 // src/animation/ProceduralLifeLayer.ts
 import { createNoise2D } from "simplex-noise";
-var logger36 = createLogger("ProceduralLifeLayer");
+var logger38 = createLogger("ProceduralLifeLayer");
 var simplex2d = createNoise2D();
 var LIFE_BS_INDEX = /* @__PURE__ */ new Map();
 for (let i = 0; i < LAM_BLENDSHAPES.length; i++) {
@@ -11122,7 +11509,7 @@ var ProceduralLifeLayer = class {
     }
     this.blinkInterval = this.nextBlinkInterval();
     this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
-    logger36.debug("constructor", {
+    logger38.debug("constructor", {
       blinkIntervalRange: this.blinkIntervalRange,
       useLogNormalBlinks: this.useLogNormalBlinks,
       gazeBreakIntervalRange: this.gazeBreakIntervalRange,
@@ -11226,7 +11613,7 @@ var ProceduralLifeLayer = class {
    * Reset all internal state to initial values.
    */
   reset() {
-    logger36.debug("reset");
+    logger38.debug("reset");
     this.blinkTimer = 0;
     this.blinkInterval = this.nextBlinkInterval();
     this.blinkPhase = PHASE_OPEN;
@@ -11278,7 +11665,7 @@ var ProceduralLifeLayer = class {
       this.blinkTimer = 0;
       this.blinkInterval = this.nextBlinkInterval();
       this.asymmetryRight = 0.95 + Math.random() * 0.08;
-      logger36.trace("blink", { nextInterval: this.blinkInterval });
+      logger38.trace("blink", { nextInterval: this.blinkInterval });
     }
     if (this.blinkPhase > PHASE_OPEN) {
       this.blinkProgress += delta;
@@ -11359,7 +11746,7 @@ var ProceduralLifeLayer = class {
       this.gazeBreakTargetX = (Math.random() - 0.5) * 2 * amp;
       this.gazeBreakTargetY = (Math.random() - 0.5) * amp * 0.4;
       this.gazeBreakInterval = randomRange(...params.interval);
-      logger36.trace("gaze break", {
+      logger38.trace("gaze break", {
         targetX: this.gazeBreakTargetX.toFixed(3),
         targetY: this.gazeBreakTargetY.toFixed(3),
         nextInterval: this.gazeBreakInterval.toFixed(2),
@@ -11602,7 +11989,7 @@ var ALL_AUS = [...new Set(
 )];
 
 // src/face/EmotionResolver.ts
-var logger37 = createLogger("EmotionResolver");
+var logger39 = createLogger("EmotionResolver");
 var BS_INDEX = /* @__PURE__ */ new Map();
 for (let i = 0; i < LAM_BLENDSHAPES.length; i++) {
   BS_INDEX.set(LAM_BLENDSHAPES[i], i);
@@ -11629,7 +12016,7 @@ var EmotionResolver = class {
       if (!emotionWeight || emotionWeight < 0.01) continue;
       const auActivations = EMOTION_TO_AU[emotionName];
       if (!auActivations) {
-        logger37.warn(`Unknown emotion name with no AU mapping: "${emotionName}"`);
+        logger39.warn(`Unknown emotion name with no AU mapping: "${emotionName}"`);
         continue;
       }
       for (const activation of auActivations) {
@@ -11654,7 +12041,7 @@ var EmotionResolver = class {
 };
 
 // src/face/FaceCompositor.ts
-var logger38 = createLogger("FaceCompositor");
+var logger40 = createLogger("FaceCompositor");
 function smoothstep(t) {
   return t * t * (3 - 2 * t);
 }
@@ -11685,7 +12072,7 @@ var FaceCompositor = class {
     if (config?.profile) {
       this.applyProfileArrays(config.profile);
     }
-    logger38.debug("constructor", {
+    logger40.debug("constructor", {
       emotionSmoothing: this.emotionSmoothing,
       hasProfile: !!config?.profile,
       hasLifeLayer: !!config?.lifeLayer
@@ -11701,7 +12088,7 @@ var FaceCompositor = class {
    * @returns Blendshapes (Float32Array[52] clamped [0,1]) and head rotation deltas
    */
   compose(base, input, target) {
-    const composeStart = performance.now();
+    const composeStart = getClock().now();
     const out = target ?? this.outputBuffer;
     out.set(base);
     const emotion = input.emotion ?? this.stickyEmotion;
@@ -11748,7 +12135,7 @@ var FaceCompositor = class {
     }
     getTelemetry()?.recordHistogram(
       MetricNames.COMPOSITOR_COMPOSE_LATENCY,
-      (performance.now() - composeStart) * 1e3
+      (getClock().now() - composeStart) * 1e3
       // µs
     );
     return { blendshapes: out, headDelta: lifeResult.headDelta };
@@ -11758,7 +12145,7 @@ var FaceCompositor = class {
    */
   setEmotion(weights) {
     this.stickyEmotion = weights;
-    logger38.debug("setEmotion", { weights });
+    logger40.debug("setEmotion", { weights });
   }
   /**
    * Update character profile at runtime.
@@ -11767,7 +12154,7 @@ var FaceCompositor = class {
     this.multiplier.fill(1);
     this.offset.fill(0);
     this.applyProfileArrays(profile);
-    logger38.debug("setProfile", {
+    logger40.debug("setProfile", {
       multiplierKeys: profile.multiplier ? Object.keys(profile.multiplier).length : 0,
       offsetKeys: profile.offset ? Object.keys(profile.offset).length : 0
     });
@@ -11781,7 +12168,7 @@ var FaceCompositor = class {
     this.lifeBuffer.fill(0);
     this.stickyEmotion = void 0;
     this.lifeLayer.reset();
-    logger38.debug("reset");
+    logger40.debug("reset");
   }
   /** Expand partial profile maps into dense Float32Arrays */
   applyProfileArrays(profile) {
@@ -11866,7 +12253,7 @@ function parseEmotionTags(text) {
 }
 
 // src/character/CharacterController.ts
-var logger39 = createLogger("CharacterController");
+var logger41 = createLogger("CharacterController");
 var FRAME_BUDGET_US = 33e3;
 var EMOTION_MAP = {
   // Synced with EmotionPresets (packages/core/src/emotion/Emotion.ts)
@@ -11936,7 +12323,7 @@ var CharacterController = class {
     this.gazeYawInfluence = config?.gaze?.yawInfluence ?? 0.4;
     this.gazePitchInfluence = config?.gaze?.pitchInfluence ?? 0.3;
     this.gazeSmoothing = config?.gaze?.smoothing ?? 5;
-    logger39.debug("constructor", {
+    logger41.debug("constructor", {
       gazeEnabled: this.gazeEnabled,
       gazeYawInfluence: this.gazeYawInfluence,
       gazePitchInfluence: this.gazePitchInfluence,
@@ -11951,7 +12338,7 @@ var CharacterController = class {
    * into a single output frame.
    */
   update(input) {
-    const frameStart = performance.now();
+    const frameStart = getClock().now();
     const base = input.baseBlendshapes ?? this.zeroBase;
     const eyeTargets = this.computeEyeTargets(
       input.cameraWorldPos,
@@ -11978,7 +12365,7 @@ var CharacterController = class {
       lifeHeadDelta,
       input.avatarRotationY ?? 0
     );
-    const frameUs = (performance.now() - frameStart) * 1e3;
+    const frameUs = (getClock().now() - frameStart) * 1e3;
     this.frameTimes[this.frameTimeIdx] = frameUs;
     this.frameTimeIdx = (this.frameTimeIdx + 1) % this.frameTimes.length;
     if (this.frameTimeFill < this.frameTimes.length) this.frameTimeFill++;
@@ -12000,13 +12387,13 @@ var CharacterController = class {
     const resolved = resolveEmotion(emotion);
     if (resolved) {
       this._compositor.setEmotion(resolved);
-      logger39.debug("setEmotion", { emotion, resolved });
+      logger41.debug("setEmotion", { emotion, resolved });
     }
   }
   /** Update character profile at runtime. */
   setProfile(profile) {
     this._compositor.setProfile(profile);
-    logger39.debug("setProfile", {
+    logger41.debug("setProfile", {
       multiplierKeys: profile.multiplier ? Object.keys(profile.multiplier).length : 0,
       offsetKeys: profile.offset ? Object.keys(profile.offset).length : 0
     });
@@ -12041,11 +12428,11 @@ var CharacterController = class {
     this._compositor.reset();
     this.gazeHeadYaw = 0;
     this.gazeHeadPitch = -0.1;
-    logger39.debug("reset");
+    logger41.debug("reset");
   }
   dispose() {
     this.reset();
-    logger39.debug("dispose");
+    logger41.debug("dispose");
   }
   // ---------------------------------------------------------------------------
   // Eye angle math (extracted from r3f useGazeTracking.computeEyeTargets)
@@ -12127,7 +12514,7 @@ var CharacterController = class {
 };
 
 // src/orchestration/MicLipSync.ts
-var logger40 = createLogger("MicLipSync");
+var logger42 = createLogger("MicLipSync");
 var MicLipSync = class extends EventEmitter {
   constructor(config) {
     super();
@@ -12146,7 +12533,7 @@ var MicLipSync = class extends EventEmitter {
     this.vadChunkSize = 0;
     this.vadBuffer = null;
     this.vadBufferOffset = 0;
-    logger40.info("MicLipSync created", {
+    logger42.info("MicLipSync created", {
       sampleRate: config.sampleRate ?? 16e3,
       micChunkSize: config.micChunkSize ?? 512,
       hasVAD: !!config.vad,
@@ -12168,12 +12555,12 @@ var MicLipSync = class extends EventEmitter {
         this._currentFrame = scaled;
         if (!this._firstFrameEmitted) {
           this._firstFrameEmitted = true;
-          logger40.trace("First blendshape frame emitted");
+          logger42.trace("First blendshape frame emitted");
         }
         this.emit("frame", { blendshapes: scaled, rawBlendshapes: raw });
       },
       onError: (error) => {
-        logger40.error("A2E inference error", { message: error.message });
+        logger42.error("A2E inference error", { message: error.message });
         this.emit("error", error);
       }
     });
@@ -12181,7 +12568,9 @@ var MicLipSync = class extends EventEmitter {
       const float32 = int16ToFloat32(pcm);
       this.processor.pushAudio(float32);
       if (this.vad) {
-        this.vadQueue = this.vadQueue.then(() => this.processVAD(float32)).catch(() => {
+        this.vadQueue = this.vadQueue.then(() => this.processVAD(float32)).catch((err) => {
+          logger42.warn("VAD processing error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
         });
       }
     });
@@ -12216,7 +12605,7 @@ var MicLipSync = class extends EventEmitter {
   /** Start microphone capture and inference loop */
   async start() {
     if (this._state === "active") return;
-    logger40.info("Starting MicLipSync");
+    logger42.info("Starting MicLipSync");
     getTelemetry()?.incrementCounter(MetricNames.MIC_SESSIONS);
     await this.mic.start();
     this.processor.startDrip();
@@ -12226,7 +12615,7 @@ var MicLipSync = class extends EventEmitter {
   /** Stop microphone and inference */
   stop() {
     if (this._state === "idle") return;
-    logger40.info("Stopping MicLipSync");
+    logger42.info("Stopping MicLipSync");
     this.processor.stopDrip();
     this.mic.stop();
     this._isSpeaking = false;
@@ -12268,14 +12657,15 @@ var MicLipSync = class extends EventEmitter {
           const wasSpeaking = this._isSpeaking;
           this._isSpeaking = result.isSpeech;
           if (!wasSpeaking && result.isSpeech) {
-            this.speechStartTime = performance.now();
+            this.speechStartTime = getClock().now();
             this.emit("speech:start");
           } else if (wasSpeaking && !result.isSpeech) {
-            const durationMs = performance.now() - this.speechStartTime;
+            const durationMs = getClock().now() - this.speechStartTime;
             this.emit("speech:end", { durationMs });
           }
         } catch (err) {
-          logger40.warn("VAD process error", { error: String(err) });
+          logger42.warn("VAD process error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
         }
         this.vadBufferOffset = 0;
       }
@@ -12292,7 +12682,7 @@ var MicLipSync = class extends EventEmitter {
 };
 
 // src/orchestration/VoicePipeline.ts
-var logger41 = createLogger("VoicePipeline");
+var logger43 = createLogger("VoicePipeline");
 var _VoicePipeline = class _VoicePipeline extends EventEmitter {
   constructor(config) {
     super();
@@ -12324,6 +12714,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     this.lastProgressiveSamples = 0;
     // ASR error recovery
     this.asrErrorCount = 0;
+    this.progressiveErrorCount = 0;
     // Response abort
     this.responseAbortController = null;
     // Listener cleanup
@@ -12367,7 +12758,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       if (typeof requestAnimationFrame !== "undefined") {
         await new Promise((r) => requestAnimationFrame(() => r()));
       }
-      logger41.debug("Creating PlaybackPipeline", {
+      logger43.debug("Creating PlaybackPipeline", {
         neutralTransitionEnabled: this.config.neutralTransitionEnabled ?? true,
         audioDelayMs: this.config.audioDelayMs,
         chunkTargetMs: this.config.chunkTargetMs
@@ -12407,8 +12798,9 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       this.setState("ready");
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
+      span?.setAttributes({ "error.type": ErrorTypes.MODEL });
       span?.endWithError(err);
-      logger41.error("Model loading failed", { message: err.message });
+      logger43.error("Model loading failed", { message: err.message });
       this.emit("error", err);
       this.setState("error");
       throw err;
@@ -12422,7 +12814,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const { backends } = this.config;
     if (!backends) throw new Error("No backends config");
     this.emitProgress("Loading models", 0, 1, 0);
-    logger41.info("Loading from pre-built backends");
+    logger43.info("Loading from pre-built backends");
     const toLoad = [];
     if (!backends.asr.isLoaded) toLoad.push(backends.asr.load());
     if (!backends.lam.isLoaded) toLoad.push(backends.lam.load());
@@ -12456,7 +12848,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       } else if (UnifiedInferenceWorker.isSupported()) {
         this.unifiedWorker = new UnifiedInferenceWorker();
         await this.unifiedWorker.init();
-        logger41.info("Created internal unified worker", { backend: this.unifiedWorker.backend });
+        logger43.info("Created internal unified worker", { backend: this.unifiedWorker.backend });
       }
     }
     this.emitProgress("Loading models", 0, 3, 0);
@@ -12493,17 +12885,17 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         throw asrResult.reason;
       }
       this.asr = asr;
-      logger41.info("SenseVoice loaded");
+      logger43.info("SenseVoice loaded");
       if (vadResult.status === "rejected") {
         throw vadResult.reason;
       }
       this.vad = vad;
-      logger41.info("Silero VAD loaded");
+      logger43.info("Silero VAD loaded");
       if (lamResult.status === "rejected") {
         throw lamResult.reason;
       }
       this.lam = lam;
-      logger41.info("LAM loaded");
+      logger43.info("LAM loaded");
     } finally {
       clearInterval(progressInterval);
     }
@@ -12511,7 +12903,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     if (this.isLocalMode) {
       const localConfig = this.config;
       if (localConfig.ttsConfig && !localConfig.tts) {
-        logger41.info("Creating Kokoro TTS from config", {
+        logger43.info("Creating Kokoro TTS from config", {
           hasUnifiedWorker: !!this.unifiedWorker,
           voice: localConfig.ttsConfig.defaultVoice
         });
@@ -12521,7 +12913,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         });
       }
       if (localConfig.tts && !localConfig.ttsConfig && isIOS()) {
-        logger41.warn(
+        logger43.warn(
           "External TTS on iOS creates a separate ORT WASM instance, risking OOM. Prefer ttsConfig for automatic unified worker integration."
         );
       }
@@ -12529,9 +12921,9 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         throw new Error("VoicePipeline local mode requires either tts or ttsConfig");
       }
       if (!localConfig.tts.isLoaded) {
-        logger41.info("Loading local TTS model...");
+        logger43.info("Loading local TTS model...");
         await localConfig.tts.load();
-        logger41.info("Local TTS model loaded");
+        logger43.info("Local TTS model loaded");
       }
     }
     this.emitProgress("Loading models", 100, 3, 3);
@@ -12547,8 +12939,8 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     this.epoch++;
     this._sessionId = crypto.randomUUID();
     this.asrErrorCount = 0;
-    logger41.info("Starting voice pipeline", { sessionId: this._sessionId });
-    logger41.debug("Pipeline mode", { mode: this.isLocalMode ? "local" : "cloud" });
+    logger43.info("Starting voice pipeline", { sessionId: this._sessionId });
+    logger43.debug("Pipeline mode", { mode: this.isLocalMode ? "local" : "cloud" });
     this.mic = new MicrophoneCapture(this.omoteEvents, {
       sampleRate: 16e3,
       chunkSize: 512
@@ -12561,11 +12953,11 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       this.emit("audio:level", level);
     });
     await this.mic.start();
-    logger41.debug("Microphone started");
+    logger43.debug("Microphone started");
     this.setState("listening");
   }
   stop() {
-    logger41.info("Stopping voice pipeline", { sessionId: this._sessionId });
+    logger43.info("Stopping voice pipeline", { sessionId: this._sessionId });
     this.stopped = true;
     this.epoch++;
     this.clearSilenceTimer();
@@ -12594,7 +12986,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     this.playback?.setProfile(profile);
   }
   async dispose() {
-    logger41.debug("Disposing VoicePipeline");
+    logger43.debug("Disposing VoicePipeline");
     this.stop();
     this.epoch++;
     await Promise.allSettled([
@@ -12628,19 +13020,20 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       if (result.isSpeech) {
         if (!wasSpeaking) {
           this.isSpeaking = true;
-          this.speechStartTime = performance.now();
+          this.speechStartTime = getClock().now();
           this.audioBuffer = [];
           this.audioBufferSamples = 0;
           this.lastProgressiveResult = null;
           this.lastProgressiveSamples = 0;
-          logger41.debug("VAD speech start");
+          this.progressiveErrorCount = 0;
+          logger43.debug("VAD speech start");
           this.emit("speech:start");
           this.startProgressiveTranscription();
         }
         this.audioBuffer.push(new Float32Array(samples));
         this.audioBufferSamples += samples.length;
         if (this.audioBufferSamples >= _VoicePipeline.MAX_AUDIO_BUFFER_SAMPLES) {
-          logger41.warn("Audio buffer exceeded max, forcing transcription flush");
+          logger43.warn("Audio buffer exceeded max, forcing transcription flush");
           this.onSilenceDetected();
           return;
         }
@@ -12656,7 +13049,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         }
       }
     } catch (err) {
-      logger41.warn("VAD error", { error: String(err) });
+      logger43.warn("VAD error", { error: String(err) });
     }
   }
   // ---------------------------------------------------------------------------
@@ -12667,18 +13060,18 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const extended = this.config.silenceTimeoutExtendedMs ?? 700;
     const adaptive = this.config.adaptiveTimeout ?? true;
     if (!adaptive) return base;
-    const speechDurationMs = performance.now() - this.speechStartTime;
+    const speechDurationMs = getClock().now() - this.speechStartTime;
     return speechDurationMs > 3e3 ? extended : base;
   }
   onSilenceDetected() {
     const capturedEpoch = this.epoch;
     this.isSpeaking = false;
-    const durationMs = performance.now() - this.speechStartTime;
-    logger41.debug("VAD speech end", { durationMs: Math.round(durationMs) });
+    const durationMs = getClock().now() - this.speechStartTime;
+    logger43.debug("VAD speech end", { durationMs: Math.round(durationMs) });
     this.emit("speech:end", { durationMs });
     this.clearSilenceTimer();
     this.processEndOfSpeech(capturedEpoch).catch((err) => {
-      logger41.error("End of speech processing failed", { error: String(err) });
+      logger43.error("End of speech processing failed", { error: String(err) });
       if (this.epoch === capturedEpoch && !this.stopped) {
         this.emit("error", err instanceof Error ? err : new Error(String(err)));
         this.setState("listening");
@@ -12692,7 +13085,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const turnSpan = getTelemetry()?.startSpan("VoicePipeline.turn", {
       "session.id": this._sessionId ?? ""
     });
-    const turnStart = performance.now();
+    const turnStart = getClock().now();
     if (this.progressivePromise) {
       try {
         await this.progressivePromise;
@@ -12717,7 +13110,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const minEnergy = this.config.minAudioEnergy ?? 0.02;
     const durationSec = totalSamples / 16e3;
     if (durationSec < minDuration) {
-      logger41.info("Audio too short, discarding", { durationSec });
+      logger43.info("Audio too short, discarding", { durationSec });
       turnSpan?.end();
       this.setState("listening");
       return;
@@ -12728,7 +13121,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     }
     rms = Math.sqrt(rms / fullAudio.length);
     if (rms < minEnergy) {
-      logger41.info("Audio too quiet, discarding", { rms });
+      logger43.info("Audio too quiet, discarding", { rms });
       turnSpan?.end();
       this.setState("listening");
       return;
@@ -12739,12 +13132,12 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const coverageThreshold = this.config.progressiveCoverageThreshold ?? 0.8;
     if (this.lastProgressiveResult && this.lastProgressiveResult.text.trim().length > 0 && this.lastProgressiveSamples >= totalSamples * coverageThreshold) {
       transcript = { ...this.lastProgressiveResult, isFinal: true };
-      logger41.info("Using progressive result", {
+      logger43.info("Using progressive result", {
         coverage: (this.lastProgressiveSamples / totalSamples).toFixed(2),
         text: transcript.text
       });
     } else {
-      logger41.debug("Progressive result insufficient, running final transcription", {
+      logger43.debug("Progressive result insufficient, running final transcription", {
         samples: totalSamples,
         hadProgressive: !!this.lastProgressiveResult
       });
@@ -12759,7 +13152,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       return;
     }
     if (!transcript || !transcript.text.trim()) {
-      logger41.info("No transcript, resuming listening");
+      logger43.info("No transcript, resuming listening");
       turnSpan?.end();
       this.setState("listening");
       return;
@@ -12767,7 +13160,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     this.emit("transcript", transcript);
     getTelemetry()?.recordHistogram(
       MetricNames.VOICE_TURN_LATENCY,
-      performance.now() - turnStart,
+      getClock().now() - turnStart,
       { mode: this.isLocalMode ? "local" : "cloud" }
     );
     await this.callResponseHandler(transcript, capturedEpoch, turnSpan?.getContext());
@@ -12781,7 +13174,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
     const span = getTelemetry()?.startSpan("VoicePipeline.response", {
       "text.length": transcript.text.length
     }, parentContext);
-    const responseStart = performance.now();
+    const responseStart = getClock().now();
     this.setState("speaking");
     this.interruption?.setAISpeaking(true);
     if (transcript.emotion) {
@@ -12798,7 +13191,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
       }
       getTelemetry()?.recordHistogram(
         MetricNames.VOICE_RESPONSE_LATENCY,
-        performance.now() - responseStart,
+        getClock().now() - responseStart,
         { mode: this.isLocalMode ? "local" : "cloud" }
       );
       span?.end();
@@ -12808,8 +13201,9 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         return;
       }
       const err = error instanceof Error ? error : new Error(String(error));
+      span?.setAttributes({ "error.type": ErrorTypes.RUNTIME });
       span?.endWithError(err);
-      logger41.error("Response handler error", { message: err.message });
+      logger43.error("Response handler error", { message: err.message });
       this.emit("error", err);
       if (this.epoch === capturedEpoch && !this.stopped) {
         this.interruption?.setAISpeaking(false);
@@ -12880,11 +13274,11 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
   // ---------------------------------------------------------------------------
   handleInterruption() {
     if (this._state !== "speaking") return;
-    logger41.info("Interruption triggered");
+    logger43.info("Interruption triggered");
     getTelemetry()?.incrementCounter(MetricNames.VOICE_INTERRUPTIONS);
     this.epoch++;
     if (this.responseAbortController) {
-      logger41.debug("Aborting in-flight response");
+      logger43.debug("Aborting in-flight response");
     }
     this.responseAbortController?.abort();
     this.playback?.stop();
@@ -12922,7 +13316,15 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
             this.lastProgressiveSamples = snapshotSamples;
             this.emit("transcript", { ...result, isFinal: false });
           }
-        } catch {
+        } catch (err) {
+          this.progressiveErrorCount++;
+          if (this.progressiveErrorCount % 10 === 1) {
+            logger43.warn("Progressive transcription error", {
+              code: ErrorCodes.SPH_ASR_ERROR,
+              count: this.progressiveErrorCount,
+              error: String(err)
+            });
+          }
         }
       })();
     }, intervalMs);
@@ -12938,8 +13340,9 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
   // ---------------------------------------------------------------------------
   async transcribeWithTimeout(audio) {
     if (!this.asr) return null;
+    const currentEpoch = this.epoch;
     const timeoutMs = this.config.transcriptionTimeoutMs ?? 1e4;
-    const startTime = performance.now();
+    const startTime = getClock().now();
     const span = getTelemetry()?.startSpan("VoicePipeline.transcribe", {
       "inference.input_samples": audio.length,
       "inference.input_duration_ms": audio.length / 16e3 * 1e3
@@ -12953,7 +13356,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         })
       ]);
       clearTimeout(timeoutId);
-      const latency = performance.now() - startTime;
+      const latency = getClock().now() - startTime;
       this.asrErrorCount = 0;
       getTelemetry()?.recordHistogram(MetricNames.VOICE_TRANSCRIPTION_LATENCY, latency);
       getTelemetry()?.incrementCounter(MetricNames.VOICE_TRANSCRIPTIONS);
@@ -12967,14 +13370,18 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
         inferenceTimeMs: latency
       };
     } catch (error) {
+      span?.setAttributes({ "error.type": ErrorTypes.INFERENCE });
       span?.endWithError(error instanceof Error ? error : new Error(String(error)));
       this.asrErrorCount++;
-      logger41.warn("Transcription failed", {
+      logger43.warn("Transcription failed", {
         attempt: this.asrErrorCount,
         error: String(error)
       });
       if (this.asrErrorCount >= 3 && this.config.models) {
-        logger41.warn("3 consecutive ASR errors, recreating session");
+        if (this.epoch !== currentEpoch) return null;
+        logger43.warn("3 consecutive ASR errors, recreating session", {
+          code: ErrorCodes.SPH_ASR_ERROR
+        });
         try {
           await this.asr.dispose();
           this.asr = createSenseVoice({
@@ -12984,9 +13391,10 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
             unifiedWorker: this.unifiedWorker ?? void 0
           });
           await this.asr.load();
+          if (this.epoch !== currentEpoch) return null;
           this.asrErrorCount = 0;
         } catch (recreateErr) {
-          logger41.error("ASR session recreation failed", { error: String(recreateErr) });
+          logger43.error("ASR session recreation failed", { error: String(recreateErr) });
         }
       }
       return null;
@@ -13015,7 +13423,7 @@ var _VoicePipeline = class _VoicePipeline extends EventEmitter {
   // ---------------------------------------------------------------------------
   setState(state) {
     if (this._state === state) return;
-    logger41.info("State transition", { from: this._state, to: state });
+    logger43.info("State transition", { from: this._state, to: state });
     this._state = state;
     this.emit("state", state);
   }
@@ -13034,7 +13442,7 @@ _VoicePipeline.MAX_AUDIO_BUFFER_SAMPLES = 16e3 * 30;
 var VoicePipeline = _VoicePipeline;
 
 // src/orchestration/VoiceOrchestrator.ts
-var logger42 = createLogger("VoiceOrchestrator");
+var logger44 = createLogger("VoiceOrchestrator");
 var VoiceOrchestrator = class extends EventEmitter {
   constructor() {
     super(...arguments);
@@ -13084,7 +13492,7 @@ var VoiceOrchestrator = class extends EventEmitter {
     const epoch = ++this.connectEpoch;
     this._mode = config.mode ?? "local";
     this._sessionId = crypto.randomUUID();
-    logger42.info("Connecting voice orchestrator", { mode: this._mode });
+    logger44.info("Connecting voice orchestrator", { mode: this._mode });
     if (this._mode === "local") {
       const localCfg = config;
       this.ttsSpeaker = new TTSSpeaker();
@@ -13137,7 +13545,7 @@ var VoiceOrchestrator = class extends EventEmitter {
     } else {
       this.wireCloudTranscript(config);
     }
-    logger42.info("Voice orchestrator connected", { mode: this._mode });
+    logger44.info("Voice orchestrator connected", { mode: this._mode });
   }
   async disconnect() {
     this.connectEpoch++;
@@ -13251,7 +13659,7 @@ var VoiceOrchestrator = class extends EventEmitter {
           await this.speak(text);
         }
       } catch (e) {
-        logger42.error("Voice transcript handler error", { error: String(e) });
+        logger44.error("Voice transcript handler error", { error: String(e) });
       } finally {
         this.interruption?.setAISpeaking(false);
         this.speechListener?.resume();
@@ -13292,7 +13700,7 @@ var VoiceOrchestrator = class extends EventEmitter {
         });
       } catch (e) {
         if (!abortController.signal.aborted) {
-          logger42.error("Cloud response handler error", { error: String(e) });
+          logger44.error("Cloud response handler error", { error: String(e) });
         }
       } finally {
         this.responseAbortController = null;
@@ -13306,7 +13714,7 @@ var VoiceOrchestrator = class extends EventEmitter {
   // -------------------------------------------------------------------------
   handleInterruption() {
     if (this._state !== "speaking") return;
-    logger42.info("Interruption triggered");
+    logger44.info("Interruption triggered");
     this.stopSpeaking();
     this.speechListener?.resume();
     this.setState("listening");
@@ -13352,10 +13760,12 @@ export {
   EMOTION_TO_AU,
   EMOTION_VECTOR_SIZE,
   EXPLICIT_EMOTION_COUNT,
+  ElevenLabsTTSBackend,
   EmotionController,
   EmotionPresets,
   EmotionResolver,
   EmphasisDetector,
+  ErrorCodes,
   ErrorTypes,
   EventEmitter,
   FaceCompositor,
@@ -13379,6 +13789,7 @@ export {
   PRESERVE_POSITION_BONES,
   PROTOCOL_VERSION,
   PlaybackPipeline,
+  PollyTTSBackend,
   ProceduralLifeLayer,
   RingBuffer,
   SafariSpeechRecognition,
@@ -13402,6 +13813,7 @@ export {
   calculatePeak,
   calculateRMS,
   configureCacheLimit,
+  configureClock,
   configureLogging,
   configureModelUrls,
   configureOrtCdn,
@@ -13418,6 +13830,7 @@ export {
   formatBytes,
   getCacheConfig,
   getCacheKey,
+  getClock,
   getEmotionPreset,
   getLoggingConfig,
   getModelCache,