dsh-better-display 0.3.7 → 0.3.9

package/src/reveal.ts

@@ -0,0 +1,90 @@
+import { spawn, type SpawnOptions } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { posix, win32 } from 'node:path';
+import type { Context } from '@deepseek-ai/cordis';
+import { isAbsoluteWorkspacePath } from './workspace-path.js';
+
+export async function revealRoots(ctx: Context, sessionId: string | undefined): Promise<readonly string[]> {
+  if (sessionId !== undefined) {
+    const sessions = ctx.get?.('sessions') as { get: (id: string) => { header: { cwd?: string } } | undefined } | undefined;
+    const cwd = sessions?.get(sessionId)?.header.cwd;
+    if (cwd) return [cwd];
+    const query = ctx.get?.('sessionQuery') as {
+      observeSession: (id: string, options: { projectionMode: 'none' }) => Promise<{ header: { cwd?: string } } & Disposable>;
+    } | undefined;
+    if (query) {
+      using observation = await query.observeSession(sessionId, { projectionMode: 'none' });
+      if (observation.header.cwd) return [observation.header.cwd];
+    }
+  }
+  const registry = ctx.get?.('workspaceRegistry') as {
+    list: () => readonly { path: string; sessionIds: readonly string[] }[];
+  } | undefined;
+  return (registry?.list() ?? [])
+    .filter(workspace => sessionId === undefined || workspace.sessionIds.includes(sessionId))
+    .map(workspace => workspace.path);
+}
+
+export function resolveRevealPath(path: string, roots: readonly string[], exists = existsSync): string {
+  if (isAbsoluteWorkspacePath(path)) return path;
+  // Drive-relative and root-relative Windows paths do not identify a workspace.
+  if (/^[A-Za-z]:|^\\/.test(path)) throw new Error('Path is not workspace-relative');
+  const matches = new Set<string>();
+  for (const root of roots) {
+    if (!isAbsoluteWorkspacePath(root)) continue;
+    const paths = /^[A-Za-z]:[/\\]|^\\\\/.test(root) ? win32 : posix;
+    const candidate = paths.resolve(root, path);
+    if (exists(candidate)) matches.add(candidate);
+  }
+  if (matches.size !== 1) throw new Error(matches.size === 0 ? 'Workspace path not found' : 'Workspace path is ambiguous');
+  return [...matches][0];
+}
+
+export function revealPath(
+  path: string,
+  platform = process.platform,
+  spawnProcess: (command: string, args: string[], options: SpawnOptions) => unknown = spawn,
+): void {
+  const options = { detached: true, stdio: 'ignore' } satisfies SpawnOptions;
+  if (platform === 'darwin') {
+    spawnProcess('open', ['-R', path], options);
+  } else if (platform === 'win32') {
+    spawnProcess('explorer.exe', [`/select,"${path}"`], { ...options, windowsVerbatimArguments: true });
+  } else {
+    spawnProcess('xdg-open', [path], options);
+  }
+}
+
+export function createRevealHandler({ roots, reveal = revealPath }: {
+  roots: (sessionId: string | undefined) => Promise<readonly string[]>;
+  reveal?: (path: string) => void;
+}): (req: IncomingMessage, res: ServerResponse) => void {
+  return (req, res) => {
+    if (req.method !== 'POST') {
+      res.statusCode = 405;
+      res.end();
+      return;
+    }
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', async () => {
+      res.setHeader('Content-Type', 'application/json');
+      try {
+        const data: unknown = JSON.parse(body);
+        const path = typeof data === 'object' && data !== null && 'path' in data && typeof data.path === 'string'
+          ? data.path.trim() : '';
+        if (!path) throw new Error('Empty path');
+        const sessionId = typeof data === 'object' && data !== null && 'sessionId' in data && typeof data.sessionId === 'string'
+          ? data.sessionId : undefined;
+        const targetPath = resolveRevealPath(path, isAbsoluteWorkspacePath(path) ? [] : await roots(sessionId));
+        reveal(targetPath);
+        res.statusCode = 200;
+        res.end(JSON.stringify({ ok: true }));
+      } catch (err) {
+        res.statusCode = 400;
+        res.end(JSON.stringify({ ok: false, error: String(err) }));
+      }
+    });
+  };
+}

package/src/workspace-path.ts

@@ -0,0 +1,4 @@
+/** Absolute paths accepted by both POSIX and Windows hosts. */
+export function isAbsoluteWorkspacePath(path: string): boolean {
+  return /^(?:\/|[A-Za-z]:[/\\]|\\\\)/.test(path);
+}

package/tests/browser-commentary.tsx

@@ -0,0 +1,191 @@
+import React, { useSyncExternalStore } from 'react';
+import { createRoot } from 'react-dom/client';
+import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
+import { Reader } from '../src/client/Reader.js';
+import { createReaderStore } from '../src/client/store.js';
+import type { ReaderProps } from '../src/client/types.js';
+
+/**
+ * Real Reader + real root/session stores; only conversation data is synthetic.
+ *
+ * This fixture isolates the "process report narration" bug: an assistant step
+ * that carries a long non-reasoning text block (正文) between thinking steps used
+ * to be classified as process content and folded away. Contract under test:
+ * body text is always visible; folds may only hold reasoning / tool / other
+ * process records.
+ *
+ * Turn layout:
+ *   1  closed/completed : step0 = reasoning + 正文A + tool-call ; step1 = reasoning + 最终回答B
+ *   2  open             : step0 = reasoning + 进行中汇报正文C ; step1 = reasoning (latest)
+ *   3  closed/error     : step0 = reasoning + 失败轮正文D
+ *   4  closed/interrupted: step0 = reasoning + 中断轮正文E
+ */
+const BODY_A = '过程汇报正文A';
+const REASON_A = '历史思考：先查简报素材';
+const FINAL_B = '最终回答B';
+const REASON_B = '第二次思考：整理结论';
+const TOOL_SUMMARY = '读取 简报素材.txt';
+const BODY_C = '进行中汇报正文C';
+const REASON_C0 = '第一轮思考';
+const REASON_C1 = '第二轮思考';
+const BODY_D = '失败轮正文D';
+const REASON_D = '报错前的思考';
+const BODY_E = '中断轮正文E';
+const REASON_E = '中断前的思考';
+// Turn 5 exercises the segmented-report case: two adjacent narration paragraphs
+// (with folded reasoning between them) plus a final answer, all with long text.
+const BODY_F = '第一段汇报：已完成需求梳理，确认改造点集中在投影层与阅读渲染层。这一步整理的是已经核实的事实，不包括猜测。\n\n第二段汇报：接下来核对折叠链边界，并验证正文在收起状态下仍然可见，同时保持思维链与工具行可以展开。';
+const REASON_F0 = '汇报前的思考';
+const BODY_G = '补充汇报：折叠只保留思维链与工具调用，正文块保持原位。';
+const REASON_G = '补充说明前的思考';
+const REASON_H = '收尾思考';
+const FINAL_H = '最终回答H';
+const TOOL_CALL_ID = 'call-read-1';
+const TOOL_ARGS = '{"path":"/fixture/工作区/简报素材.txt"}';
+
+const store = createReaderStore();
+const prefs = store.create();
+const session = store.create('commentary-fixture');
+
+type Turn = {
+  turn: number; status: 'open' | 'closed';
+  start: { seq: number; time: number };
+  end?: { time: number; data: { reason: { kind: string } } };
+  data: Map<string, any>;
+  steps: any[];
+};
+const nodes = new Map<string, any>();
+const turns = new Map<number, Turn>();
+
+function newTurn(turn: number, status: 'open' | 'closed', seq: number, reason?: string): Turn {
+  const value: Turn = {
+    turn, status, start: { seq, time: 1 },
+    end: status === 'closed' ? { time: 1001, data: { reason: { kind: reason ?? 'completed' } } } : undefined,
+    data: new Map<string, any>(),
+    steps: [],
+  };
+  turns.set(turn, value);
+  return value;
+}
+
+function addStep(turnNumber: number, step: number, seq: number, status: string, blocks: any[]): any {
+  const turn = turns.get(turnNumber)!;
+  const data = { turn: turnNumber, step, status, time: 1, blocks };
+  const location = { step, start: { seq }, data: new Map([['assistant-step', data]]) };
+  turn.steps.push(location);
+  nodes.set(`turn-${turnNumber}-step-${step}`, {
+    key: `turn-${turnNumber}-step-${step}`, kind: 'assistant-step', visibility: 'visible',
+    anchorSeq: seq, location: { kind: 'step', turn, step: location }, data,
+  });
+  return location;
+}
+
+function addToolCallNode(turnNumber: number, key: string, seq: number, location: any, callId: string, argsRaw: string): void {
+  const turn = turns.get(turnNumber)!;
+  const root = {
+    kind: 'tool-result', seq, time: 1, callId,
+    call: { name: 'read', argsRaw }, callTime: 1,
+    content: [{ kind: 'text', text: '简报素材的摘录内容' }], isError: false, subCalls: [],
+  };
+  nodes.set(key, {
+    key, kind: 'tool-call', visibility: 'visible', anchorSeq: seq,
+    location: { kind: 'step', turn, step: location }, data: { root },
+  });
+}
+
+// --- turn 1: completed; narration sits between reasoning and the final answer.
+const turn1 = newTurn(1, 'closed', 100);
+turn1.data.set('turn-tail', { closing: { step: 1 } });
+const t1s0 = addStep(1, 0, 101, 'settled', [
+  { kind: 'reasoning', text: REASON_A },
+  { kind: 'text', text: BODY_A },
+  { kind: 'tool-call', callId: TOOL_CALL_ID, name: 'read', argsRaw: TOOL_ARGS },
+]);
+addToolCallNode(1, 'turn-1-tool-call-1', 102, t1s0, TOOL_CALL_ID, TOOL_ARGS);
+addStep(1, 1, 103, 'settled', [
+  { kind: 'reasoning', text: REASON_B },
+  { kind: 'text', text: FINAL_B },
+]);
+
+// --- turn 2: open; second reasoning arrives after a process report.
+const turn2 = newTurn(2, 'open', 200);
+addStep(2, 0, 201, 'settled', [
+  { kind: 'reasoning', text: REASON_C0 },
+  { kind: 'text', text: BODY_C },
+]);
+addStep(2, 1, 202, 'running', [
+  { kind: 'reasoning', text: REASON_C1 },
+]);
+
+// --- turn 3: failed turn; nothing may fold.
+newTurn(3, 'closed', 300, 'error');
+addStep(3, 0, 301, 'settled', [
+  { kind: 'reasoning', text: REASON_D },
+  { kind: 'text', text: BODY_D },
+]);
+
+// --- turn 4: interrupted turn; nothing may fold.
+newTurn(4, 'closed', 400, 'interrupted');
+addStep(4, 0, 401, 'settled', [
+  { kind: 'reasoning', text: REASON_E },
+  { kind: 'text', text: BODY_E },
+]);
+
+// --- turn 5: completed turn whose report is split into two narration paragraphs
+// with folded reasoning between them; the rail must bridge them after collapsing.
+const turn5 = newTurn(5, 'closed', 500);
+turn5.data.set('turn-tail', { closing: { step: 2 } });
+addStep(5, 0, 501, 'settled', [
+  { kind: 'reasoning', text: REASON_F0 },
+  { kind: 'text', text: BODY_F },
+]);
+addStep(5, 1, 502, 'settled', [
+  { kind: 'reasoning', text: REASON_G },
+  { kind: 'text', text: BODY_G },
+]);
+addStep(5, 2, 503, 'settled', [
+  { kind: 'reasoning', text: REASON_H },
+  { kind: 'text', text: FINAL_H },
+]);
+
+const chat = {
+  order: [
+    'turn-1-step-0', 'turn-1-tool-call-1', 'turn-1-step-1',
+    'turn-2-step-0', 'turn-2-step-1',
+    'turn-3-step-0', 'turn-4-step-0',
+    'turn-5-step-0', 'turn-5-step-1', 'turn-5-step-2',
+  ],
+  nodes,
+  timeline: { turns },
+} as unknown as ChatSnapshot;
+const sessionSnapshot = { running: true, openState: 'ready', pendingSubmissions: [], hasMore: false, loadingOlder: false };
+const sessionsSnapshot = { byId: { 'commentary-fixture': { cwd: '/fixture' } } };
+const pending = new Map();
+const host = { home: '/fixture' };
+const useReaderStore: ReaderProps['useStore'] = selector => selector(useSyncExternalStore(session.subscribe, session.getSnapshot));
+const props = {
+  sessionId: 'commentary-fixture', useChat: selector => selector(chat),
+  useSession: selector => selector(sessionSnapshot), useSessions: selector => selector(sessionsSnapshot),
+  useSessionStatus: selector => selector(new Map([['commentary-fixture', { running: true, pendingInteraction: pending.get('commentary-fixture'), completionUnread: false }]])),
+  useStore: useReaderStore, actions: session.actions, openPrefs: prefs,
+  t: key => key, renderSlot: (_name: string, _owner: any, options: any) => options?.fallback ?? null,
+  renderSlotChain: (_name: string, _owner: any, options: any) => options?.fallback ?? null,
+  loadImage: async () => ({ data: new Uint8Array(), mediaType: 'image/png' }),
+  officialImageLoader: Object.assign(async () => null, { peek: () => null }),
+  officialFileMentions: () => undefined, officialPreviewFile: () => {},
+  officialHost: { getSnapshot: () => host, subscribe: () => () => {} },
+  fillComposer: () => true, openFile: () => {}, loadOlder: async () => {}, openView: () => {},
+} as unknown as ReaderProps;
+
+Object.assign(window, {
+  commentaryFixture: {
+    // Exercise the same root preference the Settings panel uses.
+    preference: (value: boolean) => prefs.actions.setAutoFold(value),
+    state: () => session.getSnapshot(),
+    text: { BODY_A, REASON_A, FINAL_B, REASON_B, TOOL_SUMMARY, BODY_C, REASON_C0, REASON_C1, BODY_D, REASON_D, BODY_E, REASON_E, BODY_F, REASON_F0, BODY_G, REASON_G, REASON_H, FINAL_H, TOOL_CALL_ID },
+  },
+});
+
+createRoot(document.getElementById('app')!).render(
+  <div data-conversation-scroll style={{ height: '100vh', overflow: 'auto' }}><Reader {...props} /></div>,
+);

package/tests/chat-flow-hook.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { fileURLToPath } from 'node:url';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');

package/tests/cloud-gate.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { accessSync, constants, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';

package/tests/context-tool-update.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { toolUpdateRows } from '../src/client/native/tool-update.js';
 
 test('a single tool addition is its own closed row', () => {

package/tests/conversation-scroll.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { flowTop, landTurn, READING_LINE_OFFSET_PX, scrollerOf } from '../src/client/conversation-scroll.ts';
 

package/tests/deliverables.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import type { TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import { basename, createProducedFileMentions, dirname, getTurnDeliverables, showDeliverablesRow } from '../src/client/deliverables.ts';

package/tests/entry.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { ReaderEntryPolicy, readerEntryRequested } from '../src/client/entry-policy.js';
 
 test('fresh sessions default to reading, without requiring a special URL', () => {

package/tests/fixtures/reader-lane-owners.tsx

@@ -0,0 +1,46 @@
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { StickyLane, usePublishedHeight } from '../../src/client/StickyLane.js';
+
+function Measured({ id, property, height }: { id: string; property: string; height: number }) {
+  const ref = usePublishedHeight(property);
+  return <div ref={ref} id={id} style={{ height }}>{id}</div>;
+}
+
+function SummaryReader({ id, height, show }: { id: string; height: number; show: boolean }) {
+  return <div data-dsh-better-display={id} id={`root-${id}`}>
+    <section data-reader-turn="1" id={`turn-${id}`}>
+      {show && <Measured id={`row-${id}`} property="--reader-summary-height" height={height} />}
+    </section>
+  </div>;
+}
+
+function App() {
+  const [height, setHeight] = useState(52);
+  const [show, setShow] = useState(true);
+  return <>
+    <button id="grow" type="button" onClick={() => setHeight(86)}>grow</button>
+    <button id="drop" type="button" onClick={() => setShow(false)}>drop</button>
+    <SummaryReader id="a" height={height} show={show} />
+    <SummaryReader id="b" height={52} show />
+    <div data-dsh-better-display="short" id="root-short">
+      <section data-reader-turn="1" id="turn-short">
+        <Measured id="row-short" property="--reader-status-height" height={38} />
+      </section>
+    </div>
+    <div data-dsh-better-display="toolbar" id="root-toolbar">
+      <StickyLane kind="toolbar" className="toolbarProbe">
+        <button id="toolbar-button" type="button" style={{ height: 12, padding: 0, border: 0 }}>开</button>
+      </StickyLane>
+    </div>
+    <div data-dsh-better-display="status" id="root-status">
+      <section data-reader-turn="1" id="turn-status">
+        <StickyLane kind="status" className="statusProbe">
+          <span style={{ display: 'block', height: 12 }}>用时</span>
+        </StickyLane>
+      </section>
+    </div>
+  </>;
+}
+
+createRoot(document.getElementById('app')!).render(<App />);

package/tests/fixtures/reader-official-users.tsx

@@ -0,0 +1,234 @@
+import { Context } from '@deepseek-ai/cordis';
+import * as React from 'react';
+import * as Primitives from '@deepseek-ai/dsh-client-ui-primitives';
+import { createRoot } from 'react-dom/client';
+import { flushSync } from 'react-dom';
+import { SlotRegistry } from '@fixture/registry';
+import { createSlotRenderer } from '@fixture/renderer';
+import { Reader } from '../../src/client/Reader.js';
+import { createReaderStore } from '../../src/client/store.js';
+import { installOfficialSlots, officialChildren, OFFICIAL_SEATS } from '../../src/client/official-slots.js';
+import type { ReaderProps } from '../../src/client/types.js';
+
+// Real Reader, registry, scope binding and slot renderer. Only session data is synthetic.
+function equal(actual: unknown, expected: unknown) {
+  if (!Object.is(actual, expected)) throw new Error(`Expected ${String(expected)}, got ${String(actual)}`);
+}
+const assert = {
+  equal,
+  ok(value: unknown) { equal(Boolean(value), true); },
+  deepEqual(actual: unknown, expected: unknown) { equal(JSON.stringify(actual), JSON.stringify(expected)); },
+};
+async function verify() {
+  const root = new Context();
+  await root.plugin(SlotRegistry);
+  let run = async () => {};
+  await root.plugin({ name: 'reader-user-test', inject: ['slots'], async apply(ctx: Context) {
+    const slots = ctx.slots as any;
+    slots.install(createSlotRenderer());
+    const source = <T,>(value: T) => ({ getSnapshot: () => value, subscribe: () => () => {} });
+    const binding = { key: 'session-users', ctx: new Context(), hooks: {}, keyedHooks: {}, props: { sessionId: 'session-users' } };
+    slots.installScope('session', {
+      current: source(binding), bindingSource: () => source(binding), renderArea: (_: unknown, props: any) => props.children,
+    });
+    slots.installLocale({ ...source({}), bind: () => (key: string) => key });
+    const turn = { turn: 1, status: 'closed', start: { seq: 1, time: 1 },
+      end: { time: 2, data: { reason: { kind: 'completed' } } }, data: new Map(), steps: [] };
+    const nodes = new Map(['user', 'steering', 'hidden'].map((kind, index) => {
+      const key = `${kind}-key`;
+      return [key, { key, kind: kind === 'hidden' ? 'user' : kind, anchorSeq: index + 1,
+        visibility: kind === 'hidden' ? 'hidden' : 'visible', location: { kind: 'turn', turn },
+        data: { seq: index + 1, time: 1, content: [{ type: 'text', text: `${kind} content` }] } }];
+    }));
+    const chat = { order: [...nodes.keys()], nodes, timeline: { turns: new Map([[1, turn]]) } };
+    const session = { running: false, openState: 'ready', pendingSubmissions: [], hasMore: false, loadingOlder: false };
+    const store = createReaderStore().create('session-users');
+    const props = {
+      sessionId: 'session-users', useChat: (select: any) => select(chat),
+      useSession: (select: any) => select(session), useSessions: (select: any) => select({ byId: { 'session-users': { cwd: '/fixture' } } }),
+      useSessionStatus: (select: any) => select(new Map()), useStore: (select: any) => select(store.getSnapshot()), actions: store.actions,
+      t: (key: string) => key, loadImage: async () => ({ data: new Uint8Array(), mediaType: 'image/png' }),
+      officialImageLoader: Object.assign(async () => null, { peek: () => null }),
+      officialFileMentions: () => undefined, officialPreviewFile: () => {},
+      officialHost: source({ home: '/fixture' }), fillComposer: () => true,
+      openFile: () => {}, loadOlder: async () => {}, openView: () => {},
+    };
+    slots.register({ name: 'root', children: {
+      'conversation.chat.node': { kind: 'keyed', scope: 'session', inject: { hooks: {
+        turnData: (_: unknown, context: any) => () => context.turnData,
+        disclosure: (_: unknown, context: any) => () => context.disclosureReset,
+      } } },
+      'fixture.reader': { kind: 'single', scope: 'session' },
+    } }, ({ SessionProvider, renderSlot }: any) => <SessionProvider>{renderSlot('fixture.reader', {})}</SessionProvider>);
+    slots.register({ name: 'fixture.reader', children: { ...officialChildren(slots), 'dsh-better-display.block': { kind: 'chain', scope: 'session' } } }, ({ renderSlot, renderSlotChain }: any) =>
+      <Reader {...{ ...props, renderSlot, renderSlotChain } as ReaderProps} />);
+    const stopMirror = installOfficialSlots(ctx);
+    run = async () => {
+      const container = document.getElementById('app')!;
+      const reactRoot = createRoot(container);
+      const render = () => {
+        flushSync(() => reactRoot.render(slots.renderSlot('root', {})));
+        return container.innerHTML;
+      };
+      const count = (html: string, text: string) => html.split(text).length - 1;
+      const assertSeats = (html: string) => {
+        for (const kind of ['user', 'steering']) {
+          assert.equal(count(html, `data-reader-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-anchor-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-flow-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-node-key="${kind}-key"`), 1);
+          assert.equal(count(html, `data-chat-flow-kind="${kind}"`), 1);
+        }
+        assert.equal(count(html, 'data-reader-anchor="true"'), 2);
+        assert.ok(!html.includes('hidden content'));
+      };
+
+      // The real renderSlot returns an outlet element for an unoccupied key.
+      let html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.ok(html.includes('补充消息'));
+      const seen: any[] = [];
+      const official = ({ node, sessionId, injectedSession, useTurnData, useDisclosure }: any) => {
+        assert.equal(sessionId, 'session-users');
+        assert.equal(injectedSession, 'session-users');
+        assert.equal(useTurnData(), turn.data);
+        assert.equal(useDisclosure().getSnapshot(), 0);
+        assert.equal(node, nodes.get(node.key));
+        seen.push(node.kind);
+        return <div data-official-user={node.kind}>{node.data.content[0].text}<button>Official recall</button></div>;
+      };
+      const removeUser = slots.register({ name: 'conversation.chat.node', key: 'user',
+        inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
+      const removeSteering = slots.register({ name: 'conversation.chat.node', key: 'steering',
+        inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
+      const removeAssistant = slots.register({ name: 'conversation.chat.node', key: 'assistant-step' }, () => <span>Duplicate assistant</span>);
+      await new Promise(resolve => queueMicrotask(resolve));
+      assert.deepEqual(slots.entriesOfSlot(OFFICIAL_SEATS.nodes).map((entry: any) => entry.options.key).sort(), ['steering', 'user']);
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'Official recall'), 2);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.deepEqual(seen, ['user', 'steering']);
+
+      // A winner intentionally returning null must keep its row hidden.
+      const removeWinner = slots.register({ name: 'conversation.chat.node', key: 'user', priority: -1 }, () => null);
+      await new Promise(resolve => queueMicrotask(resolve));
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 0);
+      assert.equal(count(html, 'Official recall'), 1);
+      removeWinner();
+      await new Promise(resolve => queueMicrotask(resolve));
+      assert.equal(count(render(), 'Official recall'), 2);
+      removeUser(); removeSteering(); removeAssistant();
+      await new Promise(resolve => queueMicrotask(resolve));
+      html = render();
+      assertSeats(html);
+      assert.equal(count(html, 'user content'), 1);
+      assert.equal(count(html, 'steering content'), 1);
+      assert.equal(count(html, 'Official recall'), 0);
+
+      // A priority below the official assistant renderer is a replacement.
+      // Reader keeps the reasoning card and hands only the body blocks over.
+      const assistant = {
+        key: 'assistant-key', kind: 'assistant-step', anchorSeq: 4, visibility: 'visible',
+        location: { kind: 'turn', turn },
+        data: {
+          status: 'settled', turn: 1, step: 0, time: 3,
+          blocks: [
+            { kind: 'reasoning', text: 'think privately' },
+            { kind: 'text', text: '<div id="vcp-root">card face</div>' },
+          ],
+        },
+      };
+      // Reader memoizes on the order array and the nodes map. A real host
+      // publishes new references; this fixture has to do the same.
+      chat.nodes = new Map(chat.nodes);
+      chat.nodes.set('assistant-key', assistant);
+      chat.order = [...chat.order, 'assistant-key'];
+      store.actions.setExpanded('turn:1:closed:completed', true);
+      html = render();
+      assert.equal(count(html, 'data-foreign-assistant'), 0);
+      assert.ok(html.includes('vcp-root'));
+      assert.ok(html.includes('think privately'));
+      const calls: Array<{ groupPart: unknown; kinds: string[]; text: string }> = [];
+      const Foreign = (props: { groupPart?: unknown; node?: { data?: { blocks?: Array<{ kind: string; text?: string }> } } }) => {
+        const blocks = props.node?.data?.blocks ?? [];
+        calls.push({
+          groupPart: props.groupPart,
+          kinds: blocks.map(block => block.kind),
+          text: blocks.map(block => block.text ?? '').join('\n'),
+        });
+        const body = blocks.filter(block => block.kind === 'text').map(block => block.text ?? '').join('\n');
+        return <div data-foreign-assistant>{body}</div>;
+      };
+      const removeOfficialAssistant = slots.register({ name: 'conversation.chat.node', key: 'assistant-step' }, () => <span>Official assistant</span>);
+      const removeForeign = slots.register({ name: 'conversation.chat.node', key: 'assistant-step', priority: -10 }, Foreign);
+      await new Promise(resolve => queueMicrotask(resolve));
+      assert.ok(slots.entriesOfSlot(OFFICIAL_SEATS.nodes).some((entry: { options: { key?: string; priority?: number } }) => entry.options.key === 'assistant-step' && entry.options.priority === -10));
+      html = render();
+      const answer = container.querySelector('[data-reader-body]');
+      assert.ok(answer);
+      assert.equal(answer!.querySelectorAll('[data-foreign-assistant]').length, 1);
+      assert.ok(answer!.textContent?.includes('<div id="vcp-root">card face</div>'));
+      assert.equal(answer!.querySelectorAll('pre').length, 0);
+      assert.equal(count(html, 'Official assistant'), 0);
+      assert.ok(calls.some(call => call.groupPart === 'response' && call.kinds.join(',') === 'text' && call.text.includes('vcp-root')));
+      assert.ok(calls.every(call => !call.kinds.includes('reasoning')));
+      const reasoning = container.querySelector('[data-reader-text-kind="reasoning"]');
+      assert.ok(reasoning);
+      assert.ok(reasoning!.textContent?.includes('think privately'));
+      assert.equal(reasoning!.querySelectorAll('[data-foreign-assistant]').length, 0);
+      removeForeign();
+      removeOfficialAssistant();
+      await new Promise(resolve => queueMicrotask(resolve));
+      html = render();
+      assert.equal(count(html, 'data-foreign-assistant'), 0);
+      assert.ok(html.includes('vcp-root'));
+      assert.ok(html.includes('think privately'));
+      chat.nodes = new Map(chat.nodes);
+      chat.nodes.delete('assistant-key');
+      chat.order = chat.order.filter((key: string) => key !== 'assistant-key');
+      store.actions.setExpanded('turn:1:closed:completed', false);
+
+      const module = Reflect.get(window, 'easyrewriteModule');
+      if (module) {
+        const plugin = module.factory((name: string) => {
+          if (name === 'react') return React;
+          if (name === '@deepseek-ai/dsh-client-ui-primitives') return Primitives;
+          throw new Error(`Unexpected easyrewrite dependency: ${name}`);
+        });
+        const disposers: Array<() => void> = [];
+        plugin.apply({
+          effect: (effect: () => () => void) => disposers.push(effect()),
+          slots: {
+            inject: (key: string, effect: () => () => void) => key === 'conversation.chat.node' ? effect() : () => {},
+            register: (options: object, component: unknown) => slots.register(options, component),
+          },
+          sessions: { list: source({ current: 'session-users' }), scope: () => ({ get: () => undefined }) },
+          workspaces: {},
+        });
+        await new Promise(resolve => queueMicrotask(resolve));
+        html = render();
+        assertSeats(html);
+        assert.equal(count(html, 'data-dsh-easyrewrite="user"'), 1);
+        assert.equal(count(html, 'data-dsh-easyrewrite="recall-key"'), 1);
+        assert.equal(count(html, 'user content'), 1);
+        assert.equal(count(html, 'steering content'), 1);
+        const recall = container.querySelector<HTMLButtonElement>('[data-dsh-easyrewrite="recall-key"]');
+        assert.ok(recall);
+        flushSync(() => recall!.click());
+        assert.equal(container.querySelectorAll('[data-dsh-easyrewrite="confirm-capsule"]').length, 1);
+        for (const dispose of disposers) dispose();
+      }
+      stopMirror();
+      reactRoot.unmount();
+      Object.assign(window, { readerUserResult: 'passed' });
+    };
+  } });
+  await run();
+}
+verify().catch(error => { console.error(error); Object.assign(window, { readerUserResult: `${error.stack}\n${document.getElementById('app')?.innerHTML}` }); });