dsh-markdown-bubble 0.1.3 → 0.1.5

package/README.md

@@ -33,9 +33,9 @@ DSH 的用户消息气泡按原样显示你输入的文字（`white-space: pre-w
 
 - **官方座位替换** —— 经 `ctx.slots` 在 `conversation.chat.node` 的 `user` / `steering` 两个 keyed 座位上以 `priority: -1` 遮蔽宿主渲染器；停用/卸载即恢复宿主自己的气泡，不改源码、不动日志
 - **宿主同款渲染** —— 不自己造 Markdown 管线，直接调用 `@deepseek-ai/dsh-client-ui-primitives` 的 `MarkdownText`：与助手回复同一套解析、高亮、表格、公式与代码卡
-- **引用 chip 保留** —— 宿主投影函数 `projectUserText` 照常调用，返回的片段按 chip / 纯文本拆分：chip 仍是可点击的文件 / 技能 chip，纯文本段逐个进 Markdown
+- **引用 chip 保留** —— 调用宿主自己的文本工厂槽 `conversation.user.text`（0.2.1 起投影就住在那里），返回的片段按 chip / 纯文本拆分：chip 仍是可点击的文件 / 技能 chip，纯文本段逐个进 Markdown
 - **操作条与三方插件兼容** —— 时间 + 复制按钮用官方 primitives 重建，操作条保留 `_actions` / `_action` 类名后缀与 `data-clock` 锚点；dsh-edit-turn、dsh-delete-turn、dsh-rerun-turn 的按钮注入照常工作
-- **附件与补充块** —— 图片走官方 `conversation.message.images` 座位（`renderMessageImages`），文件卡、引用摘要、`JsonBlock` 补充块与宿主同款
+- **附件与补充块** —— 图片走官方的图片画廊工厂槽 `conversation.images.content`，文件卡、引用摘要、`JsonBlock` 补充块与宿主同款
 - **软换行保留** —— 仅对围栏代码之外的续行补 GFM 两空格硬换行；代码块一个字节不动，缩进代码与表格行不误伤
 - **出错兜底** —— 单条消息的渲染错误被错误边界接住，回退为宿主的原始投影，不会连累整条座位被槽位机制摘除
 - **中英双语** 随系统语言切换（代码卡文案复用宿主 `chat` 字典）
@@ -89,12 +89,31 @@ const a = 1
 
 ### 兼容性
 
-- 实测 DSH `0.2.0-rc.1`（web profile，Chromium）。依赖：keyed 槽位 `conversation.chat.node`、行锚点 `data-chat-flow-kind` / `data-pending-steering` / `data-submission-echo`、primitives 导出的 `MarkdownText` / `projectUserText` / `writeClipboard`。
+- 实测 DSH `0.2.1-rc.2`（web profile，Chromium）。依赖：keyed 槽位 `conversation.chat.node`（`user` / `steering`）、座位上的 `renderFactorySlot` 绑定、行锚点 `data-chat-flow-kind` / `data-pending-steering` / `data-submission-echo`、primitives 导出的 `MarkdownText` / `writeClipboard`。
+- **0.2.1 把扩展点往里挪了**，本插件 0.1.5 已按新契约移植（旧契约的三样东西都不在了）：`primitives.projectUserText` 被删除 → 改调文本工厂槽 `conversation.user.text`；座位 props 从 `{ node, renderMessageImages, openFile, openSkill, t }` 变成 `{ node, renderFactorySlot, loadImage, t }` → 图片改调图片画廊工厂槽 `conversation.images.content`。
+- **为什么不能去换内容工厂槽**：`conversation.chat.user.content` 由宿主注册，插件再注册同名工厂会让**宿主自己的聊天插件启动失败**（实测 `web boot: 1 entry did not activate @deepseek-ai/dsh-client-ui-chat: failed`），所以「只换气泡内部」这条路走不通；同理，`conversation.chat.user.images` 这个子槽也不能由插件声明（实测 `slot "conversation.chat.user.images" is already declared (by factory "conversation.chat.user.content")`）。座位替换 + 两个工厂槽调用是当前版本唯一可行且不伤宿主的组合。
 - 与 `dsh-edit-turn`、`dsh-delete-turn`、`dsh-rerun-turn` 协同：三者的按钮注入基于 `[class*="_actions"]` / `[class*="_action"]`，本插件保留该契约；被 dsh-edit-turn 改写（rollback）的消息显示其自己的改写气泡，与本插件无关。
 - 宿主半区为惰性入口（无运行时行为），全部逻辑在 `./client` 浏览器半区；不修改官方源码，不写私有事件类型。
 
+### 为什么现在不能换成「替换内容工厂」（B 方案）
+
+理想做法是替换宿主的内容工厂槽 `conversation.chat.user.content`：气泡内部（附件 + 气泡 + 引用摘要）全部交回宿主，本插件只换掉正文那一段。这样能删掉自建的行外壳、时间/复制操作条与相关样式约 200 行，也不再依赖座位 props 的形状。**现在做不了，卡在下面三条**（都在 DSH `0.2.1-rc.2` 上实测过；等哪天宿主放开了任意一条，就可以改成 B）：
+
+| 缺什么 | 实测结果 | 放开之后 |
+|---|---|---|
+| 工厂槽能被插件**遮蔽/替换** | 注册同名工厂不是遮蔽而是硬错误，且会让**宿主自己的聊天插件启动失败**：`web boot: 1 entry did not activate @deepseek-ai/dsh-client-ui-chat: failed` | 直接换成注册 `conversation.chat.user.content`，删掉自建行外壳与操作条 |
+| 子槽能由**多个**声明方共享 | 想让座位条目自己声明 `conversation.chat.user.images` 以拿到 `renderSlot`，被拒：`slot "conversation.chat.user.images" is already declared (by factory "conversation.chat.user.content")`，且整条注册一起失败 | 图片可以用官方的座位/子槽渲染，不必绕工厂槽 |
+| 有一个**公开的**「渲染一条用户消息」入口 | 0.2.1 删掉了 `primitives.projectUserText`，投影只存在于工厂槽内部（现在只能调 `conversation.user.text` / `conversation.images.content` 这两个工厂槽） | 插件插入的气泡（例如 dsh-edit-turn 改写后的提示词）也能走同一条管线，见 [deepseek-harness#10704](https://github.com/deepseek-ai/deepseek-harness/discussions/10704) |
+
+也就是说：**座位替换（A）+ 调两个工厂槽**是当前版本唯一不伤宿主的组合；上面三条任意一条放开，都可以迁到 B。
+
 ### 修复记录
 
+- **0.1.5** —— 按 DSH `0.2.1-rc.2` 的新契约移植，并把 `engines.dsh` 从开口的 `>=0.2.0-rc.1` 收成 `>=0.2.1-rc.2`（旧区间会让它在 0.2.1 上照样安装、只静默降级）。
+  - **引用 chip 回来了**：`primitives.projectUserText` 在 0.2.1 被删除（真机报 `TypeError: primitives.projectUserText is not a function`），投影改成调用宿主的文本工厂槽 `conversation.user.text`（`facts.sessionLabels` / `facts.skillNames` + `interactive`），chip 拆分逻辑不变。真机复验：控制台里那条降级告警不再出现（0 条），25/25 条用户气泡仍由本插件渲染。
+  - **图片附件回来了**：座位 props 里的 `renderMessageImages` 已不存在，改调图片画廊工厂槽 `conversation.images.content`（附件插件自己注册的那个；它的 `MessageImages` 也只是这一步调用）。三条看起来更顺的路都被堵着，README 的「兼容性」一节记了实测报错原文。
+  - **性能**：降级投影从「每帧算两次」改成只算一次（`MarkdownBoundary` 的 fallback 改成惰性 thunk，只有真失败时才构造）；`toMarkdown()` 加 64 条 LRU 缓存（流式期间同一条消息会被反复重排，而准备源码是 split/join + 逐行正则）；传给 `MarkdownText` 的 labels 对象按 `t` 记忆化（宿主自己的 `ReasoningContent` 正是这么做的，每次新建对象会让下游 memo 失效）。
+- **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 +198,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.5",
   "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",
@@ -48,7 +48,7 @@
       ]
     },
     "engines": {
-      "dsh": ">=0.2.0-rc.1"
+      "dsh": ">=0.2.1-rc.2"
     }
   }
 }

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.5'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_MARKDOWN_BUBBLE__'
@@ -189,7 +189,27 @@ window.__ModuleLoader__.load({
      * @param text - raw logged message text.
      * @returns markdown source for the renderer.
      */
+    // Prepared markdown source, keyed by the raw text. A bubble repaints on
+    // every transcript update (a streaming turn re-renders constantly) and the
+    // preparation is a split/join plus a regex per line, so the same message was
+    // re-walked dozens of times while an unrelated row streamed. Cleared whole
+    // when it grows past the cap: the entries are strings, and a long transcript
+    // has far fewer distinct message texts than it has repaints.
+    const markdownSourceCache = new Map()
+    const MARKDOWN_CACHE_LIMIT = 64
+
     function toMarkdown(text) {
+      const key = typeof text === 'string' ? text : ''
+      const cached = markdownSourceCache.get(key)
+      if (cached !== undefined) return cached
+      const source = prepareMarkdown(key)
+      if (markdownSourceCache.size >= MARKDOWN_CACHE_LIMIT) markdownSourceCache.clear()
+      markdownSourceCache.set(key, source)
+      return source
+    }
+
+    /** The uncached preparation: CRLF, session wire links, soft breaks. */
+    function prepareMarkdown(text) {
       const normalized = text.replace(/\r\n?/gu, '\n')
       return walkOutsideFences(normalized, (line, next) => hardBreakLine(line.replace(SESSION_WIRE_RE, '$1'), next))
     }
@@ -249,12 +269,44 @@ 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 renderFactorySlot - the seat's Factory binding (chips + plain runs).
+     * @returns the degraded body, never null and never a throw.
+     */
+    function degradedBody(text, referenceLabels, skillNames, renderFactorySlot) {
       try {
-        return primitives.projectUserText(text, referenceLabels, skillNames, 'skill', references)
+        if (typeof renderFactorySlot !== 'function') throw new Error('the seat handed over no renderFactorySlot')
+        // The projection moved into the host's own Factory in 0.2.1-rc.2
+        // (`conversation.user.text`, registered by dsh-client-ui-conversation;
+        // it owns the keyed child slot that renders a reference chip). The old
+        // public primitive `primitives.projectUserText` was REMOVED in the same
+        // release, which is why this call used to throw and chips degraded to
+        // plain text.
+        return renderFactorySlot('conversation.user.text', {
+          text,
+          facts: { sessionLabels: referenceLabels, skillNames },
+          interactive: true,
+          ellipsis: false,
+        })
       } 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,22 +321,21 @@ 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.
      * @param t - the injected chat translator.
      * @param referenceLabels - session recall labels.
      * @param skillNames - skill names.
-     * @param references - file/skill open callbacks.
+     * @param renderFactorySlot - the seat's Factory binding.
      * @returns the composed body, or null when markdown cannot be produced.
      */
-    function safeMarkdownBody(text, t, referenceLabels, skillNames, references) {
+    function safeMarkdownBody(text, t, referenceLabels, skillNames, renderFactorySlot, labels) {
       try {
-        const labels = buildMarkdownLabels(t)
-        return composeUserMarkdown(text, labels, referenceLabels, skillNames, references)
+        return composeUserMarkdown(text, labels, referenceLabels, skillNames, renderFactorySlot)
       } catch (error) {
-        console.warn('[' + NS + '] markdown composition failed; showing the plain projection', error)
+        warnOnce('markdown composition failed; showing the degraded projection', error)
         return null
       }
     }
@@ -321,12 +372,14 @@ window.__ModuleLoader__.load({
      * @param labels - markdown chrome labels.
      * @param referenceLabels - session recall labels the host associates with the message.
      * @param skillNames - skill names the host loaded for the message.
-     * @param references - file/skill open callbacks for clickable chips.
+     * @param renderFactorySlot - the seat's Factory binding.
      * @returns the composed body, or null for empty text.
      */
-    function composeUserMarkdown(text, labels, referenceLabels, skillNames, references) {
+    function composeUserMarkdown(text, labels, referenceLabels, skillNames, renderFactorySlot) {
       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, renderFactorySlot)
       const pieces =
         react.isValidElement(projected) && projected.type === Fragment && Array.isArray(projected.props.children)
           ? projected.props.children
@@ -503,7 +556,12 @@ window.__ModuleLoader__.load({
       }
 
       render() {
-        return this.state.failed ? this.props.fallback : this.props.children
+        if (!this.state.failed) return this.props.children
+        const { fallback } = this.props
+        // A thunk is called only when it is actually needed: building the
+        // degraded projection on every healthy render is wasted work (and, on a
+        // host whose projection is gone, a caught throw every time).
+        return typeof fallback === 'function' ? fallback() : fallback
       }
     }
 
@@ -593,9 +651,24 @@ window.__ModuleLoader__.load({
       }
     }
 
-    function renderAttachmentEntry({ attachment, renderMessageImages, compactImages }) {
+    function renderAttachmentEntry({ attachment, renderFactorySlot, loadImage, compactImages }) {
       if (attachment.type === 'image') {
-        return h(Fragment, null, renderMessageImages({ images: [attachment.image], align: 'end', compact: compactImages }))
+        // The host's image gallery, through the SAME Factory seam as the text
+        // projection. The three routes that look obvious are all closed on
+        // 0.2.1-rc.2: the `renderMessageImages` seat prop is gone, the child
+        // slot `conversation.chat.user.images` cannot be declared by a plugin
+        // ("already declared (by factory conversation.chat.user.content)",
+        // verified live), and `@deepseek-ai/dsh-client-ui-attachment` exports
+        // only apply/inject. The gallery Factory is the one that works: the
+        // attachment plugin registers `conversation.images.content` at root
+        // scope and its own `MessageImages` is nothing but a call to it.
+        if (typeof renderFactorySlot !== 'function') throw new Error('the seat handed over no renderFactorySlot')
+        return h(Fragment, null, renderFactorySlot('conversation.images.content', {
+          images: [attachment.image],
+          loadImage,
+          align: 'end',
+          compact: compactImages,
+        }))
       }
       const file = attachment.file ?? {}
       const name = typeof file.name === 'string' ? file.name : ''
@@ -627,7 +700,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
@@ -646,21 +719,31 @@ window.__ModuleLoader__.load({
     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
+      // The seat's props on 0.2.1-rc.2: the two renderer bindings and the image
+      // loader. The old `renderMessageImages` / `openFile` / `openSkill` pair is
+      // gone; images now go through the declared child slot and reference chips
+      // through the `conversation.user.text` Factory.
+      const renderFactorySlot = safeProps.renderFactorySlot
+      const renderSlot = safeProps.renderSlot
+      const loadImage = safeProps.loadImage
       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 compactImages = attachments.length > 1
       const showBubble = text !== '' || rest.length > 0
+      // The host memoizes its own label object before handing it to MarkdownText
+      // (`ReasoningContent` does exactly this); a fresh object every render
+      // defeats that memoization and re-renders the whole markdown tree.
+      const labels = react.useMemo(() => buildMarkdownLabels(t), [t])
 
       // Never let composition throw out of this render — see safeMarkdownBody.
-      const body = safeMarkdownBody(text, t, referenceLabels, skillNames, references)
-      const fallback = plainProjection(text, referenceLabels, skillNames, references)
+      // ONE degraded body per render: it is the composition guard's projection
+      // and the boundary's fallback, so building it eagerly (as this used to)
+      // ran the projection twice per render and, on 0.2.1-rc.2, threw twice.
+      const body = safeMarkdownBody(text, t, referenceLabels, skillNames, renderFactorySlot, labels)
+      const degraded = () => degradedBody(text, referenceLabels, skillNames, renderFactorySlot)
 
       // The action strip leads the row in DOM order and is pushed below the
       // bubble by flex `order`. Sibling plugins pick their bar with
@@ -684,7 +767,8 @@ window.__ModuleLoader__.load({
                 h(AttachmentEntry, {
                   key: `${attachment.type}:${index}`,
                   attachment,
-                  renderMessageImages,
+                  renderFactorySlot,
+                  loadImage,
                   compactImages,
                 }),
               ),
@@ -693,7 +777,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 +809,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 : [],
+        safeProps.renderFactorySlot,
+      )
       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.5'
 
 /** Cordis plugin name; the bundle patch resolves the package by this row. */
 export const name = PLUGIN_ID