@goodandready/dsh-voice 0.8.26 → 0.8.28

package/lib/client.js

@@ -465,8 +465,14 @@ window.__ModuleLoader__.load({
       if (!voice.settings || voice.settings.contextGlossary === false) return []
       const text = (voice.input && typeof voice.input.draft === 'string') ? voice.input.draft : ''
       if (!text || text.length < 3) return []
-      const matches = text.match(/\b[A-Za-z_][A-Za-z0-9_]{2,29}\b/g) || []
-      const stop = new Set(['the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'any', 'can', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now', 'old', 'see', 'two', 'way', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she', 'too', 'use'])
+      const matches = text.match(/[A-Za-zА-Яа-яЁё_][A-Za-zА-Яа-яЁё0-9_]{2,29}/g) || []
+      const stop = new Set([
+        'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'any', 'can', 'her', 'was',
+        'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now',
+        'old', 'see', 'two', 'way', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she',
+        'too', 'use', 'это', 'как', 'что', 'для', 'или', 'если', 'все', 'при', 'так', 'уже',
+        'был', 'быть', 'только', 'тоже', 'под', 'над', 'без', 'нет', 'даже', 'где', 'чем',
+      ])
       const words = []
       const seen = new Set()
       for (const m of matches) {
@@ -485,11 +491,24 @@ window.__ModuleLoader__.load({
       const payload = { dataBase64, mimeType: mime, mode }
       const contextWords = extractContextKeywords()
       if (contextWords && contextWords.length > 0) payload.contextWords = contextWords
-      const res = await fetch('/dsh-voice/transcribe', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify(payload),
-      })
+      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+      const timer = controller ? setTimeout(() => controller.abort(), 60000) : null
+      let res = null
+      try {
+        res = await fetch('/dsh-voice/transcribe', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify(payload),
+          signal: controller ? controller.signal : undefined,
+        })
+      } catch (e) {
+        if (e && e.name === 'AbortError') {
+          throw new Error('Transcription request timed out (60s)')
+        }
+        throw e
+      } finally {
+        if (timer) clearTimeout(timer)
+      }
       let parsed = null
       try { parsed = await res.json() } catch (e) { /* not json */ }
       if (!res.ok || !parsed || !parsed.ok) {
@@ -539,7 +558,8 @@ window.__ModuleLoader__.load({
         // Draft was edited manually — cut the last insert as a substring.
         const i = draft.lastIndexOf(last.added)
         if (i < 0) { insertHistory.push(last); return t('nothingToUndo') }
-        actions.setDraft((draft.slice(0, i) + draft.slice(i + last.added.length)).replace(/\s+$/, ''))
+        const spliced = draft.slice(0, i) + draft.slice(i + last.added.length)
+        actions.setDraft(spliced.replace(/[ \t]{2,}/g, ' ').replace(/\s+$/, '').trimStart())
       }
       return t('undone')
     }
@@ -706,10 +726,24 @@ window.__ModuleLoader__.load({
       if (!rec) return
       try { rec.stream.getTracks().forEach((t) => t.stop()) } catch (e) { /* already stopped */ }
       if (rec.srcNode) { try { rec.srcNode.disconnect() } catch (e) { /* already disconnected */ } }
+      if (rec.filterNode) { try { rec.filterNode.disconnect() } catch (e) { /* already disconnected */ } }
+      if (rec.analyser) { try { rec.analyser.disconnect() } catch (e) { /* already disconnected */ } }
       if (rec.audioCtx) { try { rec.audioCtx.close() } catch (e) { /* already closed */ } }
     }
 
+    if (typeof window !== 'undefined') {
+      const onPageUnload = () => {
+        if (voice.rec) teardown(voice.rec)
+        if (voice.browser) {
+          try { voice.browser.abort() } catch (e) { /* ignore */ }
+        }
+      }
+      window.addEventListener('pagehide', onPageUnload)
+      window.addEventListener('beforeunload', onPageUnload)
+    }
+
     function waitStop(recorder) {
+      if (!recorder || recorder.state === 'inactive') return Promise.resolve()
       return new Promise((resolve) => recorder.addEventListener('stop', resolve, { once: true }))
     }
 
@@ -792,21 +826,32 @@ window.__ModuleLoader__.load({
       if (!rec || rec.cutting || rec.closing) return
       rec.cutting = true
       const stopped = waitStop(rec.recorder)
-      try { rec.recorder.stop() } catch (e) { /* already stopped */ }
+      try {
+        if (rec.recorder && rec.recorder.state !== 'inactive') {
+          rec.recorder.stop()
+        }
+      } catch (e) {
+        rec.cutting = false
+        return
+      }
       stopped.then(async () => {
         const blob = new Blob(rec.chunks, { type: rec.mime })
         rec.chunks = []
         rec.silenceMs = 0
         rec.hadSpeech = false
         rec.streamMs = 0
-        if (!rec.closing) {
-          try { rec.recorder.start() } catch (e) { /* stream already closed */ }
+        if (!rec.closing && !rec.cancelled) {
+          try {
+            if (rec.recorder && rec.recorder.state === 'inactive') rec.recorder.start()
+          } catch (e) { /* stream already closed */ }
         }
         rec.cutting = false
-        if (blob.size < 600) return       // too short — not speech
+        if (rec.cancelled || blob.size < 600) return       // cancelled or too short — not speech
         dictationQueue = dictationQueue.then(async () => {
+        if (rec.cancelled) return
         try {
           const out = await sendAudio(blob, rec.mime, 'dictation')
+          if (rec.cancelled) return
           const text = out && out.text ? out.text : ''
           const delay = Number(voice.settings.sendDelayMs) || 0
           if (text && delay > 0 && !voice.holding) {
@@ -818,7 +863,9 @@ window.__ModuleLoader__.load({
           }
           if (text) appendDraft(text)
         } catch (e) {
-          voice.set({ error: String(e && e.message ? e.message : e) })
+          if (!rec.cancelled) {
+            voice.set({ error: String(e && e.message ? e.message : e) })
+          }
         }
         })
       })
@@ -979,9 +1026,12 @@ window.__ModuleLoader__.load({
       const rec = voice.rec
       voice.pending = null
       if (!rec) { voice.set({ phase: 'idle', error: '' }); return }
+      rec.cancelled = true
       rec.closing = true
       const stopped = waitStop(rec.recorder)
-      try { rec.recorder.stop() } catch (e) { /* already stopped */ }
+      try {
+        if (rec.recorder && rec.recorder.state !== 'inactive') rec.recorder.stop()
+      } catch (e) { /* already stopped */ }
       stopped.then(() => { teardown(rec); voice.rec = null; voice.set({ phase: 'idle', error: '' }) })
     }
 
@@ -1011,7 +1061,9 @@ window.__ModuleLoader__.load({
       rec.closing = true
       const mode = rec.mode
       const stopped = waitStop(rec.recorder)
-      try { rec.recorder.stop() } catch (e) { /* already stopped */ }
+      try {
+        if (rec.recorder && rec.recorder.state !== 'inactive') rec.recorder.stop()
+      } catch (e) { /* already stopped */ }
       stopped.then(async () => {
         const blob = new Blob(rec.chunks, { type: rec.mime })
         teardown(rec)
@@ -1053,14 +1105,21 @@ window.__ModuleLoader__.load({
           try {
             const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
             if (draft.trim()) {
-              const res = await fetch('/dsh-voice/polish', {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ text: draft }),
-              })
-              const parsed = await res.json().catch(() => null)
-              if (parsed && parsed.ok && typeof parsed.text === 'string' && parsed.text.trim()) {
-                actions.setDraft(parsed.text.trim())
+              const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+              const timer = controller ? setTimeout(() => controller.abort(), 10000) : null
+              try {
+                const res = await fetch('/dsh-voice/polish', {
+                  method: 'POST',
+                  headers: { 'content-type': 'application/json' },
+                  body: JSON.stringify({ text: draft }),
+                  signal: controller ? controller.signal : undefined,
+                })
+                const parsed = await res.json().catch(() => null)
+                if (parsed && parsed.ok && typeof parsed.text === 'string' && parsed.text.trim()) {
+                  actions.setDraft(parsed.text.trim())
+                }
+              } finally {
+                if (timer) clearTimeout(timer)
               }
             }
           } catch (e) { /* polish is best-effort */ }
@@ -1126,22 +1185,35 @@ window.__ModuleLoader__.load({
     }
 
     // ----------------------------------------------------------- visualizers
+    let _accentColorCache = { color: '', expires: 0 }
+    let _softColorCache = { color: '', expires: 0 }
+
     function accentColor(fallback) {
+      const now = Date.now()
+      if (now < _accentColorCache.expires && _accentColorCache.color) return _accentColorCache.color
       try {
         const root = document.documentElement
         const s = getComputedStyle(root)
         const pick = s.getPropertyValue('--dsw-alias-state-info-primary').trim()
           || s.getPropertyValue('--dsw-alias-label-primary').trim()
-        if (pick) return pick
+        if (pick) {
+          _accentColorCache = { color: pick, expires: now + 1000 }
+          return pick
+        }
       } catch (noTheme) { /* canvas-only fallback */ }
       return fallback || voice.waveColor || 'currentColor'
     }
     function softColor(fallback) {
+      const now = Date.now()
+      if (now < _softColorCache.expires && _softColorCache.color) return _softColorCache.color
       try {
         const s = getComputedStyle(document.documentElement)
         const pick = s.getPropertyValue('--dsw-alias-bg-layer-3').trim()
           || s.getPropertyValue('--dsw-alias-label-primary').trim()
-        if (pick) return pick
+        if (pick) {
+          _softColorCache = { color: pick, expires: now + 1000 }
+          return pick
+        }
       } catch (noTheme) { /* fallback */ }
       return fallback || voice.waveColor || 'currentColor'
     }
@@ -1528,6 +1600,7 @@ window.__ModuleLoader__.load({
                 polishSend: !!(data && data.modes && data.modes.message && data.modes.message.polishSend),
                 sessionCommands: !!(data && data.modes && data.modes.message && data.modes.message.sessionCommands),
                 noiseSuppression: data && data.noiseSuppression !== false,
+                noiseGateDb: Number(data && data.noiseGateDb !== undefined ? data.noiseGateDb : -45),
                 contextGlossary: data && data.contextGlossary !== false,
                 visualizerStyle: (data && data.visualizerStyle) || 'liquid-wave',
               })
@@ -1825,7 +1898,7 @@ window.__ModuleLoader__.load({
         const timer = setInterval(() => {
           if (tries >= 15) { clearInterval(timer); return }
           tries += 1
-          try { ((ctx.get && ctx.get('lanSettings')) || ctx.settingsScope).describe().load() } catch (e) { /* service not up yet */ }
+          try { ctx.settingsScope.describe().load() } catch (e) { /* service not up yet */ }
         }, 1000)
         return () => clearInterval(timer)
       }, [ready])
@@ -1841,26 +1914,27 @@ window.__ModuleLoader__.load({
 
       React.useEffect(() => {
         if (!ready) return
+        const val = value || {}
         voice.settings = Object.assign({}, voice.settings, {
-          vadSilenceMs: Number(value && value.dictation && value.dictation.vadSilenceMs) || 700,
-          autoSendMs: Number(value && value.message && value.message.autoSendMs) || 4000,
-          beep: !!(value && value.beep),
-          micDeviceId: String((value && value.micDeviceId) || ''),
-          historyLimit: Number(value && value.historyLimit) || 20,
-          voiceCommands: !!(value && value.voiceCommands),
-          sendDelayMs: Number(value && value.dictation && value.dictation.sendDelayMs) || 0,
-          stream: !!(value && value.dictation && value.dictation.stream),
-          streamChunkMs: Number(value && value.dictation && value.dictation.streamChunkMs) || 1200,
-          vadAdapt: Number(value && value.dictation && value.dictation.vadAdapt) || 0,
-          wakeWord: String((value && value.wakeWord) || ''),
-          bargeIn: !!(value && value.bargeIn),
-          polishSend: !!(value && value.message && value.message.polishSend),
-          sessionCommands: !!(value && value.message && value.message.sessionCommands),
-          polishBaseUrl: String((value && value.polishBaseUrl) || ''),
-          noiseSuppression: value.noiseSuppression !== false,
-          noiseGateDb: Number((value && value.noiseGateDb) !== undefined ? value.noiseGateDb : -45),
-          contextGlossary: value.contextGlossary !== false,
-          visualizerStyle: (value && value.visualizerStyle) || 'liquid-wave',
+          vadSilenceMs: Number(val.dictation && val.dictation.vadSilenceMs) || 700,
+          autoSendMs: Number(val.message && val.message.autoSendMs) || 4000,
+          beep: !!val.beep,
+          micDeviceId: String(val.micDeviceId || ''),
+          historyLimit: Number(val.historyLimit) || 20,
+          voiceCommands: !!val.voiceCommands,
+          sendDelayMs: Number(val.dictation && val.dictation.sendDelayMs) || 0,
+          stream: !!(val.dictation && val.dictation.stream),
+          streamChunkMs: Number(val.dictation && val.dictation.streamChunkMs) || 1200,
+          vadAdapt: Number(val.dictation && val.dictation.vadAdapt) || 0,
+          wakeWord: String(val.wakeWord || ''),
+          bargeIn: !!val.bargeIn,
+          polishSend: !!(val.message && val.message.polishSend),
+          sessionCommands: !!(val.message && val.message.sessionCommands),
+          polishBaseUrl: String(val.polishBaseUrl || ''),
+          noiseSuppression: val.noiseSuppression !== false,
+          noiseGateDb: Number(val.noiseGateDb !== undefined ? val.noiseGateDb : -45),
+          contextGlossary: val.contextGlossary !== false,
+          visualizerStyle: val.visualizerStyle || 'liquid-wave',
         })
       }, [ready, value])
 
@@ -1891,9 +1965,18 @@ window.__ModuleLoader__.load({
           const audioCtx = new AC()
           if (audioCtx.state === 'suspended') await audioCtx.resume().catch(() => {})
           const src = audioCtx.createMediaStreamSource(stream)
+          let lastNode = src
+          try {
+            const filter = audioCtx.createBiquadFilter()
+            filter.type = 'highpass'
+            filter.frequency.value = 80
+            filter.Q.value = 0.707
+            src.connect(filter)
+            lastNode = filter
+          } catch (e) {}
           const analyser = audioCtx.createAnalyser()
           analyser.fftSize = 128
-          src.connect(analyser)
+          lastNode.connect(analyser)
           testRef.current = { stream, audioCtx, analyser, active: true }
           setTestingMic(true)
 
@@ -1980,21 +2063,22 @@ window.__ModuleLoader__.load({
           }
         }
 
+        const d = draft || {}
         Object.assign(voice.settings, {
-          vadSilenceMs: Number(draft.dictation && draft.dictation.vadSilenceMs) || 700,
-          autoSendMs: Number(draft.message && draft.message.autoSendMs) || 4000,
-          beep: !!draft.beep,
-          micDeviceId: String(draft.micDeviceId || ''),
-          historyLimit: Number(draft.historyLimit),
-          voiceCommands: !!draft.voiceCommands,
-          sendDelayMs: Number(draft.dictation && draft.dictation.sendDelayMs) || 0,
-          stream: !!(draft.dictation && draft.dictation.stream),
-          streamChunkMs: Number(draft.dictation && draft.dictation.streamChunkMs) || 1200,
-          vadAdapt: Number(draft.dictation && draft.dictation.vadAdapt) || 0,
-          noiseSuppression: draft.noiseSuppression !== false,
-          noiseGateDb: Number(draft.noiseGateDb !== undefined ? draft.noiseGateDb : -45),
-          contextGlossary: draft.contextGlossary !== false,
-          visualizerStyle: draft.visualizerStyle || 'liquid-wave',
+          vadSilenceMs: Number(d.dictation && d.dictation.vadSilenceMs) || 700,
+          autoSendMs: Number(d.message && d.message.autoSendMs) || 4000,
+          beep: !!d.beep,
+          micDeviceId: String(d.micDeviceId || ''),
+          historyLimit: Number(d.historyLimit),
+          voiceCommands: !!d.voiceCommands,
+          sendDelayMs: Number(d.dictation && d.dictation.sendDelayMs) || 0,
+          stream: !!(d.dictation && d.dictation.stream),
+          streamChunkMs: Number(d.dictation && d.dictation.streamChunkMs) || 1200,
+          vadAdapt: Number(d.dictation && d.dictation.vadAdapt) || 0,
+          noiseSuppression: d.noiseSuppression !== false,
+          noiseGateDb: Number(d.noiseGateDb !== undefined ? d.noiseGateDb : -45),
+          contextGlossary: d.contextGlossary !== false,
+          visualizerStyle: d.visualizerStyle || 'liquid-wave',
         })
         try { window.dispatchEvent(new CustomEvent('dsh-voice:settings-saved')) } catch (noEvents) { /* nobody */ }
 
@@ -2029,7 +2113,7 @@ window.__ModuleLoader__.load({
         React.createElement('span', { className: 'dvs-sub' }, t('hotkeyHint1') + t('hotkeyHint2')),
       )
 
-      const gateDbVal = Number((draft && draft.noiseGateDb) !== undefined ? draft.noiseGateDb : (value && value.noiseGateDb) !== undefined ? value.noiseGateDb : -45)
+      const gateDbVal = Number((draft && draft.noiseGateDb !== undefined) ? draft.noiseGateDb : (value && value.noiseGateDb !== undefined) ? value.noiseGateDb : -45)
       const gateThresholdPercent = gateDbVal <= -90 ? 0 : Math.min(100, Math.max(0, Math.round(((gateDbVal + 60) / 40) * 100)))
 
       const micField = () => React.createElement('div', { className: 'cb-field' },

package/lib/index.js

@@ -303,7 +303,7 @@ export function apply(ctx, baseConfig) {
       : (Array.isArray(cfg.vocabulary) ? cfg.vocabulary : [])
 
     const providers = makeProviders(
-      { resolveKey, fetchImpl: fetch, cfg, toWav: (b) => toWav16k(b, cfg.ffmpegBin) },
+      { resolveKey, fetchImpl: fetch, cfg, toWav: (b, sig) => toWav16k(b, cfg.ffmpegBin, sig || signal) },
       { bytes, mime, lang: modeCfg.language, signal, models, vocabulary: vocab },
     )
     return runChain(order, providers, statsTracker.record)
@@ -356,6 +356,7 @@ export function apply(ctx, baseConfig) {
         beep: cfg.beep,
         localOnly: cfg.localOnly,
         micDeviceId: cfg.micDeviceId,
+        noiseGateDb: cfg.noiseGateDb !== undefined ? cfg.noiseGateDb : -45,
         historyLimit: cfg.historyLimit,
         voiceCommands: cfg.voiceCommands,
         wakeWord: String(cfg.wakeWord || ''),

package/lib/normalize.js

@@ -17,7 +17,7 @@ export function ensureTrailingPeriod(text) {
 }
 
 const NUM_WORDS = {
-  ноль: 0, один: 1, одна: 1, два: 2, две: 2, три: 3, четыре: 4, пять: 5,
+  ноль: 0, один: 1, одна: 1, одно: 1, два: 2, две: 2, три: 3, четыре: 4, пять: 5,
   шесть: 6, семь: 7, восемь: 8, девять: 9, десять: 10, одиннадцать: 11,
   двенадцать: 12, тринадцать: 13, четырнадцать: 14, пятнадцать: 15,
   шестнадцать: 16, семнадцать: 17, восемнадцать: 18, девятнадцать: 19,

package/lib/providers.js

@@ -158,6 +158,7 @@ export function makeProviders(deps, req) {
     form.append('file', new Blob([bytes], { type: mime }), fileName(mime))
     form.append('model', pickModel(models, 'groq'))
     if (!isAutoLang(lang)) form.append('language', lang)
+    if (vocab) form.append('prompt', vocab)
     form.append('response_format', 'json')
     const res = await fetchImpl('https://api.groq.com/openai/v1/audio/transcriptions', {
       method: 'POST',
@@ -205,7 +206,7 @@ export function makeProviders(deps, req) {
         return { ok: false, provider: 'local-whisper', reason: 'local whisper needs WAV, no converter configured' }
       }
       try {
-        sendBytes = await deps.toWav(bytes)
+        sendBytes = await deps.toWav(bytes, signal)
         sendMime = 'audio/wav'
       } catch (e) {
         return { ok: false, provider: 'local-whisper', reason: `local whisper: ${String(e && e.message || e)}` }
@@ -249,7 +250,7 @@ export function makeProviders(deps, req) {
         return { ok: false, provider: 'sensevoice', reason: 'sensevoice needs WAV, no converter configured' }
       }
       try {
-        sendBytes = await deps.toWav(bytes)
+        sendBytes = await deps.toWav(bytes, signal)
         sendMime = 'audio/wav'
       } catch (e) {
         return { ok: false, provider: 'sensevoice', reason: `sensevoice: ${String(e && e.message || e)}` }
@@ -259,12 +260,11 @@ export function makeProviders(deps, req) {
     form.append('file', new Blob([sendBytes], { type: sendMime }), fileName(sendMime))
     const isOpenAI = url.includes('/transcriptions')
     if (isOpenAI) {
-      const model = pickModel(models, 'sensevoice') || 'SenseVoiceSmall'
-      form.append('model', model)
+      form.append('model', pickModel(models, 'sensevoice'))
+      if (!isAutoLang(lang)) form.append('language', lang)
+      if (vocab) form.append('prompt', vocab)
       form.append('response_format', 'json')
     }
-    if (!isAutoLang(lang)) form.append('language', lang)
-    if (vocab) form.append('prompt', vocab)
 
     let res
     try {
@@ -316,6 +316,7 @@ export function makeProviders(deps, req) {
       form.append('file', new Blob([bytes], { type: mime }), fileName(mime))
       form.append('model', model)
       if (lang && lang !== 'auto') form.append('language', lang)
+      if (vocab) form.append('prompt', vocab)
       form.append('response_format', 'json')
       const res = await fetchImpl(`${base}/audio/transcriptions`, {
         method: 'POST', headers, body: form, signal,
@@ -330,9 +331,9 @@ export function makeProviders(deps, req) {
       let format = chatAudioFormat(mime)
       if (!format) {
         if (typeof deps.toWav !== 'function') {
-          throw new Error(`${label} needs wav or mp3, no converter configured`)
+          throw new Error(`${label}: chat template needs wav or mp3, unsupported format ${mime}`)
         }
-        sendBytes = await deps.toWav(bytes)
+        sendBytes = await deps.toWav(bytes, signal)
         format = 'wav'
       }
       const ask = (spec.prompt || CHAT_AUDIO_PROMPT)

package/lib/transcribe-core.js

@@ -29,10 +29,10 @@ export function buildProviderOrder({ localOnly, chain, customKeys, knownKeys, de
 }
 
 const SESSION_COMMANDS = [
-  { re: /^(отправь|отправить|пошли|send)\s*[.!?]*$/i, cmd: 'send' },
-  { re: /^(отмени|отмена|cancel|отменить)\s*[.!?]*$/i, cmd: 'cancel' },
-  { re: /^(стоп|stop|хватит)\s*[.!?]*$/i, cmd: 'stop' },
-  { re: /^(продолжи|continue|продолжай)\s*[.!?]*$/i, cmd: 'continue' },
+  { re: /^(отправь|отправить|пошли|send|发送|发出去)\s*[.!?]*$/i, cmd: 'send' },
+  { re: /^(отмени|отмена|cancel|отменить|取消|算了)\s*[.!?]*$/i, cmd: 'cancel' },
+  { re: /^(стоп|stop|хватит|停止|暂停)\s*[.!?]*$/i, cmd: 'stop' },
+  { re: /^(продолжи|continue|продолжай|继续)\s*[.!?]*$/i, cmd: 'continue' },
 ]
 
 /**

package/lib/wav.js

@@ -11,8 +11,12 @@ import { spawn } from 'node:child_process'
  * @param ffmpegBin {string} ffmpeg binary path
  * @returns {Promise<Buffer>} 16 kHz mono WAV
  */
-export function toWav16k(bytes, ffmpegBin = 'ffmpeg') {
+export function toWav16k(bytes, ffmpegBin = 'ffmpeg', signal = null) {
   return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error('ffmpeg conversion aborted before start'))
+      return
+    }
     const proc = spawn(ffmpegBin, [
       '-hide_banner', '-loglevel', 'error',
       '-i', 'pipe:0',
@@ -21,10 +25,37 @@ export function toWav16k(bytes, ffmpegBin = 'ffmpeg') {
     ])
     const out = []
     const err = []
+    let done = false
+
+    const timeout = setTimeout(() => {
+      cleanup()
+      try { proc.kill('SIGKILL') } catch {}
+      reject(new Error('ffmpeg conversion timed out after 30s'))
+    }, 30000)
+
+    const onAbort = () => {
+      cleanup()
+      try { proc.kill('SIGKILL') } catch {}
+      reject(new Error('ffmpeg conversion aborted'))
+    }
+
+    if (signal) signal.addEventListener('abort', onAbort, { once: true })
+
+    function cleanup() {
+      if (done) return
+      done = true
+      clearTimeout(timeout)
+      if (signal) signal.removeEventListener('abort', onAbort)
+    }
+
     proc.stdout.on('data', (c) => out.push(c))
     proc.stderr.on('data', (c) => err.push(c))
-    proc.on('error', (e) => reject(new Error(`ffmpeg unavailable: ${e.message}`)))
+    proc.on('error', (e) => {
+      cleanup()
+      reject(new Error(`ffmpeg unavailable: ${e.message}`))
+    })
     proc.on('close', (code) => {
+      cleanup()
       if (code !== 0) {
         reject(new Error(`ffmpeg exit ${code}: ${Buffer.concat(err).toString('utf8').slice(0, 200)}`))
         return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.26",
+  "version": "0.8.28",
   "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",