dsh-live-voice 0.7.0 → 0.7.2

package/src/modules/core/coordinator.ts

@@ -4,7 +4,6 @@ import { TranscriptDraft } from './transcript.ts';
 import { normalizeSettings } from './settings.ts';
 import { SPEECH_QUEUE_PREFETCH_LIMIT } from '../speak/services/speechQueue.js';
 import {
-  filterSpeechOutput,
   hasMinimumWords,
   hasUnclosedCodeFence,
   hasIncompleteSpeechMarkdown,
@@ -62,6 +61,9 @@ export class VoiceCoordinator {
     this.unfinished = new Set();
     this.suppressed = new Set();
     this.inputTail = Promise.resolve();
+    this.navigationPaused = false;
+    this.navigationEpoch = 0;
+    this.navigationResults = [];
     this.speechBarrier = Promise.resolve();
     this.disposed = false;
     this.inputReleaseError = null;
@@ -325,6 +327,12 @@ export class VoiceCoordinator {
     });
   }
   _recoverInput(error) {
+    if (this.navigationPaused) {
+      // Keep the recording and remaining STT queue; only an attached chat may
+      // decide to retry or replace its capture resources.
+      this.patch({ inputError: message(error), error: message(error) });
+      return;
+    }
     const attempt = this.inputRecoveryAttempt || 0;
     const retry =
       !this.inputReleaseError && isRetryableVoiceError(error) && attempt < MAX_RECOVERY_ATTEMPTS;
@@ -393,6 +401,27 @@ export class VoiceCoordinator {
     this.inputTail = result.catch(() => {});
     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() {
     // Drain recorder-owned worklet buffers while its context/source still exist.
     const recognitionResult = await Promise.resolve()
@@ -769,8 +798,19 @@ export class VoiceCoordinator {
     }, this.snapshot.settings.assistantSpeechDelaySeconds * 1000);
   }
 
-  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 &&
@@ -885,7 +925,7 @@ export 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' ||
@@ -968,6 +1008,9 @@ export 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();
@@ -1135,11 +1178,69 @@ export 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;
+      // A failed pause must not leave a failed input ownership barrier forever.
+      // Release hardware before another chat can acquire it; preserve already
+      // completed results for the original composer.
+      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) {
+      // The prior capture could not be paused and was released safely. A fresh
+      // capture is permitted only after the user returns to this chat.
+      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) {
@@ -1206,6 +1307,20 @@ export 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 &&
@@ -1259,23 +1374,67 @@ export 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;
+    // Preserve recording-backed capture; native engines retain safe stop/restart.
+    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) {
+      // Reaffirming pause invalidates a resume whose capture gate is still pending.
+      const epoch = this.speechEpoch;
+      const control = ++this.controlEpoch;
+      await this.inputTail;
+      await this._restorePausedSpeechInput(epoch, control);
+      return;
+    }
     if (!this.snapshot.speaking && this.snapshot.speechRunActive) {
       this._cancelAssistantSpeechTimer();
+      const control = ++this.controlEpoch;
       this.patch({ paused: true });
+      await this._restorePausedSpeechInput(this.speechEpoch, control);
       return;
     }
     if (!this.snapshot.speaking) return;
     if (this.speechLaunchPending) {
       // Preparation has no player to pause yet; retain an explicit launch gate.
-      ++this.controlEpoch;
+      const control = ++this.controlEpoch;
       this.patch({ paused: true });
+      await this._restorePausedSpeechInput(this.speechEpoch, control);
       return;
     }
     const epoch = this.speechEpoch;
@@ -1292,6 +1451,7 @@ export class VoiceCoordinator {
       ) {
         this.patch({ paused: true });
         this.activeRecordingTimeline?.('assistant-pause');
+        await this._restorePausedSpeechInput(epoch, control);
       }
     } catch (error) {
       if (epoch === this.speechEpoch) this.patch({ error: message(error) });
@@ -1311,12 +1471,11 @@ export class VoiceCoordinator {
     if (this.speechLaunchPending) {
       const epoch = this.speechEpoch;
       const control = ++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 (epoch === this.speechEpoch) this.patch({ error: message(error) });
+        return;
       }
       if (epoch === this.speechEpoch && control === this.controlEpoch)
         this.patch({ paused: false });
@@ -1325,10 +1484,7 @@ export 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();
@@ -1336,9 +1492,12 @@ export class VoiceCoordinator {
         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) {
@@ -1422,15 +1581,23 @@ export 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;
+      // A pause can arrive while the initial capture gate is still settling.
+      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;
@@ -1572,6 +1739,12 @@ export 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 &&
@@ -1712,16 +1885,18 @@ export 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((text) => ({ text, id })));
       this._prefetchSpeech();
       this._syncSpeechSegments();

package/src/modules/recognition/engines/whisper/WhisperRecognitionEngine.ts

@@ -174,6 +174,18 @@ export class WhisperHttpRecognitionEngine {
   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;

package/src/modules/recognition/vad/SileroVadRuntime.ts

@@ -364,13 +364,18 @@ export async function attachSileroVadCapture(
   source: AudioNode,
   stream: SileroVadStream,
   onPcm?: (pcm: Float32Array, sampleRate: number) => void,
-): Promise<{ finish(): Promise<void>; release(): void }> {
+): Promise<{
+  finish(): Promise<void>;
+  flush(pause?: boolean): Promise<void>;
+  resume(): void;
+  release(): void;
+}> {
   if (!context.audioWorklet || typeof AudioWorkletNode !== 'function')
     throw new Error('AudioWorklet PCM capture is unavailable.');
   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(() => {
@@ -389,6 +394,10 @@ export async function attachSileroVadCapture(
   let released = false;
   let acknowledged = false;
   let finishing: Promise<void> | undefined;
+  let flushing: Promise<void> | undefined;
+  let resolveFlush: (() => void) | undefined;
+  let rejectFlush: ((error: Error) => void) | undefined;
+  let flushTimer: ReturnType<typeof setTimeout> | undefined;
   let resolveFinish: (() => void) | undefined;
   let rejectFinish: ((error: Error) => void) | undefined;
   let failure: Error | undefined;
@@ -398,6 +407,8 @@ export async function attachSileroVadCapture(
     if (released) return;
     released = true;
     clearTimeout(timer);
+    clearTimeout(flushTimer);
+    rejectFlush?.(cancelled());
     unsubscribe();
     node.port.onmessage = null;
     node.onprocessorerror = null;
@@ -415,6 +426,8 @@ export async function attachSileroVadCapture(
     if (released) return;
     failure = error;
     rejectFinish?.(error);
+    rejectFlush?.(error);
+    rejectFlush = undefined;
     cleanup();
   };
   unsubscribe = stream.onInvalidated((error) => {
@@ -427,7 +440,15 @@ export async function attachSileroVadCapture(
   }
   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 = undefined;
+        flushing = undefined;
+        done?.();
+      }, fail);
+    } else if (event.data?.type === 'stopped') {
       if (!finishing || acknowledged) return;
       acknowledged = true;
       clearTimeout(timer);
@@ -469,6 +490,25 @@ export async function attachSileroVadCapture(
     throw error;
   }
   return {
+    resume() {
+      if (released || finishing) throw failure || cancelled();
+      node.port.postMessage({ type: 'resume' });
+    },
+    flush(pause = false) {
+      if (flushing) return flushing;
+      if (released || stream.released || finishing) return Promise.reject(failure || cancelled());
+      flushing = new Promise<void>((resolve, reject) => {
+        resolveFlush = resolve;
+        rejectFlush = reject;
+      });
+      flushTimer = setTimeout(() => fail(new Error('VAD capture flush timed out.')), 3000);
+      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(failure || cancelled()));

package/src/modules/recognition/vad/vad.capture.ts

@@ -6,11 +6,22 @@ declare class AudioWorkletProcessor {
 declare function registerProcessor(name: string, processor: typeof AudioWorkletProcessor): void;
 class VadCaptureProcessor extends AudioWorkletProcessor {
   private stopped = false;
+  private paused = false;
   private pcm = new Float32Array(2048);
   private at = 0;
   constructor() {
     super();
     this.port.onmessage = (event) => {
+      if (event.data?.type === 'resume') this.paused = false;
+      if (event.data?.type === 'flush') {
+        if (event.data.pause) this.paused = true;
+        if (this.at) {
+          const pcm = this.pcm.slice(0, this.at);
+          this.port.postMessage({ pcm, sampleRate }, [pcm.buffer]);
+          this.at = 0;
+        }
+        this.port.postMessage({ type: 'flushed' });
+      }
       if (event.data?.type === 'stop') {
         this.stopped = true;
         if (event.data.drain && this.at) {
@@ -25,6 +36,7 @@ class VadCaptureProcessor extends AudioWorkletProcessor {
   process(inputs: Float32Array[][], outputs: Float32Array[][]): boolean {
     for (const channels of outputs) for (const channel of channels) channel.fill(0);
     if (this.stopped) return false;
+    if (this.paused) return true;
     const input = inputs[0];
     if (!input?.length) return true;
     for (let i = 0; i < input[0].length; i++) {

package/src/modules/recording/RecordingRecognition.ts

@@ -10,7 +10,12 @@ import type {
   RecordingVoiceCommand,
 } from './types.js';
 import type { SileroVadOptions, SileroVadStream } from '../recognition/vad/SileroVadRuntime.js';
-type CaptureHandle = { finish(): Promise<void>; release(): void };
+type CaptureHandle = {
+  finish(): Promise<void>;
+  flush?(pause?: boolean): Promise<void>;
+  resume?(): void;
+  release(): void;
+};
 type Processing = {
   queued: number;
   active: boolean;
@@ -75,6 +80,8 @@ interface RecordingEngine {
     stream: SileroVadStream,
     onPcm: (pcm: Float32Array, rate: number) => void,
   ): Promise<CaptureHandle>;
+  suspendCapture?(): Promise<boolean>;
+  resumeCapture?(): Promise<boolean>;
   stop(): Promise<void>;
 }
 interface RecognitionSession {
@@ -97,6 +104,10 @@ interface RecognitionSession {
   lang: string;
   operation: string;
   capturedSamples: number;
+  captureSuspended: boolean;
+  suspendCapture(): Promise<boolean>;
+  resumeCapture(): Promise<boolean>;
+  pauseForNavigation(): Promise<boolean>;
   pinDetector?: PinDetector;
   finishRecording(): Promise<void>;
   stopRecording(): Promise<void>;
@@ -157,6 +168,7 @@ export async function startRecordingRecognition(
     await writer.finish('interrupted');
     throw Object.assign(new Error('Cancelled'), { name: 'AbortError' });
   }
+  let suspension: Promise<boolean> | null = null;
   const session: RecognitionSession = {
     writer,
     detector: capture.silero ? 'silero' : 'energy',
@@ -177,6 +189,31 @@ export async function startRecordingRecognition(
     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 () => {},
     abort: () => {},
@@ -285,10 +322,13 @@ export async function startRecordingRecognition(
     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);
@@ -346,6 +386,21 @@ export async function startRecordingRecognition(
     },
   });
   session.pinDetector = detector;
+  session.pauseForNavigation = async () => {
+    // Pause at the worklet boundary and drain its partial buffer before freezing
+    // the context. No port acknowledgement is awaited on a suspended context.
+    // Speaker playback may already be suspending this context. Wait for that
+    // transition before deciding whether its worklet can acknowledge a flush.
+    if (suspension) await suspension;
+    if (!session.captureSuspended) await session.capture?.flush?.(true);
+    if (!(await session.suspendCapture()) || !valid()) return false;
+    // Close an open utterance at the real capture boundary, without sealing
+    // the writer. Requests already running retain their original callbacks.
+    detector.finish();
+    await session.tail;
+    await serialize(() => releaseCapturedRanges(true), false, true);
+    return valid();
+  };
   async function drain() {
     if (session.draining || !valid()) return;
     session.draining = true;
@@ -633,7 +688,7 @@ export async function startRecordingRecognition(
     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();