dsh-markdown-bubble 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DDDMUC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# dsh-markdown-bubble
+
+**DeepSeek Harness 用户消息 Markdown 渲染插件 —— 你发出去的每一条消息，都按 Markdown 渲染。** 标题、列表、加粗、行内代码、引用、代码块、表格与公式不再以源码形态躺在气泡里，而是经宿主自己的 Markdown 管线（`MarkdownText`）呈现；引用 chip、附件、时间/复制操作条与其它插件注入的按钮全部原样保留。实现方式是官方 keyed 槽位 `conversation.chat.node` 的 `user` / `steering` 座位替换，不修改 DSH 源码，不改写任何会话日志。
+
+[中文](#中文) · [English](#english)
+
+---
+
+## 中文
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/DDDMUC/dsh-markdown-bubble/main/docs/screenshots/01-markdown-bubble.png" alt="用户消息气泡按 Markdown 渲染" width="820" />
+  <br>
+  <sub>▲ 发出的 Markdown 按格式渲染；单换行保留为换行，代码块带宿主同款语法高亮卡</sub>
+  <br><br>
+  <img src="https://raw.githubusercontent.com/DDDMUC/dsh-markdown-bubble/main/docs/screenshots/02-action-strip.png" alt="操作条上的复制、删除、重跑、编辑按钮" width="520" />
+  <br>
+  <sub>▲ 操作条原样保留：时间、复制，以及 dsh-delete-turn / dsh-rerun-turn / dsh-edit-turn 注入的按钮</sub>
+</div>
+
+### 为什么需要它
+
+DSH 的用户消息气泡按原样显示你输入的文字（`white-space: pre-wrap`）：粘贴一段 README、写一段带列表的提示词、贴一段代码，都要先在脑子里解一遍 Markdown。助手回复有完整的 Markdown 管线，你自己的消息却没有。
+
+这个插件把你这一侧的气泡也接到同一条管线上：
+
+- 标题、列表、有序列表、任务列表、加粗 / 斜体 / 删除线、行内代码；
+- 围栏代码块（宿主同款语法高亮与复制 / 换行工具条）、引用、分割线；
+- 表格（宽表可横向滚动）、链接、图片、KaTeX 公式、脚注；
+- 单换行保留为换行（GFM 语义会把 `第一行\n第二行` 合并成一段，聊天里没有人希望这样）。
+
+### 特性
+
+- **官方座位替换** —— 经 `ctx.slots` 在 `conversation.chat.node` 的 `user` / `steering` 两个 keyed 座位上以 `priority: -1` 遮蔽宿主渲染器；停用/卸载即恢复宿主自己的气泡，不改源码、不动日志
+- **宿主同款渲染** —— 不自己造 Markdown 管线，直接调用 `@deepseek-ai/dsh-client-ui-primitives` 的 `MarkdownText`：与助手回复同一套解析、高亮、表格、公式与代码卡
+- **引用 chip 保留** —— 宿主投影函数 `projectUserText` 照常调用，返回的片段按 chip / 纯文本拆分：chip 仍是可点击的文件 / 技能 chip，纯文本段逐个进 Markdown
+- **操作条与三方插件兼容** —— 时间 + 复制按钮用官方 primitives 重建，操作条保留 `_actions` / `_action` 类名后缀与 `data-clock` 锚点；dsh-edit-turn、dsh-delete-turn、dsh-rerun-turn 的按钮注入照常工作
+- **附件与补充块** —— 图片走官方 `conversation.message.images` 座位（`renderMessageImages`），文件卡、引用摘要、`JsonBlock` 补充块与宿主同款
+- **软换行保留** —— 仅对围栏代码之外的续行补 GFM 两空格硬换行；代码块一个字节不动，缩进代码与表格行不误伤
+- **出错兜底** —— 单条消息的渲染错误被错误边界接住，回退为宿主的原始投影，不会连累整条座位被槽位机制摘除
+- **中英双语** 随系统语言切换（代码卡文案复用宿主 `chat` 字典）
+
+### 安装
+
+```sh
+# npm 安装（web profile）
+dsh plugin --profile web add dsh-markdown-bubble
+
+# 本地工作区（开发）
+dsh plugin --profile web add link:/path/to/dsh-markdown-bubble
+```
+
+`dsh plugin add` 会把依赖写进 profile 并把包追加到 `dsh.profile.bundles`。实测宿主随即扫描到新行、浏览器端热挂载，无需重启；若你的宿主版本未热载，重启 DSH 进程后刷新页面即可。
+
+### 使用
+
+安装即生效，无命令、无设置项。发一条带 Markdown 的消息即可看到渲染结果：
+
+````markdown
+# 标题
+
+- 列表 **加粗**
+- 第二项 `行内代码`
+
+> 引用一行
+
+```js
+const a = 1
+```
+````
+
+排队中的消息预览、输入框本身与 goal 面板保持纯文本（见「已知限制」）。
+
+### 工作原理
+
+1. **座位遮蔽**：浏览器半区 `ctx.slots.inject('conversation.chat.node', …)` 注册 `user` 与 `steering` 两个 keyed 条目，`priority: -1` 低于宿主默认的 `0`（同 key 同优先级会抛错，最低者渲染）。
+2. **内容拆分**：从节点数据取 `content`，按宿主 `UserStyleBubble` 的同一规则拆成文本 / 图片附件 / 文件卡 / 剩余块。
+3. **chip 感知的 Markdown 合成**：调用宿主投影 `projectUserText`，把返回片段分成 chip 与纯文本；纯文本段逐个经 `MarkdownText` 渲染，chip 原样成为可点击元素。
+4. **源码预处理**：CRLF 归一、会话回顾 wire 链接（`@[label](dsh-session:…)`）还原为显示名、围栏代码之外的续行补两空格硬换行。
+5. **外壳复用**：行 / 堆栈 / 气泡 / 文件卡的度量值逐条对齐宿主样式表（`MessageItem.module.css`、`MessageIconActions.module.css`），颜色全部走主题 token；操作条在 DOM 序中前置、用 flex `order` 还原视觉顺序——这样三方插件 `querySelector('[class*="_actions"]')` 的首个命中永远是消息操作条，而不是气泡内代码卡的工具条。
+
+### 已知限制
+
+- **待确认气泡不覆盖**：本地回声与待发送 steering 由宿主 `PendingSubmissionBubble` / `PendingSteeringBubble` 直绘，不走 chat-node 座位，仍是纯文本；消息落盘后即切换为 Markdown。
+- **队列预览不覆盖**：排队消息的一行预览与 goal 命令行保持纯文本。
+- **行内 chip 的折衷**：chip 打断连排段落时，该段会拆成 chip 两边的块（与社区同类实现相同的取舍）；chip 在段首/段尾的常见情形无缝。
+- **皮肤边界**：若某个皮肤直接针对宿主 CSS-module 类名定制用户气泡样式，不会命中本插件的气泡；主题 token 与 `.dshmb-*` / `.dshmb_*` 自定义样式正常生效。
+- **多行语义**：单换行按硬换行渲染；连续空格、Tab 缩进等 Markdown 忽略的空白会被折叠（代码块内除外）。
+
+### 兼容性
+
+- 实测 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-edit-turn`、`dsh-delete-turn`、`dsh-rerun-turn` 协同：三者的按钮注入基于 `[class*="_actions"]` / `[class*="_action"]`，本插件保留该契约；被 dsh-edit-turn 改写（rollback）的消息显示其自己的改写气泡，与本插件无关。
+- 宿主半区为惰性入口（无运行时行为），全部逻辑在 `./client` 浏览器半区；不修改官方源码，不写私有事件类型。
+
+### 修复记录
+
+- **0.1.1** — 修复两个引用 chip 之间只有空白时该空白被当作空 Markdown 块丢弃的问题：相邻 chip 不再粘成 `@a@b`，chip 之间的换行也按宿主 `pre-wrap` 气泡的样子保留为换行（空白段渲染为 `data-dshmb-gap` 的预换行节点，仍不产生空 Markdown 块）；自建的操作条 / 复制按钮补上 `data-dshmb-actions` / `data-dshmb-action` 命名空间标记；座位优先级 `-1` 的宿主依据（宿主默认 0、最低者渲染、同优先级抛错）与三个兄弟插件依赖的锚点结构一并加进回归测试。
+
+### License
+
+MIT
+
+---
+
+## English
+
+**Markdown rendering for DeepSeek Harness sent messages — every message you send is rendered as Markdown.** Headings, lists, bold, inline code, quotes, code fences, tables and math stop sitting in the bubble as source text and render through the host's own Markdown pipeline (`MarkdownText`); reference chips, attachments, the clock/copy action strip and sibling plugins' injected buttons all stay exactly where they were. It works by shadowing the official `user` / `steering` keyed seats of `conversation.chat.node` — no DSH source changes, no session-log rewrites.
+
+### Why you need it
+
+DSH draws your own messages verbatim (`white-space: pre-wrap`): paste a README, write a prompt with a list, drop in a code snippet, and you parse the Markdown in your head first. Assistant replies get the full pipeline; your side does not. This plugin puts your side on the same pipeline: headings, lists, task lists, bold/italic/strikethrough, inline code, fenced code blocks (with the host's syntax highlighting and copy/wrap toolbar), quotes, rules, tables (wide ones scroll), links, images, KaTeX math and footnotes — with single line breaks preserved as line breaks.
+
+### Features
+
+- **Official seat replacement** — registers `user` and `steering` keyed entries in `conversation.chat.node` at `priority: -1` through `ctx.slots`; disabling or uninstalling restores the host's own bubble. No source edits, no log writes.
+- **The host's own renderer** — calls `MarkdownText` from `@deepseek-ai/dsh-client-ui-primitives`, so user messages share the assistant pipeline: the same parsing, highlighting, tables, math and code cards.
+- **Reference chips stay chips** — the host projection (`projectUserText`) is called as usual and split into chips and plain runs; chips keep their click targets, each plain run becomes a Markdown block.
+- **Action strip and sibling-plugin compatibility** — clock and copy are rebuilt from exported primitives; the strip keeps the `_actions` / `_action` class suffixes and the `data-clock` anchor that dsh-edit-turn, dsh-delete-turn and dsh-rerun-turn search for.
+- **Attachments and extra blocks** — images go through the official `conversation.message.images` seat (`renderMessageImages`); file cards, the reference summary and `JsonBlock` extras match the host.
+- **Soft breaks preserved** — continuation lines outside fenced code get GFM's two-space hard break; code keeps every byte, indented code and table rows are left alone.
+- **Crash containment** — a per-message error boundary falls back to the host's plain projection instead of having the slot machinery retire the whole seat.
+- **Bilingual** copy follows the active locale (code-card chrome reuses the host `chat` dictionary).
+
+### Install
+
+```sh
+# from npm (web profile)
+dsh plugin --profile web add dsh-markdown-bubble
+
+# local workspace (development)
+dsh plugin --profile web add link:/path/to/dsh-markdown-bubble
+```
+
+`dsh plugin add` writes the dependency into the profile and appends the package to `dsh.profile.bundles`. In testing the host picked the new row up live and the browser hot-mounted it with no restart; if your host build does not hot-load, restart DSH and reload the page.
+
+### Usage
+
+Install and send Markdown — no command, no setting. A smoke test:
+
+````markdown
+# Heading
+
+- list with **bold**
+- second item `inline code`
+
+> a quote
+
+```js
+const a = 1
+```
+````
+
+Queued-message previews, the composer itself and the goal panel stay plain text (see limitations).
+
+### How it works
+
+1. **Seat shadowing** — the browser half registers `user` and `steering` keyed entries under `conversation.chat.node` at `priority: -1`, lower than the host's default `0` (same key at the same priority throws; the lowest renders).
+2. **Content split** — the node's `content` is split exactly as the host's `UserStyleBubble` does: text, image attachments, file cards, remaining blocks.
+3. **Chip-aware Markdown composition** — the host projection is split into chips and plain runs; each plain run renders through `MarkdownText`, chips stay clickable elements.
+4. **Source preparation** — CRLF normalization, session-recall wire links (`@[label](dsh-session:…)`) reduced to their display label, and two-space hard breaks on continuation lines outside fenced code.
+5. **Shell parity** — row/stack/bubble/file-card metrics are copied from the host sheets (`MessageItem.module.css`, `MessageIconActions.module.css`) while colors stay theme tokens; the action strip leads the row's DOM order with flex `order` restoring the visual order, so a sibling plugin's `querySelector('[class*="_actions"]')` always lands on the message bar — never on a code card's toolbar inside the bubble.
+
+### Known limitations
+
+- **Pending bubbles are not covered**: the local submission echo and the pending steering bubble are drawn directly by the host (not through the chat-node seats) and stay plain text until the message lands.
+- **Queue previews are not covered**: the one-line queue preview and goal command rows stay plain text.
+- **Inline-chip trade-off**: a chip interrupting a running paragraph splits that paragraph into blocks around the chip (the same trade-off community implementations take); boundary chips are seamless.
+- **Skin boundary**: a skin that styles the host's CSS-module bubble classes directly will not hit this plugin's bubble; theme tokens and `.dshmb-*` / `.dshmb_*` custom styles work.
+- **Multi-line semantics**: single newlines render as hard breaks; whitespace Markdown ignores (runs of spaces, tab indentation) is collapsed outside code blocks.
+
+### Compatibility
+
+- Verified against DSH `0.2.0-rc.1` (web profile, Chromium). Depends on the keyed `conversation.chat.node` slot, the `data-chat-flow-kind` / `data-pending-steering` / `data-submission-echo` row anchors, and the primitives exports `MarkdownText` / `projectUserText` / `writeClipboard`.
+- Works alongside `dsh-edit-turn`, `dsh-delete-turn` and `dsh-rerun-turn`: their injection relies on `[class*="_actions"]` / `[class*="_action"]`, which this plugin preserves. A message rewritten (rolled back) by dsh-edit-turn shows that plugin's own replacement bubble, which is out of scope here.
+- The host half is an inert entry (no runtime behavior); everything lives in the `./client` browser bundle. No official source is modified and no private event type is written.
+
+### Fixes
+
+- **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
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,12 @@
+# dsh-markdown-bubble bundle patch: inserts the plugin row into the profile roster.
+#
+# The host half is inert: how a sent message is drawn is a browser-side
+# projection, so the work lives entirely in the exported "./client" bundle.
+#
+# The entry name is the BARE package name on purpose: the client-module scanner
+# treats it as a package specifier and resolves `<name>/package.json`, so a
+# subpath entry would be cached as "not a client package" and the browser half
+# would silently never load.
+- insert:
+    - id: dsh-markdown-bubble
+      name: 'dsh-markdown-bubble'

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "dsh-markdown-bubble",
+  "version": "0.1.1",
+  "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",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./src/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "markdown",
+    "user-message",
+    "bubble",
+    "chat",
+    "render"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DDDMUC/dsh-markdown-bubble.git"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test \"test/*.test.js\""
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ]
+    },
+    "engines": {
+      "dsh": ">=0.2.0-rc.1"
+    }
+  }
+}

package/src/client.js

@@ -0,0 +1,730 @@
+// dsh-markdown-bubble — browser half.
+//
+// What this does
+// --------------
+// The chat view draws a durable sent message through the keyed
+// `conversation.chat.node` seats `user` and `steering` (one host component
+// serves both), which project the raw logged text with `projectUserText` and
+// paint it under `white-space: pre-wrap` — markdown shown as typed. This
+// plugin shadows those two seats at a lower priority and re-renders the same
+// bubble with the host's own markdown pipeline, `MarkdownText`.
+//
+// The replacement keeps what the host keeps:
+//
+// - Reference chips stay chips. The host projection is called (it is frozen,
+//   not replaceable, but perfectly callable) and its pieces are split into
+//   chips and plain runs; chips render unchanged, plain runs go through
+//   MarkdownText. A chip inside a running paragraph splits that paragraph
+//   into blocks around it — boundary chips are the common case.
+// - The action strip survives. The host's own bar (clock + copy) is rebuilt
+//   from exported primitives, and its container keeps the `_actions` /
+//   `_action` class suffixes and the `data-clock` attribute that sibling
+//   plugins (dsh-edit-turn, dsh-delete-turn, dsh-rerun-turn) anchor their
+//   injected buttons on — verified against their sources.
+// - Attachments, the reference summary and `JsonBlock` extras render as the
+//   host renders them, from the same node data and the same owner callbacks.
+//
+// The pending steering bubble and the local submission echo do not pass
+// through these seats (they are not chat nodes yet), so they keep the host's
+// plain projection. Queue previews and the goal panel keep it too.
+//
+// Soft line breaks are preserved: GFM would join "line one\nline two" into one
+// paragraph, but a chat box Enter is a line break. Plain runs are prepared
+// with two-space hard breaks outside fenced code before they reach the
+// renderer.
+//
+// The bundle follows the client-modules contract: it registers a factory with
+// `window.__ModuleLoader__.load` and returns the plugin exports.
+window.__ModuleLoader__.load({
+  id: 'dsh-markdown-bubble',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const react = require('react')
+    const primitives = require('@deepseek-ai/dsh-client-ui-primitives')
+
+    /** Plugin identity and diagnostics key. */
+    const NS = 'dsh-markdown-bubble'
+
+    /** Keep in sync with package.json and src/index.js. */
+    const PLUGIN_VERSION = '0.1.1'
+
+    /** Presence marker the live verifier reads. */
+    const DEBUG_KEY = '__DSH_MARKDOWN_BUBBLE__'
+
+    /** Style tag id claimed by this plugin (HMR and dispose remove it by id). */
+    const CSS_TAG = NS + '/markdown-bubble.css'
+
+    /** Chat-node seats this renderer replaces; the host serves both with one view. */
+    const SEATS = ['user', 'steering']
+
+    // Seat priority: the host's default is 0, the plugin sits below it, and it
+    // must not merely be different — the same key at the same priority is not a
+    // shadow, it is an error.
+    //
+    // Evidence (verified against the installed host, DSH 0.2.0-rc.1):
+    // - the host registers these two keys with no priority field at all
+    //   (@deepseek-ai/dsh-client-ui-chat/lib/client.js:6830-6839), so its entry
+    //   carries the default;
+    // - @deepseek-ai/dsh-client-ui-slots/lib/index.js reads
+    //   options.priority ?? 0 (:167), keeps the ledger sorted by priority
+    //   ascending (:221) and answers a keyed cell with the FIRST live entry of
+    //   that key (:278-293) — the lowest priority renders;
+    // - the same key at the same priority throws instead of shadowing
+    //   (:177-178), so 0 would break the page, and a positive value would lose
+    //   the seat to the host.
+    // -1 is therefore the smallest step that shadows the host and stays clear
+    // of it.
+    const SEAT_PRIORITY = -1
+
+    const { createElement: h, Fragment } = react
+
+    // --- source preparation ---------------------------------------------------
+
+    /** Session recalls log the wire form `@[label](dsh-session:...)`; the label alone is what a chip shows. */
+    const SESSION_WIRE_RE = /@\[([^\]\n]+)\]\(dsh-session:[^)\s]+\)/gu
+
+    /**
+     * A fenced-code opening line: up to three spaces and a run of three or
+     * more backticks or tildes. Returns the fence descriptor, or null.
+     * @param line - one source line.
+     * @returns the fence descriptor or null.
+     */
+    function openingFence(line) {
+      const match = /^ {0,3}(`{3,}|~{3,})/.exec(line)
+      return match === null ? null : { char: match[1][0], length: match[1].length }
+    }
+
+    /**
+     * A fenced-code closing line for one fence: the same character, a run at
+     * least as long as the opening one, and nothing but trailing whitespace
+     * after it (CommonMark forbids a closing info string).
+     * @param line - one source line.
+     * @param fence - the opening fence descriptor.
+     * @returns whether this line closes the fence.
+     */
+    function isClosingFence(line, fence) {
+      const match = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line)
+      return match !== null && match[1][0] === fence.char && match[1].length >= fence.length
+    }
+
+    /**
+     * Walk the source line by line, rewriting only lines that sit outside a
+     * fenced code block. Fenced code is left byte-for-byte alone — its
+     * whitespace is the point — and its opening and closing lines are never
+     * rewritten either.
+     * @param text - message text.
+     * @param visit - (line, nextLine | undefined) => replacement line.
+     * @returns the rewritten source.
+     */
+    function walkOutsideFences(text, visit) {
+      if (!text.includes('\n')) return visit(text, undefined)
+      const lines = text.split('\n')
+      let fence = null
+      for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]
+        if (fence !== null) {
+          if (isClosingFence(line, fence)) fence = null
+          continue
+        }
+        const opener = openingFence(line)
+        if (opener !== null) {
+          fence = opener
+          continue
+        }
+        lines[index] = visit(line, lines[index + 1])
+      }
+      return lines.join('\n')
+    }
+
+    /**
+     * The two-space GFM hard break a line needs when a soft break would
+     * otherwise join it to the next: applied only to content lines that
+     * continue (blank lines end the paragraph), and never to indented code
+     * (which preserves its own line structure).
+     * @param line - current line.
+     * @param next - the following line, absent on the last line.
+     * @returns the line with its hard-break suffix when it needs one.
+     */
+    function hardBreakLine(line, next) {
+      if (line === '' || next === undefined || next.trim() === '') return line
+      if (/^ {4}/.test(line) || line.startsWith('\t')) return line
+      return line + '  '
+    }
+
+    /**
+     * Preserve the single line breaks a reader typed.
+     *
+     * GFM treats one newline inside a paragraph as a soft break (a space), but
+     * this bubble renders what a person typed into a chat box, where Enter is
+     * a line break. Blanket `pre-wrap` is not an option: it would also expose
+     * the source whitespace markdown ignores (list indentation, continuation
+     * spacing). So the source itself is prepared for the renderer.
+     * @param text - newline-normalized message text.
+     * @returns the source with soft breaks promoted to hard breaks.
+     */
+    function preserveHardBreaks(text) {
+      return walkOutsideFences(text, hardBreakLine)
+    }
+
+    /**
+     * Replace a session-recall wire link with its display label. The markdown
+     * renderer only allows http(s)/mailto destinations, so an untranslated
+     * `dsh-session:` link would lose its anchor anyway — this just makes the
+     * plain-text fallback identical to what the chip showed. Fenced code is
+     * left alone: a pasted wire link there is code, not a recall.
+     * @param text - raw logged message text.
+     * @returns the text with wire links unwrapped.
+     */
+    function unwrapSessionReferences(text) {
+      return walkOutsideFences(text, (line) => line.replace(SESSION_WIRE_RE, '$1'))
+    }
+
+    /**
+     * The message text as markdown source: CRLF normalized, session wire
+     * links unwrapped, soft breaks promoted to hard breaks — each applied
+     * only outside fenced code.
+     * @param text - raw logged message text.
+     * @returns markdown source for the renderer.
+     */
+    function toMarkdown(text) {
+      const normalized = text.replace(/\r\n?/gu, '\n')
+      return walkOutsideFences(normalized, (line, next) => hardBreakLine(line.replace(SESSION_WIRE_RE, '$1'), next))
+    }
+
+    // --- content projection ----------------------------------------------------
+
+    /**
+     * Split content blocks exactly as the host's UserStyleBubble does: joined
+     * text, image/file attachments, and the remainder.
+     * @param content - the node's content blocks.
+     * @returns text, attachments and rest blocks.
+     */
+    function contentParts(content) {
+      const texts = []
+      const attachments = []
+      const rest = []
+      for (const block of content) {
+        if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+          texts.push(block.text)
+        } else if (block !== null && typeof block === 'object' && block.type === 'image' && block.attachment !== undefined) {
+          attachments.push({ type: 'image', image: { attachment: block.attachment } })
+        } else if (block !== null && typeof block === 'object' && block.type === 'file' && block.attachment !== undefined) {
+          attachments.push({ type: 'file', file: block.attachment })
+        } else {
+          rest.push(block)
+        }
+      }
+      return { text: texts.join(''), attachments, rest }
+    }
+
+    /** Is this projected piece a reference chip (vs a plain text run)? */
+    function isChip(piece) {
+      return react.isValidElement(piece) && piece.props !== null && piece.props['data-ref-chip'] !== undefined
+    }
+
+    /** Plain-run text sits directly inside the projection's run spans. */
+    function runText(piece) {
+      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) {
+      try {
+        return primitives.projectUserText(text, referenceLabels, skillNames, 'skill', references)
+      } catch (error) {
+        console.warn('[' + NS + '] the host user-text projection failed; showing raw text', error)
+        return h('span', { className: 'dshmb-plain' }, text)
+      }
+    }
+
+    /**
+     * 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
+     * markdown, so it is never a markdown block, but it is not nothing either —
+     * see the flush() comment in composeUserMarkdown.
+     * @param text - the run's whitespace.
+     * @param key - react key.
+     * @returns the gap span.
+     */
+    function gapSpan(text, key) {
+      return h('span', { className: 'dshmb-plain', 'data-dshmb-gap': '1', key }, text)
+    }
+
+    /** One markdown block for one contiguous plain run. */
+    function markdownBlock(source, labels, key) {
+      return h(
+        'div',
+        { className: 'dshmb-md', 'data-dshmb-md': '1', key },
+        h(primitives.MarkdownText, { text: source, labels }),
+      )
+    }
+
+    /**
+     * Compose the bubble body: reference chips stay chips, each contiguous
+     * plain run becomes a markdown block — except a whitespace-only run, which
+     * stays a pre-wrap text node so two chips never glue together. A chip inside
+     * a running paragraph splits that paragraph around the chip; boundary chips
+     * read seamlessly.
+     * @param text - the message text.
+     * @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.
+     * @returns the composed body, or null for empty text.
+     */
+    function composeUserMarkdown(text, labels, referenceLabels, skillNames, references) {
+      if (typeof text !== 'string' || text === '') return null
+      const projected = plainProjection(text, referenceLabels, skillNames, references)
+      const pieces =
+        react.isValidElement(projected) && projected.type === Fragment && Array.isArray(projected.props.children)
+          ? projected.props.children
+          : [projected]
+      if (!pieces.some(isChip)) return markdownBlock(toMarkdown(text), labels, 'md')
+
+      const out = []
+      let run = []
+      const flush = () => {
+        if (run.length === 0) return
+        const raw = run.join('')
+        const source = toMarkdown(raw)
+        if (source.trim() === '') {
+          // Whitespace is not markdown, so it never becomes a block — but it is
+          // not nothing either. Between two chips it is the only thing keeping
+          // them apart: dropping it renders "@a@b" where the host shows
+          // "@a @b", and a newline between two chips (a real line break in the
+          // host's pre-wrap bubble) would collapse onto one line. The host
+          // projection keeps that run as a plain span with the same whitespace;
+          // this renderer keeps it as the pre-wrap stand-in instead of deleting
+          // it.
+          const gap = raw.replace(/\r\n?/gu, '\n')
+          if (gap !== '') out.push(gapSpan(gap, 'gap' + out.length))
+        } else {
+          out.push(markdownBlock(source, labels, 'md' + out.length))
+        }
+        run = []
+      }
+      for (const piece of pieces) {
+        if (isChip(piece)) {
+          flush()
+          out.push(h(Fragment, { key: 'chip' + out.length }, piece))
+        } else {
+          run.push(runText(piece))
+        }
+      }
+      flush()
+      if (out.length === 0) return null
+      return out.length === 1 ? out[0] : h(Fragment, null, out)
+    }
+
+    // --- markdown chrome --------------------------------------------------------
+
+    /**
+     * Markdown chrome labels from the chat translator, matching the host's own
+     * `markdownLabels` wiring so fence cards carry identical copy.
+     * @param t - the chat locale seat.
+     * @returns labels for code fences and footnotes.
+     */
+    function buildMarkdownLabels(t) {
+      return {
+        code: {
+          copyLabel: t('copy'),
+          copiedLabel: t('copied'),
+          toolbarLabels: {
+            codeLabel: t('codeBlock.title'),
+            wrapLabel: t('codeBlock.wrap'),
+            unwrapLabel: t('codeBlock.unwrap'),
+          },
+        },
+        footnotes: t('markdown.footnotes'),
+      }
+    }
+
+    // --- clock ------------------------------------------------------------------
+
+    /** @param value - non-negative integer. @returns two-digit string. */
+    function pad2(value) {
+      return String(value).padStart(2, '0')
+    }
+
+    /**
+     * Midnight epoch of the current local day.
+     * @param now - epoch milliseconds.
+     * @returns the day's local start.
+     */
+    function startOfLocalDay(now) {
+      const date = new Date(now)
+      date.setHours(0, 0, 0, 0)
+      return date.getTime()
+    }
+
+    /**
+     * Milliseconds until the next local midnight.
+     * @param now - epoch milliseconds.
+     * @returns the remaining interval.
+     */
+    function msUntilNextLocalMidnight(now) {
+      const next = new Date(startOfLocalDay(now))
+      next.setDate(next.getDate() + 1)
+      return Math.max(1, next.getTime() - now)
+    }
+
+    /**
+     * Local calendar-day epoch that advances at each local midnight, so a
+     * message clock flips from `HH:mm` to a date without a re-render trigger.
+     * @returns midnight ms for the current local day.
+     */
+    function useLocalDay() {
+      const [day, setDay] = react.useState(() => startOfLocalDay(Date.now()))
+      react.useEffect(() => {
+        const timer = setTimeout(() => setDay(startOfLocalDay(Date.now())), msUntilNextLocalMidnight(Date.now()))
+        return () => clearTimeout(timer)
+      }, [day])
+      return day
+    }
+
+    /**
+     * 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.
+     * @param time - message time in epoch milliseconds.
+     * @param t - the chat locale seat.
+     * @param now - current epoch milliseconds (already local-day bucketed by the caller).
+     * @returns the display string.
+     */
+    function formatMessageClock(time, t, now) {
+      const date = new Date(time)
+      const reference = new Date(now)
+      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}`
+    }
+
+    // --- pieces -----------------------------------------------------------------
+
+    /**
+     * Contain a renderer crash to one message: the bubble falls back to the
+     * host's plain projection instead of crashing the seat, which the slot
+     * machinery would answer by retiring the whole renderer.
+     */
+    class MarkdownBoundary extends react.Component {
+      constructor(props) {
+        super(props)
+        this.state = { failed: false }
+      }
+
+      static getDerivedStateFromError() {
+        return { failed: true }
+      }
+
+      componentDidCatch(error) {
+        console.warn('[' + NS + '] markdown rendering failed; falling back to the plain projection', error)
+      }
+
+      render() {
+        return this.state.failed ? this.props.fallback : this.props.children
+      }
+    }
+
+    /**
+     * The host's action strip for a sent message: clock + copy. The container
+     * keeps the `_actions` class suffix and the `data-clock` attribute that
+     * dsh-edit-turn / dsh-delete-turn / dsh-rerun-turn search for when they
+     * inject their own buttons, and the copy button keeps the `_action`
+     * suffix their ordering heuristic reads.
+     * @param props - message text, time, and the chat translator.
+     * @returns the action strip.
+     */
+    // Anchor fidelity, live-verified on the running instance: this strip is the
+    // row's first DOM child, its direct children are [clock span, copy button]
+    // exactly like the host's own MessageIconActions
+    // (@deepseek-ai/dsh-client-ui-chat/lib/client.js:1157-1172), the copy button
+    // keeps the _action suffix on a direct child (the host's Tooltip adds no
+    // wrapper box) and data-clock stays "start". dsh-edit-turn, dsh-delete-turn
+    // and dsh-rerun-turn therefore find the bar with
+    // row.querySelector('[class*="_actions"]') and their insertion point with
+    // bar.querySelectorAll('button') without knowing a single class hash of the
+    // host's.
+    function MessageActions({ text, time, t }) {
+      const day = useLocalDay()
+      const [copied, setCopied] = react.useState(false)
+      const pending = react.useRef(false)
+      const timer = react.useRef(null)
+
+      react.useEffect(
+        () => () => {
+          pending.current = false
+          if (timer.current !== null) clearTimeout(timer.current)
+        },
+        [],
+      )
+
+      const onCopy = react.useCallback(() => {
+        if (copied || pending.current) return
+        pending.current = true
+        primitives.writeClipboard(text).then((ok) => {
+          pending.current = false
+          if (!ok) return
+          setCopied(true)
+          timer.current = window.setTimeout(() => {
+            timer.current = null
+            setCopied(false)
+          }, 1000)
+        })
+      }, [copied, text])
+
+      const clock =
+        time === undefined ? null : h('span', { className: 'dshmb-timeStart' }, formatMessageClock(time, t, day))
+      const label = copied ? t('copied') : t('copy')
+
+      return h(
+        'div',
+        { className: 'dshmb_actions', 'data-clock': 'start', 'data-dshmb-actions': '1' },
+        clock,
+        h(
+          primitives.Tooltip,
+          { label, side: 'bottom' },
+          h(
+            'button',
+            { type: 'button', className: 'dshmb_action', 'aria-label': label, 'data-dshmb-action': '1', onClick: onCopy },
+            copied ? h(primitives.IconCheckOutlineRegular, {}) : h(primitives.IconCopyOutlineRegular, {}),
+          ),
+        ),
+      )
+    }
+
+    /**
+     * One attachment row entry: an image goes through the host's durable
+     * image renderer, a file renders as the host's file card.
+     * @param props - the attachment entry and the owner's image renderer.
+     * @returns the row entry.
+     */
+    function AttachmentEntry({ 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)]
+        .filter(Boolean)
+        .join(' ')
+      return h(
+        'span',
+        { className: 'dshmb-fileCard', title: file.name },
+        h(primitives.FileTypeIcon, { path: file.name, className: 'dshmb-fileIcon' }),
+        h(
+          'span',
+          { className: 'dshmb-fileContent' },
+          h('span', { className: 'dshmb-fileName' }, file.name),
+          h('span', { className: 'dshmb-fileMeta' }, meta),
+        ),
+      )
+    }
+
+    /**
+     * The markdown-rendered user message bubble — the keyed `user`/`steering`
+     * seat replacement. The host serves both keys with one identical view and
+     * so does this component.
+     * @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 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
+
+      // 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
+      // order — and a markdown bubble can contain a code card whose own
+      // toolbar carries an `_actions` class (`_actions_1pq26_43`). With the
+      // strip first, that lookup always lands on the message bar, the way it
+      // did before markdown put code cards inside the row.
+      return h(
+        'div',
+        { className: 'dshmb-row', 'data-dshmb-row': '1' },
+        h(MessageActions, { text, time: data.time, t }),
+        h(
+          'div',
+          { className: 'dshmb-stack' },
+          attachments.length > 0 &&
+            h(
+              'div',
+              { className: 'dshmb-attachments', 'data-message-attachments': true },
+              attachments.map((attachment, index) =>
+                h(AttachmentEntry, {
+                  key: `${attachment.type}:${index}`,
+                  attachment,
+                  renderMessageImages,
+                  compactImages,
+                }),
+              ),
+            ),
+          showBubble &&
+            h(
+              'div',
+              { className: 'dshmb-bubble' },
+              h(
+                MarkdownBoundary,
+                { key: text, fallback: plainProjection(text, referenceLabels, skillNames, references) },
+                composeUserMarkdown(text, labels, referenceLabels, skillNames, references),
+              ),
+              rest.map((block, index) =>
+                h(primitives.JsonBlock, {
+                  key: 'rest' + index,
+                  label: t('message.extraBlock'),
+                  payload: block,
+                  truncatedLabel: (total) => t('json.truncated', { total }),
+                }),
+              ),
+            ),
+          referenceLabels.length > 0 &&
+            h(
+              'div',
+              { className: 'dshmb-referenceSummary' },
+              t('message.referenceSummary', { labels: referenceLabels.join(t('message.referenceSeparator')) }),
+            ),
+        ),
+      )
+    })
+
+    // --- style ------------------------------------------------------------------
+
+    // Metrics are copied from the host's own sheets (MessageItem.module.css,
+    // MessageIconActions.module.css) so the bubble is the same bubble, but the
+    // classes are this plugin's own — no CSS-module hash to chase between
+    // builds. Colors stay theme tokens; the two class suffixes sibling plugins
+    // search for (`_actions`, `_action`) are preserved on the strip and its
+    // buttons on purpose.
+    const CSS = [
+      '.dshmb-row{flex-direction:column;align-items:flex-end;gap:6px;display:flex}',
+      // The strip leads the row's DOM order so sibling plugins' `_actions`
+      // lookup finds it before any code-card toolbar inside the bubble;
+      // `order` restores the visual order (bubble above, actions below).
+      '.dshmb-stack{order:1;min-width:0;max-width:min(calc(var(--dsh-chat-content-width,748px) * .702), 82%);flex-direction:column;align-items:flex-end;gap:8px;display:flex}',
+      '.dshmb-bubble{background:var(--dsw-specific-bubble);border-radius:var(--dsw-radius-xl);max-width:100%;font-size:var(--dsh-content-font-size,14px);line-height:calc(22px + var(--dsh-content-font-delta,0px));color:var(--dsw-alias-label-primary);word-break:break-word;padding:10px 16px}',
+      '.dshmb-referenceSummary{color:var(--dsw-alias-label-tertiary);font-size:var(--dsh-content-font-size-secondary,13px);line-height:calc(18px + var(--dsh-content-font-delta-secondary,0px))}',
+      '.dshmb-attachments{flex-wrap:wrap;justify-content:flex-end;gap:8px;max-width:100%;display:flex}',
+      '.dshmb-fileCard{border:.5px solid var(--dsw-alias-border-l2,#0000001f);border-radius:var(--dsw-radius-xl);background:var(--dsw-specific-input-major,transparent);box-sizing:border-box;flex:0 0 240px;align-items:center;gap:10px;width:240px;min-height:64px;padding:8px 12px;display:inline-flex}',
+      '.dshmb-fileIcon{flex:none;width:28px;height:28px}',
+      '.dshmb-fileContent{flex-direction:column;flex:1;min-width:0;display:flex}',
+      '.dshmb-fileName{white-space:nowrap;text-overflow:ellipsis;color:var(--dsw-alias-label-primary);font-size:14px;font-weight:500;line-height:22px;overflow:hidden}',
+      '.dshmb-fileMeta{white-space:nowrap;text-overflow:ellipsis;color:var(--dsw-alias-label-tertiary,#00000073);font-size:12px;line-height:15px;overflow:hidden}',
+      // The bubble wraps with `pre-wrap`; markdown brings its own line
+      // structure, so the markdown container returns to the normal policy.
+      '.dshmb-md{white-space:normal;word-break:normal;overflow-wrap:anywhere;min-width:0;max-width:100%}',
+      // MarkdownText's document spacing is tuned for a full transcript column;
+      // inside a bubble those margins read as gaps. The host sheet's
+      // first/last-child collapse is kept.
+      '.dshmb-md > div > :first-child{margin-top:0!important}',
+      '.dshmb-md > div > :last-child{margin-bottom:0!important}',
+      '.dshmb-md > div p{margin:8px 0}',
+      '.dshmb-md > div :where(h1,h2,h3){margin:16px 0 8px}',
+      '.dshmb-md > div :where(h4,h5,h6){margin:12px 0 6px}',
+      '.dshmb-md > div :where(ul,ol){margin:8px 0}',
+      '.dshmb-md > div blockquote{margin:8px 0 0}',
+      '.dshmb-md > div hr{margin:16px 0}',
+      '.dshmb-md > div pre{margin:12px 0}',
+      '.dshmb-plain{white-space:pre-wrap;word-break:break-word}',
+      // Action strip metrics from the host's MessageIconActions.module.css.
+      '.dshmb_actions{order:2;height:calc(28px + var(--dsh-content-font-delta,0px));align-items:center;gap:8px;display:flex}',
+      '.dshmb-timeStart{font-size:var(--dsh-content-font-size-secondary,13px);line-height:calc(24px + var(--dsh-content-font-delta,0px));color:var(--dsw-alias-label-tertiary);white-space:nowrap;padding-right:12px}',
+      '.dshmb_action{width:calc(28px + var(--dsh-content-font-delta,0px));height:calc(28px + var(--dsh-content-font-delta,0px));border-radius:var(--dsw-radius-sm);color:var(--dsw-alias-label-tertiary);cursor:pointer;background:0 0;border:none;justify-content:center;align-items:center;padding:6px;display:inline-flex}',
+      '.dshmb_action svg{width:calc(15px + var(--dsh-content-font-delta,0px));height:calc(15px + var(--dsh-content-font-delta,0px))}',
+      '.dshmb_action:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}',
+      '.dshmb_action:focus-visible{outline:2px solid var(--dsw-alias-button-primary-fill,var(--dsw-alias-state-business-primary));outline-offset:2px}',
+      // Host parity: every sent message but the latest hides its strip until
+      // hover or focus, and the `data-actions-reveal` shell preference does
+      // the same globally.
+      '@media (hover:hover){',
+      '[data-actions-reveal=hover] .dshmb_actions,',
+      ':is([data-chat-flow-kind=user],[data-chat-flow-kind=steering]):has(~:is([data-chat-flow-kind=user],[data-chat-flow-kind=steering])) .dshmb_actions{opacity:0;transition:opacity 80ms}',
+      '[data-actions-reveal=hover]:hover .dshmb_actions,',
+      '[data-actions-reveal=hover]:focus-within .dshmb_actions,',
+      ':is([data-chat-flow-kind=user],[data-chat-flow-kind=steering]):has(~:is([data-chat-flow-kind=user],[data-chat-flow-kind=steering])):hover .dshmb_actions,',
+      ':is([data-chat-flow-kind=user],[data-chat-flow-kind=steering]):has(~:is([data-chat-flow-kind=user],[data-chat-flow-kind=steering])):focus-within .dshmb_actions{opacity:1}',
+      '}',
+    ].join('')
+
+    /**
+     * Inject the plugin's stylesheet once. Runs at apply time; the loader's
+     * HMR sweep removes it by `data-plugin`, dispose by tag id.
+     */
+    function injectStyles() {
+      if (typeof document === 'undefined') return
+      if (document.querySelector('style[data-plugin-css=' + JSON.stringify(CSS_TAG) + ']') !== null) return
+      const tag = document.createElement('style')
+      tag.dataset.plugin = NS
+      tag.dataset.pluginCss = CSS_TAG
+      tag.textContent = CSS
+      document.head.appendChild(tag)
+    }
+
+    /** Remove the stylesheet this plugin injected, if still present. */
+    function removeStyles() {
+      if (typeof document === 'undefined') return
+      const tag = document.querySelector('style[data-plugin-css=' + JSON.stringify(CSS_TAG) + ']')
+      if (tag !== null) tag.remove()
+    }
+
+    // --- plugin -----------------------------------------------------------------
+
+    /**
+     * Browser plugin body: inject the stylesheet and shadow the two sent-text
+     * chat seats for as long as this fiber lives. Disposal (or an uninstall)
+     * restores the host's own renderers.
+     * @param ctx - client cordis context (slots and locale by injection).
+     */
+    function apply(ctx) {
+      injectStyles()
+      for (const key of SEATS) {
+        ctx.slots.inject('conversation.chat.node', () =>
+          ctx.slots.register(
+            {
+              name: 'conversation.chat.node',
+              key,
+              priority: SEAT_PRIORITY,
+              locale: 'chat',
+            },
+            MarkdownBubbleSeat,
+          ),
+        )
+      }
+
+      globalThis[DEBUG_KEY] = { version: PLUGIN_VERSION, seats: SEATS.slice() }
+
+      ctx.effect(
+        () => () => {
+          delete globalThis[DEBUG_KEY]
+          removeStyles()
+        },
+        NS + ': lifecycle',
+      )
+    }
+
+    exports.apply = apply
+    exports.inject = ['slots', 'locale']
+    exports.PLUGIN_VERSION = PLUGIN_VERSION
+    exports.SEATS = SEATS
+    exports.SEAT_PRIORITY = SEAT_PRIORITY
+    exports.toMarkdown = toMarkdown
+    exports.preserveHardBreaks = preserveHardBreaks
+    exports.unwrapSessionReferences = unwrapSessionReferences
+    exports.contentParts = contentParts
+    exports.composeUserMarkdown = composeUserMarkdown
+    exports.MarkdownBubbleSeat = MarkdownBubbleSeat
+    return module.exports
+  },
+})

package/src/index.js

@@ -0,0 +1,30 @@
+/**
+ * dsh-markdown-bubble — host half.
+ *
+ * The plugin has no host-side behavior: a sent message's bubble is drawn by
+ * the browser's chat view, and how it renders is a client-side projection of
+ * the same text the drawer already receives. The host row exists so the
+ * package is mounted by the Loader — the client-module scanner scans Loader
+ * entries for packages declaring `dsh.client` — and so the bundle patch has a
+ * row id to insert.
+ *
+ * @module dsh-markdown-bubble
+ */
+
+/** Stable plugin id (matches the bundle patch's insert id and the client module id). */
+export const PLUGIN_ID = 'dsh-markdown-bubble'
+
+/** Keep in sync with package.json and src/client.js. */
+export const PLUGIN_VERSION = '0.1.1'
+
+/** Cordis plugin name; the bundle patch resolves the package by this row. */
+export const name = PLUGIN_ID
+
+/** Services the inert entry needs: none. */
+export const inject = []
+
+/**
+ * Inert apply: the browser half owns every behavior.
+ * @param {import('@deepseek-ai/cordis').Context} _ctx - owning context.
+ */
+export function apply(_ctx) {}