dsh-rich-msg 0.1.0 → 0.1.1

package/README.md

@@ -1,255 +1,24 @@
 # dsh-rich-msg
 
-一个独立、无模型行为倾向的 **DSH 富内容消息渲染引擎**（Rich Message Renderer）。
+DeepSeek Harness（DSH）的富内容消息渲染插件：把声明式 JSON 渲染成跟随宿主主题、可交互的消息内容。
 
-它把结构化 JSON 协议渲染成美观、可交互、跟随宿主主题的消息内容，并提供两条互不耦合的输出通道：
+## 功能
 
-| 通道 | 数据来源 | 最终展示位置 |
-|---|---|---|
-| **A. Markdown Fence** | 最终 Assistant 回答正文中的 ```rich-msg 代码围栏 | 原位替换该代码块 |
-| **B. Tool Bridge** | 工具调用 `rich_msg_publish` 暂存的结构化内容 + 最终回答中的 `ref` 引用 | 最终回答中引用所在的位置 |
+- **双输出通道**：Markdown fence（```rich-msg，兼容上游 `rich-ui`）与 Tool Bridge（`rich_msg_publish` 暂存 + 最终回答 `ref` 引用）；两条通道共用同一渲染器。
+- **只渲染最终回答**：推理过程、工具调用阶段、中间步骤中的内容不渲染；工具暂存内容只有被最终回答明确引用后才显示。
+- **组件**：布局（stack/row/grid/card/carousel/divider/meta）、文本与 callout/code、实体列表与详情、图库与图片灯箱、卡片指标/进度/状态/表格（排序筛选）/图表（bar/line/area/donut/scatter）、流程 diagram、分层 layers、图片/视频/音频、popover/tooltip、输入/选择/滑块/开关/复选/单选/分段/tabs、条件渲染与安全表达式。
+- **交互**：本地 set/toggle/reset、复制、打开链接、发消息回传；控件状态按会话持久化。
+- **主题**：颜色/字体/圆角/阴影取自 DSH 主题变量，支持浅色、深色与 390px 移动端。
+- **安全**：严格 Schema 校验、无 HTML/JS 执行、无 eval、URL 白名单、大小/深度/数量上限、会话隔离；交互只由用户触发。
+- **模型中立**：不注入 system prompt、persona 或 skill，不规定模型何时/如何使用富内容。
+- **工具**：`rich_msg_validate`（Schema 校验）、`rich_msg_publish`（校验并存入会话 Artifact，返回引用 id）。
 
-两条通道共用同一套 Schema、校验器、React Renderer 与主题适配层。
+## 许可证
 
-本项目是**纯技术渲染层**：它不注入 system prompt / developer prompt / persona / skill，不规定模型何时使用富内容，也不改变模型回答风格。是否使用、何时使用、如何组织内容，完全由使用者自己的 Persona、Prompt 或上层应用决定。
+MIT。
 
----
+本项目基于 [kyoukisu/dsh-rich-ui](https://github.com/kyoukisu/dsh-rich-ui)（MIT，Copyright (c) 2026 kyoukisu）的源码进行独立开发与重构，上游版权声明保留在 [LICENSE](LICENSE)；与上游作者无隶属、合作或背书关系。
 
-## 设计目标
+图标来自 [lucide](https://lucide.dev)（ISC）。
 
-1. **协议先行**：先定义并校验数据结构，再渲染；非法数据永不执行、永不修补。
-2. **双通道、单渲染器**：Fence 与 Tool 两种入口最终都落到同一个 `RichResponse`。
-3. **只渲染最终回答**：推理过程、工具调用阶段、中间步骤中的内容不会被当成最终 UI 展示。
-4. **宿主优先的视觉**：组件保留自己的布局语言，颜色、字体、背景、边框、圆角、阴影全部取自 DSH 主题变量；明暗主题与移动端开箱即用。
-5. **安全默认**：声明式 JSON、无 HTML/JS 执行、无 eval、URL 白名单、Action 白名单、大小/深度/数量限制、Session 隔离。
-6. **可卸载、可重挂载**：所有 React root、样式、监听器、路由、缓存都有明确的生命周期。
-
-## 它不负责什么
-
-- 不决定模型应该如何思考、回答、教学或组织内容。
-- 不注册任何 prompt 段落、Persona、Skill 或 Agent 预设。
-- 不通过工具描述夹带 UI 使用策略。
-- 不替使用者选择模型、语气或教学策略。
-
----
-
-## 架构
-
-```
-dsh-rich-msg
-├── Host Integration（Node / Cordis 插件）
-│   ├── lib/index.js         插件入口：注册工具、装配 Artifact Store、可选 HTTP 读取路由
-│   ├── Artifact Store       会话作用域、带 TTL / 容量上限 / 淘汰策略的内存存储
-│   └── Final Message Bridge 由「工具暂存 + 最终回答引用」构成的两段式桥接
-│
-├── Protocol（框架无关）
-│   ├── core/schema.ts       RichSpec v1 定义与严格校验
-│   ├── core/evaluator.ts    安全表达式求值（无 eval）
-│   ├── core/partial.ts      流式前缀解析（只呈现已闭合且合法的部分）
-│   └── shared/protocol.ts   Fence 语言、ref 协议、Action 信封、DOM 标记、上限
-│
-├── Renderer（React）
-│   ├── ui/RichResponse.tsx  节点调度、交互状态、持久化
-│   ├── ui/blocks/*          Chart / Table / Metrics / Media / Layers / Code / Field
-│   ├── ui/EntityList.tsx    实体列表与详情
-│   └── ui/primitives/*      Popover / Tooltip / Lightbox / Gallery 等基础件
-│
-├── Client Integration（浏览器）
-│   ├── client/dom-renderer.tsx  Fence 发现、最终消息判定、挂载/回滚
-│   ├── client/chat-view.ts     读取 Chat Snapshot：最终性、推理排除、Artifact 索引
-│   ├── client/artifact-resolver.ts  ref 解析（会话日志优先，HTTP 路由兜底）
-│   ├── client/actions.ts        交互事件 → 用户消息
-│   └── client/entity-tab.tsx    可选：右侧栏实体详情页
-│
-├── Theme
-│   └── client/host-theme.css    DSH 主题变量 → 组件 token（明/暗/移动端）
-│
-└── Tests / scripts
-```
-
-详细设计见 [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)。
-
----
-
-## 两条输出通道
-
-### A. Markdown Fence
-
-最终 Assistant 回答中：
-
-````markdown
-```rich-msg
-{"version":1,"nodes":[{"type":"text","content":"Hello"},{"type":"stat","label":"Score","value":42}]}
-```
-````
-
-渲染器会：
-
-1. 只处理 **最终回答** 的 `assistant-step` 行，并用 Chat Snapshot 校验：该步骤是整轮对话的收尾回答，且其后没有工具调用；
-2. 通过 Snapshot 中该步骤的内容块区分 **正文** 与 **推理**：推理块中的围栏永不渲染；
-3. 校验 JSON；非法内容保持原生代码块（流式中）或显示诊断卡片（已稳定）；
-4. 在原位置挂载独立的 React root 并隐藏源码块，卸载时完整还原。
-
-`rich-ui` 作为上游兼容别名同样被接受。普通代码块、其他语言、工具行内容完全不受影响。
-
-### B. Tool Bridge
-
-工具调用负责**准备**内容，最终回答负责**决定是否呈现**：
-
-```
-模型调用 rich_msg_publish({document})
-   → Host 校验、存入会话作用域 Artifact Store
-   → 返回 {ok:true, id:"rm_…", kind, summary}
-模型在最终回答中写：
-```rich-msg
-{"version":1,"ref":"rm_…"}
-```
-   → 浏览器从会话日志中的工具调用还原文档（主路径）
-   → 或读取 Host 的只读路由（兜底）
-   → 在最终回答的引用位置渲染
-```
-
-如果最终回答没有引用该 id，内容不会被显示；工具阶段本身不渲染任何富内容。
-
-详细数据流与验证方法见 [docs/TOOL-BRIDGE.md](docs/TOOL-BRIDGE.md)。
-
----
-
-## 支持的能力
-
-组件与字段的完整清单见 [docs/COMPONENTS.md](docs/COMPONENTS.md)，数据协议见 [docs/PROTOCOL.md](docs/PROTOCOL.md)。
-
-- **布局**：`stack` / `row` / `grid` / `card` / `carousel` / `divider` / `meta`
-- **文本**：`text`（行内 code/bold/链接/实体 chip）、`callout`、`code`
-- **对象**：`entity-list` / `entity-ref` / 实体详情面板 / 图库 / 图片灯箱 / `image` / `image-group` / `gallery`
-- **数据**：`stat` / `progress` / `status` / `table`（排序、筛选、状态色、进度列）/ `chart`（bar/line/area/donut/scatter）/ `computed`
-- **流程**：`diagram` / `layers`
-- **媒体**：`image` / `video` / `audio` / `popover` / `tooltip`
-- **控件**：`input` / `select` / `slider` / `switch` / `checkbox` / `radio` / `segmented` / `tabs`
-- **逻辑**：`expression` / `conditional` / 本地 Action（set/toggle/reset/open-entity/close-entity/copy/open-url/send-message）
-
-## 工具接口
-
-| 工具 | 输入 | 输出 | 说明 |
-|---|---|---|---|
-| `rich_msg_validate` | `{document: string}` | `{valid, error?, title?, nodes?, entities?}` | 只做 Schema 校验，无副作用 |
-| `rich_msg_publish` | `{document: string}` | `{ok, id?, kind?, summary?, error?}` | 校验并存入当前会话的 Artifact Store，返回稳定引用 id |
-
-工具描述只说明输入、输出与副作用，不包含任何"何时应该使用"的行为指导。
-
-## 安装
-
-### 方式一：本地 link（开发）
-
-```powershell
-# 1) 构建
-node scripts/build.mjs
-
-# 2) 在 %USERPROFILE%.dshprofiles<name>package.json 中声明（示例）
-#    {
-#      "name": "dsh-profile-richmsg",
-#      "private": true,
-#      "dependencies": { "dsh-rich-msg": "link:E:/path/to/dsh-rich-msg" },
-#      "dsh": { "profile": { "bundles": ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app", "dsh-rich-msg"] } }
-#    }
-#    并在该 profile 的 node_modules 下建立指向本目录的 junction/symlink。
-
-# 3) 启动该 profile
-node <dsh>/lib/bin.js --profile <name> --host 127.0.0.1 --port 58470 --no-open
-```
-
-### 方式二：作为依赖安装
-
-把本包发布/复制到可解析的位置后，在 profile 的 `package.json` 中：
-
-```json
-{
-  "dependencies": { "dsh-rich-msg": "link:E:/path/to/dsh-rich-msg" },
-  "dsh": { "profile": { "bundles": ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app", "dsh-rich-msg"] } }
-}
-```
-
-```powershell
-dsh plugin --profile <profile> add link:E:/path/to/dsh-rich-msg
-# 并把 "dsh-rich-msg" 加入 dsh.profile.bundles
-```
-
-> 新增/替换包后需要重启宿主进程；客户端资源会按 boot revision 重新生成。
-
-## 主题
-
-- 全部颜色/字体/圆角/阴影来自 DSH 的 `--dsw-*` 令牌；
-- 同时支持浅色与深色主题（跟随 `data-ds-dark-theme` 与上游 `data-theme="dark"`）；
-- 组件不覆盖宿主消息气泡、侧边栏或其它插件的布局；
-- 移动端 390px 宽度下保持可读。
-
-详见 [docs/THEME.md](docs/THEME.md)。
-
-## 安全
-
-- 只接受声明式 JSON；
-- 拒绝 `__proto__` / `constructor` / `prototype` 键，防原型污染；
-- 文档大小、嵌套深度、数组长度、组件数量、字符串长度全部有上限；
-- URL 仅允许 http(s)，禁止内嵌凭据与危险协议；
-- Action 事件白名单校验；交互只由用户触发；
-- 富内容不能直接调用任意 DSH 工具；
-- Artifact 按 Session 隔离，跨 Session 查询与不存在等价；
-- 日志不写入文档内容或表单值。
-
-详见 [docs/SECURITY.md](docs/SECURITY.md)。
-
-## 兼容性与已验证范围
-
-- 目标宿主：`@deepseek-ai/dsh@0.2.2-alpha.2`（本机 `E:\tools\dsh-cli`）。
-- Fence 发现依赖宿主 DOM 标记（`data-chat-flow-kind`、`data-code-block-content` 等）。宿主升级后需重新验证；标记变化时渲染器**失败关闭**（保留原生代码块）。
-- 最终消息判定依赖 Chat Snapshot（`uiConversation`）。该服务不可用时退化为保守的 DOM 规则（仅已稳定的 assistant 行，且不预览流式内容），并在文档中明确记录这一降级。
-- **已验证**：13 个测试文件 / 210 项单元与集成测试通过；`tsc --noEmit` 0 错误；隔离 profile 下真实 DSH 宿主加载与 DOM 冒烟验证通过（插件加载、模块分发、Fence 渲染、普通代码/工具行/流式行不接管、卸载还原、零控制台错误、浅色/深色/390px 截图）。
-- **未验证（待人工）**：真实模型对话下的 Fence 通道与 Tool Bridge 引用渲染。自动化 CDP 发送消息未打通，已按交付要求停止；请按 [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) 第 5.3 节清单在真实 DSH 中人工验证。
-
-## 上游项目与许可证
-
-- 本项目基于 **kyoukisu/dsh-rich-ui**（MIT）的源码进行独立开发与重构：保留了其成熟的 RichSpec Schema、表达式求值器、React 组件与视觉实现，重写了宿主集成、消息判定、工具桥接、主题桥接与文档，并移除了运行时 Prompt 注入。
-- 上游版权声明保留在 [LICENSE](LICENSE)（MIT, Copyright (c) 2026 kyoukisu）。
-- 图标来自 [lucide-react](https://lucide.dev)（ISC），详见 [docs/THIRD-PARTY.md](docs/THIRD-PARTY.md)。
-- 本项目与上游作者无隶属、合作或背书关系；名称 `dsh-rich-msg` 用于区分衍生项目。
-
-## 变更报告
-
-| 模块 | 上游原有能力 | 本次修改 | 修改原因 |
-|---|---|---|---|
-| Prompt | 通过 `inject: ["systemPrompt"]` 注册 `rich-ui:fence` 段落，构建行为指令并注入每次请求 | **完全移除**运行时注入；删除 `prompt-rich-ui/` 运行时文件；技术内容改为离线文档 | 保持模型行为中立 |
-| Validator | `rich_ui_validate` 工具，描述含"默认使用/优先"等行为指导 | 保留校验能力，改名为 `rich_msg_validate`，描述仅含参数、返回与副作用 | 工具 API 保持纯技术性 |
-| Tool | 仅校验，无状态 | 新增 `rich_msg_publish` + 会话作用域 Artifact Store + 只读读取路由 | 支持 Tool 输出通道 |
-| Fence | DOM MutationObserver 扫描 `rich-ui` 围栏，仅以 assistant-step 祖先判定 | 保留扫描技术；新增 Chat Snapshot 最终性判定、推理排除、流式回撤、引用解析、稳定重挂载 | 只渲染最终回答，不误渲染推理/工具阶段 |
-| Renderer | RichSpec React 组件体系 | 复用全部组件；命名空间改为 `dsh-rich-msg`；保留既有可访问性修复 | 降低改造成本 |
-| Theme | 自带配色 + 部分 DSH token 桥接 | 新增完整桥接层（明/暗/移动端），统一映射 `--dsw-*` | Hybrid 视觉要求 |
-| Actions | `[rich-ui-action]` 用户消息 | 改为 `[rich-msg-action]`，保留白名单、大小上限、会话捕获 | 品牌统一与安全 |
-| Build | Vite + tsc + 独立 demo | esbuild 双产物（Host ESM / Client ModuleLoader bundle），无需 Vite 运行时 | 简化构建、与宿主加载协议对齐 |
-| Tests | vitest 单测 + Playwright 截图 | 保留并扩充为 13 文件 / 210 项单测与集成测试；新增真实宿主 DOM 冒烟脚本；真实模型 E2E 改为人工验证 | 可复现、不虚构验证 |
-| Docs | 上游内部文档 + 运行时 prompt 文件 | 重写为 7 份技术文档，且明确不得成为运行时 prompt | 交付要求 |
-
-完整说明见 [docs/CHANGES.md](docs/CHANGES.md)。
-
-## 开发
-
-```powershell
-node scripts/build.mjs               # 构建 lib/index.js 与 lib/client.js
-npx tsc --noEmit                     # 类型检查
-npx vitest run                       # 单元 + 集成测试
-node scripts/package.mjs             # 打包 dist/*.zip + sha256
-```
-
-详见 [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md)。
-
-## 目录
-
-```
-src/core        协议与求值
-src/host        Node 插件：工具、Artifact Store、读取路由
-src/client      浏览器插件：Fence 渲染、消息判定、引用解析、交互回传
-src/ui          React Renderer 与样式
-src/shared      双端共享协议常量
-tests           单元与集成测试
-scripts         构建与真实宿主验证脚本
-docs            技术文档
-```
+技术文档见 `docs/`。

package/docs/ARCHITECTURE.md

@@ -88,15 +88,23 @@
  └─ 通过 → 校验/挂载；任一环节失败 → 保留宿主原生代码块
 ```
 
-**关键点**：`assistant-step` 在 DSH 中既包含推理过程，也包含工具调用前后的中间叙述，所以"祖先匹配"不能证明它是最终回答。Snapshot 判定解决了这一点，并且当模型在后续步骤调用工具时，已挂载的流式预览会被**自动回撤**（恢复到原生代码块）。
+**关键点**：`assistant-step` 在 DSH 中既包含推理过程，也包含工具调用前后的中间叙述，所以"祖先匹配"不能证明它是最终回答。Snapshot 判定解决了这一点。
+
+**调度策略（0.1.1 起）**：完全事件驱动。
+
+- 触发器只有三个：宿主 DOM 的 `MutationObserver` 批次、Chat Snapshot 订阅、`visibilitychange`；
+- 同一事件循环内的多次触发合并到一个微任务，**没有定时器、没有轮询、没有 rAF 循环**；
+- 每次只评估事件命中的行；行签名未变时零解析、零重绘；
+- **默认只在行已稳定后渲染**（不渲染流式预览）。回答完成前的围栏保持宿主原生代码块，避免每个 token 重建 React 树；
+- 渲染异常由 `RenderBoundary` 捕获：隐藏容器、恢复源码块，不重试同一失败树。
 
 ### 4.3 挂载与重挂载
 
 - 每个源码块对应一个独立 `createRoot` 容器，容器插在源码块之后并设置 `hidden` 隐藏源块；
-- 复用条件：raw 文本、会话、streaming 状态、行 owner、模式（spec/ref/diagnostic）全部一致，避免每个 token 重建整棵树；
-- 宿主 reconcillation 可能移动节点：每次扫描校验 `source.nextSibling === container`，需要时重新插入；
-- 渲染异常由 `RenderBoundary` 捕获：隐藏容器、恢复源码块，不产生无限重试；
-- 卸载：逐个 unmount、移除容器、恢复 `source.hidden`。
+- 同一围栏内容变化时**原地更新**（复用 root、按渲染 key 去重），不销毁重建；
+- 宿主 reconciler 可能移除外来节点：校验 `source.nextSibling === container` 并按需重插，**最多 3 次**；超限则放弃该行并恢复原生代码块，避免插入/删除拉锯；
+- **每个 document scope 只允许一个渲染器实例**（HMR/重复安装会替换旧实例，而不是双挂载）；
+- 卸载：逐个 unmount、移除容器、恢复 `source.hidden`、断开观察者与订阅。
 
 ### 4.4 持久化
 

package/docs/CHANGES.md

@@ -2,6 +2,27 @@
 
 相对上游 `kyoukisu/dsh-rich-ui@0.6.2` 的完整变更报告。
 
+## 0.1.1（稳定性修复）
+
+0.1.0 在长会话中会出现页面无响应（"此页面没有响应"）。根因是渲染调度而非数据协议：
+
+1. 流式期间每来一个 token 就销毁并重建一个 React root；
+2. 每次 DOM 变更全量扫描整个页面，长会话 / 长历史下开销失控；
+3. 复用分支把已渲染容器反向设为 `hidden`，与宿主 reconciler 反复拉扯。
+
+0.1.1 修复：
+
+- 渲染调度改为**纯事件驱动**（DOM MutationObserver 批次 / Chat Snapshot 订阅 / `visibilitychange`，微任务合并；无定时器、无轮询、无 rAF 循环）；
+- **默认只在稳定的最终回答渲染**（流式预览改为可选且默认关闭），消除 per-token React 重建；
+- 按事件命中的行**局部评估**，行签名缓存使重复扫描零解析、零重绘；
+- 同一围栏**原地更新**，不重建 root；
+- **每个 document scope 只允许一个渲染器实例**；
+- 宿主移除外来容器时最多重插 3 次，超限放弃并恢复原生代码块；
+- 修复复用分支的 `hidden` 反转 bug；
+- 删除对已移除的 `prompt-rich-ui` 目录的残留测试引用。
+
+验证：`tsc --noEmit` 0 错误；15 个测试文件 / 226 项测试通过；隔离宿主压力验证（201 行模拟历史 + 150 次流式形状 DOM 变更）0 long task、最大帧间隔 19.5ms、单 root、卸载归零、无控制台错误。
+
 ## 1. 总体
 
 | 维度 | 上游 | dsh-rich-msg |
@@ -12,7 +33,7 @@
 | 最终消息判定 | 仅 `assistant-step` 祖先 | Snapshot 最终性 + 推理排除 + 流式回撤 |
 | 主题 | 自有配色 + 部分桥接 | 全量 DSH token 桥接（明/暗/移动端） |
 | 构建 | Vite + tsc + 独立 demo | esbuild 双产物、无 Vite 依赖 |
-| 测试 | vitest + Playwright 快照 | 13 文件 / 210 项单测与集成测试通过 + 真实宿主 DOM 冒烟；真实模型 E2E 改为人工 |
+| 测试 | vitest + Playwright 快照 | 15 文件 / 226 项单测与集成测试通过 + 真实宿主 DOM 冒烟；真实模型 E2E 改为人工 |
 
 ## 2. 模块级明细
 
@@ -44,7 +65,7 @@
 
 ## 3.1 验证状态
 
-- 已通过：`tsc --noEmit`（0 错误）、`vitest run`（210/210）、隔离 profile 真实宿主加载与 DOM 冒烟。
+- 已通过：`tsc --noEmit`（0 错误）、`vitest run`（15 文件 / 226 项）、隔离 profile 真实宿主加载与 DOM 冒烟、0.1.1 事件驱动压力验证。
 - 未完成（按用户要求停止自动化，改人工）：真实模型对话的 Fence 通道与 Tool Bridge 引用端到端验证。
 - 未验证：Android WebView、多标签页并发、超长历史压测、宿主升级后的 DOM 契约。
 

package/docs/DEVELOPMENT.md

@@ -46,7 +46,7 @@ node scripts/build.mjs
 
 ```
 lib/index.js   48,876 bytes
-lib/client.js 341,008 bytes
+lib/client.js 346,449 bytes   (0.1.1)
 host esbuild warnings: 0
 tsc --noEmit: 0 errors
 ```
@@ -59,17 +59,18 @@ npx vitest run
 ```
 
 ```
-Test Files  13 passed (13)
-Tests       210 passed (210)
+Test Files  15 passed (15)
+Tests       226 passed (226)
 ```
 
+> 0.1.1 修复记录：0.1.0 在长会话中会出现页面无响应——根因是流式期间每 token 重建 React root、每次 DOM 变更全量扫描整页、宿主 reconcider 与容器隐藏互相拉扯。0.1.1 改为纯事件驱动、默认只在稳定回答渲染、按行局部评估、原地更新、单 scope 单实例、重插上限。上述 226 项测试与隔离宿主压力验证（201 行模拟历史 + 150 次流式形状 DOM 变更：0 long task、最大帧间隔 19.5ms、单 root、卸载归零）均在 0.1.1 上通过。
+
 覆盖范围：
 
 | 测试文件 | 覆盖 |
 |---|---|
 | `tests/core/schema.test.ts` | RichSpec 全字段校验、非法输入、上限、实体/引用/图表/表格/控件 |
 | `tests/core/evaluator.test.ts` | 表达式求值、算子树、状态、边界 |
-| `tests/core/references.test.ts` | 引用目标收集 |
 | `tests/shared/protocol.test.ts` | ref 协议、Action 信封、id 语法、大小上限 |
 | `tests/host/artifacts.test.ts` | 会话隔离、TTL、容量、淘汰、清理 |
 | `tests/host/tools.test.ts` | 工具 Schema、中性描述、校验/发布行为、取消信号 |

package/lib/client.js

@@ -9783,7 +9783,9 @@ function looksLikeDocument(raw) {
 }
 function claimFence(source, body, raw) {
   if (raw.length > MAX_SOURCE_LENGTH) {
-    if (isOurs(labelToken(fenceLabel(source, body)))) return { kind: "invalid", error: "Document is longer than " + MAX_SOURCE_LENGTH + " characters" };
+    if (isOurs(labelToken(fenceLabel(source, body)))) {
+      return { kind: "invalid", error: "Document is longer than " + MAX_SOURCE_LENGTH + " characters" };
+    }
     return null;
   }
   const label = fenceLabel(source, body);
@@ -9819,14 +9821,39 @@ function rowOf(source) {
 function isStreamingDom(source) {
   return source.closest("[data-streaming]") !== null;
 }
-function factsTag(facts) {
-  if (facts === void 0) return "no-facts";
-  return facts.finality + "|" + facts.fenceLocation;
+function surfacesOf(row) {
+  return [...row.querySelectorAll(SURFACES)].filter(
+    (surface) => !surface.closest(OWN) && !surface.parentElement?.closest(SURFACES)
+  );
+}
+function rowSignature(row) {
+  const key2 = row.getAttribute("data-chat-node-key") ?? row.getAttribute("data-chat-anchor-key") ?? "";
+  const streaming = isStreamingDom(row) ? "1" : "0";
+  const surfaces = surfacesOf(row);
+  const lengths = surfaces.map((surface) => {
+    const body = surface.querySelector("pre") ?? surface.querySelector("[data-code-block-content]");
+    return body?.textContent?.length ?? 0;
+  });
+  return key2 + "|" + streaming + "|" + surfaces.length + "|" + lengths.join(",");
 }
-function installFenceRenderer(deps, scope = document.body) {
+function installFenceRenderer(deps, scope = document.body, options = {}) {
+  if (activeScopeRenderer !== void 0 && activeScopeRenderer.scope === scope) {
+    try {
+      activeScopeRenderer.dispose();
+    } catch {
+    }
+  }
+  const previewAllowed = options.previewDuringStreaming === true;
+  const maxMounts = typeof options.maxMounts === "number" && options.maxMounts > 0 ? options.maxMounts : 40;
   const mounts = /* @__PURE__ */ new Map();
+  const knownRows = /* @__PURE__ */ new Set();
+  const unstableRows = /* @__PURE__ */ new WeakSet();
+  const rowSignatures = /* @__PURE__ */ new Map();
   let disposed = false;
-  let scheduled = false;
+  let flushPending = false;
+  let pendingRows = /* @__PURE__ */ new Set();
+  let fullRescan = true;
+  let sessionId;
   const remove = (source, mount) => {
     try {
       mount.root.unmount();
@@ -9837,9 +9864,9 @@ function installFenceRenderer(deps, scope = document.body) {
     mounts.delete(source);
   };
   const paint = (mount, facts) => {
-    const sessionId = mount.sessionId;
+    const session = mount.sessionId;
     const onAction = (action2, payload) => {
-      deps.sendAction(sessionId, action2, payload);
+      deps.sendAction(session, action2, payload);
     };
     const onOpenEntity = (entity, entities) => {
       if (deps.openEntity === void 0) return false;
@@ -9872,63 +9899,87 @@ function installFenceRenderer(deps, scope = document.body) {
     const error = mount.mode === "resolving" ? "Resolving reference..." : mount.error ?? "Invalid document";
     mount.root.render((0, import_react16.createElement)(Diagnostic, { key: error + ":" + mount.raw, error, source: mount.raw }));
   };
-  const claimFor = (source, body, raw, row) => {
-    const facts = deps.chat.factsForRow(row, raw);
-    const claim = claimFence(source, body, raw);
-    if (claim === null) return { claim: null, facts, streaming: false };
-    if (facts !== void 0) {
-      if (facts.fenceLocation === "reasoning") return { claim: null, facts, streaming: false };
-      if (facts.finality === "not-final") return { claim: null, facts, streaming: false };
-      if (facts.finality === "streaming-final" && facts.fenceLocation !== "text") return { claim: null, facts, streaming: false };
-      return { claim, facts, streaming: facts.finality === "streaming-final" };
-    }
-    if (isStreamingDom(source)) return { claim: null, facts, streaming: false };
-    return { claim, facts, streaming: false };
+  const paintIfNeeded = (mount, facts) => {
+    const key2 = mount.mode + "|" + mount.raw + "|" + (mount.error ?? "") + "|" + (mount.ref ?? "") + "|" + (facts?.finality ?? "");
+    if (mount.renderedKey === key2) return;
+    mount.renderedKey = key2;
+    paint(mount, facts);
   };
-  const scan = () => {
-    scheduled = false;
-    if (disposed) return;
-    for (const [source, mount] of mounts) {
-      if (!scope.contains(source)) remove(source, mount);
+  const ensurePlacement = (source, mount) => {
+    if (source.nextSibling !== mount.container) {
+      if (!source.isConnected) return false;
+      mount.reinserts += 1;
+      if (mount.reinserts > 3) {
+        const row = rowOf(source);
+        if (row !== null) unstableRows.add(row);
+        return false;
+      }
+      source.after(mount.container);
     }
-    const candidates = new Set(scope.querySelectorAll(SURFACES));
-    for (const body of scope.querySelectorAll("[data-code-block-content]")) {
-      if (body.parentElement !== null) candidates.add(body.parentElement);
+    if (!source.hidden) source.hidden = true;
+    if (mount.container.hidden) mount.container.hidden = false;
+    return true;
+  };
+  const evaluateRow = (row, force = false) => {
+    if (disposed || !row.isConnected) return;
+    if (unstableRows.has(row)) return;
+    if (row.getAttribute("data-chat-flow-kind") !== ANSWER_ROW) {
+      for (const source of surfacesOf(row)) {
+        const mount = mounts.get(source);
+        if (mount !== void 0) remove(source, mount);
+      }
+      knownRows.delete(row);
+      return;
+    }
+    const surfaces = surfacesOf(row);
+    if (surfaces.length === 0) {
+      knownRows.delete(row);
+      return;
+    }
+    knownRows.add(row);
+    const signature = rowSignature(row);
+    if (!force && rowSignatures.get(row) === signature) {
+      for (const source of surfaces) {
+        const mount = mounts.get(source);
+        if (mount !== void 0 && !ensurePlacement(source, mount)) remove(source, mount);
+      }
+      return;
     }
-    const sessionId = deps.chat.sessionId();
-    for (const source of candidates) {
-      if (source.closest(OWN)) continue;
-      const row = rowOf(source);
+    rowSignatures.set(row, signature);
+    for (const source of surfaces) {
       const body = source.querySelector("pre") ?? source.querySelector("[data-code-block-content]");
-      if (row === null || body === null || row.getAttribute("data-chat-flow-kind") !== ANSWER_ROW) {
-        const mount2 = mounts.get(source);
-        if (mount2 !== void 0) remove(source, mount2);
+      if (body === null) {
+        const stale = mounts.get(source);
+        if (stale !== void 0) remove(source, stale);
         continue;
       }
       const raw = body.textContent ?? "";
-      const evaluated = claimFor(source, body, raw, row);
+      const facts = deps.chat.factsForRow(row, raw);
+      const claim = claimFence(source, body, raw);
       const mount = mounts.get(source);
-      if (evaluated.claim === null) {
+      const streaming = facts !== void 0 ? facts.finality === "streaming-final" : isStreamingDom(source);
+      const claimable = claim !== null && !(facts !== void 0 && facts.fenceLocation === "reasoning") && !(facts !== void 0 && facts.finality === "not-final") && !(facts !== void 0 && facts.finality === "streaming-final" && facts.fenceLocation !== "text") && !(streaming && !previewAllowed);
+      if (!claimable || claim === null) {
         if (mount !== void 0) remove(source, mount);
         continue;
       }
-      if (mount !== void 0 && mount.sessionId !== sessionId) {
-        remove(source, mount);
-      }
-      const existing = mounts.get(source);
       const owner = fenceOwnerKey(source, row);
-      const mode = evaluated.claim.kind === "spec" ? "rich" : evaluated.claim.kind === "ref" ? "resolving" : "diagnostic";
-      const ref = evaluated.claim.kind === "ref" ? evaluated.claim.ref : void 0;
-      if (existing !== void 0 && !existing.failed && existing.raw === raw && existing.sessionId === sessionId && existing.streaming === evaluated.streaming && existing.owner === owner && existing.ref === ref && existing.mode === mode) {
-        if (source.nextSibling !== existing.container) source.after(existing.container);
-        if (!source.hidden) {
-          existing.container.hidden = true;
-          source.hidden = true;
+      const nextMode = claim.kind === "spec" ? "rich" : claim.kind === "ref" ? "resolving" : "diagnostic";
+      const nextRef = claim.kind === "ref" ? claim.ref : void 0;
+      if (mount !== void 0 && !mount.failed && mount.sessionId === sessionId && mount.owner === owner && mount.ref === nextRef && mount.mode !== "resolving") {
+        mount.raw = raw;
+        mount.streaming = streaming;
+        mount.error = claim.kind === "invalid" ? claim.error : void 0;
+        mount.spec = claim.kind === "spec" ? claim.spec : mount.spec;
+        if (!ensurePlacement(source, mount)) {
+          remove(source, mount);
+          continue;
         }
+        paintIfNeeded(mount, facts);
         continue;
       }
-      if (existing !== void 0) remove(source, existing);
-      if (evaluated.streaming && evaluated.claim.kind === "invalid") continue;
+      if (mount !== void 0) remove(source, mount);
+      if (mounts.size >= maxMounts) continue;
       const container = document.createElement("div");
       container.setAttribute(DOM_MARKERS.root, "");
       const root = (0, import_client.createRoot)(container);
@@ -9938,23 +9989,20 @@ function installFenceRenderer(deps, scope = document.body) {
         root,
         raw,
         sourceHidden: source.hidden,
-        streaming: evaluated.streaming,
-        mode,
-        ref,
-        spec: evaluated.claim.kind === "spec" ? evaluated.claim.spec : void 0,
-        error: evaluated.claim.kind === "invalid" ? evaluated.claim.error : void 0,
+        streaming,
+        mode: nextMode,
+        ref: nextRef,
+        spec: claim.kind === "spec" ? claim.spec : void 0,
+        error: claim.kind === "invalid" ? claim.error : void 0,
         sessionId,
-        owner
+        owner,
+        reinserts: 0
       };
       mounts.set(source, next);
       source.after(container);
       source.hidden = true;
-      if (mode === "rich") {
-        paint(next, evaluated.facts);
-        continue;
-      }
-      if (mode === "diagnostic") {
-        paint(next, evaluated.facts);
+      if (nextMode === "rich" || nextMode === "diagnostic") {
+        paintIfNeeded(next, facts);
         continue;
       }
       const referenceId = next.ref ?? "";
@@ -9963,7 +10011,7 @@ function installFenceRenderer(deps, scope = document.body) {
         applyResolution(next, immediate);
         continue;
       }
-      paint(next, evaluated.facts);
+      paintIfNeeded(next, facts);
       void deps.artifacts.resolve(sessionId, referenceId).then((resolved) => {
         if (disposed || mounts.get(source) !== next) return;
         applyResolution(next, resolved);
@@ -9975,52 +10023,156 @@ function installFenceRenderer(deps, scope = document.body) {
       mount.mode = "rich";
       mount.spec = resolved.spec;
       mount.container.hidden = false;
-      paint(mount, void 0);
+      mount.renderedKey = void 0;
+      paintIfNeeded(mount, void 0);
       return;
     }
     mount.mode = "diagnostic";
     mount.error = "Unresolved rich-msg reference: " + (resolved.id || "missing id");
     mount.container.hidden = false;
-    paint(mount, void 0);
+    mount.renderedKey = void 0;
+    paintIfNeeded(mount, void 0);
+  };
+  const rowsFromRecords = (records) => {
+    const rows = /* @__PURE__ */ new Set();
+    let full = false;
+    for (const record of records) {
+      const target = record.target instanceof Element ? record.target : record.target.parentElement;
+      if (target === null) {
+        full = true;
+        continue;
+      }
+      if (target.closest(OWN) !== null) continue;
+      const row = target.closest("[data-chat-flow-kind]");
+      if (row !== null) rows.add(row);
+      for (const node of [...record.addedNodes, ...record.removedNodes]) {
+        if (!(node instanceof Element)) continue;
+        if (node.matches(OWN) || node.closest(OWN) !== null) continue;
+        const addedRow = node.closest?.("[data-chat-flow-kind]");
+        if (addedRow !== null && addedRow !== void 0) rows.add(addedRow);
+        for (const nested of node.querySelectorAll?.("[data-chat-flow-kind]") ?? []) {
+          if (nested instanceof HTMLElement) rows.add(nested);
+        }
+      }
+      if (record.type === "childList" || record.type === "characterData") {
+        const owner = target.closest("[data-chat-flow-kind]");
+        if (owner !== null) rows.add(owner);
+      }
+    }
+    return { rows, full };
+  };
+  const schedule = (rows, full = false) => {
+    if (disposed) return;
+    if (full) fullRescan = true;
+    if (rows !== void 0) for (const row of rows) pendingRows.add(row);
+    if (flushPending) return;
+    flushPending = true;
+    queueMicrotask(() => {
+      flushPending = false;
+      if (disposed) return;
+      flush();
+    });
   };
-  const schedule = () => {
-    if (scheduled || disposed) return;
-    scheduled = true;
-    if (scope.querySelector("[data-streaming]") !== null && typeof requestAnimationFrame === "function") {
-      requestAnimationFrame(scan);
-    } else {
-      queueMicrotask(scan);
+  const flush = () => {
+    if (disposed) return;
+    const nextSession = deps.chat.sessionId();
+    if (nextSession !== sessionId) {
+      sessionId = nextSession;
+      fullRescan = true;
+    }
+    if (fullRescan) {
+      fullRescan = false;
+      for (const [source, mount] of mounts) remove(source, mount);
+      knownRows.clear();
+      rowSignatures.clear();
+      const rows = /* @__PURE__ */ new Set();
+      for (const surface of scope.querySelectorAll(SURFACES)) {
+        if (surface.closest(OWN) !== null) continue;
+        const row = rowOf(surface);
+        if (row !== null) rows.add(row);
+      }
+      for (const row of rows) evaluateRow(row, true);
+      return;
+    }
+    for (const row of pendingRows) {
+      if (!row.isConnected) {
+        knownRows.delete(row);
+        continue;
+      }
+      evaluateRow(row);
+    }
+    pendingRows = /* @__PURE__ */ new Set();
+    for (const [source, mount] of mounts) {
+      if (!source.isConnected || !mount.container.isConnected) remove(source, mount);
     }
+    void knownRows;
   };
-  const observer = new MutationObserver((records) => {
-    if (records.every((record) => {
-      const target = record.target instanceof Element ? record.target : record.target.parentElement;
-      return target?.closest(OWN) !== null && target?.closest(OWN) !== void 0;
-    })) {
+  const onChatChange = () => {
+    if (disposed) return;
+    const nextSession = deps.chat.sessionId();
+    const rows = /* @__PURE__ */ new Set();
+    for (const row of knownRows) {
+      if (row.isConnected) rows.add(row);
+    }
+    if (nextSession !== sessionId) {
+      schedule(rows, true);
       return;
     }
-    schedule();
+    if (rows.size === 0) return;
+    if (flushPending) return;
+    flushPending = true;
+    queueMicrotask(() => {
+      flushPending = false;
+      if (disposed) return;
+      for (const row of rows) if (row.isConnected) evaluateRow(row, true);
+      for (const [source, mount] of mounts) {
+        if (!source.isConnected || !mount.container.isConnected) remove(source, mount);
+      }
+    });
+  };
+  const observer = new MutationObserver((records) => {
+    if (disposed) return;
+    const { rows, full } = rowsFromRecords(records);
+    if (full || rows.size > 0) schedule(rows, full);
   });
   observer.observe(scope, {
     childList: true,
     subtree: true,
     characterData: true,
     attributes: true,
-    attributeFilter: ["data-streaming", "hidden", "data-chat-node-key", "data-chat-anchor-key", "data-chat-flow-kind"]
+    attributeFilter: ["data-streaming", "data-chat-node-key", "data-chat-anchor-key", "data-chat-flow-kind"]
   });
-  const unsubscribeFacts = deps.chat.subscribe(schedule);
-  scan();
-  return () => {
+  const onVisibility = () => {
+    if (disposed) return;
+    if (typeof document !== "undefined" && document.hidden) return;
+    schedule(void 0, true);
+  };
+  if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisibility);
+  const unsubscribeChat = deps.chat.subscribe(onChatChange);
+  sessionId = deps.chat.sessionId();
+  fullRescan = true;
+  flush();
+  const dispose = () => {
     if (disposed) return;
     disposed = true;
-    unsubscribeFacts();
+    unsubscribeChat();
     observer.disconnect();
+    if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisibility);
     for (const [source, mount] of mounts) remove(source, mount);
+    knownRows.clear();
+    rowSignatures.clear();
+    pendingRows = /* @__PURE__ */ new Set();
+    if (activeScopeRenderer !== void 0 && activeScopeRenderer.dispose === dispose) {
+      activeScopeRenderer = void 0;
+    }
   };
+  activeScopeRenderer = { scope, dispose };
+  return dispose;
 }
+var activeScopeRenderer;
 function persistenceKeyOf(mount, facts) {
-  if (mount.sessionId === void 0) return void 0;
-  const tag = factsTag(facts);
+  if (mount.sessionId === void 0) return JSON.stringify(["dsh-rich-msg", mount.owner ?? "", mount.ref ?? ""]);
+  const tag = facts === void 0 ? "no-facts" : facts.finality + "|" + facts.fenceLocation;
   return JSON.stringify(["dsh-rich-msg", mount.sessionId, mount.owner ?? "", tag, mount.ref ?? ""]);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rich-msg",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Rich content message renderer for DeepSeek Harness: declarative JSON rendered as themed, interactive message UI, with fence and tool-bridge channels.",
   "license": "MIT",
   "type": "module",