dsh-chubby-whale 1.1.64 → 1.1.66

package/CHANGELOG.md

@@ -4,6 +4,53 @@
 
 ## [未发布]
 
+## [1.1.66] - 2026-11-07
+
+### 修复（B94 HTTP 错误分类与聊天断连分身）
+- **`isTimeoutError` 把「客户端走了」与「上游太慢」混为一类**：日志分不清，路由也没法据此分流。新增 `isAbortError` / `isTimeoutOnly`（旧函数语义原样保留，不破既有断言）
+- **`/chat` 不接断连**：客户端走了仍把模型跑完、且把 AbortError 记成 `CHAT-TIMEOUT`；请求体断连还会往死连接回 200 兜底包。现在断连即 abort 上游、**半截不记账**（`resolve` 出的完整回复仍照常记账——已付费的语义不变）
+- **`/chat-stream` 漏 `req` 侧断连信号**、每请求留一个 `res close` 监听不摘、断连后仍往死 socket 写 `stream: client closed` 帧
+- `http.ts` 新增公共 `watchClientGone`（三形状判定，正常结束有 `writableFinished` 守护）
+
+### 修复（B94 TTS 断连中止分身）
+- **客户端走了仍在合成**：`/tts` 完全没有断连检测，`TtsEngine`/`cloudTts` 也没有 signal 通道。现在 signal 一路贯到 worker/CLI/云端
+- 取舍写在代码里：edge-tts **共享 worker 不杀**（杀掉会连带失败并发段并重付启动），只把本次从 pending 摘除、产物作废；CLI 回退路径本请求独占 python，abort 直接 kill；临时文件 `EBUSY` 时 5s 补删一次
+- abort 的请求**不记账、不写缓存、不进降级闸、不回退 edge-tts**，只留一行 `TTS-CLIENT-ABORT` 诊断
+
+### 修复（主代理）
+- **整句打断词表三处各抄一份**：`echo-filter` 认 19 条、`voice-bridge` 只认 8 条 → 「停下来吧」在闸门能放行、到桥接却认不出。统一到 `shared/noise.ts` 的 `INTERRUPT_PHRASES` + `isInterruptCommand()`
+- `intent.ts` 头部「纯函数」口径修正：判定同步，但会触发一次 `ensurePoemTitles()` 后台预热（有网络副作用），单测须 stub
+
+### 测试
+- 新增 `test-chat-abort.mjs`(51)、`test-tts-abort.mjs`(61)，接入 `npm test`；`test-shared-voice` +7
+- 全链 **4033 项 0 失败**（`node tools/test-count.mjs`：56 个套件，失败 0，未识别 0）
+
+## [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 客户端朗读播放路径分身）

package/dist/client.js

@@ -25,7 +25,7 @@
   }
 
   // src/client/version.ts
-  var VERSION = "1.1.64";
+  var VERSION = "1.1.66";
 
   // src/client/styles.ts
   var W = 240;
@@ -1133,6 +1133,32 @@
     if (/^([\u4e00-\u9fa5])\1{2,}$/.test(k)) return true;
     return false;
   }
+  var INTERRUPT_PHRASES = Object.freeze([
+    "停下",
+    "停下来",
+    "停下来吧",
+    "停一下",
+    "停一停",
+    "停吧",
+    "别说了",
+    "别讲了",
+    "别念了",
+    "别吵",
+    "别说下去了",
+    "不要说了",
+    "不用说了",
+    "安静",
+    "打住",
+    "够了",
+    "暂停",
+    "算了"
+  ]);
+  function isInterruptCommand(text) {
+    const k = normalizeNoiseKey(text);
+    if (!k) return false;
+    if (isInterruptWord(k)) return true;
+    return INTERRUPT_PHRASES.indexOf(k) >= 0;
+  }
   function isInterruptWord(text) {
     const k = normalizeNoiseKey(text);
     return k.length > 0 && INTERRUPT_WORDS.indexOf(k) >= 0;
@@ -1183,31 +1209,6 @@
   }
 
   // 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 = [];
@@ -1229,7 +1230,7 @@
       }
       const plain = normalizePlain(text).toLowerCase();
       const plainKey = echoKey(text).toLowerCase();
-      const interrupt = SINGLE_INTERRUPT.test(plain);
+      const interrupt = isInterruptWord(plain);
       const stopCmd = isInterruptCommand(plain);
       if (plain.length < 2 && !interrupt) return { ok: false, reason: "trivial" };
       if (!interrupt && isNoiseText(plain)) return { ok: false, reason: "noise" };
@@ -1337,7 +1338,7 @@
     }
   }
 
-  // src/client/voice/voices.ts
+  // src/shared/voices.ts
   var TTS_VOICES = [
     "zh-CN-XiaoyiNeural",
     "zh-CN-XiaoxiaoNeural",
@@ -1359,14 +1360,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"));
@@ -1485,12 +1488,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
@@ -2558,8 +2560,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();
     }
@@ -3874,13 +3888,11 @@
   }
 
   // src/client/voice-bridge.ts
-  var STOP_PHRASES = ["停下", "停一下", "别说了", "别讲了", "别念了", "别吵", "安静", "够了"];
   var NARR_STOP_RE = /停|别念|不念|够了|算了|打住/;
   var HAS_CONTENT_RE = /[\u4e00-\u9fa5a-z0-9]/i;
   function isStopCommand(norm) {
     if (!norm) return false;
-    if (isInterruptWord(norm)) return true;
-    return STOP_PHRASES.indexOf(norm) >= 0;
+    return isInterruptCommand(norm);
   }
   function bump(key) {
     try {

package/dist/host/http.js

@@ -21,25 +21,157 @@ function bodyTooLarge() {
 export function isBodyTooLarge(err) {
     return Boolean(err && err.code === BODY_TOO_LARGE);
 }
-/** 超时/中止类错误（AbortSignal.timeout 抛 TimeoutError，手动 abort 抛 AbortError） */
+/**
+ * 错误名（B94）：只看 name，不猜 instanceof —— DOMException 跨 realm 不可靠，
+ * 测试里的替身错误也只是 Object.assign(new Error(...), { name })。
+ * 有的运行时/薄封装会把中止原因再包一层（err.reason = 原始 reason），这里顺手认一层。
+ */
+function errorName(err) {
+    return String((err && err.name) || '');
+}
+/** 超时/中止类错误 —— **兼容旧语义：TimeoutError 与 AbortError 都算**（既有测试与 asr 路由按此口径） */
 export function isTimeoutError(err) {
-    const n = String((err && err.name) || '');
+    const n = errorName(err);
     return n === 'TimeoutError' || n === 'AbortError';
 }
+/**
+ * 只因**调用方**（外部 signal：客户端断连 / 切页 / 上层主动取消）中止 —— AbortError。
+ * 依据：fetch 被中止时以 signal.reason 拒绝；AbortController.abort() 的默认 reason 是 AbortError。
+ * 与内部超时（TimeoutError）互斥：路由据此把「客户端走了」与「上游太慢」分开记日志/记账
+ * （B93 取证：两者混在 isTimeoutError 里时，CHAT-TIMEOUT / ASR-TIMEOUT 分不出是谁先放弃的）。
+ */
+export function isAbortError(err) {
+    return errorName(err) === 'AbortError' || errorName(err && err.reason) === 'AbortError';
+}
+/**
+ * 只是内部**超时**（AbortSignal.timeout(ms) 到点）—— TimeoutError；调用方中止不算。
+ * 旧名 isTimeoutError 被「两者都算」的历史语义占着，区分用的新名字另起（B94）。
+ */
+export function isTimeoutOnly(err) {
+    return errorName(err) === 'TimeoutError' || errorName(err && err.reason) === 'TimeoutError';
+}
 /** N 毫秒后自动中止的 signal（Node 18+ 的 AbortSignal.timeout，项目 engines 要求 >=22） */
 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;
+}
+/**
+ * 取中止原因（B94）：先触发那一方的 reason 原样转发；老运行时 signal 没有 reason 时
+ * 按来源补一个**同名**的 DOMException —— 否则内部超时会退化成 AbortError，
+ * isTimeoutOnly 就再也认不出「这是超时还是客户端中止」（手写兜底路径的关键）。
+ */
+function abortReason(src, name) {
+    if (src && src.reason !== undefined)
+        return src.reason;
+    const D = globalThis.DOMException;
+    if (typeof D === 'function') {
+        try {
+            return new D('aborted: ' + name, name);
+        }
+        catch { }
+    }
+    const e = new Error('aborted: ' + name);
+    e.name = name;
+    return e;
+}
+/**
+ * 把「内部超时」和「调用方中止」（客户端断连等外部 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();
+        // 事件没带源 signal（少数实现）时按「谁已经中止」判来源：绝不能把超时当调用方中止
+        const given = ev && (ev.target || ev.currentTarget);
+        const src = given || (timeout.aborted ? timeout : outer);
+        try {
+            ctl.abort(abortReason(src, src === timeout ? 'TimeoutError' : 'AbortError'));
+        }
+        catch { }
+    }
+    // 传进来就已经中止的 signal 不会再发事件：先各自判一次，否则这个请求会一直等超时
+    if (timeout.aborted || outer.aborted) {
+        const src = timeout.aborted ? timeout : outer;
+        try {
+            ctl.abort(abortReason(src, src === timeout ? 'TimeoutError' : 'AbortError'));
+        }
+        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 {
@@ -129,3 +261,74 @@ export async function readBody(req, maxBytes) {
         throw bodyTooLarge(); // 已经读空，路由这时写 413 能送到客户端
     return Buffer.concat(chunks);
 }
+/**
+ * 盯住「客户端是不是走了」（B94：从 routes/asr.ts 的私有实现提成公共件，两条 chat 路由共用）。
+ * 返回的 signal 交给 host/http.ts 的外呼（fetchWithTimeout / fetchJson 的第 4 个参数）：
+ * 客户端一走，还在等上游的那次付费请求就立刻中止，不必跑满超时、也不把回复写进记忆。
+ * onGone 可选：仅供路由在自己的 controller 上收口（如 /chat-stream 的空闲/总时长 controller），
+ * 在 ctl.abort() 之后调用一次，抛错只吞掉。
+ *
+ * 为什么不能只听 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 硬超时就是这个形状（宿主还在跑 30s 的聊天/60s 的识别）。
+ * 正常结束的 res 'close' 里 writableFinished=true，不会命中 ③，所以不会误中止正常请求。
+ */
+export function watchClientGone(req, res, onGone) {
+    const ctl = new AbortController();
+    let gone = false;
+    const mark = () => {
+        if (gone)
+            return;
+        gone = true;
+        try {
+            ctl.abort();
+        }
+        catch { }
+        if (onGone) {
+            try {
+                onGone();
+            }
+            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() {
+            // req/res 是每请求对象，不摘也不会串到下一个请求；但已结束的 handler 没必要继续响应
+            // 'close'/'aborted'（多做一次无意义的 abort），排障时也容易看花眼
+            off(req, 'aborted', onReqAborted);
+            off(req, 'close', onReqClose);
+            off(res, 'close', onResClose);
+        },
+    };
+}

package/dist/host/routes/asr.js

@@ -3,7 +3,7 @@
  * POST JSON { audio: base64, format: 'webm'|'wav'|'mp3' } → { text }
  * Key 由入口注入（getKey），路由不再自己读 config.json / 环境变量。
  * 体积：请求体（base64）上限 12MB → 413；解码后音频上限 8MB → 同样 413（口径统一，2026-11-07）
- * 外呼超时 60 秒
+ * 外呼超时 60 秒；**客户端断开（30s 硬超时/切页/断网）立刻中止外呼**，不再把付费识别跑满 60s（B93）
  */
 import { hashBytes } from '../../shared/hash.js';
 import { isInterruptWord, isNoiseText } from '../../shared/noise.js';
@@ -20,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) {
@@ -102,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 无响应，已中止');
@@ -135,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();
+        }
     };
 }