dsh-chubby-whale 1.1.63 → 1.1.65

package/CHANGELOG.md

@@ -4,6 +4,53 @@
 
 ## [未发布]
 
+## [1.1.65] - 2026-11-07
+
+### 修复（B93 音色白名单同源分身）
+- **音色白名单只在客户端**：宿主 `/tts` 只做 `^[a-zA-Z0-9-]+# 更新日志
+
+本文件格式遵循 Keep a Changelog，版本号遵循语义化版本。版本号唯一来源是 `package.json`；「未发布」一节记录已进 `main`、尚未发版的内容，发版时整节改为 `## [X.Y.Z] - YYYY-MM-DD`。
+
+，HTTP 直调 `ja-JP-NanamiNeural` 会原样进引擎（旧测试里甚至写着「现状快照：仍会收到它」）。白名单提到 `shared/voices.ts`（client/host 同一份），名单外**回落默认音色**（不 400，兼容旧调用方）并带 `x-tts-voice: fallback`
+- **路由内自建引擎兜底**：`opts.engine || createEdgeTtsEngine()` 与「引擎必须在装配层构造（否则没句柄 dispose）」冲突；改为 engine 必传，构造时缺即抛（fail-fast）
+- `ports.ts` 死字段 `voice?: string` 删除
+
+### 修复（B93 ASR 断连中止分身）
+- **客户端已放弃，宿主还在跑满 60s**：`/asr` 没有断连监听，客户端 30s 超时并重试后，宿主仍把第一次识别跑完（付费调用）
+- 现在 `watchClientGone` 三条判定（`req aborted` / `req close` 且未收完 / `res close` 且未写完）——**注意不能只看 close**：正常请求 body 读完就发 close，直接判会误伤每一个正常请求
+- 断开即 abort 上游；`AbortError` 按「客户端走了」处理：只留 `[asr] ASR-CLIENT-ABORT` 诊断，**不写缓存、不计失败、不回包**
+- `host/http.ts` 的 `fetchJson/fetchWithTimeout` 支持外部 `signal`（原来会被内部超时**覆盖**掉），与超时用 `AbortSignal.any` 组合
+
+### 修复（主代理）
+- **云端日预算并发超额**：判定与记账之间有 `await fetch`，并发 N 个请求一起通过判定（最多超额 `(N-1)×单次字数`）。改为发请求前**预占**、`finally` 释放，`usage()` 仍只报已用量
+- **朗读队列丢段无人结账**：`capQueue` 只返回数量，被丢段若带 `onDone` 永远没人调（叙述锁只能等时间窗自愈）；新增 `capQueueDetailed` 返回被丢段，`voice.ts` 补 `onDone` 并清预取引用
+- **云端谎报 `x-tts-voice: fallback`**：云端用配置里的 speaker、不接收 `voice`，成功出云端时摘掉该头
+
+### 测试
+- 新增 `test-voices-shared.mjs`(60)、`test-asr-abort.mjs`(46)，接入 `npm test`；`test-persona-cloud` +3、`test-voice-queue` +4、`test-voice-routes` +2
+- 全链 **3914 项 0 失败**（`node tools/test-count.mjs`：54 个套件，失败 0，未识别 0）
+
+## [1.1.64] - 2026-11-07
+
+### 修复（B92 客户端朗读播放路径分身）
+- **`pitch` 选项完全失效**：`buildTtsJobs` 既不收也不复制 `pitch`，而 `voice.ts` 拼 `/tts` 请求体时读 `job.pitch` → 永远是空串；念诗明明传了 `+15Hz`（音高从未生效）
+- **没开麦克风却显示「在听」**：`pumpTts` 队列空时无条件 `setStatus('listening')`，而 `stopSpeaking` 是 `running ? listening : idle`；试听/说书走 `ensure()` 不开麦，念完状态就变成「在听」
+- **纯朗读实例没有看门狗**：旧实现只在 `start()` 里装 `setInterval`，而 `ensure()` 建的实例从不 `start()` → 音频元素不播也不报错时 `ttsBusy` 永久为真，之后每句只排队（表现「朗读全哑、只能刷新页面」）
+- **诊断计数虚高**：`ttsRequests++` 在冷却分支之前，走系统语音的段也被算成一次 `/tts` 请求
+- **打断整句被 dup 闸门吞**：`isRepeat(minLen:4)` 对 ≥4 字整句生效 —— 说书时连说两遍「停下来吧」「不要说了」，第二声被判重复丢弃；而 `voice-bridge` 的停止正则本应能停。现在打断整句跳过 short/dup 闸门（不去放宽 `sim.ts`，避免削弱短句去重）
+
+### 修复（B92 宿主语音路由分身）
+- **`/asr` 解码后超限回 200**：同一路由「请求体超限」走 413、「解码后超限」却回 200，代理/日志会把超限记成识别成功；统一 413
+- **`/asr` 缓存键缺 `format`**：同一份字节先以 `wav` 识别、再以 `webm` 上传会直接命中旧文本（实测 `fetch=1`、`cached:true`）；键升 v2 并加入 format，旧条目自然失效
+
+### 修复（主代理）
+- **设备 192kHz 导致半速音频**：`AudioContext.sampleRate` 跟随输出设备，192k 设备上数据是 192k 而 WAV 头被夹到 96k → ASR 整段识别必错。新增 `capSampleRate`（整数倍块平均）先降采样，**头与数据同采样率**
+- **`/tts` 静默截断**：6001 字回 HTTP 200 但引擎只收到 6000 字（听到半句、无任何信号）；改为 413 `{error:'text too large', limit:6000}`，正好 6000 仍正常
+
+### 测试
+- 新增 `test-voice-routes.mjs`(23)、`test-voice-tts.mjs`(99)，接入 `npm test`；`test-audio-sim` 补 6 条采样率断言
+- 全链 **3799 项 0 失败**（`node tools/test-count.mjs`：52 个套件，失败 0，未识别 0）
+
 ## [1.1.63] - 2026-11-07
 
 ### 修复（B91 共享层与语音子模块分身）

package/dist/client.js

@@ -25,7 +25,7 @@
   }
 
   // src/client/version.ts
-  var VERSION = "1.1.63";
+  var VERSION = "1.1.65";
 
   // src/client/styles.ts
   var W = 240;
@@ -799,6 +799,29 @@
     }
     return buf;
   }
+  function capSampleRate(samples, sampleRate, maxRate = 96e3) {
+    const src = samples || [];
+    const n = Math.max(0, src.length >>> 0);
+    const rate = Math.round(Number(sampleRate) || 48e3);
+    const cap = Math.max(8e3, Math.round(Number(maxRate) || 96e3));
+    if (rate <= cap || n === 0) {
+      const same = src instanceof Float32Array ? src : Float32Array.from(src);
+      return { samples: same, sampleRate: rate };
+    }
+    const factor = Math.max(2, Math.ceil(rate / cap));
+    const outLen = Math.floor(n / factor);
+    const out = new Float32Array(outLen);
+    for (let i = 0; i < outLen; i++) {
+      let sum = 0;
+      const base = i * factor;
+      for (let k = 0; k < factor; k++) {
+        const v = Number(src[base + k]);
+        sum += isFinite(v) ? v : 0;
+      }
+      out[i] = sum / factor;
+    }
+    return { samples: out, sampleRate: Math.round(rate / factor) };
+  }
   function wavBytes(seconds, sampleRate) {
     const sec = Math.max(0, Number(seconds) || 0);
     const sr = Math.max(8e3, Math.min(96e3, Math.round(Number(sampleRate) || 48e3)));
@@ -1007,11 +1030,14 @@
           const n = Math.min(2, Number(buf.numberOfChannels) || 1);
           for (let i = 0; i < n; i++) chans.push(buf.getChannelData(i));
           const mono = downmixToMono(chans);
-          if (wavBytes(mono.length / (Number(buf.sampleRate) || 48e3), buf.sampleRate) > maxWavBytes) {
+          const capped = capSampleRate(mono, buf.sampleRate);
+          const samples = capped.samples;
+          const rate = capped.sampleRate;
+          if (wavBytes(samples.length / rate, rate) > maxWavBytes) {
             done(null);
             return;
           }
-          done(new Blob([encodeWavPcm16(mono, buf.sampleRate)], { type: "audio/wav" }));
+          done(new Blob([encodeWavPcm16(samples, rate)], { type: "audio/wav" }));
         } catch (e) {
           done(null);
         }
@@ -1157,6 +1183,31 @@
   }
 
   // src/client/voice/echo-filter.ts
+  var SINGLE_INTERRUPT = /^[停别不]$/;
+  var INTERRUPT_PHRASES = [
+    "停下",
+    "停下来",
+    "停下来吧",
+    "停一下",
+    "停一停",
+    "停吧",
+    "别说了",
+    "别讲了",
+    "别念了",
+    "别吵",
+    "别说下去了",
+    "不要说了",
+    "不用说了",
+    "闭嘴",
+    "安静",
+    "打住",
+    "够了",
+    "暂停",
+    "算了"
+  ];
+  function isInterruptCommand(plain) {
+    return SINGLE_INTERRUPT.test(plain) || INTERRUPT_PHRASES.indexOf(plain) >= 0;
+  }
   function createEchoFilter() {
     const spokenRecent = [];
     const recentHeard = [];
@@ -1178,7 +1229,8 @@
       }
       const plain = normalizePlain(text).toLowerCase();
       const plainKey = echoKey(text).toLowerCase();
-      const interrupt = /^[停别不]$/.test(plain);
+      const interrupt = SINGLE_INTERRUPT.test(plain);
+      const stopCmd = isInterruptCommand(plain);
       if (plain.length < 2 && !interrupt) return { ok: false, reason: "trivial" };
       if (!interrupt && isNoiseText(plain)) return { ok: false, reason: "noise" };
       if (/^本鱼在听/.test(plain)) return { ok: false, reason: "self" };
@@ -1198,8 +1250,8 @@
         if (plain.length >= 6 && target.indexOf(plain.slice(0, 6)) >= 0) return { ok: false, reason: "echo" };
         if (plain.length >= 3 && now - s.at < 6e3 && target.indexOf(plain) >= 0) return { ok: false, reason: "echo" };
       }
-      if (isShortEchoFragment(plain, hadRecentSpeech)) return { ok: false, reason: "short" };
-      if (isRepeat(plain, { recent: recentHeard, windowMs: 8e3, threshold: 0.9, minLen: 4, now })) {
+      if (!stopCmd && isShortEchoFragment(plain, hadRecentSpeech)) return { ok: false, reason: "short" };
+      if (!stopCmd && isRepeat(plain, { recent: recentHeard, windowMs: 8e3, threshold: 0.9, minLen: 4, now })) {
         return { ok: false, reason: "dup" };
       }
       recentHeard.push({ text, at: now });
@@ -1285,7 +1337,7 @@
     }
   }
 
-  // src/client/voice/voices.ts
+  // src/shared/voices.ts
   var TTS_VOICES = [
     "zh-CN-XiaoyiNeural",
     "zh-CN-XiaoxiaoNeural",
@@ -1307,14 +1359,16 @@
   function normalizeVoiceName(name, fallback = DEFAULT_VOICE) {
     let n = "";
     try {
-      n = str(name).trim();
-    } catch (e) {
+      n = (name == null ? "" : String(name)).trim();
+    } catch {
       return fallback;
     }
     if (!n) return fallback;
     const hit = VOICE_BY_KEY.get(n.toLowerCase());
     return hit || fallback;
   }
+
+  // src/client/voice/voices.ts
   function readStoredVoiceName() {
     try {
       return normalizeVoiceName(localStorage.getItem("chubby-tts-voice"));
@@ -1414,11 +1468,13 @@
   }
   function buildTtsJobs(segs, opts) {
     const out = [];
+    const pitch = opts.pitch ? String(opts.pitch) : void 0;
     for (let i = 0; i < segs.length; i++) {
       out.push({
         seq: opts.nextSeq + i,
         text: segs[i],
         rate: opts.rate,
+        pitch,
         narration: opts.narration,
         attempts: 0,
         strict: opts.strict,
@@ -1431,12 +1487,11 @@
     return typeof token === "number" && token !== current;
   }
   var TTS_QUEUE_MAX = 200;
-  function capQueue(q, max = TTS_QUEUE_MAX) {
+  function capQueueDetailed(q, max = TTS_QUEUE_MAX) {
     const limit = Math.max(0, Math.floor(Number(max) || 0));
-    if (!Array.isArray(q) || q.length <= limit) return 0;
+    if (!Array.isArray(q) || q.length <= limit) return [];
     const drop = q.length - limit;
-    q.splice(0, drop);
-    return drop;
+    return q.splice(0, drop);
   }
 
   // src/client/voice/recorder.ts
@@ -1992,6 +2047,10 @@
       } catch (e) {
       }
     }
+    function ensureTtsWatch() {
+      if (ttsWatch) return;
+      ttsWatch = setInterval(ttsWatchdog, TTS_WATCH_MS);
+    }
     function ttsWatchdog() {
       try {
         const audioPlaying = !!(ttsAudio && !ttsAudio.paused && !ttsAudio.ended && ttsAudio.readyState > 0);
@@ -2147,6 +2206,7 @@
       }
     }
     function pumpTts(force) {
+      ensureTtsWatch();
       if (ttsBusy) return;
       if (ttsNextRetryAt > 0) {
         if (!force && Date.now() < ttsNextRetryAt) return;
@@ -2154,7 +2214,7 @@
       }
       const job = ttsQ.shift();
       if (!job) {
-        setStatus("listening");
+        setStatus(running ? "listening" : "idle");
         return;
       }
       ttsBusy = true;
@@ -2164,7 +2224,6 @@
       const myToken = ++speakToken;
       job.token = myToken;
       setStatus("speaking");
-      stats.ttsRequests++;
       if (ttsInCooldown() && job.attempts <= 0) {
         ttsSynthAt = 0;
         ttsDiag(job, true, "cooldown");
@@ -2175,6 +2234,7 @@
         ttsBrowserFallback(job, myToken);
         return;
       }
+      stats.ttsRequests++;
       const cached = ttsPrefetch.get(job.seq);
       const cur = cached || synth(job);
       if (cached) {
@@ -2490,6 +2550,8 @@
       echoFilter.noteSpoken(raw);
       const jobs = buildTtsJobs(segs, {
         rate,
+        // 音高一路传到 /tts 的请求体：不在这里交给队列任务，宿主永远只收到空串（B92 修）
+        pitch: o && o.pitch,
         narration,
         strict,
         nextSeq: ttsSeq + 1,
@@ -2497,8 +2559,20 @@
       });
       ttsSeq += segs.length;
       for (let i = 0; i < jobs.length; i++) ttsQ.push(jobs[i]);
-      const droppedQ = capQueue(ttsQ);
-      if (droppedQ > 0) stats.qDropped = (stats.qDropped || 0) + droppedQ;
+      const droppedJobs = capQueueDetailed(ttsQ);
+      if (droppedJobs.length > 0) {
+        stats.qDropped = (stats.qDropped || 0) + droppedJobs.length;
+        for (const d of droppedJobs) {
+          try {
+            ttsPrefetch.delete(d.seq);
+          } catch (e) {
+          }
+          try {
+            if (d && typeof d.onDone === "function") d.onDone();
+          } catch (e) {
+          }
+        }
+      }
       prefetchUpcoming(!!(ttsQ[0] && ttsQ[0].narration));
       pumpTts();
     }

package/dist/host/http.js

@@ -30,16 +30,106 @@ export function isTimeoutError(err) {
 export function timeoutSignal(ms) {
     return AbortSignal.timeout(ms);
 }
-/** 带超时的 fetch（薄封装：超时拒绝时抛 TimeoutError） */
-export async function fetchWithTimeout(url, init = {}, ms = 30000) {
-    return fetch(url, { ...(init || {}), signal: timeoutSignal(ms) });
+/** 调用方给的 signal 两种写法都认（第 4 个参数 / init.signal）；不是合法 AbortSignal 就当没给 */
+function pickSignal(signal, init) {
+    const cand = signal || (init && init.signal);
+    if (!cand)
+        return undefined;
+    return typeof cand.addEventListener === 'function' && typeof cand.aborted === 'boolean' ? cand : undefined;
+}
+/**
+ * 把「内部超时」和「调用方中止」（客户端断连等外部 signal）合成一个 signal：任一触发都中止外呼。
+ *
+ * 为什么要合：只用内部超时的话，调用方已经放弃了（客户端 30s 硬超时、切页面、断网），
+ * 宿主仍会把付费外呼跑满 ASR_TIMEOUT=60s —— 客户端早就超时重发了一次，等于同一句话付两次钱
+ * （2026-11-07 B93 取证）。
+ *
+ * 两条路：
+ *   · 有 AbortSignal.any（Node ≥20.3）就直接用：内部按弱引用管理源 signal 的监听，不会在
+ *     长期存活的 signal 上留监听；由此派生的 signal 被 fetch 直接使用；
+ *   · 老 Node 没有 any 时手写组合：把**先触发那一方**的 reason 原样转发（超时仍是 TimeoutError、
+ *     外部中止仍是 AbortError，isTimeoutError 的口径不变）。
+ *     监听怎么收尾（防重复监听/泄漏）：外部 signal 上的转发监听在「触发」或「本次外呼结束」时
+ *     立刻摘掉（dispose）；超时 signal 上的监听刻意保留到它到点 —— 那个 signal 是本次调用自己的，
+ *     而且超时必须继续盖住响应体读取（fetch resolve 之后才算开始读 body）。
+ *     代价：老 Node 上「外部中止」只覆盖到响应头返回为止（之后的 body 读取只受内部超时约束）；
+ *     Node ≥20.3 走 any 路径没有这个差别。
+ */
+function combineSignals(timeout, outer) {
+    // 没有外部 signal：原样交回超时 signal —— 与改动前完全一致（错误仍是 TimeoutError）
+    if (!outer)
+        return { signal: timeout, dispose() { } };
+    const AnySig = AbortSignal;
+    if (typeof AnySig.any === 'function') {
+        try {
+            return { signal: AnySig.any([timeout, outer]), dispose() { } };
+        }
+        catch { }
+    }
+    const ctl = new AbortController();
+    let hooked = false;
+    /** 只摘外部 signal 上的转发监听（超时那份要留到到点，body 读取还要靠它兜底） */
+    function unhookOuter() {
+        if (!hooked)
+            return;
+        hooked = false;
+        try {
+            outer.removeEventListener('abort', onAbort);
+        }
+        catch { }
+    }
+    function onAbort(ev) {
+        unhookOuter();
+        const src = ev && (ev.target || ev.currentTarget);
+        try {
+            if (src && src.reason !== undefined)
+                ctl.abort(src.reason);
+            else
+                ctl.abort();
+        }
+        catch { }
+    }
+    // 传进来就已经中止的 signal 不会再发事件：先各自判一次，否则这个请求会一直等超时
+    if (timeout.aborted || outer.aborted) {
+        const src = timeout.aborted ? timeout : outer;
+        try {
+            ctl.abort(src.reason);
+        }
+        catch { }
+        return { signal: ctl.signal, dispose() { } };
+    }
+    hooked = true;
+    try {
+        timeout.addEventListener('abort', onAbort);
+    }
+    catch { }
+    try {
+        outer.addEventListener('abort', onAbort);
+    }
+    catch { }
+    return { signal: ctl.signal, dispose: unhookOuter };
+}
+/**
+ * 带超时的 fetch（薄封装：超时拒绝时抛 TimeoutError）。
+ * 可选第 4 个参数 signal（也认 init.signal）：调用方中止时立刻中断，错误名为 AbortError；
+ * 不传时行为与改动前一致。
+ */
+export async function fetchWithTimeout(url, init = {}, ms = 30000, signal) {
+    const combo = combineSignals(timeoutSignal(ms), pickSignal(signal, init));
+    try {
+        return await fetch(url, { ...(init || {}), signal: combo.signal });
+    }
+    finally {
+        combo.dispose();
+    }
 }
 /**
  * 带超时的 fetch + 一次性读文本（能解析就顺手给 JSON）。
  * 不因 HTTP 非 2xx 抛错——路由要自己拿 status 决定回什么文案。
+ * signal：可选，调用方（如客户端断连）中止时立刻中断外呼。
  */
-export async function fetchJson(url, init = {}, ms = 30000) {
-    const resp = await fetchWithTimeout(url, init, ms);
+export async function fetchJson(url, init = {}, ms = 30000, signal) {
+    const resp = await fetchWithTimeout(url, init, ms, signal);
     const text = await resp.text().catch(() => '');
     let data = null;
     try {

package/dist/host/routes/asr.js

@@ -2,7 +2,8 @@
  * host/routes/asr.ts —— 语音识别路由（硅基流动 Qwen3-ASR）
  * POST JSON { audio: base64, format: 'webm'|'wav'|'mp3' } → { text }
  * Key 由入口注入（getKey），路由不再自己读 config.json / 环境变量。
- * 体积：请求体（base64）上限 12MB → 413；解码后音频上限 8MB；外呼超时 60 秒
+ * 体积：请求体（base64）上限 12MB → 413；解码后音频上限 8MB → 同样 413（口径统一，2026-11-07）
+ * 外呼超时 60 秒；**客户端断开（30s 硬超时/切页/断网）立刻中止外呼**，不再把付费识别跑满 60s（B93）
  */
 import { hashBytes } from '../../shared/hash.js';
 import { isInterruptWord, isNoiseText } from '../../shared/noise.js';
@@ -19,8 +20,76 @@ const ASR_MAX_BODY = 12 * 1024 * 1024;
 const ASR_MAX_AUDIO = 8 * 1024 * 1024;
 /** 外呼超时：60 秒 */
 const ASR_TIMEOUT = 60 * 1000;
+/**
+ * 客户端已经走了的日志标签：与真正的上游超时/网络错误分开，排障时一眼能分清。
+ * 分两条是因为两种时机差一步：外呼发出后断开（中止外呼）/ 请求体还没读完就断开（根本没发起外呼）。
+ */
+const LOG_CLIENT_ABORT_OUTBOUND = '[asr] ASR-CLIENT-ABORT 客户端已断开，上游外呼已中止（不计入 ASR 失败）';
+const LOG_CLIENT_ABORT_REQUEST = '[asr] ASR-CLIENT-ABORT 客户端已断开，请求中止（未发起外呼，不计入 ASR 失败）';
+/**
+ * 盯住「客户端是不是走了」。返回的 signal 会被合进外呼超时（见 host/http.ts 的 fetchWithTimeout），
+ * 客户端一走，还在等上游的那次付费外呼就立刻中止。
+ *
+ * 为什么不能只听 req 的 close（Node 24 本机实测，时间线见 scripts/test-asr-abort.mjs）：
+ * 请求体读完时 req 就会发 close（此时 req.complete=true、res.writableEnded=false、响应还没写）——
+ * 只看 close 会把**每个正常请求**都误判成断连。真正的断连有三种形状：
+ *   ① req 'aborted'：请求体还没收完客户端就断了（Node 24 实测会发，虽已标记废弃）；
+ *   ② req 'close' 且 req.complete === false：①的兜底（老版本/某些客户端不发 aborted）；
+ *   ③ res 'close' 且响应没写完（writableEnded 与 writableFinished 都为 false）：客户端发完了
+ *      body、等不到结果先走了 —— 客户端 30s 硬超时就是这个形状（宿主还在跑 60s 的那次）。
+ * 正常结束的 res 'close' 里 writableFinished=true，不会命中 ③，所以不会误中止正常请求。
+ */
+function watchClientGone(req, res) {
+    const ctl = new AbortController();
+    let gone = false;
+    const mark = () => {
+        if (gone)
+            return;
+        gone = true;
+        try {
+            ctl.abort();
+        }
+        catch { }
+    };
+    const onReqAborted = () => mark();
+    const onReqClose = () => { if (!req || req.complete === false)
+        mark(); };
+    const onResClose = () => { if (!res || !(res.writableEnded || res.writableFinished))
+        mark(); };
+    const on = (target, ev, fn) => {
+        // 测试里的假 req/res 未必是 EventEmitter：没有 on 就静默跳过（既有用例都是这种形状）
+        if (!target || typeof target.on !== 'function')
+            return;
+        try {
+            target.on(ev, fn);
+        }
+        catch { }
+    };
+    const off = (target, ev, fn) => {
+        if (!target || typeof target.removeListener !== 'function')
+            return;
+        try {
+            target.removeListener(ev, fn);
+        }
+        catch { }
+    };
+    on(req, 'aborted', onReqAborted);
+    on(req, 'close', onReqClose);
+    on(res, 'close', onResClose);
+    return {
+        signal: ctl.signal,
+        gone: () => gone,
+        dispose() {
+            off(req, 'aborted', onReqAborted);
+            off(req, 'close', onReqClose);
+            off(res, 'close', onResClose);
+        },
+    };
+}
 export function createAsrHandler(opts) {
     return async function handleAsr(req, res) {
+        // 先挂上断连观察器：从读 body 到外呼返回的整段都在它的看护下，结束时必须 dispose（finally）
+        const client = watchClientGone(req, res);
         try {
             const parsed = await readJsonBody(req, ASR_MAX_BODY);
             if (!parsed.ok) {
@@ -49,9 +118,13 @@ export function createAsrHandler(opts) {
                 return;
             }
             const buf = Buffer.from(audioB64, 'base64');
-            // 解码后再判音频上限（8MB）
+            // 解码后再判音频上限（8MB）。
+            // 必须与上面「请求体超限」同一口径回 413：同一个路由对「太大」给出 200/413 两种状态码，
+            // 客户端虽只看 ok 字段、表现不变，但代理、网关、访问日志只认状态码——200 会被记成
+            // 「识别成功」，排障时查不出来（2026-11-07 B92 实测：8MB+1 字节走的正是这条分支）。
             if (buf.length > ASR_MAX_AUDIO) {
-                sendJson(res, { ok: false, error: 'audio too large', text: '' });
+                console.error('[asr] AUDIO-TOO-LARGE ' + buf.length + ' bytes > ' + ASR_MAX_AUDIO);
+                sendJson(res, { ok: false, error: 'audio too large', text: '' }, 413);
                 return;
             }
             const key = opts.getKey();
@@ -61,7 +134,12 @@ export function createAsrHandler(opts) {
             }
             // 用完整音频字节做 key（只取前 4000 字符容易撞 key）
             // key 里带模型名：换 ASR 模型后不会命中旧文本
-            const ck = hashBytes(Buffer.concat([Buffer.from('v1|' + ASR_MODEL + '|'), buf]));
+            // key 里还必须带 format：同一份字节在 multipart 里声明的 Content-Type / filename 不同，
+            // 上游的解码方式就不同。原来只按「模型 + 字节」缓存，实测同一份字节先用 format=wav
+            // 识别成功，再以 format=webm 上传会直接命中上一次的文本（cached:true）——A 容器的结果
+            // 顶了 B 容器的请求。v1 前缀的旧条目没有 format，刻意升到 v2 让它们自然失效（7 天 TTL 内
+            // 最多少几次命中，不会读出别人的文本）。
+            const ck = hashBytes(Buffer.concat([Buffer.from('v2|' + ASR_MODEL + '|' + format + '|'), buf]));
             if (opts.cache) {
                 const hit = await opts.cache.getJson(ck, 'json', ASR_CACHE_MAX_AGE);
                 if (hit && typeof hit.text === 'string') {
@@ -92,9 +170,18 @@ export function createAsrHandler(opts) {
                         'content-type': 'multipart/form-data; boundary=' + boundary,
                     },
                     body: payload,
-                }, ASR_TIMEOUT);
+                }, ASR_TIMEOUT, client.signal);
             }
             catch (err) {
+                // 客户端已经走了（30s 硬超时/切页面/断网重发）：这次外呼是**我们自己** abort 的，
+                // 不是上游超时、也不是网络故障。处理口径：
+                //   · 不写缓存（没拿到结果，也避免把半截状态记进缓存）；
+                //   · 不记失败（不计入 ASR-TIMEOUT/ASR-NETWORK 的排障口径），只留专用诊断；
+                //   · 不回包（连接已经断了，没人收；写了也只是往死 socket 上叠一次写）。
+                if (client.gone()) {
+                    console.error(LOG_CLIENT_ABORT_OUTBOUND);
+                    return;
+                }
                 // 超时/网络错误：用户看到的仍是 ok:false + 空文本，日志里留标签
                 if (isTimeoutError(err))
                     console.error('[asr] ASR-TIMEOUT ' + ASR_TIMEOUT + 'ms 无响应，已中止');
@@ -125,9 +212,19 @@ export function createAsrHandler(opts) {
         }
         catch (err) {
             try {
+                // 连请求体都没收完客户端就断了（req 'aborted' / ECONNRESET）：同上，不算上游失败、不回包
+                if (client.gone()) {
+                    console.error(LOG_CLIENT_ABORT_REQUEST);
+                    return;
+                }
                 sendError(res, err, { text: '' });
             }
             catch { }
         }
+        finally {
+            // 结束就摘监听：req/res 是每请求对象，不摘也不会串到下一个请求，但已经结束的 handler
+            // 没必要继续响应 'close'/'aborted'（多做一次无意义的 abort），排障时也容易看花眼
+            client.dispose();
+        }
     };
 }

package/dist/host/routes/tts.js

@@ -1,15 +1,17 @@
 /**
  * host/routes/tts.ts —— 语音合成路由（可复用模块，带缓存）
- * HTTP/缓存/参数校验在本文件；「怎么合成」交给注入的 TtsEngine（默认 host/tts-engine.ts 的 edge-tts）。
+ * HTTP/缓存/参数校验在本文件；「怎么合成」交给**装配层注入**的 TtsEngine（host/tts-engine.ts 的 edge-tts）。
  * 缓存：文本+音色+语速+音调 hash → 复用 mp3（省时间、省调用）
  * 语速由请求体 rate 决定（说书 -15%，普通聊天 +0%），服务端不再写死。
+ * 音色：先过 `^[a-zA-Z0-9-]+$` 字符集，再用 shared/voices.ts 的白名单（与客户端菜单同一份）；
+ *       白名单外一律回落默认音色（不 400，避免破坏旧调用方），响应头 x-tts-voice: fallback 便于排障。
  */
 import { hashKey } from '../../shared/hash.js';
 import { sendTooLarge } from '../http.js';
 import { readJsonBody } from '../body.js';
 import { sendJson, sendBuffer } from '../respond.js';
 import { normalizeRate, TTS_UNAVAILABLE } from '../../shared/tts.js';
-import { createEdgeTtsEngine } from '../tts-engine.js';
+import { DEFAULT_VOICE, normalizeVoiceName } from '../../shared/voices.js';
 /** 单次合成的安全上限：客户端已按 80 字分段，这里只防整本大 JSON 被一次送进来 */
 const MAX_TEXT = 6000;
 /** 请求体上限：80 字一段的 JSON 只有几百字节，64KB 足够；超了多半是误发了整本数据 */
@@ -30,8 +32,14 @@ function oneLine(err, max = 220) {
     return String((err && err.message) || err || '').replace(/\s+/g, ' ').trim().slice(0, max);
 }
 export function createTtsHandler(opts) {
+    // 引擎必须由装配层构造并注入（src/index.ts），路由内**不再**自建：
+    // createEdgeTtsEngine 持有常驻 python 子进程，而路由工厂只交出 handler 函数，
+    // 自建的实例句柄谁也拿不到 → 插件卸载/热重载时没有对象可以 dispose()（B92 封装债，B93 去兜底）。
+    // 运行时也显式挡一道：JS 调用方漏传时构造即失败，而不是等到合成那一步才 500。
+    if (!opts || !opts.engine)
+        throw new Error('createTtsHandler: engine 必传（由装配层构造并注入，测试注入桩）');
     const cache = opts.cache;
-    const engine = opts.engine || createEdgeTtsEngine();
+    const engine = opts.engine;
     // 每个 handler 一份闸门状态：测试里多次 createTtsHandler 互不串味
     const failGuard = { streak: 0, until: 0 };
     // 预热常驻 worker（只解析解释器、导入依赖，不合成）：首句不必再等 python 启动。
@@ -54,13 +62,34 @@ export function createTtsHandler(opts) {
                 return;
             }
             const body = parsed.body;
-            const msg = typeof body?.text === 'string' ? body.text.trim().slice(0, MAX_TEXT) : '';
-            const voiceIn = typeof body?.voice === 'string' ? body.voice : '';
-            const isZh = /[\u4e00-\u9fa5]/.test(msg);
-            let voice = (voiceIn && /^[a-zA-Z0-9-]+$/.test(voiceIn)) ? voiceIn : '';
-            if (!voice || voice === 'auto' || voice === 'zh-CN-XiaoyiNeural' || voice === 'en-US-AnaNeural') {
-                voice = isZh ? 'zh-CN-XiaoyiNeural' : 'en-US-AnaNeural';
+            const rawText = typeof body?.text === 'string' ? body.text.trim() : '';
+            // 超长不再静默截断（2026-11-07 B92 审计）：原来 slice(0, MAX_TEXT) 会回 200，
+            // 但引擎只收到前 6000 字 —— 调用方听到的是半句话、却没有任何信号。
+            // 客户端本来就按句切分后再请求，这里超限基本只可能是外部直调：明确回 413 更诚实。
+            if (rawText.length > MAX_TEXT) {
+                sendJson(res, { ok: false, error: 'text too large', limit: MAX_TEXT }, 413);
+                return;
             }
+            const msg = rawText;
+            const voiceIn = typeof body?.voice === 'string' ? body.voice.trim() : '';
+            const isZh = /[\u4e00-\u9fa5]/.test(msg);
+            // 默认按文本语言选（中文晓伊 / 英文 Ana）：'auto' 与「显式传这两个默认音色」都走这条，保持旧行为
+            const langDefault = isZh ? DEFAULT_VOICE : 'en-US-AnaNeural';
+            // 第一道：字符集（历史行为，先于白名单）—— 防 CRLF/引号/shell 元字符进日志与参数
+            const charsetOk = !!voiceIn && /^[a-zA-Z0-9-]+$/.test(voiceIn);
+            // 第二道：白名单，与客户端菜单共用 shared/voices.ts；大小写脏值归一成白名单里的规范写法
+            // fallback 传 '' 表示「没命中就交回给我」，便于下面区分「没传音色」与「传了但不在名单」
+            const known = charsetOk ? normalizeVoiceName(voiceIn, '') : '';
+            // 白名单外（含字符合法但不认识的音色，如 ja-JP-NanamiNeural）→ 回落默认，**不回 400**：
+            // 旧调用方传坏值仍要能出声（B92 的「HTTP 直调绕过白名单」在此收口，成本/策略缺口关闭）。
+            const voiceFallback = voiceIn !== '' && !known;
+            const voice = (!known || known === 'auto' || known === DEFAULT_VOICE || known === 'en-US-AnaNeural')
+                ? langDefault
+                : known;
+            // 音频响应头：排障用；只在请求的音色确实被替换时带 x-tts-voice: fallback（正常请求与 auto 不带）
+            const audioHeaders = { 'cache-control': 'no-store' };
+            if (voiceFallback)
+                audioHeaders['x-tts-voice'] = 'fallback';
             // 请求体里带了合法 rate 就用它（说书 -15%），没带默认 +0%
             const rate = normalizeRate(body?.rate, '+0%');
             // 音高：允许请求体指定（带情绪的语气），非法值回落到默认
@@ -75,7 +104,7 @@ export function createTtsHandler(opts) {
             if (cache) {
                 const hit = await cache.getJson(ck, 'mp3');
                 if (hit) {
-                    sendBuffer(res, hit, 'audio/mpeg', { 'cache-control': 'no-store' });
+                    sendBuffer(res, hit, 'audio/mpeg', audioHeaders);
                     return;
                 }
             }
@@ -90,6 +119,10 @@ export function createTtsHandler(opts) {
             if (cloud && cloud.enabled()) {
                 try {
                     buf = await cloud.synthesize(msg);
+                    // 云端不接收 voice（用配置里的 speaker），所以「音色被替换」在云端路径上不成立：
+                    // 成功出云端时把 fallback 头摘掉，别让排障的人以为客户端音色真的生效了（2026-11-07 B93）。
+                    if (voiceFallback)
+                        delete audioHeaders['x-tts-voice'];
                 }
                 catch (ce) {
                     console.warn('[tts] CLOUD-FAIL 回退 edge-tts：' + String(ce?.message || ce).slice(0, 200));
@@ -108,7 +141,7 @@ export function createTtsHandler(opts) {
                 }
                 catch { }
             }
-            sendBuffer(res, buf, 'audio/mpeg', { 'cache-control': 'no-store' });
+            sendBuffer(res, buf, 'audio/mpeg', audioHeaders);
         }
         catch (err) {
             try {

package/dist/host/voice/cloud-tts.js

@@ -181,6 +181,12 @@ export function createCloudTts(deps) {
      * 重启后才有丢计数的风险（写盘成功时磁盘自然追平，不会重复计数）。
      */
     let memUsage = null;
+    /**
+     * 在途预占字数（2026-11-07 B93）：判定与记账之间隔着 await fetch，并发 N 个请求
+     * 会一起通过判定，最多超额 (N-1)×单次字数。这里在发请求前先「预占」，判定时把预占算进去，
+     * 请求结束（成功或失败）在 finally 释放。预占只影响熔断判定，不影响 usage() 报告的已用量。
+     */
+    let reservedChars = 0;
     /** 今天已用字数：磁盘与内存取大（磁盘可能是别的实例写的，内存是本进程的最低保障） */
     function usedChars(today) {
         const u = readUsage(deps.runtimeDir);
@@ -189,7 +195,8 @@ export function createCloudTts(deps) {
         return Math.max(fromDisk, fromMem);
     }
     function budgetLeft(cfg, today) {
-        return cfg.dailyChars - usedChars(today);
+        // 已用量 + 在途预占：并发请求不会同时看到「还有额度」
+        return cfg.dailyChars - usedChars(today) - reservedChars;
     }
     return {
         enabled() {
@@ -219,6 +226,8 @@ export function createCloudTts(deps) {
                 ctl && ctl.abort();
             }
             catch { } }, timeoutMs);
+            // 先占额度再发请求：判定与记账之间的 await 期间，别的请求不能再用同一份额度
+            reservedChars += body.length;
             try {
                 const res = await fetch(CLOUD_TTS_URL, {
                     method: 'POST',
@@ -277,6 +286,8 @@ export function createCloudTts(deps) {
             }
             finally {
                 clearTimeout(timer);
+                // 释放预占：成功时已记进用量（磁盘/内存），失败时这份额度要还回去
+                reservedChars = Math.max(0, reservedChars - body.length);
             }
         },
     };

package/dist/shared/voices.js

@@ -0,0 +1,62 @@
+/**
+ * shared/voices.ts —— 朗读音色白名单与归一化（宿主 /tts 与浏览器菜单共用同一份）
+ *
+ * 为什么放在 shared：白名单原先只在 client/voice/voices.ts，宿主 routes/tts.ts 只做
+ * `^[a-zA-Z0-9-]+$` 字符集校验，HTTP 直调传 `ja-JP-NanamiNeural` 这类白名单外音色
+ * 会被原样接受（B92 取证：策略/成本缺口，不是命令注入）。提到 shared 后两边共用
+ * TTS_VOICES，宿主也能按同一份名单回落，不再各自维护一份。
+ *
+ * 像 'auto' 这样的值不在 edge-tts 的语音表里，但宿主认它：按文本语言自动选晓伊/Ana。
+ *
+ * 依赖方向：shared 只依赖 shared/immutable.ts，不 import client/host。
+ */
+import { deepFreeze } from './immutable.js';
+/** 可用音色 —— 与菜单「换个声音 ▸」的列表一一对应 */
+export const TTS_VOICES = [
+    'zh-CN-XiaoyiNeural',
+    'zh-CN-XiaoxiaoNeural',
+    'zh-CN-XiaochenNeural',
+    'zh-CN-YunxiNeural',
+    'zh-CN-YunyangNeural',
+    'en-US-AnaNeural',
+    'en-US-JennyNeural',
+    'en-GB-SoniaNeural',
+    'auto',
+];
+deepFreeze(TTS_VOICES);
+/** 默认音色：晓伊（与菜单默认与 C# 版一致） */
+export const DEFAULT_VOICE = 'zh-CN-XiaoyiNeural';
+/**
+ * 白名单查表（小写名 → 规范写法）。
+ * 大小写不敏感是刻意的（2026-11-07）：手改 localStorage / 旧配置里出现
+ * "EN-US-ANANEURAL" 这类只差大小写的**合法**音色时，旧实现因为 indexOf 精确匹配
+ * 直接判成非法，把用户选的音色静默重置成晓伊。查表后返回的是白名单里的规范写法，
+ * 送给 edge-tts 的仍是大小写正确的名字。
+ * 这张表只在模块加载时构建一次、不导出，外部改不到。
+ */
+const VOICE_BY_KEY = (() => {
+    const m = new Map();
+    for (const v of TTS_VOICES)
+        m.set(v.toLowerCase(), v);
+    return m;
+})();
+/**
+ * 音色名规范化：白名单外（含空值/坏值）一律回退。
+ * @param name 待规范的音色名（来自 localStorage / 菜单 / HTTP 请求体，可能是任意坏值）
+ * @param fallback 未命中时的返回值，默认 DEFAULT_VOICE；宿主可传 '' 表示「没命中」以便自行回落
+ */
+export function normalizeVoiceName(name, fallback = DEFAULT_VOICE) {
+    // String(x) 本身会抛（Object.create(null)、自定义 toString 抛错）：
+    // 音色名从 localStorage / 菜单参数 / 请求体来，坏值只能回退，不能让整条朗读链崩在这里。
+    let n = '';
+    try {
+        n = (name == null ? '' : String(name)).trim();
+    }
+    catch {
+        return fallback;
+    }
+    if (!n)
+        return fallback;
+    const hit = VOICE_BY_KEY.get(n.toLowerCase());
+    return hit || fallback;
+}

package/docs//345/217/221/345/270/203/350/247/204/350/214/203.md

@@ -12,14 +12,14 @@
 
 | 项 | 值 |
 | --- | --- |
-| `package.json` version | 1.1.63 |
-| `src/client/version.ts` VERSION | 1.1.63（由 `scripts/gen-version.mjs` 生成） |
-| 最近 Gitee tag | `v1.1.63`（见 `git tag --list`） |
+| `package.json` version | 1.1.65 |
+| `src/client/version.ts` VERSION | 1.1.65（由 `scripts/gen-version.mjs` 生成） |
+| 最近 Gitee tag | `v1.1.65`（见 `git tag --list`） |
 | Gitee `main` HEAD | `git log -1` 实读 |
 | GitHub `main` | 发布后 `node tools/gh-verify.mjs v1.1.62` 核对（脚本按 tag 名推期望版本） |
-| npm latest | **1.1.63**（发布后轮询确认） |
+| npm latest | **1.1.65**（发布后轮询确认） |
 | README 版本 | 无硬编码版本号 |
-| `npm test` | **3671 项**（50 个套件，`node tools/test-count.mjs` 核准、失败 0） |
+| `npm test` | **3914 项**（54 个套件，`node tools/test-count.mjs` 核准、失败 0） |
 | `npm pack --dry-run` | **129 个文件 / 17.1 MB**（包）；`data/cache`、运行数据、`config.json`、`src/`、`scripts/`、`tools/` 均不进包 |
 ## 一、版本号规则
 

package/docs//345/276/205/351/207/215/345/220/257/347/224/237/346/225/210.md

@@ -355,3 +355,27 @@ Measure-Command { Invoke-RestMethod -Method Post -Uri http://127.0.0.1:3080/api/
 | 4 | 弹琴中提问会同时静琴 | `stopTts()` 原来不停琴 | 弹琴时说一句话：琴声与朗读不叠 |
 | 5 | TTS/ASR 超时现在包含响应体读取 | 以前只到响应头，慢网会永久 pending | 弱网下朗读失败会走降级/重试，而不是卡住 |
 | 6 | 诗名索引失败后会自动重试 | 原来本页永不再试 | 服务端文件缺失后补上，60s 内不刷新也能点名诗 |
+
+## 二十、2026-11-07 凌晨批次（B92：1.1.64）待重启核对
+
+| # | 改动 | 为什么 | 怎么验证 |
+|---|------|--------|----------|
+| 1 | 192kHz 设备先降采样 | 头写 96k、数据 192k = 半速，ASR 必错 | 高采样率声卡设备上说一句话：识别应正常（不出现整段错乱） |
+| 2 | `/asr` 超限统一 413 | 解码后超限原回 200，监控会记成成功 | 传超长音频：应 413 而不是「成功但空文本」 |
+| 3 | `/asr` 缓存键含 format | 换格式会命中旧格式的识别文本 | 同段音频换格式上传：文本应重新识别 |
+| 4 | `/tts` 超长回 413 | 6001 字静默截断成 6000，听到半句 | 外部直调超长文本：应 413 `text too large` |
+| 5 | 念诗的 `pitch` 真正生效 | 音高选项此前被整段丢弃 | 念诗 vs 普通朗读：音高应不同 |
+| 6 | 纯朗读后状态回 idle | 没开麦时念完显示「在听」 | 关待命→让它读一段：读完状态应回 idle，不是「在听」 |
+| 7 | 纯朗读实例也有看门狗 | 音频不播不报错时永久 `ttsBusy` → 朗读全哑 | 长时间朗读后仍能继续朗读（不必刷新） |
+| 8 | 连说两遍「停下来吧」也能停 | ≥4 字打断句被 dup 闸门吞 | 说书中连说两次「停下来吧」：第二声也应停 |
+
+## 二十一、2026-11-07 凌晨批次（B93：1.1.65）待重启核对
+
+| # | 改动 | 为什么 | 怎么验证 |
+|---|------|--------|----------|
+| 1 | `/tts` 校验音色白名单 | 原来 HTTP 直调可绕过客户端白名单 | 直调 `voice=ja-JP-NanamiNeural`：应 200 + 默认音色 + `x-tts-voice: fallback` |
+| 2 | `/tts` engine 必传 | 路由内自建引擎会让卸载时没有句柄 dispose | 反复禁用/启用插件：`tasklist` 不应堆积 python |
+| 3 | ASR 断连即中止 | 客户端 30s 超时重试后宿主仍跑满 60s（白付识别费） | 弱网下打断/关页面：日志应出现 `ASR-CLIENT-ABORT`，不再有 60s 的 `ASR-TIMEOUT` |
+| 4 | 云端预算并发不超额 | 并发请求会同时通过日预算判定 | 并发触发多段云端合成：日用量不应超过 `dailyChars` |
+| 5 | 朗读队列丢段补 onDone | >200 段时被丢的段没人结账，叙述锁只能等自愈 | 极端长文本后仍能继续朗读（不必刷新） |
+| 6 | 云端成功不再报 fallback | 云端用配置说话人，头会误导排障 | 开云端后请求：响应头不应出现 `x-tts-voice` |

package/docs//346/250/241/345/235/227/346/216/245/345/217/243/346/270/205/345/215/225.md

@@ -5,7 +5,7 @@
 > 架构宪章：**模块只对外暴露这些导出，外部不得读取模块内部实现**。
 > 新增/修改导出 = 接口变更，必须同步调用点并在提交信息里写明。
 
-> 统计：119 个模块文件，717 个导出项。
+> 统计：120 个模块文件，722 个导出项。
 
 ## 宿主（Node）（`src/host/`）
 
@@ -82,7 +82,7 @@
 | `actions/voice.ts` | `registerVoiceActions` |
 | `anim.ts` | `AnimState`、`EYE_L`、`EYE_R`、`MOUTH`、`createAnimator` |
 | `ape.ts` | `APE_DEFAULTS`、`Ape`、`ApeParams`、`ApeStep`、`simulateSegment` |
-| `audio-codec.ts` | `HostAsrFormat`、`RECORDER_MIME_CANDIDATES`、`RecFormat`、`RecorderPick`、`WAV_HEADER_BYTES`、`downmixToMono`、`encodeWavPcm16`、`formatFromMime`、`hostAsrFormat`、`pickRecorderMime`、`wavBytes` |
+| `audio-codec.ts` | `HostAsrFormat`、`RECORDER_MIME_CANDIDATES`、`RecFormat`、`RecorderPick`、`WAV_HEADER_BYTES`、`capSampleRate`、`downmixToMono`、`encodeWavPcm16`、`formatFromMime`、`hostAsrFormat`、`pickRecorderMime`、`wavBytes` |
 | `browser-tts.ts` | `browserVoiceUsable`、`speakViaBrowser`、`watchdogMs` |
 | `bubble.ts` | `BUBBLE_CSS`、`Bubble`、`BubbleOptions`、`STATUS_TEXTS`、`createBubble`、`ensureBubbleStyle` |
 | `busy.ts` | `BUSY_STALE_MS`、`BusyLock`、`Epoch`、`createBusyLock`、`createEpoch` |
@@ -124,7 +124,7 @@
 | `voice/fetch.ts` | `fetchWithTimeout` |
 | `voice/recorder.ts` | `APE_MIN_SPEECH_MS`、`CLASSIC_SPEECH_DB`、`EARLY_STOP_QUIET`、`LEVEL_PROBE_MS`、`LevelBox`、`LevelRead`、`MIN_SEGMENT_BYTES`、`MIN_SPEECH_MS`、`MUTED_SPEECH_DB`、`SILENT_PEAK_DB`、`SegmentState`、`TICK_ERROR_MS`、`TICK_MS`、`WINDOW_MS`、`accrueClassic`、`addChunk`、`clearChunks`、`createSegmentState`、`hadApeSpeech`、`isSilentPeak`、`isTooSmallSegment`、`notePeak`、`readLevel`、`resetSegmentState`、`shouldStopApeNoLevel`、`shouldStopClassic`、`takeBlob` |
 | `voice/status.ts` | `DiagSnapshots`、`StatusHolder`、`VoiceStats`、`VoiceStatus`、`createDiagSnapshots`、`createStatusHolder`、`createVoiceStats` |
-| `voice/tts-queue.ts` | `ECHO_MUTE_MS`、`TTS_QUEUE_MAX`、`TTS_RETRY_BASE_MS`、`TTS_RETRY_MAX`、`TTS_TIMEOUT_MS`、`TTS_WATCH_MS`、`TTS_ZOMBIE_MS`、`TtsJob`、`buildTtsJobs`、`capQueue`、`isStaleToken`、`narrationPauseFor`、`prefetchTargets`、`ttsRetryDelayMs` |
+| `voice/tts-queue.ts` | `ECHO_MUTE_MS`、`TTS_QUEUE_MAX`、`TTS_RETRY_BASE_MS`、`TTS_RETRY_MAX`、`TTS_TIMEOUT_MS`、`TTS_WATCH_MS`、`TTS_ZOMBIE_MS`、`TtsJob`、`buildTtsJobs`、`capQueue`、`capQueueDetailed`、`isStaleToken`、`narrationPauseFor`、`prefetchTargets`、`ttsRetryDelayMs` |
 | `voice/voices.ts` | `DEFAULT_VOICE`、`TTS_VOICES`、`normalizeVoiceName`、`readStoredVoiceName` |
 | `wake.ts` | `WAKE_WINDOW_MS`、`WAKE_WORDS`、`WAKE_WORD_KEY`、`WakeCheck`、`WakeGate`、`createWakeGate`、`loadCustomWakeWords`、`normalizeWakeText`、`setCustomWakeWord`、`stripWakeWords` |
 
@@ -140,3 +140,4 @@
 | `sse.ts` | `SseParseResult`、`parseSseBuffer` |
 | `time.ts` | `ParsedDue`、`cleanReminderText`、`formatDue`、`parseDue` |
 | `tts.ts` | `EdgeTtsOptions`、`TTS_PROBE_CODE`、`TTS_UNAVAILABLE`、`buildEdgeTtsArgs`、`cleanTtsText`、`isValidPitch`、`isValidRate`、`normalizeRate`、`splitTtsSegments` |
+| `voices.ts` | `DEFAULT_VOICE`、`TTS_VOICES`、`normalizeVoiceName` |

package/docs//350/267/250/345/271/263/345/217/260/344/270/216/345/210/206/345/267/245.md

@@ -142,3 +142,9 @@
 | B91b | 2026-11-07 | 共享层分身：`deepFreeze` 漏冻子树与 Map/Set/symbol / 噪声先 NFKC 去零宽补全角标点 / 去 6 字重复上限 / 音色白名单大小写不敏感 / 硬超时覆盖响应体；新增 `test-shared-voice.mjs`(89) | 双 tsc 0 / 3671 项 0 失败 | 见 git |
 | B91c | 2026-11-07 | 音频/模拟分身：`sim.isRepeat` 完全相等分支补 `minLen`（第二声「停」不再被吞）/ `melody` resume 1200ms 幂等看门狗；新增 `test-audio-sim.mjs`(169) | 双 tsc 0 / 3671 项 0 失败 | 见 git |
 | B91d | 2026-11-07 | 主代理：`stopTts()` 补 `melody.stop()`（P0 打断同时静琴，扬声器互斥补全另一半） | 双 tsc 0 / 3671 项 0 失败 | 见 git |
+| B92a | 2026-11-07 | 主代理：`capSampleRate` 修「192kHz 设备半速音频」（头与数据同采样率）/ `/tts` 超长改 413（不再静默截断）；`test-audio-sim` +6、`test-voice-routes` +2 | 双 tsc 0 / 3799 项 0 失败 | 见 git |
+| B92b | 2026-11-07 | 宿主语音路由分身：`/asr` 解码后超限 200→413 / 缓存键补 `format`（v1→v2）；新增 `test-voice-routes.mjs`(23) | 双 tsc 0 / 3799 项 0 失败 | 见 git |
+| B92c | 2026-11-07 | 朗读播放路径分身：`pitch` 丢失 / 没开麦报「在听」/ 纯朗读无看门狗 / `ttsRequests` 虚高 / 打断整句被 dup 吞；新增 `test-voice-tts.mjs`(99) | 双 tsc 0 / 3799 项 0 失败 | 见 git |
+| B93a | 2026-11-07 | 主代理：云端日预算**预占**（并发不再超额）/ `capQueueDetailed` 丢段结账 `onDone` 并清预取 / 云端成功不再谎报 `x-tts-voice: fallback`；`test-persona-cloud` +3、`test-voice-queue` +4、`test-voice-routes` +2 | 双 tsc 0 / 3914 项 0 失败 | 见 git |
+| B93b | 2026-11-07 | 音色白名单分身：新建 `shared/voices.ts`（client/host 同一份）/ `/tts` 名单外回落默认 + `x-tts-voice: fallback` / engine 必传去兜底 / 删 `ports.voice` 死字段；新增 `test-voices-shared.mjs`(60) | 双 tsc 0 / 3914 项 0 失败 | 见 git |
+| B93c | 2026-11-07 | ASR 断连中止分身：`watchClientGone` 三判定（不能只看 close）/ 断开 abort 上游、`AbortError` 不写缓存不计失败 / `fetchJson` 支持外部 signal（原被超时覆盖）；新增 `test-asr-abort.mjs`(46) | 双 tsc 0 / 3914 项 0 失败 | 见 git |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-chubby-whale",
-  "version": "1.1.63",
+  "version": "1.1.65",
   "description": "DSH 网页版桌面宠物「肥鲸」——蓝发鲸鱼娘，固定在 harness 页面右下角：会眨眼、能拖拽、点击可聊天，支持语音对话、念诗说书、饭点提醒。",
   "keywords": [
     "dsh",
@@ -74,7 +74,7 @@
   "scripts": {
     "build": "node scripts/gen-version.mjs && node scripts/check-bom.mjs && tsc -p tsconfig.json && tsc -p tsconfig.client.json && esbuild src/client.ts --bundle --format=iife --external:react --charset=utf8 --outfile=dist/client.js",
     "prepublishOnly": "npm run build",
-    "test": "tsc -p tsconfig.json && tsc -p tsconfig.client.json && node scripts/check-imports.mjs && node scripts/gen-module-index.mjs --check && node scripts/check-boundaries.mjs && node scripts/check-diag-keys.mjs && node scripts/check-text.mjs && node scripts/test.mjs && node scripts/test-chat-limits.mjs && node scripts/test-stream-ledger.mjs && node scripts/test-story-security.mjs && node scripts/test-behavior-regressions.mjs && node scripts/verify-voice.mjs && node scripts/smoke-client.mjs && node scripts/ape-bench.mjs && node scripts/smoke-host.mjs && node scripts/test-voice-queue.mjs && node scripts/test-tts-engine.mjs && node scripts/test-data-layer.mjs && node scripts/test-repos.mjs && node scripts/test-personality.mjs && node scripts/test-story-player.mjs && node scripts/test-chat-routes.mjs && node scripts/test-menu-actions.mjs && node scripts/test-story-client.mjs && node scripts/test-story-auto.mjs && node scripts/test-content-routes.mjs && node scripts/test-dataport-poem.mjs && node scripts/test-render-layer.mjs && node scripts/test-store-cache.mjs && node scripts/test-actions-rest.mjs && node scripts/test-misc-routes.mjs && node scripts/test-chat-client.mjs && node scripts/test-prefs-config.mjs && node scripts/test-media-reminders.mjs && node scripts/test-image-reader.mjs && node scripts/test-boundaries-guard.mjs && node scripts/test-assembly.mjs && node scripts/test-asr-concurrency.mjs && node scripts/test-host-http.mjs && node scripts/test-entry-narration.mjs && node scripts/test-poem-narration.mjs && node scripts/test-multidrop.mjs && node scripts/test-utils-pure.mjs && node scripts/test-net-client.mjs && node scripts/test-persona-cloud.mjs && node scripts/test-client-glue.mjs && node scripts/test-poem-titles-retry.mjs && node scripts/test-shared-voice.mjs && node scripts/test-audio-sim.mjs && node scripts/test-voice-bridge.mjs && node scripts/platform-check.mjs",
+    "test": "tsc -p tsconfig.json && tsc -p tsconfig.client.json && node scripts/check-imports.mjs && node scripts/gen-module-index.mjs --check && node scripts/check-boundaries.mjs && node scripts/check-diag-keys.mjs && node scripts/check-text.mjs && node scripts/test.mjs && node scripts/test-chat-limits.mjs && node scripts/test-stream-ledger.mjs && node scripts/test-story-security.mjs && node scripts/test-behavior-regressions.mjs && node scripts/verify-voice.mjs && node scripts/smoke-client.mjs && node scripts/ape-bench.mjs && node scripts/smoke-host.mjs && node scripts/test-voice-queue.mjs && node scripts/test-tts-engine.mjs && node scripts/test-data-layer.mjs && node scripts/test-repos.mjs && node scripts/test-personality.mjs && node scripts/test-story-player.mjs && node scripts/test-chat-routes.mjs && node scripts/test-menu-actions.mjs && node scripts/test-story-client.mjs && node scripts/test-story-auto.mjs && node scripts/test-content-routes.mjs && node scripts/test-dataport-poem.mjs && node scripts/test-render-layer.mjs && node scripts/test-store-cache.mjs && node scripts/test-actions-rest.mjs && node scripts/test-misc-routes.mjs && node scripts/test-chat-client.mjs && node scripts/test-prefs-config.mjs && node scripts/test-media-reminders.mjs && node scripts/test-image-reader.mjs && node scripts/test-boundaries-guard.mjs && node scripts/test-assembly.mjs && node scripts/test-asr-concurrency.mjs && node scripts/test-host-http.mjs && node scripts/test-entry-narration.mjs && node scripts/test-poem-narration.mjs && node scripts/test-multidrop.mjs && node scripts/test-utils-pure.mjs && node scripts/test-net-client.mjs && node scripts/test-persona-cloud.mjs && node scripts/test-client-glue.mjs && node scripts/test-poem-titles-retry.mjs && node scripts/test-shared-voice.mjs && node scripts/test-audio-sim.mjs && node scripts/test-voice-routes.mjs && node scripts/test-voices-shared.mjs && node scripts/test-voice-tts.mjs && node scripts/test-asr-abort.mjs && node scripts/test-voice-bridge.mjs && node scripts/platform-check.mjs",
     "version:check": "node tools/version-check.mjs",
     "typecheck": "node scripts/gen-version.mjs && tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
     "smoke:client": "node scripts/smoke-client.mjs",