dsh-markdown-bubble 0.1.1 → 0.1.4

package/README.md

@@ -95,6 +95,9 @@ 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、最低者渲染、同优先级抛错）与三个兄弟插件依赖的锚点结构一并加进回归测试。
 
 ### License
@@ -177,6 +180,9 @@ 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.
 
 ### License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-markdown-bubble",
-  "version": "0.1.1",
+  "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.1'
+    const PLUGIN_VERSION = '0.1.4'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_MARKDOWN_BUBBLE__'
@@ -230,16 +230,85 @@ window.__ModuleLoader__.load({
       return react.isValidElement(piece) && typeof piece.props.children === 'string' ? piece.props.children : ''
     }
 
-    /** The host projection, called in a guard: it is the fallback of last resort. */
-    function plainProjection(text, referenceLabels, skillNames, references) {
+    /**
+     * A copy lookup that cannot take the seat down. The framework injects a
+     * `t` for the declared `chat` namespace, but a host-shape mismatch (a
+     * locale service that was never bound, a renamed key) must fall back to
+     * the key rather than throw during render.
+     * @param t - the injected chat translator, possibly not callable.
+     * @param key - the dictionary key.
+     * @param params - template parameters.
+     * @returns the translated string, or the key.
+     */
+    function safeTranslate(t, key, params) {
+      if (typeof t !== 'function') return key
+      try {
+        return t(key, params)
+      } catch {
+        return key
+      }
+    }
+
+    /**
+     * 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)
       }
     }
 
+    /**
+     * Compose the markdown body without ever throwing.
+     *
+     * `composeUserMarkdown` runs while the seat component renders, so a throw
+     * here does NOT reach {@link MarkdownBoundary} — a boundary catches its
+     * descendants, not the parent render that creates it. It would escape to
+     * the slot machinery, which answers by retiring the whole entry and handing
+     * 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 {@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.
+     * @param t - the injected chat translator.
+     * @param referenceLabels - session recall labels.
+     * @param skillNames - skill names.
+     * @param references - file/skill open callbacks.
+     * @returns the composed body, or null when markdown cannot be produced.
+     */
+    function safeMarkdownBody(text, t, referenceLabels, skillNames, references) {
+      try {
+        const labels = buildMarkdownLabels(t)
+        return composeUserMarkdown(text, labels, referenceLabels, skillNames, references)
+      } catch (error) {
+        warnOnce('markdown composition failed; showing the degraded projection', error)
+        return null
+      }
+    }
+
     /**
      * A whitespace-only plain run: the gap between two chips, or the leading /
      * trailing padding the host's own pre-wrap bubble shows. It carries no
@@ -277,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
@@ -330,15 +401,15 @@ window.__ModuleLoader__.load({
     function buildMarkdownLabels(t) {
       return {
         code: {
-          copyLabel: t('copy'),
-          copiedLabel: t('copied'),
+          copyLabel: safeTranslate(t, 'copy'),
+          copiedLabel: safeTranslate(t, 'copied'),
           toolbarLabels: {
-            codeLabel: t('codeBlock.title'),
-            wrapLabel: t('codeBlock.wrap'),
-            unwrapLabel: t('codeBlock.unwrap'),
+            codeLabel: safeTranslate(t, 'codeBlock.title'),
+            wrapLabel: safeTranslate(t, 'codeBlock.wrap'),
+            unwrapLabel: safeTranslate(t, 'codeBlock.unwrap'),
           },
         },
-        footnotes: t('markdown.footnotes'),
+        footnotes: safeTranslate(t, 'markdown.footnotes'),
       }
     }
 
@@ -385,6 +456,23 @@ window.__ModuleLoader__.load({
       return day
     }
 
+    /**
+     * Log one degradation per distinct reason.
+     *
+     * The seat renders on every transcript update, so a hostile host shape would
+     * otherwise print the same warning on every pass and bury the one line that
+     * matters. Keyed by the reason rather than by the row: what a reader needs to
+     * know is which guard fired, once.
+     * @param reason - one line naming what degraded.
+     * @param error - the caught value.
+     */
+    const warnedReasons = new Set()
+    function warnOnce(reason, error) {
+      if (warnedReasons.has(reason)) return
+      warnedReasons.add(reason)
+      console.warn('[' + NS + '] ' + reason, error)
+    }
+
     /**
      * The host's message clock: `HH:mm` for today, the `clock.md` date plus
      * the clock earlier this year, the `clock.ymd` form for other years.
@@ -394,12 +482,25 @@ window.__ModuleLoader__.load({
      * @returns the display string.
      */
     function formatMessageClock(time, t, now) {
-      const date = new Date(time)
-      const reference = new Date(now)
+      // `new Date(x)` throws on a Symbol, a BigInt, or an object whose `valueOf`
+      // throws — and the host hands `data.time` through unchanged. A throw here
+      // happens INSIDE the seat's subtree, outside MarkdownBoundary (the strip is
+      // not the markdown body), so it would escape to the slot machinery and
+      // retire the whole entry. A missing clock is a cosmetic loss; a retired
+      // renderer is "the plugin stopped working".
+      let date
+      let reference
+      try {
+        date = new Date(time)
+        reference = new Date(now)
+      } catch (error) {
+        warnOnce('the message time cannot be read; the clock is hidden', error)
+        return ''
+      }
       const clock = `${pad2(date.getHours())}:${pad2(date.getMinutes())}`
       if (date.getFullYear() === reference.getFullYear() && date.getMonth() === reference.getMonth() && date.getDate() === reference.getDate()) return clock
       const params = { y: date.getFullYear(), m: date.getMonth() + 1, d: date.getDate() }
-      return `${date.getFullYear() === reference.getFullYear() ? t('clock.md', params) : t('clock.ymd', params)} ${clock}`
+      return `${date.getFullYear() === reference.getFullYear() ? safeTranslate(t, 'clock.md', params) : safeTranslate(t, 'clock.ymd', params)} ${clock}`
     }
 
     // --- pieces -----------------------------------------------------------------
@@ -477,7 +578,7 @@ window.__ModuleLoader__.load({
 
       const clock =
         time === undefined ? null : h('span', { className: 'dshmb-timeStart' }, formatMessageClock(time, t, day))
-      const label = copied ? t('copied') : t('copy')
+      const label = copied ? safeTranslate(t, 'copied') : safeTranslate(t, 'copy')
 
       return h(
         'div',
@@ -501,22 +602,36 @@ window.__ModuleLoader__.load({
      * @param props - the attachment entry and the owner's image renderer.
      * @returns the row entry.
      */
-    function AttachmentEntry({ attachment, renderMessageImages, compactImages }) {
+    function AttachmentEntry(props) {
+      // The image branch calls the HOST's renderer during our render, and the
+      // file branch calls host primitives (`fileExtension`, `fileSizeText`). Both
+      // sit outside MarkdownBoundary, so either can retire the entry. One
+      // attachment is worth losing; the row is not.
+      try {
+        return renderAttachmentEntry(props)
+      } catch (error) {
+        warnOnce('an attachment could not be rendered; it is skipped', error)
+        return null
+      }
+    }
+
+    function renderAttachmentEntry({ attachment, renderMessageImages, compactImages }) {
       if (attachment.type === 'image') {
         return h(Fragment, null, renderMessageImages({ images: [attachment.image], align: 'end', compact: compactImages }))
       }
       const file = attachment.file ?? {}
-      const meta = [primitives.fileExtension(file.name).toUpperCase().slice(0, 8), primitives.fileSizeText(file.bytes)]
+      const name = typeof file.name === 'string' ? file.name : ''
+      const meta = [primitives.fileExtension(name).toUpperCase().slice(0, 8), primitives.fileSizeText(file.bytes)]
         .filter(Boolean)
         .join(' ')
       return h(
         'span',
-        { className: 'dshmb-fileCard', title: file.name },
-        h(primitives.FileTypeIcon, { path: file.name, className: 'dshmb-fileIcon' }),
+        { className: 'dshmb-fileCard', title: name },
+        h(primitives.FileTypeIcon, { path: name, className: 'dshmb-fileIcon' }),
         h(
           'span',
           { className: 'dshmb-fileContent' },
-          h('span', { className: 'dshmb-fileName' }, file.name),
+          h('span', { className: 'dshmb-fileName' }, name),
           h('span', { className: 'dshmb-fileMeta' }, meta),
         ),
       )
@@ -529,22 +644,48 @@ window.__ModuleLoader__.load({
      * @param props - keyed chat renderer seat for the `user`/`steering` kinds.
      * @returns the right-aligned bubble with attachments, markdown, chips and actions.
      */
-    const MarkdownBubbleSeat = react.memo(function MarkdownBubbleSeat({
-      node,
-      renderMessageImages,
-      openFile,
-      openSkill,
-      t,
-    }) {
-      const data = node.data
-      const { text, attachments, rest } = contentParts(data.content)
-      const referenceLabels = data.referenceLabels ?? []
-      const skillNames = data.skillNames ?? []
+    const MarkdownBubbleSeat = react.memo(function MarkdownBubbleSeat(props) {
+      try {
+        return renderMarkdownBubble(props)
+      } catch (error) {
+        // Last-resort net. Everything that can throw is guarded where it is
+        // 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
+        // their own buttons on `row.querySelector('[class*="_actions"]')`.
+        warnOnce('the markdown seat failed to render; showing the plain text', error)
+        return renderPlainRow(props)
+      }
+    })
+
+    /**
+     * The real seat body. Separated from the memo wrapper so the wrapper can hold
+     * one try/catch for the whole synchronous render.
+     * @param props - keyed chat renderer seat for the `user`/`steering` kinds.
+     * @returns the right-aligned bubble with attachments, markdown, chips and actions.
+     */
+    function renderMarkdownBubble(props) {
+      const safeProps = props !== null && typeof props === 'object' ? props : {}
+      const node = safeProps.node !== null && typeof safeProps.node === 'object' ? safeProps.node : {}
+      const renderMessageImages = safeProps.renderMessageImages
+      const openFile = safeProps.openFile
+      const openSkill = safeProps.openSkill
+      const t = safeProps.t
+      const data = node.data !== null && typeof node.data === 'object' ? node.data : {}
+      const { text, attachments, rest } = contentParts(Array.isArray(data.content) ? data.content : [])
+      const referenceLabels = Array.isArray(data.referenceLabels) ? data.referenceLabels : []
+      const skillNames = Array.isArray(data.skillNames) ? data.skillNames : []
       const references = react.useMemo(() => ({ openFile, openSkill }), [openFile, openSkill])
-      const labels = react.useMemo(() => buildMarkdownLabels(t), [t])
       const compactImages = attachments.length > 1
       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 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
       // `row.querySelector('[class*="_actions"]')` — first match in document
@@ -576,17 +717,13 @@ window.__ModuleLoader__.load({
             h(
               'div',
               { className: 'dshmb-bubble' },
-              h(
-                MarkdownBoundary,
-                { key: text, fallback: plainProjection(text, referenceLabels, skillNames, references) },
-                composeUserMarkdown(text, labels, referenceLabels, skillNames, references),
-              ),
+              h(MarkdownBoundary, { key: text, fallback: degraded }, body === null ? degraded : body),
               rest.map((block, index) =>
                 h(primitives.JsonBlock, {
                   key: 'rest' + index,
-                  label: t('message.extraBlock'),
+                  label: safeTranslate(t, 'message.extraBlock'),
                   payload: block,
-                  truncatedLabel: (total) => t('json.truncated', { total }),
+                  truncatedLabel: (total) => safeTranslate(t, 'json.truncated', { total }),
                 }),
               ),
             ),
@@ -594,11 +731,48 @@ window.__ModuleLoader__.load({
             h(
               'div',
               { className: 'dshmb-referenceSummary' },
-              t('message.referenceSummary', { labels: referenceLabels.join(t('message.referenceSeparator')) }),
+              safeTranslate(t, 'message.referenceSummary', {
+                labels: referenceLabels.join(safeTranslate(t, 'message.referenceSeparator')),
+              }),
             ),
         ),
       )
-    })
+    }
+
+    /**
+     * The degraded row: the action strip plus the raw text, built so that nothing
+     * in it can throw.
+     * @param props - whatever the seat was handed.
+     * @returns the row with its sibling anchors intact.
+     */
+    function renderPlainRow(props) {
+      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 parts
+      try {
+        parts = contentParts(Array.isArray(data.content) ? data.content : [])
+      } catch {
+        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' }, degraded)),
+      )
+    }
 
     // --- style ------------------------------------------------------------------
 

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.1'
+export const PLUGIN_VERSION = '0.1.4'
 
 /** Cordis plugin name; the bundle patch resolves the package by this row. */
 export const name = PLUGIN_ID