@yfwu2020/dsh-selection-explain 0.1.3 → 0.4.0

package/scripts/test-client.mjs

@@ -41,6 +41,23 @@ class FakeEl {
     this.scrollHeight = 0
     this.clientHeight = 0
     this._listeners = new Map()
+    // 输入框语义：textarea/input 的 value 与选区。真实 DOM 里给 value 赋值会把光标
+    // 挪到末尾、setSelectionRange 能定位 —— 语音输入要验"插在光标处"，桩必须跟着做到。
+    this._value = ''
+    this.selectionStart = 0
+    this.selectionEnd = 0
+  }
+  get value() {
+    return this._value
+  }
+  set value(next) {
+    this._value = next === undefined || next === null ? '' : String(next)
+    this.selectionStart = this._value.length
+    this.selectionEnd = this._value.length
+  }
+  setSelectionRange(start, end) {
+    this.selectionStart = start
+    this.selectionEnd = end === undefined ? start : end
   }
   appendChild(child) {
     if (child.parentNode) child.parentNode.removeChild(child)
@@ -89,6 +106,10 @@ class FakeEl {
   getClientRects() {
     return [{ left: 40, top: 100, right: 200, bottom: 118, width: 160, height: 18 }]
   }
+  get firstChild() {
+    // 真实 DOM 的 firstChild：插件用 while (node.firstChild) 清空子节点，桩必须有
+    return this.children.length ? this.children[0] : null
+  }
   get textContent() {
     return textOf(this)
   }
@@ -226,9 +247,48 @@ const historyStore = new Map()
 const historySaved = []
 let historyList = []
 const openedSessions = []
+/** 引用上下文路由的调用记录（验"什么时候去问 host、带了什么"）。 */
+const quoteContextCalls = []
 /** 散文样本（固定 fixture，避免依赖真实网络/缓存命中）。 */
 const PROSE_PROBE = 'the migration ran long, so we ship Wednesday'
 
+/**
+ * 语音输入（麦克风）这一段的假 host：目录 / 转写 / 准备。
+ * 真链路由 scripts/test-speech.mjs（WAV 校验 + 真路由）与真浏览器冒烟覆盖；
+ * 这里只验客户端编排（状态机 / 提示语 / 插字位置 / 该松麦克风时松掉）。
+ */
+let speechCatalog = {
+  ok: true,
+  available: true,
+  reason: '',
+  error: '',
+  providers: [
+    {
+      id: 'sensevoice-local',
+      name: 'SenseVoiceSmall (INT8)',
+      location: 'host-local',
+      languages: ['auto', 'zh', 'en'],
+      downloadSources: ['https://huggingface.co'],
+      phase: 'standby',
+      step: '',
+      completedBytes: 0,
+      totalBytes: 0,
+      message: '',
+    },
+  ],
+  selection: { providerId: 'sensevoice-local', language: 'auto' },
+  limits: { maxSeconds: 60, maxBytes: 4194304 },
+}
+/** 下一次转写的返回（测试里逐条改成失败 / 空 / 正常）。 */
+let speechTranscript = { ok: true, text: '这段是语音转出来的问题', providerId: 'sensevoice-local', seconds: 2.4 }
+/** 按顺序取用的返回（实时字幕一次录音要发好几个请求：预览 / 定稿 / 最终整段）。 */
+let speechTranscriptQueue = []
+/** 粘住的返回：一直返回同一个（模拟"人还在说，每拍预览都该是这句"）。 */
+let speechTranscriptRepeat = null
+let speechCatalogCalls = 0
+let speechPrepareCalls = 0
+const speechTranscribeCalls = []
+
 /** Python 代码选区用例（验证语言标记影响高亮规则）。 */
 const PY_SNIPPET = ['def add(a, b):', '    # 这里是可以相加的数字', '    return a + b'].join('\n')
 
@@ -328,6 +388,13 @@ function withAbort(response, signal) {
 
 const routeFetch = (input, init) => {
   const url = typeof input === 'string' ? input : ''
+  // blob:（划词桥的交互式预览用例）：从内存表里读回我们自己建的那份文档。
+  // content-type 跟着 blob 的 type 走（真实浏览器就是这么给的）——插件要靠它搬 charset。
+  if (url.startsWith('blob:')) {
+    const blob = blobStore.get(url)
+    if (!blob) return Promise.reject(new Error('unknown blob: ' + url))
+    return Promise.resolve(new Response(blob, { headers: { 'content-type': blob.type || 'text/html' } }))
+  }
   // 模型清单：用 fixture（真实 host 有 41 个模型，跑用例时不该依赖它）
   if (url.indexOf('/selection-explain/api/models') >= 0) {
     const body = globalThis.__modelCatalogFixture || { ok: true, current: null, stages: null, models: [] }
@@ -376,6 +443,62 @@ const routeFetch = (input, init) => {
       }),
     )
   }
+  // 引用上下文：host 侧"引用所在那一组对话 ± 一组"的那份（fixture —— 取轮算法本身由
+  // test-transcript.mjs 覆盖；这里验的是**客户端怎么用它**）。globalThis.__quoteContextFixture
+  // 可切成 'miss'（定位不到）/ 'error'（路由失败），用来验兜底路径。
+  if (url.indexOf('/selection-explain/api/quote-context') >= 0) {
+    let payload = {}
+    try {
+      payload = JSON.parse(String(init && init.body))
+    } catch (error) {
+      payload = { parse_error: String(error) }
+    }
+    quoteContextCalls.push(payload)
+    const fixture = globalThis.__quoteContextFixture
+    if (fixture === 'error') {
+      return Promise.resolve(new Response(JSON.stringify({ ok: false, error: 'boom' }), { status: 500, headers: { 'content-type': 'application/json' } }))
+    }
+    if (fixture === 'miss') {
+      return Promise.resolve(new Response(JSON.stringify({ ok: true, matched: false, context: '', rounds: 0 }), { headers: { 'content-type': 'application/json' } }))
+    }
+    const context = [
+      '用户：上一句问的是什么？',
+      '助手：上一句的回答。',
+      `用户：【${payload.text}】`,
+      '助手：引用之后的那句回答。',
+      '用户：再下一句提问。',
+      '助手：再下一句回答。',
+    ].join('\n')
+    return Promise.resolve(
+      new Response(JSON.stringify({ ok: true, matched: true, context, rounds: 3, chars: context.length }), {
+        headers: { 'content-type': 'application/json' },
+      }),
+    )
+  }
+  // 语音输入：目录 / 转写 / 准备。三条都用 fixture（真识别见 test-speech.mjs 与真浏览器冒烟）。
+  if (url.indexOf('/selection-explain/api/speech') >= 0) {
+    if (url.indexOf('/transcribe') >= 0) {
+      let payload = null
+      try {
+        payload = JSON.parse(String(init && init.body))
+      } catch (error) {
+        payload = { parse_error: String(error) }
+      }
+      speechTranscribeCalls.push(payload)
+      const scripted = speechTranscriptRepeat || (speechTranscriptQueue.length ? speechTranscriptQueue.shift() : speechTranscript)
+      return Promise.resolve(new Response(JSON.stringify(scripted), { headers: { 'content-type': 'application/json' } }))
+    }
+    if (url.indexOf('/prepare') >= 0) {
+      speechPrepareCalls += 1
+      return Promise.resolve(
+        new Response(JSON.stringify({ ok: true, providerId: 'sensevoice-local', catalog: speechCatalog }), {
+          headers: { 'content-type': 'application/json' },
+        }),
+      )
+    }
+    speechCatalogCalls += 1
+    return Promise.resolve(new Response(JSON.stringify(speechCatalog), { headers: { 'content-type': 'application/json' } }))
+  }
   let body = null
   if (init && init.body) {
     try {
@@ -385,6 +508,15 @@ const routeFetch = (input, init) => {
     }
     sent.push(body)
   }
+  // 语音输入那一段的"把面板打开、翻译就绪"夹具（比 stage-probe 多一个 done 阶段）
+  if (body && body.text === 'voice-probe') {
+    const payload = [
+      `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: 'translation' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'delta', text: '## 翻译\n语音用例的翻译\n' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done', chars: 8 })}\n\n`,
+    ].join('')
+    return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
+  }
   if (body && body.text === 'stage-probe') {
     const only = body.stage === 'detail' ? '## 详解\nSTAGE-DETAIL' : '## 翻译\nSTAGE-TRANSLATION'
     const payload = [
@@ -757,15 +889,64 @@ const routeFetch = (input, init) => {
     ].join('')
     return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
   }
+  // 引用（❝）用例：首轮固定给一句可被引用的正文，详解在同一个小窗里另走 stage=detail
+  if (body && body.text === 'quote-probe') {
+    const only = body.stage === 'detail' ? '## 详解\n引用用例的详解\n' : '## 翻译\n引用用例的翻译段落（拿来被引用）\n'
+    const payload = [
+      `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: body.stage === 'detail' ? 'detail' : 'translation' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'delta', text: only })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done', chars: only.length })}\n\n`,
+    ].join('')
+    return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
+  }
+  // 「等待中的那条不给引用整条」专用：首轮立刻出，追问要等 500ms 才吐第一个字
+  if (body && body.text === 'quote-wait-probe' && !body.question) {
+    const only = '## 翻译\n等待用例的翻译\n'
+    const payload = [
+      `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: 'translation' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'delta', text: only })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done', chars: only.length })}\n\n`,
+    ].join('')
+    return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
+  }
+  if (body && body.question && body.text === 'quote-wait-probe') {
+    const encoder = new TextEncoder()
+    const stream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', mode: 'chat', effort: 'low' })}\n\n`),
+        )
+        await new Promise((r) => setTimeout(r, 500))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'delta', text: '等待用例的回答' })}\n\n`))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', chars: 8 })}\n\n`))
+        controller.close()
+      },
+    })
+    return Promise.resolve(new Response(stream, { headers: { 'content-type': 'text/event-stream' } }))
+  }
   return fetch(typeof input === 'string' && input.startsWith('/') ? ORIGIN + input : input, init)
 }
-
 const browserFetch = (input, init) => {
   const out = routeFetch(input, init)
   const signal = init && init.signal
   if (!signal || !out || typeof out.then !== 'function') return out
   return out.then((response) => (response && response.body ? withAbort(response, signal) : response))
 }
+/**
+ * 划词桥的 blob 桩：宿主交互式预览的外层文档就是 `blob:`（见 ui-sidebar-documentpreview
+ * 的 HtmlFrame）——桥要 fetch 它、再把注入过脚本的那份重新发成一个 blob 换上去。
+ */
+const blobStore = new Map()
+let blobSeq = 0
+URL.createObjectURL = (blob) => {
+  blobSeq += 1
+  const url = `blob:stub/${blobSeq}`
+  blobStore.set(url, blob)
+  return url
+}
+URL.revokeObjectURL = (url) => {
+  blobStore.delete(url)
+}
 new Function('window', 'document', 'location', 'navigator', 'requestAnimationFrame', 'fetch', source)(
   windowStub,
   documentStub,
@@ -884,6 +1065,17 @@ assert('选中文字后浮标出现', !!button && button.style.display === 'inli
 
 }
 
+// 引用（❝）的**离线**契约：浮标进了浮层、CSS 规则齐全（真实交互在宿主可达时另有一段）
+{
+  const css = readFileSync(BUNDLE, 'utf8')
+  const quoteBtn = Array.from(walk(mount)).find((n) => String(n.className).indexOf('dsh-sel-quotebtn') >= 0)
+  assert('浮层里有「❝ 引用」浮标，且默认藏着', !!quoteBtn && quoteBtn.style.display === 'none' && textOf(quoteBtn).indexOf('引用') >= 0, quoteBtn ? textOf(quoteBtn) : '未找到')
+  assert('CSS 契约：引用区默认收起、data-show 控制显隐', /\.dsh-sel-quotes\{display:none;flex-direction:column/.test(css) && /\.dsh-sel-quotes\[data-show="1"\]\{display:flex\}/.test(css), '')
+  assert('CSS 契约：引用卡片三段（来源 / 摘要 / 删除）', /\.dsh-sel-quotechip-src\{/.test(css) && /\.dsh-sel-quotechip-text\{/.test(css) && /\.dsh-sel-quotechip-x\{/.test(css), '')
+  assert('CSS 契约：气泡里的引用块单行省略（长引用不撑破气泡）', /\.dsh-sel-bqitem\{[\s\S]{0,420}?text-overflow:ellipsis;white-space:nowrap\}/.test(css), '')
+  assert('CSS 契约：「引用整条」平时隐身，鼠标移到这条消息上才出现', /\.dsh-sel-bubquote\{[\s\S]{0,520}?opacity:0;transition:opacity/.test(css) && /\.dsh-sel-bubble:hover \.dsh-sel-bubquote,\.dsh-sel-bubquote:focus-visible\{opacity:\.66\}/.test(css), '')
+}
+
 
 // ───────────────────────── 点击 → 弹窗 + 真实 host 流 ─────────────────────────
 button.dispatch('click', { preventDefault() {}, stopPropagation() {} })
@@ -967,6 +1159,17 @@ if (HOST_UP) {
     'src/index.ts',
   )
   assert('客户端给了新搜索工具中文标签', /\(name === 'advanced_search'\) return '联网搜索'/.test(readFileSync(resolve(HERE, '..', 'src', 'client', 'index.js'), 'utf8')), '')
+  {
+    // 源码契约（桩 DOM 里没有真实焦点，只能用源码钉住）：
+    // 开窗那一下的自动聚焦会把选区清掉 —— 小窗里正划着词（准备点引用）时必须让位，
+    // 否则就是"划好了词，一松手浮标没出现"（实测：开窗后首轮刚出完那一帧正好撞上）。
+    const clientSrc = readFileSync(resolve(HERE, '..', 'src', 'client', 'index.js'), 'utf8')
+    assert(
+      '开窗自动聚焦会让位给"小窗里正在划的词"',
+      /function hasPanelSelection\(\)/.test(clientSrc) && /if \(hasPanelSelection\(\)\) \{/.test(clientSrc),
+      'src/client/index.js',
+    )
+  }
   assert(
     '追问档位默认 high（翻译仍 low、详解仍 high）',
     /chatReasoningEffort: z\.string\(\)\.default\('high'\)/.test(hostSrc) &&
@@ -2503,6 +2706,1363 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
   assert('删除键不会误触发回放（回放会重新写历史，这里应为 0 次）', replayHits.length === 0, String(replayHits.length))
 }
 
+// ───────────────────────── 侧边栏网页（iframe）划词桥 ─────────────────────────
+// 侧边栏 HTML 预览是不透明源沙箱 iframe：父页面读不到里面的选区，
+// 所以桥由帧内主动上报。这一段验的是**父侧接线**：注入、来源校验、坐标换算、
+// 上下文与标签走通、帧内清空选区后收浮标。
+let bridgeOwnedBlob = ''
+{
+  // 上一段（历史列表）是开着面板测的；划词桥按老规矩"面板开着时不另开一个"，
+  // 先收起来，否则下面每条消息都会被 panelOpen 挡掉（那就测了个寂寞）。
+  hook.close()
+  const beforeBridge = hook.selection()
+
+  /** 宿主基础预览（BasicHtmlFrame）：DOMPurify 清洗 + script-src 'none'，srcdoc + sandbox=""。 */
+  const SANITIZED =
+    '<!doctype html><html><head><meta http-equiv="Content-Security-Policy" content="default-src \'none\'; ' +
+    "script-src 'none'; style-src 'unsafe-inline'\"><style>body{color:red}</style></head>" +
+    '<body><p>the migration ran long, so we ship Wednesday</p></body></html>'
+  const frame = new FakeEl('iframe')
+  frame.setAttribute('data-html-preview', 'true')
+  frame.setAttribute('sandbox', '')
+  frame.setAttribute('srcdoc', SANITIZED)
+  frame.isConnected = true
+  const frameWindow = { name: 'sidebar-frame' }
+  frame.contentWindow = frameWindow
+
+  documentStub.querySelectorAll = (selector) => (selector === 'iframe' ? [frame] : [])
+  const scanned = hook.bridgeScan()
+  assert('扫到侧边栏预览帧并桥上', scanned.frames.length === 1 && scanned.frames[0].srcdoc === true, JSON.stringify(scanned.frames))
+
+  const injected = frame.getAttribute('srcdoc')
+  assert('桥脚本注入了 srcdoc（内容没被替换掉）', injected.indexOf('data-dsh-sel-bridge') > 0 && injected.indexOf('the migration ran long, so we ship Wednesday') > 0)
+  assert('基础预览的 CSP 只放宽 script-src', /script-src 'unsafe-inline'/.test(injected) && /default-src 'none'/.test(injected))
+  assert('沙箱补 allow-scripts，但不给 allow-same-origin', frame.getAttribute('sandbox') === 'allow-scripts', String(frame.getAttribute('sandbox')))
+
+  // 陌生窗口发来的同款消息一律不理（消息可以被任意页面伪造，来源必须对得上）
+  windowStub.dispatch('message', { source: { name: 'attacker' }, data: { __dshSel: 1, kind: 'selection', sel: { text: '伪造', context: '', rect: { x: 0, y: 0, right: 10, bottom: 10, w: 10, h: 10 } } } })
+  const afterForged = hook.selection()
+  assert(
+    '陌生来源的消息被忽略（选区没被改写）',
+    (beforeBridge === null && afterForged === null) || (!!afterForged && afterForged.text === beforeBridge.text && afterForged.source === beforeBridge.source),
+    JSON.stringify(afterForged),
+  )
+  assert('陌生来源的消息不会点亮 bridge()', hook.bridge().active === false)
+
+  // 帧内报来一条选区：帧内视口坐标 + iframe 自身的 getBoundingClientRect（桩：left 40 / top 100）
+  windowStub.dispatch('message', {
+    source: frameWindow,
+    data: {
+      __dshSel: 1,
+      kind: 'selection',
+      sel: {
+        text: 'the migration ran long',
+        context: 'PM: 这周能发布吗？ Dev: 【the migration ran long】, so we ship Wednesday.',
+        keyContext: 'PM: 这周能发布吗？ Dev:',
+        label: '',
+        rect: { x: 10, y: 20, right: 120, bottom: 38, w: 110, h: 18 },
+      },
+    },
+  })
+  const bridgeSelection = hook.selection()
+  assert('帧内选区让浮标出现在「帧偏移 + 帧内坐标」处', button.style.display === 'inline-flex' && button.style.left === '98px' && button.style.top === '85px', button.style.left + '/' + button.style.top)
+  assert('选区记成 iframe 来源', !!bridgeSelection && bridgeSelection.source === 'iframe' && bridgeSelection.text === 'the migration ran long', JSON.stringify(bridgeSelection))
+  assert('标签按帧来源给（侧边栏网页）', bridgeSelection.label === '侧边栏网页', bridgeSelection.label)
+  assert('上下文由帧内带来（含【】标记）', bridgeSelection.context.indexOf('【the migration ran long】') > 0, bridgeSelection.context)
+  assert('bridge() 报 active', hook.bridge().active === true)
+
+  // 交互式预览：外层是宿主 bootstrap（blob: + document.write），桥要换一份带脚本的 blob 上去
+  const BOOTSTRAP =
+    '<!doctype html><meta charset="utf-8"><script>(()=>{document.open();document.write("<p>the migration ran long, so we ship Wednesday</p>");document.close()})()</scr' + 'ipt>'
+  const originalBlob = URL.createObjectURL(new Blob([BOOTSTRAP], { type: 'text/html;charset=utf-8' }))
+  const blobFrame = new FakeEl('iframe')
+  blobFrame.setAttribute('data-html-preview', 'true')
+  blobFrame.setAttribute('sandbox', 'allow-scripts')
+  blobFrame.setAttribute('src', originalBlob)
+  blobFrame.isConnected = true
+  const blobWindow = { name: 'sidebar-blob-frame' }
+  blobFrame.contentWindow = blobWindow
+  documentStub.querySelectorAll = (selector) => (selector === 'iframe' ? [frame, blobFrame] : [])
+  hook.bridgeScan()
+  await sleep(20) // fetch(blob) → 注入 → 换 src 是异步的
+  bridgeOwnedBlob = blobFrame.getAttribute('src')
+  assert('交互式预览：src 换成我们重发的那份 blob', bridgeOwnedBlob !== originalBlob && bridgeOwnedBlob.startsWith('blob:'), bridgeOwnedBlob)
+  assert('交互式预览：换上去的文档里有桥脚本', String(await (await browserFetch(bridgeOwnedBlob)).text()).indexOf('data-dsh-sel-bridge') > 0)
+  assert(
+    '交互式预览：重发时把原 blob 的 content-type 搬过来（charset 不能丢，否则整页乱码）',
+    (blobStore.get(bridgeOwnedBlob) || {}).type === 'text/html;charset=utf-8',
+    String((blobStore.get(bridgeOwnedBlob) || {}).type),
+  )
+  assert('交互式预览：宿主原来那份 blob 不归我们动（它自己回收）', blobStore.has(originalBlob))
+  assert('交互式预览：我们自己那份 blob 登记在册（清理时回收）', hook.bridge().frames.some((item) => item.own === true))
+
+  // 帧内清空选区 → 收浮标（顶层选区不会塌，所以只能靠这条消息）
+  windowStub.dispatch('message', { source: frameWindow, data: { __dshSel: 1, kind: 'clear' } })
+  assert('帧内清空选区后收浮标', button.style.display === 'none' && hook.bridge().active === false)
+
+  // ── 消失时机：帧内的"按下"也要收浮标（父页面收不到帧里的 mousedown）──
+  windowStub.dispatch('message', {
+    source: frameWindow,
+    data: {
+      __dshSel: 1,
+      kind: 'selection',
+      sel: { text: '按住前那一段', context: '【按住前那一段】', keyContext: '', label: '', rect: { x: 4, y: 6, right: 40, bottom: 24, w: 36, h: 18 } },
+    },
+  })
+  assert('（准备）选区先让浮标亮着', button.style.display === 'inline-flex')
+  windowStub.dispatch('message', { source: frameWindow, data: { __dshSel: 1, kind: 'press' } })
+  assert('帧内按下：浮标立刻收起', button.style.display === 'none')
+  assert('帧内按下：这条选区本身还留着（松手后可能还要用）', hook.selection() !== null && hook.selection().source === 'iframe', JSON.stringify(hook.selection()))
+
+  // 按下的若是**另一个**网页：那条选区已经不是用户在看的东西了，状态一起清
+  windowStub.dispatch('message', {
+    source: frameWindow,
+    data: {
+      __dshSel: 1,
+      kind: 'selection',
+      sel: { text: '另一个帧的词', context: '【另一个帧的词】', keyContext: '', label: '', rect: { x: 4, y: 6, right: 40, bottom: 24, w: 36, h: 18 } },
+    },
+  })
+  windowStub.dispatch('message', { source: blobWindow, data: { __dshSel: 1, kind: 'press' } })
+  assert('在另一个网页里按下：浮标收起且旧选区状态清掉', button.style.display === 'none' && hook.selection() === null && hook.bridge().active === false)
+
+  // 交互式预览那一帧报来的选区 → 点浮标 → 面板用的就是桥给的上下文
+  windowStub.dispatch('message', {
+    source: blobWindow,
+    data: {
+      __dshSel: 1,
+      kind: 'selection',
+      sel: {
+        text: 'slipped',
+        context: 'the deadline 【slipped】 to Wednesday',
+        keyContext: 'the deadline',
+        label: '代码块',
+        rect: { x: 8, y: 12, right: 60, bottom: 30, w: 52, h: 18 },
+      },
+    },
+  })
+  assert('第二帧的选区也能认（多标签页）', button.style.display === 'inline-flex' && hook.selection().text === 'slipped', JSON.stringify(hook.selection()))
+  assert('帧内给的标签优先（代码块）', hook.selection().label === '代码块', hook.selection().label)
+  button.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+  const bridgePayload = hook.payload()
+  assert('点浮标后面板用桥给的上下文（不读顶层 DOM）', !!bridgePayload && bridgePayload.context === 'the deadline 【slipped】 to Wednesday', bridgePayload && bridgePayload.context)
+  assert('面板标签也是桥给的', bridgePayload.label === '代码块', bridgePayload && bridgePayload.label)
+  hook.close()
+
+  // ── 别的插件在侧边栏渲染的生成网页（「图解」那种：blob: + allow-scripts，没有宿主标记）──
+  const visualFrame = new FakeEl('iframe')
+  visualFrame.setAttribute('class', 'dsv-frame')
+  visualFrame.setAttribute('title', '图解')
+  visualFrame.setAttribute('sandbox', 'allow-scripts allow-forms allow-modals allow-popups')
+  visualFrame.setAttribute('src', URL.createObjectURL(new Blob(['<!doctype html><html><head><meta charset="utf-8"></head><body><p>图解页</p></body></html>'], { type: 'text/html' })))
+  visualFrame.isConnected = true
+  const visualWindow = { name: 'reply-visual-frame' }
+  visualFrame.contentWindow = visualWindow
+
+  // 反面用例：不该被动的帧
+  const opaqueFrame = new FakeEl('iframe') // 没有 allow-scripts 的第三方帧：不给它加权限
+  opaqueFrame.setAttribute('sandbox', '')
+  opaqueFrame.setAttribute('srcdoc', '<!doctype html><p>别人的沙箱</p>')
+  opaqueFrame.isConnected = true
+  const remoteFrame = new FakeEl('iframe') // 远端站点：没有任何注入手段
+  remoteFrame.setAttribute('sandbox', 'allow-scripts')
+  remoteFrame.setAttribute('src', 'https://example.com/')
+  remoteFrame.isConnected = true
+  const ownFrame = new FakeEl('iframe') // 我们自己小窗里的网页答案预览
+  ownFrame.setAttribute('data-preview-id', 'pv1')
+  ownFrame.setAttribute('sandbox', 'allow-scripts')
+  ownFrame.setAttribute('srcdoc', '<!doctype html><p>生成的网页</p>')
+  ownFrame.isConnected = true
+  panel.appendChild(ownFrame)
+
+  documentStub.querySelectorAll = (selector) =>
+    selector === 'iframe' ? [frame, blobFrame, visualFrame, opaqueFrame, remoteFrame, ownFrame] : []
+  hook.bridgeScan()
+  await sleep(20) // visualFrame 的 blob 分支也是异步的
+  const bridgedNow = hook.bridge().frames
+  assert(
+    '「图解」那种 blob 帧也被桥上（不只认宿主标记）',
+    bridgedNow.length === 3 && visualFrame.getAttribute('data-dsh-sel-bridged') === '1',
+    JSON.stringify(bridgedNow),
+  )
+  assert('第三方没有 allow-scripts 的沙箱帧不动它（不给别人加权限）', opaqueFrame.getAttribute('data-dsh-sel-bridged') === null && opaqueFrame.getAttribute('sandbox') === '')
+  assert('远端站点 iframe 不动它', remoteFrame.getAttribute('data-dsh-sel-bridged') === null)
+  assert('我们小窗里的网页答案预览不桥（面板开着也不会用它）', ownFrame.getAttribute('data-dsh-sel-bridged') === null)
+  assert('「图解」帧的 src 换成了我们重发的那份', visualFrame.getAttribute('src').indexOf('blob:') === 0 && visualFrame.getAttribute('src') !== null)
+
+  windowStub.dispatch('message', {
+    source: visualWindow,
+    data: {
+      __dshSel: 1,
+      kind: 'selection',
+      sel: { text: '图解里的词', context: '【图解里的词】的上下文', keyContext: '', label: '', rect: { x: 5, y: 6, right: 40, bottom: 22, w: 35, h: 16 } },
+    },
+  })
+  const visualSelection = hook.selection()
+  assert('「图解」帧的选区也认', !!visualSelection && visualSelection.text === '图解里的词', JSON.stringify(visualSelection))
+  assert('位置标签取帧自己的 title（图解）', visualSelection.label === '图解', visualSelection.label)
+  hook.close()
+}
+
+// ───────────────────────── 引用（❝）：小窗里的内容 / 主界面选中的文字 → 输入框 ─────────────────────────
+// 两个入口共用一份清单（state.quotes），发送时拼进这一条消息：
+//   ① 小窗开着时划小窗里的正文 → 「❝ 引用」；
+//   ② 小窗开着时划主界面（含侧边栏网页）上的文字 → 同一个浮标；
+//   ③ 助手气泡末尾的「引用整条」。
+{
+  const quoteRect = { left: 40, top: 100, right: 200, bottom: 118, width: 160, height: 18 }
+  /** 造一条"本文档里的选区"：起点落在指定的节点上（祖先链就是插件要判定的东西）。 */
+  const selectText = (node, text) => {
+    const range = {
+      startContainer: node,
+      endContainer: node,
+      cloneRange: () => range,
+      getClientRects: () => [quoteRect],
+      getBoundingClientRect: () => quoteRect,
+    }
+    windowStub.getSelection = () => ({
+      isCollapsed: false,
+      rangeCount: 1,
+      toString: () => text,
+      getRangeAt: () => range,
+    })
+  }
+  const restoreGetSelection = windowStub.getSelection
+  const quoteButton = hook.quoteNode()
+  const quotesBox = Array.from(walk(panel)).find((n) => n.className === 'dsh-sel-quotes')
+  assert('输入框上方有引用区（默认收起）', !!quotesBox && quotesBox.getAttribute('data-show') === '0', quotesBox ? quotesBox.getAttribute('data-show') : '未找到')
+
+  // 本段自带前提：重开一个小窗（独一无二的选中文字，不吃缓存/历史）
+  hook.close()
+  hook.open('quote-probe', '引用用例的上下文片段', '引用测试')
+  for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+  assert('（前提）引用用例的首轮出完', hook.state().phase === 'done', hook.state().phase)
+
+  // ① 小窗里选中的正文（翻译节）
+  // ⚠️ mouseup 的 target 必须是**面板里的节点**（真实浏览器就是这样上报的）：
+  //    早先 mouseup 对面板内的目标直接 return，小窗里划词毫无反应 —— 用 document.body
+  //    当 target 的写法测不出来（实测踩过：只有「引用整条」能用）。
+  const sectionP = Array.from(walk(panel)).find((n) => n.tagName === 'P')
+  selectText(sectionP, '引用用例的翻译段落')
+  documentStub.dispatch('mouseup', { target: sectionP })
+  await sleep(30)
+  const inPanel = hook.quoteState()
+  assert('小窗里划词：浮出「❝ 引用」', inPanel.visible === true, JSON.stringify(inPanel))
+  assert(
+    '来源写到"哪一节"（用该节自己的标题）',
+    !!inPanel.selection && inPanel.selection.label === '小窗「翻译」节' && inPanel.selection.source === 'panel',
+    JSON.stringify(inPanel.selection),
+  )
+  assert('小窗开着时不弹「✦ 解读」（要解读直接在输入框里问）', button.style.display === 'none', String(button.style.display))
+
+  quoteButton.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+  await sleep(10)
+  let quotes = hook.quotes()
+  assert('点一下 → 引用区多了一张卡片', quotes.length === 1 && quotes[0].text === '引用用例的翻译段落' && quotes[0].label === '小窗「翻译」节', JSON.stringify(quotes))
+  assert('卡片画进输入框上方（来源 + 摘要）', quotesBox.getAttribute('data-show') === '1' && textOf(quotesBox).indexOf('小窗「翻译」节') >= 0 && textOf(quotesBox).indexOf('引用用例的翻译段落') >= 0, textOf(quotesBox))
+  assert('加完引用浮标自己收起来（"已经进去了"的信号）', quoteButton.style.display === 'none', String(quoteButton.style.display))
+  assert('只挂引用、没写问题时发送键可用', askSend.disabled === false, 'disabled=' + askSend.disabled)
+  assert(
+    '小窗里的引用**不带上下文**（小窗这几轮对话本来就会随历史进模型）',
+    quotes[0].context === '' && quotes[0].session === false,
+    JSON.stringify({ context: quotes[0].context, session: quotes[0].session }),
+  )
+  assert(
+    '引用浮标画在面板**之上**（小窗里划词才看得见、点得着）',
+    Number(quoteButton.style.zIndex) > Number(panel.style.zIndex),
+    `quote=${quoteButton.style.zIndex} panel=${panel.style.zIndex}`,
+  )
+
+  // 划一大段（超过单段引用上限）也必须有反应：浮标照出，加进去时截断并说明
+  {
+    selectText(sectionP, '长'.repeat(4200))
+    documentStub.dispatch('mouseup', { target: sectionP })
+    await sleep(30)
+    assert('超长选区照样浮出引用浮标（"划长一点就没反应"是坑）', hook.quoteState().visible === true, JSON.stringify(hook.quoteState()))
+    quoteButton.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+    await sleep(10)
+    const longQuote = hook.quotes().pop()
+    assert(
+      '超长引用按单段上限截断，并在状态里说明',
+      !!longQuote && longQuote.text.length >= 3000 && longQuote.text.length <= 3001 && hook.state().status.indexOf('已截断') > 0,
+      `${longQuote && longQuote.text.length} · ${hook.state().status}`,
+    )
+    const chipList = Array.from(walk(quotesBox)).filter((n) => n.className === 'dsh-sel-quotechip-x')
+    chipList[chipList.length - 1].dispatch('click', { stopPropagation() {} })
+    await sleep(5)
+    assert('删掉超长那条后回到 1 条', hook.quotes().length === 1, JSON.stringify(hook.quotes().map((q) => q.text.length)))
+    // 把浮标状态也归零：不然下面那次"再点一次"的点击会把这段长文又加回来
+    //（浮标虽然收起来了，但 state.quoteSelection 还留着上一次的选区）
+    windowStub.getSelection = () => ({ isCollapsed: true, rangeCount: 0, toString: () => '' })
+    documentStub.dispatch('mouseup', { target: sectionP })
+    await sleep(20)
+  }
+
+  const clicksBefore = hook.quoteState().visible
+  quoteButton.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+  assert('浮标收起后再点它不会重复加', hook.quotes().length === 1 && clicksBefore === false, JSON.stringify(hook.quotes().map((q) => q.text)))
+
+  // 同一段再加一次：不加，但要有交代（点了"没反应"是最难查的观感）
+  assert(
+    '重复的引用不再加，并说明原因',
+    hook.quote('引用用例的翻译段落', '小窗回答') === false && hook.state().status.indexOf('已经在引用里') >= 0,
+    hook.state().status,
+  )
+
+  // 上限：最多 4 段
+  hook.quote('第二段引用', '小窗详解')
+  hook.quote('第三段引用', '侧边栏网页')
+  hook.quote('第四段引用', '调试')
+  assert('四段引用都在', hook.quotes().length === 4, JSON.stringify(hook.quotes().map((q) => q.text)))
+  assert(
+    '第五段被挡下并说明原因',
+    hook.quote('第五段引用', '调试') === false && hook.state().status.indexOf('最多 4 段') >= 0,
+    hook.state().status,
+  )
+
+  // 卡片上的 ✕
+  const chipXs = Array.from(walk(quotesBox)).filter((n) => n.className === 'dsh-sel-quotechip-x')
+  assert('每张卡片都有 ✕', chipXs.length === 4, String(chipXs.length))
+  chipXs[0].dispatch('click', { stopPropagation() {} })
+  await sleep(5)
+  assert(
+    '点 ✕ 能精确删掉那一条',
+    hook.quotes().length === 3 && !hook.quotes().some((q) => q.text === '引用用例的翻译段落'),
+    JSON.stringify(hook.quotes().map((q) => q.text)),
+  )
+
+  // ② 小窗开着时，主界面上的选区也走同一个浮标
+  selectText(textEl, '主界面上的这一段')
+  documentStub.dispatch('mouseup', { target: textEl })
+  await sleep(30)
+  const onDoc = hook.quoteState()
+  assert('小窗开着时主界面划词：同样浮出「❝ 引用」', onDoc.visible === true, JSON.stringify(onDoc))
+  assert('来源标成「主界面选中」', !!onDoc.selection && onDoc.selection.label === '主界面选中' && onDoc.selection.source === 'document', JSON.stringify(onDoc.selection))
+  quoteButton.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+  await sleep(10)
+  quotes = hook.quotes()
+  assert(
+    '主界面选中的文字挂进了同一份清单',
+    quotes.length === 4 && quotes[3].text === '主界面上的这一段' && quotes[3].label === '主界面选中',
+    JSON.stringify(quotes.map((q) => q.label)),
+  )
+  assert(
+    '主界面的引用标成"会话里的"（发送前会问 host 要按轮取整的上下文）',
+    quotes[3].session === true,
+    JSON.stringify({ session: quotes[3].session, context: quotes[3].context.slice(0, 30) }),
+  )
+
+  // ③ 发送：引用拼进这一条消息（气泡里也要看得见），会话里的引用先补上下文
+  const callsBefore = quoteContextCalls.length
+  const beforeSend = sent.length
+  askBox.value = '这几段有什么关系？'
+  askSend.dispatch('click', { stopPropagation() {} })
+  for (let i = 0; i < 120 && sent.length === beforeSend; i += 1) await sleep(20)
+  const quotePayload = sent[sent.length - 1] || {}
+  assert(
+    '载荷里的 question 就是拼好的那份（引用在前、问题在后）',
+    String(quotePayload.question).indexOf('【引用 1】（来自小窗详解）') === 0 && /【我的问题】\n这几段有什么关系？$/.test(String(quotePayload.question)),
+    String(quotePayload.question).replace(/\n/g, '⏎').slice(0, 120),
+  )
+  assert(
+    '每段引用各带来源，按加入顺序编号',
+    /【引用 2】（来自侧边栏网页）/.test(String(quotePayload.question)) &&
+      /【引用 4】（来自主界面选中）/.test(String(quotePayload.question)) &&
+      String(quotePayload.question).indexOf('第五段引用') < 0,
+    String(quotePayload.question).replace(/\n/g, '⏎'),
+  )
+  assert(
+    '只给会话里的引用问 host（小窗里的那几段自己就有上下文，不多打一次请求）',
+    quoteContextCalls.length === callsBefore + 1 &&
+      quoteContextCalls[quoteContextCalls.length - 1].text === '主界面上的这一段' &&
+      quoteContextCalls[quoteContextCalls.length - 1].sessionId === 'session-stub-1',
+    JSON.stringify(quoteContextCalls.slice(callsBefore)),
+  )
+  assert(
+    '拼好的消息里带上【引用处上下文】，被引用的部分用【】标出',
+    String(quotePayload.question).indexOf('【引用处上下文】（被引用的部分用【】标出）') > 0 &&
+      String(quotePayload.question).indexOf('用户：【主界面上的这一段】') > 0 &&
+      String(quotePayload.question).indexOf('助手：引用之后的那句回答。') > 0,
+    String(quotePayload.question).replace(/\n/g, '⏎').slice(-160),
+  )
+  assert(
+    '没有上下文的引用照旧只给原文（不硬造一段空上下文）',
+    /【引用 1】（来自小窗详解）\n第二段引用\n/.test(String(quotePayload.question)),
+    String(quotePayload.question).replace(/\n/g, '⏎').slice(0, 80),
+  )
+  assert(
+    '引用用完即清（不会跟着下一轮又发一遍）',
+    hook.quotes().length === 0 && quotesBox.getAttribute('data-show') === '0',
+    JSON.stringify(hook.quotes()),
+  )
+  const quoteTurn = hook.turns().filter((t) => t.role === 'user').pop()
+  assert(
+    '轮次里同时留着「问了什么」和「带了哪些引用」',
+    quoteTurn.text === '这几段有什么关系？' && (quoteTurn.quotes || []).length === 4 && quoteTurn.sent === quotePayload.question,
+    JSON.stringify({ text: quoteTurn.text, quotes: (quoteTurn.quotes || []).length }),
+  )
+  assert(
+    '用户气泡里画出了引用块（引用在上、问题在下）',
+    textOf(chatLog).indexOf('❝ 小窗详解') >= 0 && textOf(chatLog).indexOf('这几段有什么关系？') >= 0,
+    textOf(chatLog).slice(-90),
+  )
+  assert(
+    '气泡里的引用是摘要（长引用不撑破气泡，完整文本进 title）',
+    Array.from(walk(chatLog)).some((n) => n.className === 'dsh-sel-bqitem' && n.title === '第二段引用'),
+    Array.from(walk(chatLog)).filter((n) => n.className === 'dsh-sel-bqitem').map((n) => n.title).join('|'),
+  )
+
+  // ④ 带引用的那一轮要以"拼好的样子"进历史给模型（否则下一轮模型不知道"这几段"指什么）
+  for (let i = 0; i < 120 && hook.state().asking !== false; i += 1) await sleep(20)
+  const beforeSecond = sent.length
+  hook.ask('那第三段呢？')
+  for (let i = 0; i < 120 && sent.length === beforeSecond; i += 1) await sleep(20)
+  const secondPayload = sent[sent.length - 1] || {}
+  const carried = (secondPayload.history || []).find((t) => t.role === 'user' && String(t.text).indexOf('【引用 1】') >= 0)
+  assert(
+    '带引用的那一轮原样进历史（引用块不能丢）',
+    !!carried && String(carried.text).indexOf('【我的问题】') > 0,
+    carried ? String(carried.text).replace(/\n/g, '⏎').slice(0, 60) : JSON.stringify((secondPayload.history || []).map((t) => t.role)),
+  )
+
+  // ④b 小窗里的对话引用：**不带上下文**，但要说清出自哪一轮（对话本身会随历史进模型）
+  for (let i = 0; i < 120 && hook.state().asking !== false; i += 1) await sleep(20)
+  {
+    const bubbles = Array.from(walk(chatLog)).filter((n) => n.className.indexOf('dsh-sel-bubble-bot') >= 0)
+    const target = bubbles[bubbles.length - 1]
+    const node = Array.from(walk(target)).find((n) => n.tagName === 'P') || target
+    selectText(node, '这是对追问的回答')
+    documentStub.dispatch('mouseup', { target: node })
+    await sleep(30)
+    const state = hook.quoteState()
+    assert('小窗气泡里划词：认得出在哪一轮上', state.selection && state.selection.turnIndex >= 0, JSON.stringify(state.selection))
+    quoteButton.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+    await sleep(10)
+    const panelQuote = hook.quotes().pop()
+    assert(
+      '对话引用的出处 = 「小窗第 N 轮回答」',
+      !!panelQuote && /^小窗第 [0-9]+ 轮回答$/.test(panelQuote.label),
+      panelQuote && panelQuote.label,
+    )
+    assert(
+      '对话引用不带上下文（小窗对话本来就在历史里，重复贴没意义）',
+      !!panelQuote && panelQuote.context === '' && panelQuote.session === false,
+      JSON.stringify(panelQuote && { context: panelQuote.context, session: panelQuote.session }),
+    )
+    const composed = hook.compose()
+    assert(
+      '拼进消息时只写出处、不贴【引用处上下文】',
+      composed.indexOf('【引用处上下文】') < 0 &&
+        composed.indexOf('【引用原文】') < 0 &&
+        composed.indexOf('【引用 1】（来自小窗第') === 0,
+      composed.replace(/\n/g, '⏎').slice(0, 160),
+    )
+    // 这一段不发了，清掉，别影响后面的用例
+    const lastChip = Array.from(walk(quotesBox)).filter((n) => n.className === 'dsh-sel-quotechip-x').pop()
+    if (lastChip) lastChip.dispatch('click', { stopPropagation() {} })
+    await sleep(5)
+  }
+
+  // ④c host 不认（引用不在会话里 / 路由失败）→ 用客户端自己采的那份上下文，照发不误
+  for (let i = 0; i < 120 && hook.state().asking !== false; i += 1) await sleep(20)
+  {
+    globalThis.__quoteContextFixture = 'miss'
+    hook.quote('回退探测的一段', '主界面选中', { context: '客户端兜底的上下文：用户：【回退探测的一段】', session: true })
+    const beforeFallback = sent.length
+    hook.ask('回退探测：这段呢？')
+    for (let i = 0; i < 120 && sent.length === beforeFallback; i += 1) await sleep(20)
+    const fallbackPayload = sent[sent.length - 1] || {}
+    assert(
+      'host 定位不到时用客户端兜底的上下文（发送不被卡住）',
+      String(fallbackPayload.question).indexOf('用户：【回退探测的一段】') > 0,
+      String(fallbackPayload.question).replace(/\n/g, '⏎').slice(0, 120),
+    )
+    globalThis.__quoteContextFixture = undefined
+  }
+
+  // ⑤ 只挂引用、没写问题：也允许发（兜底一句人话，绝不空发）
+  for (let i = 0; i < 120 && hook.state().asking !== false; i += 1) await sleep(20)
+  hook.quote('只带引用的一段', '主界面选中')
+  askBox.value = ''
+  const beforeOnly = sent.length
+  askBox.dispatch('keydown', { key: 'Enter', preventDefault() {}, stopPropagation() {} })
+  for (let i = 0; i < 120 && sent.length === beforeOnly; i += 1) await sleep(20)
+  const onlyPayload = sent[sent.length - 1] || {}
+  assert('空输入框 + 有引用时按 Enter 能发出去', sent.length === beforeOnly + 1, `sent=${sent.length - beforeOnly}`)
+  assert(
+    '兜底提问只有一句，引用块照旧在前',
+    String(onlyPayload.question).indexOf('【我的问题】\n就上面引用的文字，说说它在这里是什么意思。') > 0,
+    String(onlyPayload.question).replace(/\n/g, '⏎').slice(-60),
+  )
+  const onlyTurn = hook.turns().filter((t) => t.role === 'user').pop()
+  assert('气泡里显示的就是那句兜底提问', onlyTurn.text === '就上面引用的文字，说说它在这里是什么意思。', onlyTurn.text)
+
+  // ⑥ 助手气泡末尾的「引用整条」（平时隐身，鼠标移上去才浮出来）
+  for (let i = 0; i < 120 && hook.state().asking !== false; i += 1) await sleep(20)
+  const botBubbles = Array.from(walk(chatLog)).filter((n) => n.className.indexOf('dsh-sel-bubble-bot') >= 0)
+  const lastBot = botBubbles[botBubbles.length - 1]
+  const quoteAllBtn = Array.from(walk(lastBot)).find((n) => String(n.className).indexOf('dsh-sel-bubquote') >= 0)
+  assert('助手气泡末尾有「引用整条」', !!quoteAllBtn && textOf(quoteAllBtn).indexOf('引用整条') >= 0, quoteAllBtn ? textOf(quoteAllBtn) : '未找到')
+  quoteAllBtn.dispatch('click', { stopPropagation() {} })
+  await sleep(10)
+  const allQuotes = hook.quotes()
+  const lastBotTurn = hook.turns().filter((t) => t.role === 'assistant' && t.streaming !== true).pop()
+  assert(
+    '点一下 → 整条回答进了引用',
+    allQuotes.length === 1 && /^小窗第 [0-9]+ 轮回答$/.test(allQuotes[0].label) && allQuotes[0].text.indexOf('这是对追问的回答') >= 0,
+    JSON.stringify(allQuotes.map((q) => q.label + ':' + q.text.slice(0, 16))),
+  )
+  assert('引用的是这一轮的原文（卡片上才是摘要）', allQuotes[0].text === lastBotTurn.text, `${allQuotes[0].text.length} vs ${String(lastBotTurn.text).length}`)
+  assert(
+    '「引用整条」也不带上下文（出处靠标签）',
+    allQuotes[0].context === '' && allQuotes[0].session === false,
+    JSON.stringify({ context: allQuotes[0].context, session: allQuotes[0].session }),
+  )
+
+  // ⑥b 等待/流式中的那条不给「引用整条」：内容是半截的，引用它没有意义（定稿后才出现）
+  {
+    hook.open('quote-wait-probe', '', '等待用例')
+    for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+    hook.ask('等待用例的问题')
+    let sawStreaming = false
+    for (let i = 0; i < 60; i += 1) {
+      if (hook.turns().some((t) => t.streaming === true)) {
+        sawStreaming = true
+        break
+      }
+      await sleep(10)
+    }
+    const waiting = Array.from(walk(chatLog)).filter((n) => n.className.indexOf('dsh-sel-bubble-bot') >= 0).pop()
+    assert(
+      '等待/流式中的那条不给「引用整条」',
+      sawStreaming &&
+        !!waiting &&
+        !Array.from(walk(waiting)).some((n) => String(n.className).indexOf('dsh-sel-bubquote') >= 0),
+      `${sawStreaming ? 'streaming' : '未抓到流式态'} · ${waiting ? textOf(waiting).slice(0, 20) : '未找到'}`,
+    )
+    for (let i = 0; i < 160 && hook.state().asking !== false; i += 1) await sleep(20)
+    const settled = Array.from(walk(chatLog)).filter((n) => n.className.indexOf('dsh-sel-bubble-bot') >= 0).pop()
+    assert(
+      '定稿之后「引用整条」才出现',
+      !!settled && Array.from(walk(settled)).some((n) => String(n.className).indexOf('dsh-sel-bubquote') >= 0),
+      settled ? textOf(settled).slice(0, 20) : '未找到',
+    )
+  }
+
+  // ⑦ 小窗收起来：浮标回到「✦ 解读」（引用只在开着小窗时有意义）
+  hook.close()
+  selectText(textEl, '主界面上的另一次选中')
+  documentStub.dispatch('mouseup', { target: textEl })
+  await sleep(30)
+  assert(
+    '小窗收起后：浮标回到「✦ 解读」，引用浮标不再出现',
+    quoteButton.style.display === 'none' && button.style.display === 'inline-flex',
+    `quote=${quoteButton.style.display} read=${button.style.display}`,
+  )
+
+  // ⑧ 换一段选中文字 = 换一次对话：上一段攒的引用不该跟过来
+  hook.open('slipped', '', '换选区')
+  await sleep(30)
+  assert(
+    '换选区后引用清单清空',
+    hook.quotes().length === 0 && quotesBox.getAttribute('data-show') === '0',
+    JSON.stringify(hook.quotes()),
+  )
+
+  windowStub.getSelection = restoreGetSelection
+  hook.close()
+}
+
+// ═════════════════════ 语音输入（麦克风 → 文字 → 输入框） ═════════════════════
+//
+// UI 与主会话 ui-voice-input 同一套：平时是输入框右边的 🎤，开始录之后工具行换成
+// 录音行 ——`✕` | 实时波形 | `■`；请求权限/识别中是「呼吸点 + 文案」；出错是「文案 + 行内动作」。
+// 桩里验四件事：
+//   ① 状态机与录音行的形态（哪一格在、哪一格不在，工具行左边三样有没有让位）；
+//   ② 波形真的在动（80 根线、静音基线、有声变高、从右往左推）；
+//   ③ 文字**插进输入框**（追加在光标处，不覆盖用户已经写了一半的话）；
+//   ④ 该松麦克风的时候一定要松（取消 / 失焦 / 收起小窗 / 这条消息发出去）。
+//
+// 真实识别（真模型 + 真音频）不在这里：见 scripts/test-speech.mjs 与 scripts/smoke-voice.mjs。
+function waitVoice(predicate, ms = 1500) {
+  const started = Date.now()
+  const step = async () => {
+    if (predicate()) return true
+    if (Date.now() - started > ms) return !!predicate()
+    await sleep(10)
+    return step()
+  }
+  return step()
+}
+
+/** 从 bundle 源码里抠一个具名函数（与 test-bridge.mjs 同一套配平逻辑）。 */
+function sliceFunction(text, name) {
+  const start = text.indexOf('function ' + name + '(')
+  if (start < 0) throw new Error('bundle 里找不到函数：' + name)
+  let depth = 0
+  for (let i = text.indexOf('{', start); i < text.length; i += 1) {
+    const ch = text[i]
+    if (ch === '{') depth += 1
+    else if (ch === '}') {
+      depth -= 1
+      if (depth === 0) return text.slice(start, i + 1)
+    } else if (ch === "'" || ch === '"' || ch === '`') {
+      for (i += 1; i < text.length; i += 1) {
+        if (text[i] === '\\') i += 1
+        else if (text[i] === ch) break
+      }
+    }
+  }
+  throw new Error('函数没配平：' + name)
+}
+
+{
+  // ── 浏览器音频桩 ──────────────────────────────────────────────
+  const micCalls = []
+  const micTracks = []
+  let micDenied = false
+  let micDeferred = null
+  const makeTrack = () => {
+    const track = {
+      stopped: false,
+      stop() {
+        this.stopped = true
+      },
+    }
+    micTracks.push(track)
+    return track
+  }
+  const makeStream = () => {
+    const track = makeTrack()
+    return { getTracks: () => [track] }
+  }
+  navigatorStub.mediaDevices = {
+    getUserMedia(constraints) {
+      micCalls.push(constraints)
+      if (micDenied) {
+        const error = new Error('Permission denied')
+        error.name = 'NotAllowedError'
+        return Promise.reject(error)
+      }
+      if (micDeferred) {
+        const pending = micDeferred
+        micDeferred = null
+        return pending.promise.then(() => makeStream())
+      }
+      return Promise.resolve(makeStream())
+    },
+  }
+  /**
+   * 电平序列：头几拍是静音（刚点下麦克风还没开口），之后逐次抬高。
+   * 这样既能看到"静音 = 2px 基线"，也能看到"新电平从右边进来"（恒定电平看不出推进）。
+   */
+  let levelStep = 0
+  const nextLevel = () => {
+    levelStep += 1
+    if (levelStep <= 3) return 0
+    return Math.min(0.06 + (levelStep - 3) * 0.012, 0.5)
+  }
+  class MediaRecorderStub {
+    constructor(stream) {
+      this.stream = stream
+      this.state = 'recording'
+      this.mimeType = 'audio/webm;codecs=opus'
+      MediaRecorderStub.last = this
+    }
+    start() {
+      this.state = 'recording'
+    }
+    stop() {
+      this.state = 'inactive'
+      const chunk = new Blob([new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])], { type: 'audio/webm' })
+      if (this.ondataavailable) this.ondataavailable({ data: chunk })
+      if (this.onstop) this.onstop()
+    }
+  }
+  class AudioContextStub {
+    constructor() {
+      this.state = 'running'
+      this.closed = false
+      /** 真实浏览器里通常是 44100/48000：实时字幕的线性重采样要按这个走 */
+      this.sampleRate = 48000
+      this.processors = []
+      AudioContextStub.instances.push(this)
+    }
+    createGain() {
+      return { gain: { value: 1 }, connect() {}, disconnect() {} }
+    }
+    createScriptProcessor(size) {
+      const node = { size, onaudioprocess: null, connect() {}, disconnect() {} }
+      this.processors.push(node)
+      return node
+    }
+    createAnalyser() {
+      return {
+        fftSize: 256,
+        getFloatTimeDomainData(array) {
+          const level = nextLevel()
+          for (let i = 0; i < array.length; i += 1) array[i] = level
+        },
+      }
+    }
+    createMediaStreamSource() {
+      return { connect() {} }
+    }
+    decodeAudioData(_buffer, ok) {
+      // 2 秒的"解码结果"：下游只关心 duration 与重采样
+      if (ok) ok({ duration: 2, sampleRate: 48000, numberOfChannels: 2 })
+      return Promise.resolve({ duration: 2, sampleRate: 48000, numberOfChannels: 2 })
+    }
+    close() {
+      this.closed = true
+      return Promise.resolve()
+    }
+  }
+  AudioContextStub.instances = []
+  class OfflineAudioContextStub {
+    constructor(channels, frames, rate) {
+      this.frames = frames
+      this.sampleRate = rate
+      OfflineAudioContextStub.last = this
+    }
+    createBufferSource() {
+      return { buffer: null, connect() {}, start() {} }
+    }
+    startRendering() {
+      const data = new Float32Array(this.frames)
+      for (let i = 0; i < data.length; i += 1) data[i] = Math.sin(i / 20) * 0.5
+      return Promise.resolve({ getChannelData: () => data, duration: this.frames / this.sampleRate })
+    }
+  }
+  windowStub.MediaRecorder = MediaRecorderStub
+  windowStub.AudioContext = AudioContextStub
+  windowStub.OfflineAudioContext = OfflineAudioContextStub
+
+  // ── 面板：打开到"翻译就绪、composer 可见" ──────────────────────
+  hook.open('voice-probe', '', '语音输入')
+  await waitVoice(() => hook.state().phase === 'done')
+  const askRowNode = Array.from(walk(panel)).find((n) => String(n.className).split(/\s+/).includes('dsh-sel-ask'))
+  assert('语音用例：composer 已可见', !!askRowNode && askRowNode.style.display !== 'none', askRowNode && askRowNode.style.display)
+
+  const micButton = hook.voiceNode()
+  const nodes = hook.voiceNodes()
+  const webModeNode = Array.from(walk(panel)).find((n) => String(n.className).split(/\s+/).includes('dsh-sel-pref'))
+  const modelPillNode = Array.from(walk(panel)).find((n) => String(n.className).split(/\s+/).includes('dsh-sel-picker'))
+  const micNode = Array.from(walk(panel)).find((n) => String(n.className).split(/\s+/).includes('dsh-sel-mic'))
+  const toolsRow = micNode && micNode.parentNode
+  assert('composer 里有麦克风按钮（和发送键同属工具行）', !!micNode && !!nodes.row, String(!!micNode))
+  assert(
+    '麦克风在发送键左边（贴 composer 主操作区）',
+    !!toolsRow && toolsRow.children.indexOf(micNode) < toolsRow.children.indexOf(askSend),
+    toolsRow ? `${toolsRow.children.indexOf(micNode)} < ${toolsRow.children.indexOf(askSend)}` : 'no row',
+  )
+  assert(
+    '初始：录音行没出来、🎤 可见、状态文案是空的',
+    hook.voice().phase === 'idle' && hook.voice().capture === false && nodes.row.style.display === 'none' && hook.voice().activity === '',
+    JSON.stringify(hook.voice()).slice(0, 120),
+  )
+  assert('自检钩子能看到"这个环境支持录音"', hook.voice().supported === true, String(hook.voice().supported))
+
+  // ── ① 点一下：请求权限 → 录音（工具行换成录音行）────────────────
+  const waveBarsCount = nodes.wave.children.length
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'requesting')
+  assert('点 🎤 → 请求权限：录音行出来（和主会话一样，工具行整行换掉）', hook.voice().capture === true, String(hook.voice().capture))
+  assert('请求权限时：文案 + 呼吸点，波形与 ■ 都不出现', hook.voice().activity.indexOf('请允许使用麦克风') >= 0 && hook.voice().dot === true && hook.voice().waveform === false && hook.voice().stop === false, hook.voice().activity)
+  assert(
+    '录音行出来时，输出偏好 / 模型 / 🎤 让位（一行只讲一件事）',
+    webModeNode.style.display === 'none' && modelPillNode.style.display === 'none' && micButton.style.display === 'none',
+    `${webModeNode.style.display} / ${modelPillNode.style.display} / ${micButton.style.display}`,
+  )
+  assert('录音行是 ✕ 打头（取消在左边）', nodes.row.children[0] === nodes.cancel, String(nodes.row.children.indexOf(nodes.cancel)))
+  assert('波形是 80 根线（和主会话同一个形状）', waveBarsCount === 80, String(waveBarsCount))
+
+  await waitVoice(() => hook.voice().phase === 'recording')
+  assert('拿到麦克风 → 进入录音态', hook.voice().phase === 'recording', hook.voice().phase)
+  assert('录音时：波形出现、状态文案收起、■ 出现（✕ | 波形 | ■）', hook.voice().waveform === true && hook.voice().stop === true && nodes.activity.style.display === 'none', JSON.stringify({ wave: hook.voice().waveform, stop: hook.voice().stop }))
+  assert('只向浏览器要了麦克风（不要摄像头）', micCalls.length === 1 && micCalls[0].video === false, JSON.stringify(micCalls[0]))
+  assert(
+    '静音时波形是一条虚线（没收到声音的格子都是 2px 基线）',
+    hook.voice().bars.filter((height) => height === 2).length >= 70,
+    JSON.stringify(hook.voice().bars.slice(0, 6)),
+  )
+
+  await sleep(320)
+  const bars = hook.voice().bars
+  assert('有声之后波形变高（1+min(1,amp*5)*17）', Math.max.apply(null, bars) > 3, String(Math.max.apply(null, bars)))
+  assert(
+    '新的电平从右边进来、整排往左推（最右边最高）',
+    bars[0] > bars[bars.length - 1],
+    `${bars[0]} vs ${bars[bars.length - 1]}`,
+  )
+  assert('录音中不显示秒数文案（主会话也是只看波形）', hook.voice().activity === '', JSON.stringify(hook.voice().activity))
+
+  // ── ② 点 ■ 结束：识别 → 文字插进输入框 ─────────────────────────
+  const firstTrack = micTracks[micTracks.length - 1]
+  nodes.stop.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'transcribing')
+  assert('点 ■ → 识别中：文案 + 呼吸点，波形与 ■ 收起', hook.voice().activity.indexOf('识别中') >= 0 && hook.voice().dot === true && hook.voice().waveform === false && hook.voice().stop === false, hook.voice().activity)
+  assert('录音结束 → 松开麦克风（音轨停掉）', firstTrack.stopped === true)
+  await waitVoice(() => hook.voice().lastText !== '')
+  assert('录音结束后 AudioContext 关掉（不留音频线程）', AudioContextStub.instances.every((ctx) => ctx.closed === true), String(AudioContextStub.instances.length))
+  assert('重采样成 16kHz（host 只收这一种）', OfflineAudioContextStub.last && OfflineAudioContextStub.last.sampleRate === 16000, String(OfflineAudioContextStub.last && OfflineAudioContextStub.last.sampleRate))
+  assert('识别请求发到了 host（带 base64 音频、不带文件路径之类）', speechTranscribeCalls.length === 1 && typeof speechTranscribeCalls[0].audioBase64 === 'string', Object.keys(speechTranscribeCalls[0] || {}).join(','))
+  assert('识别出来的文字进了输入框', askBox.value.indexOf('这段是语音转出来的问题') >= 0, askBox.value)
+  assert('插入后光标在末尾（接着就能改 / 接着说）', askBox.selectionStart === askBox.value.length, `${askBox.selectionStart}/${askBox.value.length}`)
+  assert('插入后发送键可点', askSend.disabled === false, String(askSend.disabled))
+  await waitVoice(() => hook.voice().phase === 'idle')
+  assert('成功之后立刻回 idle：录音行收起、🎤 回来、不留多余提示（和主会话一致）', hook.voice().phase === 'idle' && hook.voice().capture === false && micButton.style.display === '' && hook.voice().activity === '', JSON.stringify({ phase: hook.voice().phase, activity: hook.voice().activity }))
+
+  // ── ③ 追加而不是覆盖：用户已经写了一半时接着说 ────────────────
+  hook.askValue('先写的一句')
+  speechTranscript = { ok: true, text: '后面补的一句' }
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  nodes.stop.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().lastText === '后面补的一句')
+  assert('已有内容时是追加（中间补一个空格）', askBox.value === '先写的一句 后面补的一句', askBox.value)
+  await waitVoice(() => hook.voice().phase === 'idle')
+  hook.askValue('')
+
+  // ── ④ 失败路径：权限被拒 → feedback + 🎤 重录 ──────────────────
+  micDenied = true
+  const tracksBeforeDenied = micTracks.length
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'feedback')
+  assert('权限被拒：录音行里给原因（不是 DOMException 原文）', hook.voice().activity.indexOf('麦克风权限未开启') >= 0 && hook.voice().activityTone === 'error', `${hook.voice().activityTone} ${hook.voice().activity}`)
+  assert('权限被拒时一个音轨都没拿到', micTracks.length === tracksBeforeDenied, `${micTracks.length} vs ${tracksBeforeDenied}`)
+  assert('失败时给「重新录音」🎤（主会话同款行内动作）', hook.voice().action === 'retry' && nodes.action.children.length === 1, `${hook.voice().action} / ${nodes.action.children.length}`)
+  micDenied = false
+
+  // ── ⑤ ✕ 关掉这条提示（feedback → idle，工具行还回去）──────────
+  nodes.cancel.dispatch('click', { stopPropagation() {} })
+  await sleep(20)
+  assert('点 ✕ 关掉提示：回 idle、工具行还原（输出偏好 / 模型 / 🎤 都回来）', hook.voice().phase === 'idle' && hook.voice().capture === false && webModeNode.style.display === '' && modelPillNode.style.display === '' && micButton.style.display === '', `${hook.voice().phase} ${webModeNode.style.display}`)
+
+  // ── ⑥ 模型没准备好 → 「准备模型」行内动作 ───────────────────────
+  const goodCatalog = speechCatalog
+  speechCatalog = {
+    ...goodCatalog,
+    available: false,
+    reason: 'unprepared',
+    providers: [{ ...goodCatalog.providers[0], phase: 'unprepared' }],
+  }
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().action === 'prepare')
+  assert('模型没准备：说清 + 给「准备模型」按钮', hook.voice().activity.indexOf('语音模型还没准备好') >= 0 && hook.voice().activityTone === 'warn', `${hook.voice().activityTone} ${hook.voice().activity}`)
+  assert('没准备好时不进录音态（不在没模型时占着麦克风）', hook.voice().phase === 'feedback' && micTracks.length === tracksBeforeDenied, hook.voice().phase)
+  const prepareBtn = nodes.action.children[0]
+  assert('提示里的按钮确实画出来了', !!prepareBtn && prepareBtn.textContent === '准备模型', prepareBtn ? prepareBtn.textContent : 'none')
+  speechCatalog = { ...goodCatalog, available: true, providers: [{ ...goodCatalog.providers[0], phase: 'ready' }] }
+  prepareBtn.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => speechPrepareCalls > 0)
+  assert('点「准备模型」→ 通知 host 去准备（下载在 host 上跑）', speechPrepareCalls === 1, String(speechPrepareCalls))
+  assert('准备中：复用"进行中"形态（文案 + 呼吸点）', hook.voice().activity.indexOf('正在准备语音模型') >= 0 && hook.voice().dot === true, hook.voice().activity)
+  await waitVoice(() => hook.voice().activity.indexOf('已就绪') >= 0, 3000)
+  assert('准备完成后提示"可以开始说话"（行内动作换成 🎤）', hook.voice().activity.indexOf('已就绪') >= 0 && hook.voice().action === 'retry', `${hook.voice().action} ${hook.voice().activity}`)
+  speechCatalog = goodCatalog
+  nodes.cancel.dispatch('click', { stopPropagation() {} })
+  await sleep(20)
+
+  // ── ⑦ 失败路径：识别失败 / 没听清 ──────────────────────────────
+  speechTranscript = { ok: false, code: 'failed', error: '识别服务挂了' }
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  nodes.stop.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'feedback')
+  assert('识别失败：原样说清原因', hook.voice().activityTone === 'error' && hook.voice().activity.indexOf('识别服务挂了') >= 0, hook.voice().activity)
+  assert('识别失败不会往输入框里塞东西', askBox.value === '', JSON.stringify(askBox.value))
+
+  speechTranscript = { ok: false, code: 'empty-transcript', error: '没听清（这段录音里没有识别到内容）' }
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  nodes.stop.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().activity.indexOf('未识别到语音') >= 0)
+  assert('没听清：给主会话那句「未识别到语音」+ 可重录', hook.voice().activity === '未识别到语音' && hook.voice().activityTone === 'warn' && hook.voice().action === 'retry', `${hook.voice().activityTone} ${hook.voice().activity}`)
+
+  // 识别中点 ✕ = 取消（不能有文字冒出来）
+  speechTranscript = { ok: true, text: '这段不该被插进去' }
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  nodes.stop.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'transcribing')
+  nodes.cancel.dispatch('click', { stopPropagation() {} })
+  await sleep(80)
+  assert('识别中点 ✕ = 取消（回 idle）', hook.voice().phase === 'idle' && hook.voice().capture === false, hook.voice().phase)
+  assert('取消之后晚到的结果不会插进输入框', askBox.value.indexOf('这段不该被插进去') < 0, JSON.stringify(askBox.value))
+
+  // ── ⑧ 权限还没回来就取消：晚到的授权不能变成"在录音" ────────────
+  micDeferred = Promise.withResolvers()
+  speechTranscript = { ok: true, text: '不该出现的第二段' }
+  const beforeCancelCalls = micCalls.length
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => micCalls.length === beforeCancelCalls + 1)
+  assert('点了麦克风之后到授权回来之前是「请求中」', hook.voice().phase === 'requesting', `${hook.voice().phase} calls=${micCalls.length}`)
+  nodes.cancel.dispatch('click', { stopPropagation() {} })
+  assert('请求中点 ✕ = 取消（回 idle）', hook.voice().phase === 'idle' && hook.voice().capture === false, hook.voice().phase)
+  const tracksBeforeLate = micTracks.length
+  micDeferred && micDeferred.resolve()
+  await sleep(80)
+  assert(
+    '取消后晚到的授权不会偷偷开录（也不留下音轨）',
+    hook.voice().phase === 'idle' && micTracks.length === tracksBeforeLate,
+    `${hook.voice().phase} tracks=${micTracks.length - tracksBeforeLate}`,
+  )
+
+  // ── ⑨ 这条消息发出去了：正在录的那段收掉 ───────────────────────
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  const sendTrack = micTracks[micTracks.length - 1]
+  hook.ask('边录边说的问题')
+  await sleep(60)
+  assert('发送消息时正在录的那段被收掉（音轨停掉）', sendTrack.stopped === true, String(sendTrack.stopped))
+  assert('并说明为什么停（不是悄悄停）', hook.voice().activity.indexOf('已停止录音') >= 0, hook.voice().activity)
+  await waitVoice(() => hook.voice().phase === 'idle', 3000)
+  assert('这句交代过两秒自己收起（不占着录音行）', hook.voice().capture === false, String(hook.voice().capture))
+
+  // ── ⑩ 切走窗口（blur）= 停止录音，识别不打断 ───────────────────
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  const blurTrack = micTracks[micTracks.length - 1]
+  windowStub.dispatch('blur', {})
+  await sleep(30)
+  assert('窗口失焦：录音取消、麦克风松开（主会话同款）', blurTrack.stopped === true && hook.voice().phase === 'idle', `${blurTrack.stopped} ${hook.voice().phase}`)
+
+  // ── ⑪ 收起小窗 = 立刻松麦克风 ─────────────────────────────────
+  micButton.dispatch('click', { stopPropagation() {} })
+  await waitVoice(() => hook.voice().phase === 'recording')
+  const openTrack = micTracks[micTracks.length - 1]
+  hook.close()
+  await sleep(30)
+  assert('收起小窗：音轨停掉、状态回 idle', openTrack.stopped === true && hook.voice().phase === 'idle', `${openTrack.stopped} ${hook.voice().phase}`)
+  assert('收起小窗：录音行一起收掉（不留半句"正在录音"）', hook.voice().capture === false && hook.voice().activity === '', JSON.stringify({ capture: hook.voice().capture, activity: hook.voice().activity }))
+
+  // ══════════ ⑬ 实时字幕：半句预览 + 停顿定稿（采样水龙头驱动）══════════
+  // 真浏览器里 onaudioprocess 会自己喂采样；桩里由测试直接喂（同一段代码路径）。
+  const feedTap = (node, seconds, amplitude) => {
+    const frames = Math.round(seconds * 48000)
+    const chunk = new Float32Array(frames)
+    for (let i = 0; i < frames; i += 1) chunk[i] = amplitude
+    node.onaudioprocess({ inputBuffer: { getChannelData: () => chunk } })
+  }
+
+  {
+    const before = askBox.value
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    assert('录音时接上了采样水龙头（实时字幕的前提）', !!tap && hook.voice().live.active === true && hook.voice().live.disabled === false, JSON.stringify(hook.voice().live).slice(0, 120))
+
+    // 说 1.2 秒（响）→ 第一拍半句预览
+    speechTranscriptQueue = [{ ok: true, text: '这半句还在说' }]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.passes.preview >= 1, 2000)
+    await waitVoice(() => hook.voice().live.preview !== '', 2000)
+    assert('说话时字就往输入框里长（半句预览）', hook.voice().live.preview === '这半句还在说' && askBox.value.indexOf('这半句还在说') >= 0, `${hook.voice().live.preview} / ${JSON.stringify(askBox.value)}`)
+    assert('预览是插在原来那段文字后面，不是另起一段', askBox.value.startsWith(before), JSON.stringify(askBox.value))
+
+    // 静音 0.9 秒 → 这句说完了：定稿
+    speechTranscriptQueue = [{ ok: true, text: '这句定稿了' }]
+    feedTap(tap, 0.9, 0)
+    await waitVoice(() => hook.voice().live.passes.commit >= 1, 2500)
+    await waitVoice(() => hook.voice().live.committed !== '', 2500)
+    assert('停顿 0.6 秒以上 → 这句定稿（预览换成定稿）', hook.voice().live.committed === '这句定稿了' && hook.voice().live.preview === '', JSON.stringify({ committed: hook.voice().live.committed, preview: hook.voice().live.preview }))
+    assert('定稿的文字留在输入框里', askBox.value.indexOf('这句定稿了') >= 0, JSON.stringify(askBox.value))
+
+    // 还在说（持续有声，不产生停顿）→ 第二句以"半句预览"接在定稿后面
+    hook.voiceTick()
+    speechTranscriptRepeat = { ok: true, text: '下一句也在跟' }
+    const keepTalking = setInterval(() => feedTap(tap, 0.2, 0.3), 120)
+    await waitVoice(() => hook.voice().live.preview === '下一句也在跟', 4000)
+    assert('定稿不丢、新的半句接在后面', hook.voice().live.committed === '这句定稿了' && hook.voice().live.preview === '下一句也在跟', JSON.stringify({ committed: hook.voice().live.committed, preview: hook.voice().live.preview }))
+    clearInterval(keepTalking)
+    speechTranscriptRepeat = null
+    assert('输入框里是「定稿 + 空格 + 预览」', askBox.value.indexOf('这句定稿了 下一句也在跟') >= 0, JSON.stringify(askBox.value))
+
+    // ■ 停止：整段识别以定稿开头 → 只补后半句，定稿的字一个不动
+    speechTranscriptQueue = [{ ok: true, text: '这句定稿了 下一句也在跟，而且整段还多说了几个字' }]
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert(
+      '停止时以整段为准收口：定稿部分原样保留，只把后面补全',
+      askBox.value.indexOf('这句定稿了 下一句也在跟，而且整段还多说了几个字') >= 0 && hook.voice().live.rewritten === false,
+      JSON.stringify(askBox.value),
+    )
+    assert('停止后实时层关掉（不再刷新）', hook.voice().live.active === false, String(hook.voice().live.active))
+  }
+
+  // ── ⑭ 整段识别"对不上"时：以整段为准整块替换（并记一笔）──────────
+  {
+    hook.askValue('')
+    speechTranscriptQueue = [{ ok: true, text: '实时那段' }, { ok: true, text: '实时定稿的那句' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.passes.preview >= 1, 2000)
+    feedTap(tap, 0.9, 0)
+    await waitVoice(() => hook.voice().live.committed !== '', 3000)
+    assert('（前置）这一句已经定稿', hook.voice().live.committed === '实时定稿的那句', JSON.stringify(hook.voice().live.committed))
+    speechTranscriptQueue = [{ ok: true, text: '整段识别给的是完全不同的句子' }]
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert('整段与实时对不上时：整块替换，并以自检记一笔', askBox.value === '整段识别给的是完全不同的句子' && hook.voice().live.rewritten === true, JSON.stringify({ value: askBox.value, rewritten: hook.voice().live.rewritten }))
+  }
+
+  // ── ⑮ ✕ 取消 = 只停，已经说出来的字留着（用户明确要的语义）──────────
+  {
+    hook.askValue('手写的一句')
+    speechTranscriptQueue = [{ ok: true, text: '取消之后这句要留着' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '取消之后这句要留着', 3000)
+    await waitVoice(() => hook.voice().live.passes.preview >= 1, 500)
+    assert('取消前：预览已经在输入框里', askBox.value.indexOf('取消之后这句要留着') >= 0, JSON.stringify(askBox.value))
+    const track = micTracks[micTracks.length - 1]
+    nodes.cancel.dispatch('click', { stopPropagation() {} })
+    await sleep(40)
+    assert('✕ 取消 = 停录、松开麦克风', hook.voice().phase === 'idle' && hook.voice().capture === false && track.stopped === true, JSON.stringify({ phase: hook.voice().phase, stopped: track.stopped }))
+    assert('✕ 取消 = 已经说出来的字**留着**（连着手写那句一起）', askBox.value === '手写的一句 取消之后这句要留着', JSON.stringify(askBox.value))
+    assert('取消后实时层关掉（不再更新那段文字）', hook.voice().live.active === false, JSON.stringify({ active: hook.voice().live.active }))
+  }
+
+  // ── ⑯ 失焦 / 收起小窗：录音停下，屏幕上的字留着 ─────────────────
+  {
+    hook.askValue('')
+    speechTranscriptQueue = [{ ok: true, text: '切走也别丢字' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '切走也别丢字', 3000)
+    windowStub.dispatch('blur', {})
+    await sleep(40)
+    assert('失焦停录，但已经写进输入框的字留着', hook.voice().phase === 'idle' && askBox.value.indexOf('切走也别丢字') >= 0, JSON.stringify({ phase: hook.voice().phase, value: askBox.value }))
+    hook.askValue('')
+  }
+
+  // ── ⑰ 用户在实时那段里改字 → 实时层让位（不跟用户抢）────────────
+  {
+    speechTranscriptQueue = [{ ok: true, text: '我是预览' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '我是预览' && askBox.value.indexOf('我是预览') >= 0, 3000)
+    askBox.value = askBox.value.replace('我是预览', '我改成别的了')
+    askBox.dispatch('input', {})
+    feedTap(tap, 1.2, 0.3)
+    hook.voiceTick()
+    await sleep(300)
+    assert('用户改了实时那段 → 实时层让位（不改他的字）', hook.voice().live.disabled === true && hook.voice().live.reason === 'edited' && askBox.value.indexOf('我改成别的了') >= 0, JSON.stringify({ reason: hook.voice().live.reason, value: askBox.value }))
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert('让位之后停止仍然出最终文字（退回普通插入）', askBox.value.indexOf('我是预览'.slice(0, 0)) >= 0 && askBox.value.indexOf('我改成别的了') >= 0, JSON.stringify(askBox.value))
+    hook.askValue('')
+  }
+
+  // ── ⑱ 没有采样水龙头（老浏览器）：功能自动退回"停止后出字" ───────
+  {
+    const realScriptProcessor = AudioContextStub.prototype.createScriptProcessor
+    AudioContextStub.prototype.createScriptProcessor = undefined
+    speechTranscriptQueue = [{ ok: true, text: '没有水龙头也能出字' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    assert('拿不到水龙头：实时层自己关掉（不报错、不空转）', hook.voice().live.active === false && hook.voice().live.disabled === true && hook.voice().live.reason === 'no-tap', JSON.stringify(hook.voice().live).slice(0, 120))
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert('停止后照样把整段文字插进输入框（老行为不变）', askBox.value.indexOf('没有水龙头也能出字') >= 0, JSON.stringify(askBox.value))
+    AudioContextStub.prototype.createScriptProcessor = realScriptProcessor
+    hook.askValue('')
+  }
+
+  // ── ⑲ 云端识别器：不做实时预览（每拍一次付费调用），停止后照常出字 ──
+  {
+    const hostCatalogFixture = speechCatalog
+    speechCatalog = { ...hostCatalogFixture, providers: [{ ...hostCatalogFixture.providers[0], location: 'cloud' }] }
+    speechTranscriptQueue = [{ ok: true, text: '云端也能出字，只是没有预览' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    assert('云端识别器：实时层不开（reason=cloud）', hook.voice().live.active === false && hook.voice().live.disabled === true && hook.voice().live.reason === 'cloud', JSON.stringify(hook.voice().live).slice(0, 120))
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert('云端：停止后照常把文字插进输入框（退化成"说完再出字"）', askBox.value.indexOf('云端也能出字，只是没有预览') >= 0, JSON.stringify(askBox.value))
+    speechCatalog = hostCatalogFixture
+    hook.askValue('')
+  }
+
+  // ── ⑳ 回归：停顿那几拍"没听清"不能把实时层关掉（用户报的 bug）──────
+  // 症状："实时预览只跟第一句，后面就不吐字了"。
+  // 原因：停顿里的预览窗口是纯静音 → 识别返回空转写（没听清）→ 被当成"失败"计数，
+  //       连挂 3 次就把整个实时层 disable 了。
+  {
+    hook.askValue('')
+    speechTranscriptQueue = [{ ok: true, text: '第一句' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '第一句', 3000)
+
+    // 连续 5 拍都返回"没听清"（对应停顿里那些纯静音窗口）
+    speechTranscriptRepeat = { ok: false, code: 'empty-transcript', error: '没听清（这段录音里没有识别到内容）' }
+    for (let i = 0; i < 5; i += 1) {
+      feedTap(tap, 0.2, 0.3)
+      hook.voiceTick()
+      await sleep(150)
+    }
+    assert('空转写不算失败：连来 5 拍"没听清"也不关实时层', hook.voice().live.active === true && hook.voice().live.disabled === false, JSON.stringify({ active: hook.voice().live.active, disabled: hook.voice().live.disabled, reason: hook.voice().live.reason }))
+    assert('空结果也不会把上一拍的预览抹掉（不闪没）', hook.voice().live.preview === '第一句' && askBox.value.indexOf('第一句') >= 0, JSON.stringify({ preview: hook.voice().live.preview, value: askBox.value }))
+
+    // 后面的话照样跟着出字（正面用例）
+    speechTranscriptRepeat = { ok: true, text: '第二句照样跟' }
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '第二句照样跟', 3000)
+    // 预览本来就是"这一拍窗口的识别结果"，新文本会替换旧的；而且它随时可能被"停顿定稿"接手
+    //（这里喂完就停手，600ms 后确实会定稿）。这条回归要的是：**实时层还活着、新的话确实进了输入框**。
+    assert(
+      '同一段录音里，后面的话照样跟着出字（实时层没死）',
+      askBox.value.indexOf('第二句照样跟') >= 0 && hook.voice().live.disabled === false && hook.voice().live.reason === '',
+      JSON.stringify({ preview: hook.voice().live.preview, committed: hook.voice().live.committed, value: askBox.value, reason: hook.voice().live.reason }),
+    )
+    speechTranscriptRepeat = null
+    nodes.cancel.dispatch('click', { stopPropagation() {} })
+    await sleep(30)
+    hook.askValue('')
+  }
+
+  // ── ㉑ 真故障连续 5 次才让位；静音窗口根本不发请求 ────────────────
+  {
+    speechTranscriptQueue = [{ ok: true, text: '先定稿一句' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.passes.preview >= 1, 3000)
+
+    // 定稿之后一直是静音：窗口里没有新语音 → 一次调用都不该发
+    speechTranscriptQueue = [{ ok: true, text: '定稿的那句' }]
+    feedTap(tap, 0.9, 0)
+    await waitVoice(() => hook.voice().live.committed !== '', 3000)
+    const callsBefore = speechTranscribeCalls.length
+    feedTap(tap, 1.0, 0)
+    hook.voiceTick()
+    await sleep(250)
+    hook.voiceTick()
+    await sleep(250)
+    assert('定稿后一直静音：不再浪费识别调用（也避免把预览刷没）', speechTranscribeCalls.length === callsBefore && hook.voice().live.disabled === false, `${speechTranscribeCalls.length} vs ${callsBefore}`)
+
+    // 真故障（不是"没听清"）：连续 5 次才让位
+    speechTranscriptRepeat = { ok: false, code: 'failed', error: '识别服务挂了' }
+    for (let i = 0; i < 6; i += 1) {
+      feedTap(tap, 0.25, 0.3)
+      hook.voiceTick()
+      await sleep(180)
+    }
+    assert('真故障连续 5 次才让位（不让偶发一次超时把字幕关掉）', hook.voice().live.disabled === true && hook.voice().live.reason === 'preview-failed', JSON.stringify({ disabled: hook.voice().live.disabled, reason: hook.voice().live.reason }))
+    speechTranscriptRepeat = null
+    speechTranscriptQueue = [{ ok: true, text: '让位之后停止照样出字' }]
+    nodes.stop.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'idle', 3000)
+    assert('让位之后停止仍然出字（整段那条路不受影响）', askBox.value.indexOf('让位之后停止照样出字') >= 0, JSON.stringify(askBox.value))
+    hook.askValue('')
+  }
+
+  // ── ㉒ 输入框自适应拉伸（用户报：换行后下面的字看不见）────────────────
+  // 桩里的 scrollHeight 是可控的：直接改它再触发一次刷新，就是"内容变高了"。
+  {
+    const box = askBox
+    const originalScrollHeight = Object.getOwnPropertyDescriptor(box, 'scrollHeight')
+    box.value = ''
+    // 一行：高度=内容高度（和 CSS 的 min-height 一致），且不该出现滚动条
+    box.scrollHeight = 26
+    hook.askValue('一行')
+    assert('输入框：一行内容时高度就是内容高（不出滚动条）', box.style.height === '26px' && box.style.overflowY === 'hidden', JSON.stringify({ height: box.style.height, overflow: box.style.overflowY }))
+    box.scrollHeight = 78
+    hook.askValue('第一行\n第二行\n第三行')
+    assert('输入框：多行了就自己长高（高度=内容高）', box.style.height === '78px' && box.style.overflowY === 'hidden', JSON.stringify({ height: box.style.height, overflow: box.style.overflowY }))
+
+    box.scrollHeight = 400
+    hook.askValue('很多行'.repeat(80))
+    assert('输入框：到上限（132px）就停住、改成内部滚动', box.style.height === '132px' && box.style.overflowY === 'auto', JSON.stringify({ height: box.style.height, overflow: box.style.overflowY }))
+    assert('输入框：超过上限时自动滚到最新一行（语音输入一直在末尾加字）', box.scrollTop === 400, String(box.scrollTop))
+
+    // 语音输入落字 → 也会走同一条自适应（liveWrite → refreshAskState）
+    box.scrollHeight = 104
+    hook.askValue('')
+    speechTranscriptQueue = [{ ok: true, text: '这一句会比较长，长到换行以后还能看得见' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    box.scrollHeight = 104
+    await waitVoice(() => hook.voice().live.preview !== '', 3000)
+    assert('语音输入落字时输入框同样跟着长高', box.style.height === '104px', JSON.stringify({ height: box.style.height, value: box.value }))
+    nodes.cancel.dispatch('click', { stopPropagation() {} })
+    await sleep(30)
+
+    // 恢复桩的 scrollHeight 语义（后面的用例还要用）
+    box.scrollHeight = 0
+    if (originalScrollHeight) Object.defineProperty(box, 'scrollHeight', originalScrollHeight)
+    hook.askValue('')
+  }
+
+  // ── ㉓ Esc 分两级：先取消语音，再关窗（+ 开窗聚焦输入框）────────────
+  {
+    // 开窗 → 输入框可见后自动聚焦一次（假 DOM 里 focus 是空实现，这里换成探针）
+    let focused = 0
+    const realFocus = askBox.focus
+    askBox.focus = () => {
+      focused += 1
+    }
+    hook.open('voice-probe', '', 'Esc 语义')
+    await waitVoice(() => hook.state().phase === 'done', 3000)
+    assert('开窗后自动聚焦输入框（键盘用户不用先 Tab）', focused === 1, String(focused))
+
+    // ① 语音进行中按 Esc：只取消这一次语音，面板留着
+    speechTranscriptQueue = [{ ok: true, text: '按 Esc 之前已经在框里的字' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview !== '', 3000)
+    const track = micTracks[micTracks.length - 1]
+    documentStub.dispatch('keydown', { key: 'Escape', preventDefault() {}, stopPropagation() {} })
+    await sleep(40)
+    assert('语音中按 Esc：录音取消、麦克风松开', hook.voice().phase === 'idle' && track.stopped === true && hook.voice().capture === false, JSON.stringify({ phase: hook.voice().phase, stopped: track.stopped }))
+    assert('语音中按 Esc：面板**留着**（不再顺手关掉整个小窗）', hook.quoteState().panelOpen === true && panel.style.display === 'flex', String(hook.quoteState().panelOpen))
+    assert('语音中按 Esc：已经说出来的字留着（取消只停，不删字）', askBox.value.indexOf('按 Esc 之前已经在框里的字') >= 0, JSON.stringify(askBox.value))
+
+    // ② 不录音时再按 Esc：这次才关窗
+    documentStub.dispatch('keydown', { key: 'Escape', preventDefault() {}, stopPropagation() {} })
+    await sleep(40)
+    assert('不录音时按 Esc：关窗（两级 Esc 的第二级）', hook.quoteState().panelOpen === false && panel.style.display === 'none', String(hook.quoteState().panelOpen))
+
+    // ③ 提示行还在（feedback）时按 Esc：先收起提示，面板不关
+    micDenied = true
+    hook.open('voice-probe', '', 'Esc 语义')
+    await waitVoice(() => hook.state().phase === 'done', 3000)
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'feedback')
+    documentStub.dispatch('keydown', { key: 'Escape', preventDefault() {}, stopPropagation() {} })
+    await sleep(40)
+    assert('失败提示还在时按 Esc：收起提示、面板留着', hook.voice().phase === 'idle' && hook.quoteState().panelOpen === true, JSON.stringify({ phase: hook.voice().phase, open: hook.quoteState().panelOpen }))
+    micDenied = false
+    documentStub.dispatch('keydown', { key: 'Escape', preventDefault() {}, stopPropagation() {} })
+    await sleep(40)
+    assert('提示收掉之后再按 Esc 才关窗', hook.quoteState().panelOpen === false, String(hook.quoteState().panelOpen))
+    askBox.focus = realFocus
+    hook.askValue('')
+  }
+
+  // ── ㉔ 开窗聚焦的两种情形 + 录音时光标跟着预览走 ────────────────
+  {
+    let focused = 0
+    const realFocus = askBox.focus
+    askBox.focus = () => {
+      focused += 1
+    }
+    const realActive = documentStub.activeElement
+
+    // ① 焦点在浮标上 —— 这就是真实点开小窗时的情形（Chrome 点 <button> 会把焦点给它）
+    hook.close()
+    documentStub.activeElement = new FakeEl('button')
+    hook.open('voice-probe', '', '聚焦')
+    await waitVoice(() => hook.state().phase === 'done', 3000)
+    assert('开窗聚焦：焦点在浮标按钮上时也要把光标交给输入框（真实路径）', focused === 1, String(focused))
+
+    // ② 人家正在别处（主会话输入框）打字 → 不抢
+    hook.close()
+    focused = 0
+    documentStub.activeElement = new FakeEl('textarea')
+    hook.open('voice-probe', '', '聚焦')
+    await waitVoice(() => hook.state().phase === 'done', 3000)
+    assert('开窗聚焦：别人正在别处打字就不抢（那才是真的别打扰）', focused === 0, String(focused))
+
+    // ③ 录音一开始就把光标交给输入框；预览落字后光标停在最新文字后面
+    hook.close()
+    documentStub.activeElement = realActive
+    focused = 0
+    hook.askValue('')
+    speechTranscriptQueue = [{ ok: true, text: '第一拍预览' }]
+    micButton.dispatch('click', { stopPropagation() {} })
+    await waitVoice(() => hook.voice().phase === 'recording')
+    assert('录音开始就把光标交给输入框（不聚焦就看不见光标跳）', focused >= 1, String(focused))
+    const context = AudioContextStub.instances[AudioContextStub.instances.length - 1]
+    const tap = context.processors[context.processors.length - 1]
+    feedTap(tap, 1.2, 0.3)
+    await waitVoice(() => hook.voice().live.preview === '第一拍预览', 3000)
+    assert('预览落字后：光标停在最新文字末尾（会在那里跳）', askBox.selectionStart === askBox.value.length && askBox.value.length > 0, `${askBox.selectionStart}/${askBox.value.length}`)
+
+    // ④ 预览换成更长的一句 → 光标跟着新末尾走
+    speechTranscriptRepeat = { ok: true, text: '第二拍预览更长一些' }
+    feedTap(tap, 1.2, 0.3)
+    hook.voiceTick()
+    await waitVoice(() => hook.voice().live.preview === '第二拍预览更长一些', 3000)
+    assert('预览整段替换时：光标跟到新末尾（不会留在旧位置）', askBox.selectionStart === askBox.value.length, `${askBox.selectionStart}/${askBox.value.length}`)
+
+    // ⑤ 用户自己把光标挪走 → 不再跟着挪（不抢他的位置）
+    speechTranscriptRepeat = { ok: true, text: '第三拍再长一点的预览文字' }
+    askBox.setSelectionRange(0, 0)
+    feedTap(tap, 1.2, 0.3)
+    hook.voiceTick()
+    await sleep(250)
+    assert('用户自己挪了光标之后就不再跟着挪（不跟他抢位置）', askBox.selectionStart === 0, String(askBox.selectionStart))
+
+    speechTranscriptRepeat = null
+    nodes.cancel.dispatch('click', { stopPropagation() {} })
+    await sleep(40)
+    askBox.focus = realFocus
+    documentStub.activeElement = realActive
+    hook.askValue('')
+  }
+
+  // ── ⑫ 音频格式：和 host 的 validateWave 同源（纯函数打表）────────
+  const helpers = new Function(
+    [
+      sliceFunction(source, 'encodeWave'),
+      sliceFunction(source, 'bytesToBase64'),
+      sliceFunction(source, 'formatClock'),
+      'return { encodeWave: encodeWave, bytesToBase64: bytesToBase64, formatClock: formatClock }',
+    ].join('\n'),
+  )()
+  const samples = new Float32Array(16000) // 1 秒
+  for (let i = 0; i < samples.length; i += 1) samples[i] = Math.sin(i / 12) * 0.7
+  const wave = helpers.encodeWave(samples)
+  const view = new DataView(wave.buffer)
+  const ascii = (start, end) => Buffer.from(wave.slice(start, end)).toString('ascii')
+  assert('WAV 头：RIFF/WAVE/fmt', ascii(0, 4) === 'RIFF' && ascii(8, 12) === 'WAVE' && ascii(12, 16) === 'fmt ', ascii(0, 16))
+  assert(
+    'WAV 头：16kHz / 单声道 / PCM16（host 逐字段校验的就是这几个）',
+    view.getUint32(24, true) === 16000 && view.getUint16(22, true) === 1 && view.getUint16(34, true) === 16 && view.getUint16(20, true) === 1,
+    `${view.getUint32(24, true)}Hz ch=${view.getUint16(22, true)} bit=${view.getUint16(34, true)}`,
+  )
+  assert('WAV 头：长度字段自洽（RIFF / data 都算对）', view.getUint32(4, true) === wave.length - 8 && view.getUint32(40, true) === wave.length - 44, `${view.getUint32(4, true)} / ${view.getUint32(40, true)}`)
+  assert('WAV：1 秒 = 44 字节头 + 32000 字节数据', wave.length === 44 + 32000, String(wave.length))
+  assert('base64 是可解回来的（host 会校验"规范 base64"）', Buffer.from(helpers.bytesToBase64(wave), 'base64').equals(Buffer.from(wave)), 'round-trip')
+  const clipped = helpers.encodeWave(new Float32Array([2, -2, 0]))
+  // 16 位小端、有符号：+32767 = ff 7f，-32768 = 00 80（不夹的话 2*32767 会绕成负数）
+  assert(
+    '采样越界会被夹住（±2 不该绕回成爆音）',
+    clipped[44] === 0xff && clipped[45] === 0x7f && clipped[46] === 0x00 && clipped[47] === 0x80,
+    `${clipped[44]},${clipped[45]},${clipped[46]},${clipped[47]}`,
+  )
+  assert('录音秒数显示成 0:07 这种', helpers.formatClock(7500) === '0:07' && helpers.formatClock(60000) === '1:00', helpers.formatClock(7500))
+
+  hook.close()
+}
+
 // ───────────────────────── 关闭 / 清理 ─────────────────────────
 hook.close()
 assert('Esc/关闭后隐藏', panel.style.display === 'none')
@@ -2514,6 +4074,7 @@ for (const dispose of disposers.reverse()) {
   }
 }
 assert('清理后 DOM 归零', mount.children.length === 0 && body.children.indexOf(container) >= 0)
+assert('清理后划词桥自己建的预览 blob 被回收', bridgeOwnedBlob !== '' && !blobStore.has(bridgeOwnedBlob), bridgeOwnedBlob)
 assert('清理后钩子移除', windowStub.__dshSelectionExplain === undefined)
 console.log('\n=== 客户端集成测试结束 ===')