@drscrewdriver/dsh-better-display 0.3.3-fork.1

package/tests/timeline.test.ts

@@ -0,0 +1,59 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mergeTimelineItems } from '../src/client/timeline.ts';
+
+test('mergeTimelineItems handles empty inputs gracefully', () => {
+  assert.deepEqual(mergeTimelineItems([], undefined), []);
+  assert.deepEqual(mergeTimelineItems([], []), []);
+  assert.deepEqual(mergeTimelineItems(undefined, null), []);
+});
+
+test('mergeTimelineItems parses and normalizes wire turn outline entries', () => {
+  const outline = [
+    { turn: 1, seq: 10, prompt: 'Hello world', response: 'Hi there' },
+    { turn: 2, seq: 25, prompt: 'Fix the bug', response: 'Fixed' },
+    { turn: 'invalid', seq: 30 }, // should be ignored
+    null,
+    { turn: 0, seq: 1, prompt: '', response: '' },
+  ];
+
+  const items = mergeTimelineItems([], outline);
+  assert.equal(items.length, 3);
+  assert.equal(items[0].turn, 0);
+  assert.equal(items[1].turn, 1);
+  assert.equal(items[1].prompt, 'Hello world');
+  assert.equal(items[1].anchor.kind, 'unloaded');
+  if (items[1].anchor.kind === 'unloaded') {
+    assert.equal(items[1].anchor.seq, 10);
+  }
+  assert.equal(items[2].turn, 2);
+});
+
+test('mergeTimelineItems prioritizes loaded anchors and preserves deliverable flags', () => {
+  const outline = [
+    { turn: 1, seq: 10, prompt: 'Outline prompt', response: 'Outline reply' },
+    { turn: 2, seq: 20, prompt: 'Turn 2 prompt', response: '' },
+  ];
+
+  const loaded = [
+    { turn: 1, anchorKey: 'node-turn-1', prompt: 'Loaded prompt 1', response: 'Loaded reply 1' },
+  ];
+
+  const deliverables = new Set([1]);
+  const items = mergeTimelineItems(loaded, outline, deliverables);
+
+  assert.equal(items.length, 2);
+  // Turn 1 should be loaded anchor with freshest prompt & hasDeliverables = true
+  assert.equal(items[0].turn, 1);
+  assert.equal(items[0].anchor.kind, 'loaded');
+  if (items[0].anchor.kind === 'loaded') {
+    assert.equal(items[0].anchor.key, 'node-turn-1');
+  }
+  assert.equal(items[0].prompt, 'Loaded prompt 1');
+  assert.equal(items[0].hasDeliverables, true);
+
+  // Turn 2 is still unloaded
+  assert.equal(items[1].turn, 2);
+  assert.equal(items[1].anchor.kind, 'unloaded');
+  assert.equal(items[1].hasDeliverables, false);
+});

package/tests/tool-diff.test.ts

@@ -0,0 +1,57 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { callDiffHunks, DIFF_FALLBACK_TOOLS, diffTotals } from '../src/client/tool-activity.ts';
+import type { ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
+
+test('diff argument fallback is whitelisted to write/edit/str_replace_editor', () => {
+  assert.deepEqual([...DIFF_FALLBACK_TOOLS], ['write', 'edit', 'str_replace_editor']);
+});
+
+test('meta.diffs wins; memory-like content fields do not invent counts', () => {
+  const fromMeta = callDiffHunks({
+    kind: 'tool-result',
+    callId: 'w1',
+    time: 1,
+    callTime: 0,
+    content: [],
+    isError: false,
+    meta: { diffs: [{ path: 'a.ts', oldText: 'old\n', newText: 'new\nline\n' }] },
+    call: { name: 'write', argsRaw: '{"path":"a.ts","content":"ignored"}' },
+    subCalls: [],
+  } as unknown as ToolCallBlock, { path: 'a.ts', content: 'ignored' }, 'write');
+  assert.equal(fromMeta.length, 1);
+  assert.equal(fromMeta[0]?.path, 'a.ts');
+
+  const note = callDiffHunks(undefined, { content: 'line1\nline2\nline3\nline4\nline5' }, 'memory_note_pre');
+  assert.deepEqual(note, []);
+  assert.equal(diffTotals(undefined, { content: 'a\nb\nc' }, 'memory_note_pre'), null);
+});
+
+test('write/edit/str_replace_editor fall back to arguments; parent rolls up subCalls', () => {
+  const write = callDiffHunks(undefined, { path: 'src/a.ts', content: 'one\ntwo\n' }, 'write');
+  assert.equal(write.length, 1);
+  assert.equal(write[0]?.path, 'src/a.ts');
+
+  const parent = callDiffHunks({
+    kind: 'tool-result',
+    callId: 'run',
+    time: 1,
+    callTime: 0,
+    content: [],
+    isError: false,
+    meta: {},
+    call: { name: 'run_code', argsRaw: '{}' },
+    subCalls: [{
+      kind: 'tool-result',
+      callId: 'child',
+      time: 1,
+      callTime: 0,
+      content: [],
+      isError: false,
+      meta: {},
+      call: { name: 'edit', argsRaw: '{"path":"nested.ts","old_string":"a\\n","new_string":"b\\nc\\n"}' },
+      subCalls: [],
+    }],
+  } as unknown as ToolCallBlock, {}, 'run_code');
+  assert.equal(parent.some(hunk => hunk.path === 'nested.ts'), true);
+});

package/tests/waiting-clock.test.ts

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { HANDOVER_KINDS, handsBackToModel, WAIT_AFTER, waitingAnchor } from '../src/client/waiting-clock.js';
+
+const nodes = new Map<string, { kind: string; data: unknown }>([
+  ['u1', { kind: 'user', data: { time: 1000 } }],
+  ['s1', { kind: 'steering', data: { time: 301000 } }],
+  ['s2', { kind: 'steering', data: { time: 305000 } }],
+  ['a1', { kind: 'assistant-step', data: { time: 302000 } }],
+  ['ctx', { kind: 'context', data: { time: 399000 } }],
+  // A settled tool: the root carries its result, so control returns to the model.
+  ['tr', { kind: 'tool-call', data: { time: 61000, root: { kind: 'tool-result', callId: 'c1' } } }],
+  // A running tool: no result yet, so the tool — not the model — is working.
+  ['tc', { kind: 'tool-call', data: { time: 62000, root: { callId: 'c2', name: 'read', argsRaw: '{}' } } }],
+  // A command that already reported an outcome.
+  ['cmd', { kind: 'command', data: { time: 70000, outcome: { kind: 'success' } } }],
+  // A command that has not settled yet.
+  ['cmd-open', { kind: 'command', data: { time: 71000, outcome: null } }],
+]);
+const get = (key: string) => nodes.get(key);
+
+// The regression this guards: the handover set is matched against the CHAT layer's
+// kind union, because that is what `snapshot.nodes` holds. A conversation-layer name
+// ('tool-result') or an invented one ('tool-return') never occurs there, so the branch
+// it guards is silently dead — which is how a returned tool stopped restarting the wait.
+test('handover kinds are chat-layer kinds, verified against the host type', () => {
+  // The compile-time check lives in the `satisfies` in waiting-clock; this is the
+  // runtime echo so a cast cannot quietly defeat it.
+  for (const kind of HANDOVER_KINDS) {
+    assert.ok(WAIT_AFTER.has(kind) || kind === 'user' || kind === 'steering' || kind === 'tool-call' || kind === 'command', kind);
+  }
+});
+
+test('the conversation-layer name for a returned tool is NOT a chat kind', () => {
+  // 'tool-result' is real in the conversation contract, but the reader never sees a
+  // node with that kind: it is nested inside tool-call data. Keeping it in the set
+  // was the bug, so pin its absence.
+  assert.ok(!WAIT_AFTER.has('tool-result' as never), 'tool-result is not a chat node kind');
+  assert.ok(!WAIT_AFTER.has('tool-return' as never), 'tool-return was never a kind at all');
+  assert.ok(!WAIT_AFTER.has('command-input' as never), 'command-input is not a chat node kind');
+});
+
+test('a returned tool hands control back to the model', () => {
+  const node = get('tr')!;
+  assert.ok(handsBackToModel(node));
+  assert.deepEqual(waitingAnchor(['u1', 's1', 'tr'], get), { key: 'tr', time: 61000 });
+});
+
+test('a running tool does NOT hand control back — the tool is the one working', () => {
+  assert.ok(!handsBackToModel(get('tc')!));
+  // Falling back to the user's message: the wait keeps its earlier clock.
+  assert.deepEqual(waitingAnchor(['u1', 'tc'], get), { key: 'u1', time: 1000 });
+});
+
+test('a settled command hands over; one still executing does not', () => {
+  assert.ok(handsBackToModel(get('cmd')!));
+  assert.ok(!handsBackToModel(get('cmd-open')!));
+  assert.deepEqual(waitingAnchor(['u1', 'cmd'], get), { key: 'cmd', time: 70000 });
+  assert.deepEqual(waitingAnchor(['u1', 'cmd-open'], get), { key: 'u1', time: 1000 });
+});
+
+test('ordinary waiting starts at user input', () => assert.deepEqual(waitingAnchor(['u1'], get), { key: 'u1', time: 1000 }));
+test('steering resets a five-minute-old turn to the new input', () => assert.deepEqual(waitingAnchor(['u1', 's1'], get), { key: 's1', time: 301000 }));
+test('repeated steering resets even while the waiting indicator stays mounted', () => assert.deepEqual(waitingAnchor(['u1', 's1', 's2'], get), { key: 's2', time: 305000 }));
+
+// An assistant-step mid-turn is not a handover, so the wait keeps its earlier clock.
+test('an assistant step does not reset waiting', () => assert.deepEqual(waitingAnchor(['u1', 's1', 'a1'], get), { key: 's1', time: 301000 }));
+
+// Context injection IS a handover: the model owes the next move from that moment,
+// and the clock must not keep counting the minutes spent before it.
+test('context injection restarts the wait', () => assert.deepEqual(waitingAnchor(['u1', 's1', 'a1', 'ctx'], get), { key: 'ctx', time: 399000 }));
+
+test('local echo resets immediately before steering admission', () => assert.deepEqual(waitingAnchor(['u1'], get, [{ requestId: 'new', time: 301000, placement: 'next-step' }]), { key: 'pending:new', time: 301000 }));
+
+test('queued future turns and stale echoes cannot reset current waiting', () => {
+  assert.deepEqual(waitingAnchor(['u1', 's1'], get, [{ requestId: 'q', time: 400000, placement: 'queued' }]), { key: 's1', time: 301000 });
+  assert.deepEqual(waitingAnchor(['u1', 's1'], get, [{ requestId: 'old', time: 1000 }]), { key: 's1', time: 301000 });
+});
+
+test('missing latest timestamp falls back to a new-input clock, not old history', () => {
+  assert.deepEqual(waitingAnchor(['u1', 'bad'], key => key === 'bad' ? { kind: 'steering', data: {} } : get(key)), { key: 'bad', time: null });
+  assert.deepEqual(waitingAnchor([], get), { key: 'unresolved', time: null });
+});

package/tests/word-timeline.test.ts

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import type { Nodes } from 'mdast';
+import { WORD_MOTION, WordTimeline } from '../src/client/word-timeline.js';
+import { IncrementalMarkdownParser } from '../src/client/markdown/incremental.js';
+import { parseGfm, parseGfmWithMath } from '../src/client/markdown/parse.js';
+
+function textLeaves(node: Nodes): { value: string; offset: number }[] {
+  if (node.type === 'text') return [{ value: node.value, offset: node.position!.start.offset! }];
+  return 'children' in node ? node.children.flatMap(textLeaves) : [];
+}
+
+test('CJK resegmentation and unfinished Markdown cannot reveal later text before queued earlier text', () => {
+  for (const full of [
+    '前面的字还在排队，后面 **加粗重点** 怎么抢先出现。',
+    '前面 words waiting... [后面的链接](https://example.com) 接着文字。',
+  ]) {
+    const timeline = new WordTimeline();
+    timeline.begin('', true, 0, 0);
+    for (let end = 1; end <= full.length; end++) {
+      const now = 100 + end * 8;
+      const source = full.slice(0, end);
+      timeline.begin(source, true, 0, now);
+      const words = textLeaves(parseGfm(source)).flatMap(leaf => timeline.words(leaf.value, leaf.offset)).filter(word => word.text.trim());
+      for (let index = 1; index < words.length; index++) {
+        const previous = words[index - 1]!;
+        const current = words[index]!;
+        assert.ok((previous.born ?? -Infinity) <= (current.born ?? -Infinity), `${source}: ${JSON.stringify(previous)} overtaken by ${JSON.stringify(current)}`);
+      }
+    }
+  }
+});
+
+test('leaf render order cannot determine the order of word arrival', () => {
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin('alpha beta', true, 0, 100);
+  const later = timeline.words('beta', 6)[0]!;
+  const earlier = timeline.words('alpha', 0)[0]!;
+  assert.ok(earlier.born! <= later.born!, 'A later-rendered earlier source leaf was scheduled last');
+});
+
+test('historical and already-received prefixes never replay', () => {
+  const history = new WordTimeline();
+  history.begin('已经完成的正文。', false, 0, 100);
+  assert.equal(history.hasLiveText, false);
+  assert.ok(history.words('已经完成的正文。', 0).every(word => word.born === null));
+  const running = new WordTimeline();
+  running.begin('已经收到的部分。', true, 0, 100);
+  assert.ok(running.words('已经收到的部分。', 0).every(word => word.born === null));
+});
+
+test('only new word identities receive the stagger, and the queue stays bounded', () => {
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin('one two three four five six seven', true, 0, 100);
+  const words = timeline.words('one two three four five six seven', 0).filter(word => word.text.trim());
+  const born = words.map(word => word.born!);
+  // Every word of one batch is scheduled from the same clock, in order, and the
+  // whole batch lands inside the batch window — that is what lets a fast model's
+  // words arrive together instead of dripping out at a fixed per-word cadence.
+  assert.deepEqual(born, [...born].sort((a, b) => a - b));
+  assert.ok(born[0]! >= 100);
+  assert.ok(born.at(-1)! <= 100 + WORD_MOTION.batchMs, `batch ran past its window: ${born.at(-1)}`);
+  // A single later word keeps the original typing rhythm rather than being
+  // silently absorbed into the previous batch.
+  timeline.begin('one two three four five six seven eight', true, 0, 900);
+  const first = timeline.words('one two three', 0).filter(word => word.text.trim()).map(word => word.born);
+  assert.deepEqual(first, born.slice(0, 3));
+  const added = timeline.words('eight', 40).filter(word => word.text.trim());
+  assert.ok(added[0]!.born! >= 900, 'a lone new word must not be scheduled in the past');
+});
+
+test('stop, motion-off and authoritative replacement cancel old births', () => {
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin('原始输出', true, 0, 100);
+  assert.ok(timeline.words('原始输出', 0).some(word => word.born !== null));
+  const previous = timeline.generation;
+  timeline.begin('修正的输出', true, 1, 200);
+  assert.ok(timeline.generation > previous);
+  assert.ok(timeline.words('修正的输出', 0).every(word => word.born === null));
+  timeline.begin('修正的输出', false, 1, 300);
+  timeline.begin('修正的输出', true, 1, 300);
+  assert.ok(timeline.words('修正的输出', 0).every(word => word.born === null));
+});
+
+test('word segmentation retains all whitespace, CJK, and combined emoji', () => {
+  const text = '中文  English\n👩🏽‍💻 e\u0301 🇨🇳';
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin(text, true, 0, 100);
+  const words = timeline.words(text, 0);
+  assert.equal(words.map(word => word.text).join(''), text);
+  assert.ok(words.some(word => word.text === '👩🏽‍💻'));
+  assert.ok(words.some(word => word.text === 'e\u0301'));
+});
+
+test('animated word boxes preserve Chinese punctuation wrapping and source offsets', () => {
+  const text = '慢慢走着，看看「夜晚」与（远方）。 English, too!';
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin(' '.repeat(20) + text, true, 0, 100);
+  const words = timeline.words(text, 20);
+  assert.equal(words.map(word => word.text).join(''), text);
+  for (const word of words) assert.equal(text.slice(word.key - 20, word.key - 20 + word.text.length), word.text);
+  assert.ok(words.some(word => word.text === '着，'));
+  assert.ok(words.some(word => word.text === '「夜晚」'));
+  assert.ok(words.some(word => word.text === '（远方）。'));
+  assert.ok(words.some(word => word.text === 'English,'));
+});
+
+test('a closing mark arriving later does not restart the preceding word', () => {
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  timeline.begin('夜晚', true, 0, 100);
+  const first = timeline.words('夜晚', 0)[0];
+  timeline.begin('夜晚。', true, 0, 500);
+  const next = timeline.words('夜晚。', 0)[0];
+  assert.equal(next.key, first.key);
+  assert.equal(next.born, first.born);
+  assert.equal(next.text, '夜晚。');
+});
+
+test('incremental source offsets survive freezing and match the final parse', () => {
+  const text = '第一段。\n\n第二段 **加粗**。\n\n第三段。\n\n第四段。';
+  const parser = new IncrementalMarkdownParser(parseGfm);
+  for (let i = 1; i <= text.length; i++) parser.update(text.slice(0, i));
+  const parsed = parser.update(text);
+  const blocks = [...parsed.frozen, ...parsed.tail];
+  assert.deepEqual(blocks.map(block => block.key), parseGfm(text).children.map(node => node.position!.start.offset));
+  for (const block of blocks) {
+    const base = block.key - block.node.position!.start.offset!;
+    assert.equal(text.slice(base + block.node.position!.start.offset!, base + block.node.position!.end.offset!), text.slice(block.key, block.key + block.node.position!.end.offset! - block.node.position!.start.offset!));
+  }
+});
+
+test('the pinned DSH grammar retains CJK emphasis, GFM and math compatibility', () => {
+  const parsed = parseGfm('**加粗。**中文\n\n| 项目 | 数量 |\n| --- | --- |\n| A | 2 |\n\n- [x] 完成');
+  assert.ok(parsed.children.some(node => node.type === 'table'));
+  assert.ok(parsed.children.some(node => node.type === 'list'));
+  const first = parsed.children[0];
+  assert.ok(first?.type === 'paragraph' && first.children.some(node => node.type === 'strong'));
+  const math = parseGfmWithMath('公式 \\(x^2\\)');
+  assert.ok(math.children.some(node => node.type === 'paragraph' && node.children.some(child => child.type === 'inlineMath')));
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2024", "module": "NodeNext", "moduleResolution": "NodeNext",
+    "strict": true, "skipLibCheck": true, "declaration": true,
+    "declarationMap": true, "sourceMap": true,
+    "rootDir": "src", "outDir": "lib/types", "jsx": "react-jsx",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "types": ["node", "react"]
+  },
+  "include": ["src"]
+}

package/tsdown.config.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import type { TsdownPlugin, UserConfig } from 'tsdown';
+
+const vendored = fileURLToPath(new URL('./tools/client-build.js', import.meta.url));
+
+function resolveHarnessAdapter(): string {
+  const configured = process.env.DSHX_HARNESS?.trim();
+  if (configured) return join(resolve(configured), 'tools/dshx/src/client-build.js');
+  const configPath = join(homedir(), '.config/dshx/harness');
+  const recorded = existsSync(configPath) ? readFileSync(configPath, 'utf8').trim() : undefined;
+  if (!recorded) {
+    throw new Error('client rebuild requires a Harness root from DSHX_HARNESS or ~/.config/dshx/harness');
+  }
+  return join(resolve(recorded), 'tools/dshx/src/client-build.js');
+}
+
+const adapter = existsSync(vendored) ? vendored : resolveHarnessAdapter();
+if (!existsSync(adapter)) throw new Error('externalClientBundle adapter is missing.');
+const { externalClientBundle } = await import(pathToFileURL(adapter).href);
+
+const bundle = externalClientBundle('dsh-better-display', ['src/dsh-better-display.ts'], {
+  clientEntry: 'src/client/index.tsx',
+}) as UserConfig[];
+
+const portableOutput: TsdownPlugin = {
+  name: 'dsh-better-display-portable-output',
+  generateBundle(_options, output) {
+    const client = output['client.js'];
+    if (client?.type !== 'chunk') this.error('client.js was not emitted');
+    client.code = client.code.replace(
+      /^([ \t]*\/\/#region \\0dshx-css-module:).*[\\/]([^/\\\r\n]+\.module\.css\.mjs)(\r?)$/gmu,
+      '$1$2$3',
+    );
+    if (/^.*\/\/#region \\0dshx-css-module:.*[\\/].*$/mu.test(client.code)) {
+      this.error('client.js contains a non-portable CSS module path');
+    }
+  },
+};
+
+export default bundle.map((config) => {
+  if (config.name !== 'dsh-better-display/client') return config;
+  const plugins = Array.isArray(config.plugins)
+    ? config.plugins
+    : config.plugins === undefined
+      ? []
+      : [config.plugins];
+  return { ...config, plugins: [...plugins, portableOutput] };
+});