@goodandready/dsh-tts 0.3.23 → 0.4.1

package/lib/client-src/20-player.js

@@ -0,0 +1,290 @@
+    // Player.
+    //
+    // Each incoming chunk used to replace the previous one immediately; while reading
+    // For full replies this was invisible; with speak-as-it-goes only the last
+    // chunk would be heard. Now items queue: the next starts after the previous ends.
+    const player = {
+      audio: null,
+      after: '',
+      enabled: false,
+      rate: 1,
+      chime: 'ding',
+      queue: [],
+      bargeIn: true,
+      busy: false,
+      paused: false,
+      listeners: new Set(),
+    }
+    const seenIds = new Set()
+    let currentAudioResolve = null
+
+    function playerChanged() {
+      for (const listener of [...player.listeners]) {
+        try { listener() } catch (listenerFailure) { /* чужой слушатель не наша забота */ }
+      }
+    }
+
+    function usePlayer() {
+      const [, force] = React.useReducer((n) => n + 1, 0)
+      React.useEffect(() => {
+        player.listeners.add(force)
+        return () => { player.listeners.delete(force) }
+      }, [])
+      return player
+    }
+
+    // Short chime is synthesized in-browser: no file to download, store, or configure.
+    function playChime(kind) {
+      return new Promise((resolve) => {
+        try {
+          const AC = window.AudioContext || window.webkitAudioContext
+          if (!AC) { resolve(); return }
+          const audioCtx = new AC()
+          const gain = audioCtx.createGain()
+          gain.connect(audioCtx.destination)
+          const tones = kind === 'beep' ? [880, 880] : [660, 990]
+          let at = audioCtx.currentTime
+          for (const freq of tones) {
+            const osc = audioCtx.createOscillator()
+            osc.frequency.value = freq
+            osc.connect(gain)
+            gain.gain.setValueAtTime(0.0001, at)
+            gain.gain.exponentialRampToValueAtTime(0.25, at + 0.02)
+            gain.gain.exponentialRampToValueAtTime(0.0001, at + 0.18)
+            osc.start(at)
+            osc.stop(at + 0.2)
+            at += 0.22
+          }
+          setTimeout(() => { try { audioCtx.close() } catch (already) { /* закрыт */ } resolve() }, 600)
+        } catch (noAudio) { resolve() }
+      })
+    }
+
+    // Provider failed — fall back to the browser voice. Worse quality, but silence
+    // is worse: the user would not know the reply is ready.
+    function speakInBrowser(text) {
+      return new Promise((resolve) => {
+        try {
+          if (!window.speechSynthesis || !text) { resolve(); return }
+          const utterance = new SpeechSynthesisUtterance(String(text))
+          utterance.rate = Math.max(0.5, Math.min(2, player.rate || 1))
+          utterance.onend = () => resolve()
+          utterance.onerror = () => resolve()
+          window.speechSynthesis.speak(utterance)
+        } catch (noSpeech) { resolve() }
+      })
+    }
+
+    function prepareAudioItem(item) {
+      if (!item || !item.audioBase64 || item.prepared) return item
+      try {
+        const bin = atob(item.audioBase64)
+        const bytes = new Uint8Array(bin.length)
+        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i)
+        const blob = new Blob([bytes], { type: item.mime || 'audio/mpeg' })
+        const url = URL.createObjectURL(blob)
+        const audio = new Audio(url)
+        audio.preload = 'auto'
+        item.prepared = { audio, url }
+      } catch (err) { /* decode error */ }
+      return item
+    }
+
+    function prebufferNext() {
+      for (const next of player.queue) {
+        if (next && next.audioBase64 && !next.prepared) {
+          prepareAudioItem(next)
+          break
+        }
+      }
+    }
+
+    function playAudio(item) {
+      return new Promise((resolve) => {
+        try {
+          prepareAudioItem(item)
+          if (!item.prepared) return resolve()
+          const { audio, url } = item.prepared
+          audio.playbackRate = Math.max(0.5, Math.min(2, player.rate || 1))
+          player.audio = audio
+          playerChanged()
+          prebufferNext()
+          let doneCalled = false
+          const done = () => {
+            if (doneCalled) return
+            doneCalled = true
+            currentAudioResolve = null
+            try { URL.revokeObjectURL(url) } catch (_) {}
+            item.prepared = null
+            player.audio = null
+            playerChanged()
+            resolve()
+          }
+          currentAudioResolve = done
+          audio.onended = done
+          audio.onerror = done
+          audio.play().catch(() => {
+    // Autoplay without a user gesture is blocked — not a bug; just no sound.
+            done()
+          })
+        } catch (cannotDecode) {
+          currentAudioResolve = null
+          resolve()
+        }
+      })
+    }
+
+    async function drainQueue() {
+      if (player.busy) return
+      player.busy = true
+      playerChanged()
+      try {
+        while (player.queue.length) {
+          if (player.paused) break
+          const item = player.queue.shift()
+          if (!item || item.kind === 'reserved') continue
+          if (item.kind === 'chime') { await playChime(item.chime || player.chime); continue }
+          if (item.audioBase64) await playAudio(item)
+          else if (item.error && item.text) await speakInBrowser(item.text)
+        }
+      } finally {
+        player.busy = false
+        playerChanged()
+      }
+    }
+
+    function stopPlayback() {
+      for (const item of player.queue) {
+        if (item && item.prepared && item.prepared.url) {
+          try { URL.revokeObjectURL(item.prepared.url) } catch (_) {}
+          item.prepared = null
+        }
+      }
+      player.queue.length = 0
+      player.paused = false
+      if (currentAudioResolve) {
+        currentAudioResolve()
+      } else if (player.audio) {
+        try { player.audio.pause() } catch (already) { /* стоит */ }
+        player.audio = null
+      }
+      try { if (window.speechSynthesis) window.speechSynthesis.cancel() } catch (noSpeech) { /* нет синтеза */ }
+      playerChanged()
+    }
+
+    function togglePause() {
+      player.paused = !player.paused
+      if (player.audio) {
+        try { player.paused ? player.audio.pause() : player.audio.play() } catch (already) { /* всё равно */ }
+      }
+      if (!player.paused) drainQueue()
+      playerChanged()
+    }
+
+    function skipCurrent() {
+      if (currentAudioResolve) {
+        currentAudioResolve()
+      } else if (player.audio) {
+        try { player.audio.pause() } catch (already) { /* стоит */ }
+        player.audio = null
+        playerChanged()
+        if (player.queue.length) drainQueue()
+      }
+    }
+
+    // User started talking — stop playback.
+    //
+    // The event may come from a voice-input plugin, but there is no hard dependency:
+    // without that plugin the event simply never fires. We listen on window on purpose.
+    function listenForVoice() {
+      if (typeof window === 'undefined') return () => {}
+      const onSpeaking = (event) => {
+        const phase = event && event.detail && event.detail.phase
+        if (phase !== 'start') return
+        if (!player.bargeIn) return
+        if (!player.audio && !player.queue.length && !player.busy) return
+        stopPlayback()
+      }
+      window.addEventListener('dsh-voice:speaking', onSpeaking)
+      return () => window.removeEventListener('dsh-voice:speaking', onSpeaking)
+    }
+
+    async function pollPending() {
+      try {
+        const st = await fetch('/dsh-tts/status', { cache: 'no-store' })
+        if (!st.ok) return
+        const meta = await st.json()
+        player.enabled = !!(meta && meta.speakReplies)
+        if (meta && typeof meta.rate === 'number') player.rate = meta.rate
+        if (meta && meta.chime) player.chime = meta.chime
+          if (meta && meta.roles) player.roles = meta.roles
+        if (meta && typeof meta.bargeIn === 'boolean') player.bargeIn = meta.bargeIn
+        if (!player.enabled) return
+        const res = await fetch('/dsh-tts/pending?after=' + encodeURIComponent(player.after || ''), { cache: 'no-store' })
+        if (!res.ok) return
+        const data = await res.json()
+        const items = data && Array.isArray(data.items) ? data.items : []
+        for (const item of items) {
+    // Queue slot reserved but synthesis still running — wait for the next poll
+    // or phrase order would break.
+          if (item.kind === 'reserved') break
+          player.after = item.id
+          if (seenIds.has(item.id)) continue
+          seenIds.add(item.id)
+          if (seenIds.size > 500) {
+            const first = seenIds.values().next().value
+            seenIds.delete(first)
+          }
+          if (item.text) recent.add(item.text)
+          player.queue.push(item)
+        }
+        if (player.queue.length) drainQueue()
+      } catch (hostRestarting) { /* хост перезапускается */ }
+    }
+
+    // Recent utterances: last reply texts and favorites (localStorage).
+    function recentStore() {
+      const KEY = 'dsh-tts/recent'
+      let st
+      try {
+        const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(KEY) : null
+        st = JSON.parse(raw) || { items: [], favs: [] }
+      } catch (broken) { st = { items: [], favs: [] } }
+      const persist = () => { try { if (typeof localStorage !== 'undefined') localStorage.setItem(KEY, JSON.stringify(st)) } catch (full) { /* приватный режим */ } }
+      return {
+        add(text) {
+          if (!text || text.length < 2) return
+          st.items = [text, ...st.items.filter((x) => x !== text)].slice(0, 30)
+          persist()
+        },
+        toggleFav(text) {
+          st.favs = st.favs.includes(text)
+            ? st.favs.filter((x) => x !== text)
+            : [text, ...st.favs].slice(0, 20)
+          persist()
+        },
+        list() { return { items: st.items, favs: st.favs } },
+      }
+    }
+    const recent = recentStore()
+
+    // One-shot playback outside the queue: replay from recents.
+    function playStandalone(text) {
+      fetch('/dsh-tts/speak', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text }),
+      })
+        .then((r) => r.json())
+        .then((d) => {
+          if (!d || !d.ok) return
+          const audio = new Audio('data:' + (d.mime || 'audio/mpeg') + ';base64,' + d.audioBase64)
+          audio.play().catch(() => {})
+        })
+        .catch(() => {})
+    }
+
+    function credOf(map, provider) {
+      return (map && map[provider]) || { configured: false, writable: true, ref: '' }
+    }
+

package/lib/client-src/30-locales.js

@@ -0,0 +1,325 @@
+    const en = {
+      'statusOnline': 'Host online',
+      'statusOffline': 'Host unreachable',
+      'cacheStats': 'Cache',
+
+      'general': 'General',
+      'loading': 'Loading\u2026',
+      'chainHintCard': 'Pick a provider, paste its API key, and Save (or leave the key field). The key is written to the host credentials store immediately. The browser never reads it back.',
+      'speakRepliesHint': 'When on, each finished reply is synthesized on the host and played in this browser. Audio is not sent back to the model.',
+      'chainHint': 'Top to bottom is the fallback order. Cloud keys are saved to the host credentials store, never into plugin settings.',
+      'title': 'Speech',
+      'speakReplies': 'Speak agent replies',
+      'speakAsItGoes': 'Speak as it goes',
+      'speakAsItGoesHint': 'Read each reply the moment it lands, sentence by sentence, instead of waiting for the whole turn.',
+      'rate': 'Playback speed',
+      'rateHint': '0.5 to 2. Synthesis is untouched; the browser plays faster or slower.',
+      'bargeIn': 'Fall silent when you speak',
+      'bargeInHint': 'Stop reading the moment the microphone opens.',
+      'announce': 'Announce approvals',
+      'announceHint': 'Say it out loud and play a chime when the agent stops for an approval or asks a question.',
+      'approvalText': 'Approval wording',
+      'approvalHint': 'Said when an approval is asked for; the tool name is appended.',
+      'questionText': 'Question wording',
+      'questionHint': 'Said when the agent asks a question. Empty disables it.',
+      'chime': 'Chime',
+      'chimeHint': 'ding, beep or none.',
+      'language': 'Language',
+      'languageHint': 'Hint for voices that need a locale (eSpeak, Azure SSML).',
+      'piperModel': 'Piper model path',
+      'piperModelHint': 'Absolute path to an ONNX model. Leave empty to skip Piper.',
+      'piperBin': 'Piper binary',
+      'binHint': 'Looked up in PATH unless absolute.',
+      'espeakBin': 'eSpeak binary',
+      'espeakHint': 'Usually espeak-ng.',
+      'edgeBin': 'edge-tts binary',
+      'edgeHint': 'Python CLI from the edge-tts package.',
+      'azureRegion': 'Azure region',
+      'azureHint': 'Required for the azure provider, e.g. eastus.',
+      'openaiBaseUrl': 'OpenAI base URL',
+      'openaiBaseUrlHint': 'OpenAI-compatible origin for the openai provider.',
+      'mimoBaseUrl': 'MiMo base URL',
+      'mimoBaseUrlHint': 'MiMo API root; synthesis uses its chat endpoint.',
+      'mimoFormat': 'MiMo format',
+      'mimoFormatHint': 'mp3 or wav.',
+      'minimaxBin': 'MiniMax CLI',
+      'minimaxBinHint': 'Looked up in PATH unless absolute; install and log in separately.',
+      'advancedTitle': 'Advanced',
+      'advancedHint': 'Limits and endpoint overrides. Provider API keys stay in the chain editor; credential slot names (*KeyEnv) are config-only.',
+      'maxChars': 'Max characters',
+      'maxCharsHint': 'Hard cap before long-reply handling; 0 disables.',
+      'sentenceChars': 'Sentence chunk size',
+      'sentenceCharsHint': 'Max characters per streaming sentence piece.',
+      'timeoutMs': 'Provider timeout (ms)',
+      'timeoutMsHint': 'Abort a provider attempt after this many milliseconds.',
+      'maxQueue': 'Max queue length',
+      'maxQueueHint': 'Drop oldest pending pieces beyond this count.',
+      'chainTitle': 'Provider chain',
+      'addProvider': 'Add provider',
+      'localProvider': 'Local / CLI provider — no API key',
+      'configured': 'Configured',
+      'notSet': 'Not set',
+      'fromEnv': 'Set in environment',
+      'clear': 'Clear',
+      'remove': 'Remove',
+      'up': 'Up',
+      'down': 'Down',
+      'save': 'Save',
+      'saved': 'Saved',
+      'cardHint': 'Provider chain, voices and playback options.',
+      'skipCode': 'Skip code blocks',
+      'skipCodeHint': 'Say a short notice instead of reading code aloud.',
+      'cache': 'Synthesis cache',
+      'cacheHint': 'Reuse synthesized audio for repeated phrases.',
+      'cacheMaxMb': 'Cache size limit, MB',
+      'cacheMaxMbHint': 'Least recently used items are evicted first.',
+      'clearCache': 'Clear cache',
+      'pronTitle': 'Pronunciation',
+      'pronHint': 'Rules run top-down. Wrap left side in /…/ for a regex; Lang filters the rule.',
+      'pronFrom': 'Replace',
+      'pronTo': 'With',
+      'pronWhole': 'Whole word',
+      'pronLang': 'Lang',
+      'addRule': 'Add rule',
+      'rolesTitle': 'Voice roles',
+      'rolesHint': 'Empty fields inherit the main chain.',
+      'roleReply': 'Reply',
+      'roleApproval': 'Approval',
+      'roleError': 'Error',
+      'longReply': 'Long replies',
+      'longReplyHint': 'truncate: cut at the limit; summarize: short retelling; full: read everything.',
+      'summaryModel': 'Summary model',
+      'summaryModelHint': 'provider/model, empty = conversation default.',
+      'summarySentences': 'Retelling length',
+      'summarySentencesHint': 'Sentences in the spoken retelling.',
+      'preview': 'Preview',
+      'statsTitle': 'Statistics',
+      'statTotal': 'Total',
+      'statHits': 'Cache hits',
+      'statErrors': 'Errors',
+      'statReset': 'Reset stats',
+
+      'autoDetect': 'Auto language per piece',
+      'autoDetectHint': 'Guess ru/en per spoken piece instead of the language setting.',
+      'narrateQuotesOnly': 'Only quotes',
+      'narrateQuotesHint': 'Read only «quoted» fragments of a reply.',
+      'skipActions': 'Skip *actions*',
+      'skipActionsHint': 'Drop asterisk action blocks.',
+      'removeRegex': 'Remove regex',
+      'removeRegexHint': 'Global regex; matches are removed before synthesis.',
+      'customBaseUrl': 'Custom TTS endpoint',
+      'customBaseUrlHint': 'OpenAI-compatible origin, e.g. http://localhost:8880/v1; empty = off.',
+      'customKeyEnv': 'Custom key env',
+      'customKeyEnvHint': 'Credential name for the custom endpoint bearer key.',
+
+      'localEnginesTitle': 'Local Engines (Offline)',
+      'localEnginesHint': 'Run speech synthesis 100% offline without API keys.',
+      'enableLocalEngines': 'Enable local engines',
+      'enableLocalEnginesHint': 'Use Kokoro or F5-TTS when installed.',
+      'streamingEnabled': 'Instant streaming (< 300 ms)',
+      'streamingEnabledHint': 'Play audio via AudioWorklet and SSE in real-time.',
+      'useKokoro': 'Enable Kokoro-82M (CPU)',
+      'useKokoroHint': 'Fast neural synthesis on CPU.',
+      'useF5': 'Enable F5-TTS (GPU)',
+      'useF5Hint': 'High-fidelity zero-shot synthesis on NVIDIA GPU.',
+      'installed': 'Installed',
+      'notInstalled': 'Not installed',
+      'downloading': 'Downloading',
+      'installKokoro': 'Install (350 MB)',
+      'installF5': 'Install (2.1 GB)',
+      'deleteModel': 'Delete',
+
+      'voiceDuplexTitle': 'Voice Duplex (Voice-to-Voice)',
+      'voiceDuplexHint': 'Interactive voice conversation integrated with dsh-voice.',
+      'voiceNotInstalledTitle': 'Required plugin @goodandready/dsh-voice is not installed',
+      'voiceInstallHint': 'To enable voice duplex, install the plugin with',
+      'voiceDuplex': 'Voice-to-Voice mode',
+      'voiceDuplexHintToggle': 'Automatically synthesize agent reply when finished talking.',
+      'vadBargeIn': 'VAD Barge-in',
+      'vadBargeInHint': 'Mute speech synthesis immediately when user voice is detected.',
+      'newSubagentRole': 'Subagent name (e.g. coder, reviewer)',
+      'addSubagentRole': 'Add Subagent',
+      'role_coder': 'Coder',
+      'role_reviewer': 'Reviewer',
+      'role_planner': 'Planner',
+
+      'enableItDictionary': 'Built-in IT dictionary',
+      'enableItDictionaryHint': 'Auto-correct pronunciation for SQL, Nginx, K8s, Docker, API, JSON, YAML, etc.',
+      'loadItDictionary': 'Populate IT terms',
+      'previewRule': 'Listen',
+
+      'messengerIntegrationTitle': 'Messenger Integration (Telegram, Discord)',
+      'messengerIntegrationHint': 'Voice replies and notes sent through @goodandready/dsh-messenger-gateway.',
+      'messengerNotInstalledTitle': 'Required plugin @goodandready/dsh-messenger-gateway is not installed',
+      'messengerInstallHint': 'To enable voice notes in messengers, install the plugin with',
+      'messengerTtsEnabled': 'Voice replies in messengers',
+      'messengerTtsEnabledHint': 'Allow messenger bridge to synthesize voice notes for agent replies.',
+
+      'dockLabel': 'Speech',
+      'dockPause': 'Pause',
+      'dockResume': 'Resume speech',
+      'dockStop': 'Stop speech',
+    }
+    const ru = {
+      'statusOnline': 'Хост на связи',
+      'statusOffline': 'Хост недоступен',
+      'cacheStats': 'Кэш',
+
+      'dockLabel': 'Чтение',
+      'dockPause': 'Пауза',
+      'dockResume': 'Продолжить чтение',
+      'dockStop': 'Прекратить чтение',
+
+      'general': 'Общее',
+      'loading': 'Загрузка…',
+      'chainHintCard': 'Выберите провайдера, вставьте ключ и нажмите «Сохранить» (или просто уйдите из поля). Ключ сразу попадает в хранилище учётных данных харнесса; браузер его обратно не читает.',
+      'speakRepliesHint': 'Каждый законченный ответ озвучивается на стороне харнесса и играет в этом браузере. Звук модели не отправляется.',
+      'chainHint': 'Порядок сверху вниз — порядок отката. Ключи облачных провайдеров попадают в хранилище учётных данных харнесса, а не в настройки плагина.',
+      'title': 'Озвучка',
+      'speakReplies': 'Читать ответы агента',
+      'speakAsItGoes': 'Читать по ходу',
+      'speakAsItGoesHint': 'Читать каждый ответ, как только он пришёл, предложениями, не дожидаясь конца хода.',
+      'rate': 'Скорость чтения',
+      'rateHint': 'От 0.5 до 2. Синтез не меняется — быстрее или медленнее играет браузер.',
+      'bargeIn': 'Замолкать, когда вы заговорили',
+      'bargeInHint': 'Прекращать чтение, как только открылся микрофон.',
+      'announce': 'Объявлять запрос подтверждения',
+      'announceHint': 'Говорить вслух и подавать сигнал, когда агент остановился ради подтверждения или задал вопрос.',
+      'approvalText': 'Что говорить о подтверждении',
+      'approvalHint': 'Произносится при запросе подтверждения; имя инструмента добавляется следом.',
+      'questionText': 'Что говорить о вопросе',
+      'questionHint': 'Произносится, когда агент задал вопрос. Пусто — не произносить.',
+      'chime': 'Сигнал',
+      'chimeHint': 'ding, beep или none.',
+      'language': 'Язык',
+      'languageHint': 'Подсказка для голосов, которым нужен язык (eSpeak, Azure SSML).',
+      'piperModel': 'Piper: путь к модели',
+      'piperModelHint': 'Абсолютный путь к модели ONNX. Пусто — Piper пропускается.',
+      'piperBin': 'Piper: бинарь',
+      'binHint': 'Ищется в PATH, если путь не абсолютный.',
+      'espeakBin': 'eSpeak: бинарь',
+      'espeakHint': 'Обычно espeak-ng.',
+      'edgeBin': 'edge-tts: бинарь',
+      'edgeHint': 'Консольная утилита из пакета edge-tts.',
+      'azureRegion': 'Azure: регион',
+      'azureHint': 'Нужен провайдеру azure, например eastus.',
+      'openaiBaseUrl': 'OpenAI base URL',
+      'openaiBaseUrlHint': 'OpenAI-совместимый origin для провайдера openai.',
+      'mimoBaseUrl': 'MiMo base URL',
+      'mimoBaseUrlHint': 'Корень API MiMo; синтез идёт через chat endpoint.',
+      'mimoFormat': 'Формат MiMo',
+      'mimoFormatHint': 'mp3 или wav.',
+      'minimaxBin': 'MiniMax CLI',
+      'minimaxBinHint': 'Ищется в PATH, если путь не абсолютный; вход в CLI — отдельно.',
+      'advancedTitle': 'Дополнительно',
+      'advancedHint': 'Лимиты и override endpoint. API-ключи — в редакторе цепочки; имена credential-слотов (*KeyEnv) — только в конфиге.',
+      'maxChars': 'Максимум символов',
+      'maxCharsHint': 'Жёсткий лимит до обработки длинных ответов; 0 — без лимита.',
+      'sentenceChars': 'Размер куска (символы)',
+      'sentenceCharsHint': 'Максимум символов в streaming-куске предложения.',
+      'timeoutMs': 'Таймаут провайдера (мс)',
+      'timeoutMsHint': 'Прервать попытку провайдера через столько миллисекунд.',
+      'maxQueue': 'Длина очереди',
+      'maxQueueHint': 'Отбрасывать самые старые куски сверх этого числа.',
+      'chainTitle': 'Цепочка провайдеров',
+      'addProvider': 'Добавить провайдера',
+      'localProvider': 'Локальный провайдер — ключ не нужен',
+      'configured': 'Ключ задан',
+      'notSet': 'Ключа нет',
+      'fromEnv': 'Задан в окружении',
+      'clear': 'Убрать',
+      'remove': 'Удалить',
+      'up': 'Выше',
+      'down': 'Ниже',
+      'save': 'Сохранить',
+      'saved': 'Сохранено',
+      'cardHint': 'Цепочка провайдеров, голоса и параметры чтения.',
+      'skipCode': 'Пропускать код',
+      'skipCodeHint': 'Вместо чтения кода вслух — короткая пометка.',
+      'cache': 'Кэш синтеза',
+      'cacheHint': 'Повторяющиеся фразы не синтезируются заново.',
+      'cacheMaxMb': 'Лимит кэша, МБ',
+      'cacheMaxMbHint': 'Сначала вытесняется самое давнее по использованию.',
+      'clearCache': 'Очистить кэш',
+      'pronTitle': 'Произношение',
+      'pronHint': 'Правила работают сверху вниз; /…/ в левой части — регулярка; Язк ограничивает правило.',
+      'pronFrom': 'Заменить',
+      'pronTo': 'На',
+      'pronWhole': 'Целое слово',
+      'pronLang': 'Язк',
+      'addRule': 'Добавить правило',
+      'rolesTitle': 'Голоса ролей',
+      'rolesHint': 'Пустые поля наследуют основную цепочку.',
+      'roleReply': 'Ответ',
+      'roleApproval': 'Подтверждение',
+      'roleError': 'Ошибка',
+      'longReply': 'Длинные ответы',
+      'longReplyHint': 'truncate: обрезать; summarize: короткий пересказ; full: читать целиком.',
+      'summaryModel': 'Модель пересказа',
+      'summaryModelHint': 'provider/model, пусто — как у разговора.',
+      'summarySentences': 'Длина пересказа',
+      'summarySentencesHint': 'Предложений в озвучиваемом пересказе.',
+      'preview': 'Проба',
+      'statsTitle': 'Статистика',
+      'statTotal': 'Всего',
+      'statHits': 'Кэш-хиты',
+      'statErrors': 'Ошибки',
+      'statReset': 'Сбросить',
+
+      'autoDetect': 'Автоязык по куску',
+      'autoDetectHint': 'Подсказывать провайдеру ru/en по каждому куску вместо общей настройки.',
+      'narrateQuotesOnly': 'Только цитаты',
+      'narrateQuotesHint': 'Читать только фрагменты в кавычках.',
+      'skipActions': 'Пропускать *действия*',
+      'skipActionsHint': 'Вырезать блоки в звёздочках.',
+      'removeRegex': 'Регулярка вырезания',
+      'removeRegexHint': 'Глобальная регулярка: совпадения удаляются перед синтезом.',
+      'customBaseUrl': 'Свой TTS endpoint',
+      'customBaseUrlHint': 'OpenAI-compatible base URL, e.g. http://localhost:8880/v1; empty disables it.',
+      'customKeyEnv': 'Имя ключа для endpoint',
+      'customKeyEnvHint': 'Имя credential для Bearer-ключа своего endpointа.',
+
+      'localEnginesTitle': 'Локальные движки (Offline)',
+      'localEnginesHint': 'Автономный синтез без API-ключей и интернета.',
+      'enableLocalEngines': 'Включить локальные движки',
+      'enableLocalEnginesHint': 'Использовать Kokoro или F5-TTS при наличии моделей.',
+      'streamingEnabled': 'Мгновенный потоковый звук (< 300 мс)',
+      'streamingEnabledHint': 'Воспроизводить звук через AudioWorklet и SSE без задержек.',
+      'useKokoro': 'Использовать Kokoro-82M (CPU)',
+      'useKokoroHint': 'Быстрый нейросинтез на процессоре.',
+      'useF5': 'Использовать F5-TTS (GPU)',
+      'useF5Hint': 'Высокоточный синтез на видеокарте NVIDIA.',
+      'installed': 'Установлена',
+      'notInstalled': 'Не установлена',
+      'downloading': 'Загрузка',
+      'installKokoro': 'Установить (350 МБ)',
+      'installF5': 'Установить (2.1 ГБ)',
+      'deleteModel': 'Удалить',
+
+      'voiceDuplexTitle': 'Голосовой диалог (Voice-to-Voice)',
+      'voiceDuplexHint': 'Интерактивный голосовой разговор при наличии плагина dsh-voice.',
+      'voiceNotInstalledTitle': 'Плагин @goodandready/dsh-voice не установлен',
+      'voiceInstallHint': 'Для включения голосового диалога установите плагин командой',
+      'voiceDuplex': 'Voice-to-Voice режим',
+      'voiceDuplexHintToggle': 'Автоматически отвечать голосом после завершения голосовой реплики.',
+      'vadBargeIn': 'VAD Barge-in',
+      'vadBargeInHint': 'Мгновенно глушить речь ассистента при обнаружении голоса пользователя.',
+      'newSubagentRole': 'Имя субагента (например, coder, reviewer)',
+      'addSubagentRole': 'Добавить субагента',
+      'role_coder': 'Кодер',
+      'role_reviewer': 'Ревьюер',
+      'role_planner': 'Планировщик',
+
+      'enableItDictionary': 'Предустановленный словарь IT-терминов',
+      'enableItDictionaryHint': 'Автоматически заменять SQL, Nginx, K8s, Docker, API, JSON, YAML и др. на правильное произношение.',
+      'loadItDictionary': 'Вставить IT-термины в таблицу',
+      'previewRule': 'Прослушать',
+
+      'messengerIntegrationTitle': 'Интеграция с мессенджерами (Telegram, Discord)',
+      'messengerIntegrationHint': 'Озвучивание ответов и голосовые заметки через @goodandready/dsh-messenger-gateway.',
+      'messengerNotInstalledTitle': 'Плагин @goodandready/dsh-messenger-gateway не установлен',
+      'messengerInstallHint': 'Для отправки голосовых сообщений в мессенджеры установите плагин командой',
+      'messengerTtsEnabled': 'Голосовые ответы в мессенджеры',
+      'messengerTtsEnabledHint': 'Разрешить мосту мессенджеров озвучивать ответы голосовыми заметками.',
+    }
+