dsh-markdown-bubble 0.1.3 → 0.1.4

package/README.md

@@ -95,6 +95,7 @@ const a = 1
 
 ### 修复记录
 
+- **0.1.4** —— 按评审意见把降级路径**合成一个函数**：此前「合成失败」「宿主投影抛错」「最后兜底」各自写了一份降级逻辑（一份调宿主投影、一份内联拼裸文本），三处要人工保持同步。现在只有 `degradedBody()` 一处：先试宿主自己的投影（保住引用 chip 等宿主渲染），投影也抛才退到裸文本；三条降级路径全部走它。内容优先这一点写进函数契约：裸文本是最后一步，只有宿主自己拒绝投影时才到。新增回归：断言 `projectUserText` 全仓只有一次调用、裸文本 span 只有一处构造、降级调用方都走同一函数（再造一份降级该测试转红）。
 - **0.1.3** —— 把「座位 render 绝不抛」这条不变式补完：0.1.2 守住了合成与文案查询，但仍有形状会在**座位自己的渲染里**抛错（`node` 缺失 → `node.data`、`props` 缺失 → 解构本身、`new Date(time)` 遇到 Symbol / BigInt / 抛错的 valueOf、宿主图片渲染器抛错）。这些同样冒泡到槽位机制、退掉整条条目，症状与 0.1.2 修的完全一样。现在三层兜底：座位本体一层 try 并把 `node` / `data` 的取用改成防御式；时钟与附件卡在各自调用点兜底；最后一层 `renderPlainRow` 保证最坏情况只是这一行退回纯文本，而操作条与兄弟插件锚点仍在。新增回归：21 种恶意宿主形状逐一断言不抛、且行与操作条都在。
 - **0.1.2** — 座位组件不再可能因渲染期异常被槽位机制摘除：`composeUserMarkdown` / `buildMarkdownLabels` 在座位渲染过程中运行，抛错不会被错误边界接住（错误边界只能接住其后代，接不住创建它的那次渲染），会冒泡到槽位机制并把该条目整条退掉——屏幕上就是气泡交还给宿主、Markdown 变回源码。现在合成与所有文案查询都在座位内部兜底：任何宿主形状不符（节点结构异常、投影返回不可识别、locale 席位不可调用）都退回宿主原始投影，气泡外壳、操作条与兄弟插件锚点全部保留。`data.content` 非数组、`t` 不可调用等情形一并加进回归测试。
 - **0.1.1** — 修复两个引用 chip 之间只有空白时该空白被当作空 Markdown 块丢弃的问题：相邻 chip 不再粘成 `@a@b`，chip 之间的换行也按宿主 `pre-wrap` 气泡的样子保留为换行（空白段渲染为 `data-dshmb-gap` 的预换行节点，仍不产生空 Markdown 块）；自建的操作条 / 复制按钮补上 `data-dshmb-actions` / `data-dshmb-action` 命名空间标记；座位优先级 `-1` 的宿主依据（宿主默认 0、最低者渲染、同优先级抛错）与三个兄弟插件依赖的锚点结构一并加进回归测试。
@@ -179,6 +180,7 @@ Queued-message previews, the composer itself and the goal panel stay plain text
 
 ### Fixes
 
+- **0.1.4** — synthesizes the degradation paths into ONE function, as the reviewer asked: composition failure, a throwing host projection and the last-resort net each used to carry their own copy (one calling the host projection, one building the raw-text span inline), all kept in step by hand. There is now a single `degradedBody()`: it tries the host's own projection first — so reference chips and the host's own inline pieces survive — and only a projection that itself throws degrades to the raw text. Content first is now the function's contract: raw text is the last step, reached only when the host refuses to project. New regression: exactly one `projectUserText` call in the whole file, one raw-text span construction, and every degradation caller sharing the function (re-introducing a second copy turns it red).
 - **0.1.3** — completes the "the seat render never throws" invariant: 0.1.2 guarded composition and the copy lookups, but shapes still threw in the seat's own render (an absent `node` -> `node.data`, absent props -> the destructuring itself, a `time` the Date constructor refuses — Symbol, BigInt, a `valueOf` that throws — and a host image renderer that throws). Each escaped to the slot machinery and retired the entry, the same symptom 0.1.2 fixed. Three layers now: one try around the seat body with defensive `node` / `data` access, per-call guards for the clock and the attachment card, and a last-resort `renderPlainRow` so the worst case is one row falling back to plain text with its action strip and the sibling anchors intact. Regression: 21 hostile host shapes, each asserted not to throw and to keep the row and its strip.
 - **0.1.2** — the seat component can no longer be retired by a render-time exception: `composeUserMarkdown` / `buildMarkdownLabels` run while the seat renders, and a throw there is not caught by the error boundary (a boundary catches its descendants, not the render that creates it) — it escapes to the slot machinery, which drops the whole entry and hands the row back to the host, so the bubble reverts to raw source on screen. Composition and every copy lookup now degrade inside the seat: any host-shape mismatch (an unexpected node, an unrecognised projection result, a locale seat that is not callable) falls back to the host's plain projection while the bubble shell, the action strip and the sibling-plugin anchors stay intact. `data.content` that is not an array and an uncallable `t` are covered by regression tests.
 - **0.1.1** — fixed whitespace-only plain runs between two reference chips being dropped as an empty Markdown block: adjacent chips no longer glue into `@a@b`, and a newline between two chips stays a line break the way the host's `pre-wrap` bubble shows it (the run renders as a `data-dshmb-gap` pre-wrap node, still never an empty Markdown block); the self-created action strip and copy button now carry the `data-dshmb-actions` / `data-dshmb-action` namespace markers; and the host evidence behind `priority: -1` (host default 0, lowest renders, same priority throws) plus the anchor structure the three sibling plugins rely on are covered by regression tests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-markdown-bubble",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Markdown rendering for DeepSeek Harness sent user messages: every message bubble renders lists, code, tables, quotes and inline formatting through the host's own Markdown pipeline, while queues, previews and the composer keep their plain projection.",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -49,7 +49,7 @@ window.__ModuleLoader__.load({
     const NS = 'dsh-markdown-bubble'
 
     /** Keep in sync with package.json and src/index.js. */
-    const PLUGIN_VERSION = '0.1.3'
+    const PLUGIN_VERSION = '0.1.4'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_MARKDOWN_BUBBLE__'
@@ -249,12 +249,32 @@ window.__ModuleLoader__.load({
       }
     }
 
-    /** The host projection, called in a guard: it is the fallback of last resort. */
-    function plainProjection(text, referenceLabels, skillNames, references) {
+    /**
+     * The ONE degraded projection: what this plugin shows whenever the markdown
+     * pipeline cannot be used.
+     *
+     * The host's own projection is tried first — it is the rendering the host
+     * would have used, so reference chips and inline pieces survive it — and a
+     * projection that throws degrades once more, to the raw text. Composition
+     * failure (see {@link safeMarkdownBody}), a boundary catch and the
+     * last-resort net (see {@link renderPlainRow}) ALL answer here, so the ways
+     * this plugin degrades cannot drift apart: there is no second copy of the
+     * fallback for someone to keep in step.
+     *
+     * Content comes first: the raw-text step is the last step, reached only when
+     * the host itself refuses to project.
+     *
+     * @param text - the message text.
+     * @param referenceLabels - session recall labels.
+     * @param skillNames - skill names.
+     * @param references - file/skill open callbacks.
+     * @returns the degraded body, never null and never a throw.
+     */
+    function degradedBody(text, referenceLabels, skillNames, references) {
       try {
         return primitives.projectUserText(text, referenceLabels, skillNames, 'skill', references)
       } catch (error) {
-        console.warn('[' + NS + '] the host user-text projection failed; showing raw text', error)
+        warnOnce('the host user-text projection failed; showing raw text', error)
         return h('span', { className: 'dshmb-plain' }, text)
       }
     }
@@ -269,7 +289,7 @@ window.__ModuleLoader__.load({
      * the row back to the host's raw renderer; on screen that is
      * indistinguishable from "the plugin stopped working". A host-shape
      * mismatch (an unexpected node shape, an unrecognised projection result)
-     * therefore falls back to the plain projection right here, inside our own
+     * therefore falls back to {@link degradedBody} right here, inside our own
      * render, so the bubble keeps its shell, its actions and the sibling
      * plugins' injection anchors.
      * @param text - the message text.
@@ -284,7 +304,7 @@ window.__ModuleLoader__.load({
         const labels = buildMarkdownLabels(t)
         return composeUserMarkdown(text, labels, referenceLabels, skillNames, references)
       } catch (error) {
-        console.warn('[' + NS + '] markdown composition failed; showing the plain projection', error)
+        warnOnce('markdown composition failed; showing the degraded projection', error)
         return null
       }
     }
@@ -326,7 +346,9 @@ window.__ModuleLoader__.load({
      */
     function composeUserMarkdown(text, labels, referenceLabels, skillNames, references) {
       if (typeof text !== 'string' || text === '') return null
-      const projected = plainProjection(text, referenceLabels, skillNames, references)
+      // The same single degraded projection, so a projection that throws inside
+      // composition degrades exactly as one that throws on the healthy path.
+      const projected = degradedBody(text, referenceLabels, skillNames, references)
       const pieces =
         react.isValidElement(projected) && projected.type === Fragment && Array.isArray(projected.props.children)
           ? projected.props.children
@@ -627,7 +649,7 @@ window.__ModuleLoader__.load({
         return renderMarkdownBubble(props)
       } catch (error) {
         // Last-resort net. Everything that can throw is guarded where it is
-        // called (see safeMarkdownBody, plainProjection, formatMessageClock,
+        // called (see safeMarkdownBody, degradedBody, formatMessageClock,
         // AttachmentEntry); this exists so an UNKNOWN host shape degrades one
         // row to plain text instead of retiring the renderer. The fallback still
         // renders the action strip, because the three sibling plugins anchor
@@ -659,8 +681,10 @@ window.__ModuleLoader__.load({
       const showBubble = text !== '' || rest.length > 0
 
       // Never let composition throw out of this render — see safeMarkdownBody.
+      // One degraded body per render, shared by the composition guard and the
+      // boundary's own fallback; the last-resort net calls it too.
       const body = safeMarkdownBody(text, t, referenceLabels, skillNames, references)
-      const fallback = plainProjection(text, referenceLabels, skillNames, references)
+      const degraded = degradedBody(text, referenceLabels, skillNames, references)
 
       // The action strip leads the row in DOM order and is pushed below the
       // bubble by flex `order`. Sibling plugins pick their bar with
@@ -693,7 +717,7 @@ window.__ModuleLoader__.load({
             h(
               'div',
               { className: 'dshmb-bubble' },
-              h(MarkdownBoundary, { key: text, fallback }, body === null ? fallback : body),
+              h(MarkdownBoundary, { key: text, fallback: degraded }, body === null ? degraded : body),
               rest.map((block, index) =>
                 h(primitives.JsonBlock, {
                   key: 'rest' + index,
@@ -725,19 +749,28 @@ window.__ModuleLoader__.load({
       const safeProps = props !== null && typeof props === 'object' ? props : {}
       const node = safeProps.node !== null && typeof safeProps.node === 'object' ? safeProps.node : {}
       const data = node.data !== null && typeof node.data === 'object' ? node.data : {}
-      let text = ''
+      let parts
       try {
-        text = contentParts(Array.isArray(data.content) ? data.content : []).text
+        parts = contentParts(Array.isArray(data.content) ? data.content : [])
       } catch {
-        text = ''
+        parts = { text: '', attachments: [], rest: [] }
       }
+      const text = parts.text
+      // The same degraded projection the healthy path uses, so a row that
+      // degraded in one place looks exactly like a row that degraded in another.
+      const degraded = degradedBody(
+        text,
+        Array.isArray(data.referenceLabels) ? data.referenceLabels : [],
+        Array.isArray(data.skillNames) ? data.skillNames : [],
+        { openFile: safeProps.openFile, openSkill: safeProps.openSkill },
+      )
       return h(
         'div',
         { className: 'dshmb-row', 'data-dshmb-row': '1', 'data-dshmb-degraded': '1' },
         h(MessageActions, { text, time: data.time, t: safeProps.t }),
         text === ''
           ? null
-          : h('div', { className: 'dshmb-stack' }, h('div', { className: 'dshmb-bubble' }, h('span', { className: 'dshmb-plain' }, text))),
+          : h('div', { className: 'dshmb-stack' }, h('div', { className: 'dshmb-bubble' }, degraded)),
       )
     }
 

package/src/index.js

@@ -15,7 +15,7 @@
 export const PLUGIN_ID = 'dsh-markdown-bubble'
 
 /** Keep in sync with package.json and src/client.js. */
-export const PLUGIN_VERSION = '0.1.3'
+export const PLUGIN_VERSION = '0.1.4'
 
 /** Cordis plugin name; the bundle patch resolves the package by this row. */
 export const name = PLUGIN_ID