dsh-live-voice 0.2.0 → 0.2.2

package/lib/client.js

@@ -114,6 +114,9 @@ var defaultSettings = Object.freeze({
   recognitionProcessLocally: true,
   recognitionAutoInstall: true,
   voiceDetectionPreset: "natural",
+  recognitionMaxUtteranceSeconds: 60,
+  microphoneEnabled: true,
+  holdToTalkEnabled: true,
   announceAssistantMessages: true,
   interruptSpeechOnUserMessage: false,
   sendingMode: "manual",
@@ -149,6 +152,9 @@ function normalizeSettings(value) {
     recognitionProcessLocally: typeof source.recognitionProcessLocally === "boolean" ? source.recognitionProcessLocally : defaultSettings.recognitionProcessLocally,
     recognitionAutoInstall: typeof source.recognitionAutoInstall === "boolean" ? source.recognitionAutoInstall : defaultSettings.recognitionAutoInstall,
     voiceDetectionPreset: Object.hasOwn(voiceDetectionPresets, source.voiceDetectionPreset) ? source.voiceDetectionPreset : defaultSettings.voiceDetectionPreset,
+    recognitionMaxUtteranceSeconds: Number.isInteger(source.recognitionMaxUtteranceSeconds) && source.recognitionMaxUtteranceSeconds >= 10 && source.recognitionMaxUtteranceSeconds <= 300 ? source.recognitionMaxUtteranceSeconds : defaultSettings.recognitionMaxUtteranceSeconds,
+    microphoneEnabled: typeof source.microphoneEnabled === "boolean" ? source.microphoneEnabled : defaultSettings.microphoneEnabled,
+    holdToTalkEnabled: typeof source.holdToTalkEnabled === "boolean" ? source.holdToTalkEnabled : defaultSettings.holdToTalkEnabled,
     announceAssistantMessages: typeof source.announceAssistantMessages === "boolean" ? source.announceAssistantMessages : defaultSettings.announceAssistantMessages,
     interruptSpeechOnUserMessage: typeof source.interruptSpeechOnUserMessage === "boolean" ? source.interruptSpeechOnUserMessage : defaultSettings.interruptSpeechOnUserMessage,
     sendingMode: source.sendingMode === "automatic" ? "queue" : ["manual", "queue", "steer"].includes(source.sendingMode) ? source.sendingMode : defaultSettings.sendingMode,
@@ -271,7 +277,8 @@ var VoiceCoordinator = class {
       conversation: false,
       listening: false,
       recognizing: false,
-      muted: false,
+      pendingTranscriptions: 0,
+      muted: normalizeSettings(settings).microphoneEnabled === false,
       speaking: false,
       paused: false,
       starting: false,
@@ -285,6 +292,7 @@ var VoiceCoordinator = class {
     };
     this.autoSendTimer = null;
     this.autoSendDraft = null;
+    this.holdToTalkRelease = false;
     this.interruptionTimer = null;
     this.interruptionTranscriptConfirmed = false;
     this.interruptionPausedSpeech = false;
@@ -338,7 +346,12 @@ var VoiceCoordinator = class {
       autoInstallLocalPack: settings.recognitionAutoInstall,
       voiceDetectionPreset: settings.voiceDetectionPreset
     });
-    this.patch({ settings, error: null });
+    this.patch({
+      settings,
+      muted: settings.microphoneEnabled === false,
+      recognizing: settings.microphoneEnabled === false ? false : this.snapshot.recognizing,
+      error: null
+    });
     if (settings.sendingMode === "manual") this.cancelAutoSend();
     if (Object.hasOwn(next, "announceAssistantMessages") && !settings.announceAssistantMessages) {
       this.queue = [];
@@ -397,20 +410,42 @@ var VoiceCoordinator = class {
   startDictation() {
     return this.startListening(false);
   }
+  startHoldToTalk() {
+    this.holdToTalkRelease = false;
+    return this.startListening(false);
+  }
+  async releaseHoldToTalk() {
+    if (this.disposed || !this.snapshot.listening && !this.snapshot.starting) return;
+    this.holdToTalkRelease = true;
+    if (this.snapshot.starting) return;
+    await this.recognition.finish?.();
+    if (this.snapshot.pendingTranscriptions === 0) this._finishHoldToTalk();
+  }
+  _finishHoldToTalk() {
+    if (!this.holdToTalkRelease) return;
+    this.holdToTalkRelease = false;
+    const draft = this.composer.getDraft();
+    if (!draft.trim()) {
+      void this.stopListening();
+      return;
+    }
+    this.scheduleAutoSend(draft, { force: true, stopAfter: true });
+  }
   startConversation() {
     return this.startListening(true);
   }
   muteListening() {
-    if (!this.snapshot.settings.voiceCommandsEnabled) return this.stopListening();
     this.cancelAutoSend();
     this.composer.setDraft(this.transcript.update(this.composer.getDraft(), "", true));
     this.transcript.reset();
-    this.patch({ muted: true, recognizing: false });
+    this.updateSettings({ microphoneEnabled: false });
+    if (!this.snapshot.settings.voiceCommandsEnabled) return this.stopListening();
   }
   resumeListeningInput() {
+    this.transcript.reset();
+    this.updateSettings({ microphoneEnabled: true });
     if (this.snapshot.listening || this.snapshot.starting) {
-      this.transcript.reset();
-      this.patch({ muted: false, recognizing: false });
+      this.patch({ recognizing: false });
       return;
     }
     return this.startListening(this.snapshot.conversation);
@@ -475,6 +510,14 @@ var VoiceCoordinator = class {
           onResult: (result) => {
             if (valid()) this.onResult(result);
           },
+          onProcessingChange: ({ pending = 0 } = {}) => {
+            if (!valid()) return;
+            const count = Number.isSafeInteger(pending) && pending >= 0 ? pending : 0;
+            this.patch({ pendingTranscriptions: count });
+            if (count > 0) this.cancelAutoSend();
+            else if (this.holdToTalkRelease) this._finishHoldToTalk();
+            else this.maybeScheduleAutoSend();
+          },
           onActivity: (active) => {
             if (!valid()) return;
             if (active) {
@@ -499,6 +542,7 @@ var VoiceCoordinator = class {
           return;
         }
         this.patch({ listening: true, starting: false });
+        if (this.holdToTalkRelease) void this.releaseHoldToTalk();
         this._drain();
       } catch (error) {
         try {
@@ -611,7 +655,7 @@ var VoiceCoordinator = class {
       }
       const next = this.transcript.update(this.composer.getDraft(), final, true);
       this.composer.setDraft(next);
-      if (this.snapshot.settings.sendingMode !== "manual") this.scheduleAutoSend(next);
+      this.maybeScheduleAutoSend(next);
     }
     if (interim) {
       this.cancelAutoSend();
@@ -622,7 +666,12 @@ var VoiceCoordinator = class {
     this.patch({ recognizing: !!interim });
     this._drain();
   }
-  scheduleAutoSend(draft) {
+  maybeScheduleAutoSend(draft = this.composer.getDraft()) {
+    if (this.snapshot.settings.sendingMode === "manual" || this.snapshot.recognizing || this.snapshot.pendingTranscriptions > 0)
+      return;
+    this.scheduleAutoSend(draft);
+  }
+  scheduleAutoSend(draft, { force = false, stopAfter = false } = {}) {
     this.cancelAutoSend();
     if (!draft.trim() || typeof this.composer.submit !== "function") return;
     const delay = this.snapshot.settings.autoSendDelaySeconds * 1e3;
@@ -633,11 +682,14 @@ var VoiceCoordinator = class {
       const expected = this.autoSendDraft;
       this.autoSendDraft = null;
       this.patch({ autoSendAt: null });
-      if (!this.disposed && this.snapshot.settings.sendingMode !== "manual" && expected === this.composer.getDraft()) {
+      if (!this.disposed && (force || this.snapshot.settings.sendingMode !== "manual") && expected === this.composer.getDraft()) {
         try {
-          this.composer.submit(this.snapshot.settings.sendingMode === "steer" ? "steer" : "queue");
+          this.composer.submit(
+            this.snapshot.settings.sendingMode === "steer" && !force ? "steer" : "queue"
+          );
           this.transcript.reset();
           this.recognition.reset?.();
+          if (stopAfter) void this.stopListening();
         } catch (error) {
           this.patch({ error: message(error) });
         }
@@ -654,10 +706,11 @@ var VoiceCoordinator = class {
     if (this.autoSendDraft !== null && draft !== this.autoSendDraft) this.cancelAutoSend();
   }
   stopListening() {
+    this.holdToTalkRelease = false;
     this.cancelAutoSend();
     ++this.epoch;
     this.inputController?.abort();
-    this.patch({ listening: false, recognizing: false, starting: false });
+    this.patch({ listening: false, recognizing: false, pendingTranscriptions: 0, starting: false });
     return this._input(async () => {
       try {
         await this._releaseInput();
@@ -1381,7 +1434,10 @@ var BrowserRecognitionEngine = class {
       restarts: 0,
       timer: null,
       recognition: null,
-      speaking: false
+      speaking: false,
+      finishing: false,
+      finishPromise: null,
+      resolveFinish: null
     };
     this.session = session;
     const cancelled3 = new Promise((resolve, reject) => {
@@ -1479,6 +1535,12 @@ var BrowserRecognitionEngine = class {
       session.recognition = null;
       this._activity(session, false);
       if (this.session !== session) return;
+      if (session.finishing) {
+        this.session = null;
+        session.signal?.removeEventListener("abort", session.cancel);
+        session.resolveFinish?.();
+        return;
+      }
       if (session.restarts >= this.maxRestarts) {
         this._fail(
           session,
@@ -1507,6 +1569,33 @@ var BrowserRecognitionEngine = class {
     };
     recognition.start();
   }
+  finish() {
+    const session = this.session;
+    if (!session) return Promise.resolve();
+    if (session.finishPromise) return session.finishPromise;
+    session.finishing = true;
+    session.finishPromise = new Promise((resolve) => {
+      session.resolveFinish = resolve;
+    });
+    if (session.timer !== null) {
+      (this.globals.clearTimeout ?? globalThis.clearTimeout)(session.timer);
+      session.timer = null;
+      this.session = null;
+      session.resolveFinish();
+      return session.finishPromise;
+    }
+    try {
+      session.recognition?.stop();
+      if (!session.recognition) {
+        this.session = null;
+        session.resolveFinish();
+      }
+    } catch {
+      this.session = null;
+      session.resolveFinish();
+    }
+    return session.finishPromise;
+  }
   reset() {
     const session = this.session;
     const recognition = session?.recognition;
@@ -1541,6 +1630,7 @@ var BrowserRecognitionEngine = class {
     } catch {
     }
     this._activity(session, false);
+    session.resolveFinish?.();
   }
 };
 
@@ -1577,12 +1667,18 @@ function encodeMonoPcm16Wav(samples, inputRate) {
   return buffer;
 }
 var WhisperHttpRecognitionEngine = class {
-  constructor({ globals = globalThis, meter, voiceDetectionPreset = "natural" } = {}) {
+  constructor({
+    globals = globalThis,
+    meter,
+    voiceDetectionPreset = "natural",
+    maxUtteranceSeconds = 60
+  } = {}) {
     this.g = globals;
     this.meter = meter;
     this.session = null;
     this.lang = "pt-BR";
     this.voiceDetectionPreset = voiceDetectionPreset;
+    this.maxUtteranceSeconds = maxUtteranceSeconds;
     this.route = ROUTE;
   }
   get segmentation() {
@@ -1608,7 +1704,14 @@ var WhisperHttpRecognitionEngine = class {
       };
     }
   }
-  async start({ lang = this.lang, signal, onResult, onActivity, onError } = {}) {
+  async start({
+    lang = this.lang,
+    signal,
+    onResult,
+    onActivity,
+    onError,
+    onProcessingChange
+  } = {}) {
     await this.stop();
     if (signal?.aborted) throw abortError3();
     const context = this.meter?.context, source = this.meter?.source;
@@ -1628,16 +1731,24 @@ var WhisperHttpRecognitionEngine = class {
       samples: 0,
       voiced: false,
       silence: 0,
-      inflight: /* @__PURE__ */ new Set(),
+      transcriptionQueue: [],
+      activeRequest: null,
+      draining: false,
       onResult,
       onActivity,
       onError,
+      onProcessingChange,
       lang,
       signal
     };
     this.session = session;
     const valid = () => this.session === session && !signal?.aborted;
-    const submit = async () => {
+    const notifyProcessing = () => session.onProcessingChange?.({
+      queued: session.transcriptionQueue.length,
+      active: !!session.activeRequest,
+      pending: session.transcriptionQueue.length + (session.activeRequest ? 1 : 0)
+    });
+    const enqueue = () => {
       if (!session.voiced || session.samples < context.sampleRate * 0.25) {
         session.chunks = [];
         session.samples = 0;
@@ -1655,29 +1766,46 @@ var WhisperHttpRecognitionEngine = class {
       session.samples = 0;
       session.voiced = false;
       session.silence = 0;
-      const request = new AbortController();
-      session.inflight.add(request);
+      session.transcriptionQueue.push(samples);
+      notifyProcessing();
+      void drain();
+    };
+    const drain = async () => {
+      if (session.draining || !valid()) return;
+      session.draining = true;
       try {
-        const response = await this.g.fetch(this.route + "/transcribe", {
-          method: "POST",
-          credentials: "same-origin",
-          headers: {
-            "content-type": "audio/wav",
-            "x-dlv-client-id": session.operation,
-            "x-dlv-operation-id": id(),
-            "x-dlv-language": lang
-          },
-          body: encodeMonoPcm16Wav(samples, context.sampleRate),
-          signal: request.signal
-        });
-        const json = await response.json();
-        if (!response.ok || !json?.ok)
-          throw new Error(json?.error?.message || "HTTP transcription failed.");
-        if (valid() && json.value.text) onResult?.({ final: json.value.text, interim: "" });
-      } catch (error) {
-        if (error.name !== "AbortError" && valid()) onError?.(error);
+        while (valid() && session.transcriptionQueue.length) {
+          const samples = session.transcriptionQueue.shift();
+          const request = new AbortController();
+          session.activeRequest = request;
+          notifyProcessing();
+          try {
+            const response = await this.g.fetch(this.route + "/transcribe", {
+              method: "POST",
+              credentials: "same-origin",
+              headers: {
+                "content-type": "audio/wav",
+                "x-dlv-client-id": session.operation,
+                "x-dlv-operation-id": id(),
+                "x-dlv-language": lang
+              },
+              body: encodeMonoPcm16Wav(samples, context.sampleRate),
+              signal: request.signal
+            });
+            const json = await response.json();
+            if (!response.ok || !json?.ok)
+              throw new Error(json?.error?.message || "HTTP transcription failed.");
+            if (valid() && json.value.text) onResult?.({ final: json.value.text, interim: "" });
+          } catch (error) {
+            if (error.name !== "AbortError" && valid()) onError?.(error);
+          } finally {
+            if (session.activeRequest === request) session.activeRequest = null;
+            notifyProcessing();
+          }
+        }
       } finally {
-        session.inflight.delete(request);
+        session.draining = false;
+        notifyProcessing();
       }
     };
     processor.onaudioprocess = (event) => {
@@ -1693,13 +1821,24 @@ var WhisperHttpRecognitionEngine = class {
       }
       session.chunks.push(data);
       session.samples += data.length;
-      if (session.voiced && session.silence > context.sampleRate * (this.segmentation.silenceMs / 1e3) || session.samples > context.sampleRate * 20)
-        void submit();
+      if (session.voiced && session.silence > context.sampleRate * (this.segmentation.silenceMs / 1e3) || session.samples > context.sampleRate * this.maxUtteranceSeconds)
+        enqueue();
     };
     source.connect(processor);
+    session.finish = enqueue;
     session.abort = () => this.stop();
     signal?.addEventListener("abort", session.abort, { once: true });
   }
+  finish() {
+    const session = this.session;
+    if (!session) return;
+    session.processor.onaudioprocess = null;
+    try {
+      this.meter?.source?.disconnect(session.processor);
+    } catch {
+    }
+    session.finish?.();
+  }
   async stop() {
     const session = this.session;
     if (!session) return;
@@ -1715,8 +1854,10 @@ var WhisperHttpRecognitionEngine = class {
       session.gain?.disconnect();
     } catch {
     }
-    for (const request of session.inflight) request.abort();
-    session.inflight.clear();
+    session.transcriptionQueue = [];
+    session.activeRequest?.abort();
+    session.activeRequest = null;
+    session.onProcessingChange?.({ queued: 0, active: false, pending: 0 });
   }
 };
 
@@ -2886,6 +3027,28 @@ function createComponents(React2) {
                 null,
                 "Controls how long a pause must last before captured speech is sent for recognition."
               ),
+              h(
+                "label",
+                { className: "dlv-setting-field" },
+                "Maximum continuous speech (seconds)",
+                h("input", {
+                  type: "number",
+                  min: 10,
+                  max: 300,
+                  step: 1,
+                  value: settings.recognitionMaxUtteranceSeconds ?? 60,
+                  onChange: (event) => {
+                    const value = Number(event.target.value);
+                    if (Number.isInteger(value) && value >= 10 && value <= 300)
+                      invoke("updateSettings", { recognitionMaxUtteranceSeconds: value });
+                  }
+                }),
+                h(
+                  "small",
+                  null,
+                  "If speech never pauses, start a new transcription chunk after this duration. Default: 60 seconds."
+                )
+              ),
               h(
                 "div",
                 {
@@ -2953,6 +3116,21 @@ function createComponents(React2) {
           { key: "interrupt-message-description", className: "dlv-setting-description" },
           settings.interruptSpeechOnUserMessage ? "Sending or steering a new user message stops current or paused assistant speech." : "Sending another message does not stop the assistant audio you are already hearing."
         ),
+        h(
+          "label",
+          { key: "hold-to-talk", className: "dlv-check" },
+          h("input", {
+            type: "checkbox",
+            checked: settings.holdToTalkEnabled !== false,
+            onChange: (event) => invoke("updateSettings", { holdToTalkEnabled: event.target.checked })
+          }),
+          " Hold Control to talk"
+        ),
+        h(
+          "p",
+          { key: "hold-to-talk-description", className: "dlv-setting-description" },
+          "While a composer is open, hold Control anywhere on the page to capture speech. Release it to flush queued transcription, wait the configured send delay, queue the message, and close voice capture. Press Escape while holding to cancel."
+        ),
         field("Listening mode", "mode", [
           { value: "speaker", label: "Speakers \u2014 gated listening" },
           { value: "headphones", label: "Headphones \u2014 open microphone" }
@@ -3112,12 +3290,22 @@ function apply(ctx) {
   let disposed = false;
   let voiceModeActive = false;
   const ownership = new VoiceOwnership();
+  const recognitionSettingKeys = /* @__PURE__ */ new Set([
+    "recognitionEngine",
+    "recognitionProcessLocally",
+    "recognitionAutoInstall",
+    "voiceDetectionPreset",
+    "recognitionMaxUtteranceSeconds"
+  ]);
+  const changesRecognition = (next) => Object.keys(next).some((key) => recognitionSettingKeys.has(key));
   const recognitionFor = (settings, meter) => settings.recognitionEngine === "qwen-http" ? new QwenHttpRecognitionEngine({
     meter,
-    voiceDetectionPreset: settings.voiceDetectionPreset
+    voiceDetectionPreset: settings.voiceDetectionPreset,
+    maxUtteranceSeconds: settings.recognitionMaxUtteranceSeconds
   }) : settings.recognitionEngine === "whisper-http" ? new WhisperHttpRecognitionEngine({
     meter,
-    voiceDetectionPreset: settings.voiceDetectionPreset
+    voiceDetectionPreset: settings.voiceDetectionPreset,
+    maxUtteranceSeconds: settings.recognitionMaxUtteranceSeconds
   }) : new BrowserRecognitionEngine({
     processLocally: settings.recognitionProcessLocally,
     autoInstallLocalPack: settings.recognitionAutoInstall
@@ -3194,7 +3382,8 @@ function apply(ctx) {
             if (capture.index < capture.interaction.questions.length) {
               capture.answering = false;
               const text = pendingQuestionSpeech(capture.interaction, capture.index);
-              if (text) run(entry.controller, entry.controller.speak(text, capture.interaction.key));
+              if (text)
+                run(entry.controller, entry.controller.speak(text, capture.interaction.key));
             } else {
               entry.questionCapture = null;
               entry.controller.patch({ answeringQuestion: false });
@@ -3244,7 +3433,7 @@ function apply(ctx) {
     });
     const pendingInteractions = ctx.uiSession.pendingInteractions;
     const refreshPendingQuestion = (baseline = false) => {
-      if (disposed || entry.closed) return;
+      if (disposed || entry.closed || !pendingInteractions) return;
       const interaction = pendingInteractions.getSnapshot().get(sessionId);
       const key2 = interaction?.kind === "question" ? interaction.key : null;
       if (!key2 || entry.questionCapture && entry.questionCapture.interaction.key !== key2) {
@@ -3264,22 +3453,28 @@ function apply(ctx) {
         run(controller, controller.speak(text, key2));
       }
     };
-    refreshPendingQuestion(true);
-    entry.unsubscribePendingQuestion = pendingInteractions.subscribe(refreshPendingQuestion);
+    if (pendingInteractions) {
+      refreshPendingQuestion(true);
+      entry.unsubscribePendingQuestion = pendingInteractions.subscribe(refreshPendingQuestion);
+    }
     const update = controller.updateSettings.bind(controller);
-    controller.updateSettings = (next) => {
-      if (disposed || entry.closed) return;
+    entry.applySettings = (next) => {
       update(next);
       engineBrowser.lang = controller.getSnapshot().settings.lang;
       engineQwen.lang = controller.getSnapshot().settings.lang;
+      run(controller, controller.refreshCapabilities());
+    };
+    controller.updateSettings = (next) => {
+      if (disposed || entry.closed) return;
+      entry.applySettings(next);
+      const settings2 = controller.getSnapshot().settings;
       try {
-        localStorage.setItem(
-          "dsh-live-voice.settings",
-          JSON.stringify(controller.getSnapshot().settings)
-        );
+        localStorage.setItem("dsh-live-voice.settings", JSON.stringify(settings2));
       } catch {
       }
-      run(controller, controller.refreshCapabilities());
+      for (const other of controllers.values()) {
+        if (other !== entry && !other.closed) other.applySettings(settings2);
+      }
     };
     for (const method of ["stopListening", "cancelDictation", "endConversation", "stopSpeech"]) {
       const original = controller[method].bind(controller);
@@ -3289,7 +3484,7 @@ function apply(ctx) {
         return original(...args);
       };
     }
-    for (const method of ["startDictation", "startConversation", "speak"]) {
+    for (const method of ["startDictation", "startHoldToTalk", "startConversation", "speak"]) {
       const original = controller[method].bind(controller);
       controller[method] = (...args) => {
         if (disposed || entry.closed || !entry.refs) return Promise.resolve();
@@ -3400,13 +3595,11 @@ function apply(ctx) {
       let settingsRevision = 0;
       c.updateSettings = async (next) => {
         const revision = ++settingsRevision;
-        const previousEngine = c.getSnapshot().settings.recognitionEngine;
         update(next);
         browser.lang = c.getSnapshot().settings.lang;
         qwen.lang = c.getSnapshot().settings.lang;
         const settings2 = c.getSnapshot().settings;
-        if (previousEngine !== settings2.recognitionEngine)
-          c.replaceRecognition(recognitionFor(settings2, c.meter));
+        if (changesRecognition(next)) c.replaceRecognition(recognitionFor(settings2, c.meter));
         localStorage.setItem("dsh-live-voice.settings", JSON.stringify(settings2));
         run(c, c.refreshCapabilities());
         const active = [...controllers.values()];
@@ -3417,9 +3610,9 @@ function apply(ctx) {
         if (revision !== settingsRevision || disposed || c.disposed) return;
         for (const entry of controllers.values()) {
           if (entry.closed) continue;
-          if (entry.controller.getSnapshot().settings.recognitionEngine !== settings2.recognitionEngine)
+          if (changesRecognition(next))
             entry.controller.replaceRecognition(recognitionFor(settings2, entry.controller.meter));
-          entry.controller.updateSettings(settings2);
+          entry.applySettings(settings2);
           run(entry.controller, entry.controller.refreshCapabilities());
         }
       };
@@ -3534,19 +3727,47 @@ function apply(ctx) {
       for (const entry of controllers.values())
         run(entry.controller, entry.controller.endConversation());
     };
-    const onKey = (event) => {
-      if (disposed || event.defaultPrevented || !event.ctrlKey || !event.shiftKey || event.code !== "Space" || event.repeat)
-        return;
+    let holdToTalk = null;
+    const candidate = () => {
       const candidates = [...controllers.values()].filter(
         (entry) => entry.buttons > 0 && entry.composers.size > 0
       );
-      if (candidates.length !== 1) return;
-      event.preventDefault();
-      const c = candidates[0].controller;
-      run(
-        c,
-        c.getSnapshot().listening || c.getSnapshot().starting ? c.stopListening() : c.startDictation()
-      );
+      return candidates.length === 1 ? candidates[0] : null;
+    };
+    const releaseHoldToTalk = () => {
+      const entry = holdToTalk;
+      holdToTalk = null;
+      if (!entry || entry.closed) return;
+      run(entry.controller, entry.controller.releaseHoldToTalk());
+    };
+    const onKeyDown = (event) => {
+      if (disposed || event.defaultPrevented || event.repeat) return;
+      if (event.key === "Escape" && holdToTalk) {
+        const entry2 = holdToTalk;
+        holdToTalk = null;
+        event.preventDefault();
+        run(entry2.controller, entry2.controller.cancelDictation());
+        return;
+      }
+      if (event.ctrlKey && event.shiftKey && event.code === "Space") {
+        const entry2 = candidate();
+        if (!entry2) return;
+        event.preventDefault();
+        const c = entry2.controller;
+        run(
+          c,
+          c.getSnapshot().listening || c.getSnapshot().starting ? c.stopListening() : c.startDictation()
+        );
+        return;
+      }
+      if (event.key !== "Control" || event.altKey || event.metaKey || event.shiftKey) return;
+      const entry = candidate();
+      if (!entry || !entry.controller.getSnapshot().settings.holdToTalkEnabled) return;
+      holdToTalk = entry;
+      run(entry.controller, entry.controller.startHoldToTalk());
+    };
+    const onKeyUp = (event) => {
+      if (event.key === "Control") releaseHoldToTalk();
     };
     const refreshCapabilities = () => {
       for (const entry of controllers.values())
@@ -3559,7 +3780,9 @@ function apply(ctx) {
     window.speechSynthesis?.addEventListener?.("voiceschanged", refreshCapabilities);
     navigator.mediaDevices?.addEventListener?.("devicechange", refreshCapabilities);
     document.addEventListener("visibilitychange", visibilityChanged);
-    document.addEventListener("keydown", onKey);
+    document.addEventListener("keydown", onKeyDown);
+    document.addEventListener("keyup", onKeyUp);
+    window.addEventListener("blur", releaseHoldToTalk);
     window.addEventListener("pagehide", stop);
     return () => {
       disposed = true;
@@ -3567,7 +3790,9 @@ function apply(ctx) {
       window.speechSynthesis?.removeEventListener?.("voiceschanged", refreshCapabilities);
       navigator.mediaDevices?.removeEventListener?.("devicechange", refreshCapabilities);
       document.removeEventListener("visibilitychange", visibilityChanged);
-      document.removeEventListener("keydown", onKey);
+      document.removeEventListener("keydown", onKeyDown);
+      document.removeEventListener("keyup", onKeyUp);
+      window.removeEventListener("blur", releaseHoldToTalk);
       window.removeEventListener("pagehide", stop);
       for (const entry of controllers.values()) retire(entry);
     };

package/lib/server.js

@@ -460,6 +460,9 @@ var defaultSettings = Object.freeze({
   recognitionProcessLocally: true,
   recognitionAutoInstall: true,
   voiceDetectionPreset: "natural",
+  recognitionMaxUtteranceSeconds: 60,
+  microphoneEnabled: true,
+  holdToTalkEnabled: true,
   announceAssistantMessages: true,
   interruptSpeechOnUserMessage: false,
   sendingMode: "manual",