dsh-think-translate 1.2.19 → 1.2.21

package/lib/credentials.js

@@ -1,54 +1,54 @@
-import { randomUUID } from 'node:crypto'
-
-const OWN_REF = /^DSH_XLATE_[A-F0-9]{32}$/
-
-/** Store manually entered keys with DSH; configuration contains references only. */
-export async function prepareCredentials(config, credentials) {
-  const next = JSON.parse(JSON.stringify(config))
-  const created = []
-  try {
-    for (const [id, p] of Object.entries(next.providers || {})) {
-      delete p.hasApiKey
-      if (p.source === 'dsh' || p.apiKeyEnv) {
-        delete p.apiKey
-        delete p.apiKeyRef
-        continue
-      }
-      if (typeof p.apiKey === 'string' && p.apiKey) {
-        // Ollama's compatibility placeholder is not a credential.
-        if (!(id === 'openai' && p.apiKey === 'ollama-local' && /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(?=[:/]|$)/i.test(p.baseURL || ''))) {
-          if (!credentials?.set) throw new Error('DSH credential storage is unavailable; use an existing credential reference instead')
-          const ref = 'DSH_XLATE_' + randomUUID().replaceAll('-', '').toUpperCase()
-          await credentials.set(ref, p.apiKey)
-          created.push(ref)
-          p.apiKeyRef = ref
-        }
-      }
-      delete p.apiKey
-    }
-    return { config: next, created }
-  } catch (_error) {
-    await discardCredentials(created, credentials)
-    // Storage/provider errors can contain secrets. Never forward their text.
-    throw new Error('Unable to save API key in DSH credential storage; configuration was not changed')
-  }
-}
-
-/** Remove only references created and owned by this plugin. */
-export async function discardCredentials(refs, credentials) {
-  if (!credentials?.unset) return
-  await Promise.allSettled(refs.filter(ref => OWN_REF.test(ref)).map(ref => credentials.unset(ref)))
-}
-
-/** Apply explicit key replacement/deletion while preserving omitted, masked fields. */
-export function applyCredentialEdits(next, patch) {
-  const fields = patch?.providers?._full?._full === true ? patch.providers._full : patch?.providers
-  for (const [id, p] of Object.entries(fields || {})) {
-    if (!p || typeof p !== 'object' || !next.providers?.[id] || next.providers[id].source === 'dsh') continue
-    if (Object.hasOwn(p, 'apiKey') || (typeof p.apiKeyEnv === 'string' && p.apiKeyEnv)) delete next.providers[id].apiKeyRef
-  }
-}
-
-export function ownedCredentialRefs(config) {
-  return Object.values(config?.providers || {}).map(p => p.apiKeyRef).filter(ref => typeof ref === 'string' && OWN_REF.test(ref))
-}
+import { randomUUID } from 'node:crypto'
+
+const OWN_REF = /^DSH_XLATE_[A-F0-9]{32}$/
+
+/** Store manually entered keys with DSH; configuration contains references only. */
+export async function prepareCredentials(config, credentials) {
+  const next = JSON.parse(JSON.stringify(config))
+  const created = []
+  try {
+    for (const [id, p] of Object.entries(next.providers || {})) {
+      delete p.hasApiKey
+      if (p.source === 'dsh' || p.apiKeyEnv) {
+        delete p.apiKey
+        delete p.apiKeyRef
+        continue
+      }
+      if (typeof p.apiKey === 'string' && p.apiKey) {
+        // Ollama's compatibility placeholder is not a credential.
+        if (!(id === 'openai' && p.apiKey === 'ollama-local' && /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(?=[:/]|$)/i.test(p.baseURL || ''))) {
+          if (!credentials?.set) throw new Error('DSH credential storage is unavailable; use an existing credential reference instead')
+          const ref = 'DSH_XLATE_' + randomUUID().replaceAll('-', '').toUpperCase()
+          await credentials.set(ref, p.apiKey)
+          created.push(ref)
+          p.apiKeyRef = ref
+        }
+      }
+      delete p.apiKey
+    }
+    return { config: next, created }
+  } catch (_error) {
+    await discardCredentials(created, credentials)
+    // Storage/provider errors can contain secrets. Never forward their text.
+    throw new Error('Unable to save API key in DSH credential storage; configuration was not changed')
+  }
+}
+
+/** Remove only references created and owned by this plugin. */
+export async function discardCredentials(refs, credentials) {
+  if (!credentials?.unset) return
+  await Promise.allSettled(refs.filter(ref => OWN_REF.test(ref)).map(ref => credentials.unset(ref)))
+}
+
+/** Apply explicit key replacement/deletion while preserving omitted, masked fields. */
+export function applyCredentialEdits(next, patch) {
+  const fields = patch?.providers?._full?._full === true ? patch.providers._full : patch?.providers
+  for (const [id, p] of Object.entries(fields || {})) {
+    if (!p || typeof p !== 'object' || !next.providers?.[id] || next.providers[id].source === 'dsh') continue
+    if (Object.hasOwn(p, 'apiKey') || (typeof p.apiKeyEnv === 'string' && p.apiKeyEnv)) delete next.providers[id].apiKeyRef
+  }
+}
+
+export function ownedCredentialRefs(config) {
+  return Object.values(config?.providers || {}).map(p => p.apiKeyRef).filter(ref => typeof ref === 'string' && OWN_REF.test(ref))
+}

package/lib/glossary-presets.js

@@ -0,0 +1,54 @@
+// Curated English technical terms, not an automatic word-by-word dictionary.
+// Increment the version whenever a source or translation changes (cache contract).
+export const BUILTIN_GLOSSARY_VERSION = 'technical-v1'
+const languages = ['zh-CN', 'ja', 'ko', 'es', 'fr', 'de', 'ru', 'pt']
+const rows = [
+  ['AI agent', 'AI 智能体', 'AI エージェント', 'AI 에이전트', 'agente de IA', 'agent IA', 'KI-Agent', 'ИИ-агент', 'agente de IA'],
+  ['agent', '智能体', 'エージェント', '에이전트', 'agente', 'agent', 'Agent', 'агент', 'agente'],
+  ['reasoning', '推理', '推論', '추론', 'razonamiento', 'raisonnement', 'Schlussfolgern', 'рассуждение', 'raciocínio'],
+  ['large language model', '大语言模型', '大規模言語モデル', '대규모 언어 모델', 'modelo de lenguaje de gran tamaño', 'grand modèle de langage', 'großes Sprachmodell', 'большая языковая модель', 'modelo de linguagem de grande porte'],
+  ['context window', '上下文窗口', 'コンテキストウィンドウ', '컨텍스트 창', 'ventana de contexto', 'fenêtre de contexte', 'Kontextfenster', 'контекстное окно', 'janela de contexto'],
+  ['chain of thought', '思维链', '思考の連鎖', '사고 과정', 'cadena de pensamiento', 'chaîne de pensée', 'Gedankenkette', 'цепочка рассуждений', 'cadeia de pensamento'],
+  ['prompt injection', '提示注入', 'プロンプトインジェクション', '프롬프트 주입', 'inyección de instrucciones', 'injection de prompt', 'Prompt-Injection', 'инъекция промпта', 'injeção de prompt'],
+  ['function calling', '函数调用', '関数呼び出し', '함수 호출', 'llamada a funciones', 'appel de fonctions', 'Funktionsaufruf', 'вызов функций', 'chamada de funções'],
+  ['tool calling', '工具调用', 'ツール呼び出し', '도구 호출', 'llamada a herramientas', 'appel d’outils', 'Werkzeugaufruf', 'вызов инструментов', 'chamada de ferramentas'],
+  ['fine-tuning', '微调', 'ファインチューニング', '미세 조정', 'ajuste fino', 'ajustement fin', 'Feinabstimmung', 'дообучение', 'ajuste fino'],
+  ['retrieval-augmented generation', '检索增强生成', '検索拡張生成', '검색 증강 생성', 'generación aumentada por recuperación', 'génération augmentée par récupération', 'abrufgestützte Generierung', 'генерация с дополнением поиском', 'geração aumentada por recuperação'],
+  ['embedding', '嵌入向量', '埋め込み', '임베딩', 'representación vectorial', 'plongement vectoriel', 'Einbettung', 'векторное представление', 'representação vetorial'],
+  ['inference', '推理', '推論', '추론', 'inferencia', 'inférence', 'Inferenz', 'инференс', 'inferência'],
+  ['provider', '提供方', 'プロバイダー', '제공자', 'proveedor', 'fournisseur', 'Anbieter', 'провайдер', 'provedor'],
+  ['rate limit', '速率限制', 'レート制限', '요청 속도 제한', 'límite de solicitudes', 'limite de requêtes', 'Ratenbegrenzung', 'ограничение частоты запросов', 'limite de requisições'],
+  ['API key', 'API 密钥', 'API キー', 'API 키', 'clave de API', 'clé API', 'API-Schlüssel', 'ключ API', 'chave de API'],
+  ['access token', '访问令牌', 'アクセストークン', '액세스 토큰', 'token de acceso', 'jeton d’accès', 'Zugriffstoken', 'токен доступа', 'token de acesso'],
+  ['environment variable', '环境变量', '環境変数', '환경 변수', 'variable de entorno', 'variable d’environnement', 'Umgebungsvariable', 'переменная окружения', 'variável de ambiente'],
+  ['working directory', '工作目录', '作業ディレクトリ', '작업 디렉터리', 'directorio de trabajo', 'répertoire de travail', 'Arbeitsverzeichnis', 'рабочий каталог', 'diretório de trabalho'],
+  ['command line', '命令行', 'コマンドライン', '명령줄', 'línea de comandos', 'ligne de commande', 'Befehlszeile', 'командная строка', 'linha de comando'],
+  ['pull request', '拉取请求', 'プルリクエスト', '풀 리퀘스트', 'solicitud de incorporación', 'demande de fusion', 'Pull Request', 'запрос на слияние', 'solicitação de pull'],
+  ['merge conflict', '合并冲突', 'マージ競合', '병합 충돌', 'conflicto de fusión', 'conflit de fusion', 'Zusammenführungskonflikt', 'конфликт слияния', 'conflito de mesclagem'],
+  ['version control', '版本控制', 'バージョン管理', '버전 관리', 'control de versiones', 'gestion de versions', 'Versionskontrolle', 'контроль версий', 'controle de versão'],
+  ['source code', '源代码', 'ソースコード', '소스 코드', 'código fuente', 'code source', 'Quellcode', 'исходный код', 'código-fonte'],
+  ['dependency injection', '依赖注入', '依存性注入', '의존성 주입', 'inyección de dependencias', 'injection de dépendances', 'Abhängigkeitsinjektion', 'внедрение зависимостей', 'injeção de dependências'],
+  ['unit test', '单元测试', '単体テスト', '단위 테스트', 'prueba unitaria', 'test unitaire', 'Modultest', 'модульный тест', 'teste unitário'],
+  ['integration test', '集成测试', '結合テスト', '통합 테스트', 'prueba de integración', 'test d’intégration', 'Integrationstest', 'интеграционный тест', 'teste de integração'],
+  ['regression test', '回归测试', '回帰テスト', '회귀 테스트', 'prueba de regresión', 'test de régression', 'Regressionstest', 'регрессионный тест', 'teste de regressão'],
+  ['stack trace', '堆栈跟踪', 'スタックトレース', '스택 추적', 'traza de pila', 'trace de pile', 'Stapelrückverfolgung', 'трассировка стека', 'rastreamento de pilha'],
+  ['middleware', '中间件', 'ミドルウェア', '미들웨어', 'middleware', 'intergiciel', 'Middleware', 'промежуточное ПО', 'middleware'],
+  ['callback', '回调', 'コールバック', '콜백', 'función de retorno', 'fonction de rappel', 'Rückruffunktion', 'обратный вызов', 'função de retorno'],
+  ['deadlock', '死锁', 'デッドロック', '교착 상태', 'interbloqueo', 'interblocage', 'Verklemmung', 'взаимная блокировка', 'impasse'],
+  ['race condition', '竞态条件', '競合状態', '경쟁 상태', 'condición de carrera', 'condition de concurrence', 'Wettlaufsituation', 'состояние гонки', 'condição de corrida'],
+  ['memory leak', '内存泄漏', 'メモリリーク', '메모리 누수', 'fuga de memoria', 'fuite de mémoire', 'Speicherleck', 'утечка памяти', 'vazamento de memória'],
+  ['garbage collection', '垃圾回收', 'ガベージコレクション', '가비지 컬렉션', 'recolección de basura', 'ramasse-miettes', 'Speicherbereinigung', 'сборка мусора', 'coleta de lixo'],
+  ['cache invalidation', '缓存失效', 'キャッシュの無効化', '캐시 무효화', 'invalidación de caché', 'invalidation du cache', 'Cache-Invalidierung', 'инвалидация кэша', 'invalidação de cache'],
+  ['load balancing', '负载均衡', '負荷分散', '부하 분산', 'equilibrio de carga', 'répartition de charge', 'Lastverteilung', 'балансировка нагрузки', 'balanceamento de carga'],
+  ['reverse proxy', '反向代理', 'リバースプロキシ', '리버스 프록시', 'proxy inverso', 'proxy inverse', 'Reverse Proxy', 'обратный прокси', 'proxy reverso'],
+  ['webhook', 'Webhook', 'Webhook', '웹훅', 'webhook', 'webhook', 'Webhook', 'вебхук', 'webhook'],
+  ['streaming response', '流式响应', 'ストリーミング応答', '스트리밍 응답', 'respuesta en flujo', 'réponse en continu', 'Streaming-Antwort', 'потоковый ответ', 'resposta em fluxo'],
+  ['batch processing', '批处理', 'バッチ処理', '일괄 처리', 'procesamiento por lotes', 'traitement par lots', 'Stapelverarbeitung', 'пакетная обработка', 'processamento em lote'],
+  ['fallback', '失败回退', 'フォールバック', '폴백', 'alternativa de respaldo', 'solution de repli', 'Ausweichlösung', 'резервный вариант', 'alternativa de contingência'],
+]
+const preserved = ['DeepSeek', 'Ollama', 'OpenAI', 'Anthropic', 'GitHub', 'Git', 'Node.js', 'JavaScript', 'TypeScript', 'Python', 'React', 'JSON', 'Markdown', 'SDK', 'API', 'CLI', 'LLM', 'RAG']
+const entries = Object.fromEntries(['en', ...languages].map(language => [language, Object.freeze([
+  ...rows.map(row => Object.freeze({ source: row[0], target: language === 'en' ? row[0] : row[languages.indexOf(language) + 1] })),
+  ...preserved.map(source => Object.freeze({ source, target: source })),
+])]))
+export const BUILTIN_GLOSSARY = Object.freeze({ version: BUILTIN_GLOSSARY_VERSION, entries: Object.freeze(entries) })

package/lib/glossary.js

@@ -1,138 +1,151 @@
-export const GLOSSARY_LANGUAGES = ['zh-CN', 'en', 'ja', 'ko', 'es', 'fr', 'de', 'ru', 'pt']
-export const GLOSSARY_LIMIT = 128
-
-function glossaryError(code, line = 1) {
-  return Object.assign(new Error('Invalid glossary configuration: ' + code + ' at line ' + line), { code: 'GLOSSARY_' + code, line })
-}
-
-export function validateGlossaryEntries(entries) {
-  if (!Array.isArray(entries)) throw glossaryError('FORMAT')
-  if (entries.length > GLOSSARY_LIMIT) throw glossaryError('LIMIT', GLOSSARY_LIMIT + 1)
-  const seen = new Set()
-  return entries.map((entry, index) => {
-    if (!entry || typeof entry.source !== 'string' || typeof entry.target !== 'string') throw glossaryError('FORMAT', index + 1)
-    const source = entry.source.trim(), target = entry.target.trim()
-    if (!source || !target || source.includes('=>') || /[\x00-\x1f\x7f]/.test(source + target)) throw glossaryError('FORMAT', index + 1)
-    if (source.length > 128 || target.length > 256) throw glossaryError('LIMIT', index + 1)
-    const key = source.toLowerCase()
-    if (seen.has(key)) throw glossaryError('DUPLICATE', index + 1)
-    seen.add(key)
-    return { source, target }
-  })
-}
-
-/** One literal source => target pair per nonblank line; user text is never a regex. */
-export function parseGlossaryText(text) {
-  const entries = [], lines = []
-  String(text).split(/\r?\n/).forEach((line, index) => {
-    if (!line.trim()) return
-    const separator = line.indexOf('=>')
-    if (separator < 0) throw glossaryError('FORMAT', index + 1)
-    entries.push({ source: line.slice(0, separator), target: line.slice(separator + 2) })
-    lines.push(index + 1)
-  })
-  try { return validateGlossaryEntries(entries) }
-  catch (error) { if (lines[error.line - 1]) error.line = lines[error.line - 1]; throw error }
-}
-
-export function serializeGlossary(entries) {
-  return (entries || []).map(entry => entry.source + ' => ' + entry.target).join('\n')
-}
-
-/** Validate only fields supplied by the configuration editor; keep other languages. */
-export function normalizeGlossaryPatch(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw glossaryError('FORMAT')
-  const result = {}
-  if (value.enabled !== undefined) {
-    if (typeof value.enabled !== 'boolean') throw glossaryError('FORMAT')
-    result.enabled = value.enabled
-  }
-  if (value.entries !== undefined) {
-    if (!value.entries || typeof value.entries !== 'object' || Array.isArray(value.entries)) throw glossaryError('FORMAT')
-    result.entries = {}
-    for (const [language, entries] of Object.entries(value.entries)) {
-      if (!GLOSSARY_LANGUAGES.includes(language)) throw glossaryError('LANGUAGE')
-      result.entries[language] = validateGlossaryEntries(entries)
-    }
-  }
-  return result
-}
-
-// Provider translation. Call only for prose already separated from protected code.
-export function glossaryEntriesForTarget(glossary, target) {
-  if (!glossary || glossary.enabled === false) return []
-  const tag = String(target || '').replaceAll('_', '-').toLowerCase()
-  const traditional = !/(?:^|-)hans(?:-|$)/.test(tag) && /(?:^|-)(?:hant|tw|hk|mo)(?:-|$)/.test(tag)
-  const language = /^zh(?:-|$)/.test(tag)
-    ? traditional ? null : 'zh-CN'
-    : GLOSSARY_LANGUAGES.find(language => language.toLowerCase() === tag.split('-')[0])
-  return language ? validateGlossaryEntries(glossary.entries?.[language] || []) : []
-}
-
-function escapePattern(text) { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') }
-
-function glossaryMatches(text, entries) {
-  if (!entries.length) return []
-  const sorted = entries.slice().sort((a, b) => b.source.length - a.source.length)
-  const pattern = new RegExp(sorted.map(entry => '(' + escapePattern(entry.source) + ')').join('|'), 'giu')
-  const matches = []
-  let match
-  while ((match = pattern.exec(text)) !== null) {
-    const entry = sorted[match.slice(1).findIndex(value => value !== undefined)]
-    const end = match.index + match[0].length
-    if ((/[A-Za-z0-9_]/.test(entry.source[0]) && /[A-Za-z0-9_]/.test(text[match.index - 1] || ''))
-      || (/[A-Za-z0-9_]/.test(entry.source.at(-1)) && /[A-Za-z0-9_]/.test(text[end] || ''))) continue
-    matches.push({ start: match.index, end, target: entry.target })
-  }
-  return matches
-}
-
-/** Keep a matched multiword term intact at long-input chunk boundaries. */
-export function splitGlossaryText(text, entries, fallback) {
-  if (!entries.length || text.length <= 1200) return fallback(text)
-  const matches = glossaryMatches(text, entries), chunks = []
-  let start = 0
-  while (start < text.length) {
-    let end = Math.min(start + 1200, text.length)
-    if (end < text.length) {
-      const paragraph = text.lastIndexOf('\n\n', end - 2)
-      const space = text.lastIndexOf(' ', end - 1)
-      if (paragraph > start) end = paragraph + 2
-      else if (space > start + 600) end = space + 1
-      if (/[\uD800-\uDBFF]/.test(text[end - 1]) && /[\uDC00-\uDFFF]/.test(text[end] || '')) end--
-      const crossing = matches.find(match => match.start < end && match.end > end)
-      if (crossing) end = crossing.start
-    }
-    chunks.push(text.slice(start, end))
-    start = end
-  }
-  return chunks
-}
-
-/** Restore terms only when every opaque token survives once; otherwise fail open via the provider chain. */
-export async function translateWithGlossary(text, entries, translate) {
-  if (!entries.length) return { text: await translate(text), targets: [] }
-  const matches = glossaryMatches(text, entries)
-  let prefix = 'ZXQG'
-  while (text.toLowerCase().includes(prefix.toLowerCase()) || entries.some(entry => entry.target.toLowerCase().includes(prefix.toLowerCase()))) prefix += 'Q'
-  const tokens = []
-  let cursor = 0, masked = ''
-  for (const match of matches) {
-    const token = prefix + tokens.length + 'QXZ'
-    const before = text.slice(cursor, match.start)
-    masked += before + token
-    tokens.push({ token, target: match.target })
-    cursor = match.end
-  }
-  if (!tokens.length) return { text: await translate(text), targets: [] }
-  masked += text.slice(cursor)
-  let translated = await translate(masked)
-  if (typeof translated !== 'string') throw new Error('Translation provider returned invalid glossary text')
-  for (const { token, target } of tokens) {
-    const exactToken = new RegExp(escapePattern(token), 'gi')
-    if ((translated.match(exactToken) || []).length !== 1) throw new Error('Translation provider changed a glossary token')
-    translated = translated.replace(exactToken, () => target)
-  }
-  if (translated.toLowerCase().includes(prefix.toLowerCase())) throw new Error('Translation provider returned an unknown glossary token')
-  return { text: translated, targets: [...new Set(tokens.map(token => token.target))] }
-}
+import { BUILTIN_GLOSSARY } from './glossary-presets.js'
+
+export const GLOSSARY_LANGUAGES = ['zh-CN', 'en', 'ja', 'ko', 'es', 'fr', 'de', 'ru', 'pt']
+export const GLOSSARY_LIMIT = 128
+
+function glossaryError(code, line = 1) {
+  return Object.assign(new Error('Invalid glossary configuration: ' + code + ' at line ' + line), { code: 'GLOSSARY_' + code, line })
+}
+
+export function validateGlossaryEntries(entries) {
+  if (!Array.isArray(entries)) throw glossaryError('FORMAT')
+  if (entries.length > GLOSSARY_LIMIT) throw glossaryError('LIMIT', GLOSSARY_LIMIT + 1)
+  const seen = new Set()
+  return entries.map((entry, index) => {
+    if (!entry || typeof entry.source !== 'string' || typeof entry.target !== 'string') throw glossaryError('FORMAT', index + 1)
+    const source = entry.source.trim(), target = entry.target.trim()
+    if (!source || !target || source.includes('=>') || /[\x00-\x1f\x7f]/.test(source + target)) throw glossaryError('FORMAT', index + 1)
+    if (source.length > 128 || target.length > 256) throw glossaryError('LIMIT', index + 1)
+    const key = source.toLowerCase()
+    if (seen.has(key)) throw glossaryError('DUPLICATE', index + 1)
+    seen.add(key)
+    return { source, target }
+  })
+}
+
+/** One literal source => target pair per nonblank line; user text is never a regex. */
+export function parseGlossaryText(text) {
+  const entries = [], lines = []
+  String(text).split(/\r?\n/).forEach((line, index) => {
+    if (!line.trim()) return
+    const separator = line.indexOf('=>')
+    if (separator < 0) throw glossaryError('FORMAT', index + 1)
+    entries.push({ source: line.slice(0, separator), target: line.slice(separator + 2) })
+    lines.push(index + 1)
+  })
+  try { return validateGlossaryEntries(entries) }
+  catch (error) { if (lines[error.line - 1]) error.line = lines[error.line - 1]; throw error }
+}
+
+export function serializeGlossary(entries) {
+  return (entries || []).map(entry => entry.source + ' => ' + entry.target).join('\n')
+}
+
+/** Validate only fields supplied by the configuration editor; keep other languages. */
+export function normalizeGlossaryPatch(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw glossaryError('FORMAT')
+  const result = {}
+  if (value.enabled !== undefined) {
+    if (typeof value.enabled !== 'boolean') throw glossaryError('FORMAT')
+    result.enabled = value.enabled
+  }
+  if (value.builtin !== undefined) {
+    if (typeof value.builtin !== 'boolean') throw glossaryError('FORMAT')
+    result.builtin = value.builtin
+  }
+  if (value.entries !== undefined) {
+    if (!value.entries || typeof value.entries !== 'object' || Array.isArray(value.entries)) throw glossaryError('FORMAT')
+    result.entries = {}
+    for (const [language, entries] of Object.entries(value.entries)) {
+      if (!GLOSSARY_LANGUAGES.includes(language)) throw glossaryError('LANGUAGE')
+      result.entries[language] = validateGlossaryEntries(entries)
+    }
+  }
+  return result
+}
+
+// Provider translation. Call only for prose already separated from protected code.
+export function glossaryEntriesForTarget(glossary, target) {
+  if (!glossary) return []
+  const tag = String(target || '').replaceAll('_', '-').toLowerCase()
+  const traditional = !/(?:^|-)hans(?:-|$)/.test(tag) && /(?:^|-)(?:hant|tw|hk|mo)(?:-|$)/.test(tag)
+  const language = /^zh(?:-|$)/.test(tag)
+    ? traditional ? null : 'zh-CN'
+    : GLOSSARY_LANGUAGES.find(language => language.toLowerCase() === tag.split('-')[0])
+  if (!language) return []
+  const custom = glossary.enabled === false ? [] : validateGlossaryEntries(glossary.entries?.[language] || [])
+  const builtin = glossary.builtin === true ? BUILTIN_GLOSSARY.entries[language] : []
+  // The custom limit is independent of the built-in set. Case-insensitive exact
+  // source overrides win without copying built-ins into user configuration.
+  const merged = new Map(builtin.map(entry => [entry.source.toLowerCase(), entry]))
+  custom.forEach(entry => merged.set(entry.source.toLowerCase(), entry))
+  return [...merged.values()]
+}
+
+function escapePattern(text) { return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') }
+
+function glossaryMatches(text, entries) {
+  if (!entries.length) return []
+  const sorted = entries.slice().sort((a, b) => b.source.length - a.source.length)
+  const pattern = new RegExp(sorted.map(entry => '(' + escapePattern(entry.source) + ')').join('|'), 'giu')
+  const matches = []
+  let match
+  while ((match = pattern.exec(text)) !== null) {
+    const entry = sorted[match.slice(1).findIndex(value => value !== undefined)]
+    const end = match.index + match[0].length
+    if ((/[A-Za-z0-9_]/.test(entry.source[0]) && /[A-Za-z0-9_]/.test(text[match.index - 1] || ''))
+      || (/[A-Za-z0-9_]/.test(entry.source.at(-1)) && /[A-Za-z0-9_]/.test(text[end] || ''))) continue
+    matches.push({ start: match.index, end, target: entry.target })
+  }
+  return matches
+}
+
+/** Keep a matched multiword term intact at long-input chunk boundaries. */
+export function splitGlossaryText(text, entries, fallback) {
+  if (!entries.length || text.length <= 1200) return fallback(text)
+  const matches = glossaryMatches(text, entries), chunks = []
+  let start = 0
+  while (start < text.length) {
+    let end = Math.min(start + 1200, text.length)
+    if (end < text.length) {
+      const paragraph = text.lastIndexOf('\n\n', end - 2)
+      const space = text.lastIndexOf(' ', end - 1)
+      if (paragraph > start) end = paragraph + 2
+      else if (space > start + 600) end = space + 1
+      if (/[\uD800-\uDBFF]/.test(text[end - 1]) && /[\uDC00-\uDFFF]/.test(text[end] || '')) end--
+      const crossing = matches.find(match => match.start < end && match.end > end)
+      if (crossing) end = crossing.start
+    }
+    chunks.push(text.slice(start, end))
+    start = end
+  }
+  return chunks
+}
+
+/** Restore terms only when every opaque token survives once; otherwise fail open via the provider chain. */
+export async function translateWithGlossary(text, entries, translate) {
+  if (!entries.length) return { text: await translate(text), targets: [] }
+  const matches = glossaryMatches(text, entries)
+  let prefix = 'ZXQG'
+  while (text.toLowerCase().includes(prefix.toLowerCase()) || entries.some(entry => entry.target.toLowerCase().includes(prefix.toLowerCase()))) prefix += 'Q'
+  const tokens = []
+  let cursor = 0, masked = ''
+  for (const match of matches) {
+    const token = prefix + tokens.length + 'QXZ'
+    const before = text.slice(cursor, match.start)
+    masked += before + token
+    tokens.push({ token, target: match.target })
+    cursor = match.end
+  }
+  if (!tokens.length) return { text: await translate(text), targets: [] }
+  masked += text.slice(cursor)
+  let translated = await translate(masked)
+  if (typeof translated !== 'string') throw new Error('Translation provider returned invalid glossary text')
+  for (const { token, target } of tokens) {
+    const exactToken = new RegExp(escapePattern(token), 'gi')
+    if ((translated.match(exactToken) || []).length !== 1) throw new Error('Translation provider changed a glossary token')
+    translated = translated.replace(exactToken, () => target)
+  }
+  if (translated.toLowerCase().includes(prefix.toLowerCase())) throw new Error('Translation provider returned an unknown glossary token')
+  return { text: translated, targets: [...new Set(tokens.map(token => token.target))] }
+}