dsh-edit-turn 0.2.8 → 0.2.10

package/README.md

@@ -205,7 +205,8 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
    记录里有 `state` 且 `replies` 大于 0 → 数据到了客户端，问题在渲染；**一条记录都没有** → 客户端半部没跑起来（看浏览器控制台）。
 
-4. **「历史加载失败 / 某个会话读不出来」**（`session-not-found`，控制台里出现 `SessionFormatError`）：这可能是 0.2.0–0.2.3 的回复编辑留下的坏日志。用仓库里的修复工具扫描并用官方加载器验证、备份后截断：
+4. **「某个会话里完全看不到编辑入口，控制台里 `/dsh-edit-turn/state` 返回 404」**：这个会话**正被另一个 DSH 实例使用**（例如桌面版开着它，网页版就读不到；反之亦然）。同一会话同一时间只能被一个实例持有，这是宿主的行为，不是插件的问题——在那个实例里用，或先在另一个实例里放开它。`verify:ui` 遇到这种情况会注记并跳过该项，不会误报。
+5. **「历史加载失败 / 某个会话读不出来」**（`session-not-found`，控制台里出现 `SessionFormatError`）：这可能是 0.2.0–0.2.3 的回复编辑留下的坏日志。用仓库里的修复工具扫描并用官方加载器验证、备份后截断：
 
    ```sh
    node tools/repair-session.mjs ~/.dsh/sessions/<项目目录> --dry-run
@@ -218,6 +219,18 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.2.10** —— 修「编辑器浮层留在设置页上」。
+
+- **修复：会话视图卸载后编辑器没有跟着走**。编辑器挂在 `body` 的独立浮层上（这是为了躲开宿主重绘），而没有任何框架会替它收尾：切到设置页时对话视图（连同注册在输入框卡上的条目）卸载了，编辑器却留在浮层里**飘在设置页上**。现在条目卸载时清掉自己的编辑器与参考，空浮层也一并移除。
+- 卸载判定不能"一有 cleanup 就清"：这个 effect 在每次视图变化时都会先 cleanup 再重跑，硬清会把编辑器反复拆掉（焦点/草稿语义都会乱）。现在是**延迟清理**——下一次 effect 重跑会取消它，只有真正的卸载（不再重跑）才让它落地。
+- 新增用例「会话视图卸载后编辑器跟着消失（浮层也不留）」+ 2 条静态检查；110 单测 / 80 契约 / 静态 / verify:live / verify:ui 全绿。
+
+**0.2.9** —— 修「同一条消息出现两个一样的气泡」。
+
+- **修复：一行两个替代气泡，两个来源都堵掉**。①气泡此前只认「行的直系子节点 / 紧邻前一个兄弟」，一旦被宿主挪开就认不出，下一趟又种一个；现在气泡带**行的 key 标记**（`data-dshet-revision-for`），挪到哪都找得回来，且每行只允许一个（多余的按标记清除）。②更隐蔽的一个：MutationObserver 的回调可能**晚于它所属的那次渲染**，带着**过期视图**（`hidden` 为空）跑一遍，把已折叠的行重新展开——原气泡就回到了替代气泡旁边；现在这趟 pass 从 `controller.getSnapshot()` 现取当前视图，过期视图再也不可能把行展开。
+- 测试桩补上真实 DOM 语义（`appendChild`/`insertBefore` 会先把节点从旧父节点摘除）——正是这条语义缺失让"同一个对象同时挂两处"在桩里被当成正常，掩盖了第一类问题。
+- 新增用例「被挪走的替代气泡会被复用而不是再种一个」+ 3 条静态检查；109 单测 / 80 契约 / 静态 / verify:live / verify:ui 全绿。
+
 **0.2.8** —— 安装元数据：peer 接受 DSH `0.2.0`。
 
 - **修复：在 DSH 0.2.0 上会被 peer 检查拒装**。此前 peer 范围只列到 `^0.1.5-alpha.1`，`0.2.0` 不在其中；现在两个 peer（`@deepseek-ai/dsh-settings`、`@deepseek-ai/dsh-tools`）都追加 `|| ^0.2.0-rc.1`（`^0.2.0-rc.1` 同时覆盖 `0.2.0` 与后续 `0.2.x`）。**纯安装元数据，运行时代码零变化**；`npm run verify:profile`（真实 profile 安装 + 启动 + 路由）全绿。
@@ -712,7 +725,8 @@ Separate "the plugin never loaded" from "it loaded but nothing rendered" - the t
    ```
 
    Mind the two kinds of dependency: **peers** provided by the host (`dsh-tools`, `dsh-settings`) are resolved by the DSH loader and need no install; **regular dependencies** (like `schemastery`) must resolve on their own - the loader will not find them for you.
-3. **"The history fails to load / one session is unreadable"** (`session-not-found`,
+3. **"One session shows no edit entries at all while `/dsh-edit-turn/state` answers 404 in its console"**: that session is being **held by another DSH instance** (the desktop app has it open, or vice versa). A session can only belong to one instance at a time - host behaviour, not a plugin problem. Use it from that instance, or release it in the other one first. `verify:ui` notes and skips this case instead of failing.
+4. **"The history fails to load / one session is unreadable"** (`session-not-found`,
 with `SessionFormatError` in the console): this can be a log broken by the reply
 edits of 0.2.0-0.2.3. The repository ships a repair tool that scans a sessions
 directory, validates every log through the official loader, and - after a

package/lib/client.js

@@ -30,7 +30,7 @@ window.__ModuleLoader__.load({
     const ROUTE_PREFIX = '/dsh-edit-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.2.8'
+    const PLUGIN_VERSION = '0.2.10'
 
     // --- copy -----------------------------------------------------------------
 
@@ -264,6 +264,7 @@ window.__ModuleLoader__.load({
         this.editorRow = null
         this.editorFocus = false
         this.editorDraft = ''
+        this.clearTimer = null
         this.confirming = false
         this.noticeTimer = null
         this.view = Object.freeze({
@@ -548,6 +549,9 @@ window.__ModuleLoader__.load({
       }
 
       dispose() {
+        if (this.clearTimer !== null) window.clearTimeout(this.clearTimer)
+        this.clearTimer = null
+        clearEditor()
         this.listeners.clear()
         if (this.noticeTimer !== null) window.clearTimeout(this.noticeTimer)
         this.noticeTimer = null
@@ -667,14 +671,33 @@ window.__ModuleLoader__.load({
         if (existing !== null) existing.remove()
         return true
       }
+      // Only one bubble per row, ever: drop any other bubble that claims it
+      // (the host can shunt a bubble away from where it was planted, and the
+      // next pass used to plant a second one next to the stray).
+      {
+        const key = row.getAttribute('data-chat-flow-key')
+        if (typeof key === 'string' && key !== '') {
+          for (const candidate of document.querySelectorAll('.dshet-revision')) {
+            if (candidate !== existing && candidate.dataset !== undefined && candidate.dataset[REVISION_FOR] === key) {
+              candidate.remove()
+            }
+          }
+        }
+      }
       const entry = view.editable.get(headRevision(view.revisions.get(revisionSeq), view.revisions))
       const text = entry && typeof entry.text === 'string' ? entry.text : ''
       if (text === '') {
         if (existing !== null) existing.remove()
         return node.kind !== 'user'
       }
-      const bubble = existing === null ? cloneUserBubble() : existing
+      const bubble = existing === null ? cloneUserBubble(row) : existing
       if (existing === null) bubble.dataset.dshetRevision = '1'
+      {
+        const key = row.getAttribute('data-chat-flow-key')
+        if (typeof key === 'string' && key !== '' && bubble.dataset[REVISION_FOR] !== key) {
+          bubble.dataset[REVISION_FOR] = key
+        }
+      }
       placeRevisionBubble(row, bubble)
       if (bubble.textContent !== text) bubble.textContent = text
       // The edit entry goes where every other action of this row lives: the
@@ -703,11 +726,19 @@ window.__ModuleLoader__.load({
     }
 
     // A copy of a live user bubble element, classes and all.
-    function cloneUserBubble() {
-      const sampleRow = document.querySelector('[data-chat-flow-kind="user"]')
-      const sample = sampleRow === null ? null : sampleRow.firstElementChild
+    // The key of the row a bubble stands in for. It is what makes a stray
+    // bubble recognisable after the host's DOM has shifted around it: an
+    // unlabelled bubble that is no longer the row's direct child or its
+    // immediate previous sibling used to be forgotten, and the next pass
+    // planted a second one - two identical bubbles on screen.
+    const REVISION_FOR = 'dshetRevisionFor'
+    function cloneUserBubble(row) {
       const bubble = document.createElement('div')
       bubble.className = 'dshet-revision'
+      if (row !== null && row !== undefined) {
+        const key = row.getAttribute('data-chat-flow-key')
+        if (typeof key === 'string' && key !== '') bubble.dataset[REVISION_FOR] = key
+      }
       return bubble
     }
 
@@ -725,6 +756,15 @@ window.__ModuleLoader__.load({
       if (previous !== null && previous.classList && previous.classList.contains('dshet-revision')) {
         return previous
       }
+      // Anywhere else the host may have shunted it: the bubble carries the row
+      // key, so it is found again instead of duplicated. Filtered in place
+      // rather than with an attribute selector, which keeps the stubs honest.
+      const key = row.getAttribute('data-chat-flow-key')
+      if (typeof key === 'string' && key !== '') {
+        for (const bubble of document.querySelectorAll('.dshet-revision')) {
+          if (bubble.dataset !== undefined && bubble.dataset[REVISION_FOR] === key) return bubble
+        }
+      }
       return null
     }
 
@@ -967,6 +1007,12 @@ window.__ModuleLoader__.load({
     function clearEditor() {
       const elements = document.querySelectorAll('.dshet-editor')
       for (const element of elements) element.remove()
+      // An empty layer has no business staying on the page: the editor is
+      // hosted on the body, where nothing else clears up after it.
+      if (editorLayer !== null && editorLayer.isConnected === true && editorLayer.children.length === 0) {
+        editorLayer.remove()
+        editorLayer = null
+      }
     }
 
     // The layer the editor is hosted on. It is created once, hangs off the
@@ -1416,7 +1462,11 @@ window.__ModuleLoader__.load({
         let scheduled = false
         const run = () => {
           scheduled = false
-          applyDom(snapshot, view, controller, t)
+          // Always the CURRENT view: this callback can outlive the render that
+          // created it, and a pass carrying an older view un-hid a collapsed
+          // row - the original bubble reappeared beside the revision bubble.
+          const live = typeof controller.getSnapshot === 'function' ? controller.getSnapshot() : view
+          applyDom(snapshot, live, controller, t)
         }
         run()
         const observer = new MutationObserver(() => {
@@ -1426,8 +1476,25 @@ window.__ModuleLoader__.load({
           else window.setTimeout(run, 16)
         })
         observer.observe(document.body, { childList: true, subtree: true })
+        // This effect re-runs whenever the view changes, and its cleanup runs
+        // first every time; only a REAL unmount means the conversation view
+        // went away (switching to Settings, say) and the editor has to go with
+        // it - left behind, it floated over whatever came next. So the clear is
+        // deferred, and the next run of this effect cancels it.
+        if (controller.clearTimer !== null) {
+          window.clearTimeout(controller.clearTimer)
+          controller.clearTimer = null
+        }
         return () => {
           observer.disconnect()
+          if (controller.clearTimer !== null) window.clearTimeout(controller.clearTimer)
+          controller.clearTimer = window.setTimeout(() => {
+            controller.clearTimer = null
+            clearEditor()
+            controller.editorBox = null
+            controller.editorRow = null
+            controller.editorElement = null
+          }, 250)
         }
       }, [snapshot, view, controller, t])
 

package/lib/index.js

@@ -22,7 +22,7 @@
 //      admission path. It resumes the Session when cold and starts exactly one
 //      new turn from the revised text.
 //
-// The silent replacement carrier is an EMPTY `developer/message` (0.2.8;
+// The silent replacement carrier is an EMPTY `developer/message` (0.2.10;
 // before that an empty `system/message`, which no reader accepts - see the
 // README). Empty content projects to no model message, so the rollback adds
 // nothing the model can see and the derived context after an edit is exactly
@@ -60,7 +60,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.2.8'
+export const PLUGIN_VERSION = '0.2.10'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Edit any user turn in DeepSeek Harness and re-run it: an inline editor on the message row rolls the conversation back to just before that turn through the official surface-replace contract, then re-prompts the agent with the revised text. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",