@goodandready/dsh-voice 0.9.10 → 0.9.11

package/lib/client.js

@@ -702,11 +702,15 @@ window.__ModuleLoader__.load({
     }
 
     function tidyPhrase(text) {
-      let s = String(text || '').trim()
-      if (!s) return s
+      if (!text) return ''
+      if (/^\n+$/.test(text)) return text
+      const lead = (text.match(/^\n+/) || [''])[0]
+      const trail = (text.match(/\n+$/) || [''])[0]
+      let s = String(text).trim()
+      if (!s) return lead || trail || ''
       s = s.replace(/\s*,\s*/g, ', ')
-      s = s.replace(/(^|[.!?\n]\s+)([a-zа-яё])/gi, (m, lead, ch) => lead + ch.toUpperCase())
-      return s
+      s = s.replace(/(^|[.!?\n]\s+)([a-zа-яё])/gi, (m, l, ch) => l + ch.toUpperCase())
+      return lead + s + trail
     }
 
     // Functional speech edit commands (#37): spoken line breaks and punctuation -> symbols.
@@ -724,7 +728,12 @@ window.__ModuleLoader__.load({
     function applyVoiceCommands(text) {
       let s = text
       for (const [re, to] of VOICE_COMMANDS) s = s.replace(re, to)
-      return s.replace(/[ \t]*\n[ \t]*/g, '\n').replace(/[ \t]+/g, ' ').trim()
+      if (/^\n+$/.test(s)) return s
+      const lead = (s.match(/^\n+/) || [''])[0]
+      const trail = (s.match(/\n+$/) || [''])[0]
+      const trimmed = s.replace(/[ \t]*\n[ \t]*/g, '\n').replace(/[ \t]+/g, ' ').trim()
+      if (!trimmed) return lead || trail || ''
+      return lead + trimmed + trail
     }
 
     // Insert history for undo (#29-9). Browser-only storage.
@@ -747,22 +756,33 @@ window.__ModuleLoader__.load({
       return t('undone')
     }
 
-    function appendDraft(text) {
+    function insertDraftText(text) {
       const actions = voice.inputActions
-      if (!actions || typeof actions.setDraft !== 'function') {
+      if (!actions || (typeof actions.setDraft !== 'function' && typeof actions.insertText !== 'function')) {
         voice.set({ phase: 'error', error: t('composerUnavailable') })
-        return
+        return false
+      }
+      if (typeof actions.insertText === 'function') {
+        try { actions.insertText(text); return true } catch (_) {}
       }
-      let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
-      if (!clean) return
       const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
       const before = draft
-      actions.setDraft(draft ? draft + ' ' + clean : clean)
+      const sep = (!draft || draft.endsWith('\n') || text.startsWith('\n')) ? '' : ' '
+      const after = draft + sep + text
+      actions.setDraft(after)
       const limit = Number(voice.settings.historyLimit)
       if (limit > 0) {
-        insertHistory.push({ before, added: draft ? ' ' + clean : clean, after: draft ? draft + ' ' + clean : clean })
+        insertHistory.push({ before, added: sep + text, after })
         while (insertHistory.length > limit) insertHistory.shift()
       }
+      return true
+    }
+
+    function appendDraft(text) {
+      if (!text) return
+      let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
+      if (!clean) return
+      insertDraftText(clean)
     }
 
     // Human-readable key name.
@@ -862,6 +882,8 @@ window.__ModuleLoader__.load({
       recognition.continuous = options.continuous !== false
       recognition.interimResults = true
       let stopped = false
+      let stopPromise = null
+      let resolveStop = null
 
       recognition.onresult = (event) => {
         let interim = ''
@@ -878,12 +900,18 @@ window.__ModuleLoader__.load({
         // no-speech and aborted are normal life, not failures.
         const code = event && event.error
         if (code === 'no-speech' || code === 'aborted') return
+        stopped = true
+        try { recognition.abort() } catch (_) {}
+        if (resolveStop) { resolveStop(); resolveStop = null }
         options.onError(code || t('recognitionError'))
       }
       // The browser ends recognition on its own (pauses, timeout). Restart
       // until we stop it, otherwise dictation dies silently on the first pause.
       recognition.onend = () => {
-        if (stopped) return
+        if (stopped) {
+          if (resolveStop) { resolveStop(); resolveStop = null }
+          return
+        }
         try { recognition.start() } catch (alreadyRunning) { /* already running */ }
       }
 
@@ -891,15 +919,27 @@ window.__ModuleLoader__.load({
         options.onError(String(cannotStart && cannotStart.message || cannotStart))
       }
       return {
-        stop() { stopped = true; try { recognition.stop() } catch (already) { /* already stopped */ } },
-        abort() { stopped = true; try { recognition.abort() } catch (already) { /* already stopped */ } },
+        stop() {
+          if (stopPromise) return stopPromise
+          stopped = true
+          stopPromise = new Promise((resolve) => {
+            resolveStop = resolve
+            try { recognition.stop() } catch (already) { resolve() }
+            setTimeout(resolve, 800)
+          })
+          return stopPromise
+        },
+        abort() {
+          stopped = true
+          if (resolveStop) { resolveStop(); resolveStop = null }
+          try { recognition.abort() } catch (already) { /* already stopped */ }
+        },
       }
     }
 
     // Fetch the mode chain from the host once. Only needed to decide whether
 
-    voice._core = { tidyPhrase, applyVoiceCommands, VOICE_COMMANDS, undoLastInsert, insertHistory }
-    // to use browser recognition or record a file.
+    voice._core = { tidyPhrase, applyVoiceCommands, VOICE_COMMANDS, undoLastInsert, insertHistory, insertDraftText, appendDraft }
     let chainsPromise = null
     if (typeof window !== 'undefined') {
       window.addEventListener('dsh-voice:settings-saved', () => { chainsPromise = null })
@@ -992,7 +1032,6 @@ window.__ModuleLoader__.load({
         rec.analyser.fftSize = 128
         lastNode.connect(rec.analyser)
       }
-      // No timeslice: only then each stop() yields a standalone webm file.
       recorder.start()
       return rec
     }
@@ -1010,8 +1049,6 @@ window.__ModuleLoader__.load({
       }
       return raw
     }
-    // Cut the current phrase: stop the recorder, send the finished file and
-    // immediately start a new recording with the same recorder.
     let dictationQueue = Promise.resolve()
     function cutPhrase() {
       const rec = voice.rec
@@ -1047,40 +1084,22 @@ window.__ModuleLoader__.load({
           if (rec.cancelled) return
           const text = out && out.text ? out.text : ''
           const action = out && out.action ? out.action : null
-
           if (voice.settings.structuredPromptVoice !== false && text) {
             const promptInfo = findActiveStructuredPrompt()
             if (promptInfo && submitToStructuredPrompt(text, promptInfo)) {
               return
             }
           }
-
-          if (action === 'send') {
-            if (text) appendDraft(text)
-            if (voice.inputActions && typeof voice.inputActions.send === 'function') {
-              voice.inputActions.send()
-            }
+          if (action === 'send' || action === 'clear' || action === 'newline') {
+            executeVoiceAction(action, text)
             return
           }
           if (action === 'cancel') {
             cancelCurrent()
             return
           }
-          if (action === 'clear') {
-            if (voice.inputActions && typeof voice.inputActions.clear === 'function') {
-              voice.inputActions.clear()
-            }
-            return
-          }
-          if (action === 'newline') {
-            appendDraft(text ? (text + '\n') : '\n')
-            return
-          }
-
           const delay = Number(voice.settings.sendDelayMs) || 0
           if (text && delay > 0 && !voice.holding) {
-            // Delayed insert with a cancel window (#29-5): text is already
-            // inserted; the window only allows undoing it.
             appendDraft(text)
             voice.set({ phase: 'pending', pending: { text, undoOnly: true, leftMs: delay } })
             return
@@ -1094,9 +1113,6 @@ window.__ModuleLoader__.load({
         })
       })
     }
-
-    // Browser recognition instead of file recording. Returns false when the
-    // browser cannot do it — then fall back to the normal path.
     function startBrowserLeg(mode, language) {
       if (voice.settings && voice.settings.localOnly) return false
       if (!browserRecognitionAvailable()) return false
@@ -1111,12 +1127,13 @@ window.__ModuleLoader__.load({
             voice.interimTranscript = text
           }
           voice.notify()
-          // Wake-word (#45): if interim starts with the trigger phrase, stop
-          // browser listening and switch to normal recording.
           const ww = String(voice.settings.wakeWord || '').trim().toLowerCase()
           if (ww && mode === 'dictation' && !voice.rec) {
             const t = String(text || '').trim().toLowerCase()
             if (t.startsWith(ww)) {
+              if (voice.browser && typeof voice.browser.abort === 'function') {
+                try { voice.browser.abort() } catch (_) {}
+              }
               voice.browser = null
               voice.caption = ''
               voice.interimTranscript = ''
@@ -1137,12 +1154,10 @@ window.__ModuleLoader__.load({
           finals.push(text)
           voice.caption = ''
           voice.interimTranscript = ''
-          // Dictation appends immediately; messages accumulate until release.
           if (mode === 'dictation') appendDraft(text)
           else voice.notify()
         },
         onError: (reason) => {
-          // Browser failed after start — say so instead of pretending to listen.
           voice.browser = null
           voice.interimTranscript = ''
           voice.set({ phase: 'error', error: t('browserFailed') + reason })
@@ -1152,7 +1167,6 @@ window.__ModuleLoader__.load({
       voice.notify()
       return true
     }
-
     function startRecording(mode) {
       if (voice.phase !== 'idle' && voice.phase !== 'error') return
       voice.activeOpId = (voice.activeOpId || 0) + 1
@@ -1168,7 +1182,6 @@ window.__ModuleLoader__.load({
       dictationQueue = Promise.resolve()
       voice.set({ phase: 'recording', mode, error: '', levels: [], caption: '', interimTranscript: '' })
       modeChain(mode).then((info) => {
-        // Browser leg only when it is explicitly first in the chain.
         if (info.chain[0] === 'browser' && startBrowserLeg(mode, info.language)) return
         openMic(mode)
           .then((rec) => {
@@ -1182,47 +1195,50 @@ window.__ModuleLoader__.load({
           .catch((err) => voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null }))
       })
     }
-
     function startDictation() { startRecording('dictation') }
     function startMessage() { startRecording('message') }
-
     // --------------------------------------------------------- hold gesture
-    //
-    // Two gestures on one button: a short click toggles recording until the
-    // next click; hold records only while pressed. Release sends.
-    //
-    // Distinguished by time: release before the threshold is a click.
     const HOLD_THRESHOLD_MS = 350
-
     const hold = { active: false, mode: null, startedAt: 0, armed: false }
-
-    function beginHold(mode) {
+    let activePointerCleanup = null
+    function beginHold(mode, pointerEvent) {
       if (hold.armed || (voice.phase !== 'idle' && voice.phase !== 'error')) return
       hold.armed = true
       hold.mode = mode
       hold.startedAt = Date.now()
       hold.active = false
-      // Start recording immediately: waiting for the threshold loses the first word.
+      if (pointerEvent?.target?.setPointerCapture && pointerEvent.pointerId !== undefined) {
+        try { pointerEvent.target.setPointerCapture(pointerEvent.pointerId) } catch (e) {}
+      }
+      if (typeof window !== 'undefined') {
+        if (activePointerCleanup) { try { activePointerCleanup() } catch (e) {} }
+        const onUp = () => endHold(false)
+        const onCancel = () => endHold(true)
+        window.addEventListener('pointerup', onUp, true)
+        window.addEventListener('pointercancel', onCancel, true)
+        window.addEventListener('blur', onCancel, true)
+        activePointerCleanup = () => {
+          window.removeEventListener('pointerup', onUp, true)
+          window.removeEventListener('pointercancel', onCancel, true)
+          window.removeEventListener('blur', onCancel, true)
+          activePointerCleanup = null
+        }
+      }
       startRecording(mode)
       voice.holding = true
       voice.notify()
     }
-
     function endHold(cancelled) {
       if (!hold.armed) return
+      if (activePointerCleanup) { try { activePointerCleanup() } catch (e) {} }
       const heldMs = Date.now() - hold.startedAt
       hold.armed = false
       hold.active = false
       voice.holding = false
-      // Short press is a click: recording is already on, leave it running;
-      // the second click will stop it.
       if (!cancelled && heldMs < HOLD_THRESHOLD_MS) { voice.notify(); return }
       if (cancelled) cancelCurrent()
       else stopCurrent()
     }
-
-    // Hotkey: holding a key is easier than aiming the mouse. While the key is
-    // down we record; Escape cancels.
     function hotkeyMatches(event, name) {
       if (!event || !name) return false
       if (typeof name === 'string' && name.includes('+')) {
@@ -1244,7 +1260,6 @@ window.__ModuleLoader__.load({
       if (name === 'Meta') return event.key === 'Meta'
       return event.code === name || event.key === name
     }
-
     function isAllowedInEditable(name) {
       if (!name) return false
       if (['Control', 'Alt', 'Shift', 'Meta'].includes(name)) return true
@@ -1253,9 +1268,7 @@ window.__ModuleLoader__.load({
       if (['Tab', 'Pause', 'ScrollLock', 'Insert'].includes(name)) return true
       return false
     }
-
     let activeHotkeyCleanup = null
-
     function clearGlobalHotkey() {
       if (typeof activeHotkeyCleanup === 'function') {
         try { activeHotkeyCleanup() } catch (_) { /* ignore */ }
@@ -1266,31 +1279,34 @@ window.__ModuleLoader__.load({
         window.__dsh_voice_hotkey_cleanup = null
       }
     }
-
     function installHotkey(ctx, keyName, mode) {
       clearGlobalHotkey()
       if (typeof document === 'undefined' || !keyName) return () => {}
       const down = (event) => {
         if (event.repeat) return
-        // A modifier, function key or combo does not fight the text field:
-        // modifiers/combos do not type plain text. A plain letter key must not be hijacked while typing.
         const target = event.target
-        const isEditable = target && (
-          target.tagName === 'INPUT' ||
-          target.tagName === 'TEXTAREA' ||
-          target.isContentEditable ||
-          (typeof target.getAttribute === 'function' && target.getAttribute('contenteditable') === 'true')
-        )
+        const isEditable = target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable || (typeof target.getAttribute === 'function' && target.getAttribute('contenteditable') === 'true'))
         if (isEditable && !isAllowedInEditable(keyName)) return
-
         if (hotkeyMatches(event, keyName)) {
           event.preventDefault()
           event.stopPropagation()
           beginHold(mode)
         }
       }
+    function isHotkeyRelease(event, name) {
+      if (!event || !name) return false
+      if (typeof name === 'string' && name.includes('+')) {
+        const parts = name.split('+')
+        if (event.code === parts[parts.length - 1] || event.key === parts[parts.length - 1]) return true
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (event.key === parts[i] || event.code === parts[i]) return true
+        }
+        return false
+      }
+      return event.code === name || event.key === name
+    }
       const up = (event) => {
-        if (hotkeyMatches(event, keyName)) {
+        if (hold.armed && isHotkeyRelease(event, keyName)) {
           event.preventDefault()
           endHold(false)
         } else if (event.key === 'Escape' && hold.armed) {
@@ -1317,7 +1333,6 @@ window.__ModuleLoader__.load({
       }
       return cleanup
     }
-
     function cancelCurrent() {
       voice.activeOpId = (voice.activeOpId || 0) + 1
       announceVoice('end')
@@ -1340,27 +1355,25 @@ window.__ModuleLoader__.load({
       } catch (e) { /* already stopped */ }
       stopped.then(() => { teardown(rec); voice.rec = null; voice.set({ phase: 'idle', error: '' }) })
     }
-
-    // Stop on the second click: dictation flushes the tail; a voice message
-    // sends the whole recording and opens the cancel window.
     function stopCurrent() {
       announceVoice('end')
       focusComposer()
       if (voice.browser) {
         const mode = voice.mode
-        const said = (voice.browserFinals || []).join(' ').trim()
-        voice.browser.stop()
+        const b = voice.browser
         voice.browser = null
-        voice.browserFinals = null
         voice.caption = ''
-        if (!said) { voice.set({ phase: 'idle' }); return }
-        if (mode === 'message') {
-          appendDraft(said)
-          voice.set({ phase: 'pending', pending: { text: said, leftMs: voice.settings.autoSendMs } })
-        } else {
-          // Dictation already appended while speaking — nothing extra to add.
-          voice.set({ phase: 'idle' })
-        }
+        Promise.resolve(b.stop()).then(() => {
+          const said = (voice.browserFinals || []).join(' ').trim()
+          voice.browserFinals = null
+          if (!said) { voice.set({ phase: 'idle' }); return }
+          if (mode === 'message') {
+            appendDraft(said)
+            voice.set({ phase: 'pending', pending: { text: said, leftMs: voice.settings.autoSendMs } })
+          } else {
+            voice.set({ phase: 'idle' })
+          }
+        })
         return
       }
       const rec = voice.rec
@@ -1377,67 +1390,101 @@ window.__ModuleLoader__.load({
         const blob = new Blob(rec.chunks, { type: rec.mime })
         teardown(rec)
         voice.rec = null
-        if (blob.size < 1200) { voice.set({ phase: 'idle' }); return }
+        if (blob.size < (mode === 'dictation' ? 600 : 1200)) {
+          if (mode === 'dictation') { try { await dictationQueue } catch (_) {} }
+          voice.set({ phase: 'idle' })
+          return
+        }
         if (voice.lastNote && voice.lastNote.url) {
-          try { URL.revokeObjectURL(voice.lastNote.url) } catch (e) { /* ignore */ }
+          try { URL.revokeObjectURL(voice.lastNote.url) } catch (e) {}
         }
         let noteUrl = ''
-        try { noteUrl = URL.createObjectURL(blob) } catch (e) { /* ignore */ }
+        try { noteUrl = URL.createObjectURL(blob) } catch (e) {}
         voice.lastNote = { blob, url: noteUrl, mime: rec.mime, text: '' }
         voice.set({ phase: 'processing' })
-        try {
-          const out = await sendAudio(blob, rec.mime, mode)
+        const processTail = async () => {
           if (rec.cancelled || voice.activeOpId !== opId || voice.phase === 'idle') return
-          if (out.command) { runSessionCommand(out.command); return }
-          const text = out.text || ''
-          const action = out.action || null
-          if (!text && !action) { voice.set({ phase: 'error', error: t('nothingHeard') }); return }
-
-          if (voice.settings.structuredPromptVoice !== false && text) {
-            const promptInfo = findActiveStructuredPrompt()
-            if (promptInfo && submitToStructuredPrompt(text, promptInfo)) {
-              voice.set({ phase: 'idle' })
+          try {
+            const out = await sendAudio(blob, rec.mime, mode)
+            if (rec.cancelled || voice.activeOpId !== opId || voice.phase === 'idle') return
+            if (out.command) { runSessionCommand(out.command); return }
+            const text = out.text || ''
+            const action = out.action || null
+            if (!text && !action) {
+              if (mode === 'message') voice.set({ phase: 'error', error: t('nothingHeard') })
+              else voice.set({ phase: 'idle' })
               return
             }
-          }
-
-          if (action === 'send') {
-            if (text) appendDraft(text)
-            submitPending()
-            return
-          }
-          if (action === 'cancel') {
-            cancelCurrent()
-            return
-          }
-          if (action === 'clear') {
-            if (voice.inputActions && typeof voice.inputActions.clear === 'function') {
-              voice.inputActions.clear()
+            if (voice.settings.structuredPromptVoice !== false && text) {
+              const promptInfo = findActiveStructuredPrompt()
+              if (promptInfo && submitToStructuredPrompt(text, promptInfo)) {
+                voice.set({ phase: 'idle' })
+                return
+              }
             }
-            voice.set({ phase: 'idle' })
-            return
-          }
-
-          appendDraft(text)
-          if (voice.lastNote) voice.lastNote.text = text
-          if (mode === 'message') {
-            voice.set({ phase: 'pending', pending: { text: text, totalMs: voice.settings.autoSendMs, leftMs: voice.settings.autoSendMs, audioUrl: noteUrl } })
-          } else {
-            voice.set({ phase: 'idle' })
+            if (action === 'send' || action === 'clear' || action === 'newline') {
+              executeVoiceAction(action, text)
+              return
+            }
+            if (action === 'cancel') { cancelCurrent(); return }
+            appendDraft(text)
+            if (voice.lastNote) voice.lastNote.text = text
+            if (mode === 'message') {
+              voice.set({ phase: 'pending', pending: { text, totalMs: voice.settings.autoSendMs, leftMs: voice.settings.autoSendMs, audioUrl: noteUrl } })
+            } else {
+              voice.set({ phase: 'idle' })
+            }
+          } catch (e) {
+            if (rec.cancelled || voice.activeOpId !== opId || voice.phase === 'idle') return
+            voice.set({ phase: 'error', error: String(e && e.message ? e.message : e) })
           }
-        } catch (e) {
-          if (rec.cancelled || voice.activeOpId !== opId || voice.phase === 'idle') return
-          voice.set({ phase: 'error', error: String(e && e.message ? e.message : e) })
+        }
+        if (mode === 'dictation') {
+          dictationQueue = dictationQueue.then(processTail)
+          try { await dictationQueue } catch (_) {}
+        } else {
+          await processTail()
         }
       })
     }
-
+    function clearDraft() {
+      const actions = voice.inputActions
+      if (!actions || typeof actions.setDraft !== 'function') {
+        voice.set({ phase: 'error', error: t('composerUnavailable') })
+        return false
+      }
+      actions.setDraft('')
+      return true
+    }
+    function executeVoiceAction(action, text) {
+      if (action === 'send') {
+        if (text) appendDraft(text)
+        submitPending()
+        return true
+      }
+      if (action === 'clear') {
+        const ok = clearDraft()
+        if (ok && voice.phase !== 'recording') voice.set({ phase: 'idle' })
+        return ok
+      }
+      if (action === 'newline') {
+        const payload = text ? (text.endsWith('\n') ? text : text + '\n') : '\n'
+        appendDraft(payload)
+        if (voice.phase !== 'recording') voice.set({ phase: 'idle' })
+        return true
+      }
+      if (action === 'cancel') { cancelCurrent(); return true }
+      return false
+    }
+    voice.executeVoiceAction = executeVoiceAction
     function submitPending() {
       voice.pending = null
-      voice.set({ phase: 'idle' })
       const actions = voice.inputActions
-      if (!actions || typeof actions.submit !== 'function') return
-      // Polish the whole draft before submit (#46). Errors do not block.
+      if (!actions || typeof actions.submit !== 'function') {
+        voice.set({ phase: 'error', error: t('composerUnavailable') })
+        return
+      }
+      voice.set({ phase: 'idle' })
       if (voice.settings.polishSend) {
         const run = async () => {
           try {
@@ -1467,36 +1514,23 @@ window.__ModuleLoader__.load({
       }
       setTimeout(() => { try { actions.submit() } catch (e) { /* composer busy */ } }, 0)
     }
-
-    // Session voice commands (#48): clean "send/cancel/stop/continue".
     function runSessionCommand(cmd) {
       const actions = voice.inputActions
       voice.set({ phase: 'idle', pending: null })
-      switch (cmd) {
-        case 'send':
-        case 'continue':
-          if (actions && typeof actions.submit === 'function') actions.submit()
-          break
-        case 'cancel':
-        case 'stop':
-          // Clear wait/recording; leave the draft text intentionally untouched.
-          break
-        default:
-          break
+      if ((cmd === 'send' || cmd === 'continue') && actions && typeof actions.submit === 'function') {
+        actions.submit()
       }
     }
-
     function keepPending() {
       voice.pending = null
       voice.set({ phase: 'idle' })
     }
-
     // ----------------------------------------------------------- components
     function VoiceButtons(props) {
       const v = useVoice()
       voice.inputActions = props.inputActions
       voice.input = props.input
-      if (v.phase !== 'idle' && v.phase !== 'error') return null
+      if (v.phase !== 'idle' && v.phase !== 'error' && !hold.armed) return null
       const err = v.phase === 'error'
       const hk = voice.hotkey ? ` (${voice.hotkey})` : ''
       return React.createElement(React.Fragment, null,
@@ -1507,13 +1541,17 @@ window.__ModuleLoader__.load({
           onClick: startDictation,
         }, micIcon()),
         React.createElement('button', {
-          type: 'button', className: 'dvo-btn', 'data-err': err ? '1' : '0',
+          type: 'button', className: 'dvo-btn' + (hold.armed ? ' dvo-btn-active' : ''), 'data-err': err ? '1' : '0',
           title: err ? v.error : (t('messageBtn') + hk),
           'aria-label': err ? v.error : (t('messageBtn') + hk),
-          // Hold: record while pressed; leaving the control cancels.
-          onPointerDown: (e) => { e.preventDefault(); beginHold('message') },
+          onPointerDown: (e) => { e.preventDefault(); beginHold('message', e) },
           onPointerUp: () => endHold(false),
-          onPointerLeave: () => { if (hold.armed) endHold(true) },
+          onPointerCancel: () => endHold(true),
+          onPointerLeave: (e) => {
+            if (hold.armed && (!e.target || typeof e.target.hasPointerCapture !== 'function' || !e.target.hasPointerCapture(e.pointerId))) {
+              endHold(true)
+            }
+          },
         }, waveIcon()),
         voice.lastNote && voice.lastNote.url
           ? React.createElement('button', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.9.10",
+  "version": "0.9.11",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",