dsh-better-display 0.1.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/waiting-clock.test.ts

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { waitingAnchor } from '../src/client/waiting-clock.js';
+const nodes = new Map([
+ ['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}}],
+]);
+const get=(key:string)=>nodes.get(key);
+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}));
+test('assistant, context and tool rerenders do not reset waiting',()=>assert.deepEqual(waitingAnchor(['u1','s1','a1','ctx'],get),{key:'s1',time:301000}));
+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,136 @@
+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 reference stagger, with a bounded queue', () => {
+  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());
+  assert.deepEqual(words.slice(0, 3).map(word => word.born), [100, 160, 220]);
+  assert.ok(words.every(word => word.born! <= 100 + WORD_MOTION.maxDelay));
+  timeline.begin('one two three four five six seven eight', true, 0, 900);
+  assert.deepEqual(timeline.words('one two three', 0).filter(word => word.text.trim()).map(word => word.born), [100, 160, 220]);
+});
+
+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,49 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { TsdownPlugin, UserConfig } from 'tsdown';
+
+function resolveHarness(): string {
+  const configured = process.env.DSHX_HARNESS?.trim();
+  if (configured) return resolve(configured);
+  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 resolve(recorded);
+}
+
+const adapter = join(resolveHarness(), 'tools/dshx/src/client-build.js');
+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] };
+});