dsh-composer-ease 0.0.0-stage → 0.9.66

package/lib/client/60-keys.js

@@ -0,0 +1,242 @@
+// ── 模块：键位层 ────────────────────────────────
+// onKeyDown（配对、跳过闭符、空对删除、方向键选候选）与两个删除动作。
+// 本文件是 lib/client.js 的片段，由 tools/build-client.mjs 按序拼回；不要直接改生成物 lib/client.js。
+
+    function onKeyDown(ev) {
+      var ed = composerOf(ev.target)
+      if (!ed) { if (popup.open) closePopup(); return }
+      lastComposer = ed
+      if (composing) return    // IME 合成期间不接管任何键（拼音的字母要原样交给输入法）
+ /* 读状态之前，先把**上一键挂起的光标复位**就地落地（幂等：文本不匹配就什么都不做）。
+ * 不这么做，下一键读到的就是旧光标位置 —— 空框打 `"` 得 `""` 之后手快再打 `"`，
+ * 因为光标还没挪到两符中间，第二下会当成字面插入 → `"""`（一次反馈正是这一拍）。 */
+      flushCaretFix()
+      if (window.__dceSyntheticBackspace && ev.key === 'Backspace') return
+      caretEpoch++            // 新按键作废上一键挂起的光标复位（否则旧回调会把光标拨回去）
+      var k = { key: ev.key, code: ev.code, ctrl: ev.ctrlKey || ev.metaKey, shift: ev.shiftKey,
+                __popupOpen: popup.open, __collapsedFalse: !!(ev.target && ev.target === ed && selectedText(ed)),
+                __nextIsCloser: caretChar(ed, +1) === ev.key }
+      dbg('keydown', { ed: ed, key: ev.key, before: textBeforeCaret(ed), composing: composing })
+ // 记下这一键按下时的选区：IME/全角那条路 keydown 拿不到字符，靠 input 事件回头补框选
+      lastSelText = selectedText(ed)
+ // 回车＝发送：先把弹层与灰字收干净，别让它们挂在被清空的输入框上。
+ // （一次反馈——发送就是这条的收尾点）
+      if (ev.key === 'Enter' && !ev.shiftKey && !ev.altKey && !ev.ctrlKey && !ev.metaKey) {
+ /* 无条件 closePopup：即使浮层还没画出来（候选响应还在路上）也要把代数 +1，
+          否则回车之后到达的响应照样会把它画出来 —— 2026-10-21 真机 3081 把 /words 延迟 900ms 后复现到的正是这一格。 */
+        closePopup()
+        return
+      }
+ // 与 dsh-composer-history 共存：它用 Ctrl+R 开反向搜索。插件的候选层开着时先把层收掉，
+ // 避免两个面板叠在一起（插件**不拦**这个键，交给它处理）——纸面对照后补。
+      if (popup.open && (ev.ctrlKey || ev.metaKey) && (ev.key === 'r' || ev.key === 'R')) closePopup()
+ // 片段占位符优先于补全接受：接受片段后 Tab 依次跳到下一个占位符（照 VS Code 的 snippet 行为）。
+ // 非 Tab 的按键清空待跳表 —— 用户一动别的，就不该再跳。
+      if (snippetStops && snippetStops.length) {
+        if (ev.key === 'Tab' && !ev.shiftKey) {
+          ev.preventDefault()
+          var nowAt = caretPos(ed)
+          var nxt = -1
+          for (var si = 0; si < snippetStops.length; si++) {
+            if (snippetStops[si] > nowAt) { nxt = snippetStops[si]; break }
+          }
+          if (nxt >= 0) placeCaretVerified(ed, nxt, textOf(ed))
+          else snippetStops = null
+          return
+        }
+        snippetStops = null
+      }
+ // 左右方向键 / Home / End 是「挪光标改字」，不是要补全：先把弹层收掉，再把键交回编辑器。
+ // 只收这一次 —— 继续打字时 onInput 会重新拉候选，所以改完接着打仍然会提示。
+      if (popup.open && (ev.key === 'ArrowLeft' || ev.key === 'ArrowRight' || ev.key === 'Home' || ev.key === 'End')) {
+        closePopup()
+      }
+ // 弹层优先：上下选必须先于 keyAction —— keyAction 对箭头返回空，放在它后面就永远走不到
+ // （的一次反馈）。
+      if (popup.open && (ev.key === 'ArrowDown' || ev.key === 'ArrowUp')) {
+        ev.preventDefault()
+        popup.index = (popup.index + (ev.key === 'ArrowDown' ? 1 : -1) + popup.items.length) % popup.items.length
+ // 必须 force：renderPopup 的签名只含 items 与语言水印、不含 index，
+ // 非 force 时同一个 sig 会早退 →「按了键但高亮不动」（就是这个）。
+        renderPopup(ed, true)
+        showGhost(ed)          // 行内预览跟着选中项走（VS Code 的 suggest.preview 口径）
+        return
+      }
+      var act = keyAction(k)
+      if (!act) return
+      if (act === 'dismiss') { if (popup.open) { ev.preventDefault(); closePopup() } return }
+      if (act === 'accept' && popup.open) { ev.preventDefault(); acceptCurrent(); return }
+      if (act === 'complete') {
+        ev.preventDefault()
+        lastToken = tokenBefore(textBeforeCaret(ed))
+        fetchCandidates(lastToken, ed)
+        return
+      }
+ // （一次反馈）：原来这里排除了 shift，
+ // 于是 `{` `"` 这类要按 Shift 才打出来的开符、以及中文输入法 Shift+9 的「（」全都不配对。
+ // 配对动作只对开符触发，Shift 不影响判断，放开它。
+      if (act === 'pairopen' && ev.repeat) {
+ // 按住符号键的自动重复：只插一个字符，不再成对（否则越按越多）
+        ev.preventDefault()
+        insertText(ed, ev.key)
+        return
+      }
+      if (act === 'pairopen' && !ev.altKey && !ev.ctrlKey && !ev.metaKey) {
+ // 反选优先：上一次框选范围还在、这次又是同一个引号 → 取消那次框选
+        if (tryUnwrap(ed, ev.key)) { ev.preventDefault(); return }
+        var before = textBeforeCaret(ed)
+        var selTxt = selectedText(ed)
+ // 决策走 decideType：全角换算在这一层完成，下面各分支只按 open/close 落地
+        var d0 = decideType(ev.key, { before: before, after: caretChar(ed, +1), selection: selTxt, fwHalf: fwHalf() })
+        var open = d0.open, close = d0.close
+        fwKeyHandled = !!FW_TO_ASCII[ev.key]
+ // 明明有选区却读不出文本（选区落在 chip / mention 这类非文本节点上）：
+ // 这时候任何插入都会把选区替掉，等于用引号吃掉选中内容 —— 宁可这一下什么都不做。
+        if (!selTxt && k.__collapsedFalse) { ev.preventDefault(); return }
+ // warn 模式：`"你好"` 这种已经框好的，再打同一个引号什么都不做（与 auto 的旧契约一致）
+        if (quoteMode() !== 'auto' && isQuoteChar(open) && alreadyClosedBefore(before, open, close)) {
+          ev.preventDefault(); return
+        }
+ // 空对里再打同一个引号 → 跳过（实测：快速连打时上一键的光标复位还没落地，
+ // 光标可能停在对子后面，于是又补一对变成三个）。按**文本形状**判，不看光标：
+ // 整段就是一个空对，或光标正好夹在空对中间，都算「已经在空对里」。
+        if (close === open && isQuoteChar(open) && quoteMode() === 'auto') {
+ // 仅 auto 模式：连打竞态下光标可能停在对子后面，此时跳过而不是再补一对。
+ // warn 模式不自动补对，连按必须逐个字面插入（）。
+          var tv = textOf(ed), pv = caretPos(ed)
+          var onlyPair = tv === open + close
+          var straddle = pv > 0 && pv < tv.length && tv.charAt(pv - 1) === open && tv.charAt(pv) === close
+          if (onlyPair || straddle) {
+            ev.preventDefault()
+            placeCaretVerified(ed, tv.length, tv)     // 光标移到闭符之后
+            return
+          }
+        }
+        ev.preventDefault()
+        if (selTxt) {
+ // 拦住 Lexical：插件的监听是 capture 阶段，stopPropagation 之后它收不到这次按键，
+ // 就不会"按自己的模型再插一遍"——实测 实测：不拦时 418ms 贴入 `“abc”`、
+ // 423ms 它又插一个 `“`，于是撤销撤掉的是那个多余引号，而不是把原文还回来。
+          try { ev.stopImmediatePropagation && ev.stopImmediatePropagation() } catch (e0) {}
+          try { ev.stopPropagation() } catch (e0b) {}
+ // 已有一个没闭合的开符在前（`"abc` 里选中 abc 再打 `"`）：这是「补闭合」而不是「再框一层」，
+ // 否则会变成 `""abc"`。对称引号才这么做；非对称的（“”）按原来的框选走。
+          if (close === open && isUnbalancedBefore(before, open, close)) {
+            var selEnd = caretOffset(ed) + selTxt.length
+            if (isText(ed)) { ed.selectionStart = ed.selectionEnd = ed.selectionEnd } else setSelectionRange(ed, selEnd, selEnd)
+            insertText(ed, open)
+          } else wrapSelection(ed, open, selTxt, close)
+        }   // 环绕选区（2026-10-16 修：选区还原到内层）
+        else if (caretChar(ed, +1) === close) {
+ // 右边已经是这一对：跳过去，不要套一对（`“”` 中间再打 `“` 会变成一对套一对）
+          var skipTo = caretPos(ed)
+          if (skipTo >= 0) placeCaretVerified(ed, skipTo + 1, textOf(ed))   // 不插字，文本不变
+ // 光标停在一个**已闭合**的闭符之后时不再吞掉这一键（旧实现 preventDefault 了什么都不做）：
+ // 反馈是「其他引号都闭合的情况下，新打的引号没有成对」。现在交给 shouldPair 决定，
+ // 默认 auto 下就是再开一对；要「不堆一个」请切到标红模式或开严格配对。
+        } else if (before.slice(-1) === open
+                   && isUnbalancedBefore(before, open, close)
+                   && textOf(ed).length > before.length) {
+ // 光标紧贴一个未闭合的开符、后面还有正文（`"|你好`）。
+ // **旧实现把闭符 setCaret 到全文末尾** —— 这就是
+ // 「后引号出现在句子后面、不在我要的位置」。改成一律在光标处字面插入：
+ // 用户在哪打就在哪落，闭合与否交给 lintQuotes 标红提示。
+          var atHere = caretPos(ed)
+          insertText(ed, open)
+          if (atHere >= 0) { try { setSelectionRange(ed, atHere + 1, atHere + 1) } catch (e) {} }
+        } else if (close === open && before.slice(-1) === open && quoteCount(before) % 2 === 1) {
+ // 对称引号（" ' `）前面是**还没闭合**的开符：只插一个（这是补闭合，不是再开一层）。
+ // 前面那对已经闭合时走下面 shouldPair，开一对新的。
+ // VS Code 的引号规则；不补这条时连按引号会 2→4→6 成串（的一次反馈）。
+          insertText(ed, open)
+        } else if (isUnbalancedBefore(before, open, close)) {
+ // 更前面还有一个没闭合的开符（`"你好` 末尾再打 `"`、`“文字` 末尾再打 `“`）：
+ // 这一下是在闭合它，不是再开一层 —— 只插一个字符。
+          insertText(ed, open)
+        } else if (shouldPair(before, caretChar(ed, +1), open)) {
+          var basePair = textOf(ed), atPair = caretPos(ed)
+          insertAtomic(ed, open + close)      // 原子插入：避免 Lexical 异步重写选区导致的竞态
+ // 先同步落一次光标：异步观察者赶不上下一次按键（实测快速连打会变 4 个引号）
+          if (atPair >= 0) { try { setSelectionRange(ed, atPair + 1, atPair + 1) } catch (e) {} }
+ // 开符落在 atPair 这一格，光标要落在它后面一格（= 两符之间）。
+ // 等文本真的落地才写（见 placeCaretVerified），expect 用来认出「有没有人插手」
+          placeCaretVerified(ed, atPair + 1,
+            atPair < 0 ? undefined : basePair.slice(0, atPair) + open + close + basePair.slice(atPair),
+            atPair < 0 ? null : afterPairCheck(ed, open, close, atPair))
+          if (atPair >= 0) ensureCaretAt(ed, atPair + 1)   // 编辑器若把光标挪到对子后面，这里按实际偏移纠回来
+        } else {
+          var atLiteral = caretPos(ed)
+          insertText(ed, open)
+ // 光标复位：字面插入后宿主可能把 caret 留在插字之前，导致下一次按键被
+ // 「跳过闭符」判据吃掉（实测连按三下只得两个引号）。
+          if (atLiteral >= 0) { try { setSelectionRange(ed, atLiteral + 1, atLiteral + 1) } catch (e) {} }
+        }
+        return
+      }
+      if (act === 'pairclose') {
+        var expect = CLOSERS[ev.key]
+        if (!selectedText(ed) && caretChar(ed, +1) === ev.key && PAIRS[expect] === ev.key) {
+ // 后面就是应得的闭合符：跳过而不是再插一个（反引号对称，同判据成立）
+          ev.preventDefault()
+          var atClose = caretPos(ed)
+          if (atClose >= 0) placeCaretVerified(ed, atClose + 1, textOf(ed))   // 不插字，文本不变
+          return
+        }
+ // 引号且不该跳过时：必须字面插入，否则这一下被吞掉（实测连按三下只得两个引号）。
+ // 括号不在此列 —— 让浏览器默认插入，别抢。
+        if (isQuoteChar(ev.key)) {
+          var bh = textBeforeCaret(ed)
+          if (alreadyClosedBefore(bh, CLOSERS[ev.key], ev.key)) return   // 已框好：不再堆一个
+          ev.preventDefault()
+          var atLit = caretPos(ed)
+          insertText(ed, ev.key)
+          if (atLit >= 0) { try { setSelectionRange(ed, atLit + 1, atLit + 1) } catch (e) {} }
+        }
+        return
+        return
+      }
+      if (act === 'pairbackspace' && !selectedText(ed)) {
+        var prev = caretChar(ed, -1), next = caretChar(ed, +1)
+        if (PAIRS[prev] === next) { // 光标正好夹在空对里：一次删掉两侧（VSCode 同款）
+          ev.preventDefault()
+ // 两次删除各派发一次 input；全角/中文标点那半边有「开符后自动补闭符」，
+ // 前删后框里只剩一个 `（`，它会立刻补回 `）`，结果就变成只删了一侧
+ // （取证：`（）`→`）`、`“”`→`”`，半角不受影响）。
+          suppressInput += 2
+          deleteForward(ed)
+          deleteBackward(ed)
+        }
+      }
+    }
+    function deleteForward(ed) {
+      try {
+        if (isText(ed)) {
+          var s = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set
+          var i = ed.selectionStart
+          s.call(ed, ed.value.slice(0, i) + ed.value.slice(i + 1))
+          ed.dispatchEvent(new Event('input', { bubbles: true }))
+          return
+        }
+        var off = caretOffset(ed)
+        if (off < 0) return
+        setSelectionRange(ed, off, off + 1)   // 2026-10-16：从 sel.modify 换过来（Lexical 不认后者）
+        document.execCommand('delete')
+      } catch (e) {}
+    }
+    function deleteBackward(ed) {
+      try {
+        if (isText(ed)) {
+          var s = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set
+          var i = ed.selectionStart
+          if (i <= 0) return
+          s.call(ed, ed.value.slice(0, i - 1) + ed.value.slice(i))
+          ed.selectionStart = ed.selectionEnd = i - 1
+          ed.dispatchEvent(new Event('input', { bubbles: true }))
+          return
+        }
+        var off = caretOffset(ed)
+        if (off <= 0) return
+        setSelectionRange(ed, off - 1, off)   // 2026-10-16：同上
+        document.execCommand('delete')
+      } catch (e) {}
+    }

package/lib/client/70-input.js

@@ -0,0 +1,369 @@
+// ── 模块：输入事件层 ────────────────────────────────
+// beforeinput/input 两条路：补闭符、收尾、引号未闭合标红、触发源定义（buildTriggerSources）。
+// 本文件是 lib/client.js 的片段，由 tools/build-client.mjs 按序拼回；不要直接改生成物 lib/client.js。
+
+    function textBeforeCaret(ed) {
+      try {
+        if (isText(ed)) return ed.value.slice(0, ed.selectionStart)
+        var sel = window.getSelection(); if (!sel.rangeCount) return ''
+        var r = sel.getRangeAt(0).cloneRange()
+        var root = composerOf(ed) || document.body
+        r.selectNodeContents(root); r.setEnd(sel.getRangeAt(0).endContainer, sel.getRangeAt(0).endOffset)
+        return r.toString()
+      } catch (e) { return '' }
+    }
+
+ /* 引号未闭合提示：**必须在模块层**声明 —— 之前写在 apply() 里，而 scheduleQuoteLint
+ * 在模块层引用它们，运行时抛 ReferenceError 被 try 吞掉，红线永远不出现（修）。 */
+    var quoteLintTimer = null
+
+ /** 「未闭合引号」计数：**撇号不算**——`let's` / `don't` 里的 ' 与 ’ 被词字符夹着，
+ * 那是英文所有格，不是引号（从没打引号也会冒出标红）。 */
+    function unclosedQuoteCount(text) {
+      var s = String(text || ''), n = 0
+      for (var i = 0; i < s.length; i++) {
+        var c = s.charAt(i)
+        if (!isQuoteChar(c)) continue
+        if (c === '\u0027' || c === '\u2019') {
+          var pv = s.charAt(i - 1), nx = s.charAt(i + 1)
+          if (/[A-Za-z0-9]/.test(pv) && /[A-Za-z0-9]/.test(nx)) continue
+        }
+        n++
+      }
+      return n
+    }
+    function lintQuotes(ed) {
+      if (!ed) return
+      var box = composerOf && composerOf(ed) || ed
+      if (!box || !box.setAttribute) return
+      var t = ''
+      try { t = textOf(ed) || '' } catch (e) { t = '' }
+      var bad = unclosedQuoteCount(t) % 2 === 1
+      paintQuoteWarn(ed, bad ? unmatchedQuoteIndex(t) : -1)   // 只画在那个没闭合的引号底下
+      try {
+        if (bad) {
+          box.setAttribute('data-dce-quote-warn', '1')
+ // 不再挂文字提示（反馈：不需要显示「引号/反引号未闭合」），只留底下那条波浪线。
+          box.setAttribute('data-dce-quote-hint', '')
+        } else {
+ // 置 '0' 而不是删除：CSS 只认 =1，且假 DOM/宿主里 removeAttribute 不一定生效
+          box.setAttribute('data-dce-quote-warn', '0')
+          box.setAttribute('data-dce-quote-hint', '')
+          if (box.removeAttribute) box.removeAttribute('title')
+        }
+      } catch (e) {}
+    }
+
+    function scheduleQuoteLint(target) {
+      if (quoteLintTimer) clearTimeout(quoteLintTimer)
+      quoteLintTimer = setTimeout(function () { try { lintQuotes(target) } catch (e) {} }, 120)
+    }
+ /* 注释行里不提示：行首（允许缩进）是 // # <!-- -- 的那一行，补全没有意义。
+ * 引号里的内容照旧提示 —— 那一侧是字符串，正是要补的地方。 */
+    var COMMENT_LINE = /^\s*(\/\/|#|<!--|--)/
+    function inCommentLine(before) {
+      var s = String(before || '')
+      var i = s.lastIndexOf('\n')
+      return COMMENT_LINE.test(i < 0 ? s : s.slice(i + 1))
+    }
+    function onInput(ev) {
+      try { scheduleQuoteLint(ev && ev.target) } catch (e0) {}   // 引号未闭合标红（不阻断输入）
+ // 三种触发：'/' 与 '@'（引用/模型）、打标识符两个字母起自动弹（VSCode 手感）
+      var ed = composerOf(ev.target)
+      if (!ed) return
+      if (suppressInput > 0) { suppressInput--; return }   // 这是接受候选时自己插的，别再弹
+    dbg('input', { ed: ed, data: ev && ev.data, itype: ev && ev.inputType,
+                   composing: composing || (ev && ev.isComposing), before: textBeforeCaret(ed) })
+      if (composing || (ev && ev.isComposing)) { if (popup.open) closePopup(); return }   // IME 合成中不补全
+ // 粘贴/拖入：先把残留的弹层与灰字收掉，也不为粘贴内容补全（否则灰字会停在旧位置）
+      var itype = ev && ev.inputType ? String(ev.inputType) : ''
+      if (itype.indexOf('Paste') >= 0 || itype.indexOf('Drop') >= 0) { closePopup(); return }
+      lastSelText = ''
+ // 全角/中文成对符走这条：IME 合成的字符不一定带对应 keydown，keydown 那条路抓不到。
+      var b0 = textBeforeCaret(ed)
+      var prev = b0.slice(-1)
+      var want = PAIRS[prev]
+ // `“文字` 末尾再打 `“` 时，上一行插入的是「闭合」而不是「开启」，
+ // 这里若还去补 `”` 就会变成 `“文字“”`（一次反馈）。
+ // 全角括号开关：打开时把输入法刚合成的 （/【 换成半角对子（只在写代码时开）。
+ // FW_TO_ASCII 在 10-foundation 里（模块级）：这里的 var 会遮蔽它，导致 beforeinput 那条路取不到
+      var keyJustHandled = fwKeyHandled
+      fwKeyHandled = false
+      if (fwHalf() && FW_TO_ASCII[prev] && !keyJustHandled) {
+        var asciiOpen = FW_TO_ASCII[prev]
+        var asciiClose = PAIRS[asciiOpen] || ''
+        suppressInput++
+        if (replaceBeforeCaret(ed, 1, asciiOpen + asciiClose)) return
+        suppressInput--
+      }
+      if (want && prev.charCodeAt(0) > 127 && caretChar(ed, +1) !== want
+          && !isUnbalancedBefore(b0.slice(0, -1), prev, want)
+          && shouldPair(b0.slice(0, -1), caretChar(ed, +1), prev)) {
+        suppressInput++                                   // 自己插的闭符别再触发一轮
+        var baseWant = textOf(ed), atWant = caretPos(ed)
+        insertText(ed, want)
+ // 闭符插在开符之后，光标回到两符之间
+        placeCaretVerified(ed, b0.length,
+          atWant < 0 ? undefined : baseWant.slice(0, atWant) + want + baseWant.slice(atWant))
+        return
+      }
+      var before = textBeforeCaret(ed)
+      lastComposer = ed
+// 注释行：整行不提示（引号里的内容仍在引号那条规则之外，照旧提示）
+      if (inCommentLine(before)) { if (popup.open) closePopup(); return }
+      var m = before.match(/(^|\s)([/@])([A-Za-z0-9_.\\/:,-]*)$/)
+      if (m) {
+ // '/' 是 DSH 原生命令入口（dsh-commands：command/run、command/done）：
+ // 插件不插手，免得两份菜单叠在一起、也免得给那条路加延迟（融合而不是抢）。
+        if (m[2] === '/') { if (popup.open) closePopup(); return }
+        lastToken = m[2] + m[3]; fetchCandidates(lastToken, ed); return
+      }
+      var w = before.match(/([A-Za-z_][A-Za-z0-9_]{1,}|[\u4e00-\u9fff]{1,})$/)
+      if (w) {
+        var tok = w[1]
+ // 汉字没有空格分词：整句会被当成一个 token，取最后 4 个字当前缀（够长又不至于永不命中）
+        if (/^[\u4e00-\u9fff]+$/.test(tok)) {
+ // 中文至少要 2 个字才算「完整词义」，单字不提示（）
+          if (tok.length < 2) { if (popup.open) closePopup(); return }
+          if (tok.length > 4) tok = tok.slice(-4)
+        }
+        lastToken = tok
+        fetchCandidates(lastToken, ed)
+        return
+      }
+      if (popup.open) closePopup()
+    }
+ /* 框选 + 打符号（原话「选中然后 shift 加符号框住」）：
+ * keydown 那条路对半角好使；**中文输入法/全角没有可用的 keydown**，所以再挂一条 beforeinput。
+ * 实测取证（demo 3081 + Playwright）把两条老假设推翻了：
+ * ① keydown 里读 DOM **不是**空的 —— 探针实测值 `text='\"你好' caret=3` 都对，影子状态不需要；
+ * ② `preventDefault()` **拦不住 Lexical**：它照自己的模型再插一遍，于是「拦 + 自己插」出双份。
+ * 现存唯一的真空窗是 `input` 事件：空框里首次插入 Lexical 根本不派发它（探针里只有
+ * beforeinput，没有 input），所以「事后靠 onInput 补闭符」在那几场永远不触发。
+ * 于是这条路改成：**判定在 beforeinput 做，落地等原生插完再收尾**（不拦默认、不自己插开符）。 */
+    var pendingFix = null
+    function textOf(ed) { return isText(ed) ? String(ed.value || '') : flatText(ed) }
+ /** 删掉绝对偏移上的那一个字符（原生多插时用）。 */
+    function deleteAt(ed, off) {
+      try {
+        if (isText(ed)) {
+          var next = ed.value.slice(0, off) + ed.value.slice(off + 1)
+          var desc = null
+          try {
+            desc = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')
+          } catch (e0) { desc = null }
+          if (desc && desc.set) desc.set.call(ed, next)   // 受控组件只认原型 setter
+          else ed.value = next                            // 没有描述符的环境直接赋值
+          ed.selectionStart = ed.selectionEnd = off
+          ed.dispatchEvent(new Event('input', { bubbles: true }))
+          return
+        }
+        setSelectionRange(ed, off, off + 1)
+        document.execCommand('delete')
+      } catch (e) {}
+    }
+    function onBeforeInput(ev) {
+      try {
+        var ed = composerOf(ev.target)
+        if (!ed) return
+        flushCaretFix()          // 同上：先让上一键挂起的光标复位落地，再读状态
+        if (suppressInput > 0) return
+        var data = ev && typeof ev.data === 'string' ? ev.data : ''
+    dbg('beforeinput', { ed: ed, data: data, itype: ev && ev.inputType, before: textBeforeCaret(ed), composing: composing })
+        if (data.length !== 1 || !PAIRS[data]) return
+        var open = data, close = PAIRS[open]
+        var selTxt = selectedText(ed)
+        if (selTxt) {
+          ev.preventDefault()      // 文本域认这次取消；真 Lexical 不认（2026-10-20 探针：照样把选区替成那一个字符）
+ // 再断掉传播：宿主那份监听在编辑器根节点上，不拦它就会自己把选区替成那一个字符，
+ // 于是包裹变成「多一个开符」再由 repairWrapDup 删掉 —— 撤回里就多出「三个引号、两个引号」两拍。
+          try { ev.stopImmediatePropagation && ev.stopImmediatePropagation() } catch (e1) {}
+          try { ev.stopPropagation() } catch (e2) {}
+          var bfSel = textBeforeCaret(ed)
+          var selEnd = bfSel.length + selTxt.length
+          if (close === open && isUnbalancedBefore(bfSel, open, close)) {
+ // 前面已有一个没闭合的同一个引号：这一下是补闭合，不是再框一层
+            setCaret(ed, selEnd)
+            insertText(ed, open)
+            return
+          }
+          if (isText(ed)) { wrapSelection(ed, open, selTxt, close); return }
+ // contenteditable：Lexical 会把选区替成那一个开符，框完就多出一个
+ // （实测值：选中 abc 打 “ → `““abc”`）。所以框完之后把多出来的那一个删掉。
+          pendingFix = { ed: ed, open: open, close: close, off: bfSel.length - selTxt.length, selTxt: selTxt, action: 'surround' }
+          wrapSelection(ed, open, selTxt, close)
+          soon(flushBeforeFix)
+          return
+        }
+        var before = textBeforeCaret(ed)
+        var off = before.length
+        var next = caretChar(ed, +1)
+ // 决策与 keydown 同一条：decideType 给出 open/close，这里只负责落地
+        var keyHandled = fwKeyHandled
+        fwKeyHandled = false
+        var d = decideType(open, { before: before, after: next, selection: '', fwHalf: fwHalf() && !keyHandled })
+        if (d.action === 'insert') return      // 让原生插一个，零干预
+        pendingFix = { ed: ed, open: d.open, close: d.close, off: off, len: before.length, action: d.action }
+        soon(flushBeforeFix)
+      } catch (e) {}
+    }
+ /** 原生那一个字符落地之后收尾。**幂等**：实测上 `input` 有时来有时不来，
+ * onInput 那条补闭符的路和这里会撞在一起 —— 谁先到都只补一次（落地后先读有没有闭符）。 */
+    function flushBeforeFix() {
+      var p = pendingFix
+      if (!p) return
+      pendingFix = null
+      try {
+        var ed = p.ed, now = textOf(ed)
+        if (p.action === 'surround') {
+          var ladder = [0, 16, 48, 110, 220], k = 0
+          var tick = function () {
+            try {
+              var nw = textOf(ed)
+              if (nw.slice(p.off, p.off + 2) === p.open + p.open) { suppressInput++; deleteAt(ed, p.off); nw = textOf(ed) }
+              var afterClose = p.off + 1 + p.selTxt.length + 1
+              if (nw.charAt(afterClose - 1) === p.close) { placeCaretVerified(ed, afterClose, nw); return }
+            } catch (e) {}
+            if (++k < ladder.length) { try { setTimeout(tick, ladder[k]) } catch (e) {} }
+          }
+          tick()
+          return
+        }
+        if (p.action === 'convert') {
+          var ladderC = [0, 16, 48, 110, 220, 360], kc = 0
+          var pairTxt = p.open + p.close
+          var tickC = function () {
+            try {
+              var cur = textOf(ed)
+              if (FULL_TO_HALF_OPEN[cur.charAt(p.off)]) {
+                backspaceOnce(ed)
+                setCaret(ed, p.off)
+                suppressInput++
+                insertText(ed, pairTxt)
+                placeCaretVerified(ed, p.off + 1, cur.slice(0, p.off) + pairTxt + cur.slice(p.off + 1))
+                return
+              }
+            } catch (e) {}
+            if (++kc < ladderC.length) { try { setTimeout(tickC, ladderC[kc]) } catch (e) {} }
+          }
+          tickC()
+          return
+        }
+        if (p.action === 'skip') {
+          if (now.length === p.len) { placeCaretVerified(ed, Math.min(p.off + 1, now.length), now); return }
+          if (now.charAt(p.off) !== p.open) return
+          suppressInput++
+          deleteAt(ed, p.off)
+          var afterDel = textOf(ed)
+          placeCaretVerified(ed, Math.min(p.off + 1, afterDel.length), afterDel)
+          return
+        }
+        if (now.charAt(p.off) !== p.open) return
+        if (now.charAt(p.off + 1) === p.close) { placeCaretVerified(ed, p.off + 1, now); return }
+        suppressInput++
+        setCaret(ed, p.off + 1)
+        insertText(ed, p.close)
+        try { setSelectionRange(ed, p.off + 1, p.off + 1) } catch (e) {}
+        placeCaretVerified(ed, p.off + 1, now.slice(0, p.off + 1) + p.close + now.slice(p.off + 1),
+          afterPairCheck(ed, p.open, p.close, p.off))
+        ensureCaretAt(ed, p.off + 1)
+      } catch (e) {}
+    }
+
+    function onCompositionStart(ev) {
+      if (!composerOf(ev.target)) return
+      composing = true
+      caretEpoch++            // 输入法接管：作废我们自己挂起的光标复位，别跟它抢
+      closePopup()            // 连灰字一起收起来（hideGhost 在 closePopup 里）
+    }
+    function onCompositionEnd(ev) {
+      if (!composerOf(ev.target)) return
+      composing = false
+ // 上屏后按新内容重新判一次（中文词补全走这条路）
+      try { onInput({ target: ev.target }) } catch (e) {}
+    }
+
+    function onBlurOut(ev) {
+      var ed = composerOf(ev.relatedTarget)
+      if (!ed && popup.open) closePopup()
+    }
+
+ /* ── 宿主输入触发源（照被录用插件的样子做）─────────────────────────────
+ * dsh-client-ui-commands / -skill / -reference 都是把内容注册进宿主的输入触发菜单，
+ * 位置、上下选、插入与撤销都由宿主负责。插件只提供 candidates 与 onPick，
+ * 不再自己画弹层、也不再跟宿主抢触发字符。 */
+ /* 「严格配对」开关（普通情况不必那么严，需要时可开）。
+ * 存在 localStorage，默认 false；由 '/' 菜单里插件那组的第一条切换。 */
+ // 借宿主的命令表做两件事：① 让本组与「指令」组同一拍落地（宿主那组要等命令目录 RPC，
+ // 原来立即 resolve，菜单先蹦三行再被顶下去）；② 错拼时按它的表补一行。
+ // 取不到（老宿主 / 没这个服务）就照旧立即返回，功能不缺。
+    function hostCommands(ctx, session, req) {
+      var cu = null
+      try { cu = ctx && typeof ctx.get === 'function' ? ctx.get('commandUi') : null } catch (e) { cu = null }
+      if (!cu || typeof cu.candidates !== 'function') return Promise.resolve(null)
+      var full = { query: '', position: (req && req.position) || 'leading', signal: req && req.signal }
+      try {
+        return Promise.resolve(cu.candidates(session, req)).then(function (matched) {
+          return Promise.resolve(cu.candidates(session, full)).then(function (all) {
+            return { matched: matched || [], all: all || [] }
+          })
+        }).catch(function () { return null })
+      } catch (e) { return Promise.resolve(null) }
+    }
+    function buildTriggerSources(ctx) {
+      var fileSource = {
+        trigger: '@',
+        name: '便捷输入框',                 // 分组名：与宿主「文件与文件夹」并列，名字要唯一（重复注册会抛）
+        order: 50,
+        showGroupTitle: true,
+        candidates: function (session, req) {
+          var q = String((req && req.query) || '')
+          return fetchItems(q).then(function (items) {
+            return items.map(function (it) {
+              var v = String(it.value || '')
+              return {
+                name: v,
+                label: triggerBasename(v),
+                description: String(it.detail || ''),
+                hint: it.kind === 'file' ? '文件' : (it.kind === 'model' ? '模型' : ''),
+              }
+            })
+          })
+        },
+        onPick: function (pick) { return { text: String(pick.candidate.name) } },
+      }
+      var slashSource = {
+        trigger: '/',
+        name: '便捷输入框',            // 与宿主的「指令」组并列；同 trigger 下 name 重复会抛
+ // 宿主按 order 升序排：内置「指令」= 1、「技能」= 2。写 20 会被垫到技能下面
+ // （的一次反馈）。开关类要放最上面，一打开菜单就看得到。
+        order: 0,
+        showGroupTitle: true,
+        candidates: function (session, req) {
+          var q = String((req && req.query) || '').trim()
+ // 三行也按 query 过滤：宿主那组因为 query 不命中而消失时，别只剩本插件这组还赖在菜单里
+          var rows = settingsRows().filter(function (r) {
+            if (!q) return true
+            return looseScore(q, r.name) >= 0 || looseScore(q, r.label || '') >= 0
+          })
+          return hostCommands(ctx, session, req).then(function (host) {
+            var leading = !req || req.position !== 'inline'
+            return rows.concat(rescueRows(q, host, leading))
+          })
+        },
+        onPick: function (pick) {
+          var cand = (pick && pick.candidate) || {}
+ // 错拼兜底行：补成真命令名再交给宿主，插件自己不解命令
+          if (cand.rescue) return { text: '/' + String(cand.rescue) + ' ' }
+          if (String(pick.candidate.name) === '引号模式') setQuoteMode(quoteMode() === 'auto' ? 'warn' : 'auto')
+          if (String(pick.candidate.name) === '重置插件设置') resetSettings()
+          if (String(pick.candidate.name) === '全角括号') setFwHalf(!fwHalf())
+          if (String(pick.candidate.name) === '严格配对') setPairStrict(!pairStrict())
+          var pickName = String(pick.candidate.name)
+          if (pickName === '候选类型') cycleKindPreset()
+          return { text: '' }        // 清掉输入框里的 '/'，不插入任何文字
+        },
+      }
+      return [fileSource, slashSource]
+    }
+