dsh-live-voice 0.7.0 → 0.7.2

package/lib/client.js

@@ -152,7 +152,7 @@ var SessionSpeechMemory = class {
 };
 
 // src/modules/recognition/vad/assets.ts
-var sileroVadAssetBase = () => "/api/dsh-live-voice/vad/" + encodeURIComponent(true ? "0.7.0" : "test") + "/";
+var sileroVadAssetBase = () => "/api/dsh-live-voice/vad/" + encodeURIComponent(true ? "0.7.2" : "test") + "/";
 async function sileroVadAvailable(fetchImpl = globalThis.fetch) {
   try {
     const response = await fetchImpl(sileroVadAssetBase() + "availability", {
@@ -458,7 +458,7 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
   let loading = captureLoads.get(context);
   if (!loading) {
     loading = context.audioWorklet.addModule(
-      sileroVadAssetBase() + "vad.capture.js?revision=finish-v1"
+      sileroVadAssetBase() + "vad.capture.js?revision=pause-v2"
     );
     captureLoads.set(context, loading);
     void loading.catch(() => {
@@ -477,6 +477,10 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
   let released = false;
   let acknowledged = false;
   let finishing;
+  let flushing;
+  let resolveFlush;
+  let rejectFlush;
+  let flushTimer;
   let resolveFinish;
   let rejectFinish;
   let failure2;
@@ -487,6 +491,8 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
     if (released) return;
     released = true;
     clearTimeout(timer);
+    clearTimeout(flushTimer);
+    rejectFlush?.(cancelled());
     unsubscribe();
     node.port.onmessage = null;
     node.onprocessorerror = null;
@@ -504,6 +510,8 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
     if (released) return;
     failure2 = error;
     rejectFinish?.(error);
+    rejectFlush?.(error);
+    rejectFlush = void 0;
     cleanup();
   };
   unsubscribe = stream.onInvalidated((error) => {
@@ -515,7 +523,15 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
   }
   node.port.onmessage = (event) => {
     if (released || stream.released) return;
-    if (event.data?.type === "stopped") {
+    if (event.data?.type === "flushed") {
+      clearTimeout(flushTimer);
+      void stream.flush().then(() => {
+        const done = resolveFlush;
+        resolveFlush = rejectFlush = void 0;
+        flushing = void 0;
+        done?.();
+      }, fail);
+    } else if (event.data?.type === "stopped") {
       if (!finishing || acknowledged) return;
       acknowledged = true;
       clearTimeout(timer);
@@ -556,6 +572,25 @@ async function attachSileroVadCapture(context, source, stream, onPcm) {
     throw error;
   }
   return {
+    resume() {
+      if (released || finishing) throw failure2 || cancelled();
+      node.port.postMessage({ type: "resume" });
+    },
+    flush(pause = false) {
+      if (flushing) return flushing;
+      if (released || stream.released || finishing) return Promise.reject(failure2 || cancelled());
+      flushing = new Promise((resolve, reject) => {
+        resolveFlush = resolve;
+        rejectFlush = reject;
+      });
+      flushTimer = setTimeout(() => fail(new Error("VAD capture flush timed out.")), 3e3);
+      try {
+        node.port.postMessage({ type: "flush", pause });
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error("VAD capture flush failed."));
+      }
+      return flushing;
+    },
     finish() {
       if (finishing) return finishing;
       if (released || stream.released) return finishing = Promise.reject(failure2 || cancelled());
@@ -2388,6 +2423,7 @@ async function startRecordingRecognition(engine, options, capture) {
     await writer.finish("interrupted");
     throw Object.assign(new Error("Cancelled"), { name: "AbortError" });
   }
+  let suspension = null;
   const session = {
     writer,
     detector: capture.silero ? "silero" : "energy",
@@ -2408,6 +2444,31 @@ async function startRecordingRecognition(engine, options, capture) {
     lang,
     operation: uid(),
     capturedSamples: 0,
+    captureSuspended: false,
+    suspendCapture: () => {
+      if (session.captureSuspended) return Promise.resolve(true);
+      if (suspension) return suspension;
+      if (session.finished || !valid()) return Promise.resolve(false);
+      suspension = (async () => {
+        await engine.meter.context.suspend();
+        if (!valid()) return false;
+        session.captureSuspended = true;
+        return true;
+      })().finally(() => {
+        suspension = null;
+      });
+      return suspension;
+    },
+    resumeCapture: async () => {
+      if (!session.captureSuspended) return true;
+      if (session.finished || !valid()) return false;
+      session.capture?.resume?.();
+      await engine.meter.context.resume();
+      if (!valid()) return false;
+      session.captureSuspended = false;
+      return true;
+    },
+    pauseForNavigation: async () => false,
     finishRecording: async () => {
     },
     stopRecording: async () => {
@@ -2502,10 +2563,10 @@ async function startRecordingRecognition(engine, options, capture) {
     queuedThrough = Math.max(queuedThrough, end);
     await releaseCapturedRanges();
   };
-  async function releaseCapturedRanges() {
+  async function releaseCapturedRanges(clampToCaptured = false) {
     if (!valid()) return;
     const captured = writer.session.capturedSamples;
-    while (awaitingTail.length && (session.finished || awaitingTail[0].endSample <= captured)) {
+    while (awaitingTail.length && (session.finished || clampToCaptured || awaitingTail[0].endSample <= captured)) {
       const pending = awaitingTail[0];
       const attempt = { ...pending, endSample: Math.min(pending.endSample, captured) };
       await writer.attempt(attempt);
@@ -2560,6 +2621,15 @@ async function startRecordingRecognition(engine, options, capture) {
     }
   });
   session.pinDetector = detector;
+  session.pauseForNavigation = async () => {
+    if (suspension) await suspension;
+    if (!session.captureSuspended) await session.capture?.flush?.(true);
+    if (!await session.suspendCapture() || !valid()) return false;
+    detector.finish();
+    await session.tail;
+    await serialize(() => releaseCapturedRanges(true), false, true);
+    return valid();
+  };
   async function drain() {
     if (session.draining || !valid()) return;
     session.draining = true;
@@ -2829,7 +2899,7 @@ async function startRecordingRecognition(engine, options, capture) {
     awaitingTail.length = 0;
     await recovering;
     session.activeRequest?.abort();
-    if (session.finishing) session.capture?.release();
+    if (session.finishing || session.captureSuspended) session.capture?.release();
     else {
       try {
         await session.capture?.finish();
@@ -3065,6 +3135,18 @@ var WhisperHttpRecognitionEngine = class {
   finish() {
     return this.session?.finishRecording() ?? Promise.resolve();
   }
+  get captureSuspended() {
+    return this.session?.captureSuspended === true;
+  }
+  suspendCapture() {
+    return this.session?.suspendCapture() ?? Promise.resolve(false);
+  }
+  resumeCapture() {
+    return this.session?.resumeCapture() ?? Promise.resolve(false);
+  }
+  pauseForNavigation() {
+    return this.session?.pauseForNavigation() ?? Promise.resolve(false);
+  }
   async stop() {
     this.startGeneration = (this.startGeneration || 0) + 1;
     const session = this.session;
@@ -3425,7 +3507,7 @@ async function removeBrowserModel(key, storage = caches) {
 }
 
 // src/modules/recognition/local/assets.ts
-var browserAsrAssetBase = () => "/api/dsh-live-voice/asr/" + encodeURIComponent(true ? "0.7.0" : "test") + "/";
+var browserAsrAssetBase = () => "/api/dsh-live-voice/asr/" + encodeURIComponent(true ? "0.7.2" : "test") + "/";
 
 // src/modules/recognition/local/runtimeIdentity.ts
 var workerProtocol = "asr-worker-v3-ort-1.31.0-dev.20260914-8d85527a0";
@@ -10258,6 +10340,9 @@ var VoiceCoordinator = class _VoiceCoordinator {
     this.unfinished = /* @__PURE__ */ new Set();
     this.suppressed = /* @__PURE__ */ new Set();
     this.inputTail = Promise.resolve();
+    this.navigationPaused = false;
+    this.navigationEpoch = 0;
+    this.navigationResults = [];
     this.speechBarrier = Promise.resolve();
     this.disposed = false;
     this.inputReleaseError = null;
@@ -10502,6 +10587,10 @@ var VoiceCoordinator = class _VoiceCoordinator {
     });
   }
   _recoverInput(error) {
+    if (this.navigationPaused) {
+      this.patch({ inputError: message(error), error: message(error) });
+      return;
+    }
     const attempt = this.inputRecoveryAttempt || 0;
     const retry = !this.inputReleaseError && isRetryableVoiceError(error) && attempt < MAX_RECOVERY_ATTEMPTS;
     const generation = (this.inputRecoveryGeneration || 0) + 1;
@@ -10566,6 +10655,23 @@ var VoiceCoordinator = class _VoiceCoordinator {
     });
     return result;
   }
+  async _suspendInputCapture() {
+    return this._input(async () => {
+      if (!this.snapshot.listening || typeof this.recognition.suspendCapture !== "function")
+        return false;
+      return await this.recognition.suspendCapture() !== false;
+    });
+  }
+  async _resumeInputCapture(valid = () => true) {
+    return this._input(async () => {
+      if (!valid() || !this.snapshot.listening || typeof this.recognition.resumeCapture !== "function")
+        return false;
+      return await this.recognition.resumeCapture() !== false;
+    });
+  }
+  _hasSuspendedInputCapture() {
+    return this.snapshot.listening && this.recognition.captureSuspended === true;
+  }
   async _releaseInput() {
     const recognitionResult = await Promise.resolve().then(() => this.recognition.stop()).then(
       () => ({ status: "fulfilled" }),
@@ -10874,8 +10980,19 @@ var VoiceCoordinator = class _VoiceCoordinator {
       void this.resumeSpeech();
     }, this.snapshot.settings.assistantSpeechDelaySeconds * 1e3);
   }
-  onResult({ final = "", interim = "", startedAt, paragraphBefore = false, onCommandRecognized }) {
+  onResult(result) {
+    const {
+      final = "",
+      interim = "",
+      startedAt,
+      paragraphBefore = false,
+      onCommandRecognized
+    } = result;
     if (this.disposed || !this.snapshot.listening && !this.snapshot.starting) return;
+    if (this.navigationPaused) {
+      if (final) this.navigationResults.push(result);
+      return;
+    }
     const recognizing = this.recognition.activityManaged ? this.snapshot.recognizing : !!interim;
     if (this.snapshot.speaking && !this.snapshot.paused && this.snapshot.settings.mode === "speaker")
       return;
@@ -10960,7 +11077,7 @@ var VoiceCoordinator = class _VoiceCoordinator {
     return this.snapshot.pendingDeliveryTranscriptions ?? this.snapshot.pendingTranscriptions;
   }
   maybeScheduleAutoSend(draft = this.autoSendIntent) {
-    if (draft == null || draft !== this.composer.getDraft()) return;
+    if (this.navigationPaused || draft == null || draft !== this.composer.getDraft()) return;
     if (this.autoSendTimer !== null) return;
     if (this.snapshot.settings.sendingMode === "manual" || this.snapshot.muted || this.composer.canAutoSend?.() === false || this.snapshot.recognizing || this.deliveryPending() > 0)
       return;
@@ -11015,6 +11132,9 @@ var VoiceCoordinator = class _VoiceCoordinator {
     if (this.autoSendIntent != null && draft !== this.autoSendIntent) this.cancelAutoSend();
   }
   stopListening() {
+    ++this.navigationEpoch;
+    this.navigationPaused = false;
+    this.navigationResults = [];
     this._cancelRecovery("input");
     this.holdToTalkRelease = false;
     this.cancelAutoSend();
@@ -11160,11 +11280,64 @@ var VoiceCoordinator = class _VoiceCoordinator {
     this.patch({ paused: checkpoint.paused && this.queue.length > 0 });
     this._syncSpeechSegments();
   }
-  async suspendSpeech() {
+  async pauseInputForNavigation() {
+    if (!this.snapshot.listening || typeof this.recognition.pauseForNavigation !== "function")
+      return false;
+    const generation = ++this.navigationEpoch;
+    this.navigationPaused = true;
+    this.cancelAutoSend();
+    try {
+      const paused = await this._input(() => this.recognition.pauseForNavigation());
+      if (!paused) throw new Error("Microphone capture could not be paused safely.");
+      return true;
+    } catch (error) {
+      if (generation !== this.navigationEpoch || this.disposed) return false;
+      try {
+        await this._input(() => this._releaseInput());
+        this.inputReleaseError = null;
+      } catch (cleanup) {
+        this.inputReleaseError = cleanup;
+        this.patch({ inputError: message(cleanup), error: message(cleanup) });
+        throw cleanup;
+      }
+      if (generation !== this.navigationEpoch || this.disposed) return false;
+      this.patch({
+        listening: false,
+        starting: false,
+        recognizing: false,
+        inputError: message(error),
+        error: message(error)
+      });
+      return false;
+    }
+  }
+  async resumeInputFromNavigation() {
+    if (!this.navigationPaused || this.disposed) return false;
+    const generation = this.navigationEpoch;
+    if (!this.snapshot.listening) {
+      const queued = this.navigationResults.splice(0);
+      this.navigationPaused = false;
+      await this._startInput(this.snapshot.conversation);
+      if (this.disposed || generation !== this.navigationEpoch) return false;
+      if (!this.snapshot.listening) {
+        this.navigationPaused = true;
+        this.navigationResults.unshift(...queued);
+        return false;
+      }
+      for (const result of queued) this.onResult(result);
+      return true;
+    }
+    const resumed = await this._input(() => this.recognition.resumeCapture());
+    if (!resumed || this.disposed || generation !== this.navigationEpoch) return false;
+    this.navigationPaused = false;
+    for (const result of this.navigationResults.splice(0)) this.onResult(result);
+    return true;
+  }
+  async suspendSpeech(preserveInput = false) {
     this.speechSuspended = true;
     await Promise.all([
       _VoiceCoordinator.prototype.stopSpeech.call(this, false),
-      this.stopListening()
+      preserveInput ? this.pauseInputForNavigation() : this.stopListening()
     ]);
   }
   discardSpeechMessage(id) {
@@ -11232,6 +11405,13 @@ var VoiceCoordinator = class _VoiceCoordinator {
       if (epoch === this.speechEpoch) this.patch({ error: message(error) });
       return;
     }
+    if (epoch === this.speechEpoch && !this.disposed && resumeListening && !this.navigationPaused && this.snapshot.settings.mode === "speaker" && this._hasSuspendedInputCapture()) {
+      try {
+        await this._resumeInputCapture();
+      } catch (error) {
+        this.patch({ inputError: message(error), error: message(error) });
+      }
+    }
     if (epoch === this.speechEpoch && !this.disposed && resumeListening && !this.snapshot.inputRecovery && this.snapshot.conversation && !this.snapshot.listening && !this.snapshot.starting)
       await this._startInput(true);
   }
@@ -11278,22 +11458,53 @@ var VoiceCoordinator = class _VoiceCoordinator {
   getSpeechProgress() {
     return this.engines[this.snapshot.speechEngine]?.getPlaybackProgress?.() ?? null;
   }
+  async _restorePausedSpeechInput(epoch, control) {
+    const valid = () => !this.disposed && !this.navigationPaused && epoch === this.speechEpoch && control === this.controlEpoch && this.snapshot.paused && this.snapshot.settings.mode === "speaker";
+    if (!valid()) return;
+    try {
+      if (this._hasSuspendedInputCapture()) {
+        await this._resumeInputCapture(valid);
+      } else if (this.snapshot.conversation && !this.snapshot.listening && !this.snapshot.starting && !this.snapshot.inputRecovery) {
+        await this._startInput(true);
+      }
+    } catch (error) {
+      if (valid()) this.patch({ inputError: message(error), error: message(error) });
+    }
+  }
+  async _gateResumedSpeechInput() {
+    if (this.snapshot.settings.mode !== "speaker") return;
+    const suspended = await this._suspendInputCapture();
+    if (!suspended) {
+      await this.stopListening();
+      if (this.inputReleaseError) throw this.inputReleaseError;
+    }
+  }
   async pauseSpeech(automatic = false) {
     if (this.snapshot.speechRecovery?.retrying) this._cancelRecovery("speech", true);
     if (!automatic) {
       this._cancelInterruptionResume();
       this.interruptionPausedSpeech = false;
     }
-    if (this.disposed || this.snapshot.paused) return;
+    if (this.disposed) return;
+    if (this.snapshot.paused) {
+      const epoch2 = this.speechEpoch;
+      const control2 = ++this.controlEpoch;
+      await this.inputTail;
+      await this._restorePausedSpeechInput(epoch2, control2);
+      return;
+    }
     if (!this.snapshot.speaking && this.snapshot.speechRunActive) {
       this._cancelAssistantSpeechTimer();
+      const control2 = ++this.controlEpoch;
       this.patch({ paused: true });
+      await this._restorePausedSpeechInput(this.speechEpoch, control2);
       return;
     }
     if (!this.snapshot.speaking) return;
     if (this.speechLaunchPending) {
-      ++this.controlEpoch;
+      const control2 = ++this.controlEpoch;
       this.patch({ paused: true });
+      await this._restorePausedSpeechInput(this.speechEpoch, control2);
       return;
     }
     const epoch = this.speechEpoch;
@@ -11304,6 +11515,7 @@ var VoiceCoordinator = class _VoiceCoordinator {
       if (epoch === this.speechEpoch && control === this.controlEpoch && this.snapshot.speaking && result !== false) {
         this.patch({ paused: true });
         this.activeRecordingTimeline?.("assistant-pause");
+        await this._restorePausedSpeechInput(epoch, control);
       }
     } catch (error) {
       if (epoch === this.speechEpoch) this.patch({ error: message(error) });
@@ -11323,12 +11535,11 @@ var VoiceCoordinator = class _VoiceCoordinator {
     if (this.speechLaunchPending) {
       const epoch2 = this.speechEpoch;
       const control2 = ++this.controlEpoch;
-      if (this.snapshot.settings.mode === "speaker") {
-        await this.stopListening();
-        if (this.inputReleaseError) {
-          this.patch({ error: message(this.inputReleaseError) });
-          return;
-        }
+      try {
+        await this._gateResumedSpeechInput();
+      } catch (error) {
+        if (epoch2 === this.speechEpoch) this.patch({ error: message(error) });
+        return;
       }
       if (epoch2 === this.speechEpoch && control2 === this.controlEpoch)
         this.patch({ paused: false });
@@ -11337,19 +11548,19 @@ var VoiceCoordinator = class _VoiceCoordinator {
     const epoch = this.speechEpoch;
     const control = ++this.controlEpoch;
     try {
-      if (this.snapshot.settings.mode === "speaker") {
-        await this.stopListening();
-        if (this.inputReleaseError) throw this.inputReleaseError;
-      }
+      await this._gateResumedSpeechInput();
       if (epoch !== this.speechEpoch || control !== this.controlEpoch) return;
       const result = await this.engines[this.snapshot.speechEngine || this.snapshot.settings.engine].resume();
       if (epoch === this.speechEpoch && control === this.controlEpoch && result !== false) {
         this.patch({ paused: false });
         this.activeRecordingTimeline?.("assistant-resume");
         this._prefetchSpeech();
+      } else {
+        await this._restorePausedSpeechInput(epoch, control);
       }
     } catch (error) {
       if (epoch === this.speechEpoch) this.patch({ error: message(error) });
+      await this._restorePausedSpeechInput(epoch, control);
     }
   }
   async speak(text, messageId = null) {
@@ -11429,15 +11640,22 @@ var VoiceCoordinator = class _VoiceCoordinator {
       if (epoch !== this.speechEpoch || this.disposed) return;
       if (this.snapshot.settings.mode === "speaker") {
         const gating = this.snapshot.listening;
+        const persistentCapture = typeof this.recognition.suspendCapture === "function";
         if (gating) timeline?.("capture-gated");
-        await this.stopListening();
-        if (this.inputReleaseError) {
+        try {
+          const suspended = persistentCapture ? await this._suspendInputCapture() : false;
+          if (gating && !suspended) {
+            await this.stopListening();
+            if (this.inputReleaseError) throw this.inputReleaseError;
+          }
+        } catch (error) {
           if (gating) timeline?.("capture-gate-failed");
-          throw this.inputReleaseError;
+          throw error;
         }
         if (gating) timeline?.("input-stop-complete");
       }
       if (epoch !== this.speechEpoch || this.disposed) return;
+      if (this.snapshot.paused) await this._restorePausedSpeechInput(epoch, this.controlEpoch);
       const queued = item;
       if (queued?.preparing) await queued.preparing;
       if (epoch !== this.speechEpoch || this.disposed) return;
@@ -11552,6 +11770,12 @@ var VoiceCoordinator = class _VoiceCoordinator {
           this.assistantSpeechDelayReason = "segment-gap";
           this.assistantSpeechNotBefore = Date.now() + this.snapshot.settings.segmentGapMs;
           this._drain();
+        } else if (this.snapshot.settings.mode === "speaker" && this.snapshot.listening) {
+          try {
+            await this._resumeInputCapture();
+          } catch (error) {
+            this.patch({ inputError: message(error), error: message(error) });
+          }
         } else if (this.snapshot.conversation && !this.snapshot.inputRecovery && !this.snapshot.listening && !this.snapshot.starting)
           await this._startInput(true);
       }
@@ -11664,16 +11888,16 @@ var VoiceCoordinator = class _VoiceCoordinator {
     if (boundary <= 0) return;
     if (!complete && hasIncompleteSpeechMarkdown(remaining.slice(0, boundary))) return;
     if (hasUnclosedCodeFence(remaining.slice(0, boundary)) && !complete) return;
-    const chunk = filterSpeechOutput(remaining.slice(0, boundary).trim(), {
+    const segments = splitSpeechOutput(remaining.slice(0, boundary).trim(), {
       filterCodeBlocks: this.snapshot.settings.outputCodeFilterEnabled,
       codeBlockMaxLines: this.snapshot.settings.outputCodeMaxLines,
       codeBlockNotice: this.snapshot.settings.outputCodeNotice,
       lang: this.snapshot.settings.lang
-    }).trim();
+    });
     this.consumed.set(id, offset + boundary);
-    if (chunk) {
+    if (segments.length) {
       const initial = !this.snapshot.speaking && !this.queue.some((item) => item.prepared);
-      const parts = initial ? splitInitialSpeechItem(chunk) : [chunk];
+      const parts = initial ? [...splitInitialSpeechItem(segments[0]), ...segments.slice(1)] : segments;
       this.queue.push(...parts.map((text2) => ({ text: text2, id })));
       this._prefetchSpeech();
       this._syncSpeechSegments();
@@ -11834,13 +12058,11 @@ var MeetingController = class {
     for (const input of this.inputs.values()) input.cancelAutoSend();
   }
   composerReplaced() {
+    for (const [source, job] of this.jobs) {
+      const state = this.snapshot[source];
+      job.discardResults = (Number.isSafeInteger(state?.pendingTranscriptionRequests) ? state.pendingTranscriptionRequests : state?.pending || 0) || (state?.recognizing ? 1 : 0);
+    }
     this.cancelDelivery();
-    const job = this.jobs.get("shared");
-    if (!job || !job.recognitionAbort) return;
-    job.recognitionAbort.abort();
-    if (this.sharedTrackLive(job)) this.queueRecognitionRecovery("shared", job);
-    else void this.stop("shared").catch(() => {
-    });
   }
   toggleTimestamps() {
     const enabled = !this.snapshot.timestamps;
@@ -11864,7 +12086,7 @@ var MeetingController = class {
     }
     this.patch(null, { active: true });
     const abort = new AbortController();
-    const job = { abort };
+    const job = { abort, discardResults: 0 };
     this.jobs.set(source, job);
     const valid = () => this.jobs.get(source) === job && !abort.signal.aborted;
     this.patch(source, { starting: true, error: null });
@@ -11934,6 +12156,10 @@ var MeetingController = class {
         signal: recognitionAbort.signal,
         onResult: ({ final, interim, startedAt, paragraphBefore }) => {
           if (!valid()) return;
+          if (job.discardResults > 0) {
+            job.discardResults--;
+            return;
+          }
           if (final?.trim()) job.retries = 0;
           const accepted = this.onSpeech?.(source, final || interim) !== false;
           if (accepted)
@@ -12770,7 +12996,6 @@ var AttendeeClient = class {
     this.queues.set(source, work);
   }
   async audio(event, generation) {
-    if (this.canDeliver && !this.canDeliver()) throw new Error("no-composer");
     const source = "attendee:" + event.botId + ":" + event.participantId;
     let row = this.rows.get(source);
     if (!row) {
@@ -14576,8 +14801,8 @@ function createDeviceOptions(devices, kind, systemDefault, fallback) {
 var import_react39 = __toESM(require("react"), 1);
 
 // src/modules/settings/services/releases.ts
-var CURRENT_VERSION = "0.7.0";
-var TESTED_DSH_VERSION = "0.2.2-alpha.2";
+var CURRENT_VERSION = "0.7.2";
+var TESTED_DSH_VERSION = "0.2.2-rc.1";
 var REPOSITORY_URL = "https://github.com/victorwads/dsh-live-voice";
 var RELEASES_URL = `${REPOSITORY_URL}/releases`;
 var LATEST_RELEASE_API_URL = "https://api.github.com/repos/victorwads/dsh-live-voice/releases/latest";
@@ -17674,7 +17899,9 @@ function apply(ctx) {
       entry.speechState.checkpoint = entry.controller.checkpointSpeech();
     entry.speechAttached = false;
     ++entry.speechRequest;
-    const stopped = entry.controller.suspendSpeech();
+    const preserveInput = entry.controller.snapshot.conversation && entry.controller.snapshot.listening && typeof entry.controller.recognition.pauseForNavigation === "function";
+    entry.parkedInput = preserveInput;
+    const stopped = entry.controller.suspendSpeech(preserveInput);
     entry.speechRelease = Promise.resolve(stopped).then(() => {
       if (entry.controller.speechStopError) throw entry.controller.speechStopError;
       if (entry.controller.inputReleaseError) throw entry.controller.inputReleaseError;
@@ -17694,6 +17921,13 @@ function apply(ctx) {
       await entry.speechRelease;
       if (disposed || entry.closed || !entry.speechAttached || request !== entry.speechRequest)
         return;
+      if (entry.parkedInput) {
+        const resumed = await entry.controller.resumeInputFromNavigation();
+        if (disposed || entry.closed || !entry.speechAttached || request !== entry.speechRequest)
+          return;
+        if (!resumed) throw new Error("The paused microphone recording could not resume.");
+        entry.parkedInput = false;
+      }
       entry.controller.restoreSpeech(entry.speechState.checkpoint);
       entry.speechState.checkpoint = null;
       entry.refreshSpeech(!entry.speechState.attached);
@@ -17704,6 +17938,7 @@ function apply(ctx) {
   function retire(entry) {
     if (entry.closed) return;
     suspendSessionSpeech(entry);
+    if (entry.parkedInput && !disposed) return;
     entry.closed = true;
     if (meetingEntry === entry) {
       void meeting.attendee.stop();
@@ -17878,7 +18113,7 @@ function apply(ctx) {
       entry.chatListeners.add(listener);
       return () => entry.chatListeners.delete(listener);
     };
-    entry.readChat = entry.chat.getSnapshot.bind(entry.chat);
+    entry.readChat = () => entry.chat.getSnapshot();
     const refresh = (reset = false) => {
       if (disposed || entry.closed) return;
       const snapshot = entry.readChat();
@@ -17906,10 +18141,20 @@ function apply(ctx) {
     };
     entry.refreshSpeech = refresh;
     refresh();
-    entry.unsubscribe = entry.chat.subscribe(() => {
+    const publishChat = () => {
       refresh();
       for (const listener of entry.chatListeners) listener();
-    });
+    };
+    entry.unsubscribe = entry.chat.subscribe(publishChat);
+    entry.reconnectChat = () => {
+      if (disposed || entry.closed) return;
+      const chat = ctx.uiConversation.binding(sessionId).target("chat");
+      if (chat === entry.chat) return;
+      entry.unsubscribe?.();
+      entry.chat = chat;
+      entry.unsubscribe = chat.subscribe(publishChat);
+      publishChat();
+    };
     const pendingInteractions = ctx.uiSession.pendingInteractions;
     const refreshPendingQuestion = (baseline = false) => {
       if (disposed || entry.closed || !pendingInteractions) return;
@@ -17941,7 +18186,7 @@ function apply(ctx) {
       const before = controller.getSnapshot();
       update(next);
       const settings2 = controller.getSnapshot().settings;
-      if ([...recognitionSettingKeys].some((key2) => before.settings[key2] !== settings2[key2])) {
+      if (!entry.parkedInput && [...recognitionSettingKeys].some((key2) => before.settings[key2] !== settings2[key2])) {
         if (!entry.restoreInput) entry.inputRestoreRequest = entry.request;
         entry.restoreInput ||= Boolean(before.listening || before.starting);
         const revision = entry.inputSettingsRevision = (entry.inputSettingsRevision || 0) + 1;
@@ -17983,6 +18228,7 @@ function apply(ctx) {
       const original = controller[method].bind(controller);
       controller[method] = (...args) => {
         if (method === "endConversation" && args[0] === true && !entry.speechAttached) {
+          if (entry.parkedInput) return entry.speechRelease ?? Promise.resolve();
           controller.patch({ conversation: false });
           return Promise.all([
             controller.stopListening(),
@@ -18004,6 +18250,7 @@ function apply(ctx) {
           }
         }
         entry.request++;
+        if (method !== "stopSpeech") entry.parkedInput = false;
         if (method === "endConversation" && args[0] !== true || method === "stopConversationInput")
           voiceModeActive = false;
         const result = original(...args);
@@ -18084,6 +18331,7 @@ function apply(ctx) {
     import_react75.default.useLayoutEffect(() => {
       if (disposed) return;
       const current = get(sessionId);
+      current.reconnectChat();
       current.refs++;
       if (kind === "buttons") current.buttons++;
       setEntry(current);
@@ -18108,7 +18356,6 @@ function apply(ctx) {
         entry.composers.delete(token.current);
         if (!entry.composers.size) suspendSessionSpeech(entry);
         if (meetingEntry === entry && !entry.composers.size) {
-          void meeting.attendee.stop();
           meeting.composerReplaced();
           meetingEntry = null;
           meeting.transcript.setActive("microphone", false);
@@ -18119,10 +18366,7 @@ function apply(ctx) {
       if (!entry || entry.closed || disposed) return;
       if (!input || typeof props.inputActions?.setDraft !== "function") return;
       if (meetingEntry !== entry) {
-        if (meetingEntry) {
-          void meeting.attendee.stop();
-          suspendSessionSpeech(meetingEntry);
-        }
+        if (meetingEntry) suspendSessionSpeech(meetingEntry);
         meeting.composerReplaced();
         meetingEntry = entry;
         entry.controller.setExternalSpeechActivity(sharedSpeechActive);
@@ -18154,7 +18398,7 @@ function apply(ctx) {
       });
       const attachSpeech = !entry.speechAttached;
       if (attachSpeech) entry.speechAttached = true;
-      const inputReady = voiceModeActive && !entry.controller.getSnapshot().conversation ? entry.controller.startConversation() : Promise.resolve();
+      const inputReady = !entry.parkedInput && voiceModeActive && !entry.controller.getSnapshot().conversation ? entry.controller.startConversation() : Promise.resolve();
       run(
         entry.controller,
         Promise.resolve(inputReady).then(() => {