dsh-better-display 0.3.7 → 0.3.9

package/tests/settings-copy.test.ts

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

package/tests/skill-status.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';

package/tests/stock-install.test.ts

@@ -1,7 +1,8 @@
 import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { fileURLToPath } from 'node:url';
 import semver from 'semver';
 
@@ -63,6 +64,13 @@ test('commits compiled lib entries and does not require a prepare script', () =>
   assert.doesNotMatch(clientJs, /submission\.images\.length/);
 });
 
+test('compiled host entry loads in Node without a TypeScript loader', () => {
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval',
+    "const plugin = await import('./lib/dsh-better-display.js'); if (plugin.name !== 'dsh-better-display' || typeof plugin.apply !== 'function') process.exit(1);",
+  ], { cwd: root, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr || String(result.error ?? 'host entry did not load'));
+});
+
 test('README leads with the official stock one-liner and names pnpm', () => {
   for (const name of ['README.md', 'README.en.md']) {
     const text = readFileSync(resolve(root, name), 'utf8');

package/tests/stream-buffer.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { StreamBuffer, STREAM_TIMING } from '../src/client/stream-buffer.js';
 
 test('a transport burst becomes multiple bounded, monotonically growing frames', () => {

package/tests/styles.test.ts

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { ensureStyles } from '../src/client/styles.js';
+
+test('ensureStyles tolerates module evaluation without a document', () => {
+  ensureStyles();
+});
+
+test('ensureStyles restores removed plugin CSS and remains idempotent', t => {
+  const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'document');
+  t.onTestFinished(() => {
+    if (descriptor) Object.defineProperty(globalThis, 'document', descriptor);
+    else Reflect.deleteProperty(globalThis, 'document');
+  });
+  const reader = { dataset: { plugin: 'dsh-better-display', pluginCss: 'dsh-better-display/Reader.module.css' }, textContent: '.reader{height:auto}' };
+  const fold = { dataset: { plugin: 'dsh-better-display', pluginCss: 'dsh-better-display/Fold.module.css' }, textContent: '.fold{overflow:hidden}' };
+  const foreign = { dataset: { plugin: 'other', pluginCss: 'other/Fold.module.css' }, textContent: '.other{}' };
+  const tags = [reader, fold, foreign];
+  const document = {
+    querySelectorAll: (selector: string) => {
+      assert.equal(selector, 'style[data-plugin="dsh-better-display"][data-plugin-css]');
+      return tags.filter(tag => tag.dataset.plugin === 'dsh-better-display');
+    },
+    createElement: (name: string) => { assert.equal(name, 'style'); return { dataset: {}, textContent: '' }; },
+    head: { appendChild: (tag: typeof reader) => { tags.push(tag); } },
+  };
+  Object.defineProperty(globalThis, 'document', { configurable: true, value: document });
+  ensureStyles();
+  assert.equal(tags.length, 3);
+  tags.splice(0, 2);
+  ensureStyles();
+  assert.deepEqual(tags, [foreign, reader, fold]);
+  ensureStyles();
+  assert.equal(tags.length, 3);
+  tags[1].textContent = '.reader{height:100px}';
+  ensureStyles();
+  tags.splice(1, 1);
+  ensureStyles();
+  assert.equal(tags.find(tag => tag.dataset.pluginCss === reader.dataset.pluginCss)?.textContent, '.reader{height:100px}');
+});
+
+test('CSS is cached after module injection and restored before mount layout effects', () => {
+  const index = readFileSync(new URL('../src/client/index.tsx', import.meta.url), 'utf8');
+  const reader = readFileSync(new URL('../src/client/Reader.tsx', import.meta.url), 'utf8');
+  assert.match(index, /\nensureStyles\(\);/);
+  // Whitespace-tolerant: the source is formatted by the project's own toolchain,
+  // which may break the effect body onto its own line.
+  assert.match(reader, /useInsertionEffect\(\(\) => \{[\s\S]{0,40}?ensureStyles\(\);[\s\S]{0,20}?\}, \[\]\)/);
+});
+
+test('user cluster fills the column so the host cap resolves once', () => {
+  const css = readFileSync(new URL('../src/client/Reader.module.css', import.meta.url), 'utf8');
+  const cluster = css.match(/\.userCluster\s*\{[^}]*\}/)?.[0] ?? '';
+  assert.match(cluster, /width:\s*100%/);
+  assert.match(cluster, /max-width:\s*100%/);
+  assert.doesNotMatch(cluster, /0\.702/);
+  assert.doesNotMatch(cluster, /525px/);
+  assert.doesNotMatch(css, /525px/);
+  // A direct-child cap misses the display:contents slot. The host row is the
+  // slot's child; capping that grandchild would replace .userStack's own 82%.
+  assert.doesNotMatch(css, /\.userCluster\s*>\s*\*/);
+  assert.doesNotMatch(css, /\[data-slot="conversation\.chat\.node"\]/);
+  assert.match(css, /\.userCluster > \[data-slot\] > \* \{[^}]*align-self:\s*stretch/);
+  assert.match(css, /\.userCluster > \[data-slot\] > \* \{[^}]*width:\s*100%/);
+  assert.doesNotMatch(css, /\.userCluster > \[data-slot\] > \* > \*/);
+  const user = css.match(/\.user\s*\{[^}]*\}/)?.[0] ?? '';
+  assert.match(user, /max-width:\s*min\(calc\(var\(--dsh-chat-content-width,\s*748px\)\s*\*\s*0\.702\),\s*82%\)/);
+  assert.match(user, /font-size:\s*var\(--dsh-content-font-size,\s*14px\)/);
+  assert.match(user, /line-height:\s*calc\(22px \+ var\(--dsh-content-font-delta,\s*0px\)\)/);
+  assert.match(user, /font-weight:\s*400/);
+  assert.match(user, /white-space:\s*pre-wrap/);
+  assert.match(user, /border-radius:\s*var\(--dsw-radius-xl,\s*22px\)/);
+  assert.doesNotMatch(css, /\.user\s*\{\s*max-width:\s*90%/);
+});

package/tests/terminal-input-preview.test.ts

@@ -0,0 +1,113 @@
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+import type { PreparingToolCall, RunningToolCall, ToolResultNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import { activityPhase, activitySummary } from '../src/client/tool-activity.ts';
+import type { ToolDraft } from '../src/client/tool-activity.ts';
+
+function draft(name: string, argsRaw: string): ToolDraft {
+  return { kind: 'tool-call', callId: 'terminal-preview', name, argsRaw };
+}
+
+test('terminal drafts expose a pending placeholder state until a command field appears', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const early = activitySummary({ draft: draft(name, '{"comman') });
+    assert.equal(early.category, 'terminal');
+    assert.equal(early.argsState, 'partial');
+    assert.equal(early.command, undefined);
+
+    const partial = activitySummary({ draft: draft(name, '{"command":"Get-C') });
+    assert.equal(partial.argsState, 'partial');
+    assert.equal(partial.command, 'Get-C');
+  }
+});
+
+test('complete Bash and PowerShell arguments remain available in full', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const values = {
+      command: name === 'pwsh' ? 'Get-ChildItem -Force' : 'printf "ready\\n"',
+      workdir: '/work/project',
+      description: 'List project files',
+      timeout_ms: 4000,
+    };
+    const model = activitySummary({ draft: draft(name, JSON.stringify(values)) });
+    assert.equal(model.argsState, 'complete');
+    assert.equal(model.command, values.command);
+    assert.deepEqual(model.args, values);
+  }
+});
+
+test('partial escaped and multiline commands keep their authored text', () => {
+  const argsRaw = '{"command":"printf \\"first\\nsecond';
+  const model = activitySummary({ draft: draft('bash', argsRaw) });
+  assert.equal(model.argsState, 'partial');
+  assert.equal(model.command, 'printf "first\nsecond');
+
+  const multiline = 'printf "first line\\nsecond line"\necho 你好';
+  const complete = activitySummary({ draft: draft('bash', JSON.stringify({ command: multiline, workdir: '/tmp' })) });
+  assert.equal(complete.command, multiline);
+  assert.equal(complete.args.workdir, '/tmp');
+});
+
+test('complete empty and non-command arguments are not mistaken for partial commands', () => {
+  const empty = activitySummary({ draft: draft('bash', '{}') });
+  assert.equal(empty.argsState, 'complete');
+  assert.deepEqual(empty.args, {});
+  assert.equal(empty.command, undefined);
+
+  const read = activitySummary({ draft: draft('read', '{"path":"/tmp/readme.md"}') });
+  assert.equal(read.argsState, 'complete');
+  assert.equal(read.category, 'read');
+  assert.equal(read.command, undefined);
+  assert.equal(read.args.path, '/tmp/readme.md');
+});
+
+test('the activity lifecycle distinguishes draft, dispatched call, and result', () => {
+  const argsRaw = '{"command":"echo ready"}';
+  const pending = draft('bash', argsRaw);
+  const running: RunningToolCall = {
+    phase: 'start', callId: pending.callId, name: pending.name, turn: 1, step: 0, time: 1000, argsRaw, subCalls: [],
+  };
+  const result: ToolResultNode = {
+    kind: 'tool-result', seq: 2, time: 2000, callId: pending.callId,
+    call: { name: pending.name, argsRaw }, callTime: 1000,
+    content: [{ type: 'text', text: 'ready\n[exit code: 0]' }], isError: false, meta: { exitCode: 0 }, subCalls: [],
+  };
+  assert.equal(activityPhase({ draft: pending }), 'preparing');
+  assert.equal(activityPhase({ block: running }), 'running');
+  assert.equal(activityPhase({ block: result }), 'succeeded');
+});
+
+test('a canonical preparing call remains preparing until dispatch', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const block: PreparingToolCall = {
+      phase: 'preparing', callId: 'preparing-head', name, turn: 1, step: 0, time: 1000, subCalls: [],
+    };
+    assert.equal(activityPhase({ block }), 'preparing');
+    assert.equal(activityPhase({ block }, true), 'interrupted');
+    const model = activitySummary({ block });
+    assert.equal(model.name, name);
+    assert.equal(model.argsState, 'partial');
+    assert.equal(model.raw, '');
+    assert.equal(model.command, undefined);
+  }
+});
+
+test('a canonical preparing head retains progressively generated draft arguments', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const block: PreparingToolCall = {
+      phase: 'preparing', callId: 'preparing-head', name, turn: 1, step: 0, time: 1000, subCalls: [],
+    };
+    for (const raw of ['{"comman', '{"command":"echo ready']) {
+      const pending = { ...draft(name, raw), callId: block.callId };
+      const model = activitySummary({ block, draft: pending });
+      assert.equal(model.raw, raw);
+      assert.equal(model.argsState, 'partial');
+      assert.equal(model.command, raw === '{"comman' ? undefined : 'echo ready');
+    }
+    const dispatched: RunningToolCall = { ...block, phase: 'start', argsRaw: '{"command":"echo sent"}' };
+    const model = activitySummary({ block: dispatched, draft: draft(name, '{"command":"stale') });
+    assert.equal(activityPhase({ block: dispatched }), 'running');
+    assert.equal(model.command, 'echo sent');
+    assert.equal(model.argsState, 'complete');
+  }
+});

package/tests/text-transform.test.ts

@@ -0,0 +1,272 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { StreamBuffer } from '../src/client/stream-buffer.js';
+import {
+  activeTextTransform,
+  createTextTransformRegistry,
+  displayStreaming,
+  installTextTransformRegistry,
+  nextDisplayCursor,
+  originalAnswerText,
+  readDisplayText,
+  readerBlockOwner,
+  type DisplayTextRequest,
+} from '../src/client/text-transform.js';
+import type { ReaderBlockOwner } from '../src/client/types.js';
+import { WordTimeline } from '../src/client/word-timeline.js';
+
+const reasoning = (text: string, streaming = true, blockKey = 'block-1'): DisplayTextRequest => ({
+  text, streaming, blockKey, kind: 'reasoning', source: 'assistant',
+});
+
+test('no transformer leaves the source text and the streaming flag untouched', () => {
+  const registry = createTextTransformRegistry();
+  const request = reasoning('Hello world', true);
+  const shown = readDisplayText(registry, request);
+  assert.equal(shown.text, request.text);
+  assert.equal(shown.final, false);
+  assert.equal(shown.motionRevision, 0);
+  assert.equal(shown.transformRevision, 0);
+  assert.equal(readDisplayText(undefined, request).text, 'Hello world');
+  assert.equal(displayStreaming(true, shown, false), true);
+  assert.equal(displayStreaming(false, { final: true }, false), false);
+  assert.equal(registry.has('reasoning'), false);
+  assert.equal(registry.has('body'), false);
+});
+
+test('a sync transformer rewrites the display string and leaves the block alone', () => {
+  const registry = createTextTransformRegistry();
+  const source = 'Hello';
+  const block = { kind: 'text' as const, text: source };
+  registry.register('body', {
+    read: request => ({ text: request.text.toUpperCase(), final: !request.streaming }),
+  });
+  const streaming = readDisplayText(registry, { text: source, streaming: true, blockKey: 'a', kind: 'body', source: 'assistant' });
+  const settled = readDisplayText(registry, { text: source, streaming: false, blockKey: 'a', kind: 'body', source: 'assistant' });
+  assert.equal(streaming.text, 'HELLO');
+  assert.equal(streaming.final, false);
+  assert.equal(displayStreaming(true, streaming, true), true);
+  assert.equal(settled.text, 'HELLO');
+  assert.equal(settled.final, true);
+  assert.equal(displayStreaming(false, settled, true), false);
+  assert.equal(source, 'Hello');
+  assert.equal(block.text, 'Hello');
+  assert.equal(originalAnswerText([block, { kind: 'reasoning', text: 'secret thought' }]), 'Hello');
+});
+
+test('an async append bumps the transform revision without restarting the reveal', () => {
+  const registry = createTextTransformRegistry();
+  let shown = 'Hello';
+  const listeners = new Set<() => void>();
+  registry.register('reasoning', {
+    read: () => ({ text: shown, final: false }),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => { listeners.delete(listener); };
+    },
+  });
+  const request = reasoning('thinking starts', true);
+  const first = registry.read(request);
+  assert.equal(first.text, 'Hello');
+  assert.equal(first.transformRevision, 0);
+  assert.equal(first.motionRevision, 0);
+
+  const buffer = new StreamBuffer('');
+  const timeline = new WordTimeline();
+  timeline.begin('', true, 0, 0);
+  const paint = (text: string, now: number) => {
+    buffer.update(text, now, { finished: false });
+    buffer.advance(now + 120);
+    timeline.begin(buffer.visible, true, buffer.revision, now + 120);
+  };
+  paint(first.text, 100);
+  assert.equal(buffer.revision, 0);
+  assert.ok(buffer.visible.length > 0);
+  const generation = timeline.generation;
+  const prefixBorn = timeline.bornAt(0);
+  const visible = buffer.visible;
+  assert.notEqual(prefixBorn, null);
+
+  shown = 'Hello there';
+  for (const listener of listeners) listener();
+  const second = registry.read(request);
+  assert.equal(second.text, 'Hello there');
+  assert.equal(second.motionRevision, first.motionRevision);
+  assert.equal(second.transformRevision, first.transformRevision + 1);
+  paint(second.text, 400);
+  assert.equal(buffer.revision, 0);
+  assert.ok(buffer.visible.startsWith(visible));
+  assert.ok(buffer.visible.length > visible.length);
+  assert.equal(timeline.generation, generation);
+  assert.equal(timeline.bornAt(0), prefixBorn);
+
+  // The transform counter is a different clock. Feeding it to the timeline
+  // settles the paragraph; the reader does not do that.
+  const trap = new WordTimeline();
+  trap.begin('', true, 0, 0);
+  trap.begin(visible, true, first.motionRevision, 220);
+  const trapGeneration = trap.generation;
+  trap.begin(second.text, true, second.transformRevision, 520);
+  assert.notEqual(trap.generation, trapGeneration);
+});
+
+test('a replaced translation settles on the new string instead of replaying from empty', () => {
+  const registry = createTextTransformRegistry();
+  let shown = 'Hello there';
+  registry.register('reasoning', {
+    read: () => ({ text: shown, final: false }),
+  });
+  const request = reasoning('source', true);
+  const first = registry.read(request);
+  const buffer = new StreamBuffer('');
+  buffer.update(first.text, 100);
+  buffer.advance(220);
+  assert.equal(buffer.visible, 'Hello there');
+  const timeline = new WordTimeline();
+  timeline.begin('', true, buffer.revision, 0);
+  timeline.begin(buffer.visible, true, buffer.revision, 220);
+  const generation = timeline.generation;
+
+  shown = '你好世界';
+  const second = registry.read(request);
+  assert.equal(second.motionRevision, first.motionRevision + 1);
+  assert.ok(second.transformRevision > first.transformRevision);
+  buffer.update(second.text, 400);
+  assert.equal(buffer.visible, '你好世界');
+  assert.notEqual(buffer.visible, '');
+  assert.equal(buffer.revision, 1);
+  timeline.begin(buffer.visible, true, buffer.revision, 400);
+  assert.notEqual(timeline.generation, generation);
+  assert.equal(timeline.bornAt(0), null);
+});
+
+test('the block owner carries presentation, holdFormatting, and liveText', () => {
+  const block = { kind: 'reasoning' as const, text: 'original' };
+  const owner = readerBlockOwner(block as ReaderBlockOwner['block'], true, 'assistant', {
+    startedAt: 42, interrupted: false, liveText: true,
+  }, false);
+  assert.equal(owner.block, block);
+  assert.equal(owner.streaming, true);
+  assert.equal(owner.source, 'assistant');
+  assert.deepEqual(owner.presentation, { startedAt: 42, interrupted: false, liveText: true });
+  assert.equal(owner.holdFormatting, false);
+  assert.equal(owner.liveText, true);
+  assert.equal(owner.block.text, 'original');
+  const bare: ReaderBlockOwner = { block: owner.block, streaming: false, source: 'user' };
+  assert.equal(bare.presentation, undefined);
+  assert.equal(bare.holdFormatting, undefined);
+  assert.equal(bare.liveText, undefined);
+});
+
+test('unregistering restores the original text and the install pointer nests', () => {
+  const registry = createTextTransformRegistry();
+  const dispose = registry.register(['reasoning', 'body'], {
+    read: request => request.text.toUpperCase(),
+  });
+  assert.equal(registry.has('reasoning'), true);
+  assert.equal(registry.has('body'), true);
+  assert.equal(readDisplayText(registry, reasoning('Ab')).text, 'AB');
+  dispose();
+  assert.equal(registry.has('reasoning'), false);
+  assert.equal(readDisplayText(registry, reasoning('Ab')).text, 'Ab');
+
+  const outer = createTextTransformRegistry();
+  const restoreOuter = installTextTransformRegistry(outer);
+  try {
+    assert.equal(activeTextTransform(), outer);
+    const inner = createTextTransformRegistry();
+    const restoreInner = installTextTransformRegistry(inner);
+    try {
+      assert.equal(activeTextTransform(), inner);
+    } finally {
+      restoreInner();
+    }
+    assert.equal(activeTextTransform(), outer);
+  } finally {
+    restoreOuter();
+  }
+  assert.equal(activeTextTransform(), undefined);
+});
+
+test('a transformer notify reaches reader subscribers, and release drops the cursor', () => {
+  const registry = createTextTransformRegistry();
+  let shown = 'Hello';
+  let notify = () => {};
+  registry.register('reasoning', {
+    read: () => ({ text: shown, final: false }),
+    subscribe(listener) {
+      notify = listener;
+      return () => {};
+    },
+  });
+  let seen = 0;
+  const stop = registry.subscribe('reasoning', () => { seen += 1; });
+  const first = registry.read(reasoning('source'));
+  assert.equal(first.text, 'Hello');
+  assert.equal(first.transformRevision, 0);
+  shown = 'Hello there';
+  notify();
+  assert.equal(seen, 1);
+  const next = registry.read(reasoning('source'));
+  assert.equal(next.text, 'Hello there');
+  assert.equal(next.motionRevision, 0);
+  assert.equal(next.transformRevision, 1);
+  stop();
+  registry.release('reasoning', 'block-1');
+  shown = 'Hello there friend';
+  const restarted = registry.read(reasoning('source'));
+  assert.equal(restarted.transformRevision, 0);
+  assert.equal(restarted.motionRevision, 0);
+});
+
+test('an extending display string keeps the motion revision', () => {
+  const first = nextDisplayCursor(undefined, { text: 'Hello', final: false });
+  const second = nextDisplayCursor(first, { text: 'Hello world', final: false });
+  const same = nextDisplayCursor(second, { text: 'Hello world', final: false });
+  assert.equal(second.motionRevision, first.motionRevision);
+  assert.equal(second.transformRevision, 1);
+  assert.equal(same, second);
+});
+
+test('a throwing transformer falls back to the original text and recovers without a remount', () => {
+  const registry = createTextTransformRegistry();
+  let broken = true;
+  let notify = () => {};
+  const warn = console.warn;
+  console.warn = () => {};
+  try {
+    registry.register('reasoning', {
+      subscribe(listener) { notify = listener; return () => {}; },
+      read(request) {
+        if (broken) throw new Error('engine down');
+        return { text: request.text.toUpperCase(), final: !request.streaming };
+      },
+    });
+    const first = registry.read(reasoning('hello', true));
+    assert.equal(first.text, 'hello');
+    assert.equal(first.final, false);
+    broken = false;
+    notify();
+    const recovered = registry.read(reasoning('hello', true));
+    assert.equal(recovered.text, 'HELLO');
+  } finally {
+    console.warn = warn;
+  }
+});
+
+test('a transformer whose subscribe throws still registers and reads', () => {
+  const registry = createTextTransformRegistry();
+  const warn = console.warn;
+  console.warn = () => {};
+  try {
+    const off = registry.register('body', {
+      subscribe() { throw new Error('no events'); },
+      read(request) { return request.text.toUpperCase(); },
+    });
+    assert.equal(registry.read({ text: 'ok', streaming: false, blockKey: 'b', kind: 'body', source: 'assistant' }).text, 'OK');
+    off();
+    assert.equal(registry.has('body'), false);
+  } finally {
+    console.warn = warn;
+  }
+});

package/tests/timeline.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { mergeTimelineItems } from '../src/client/timeline.ts';
 

package/tests/tool-clock.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { callStartTime, forgetCallClock, runningClockBase } from '../src/client/tool-activity.ts';
 import type { RunningToolCall, ToolResultNode } from '@deepseek-ai/dsh-client-ui-conversation/client';

package/tests/tool-diff.test.ts

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 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';

package/tests/waiting-clock.test.ts

@@ -1,4 +1,4 @@
-import test from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import { HANDOVER_KINDS, handsBackToModel, WAIT_AFTER, waitingAnchor } from '../src/client/waiting-clock.js';
 

package/tests/word-timeline.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import type { Nodes } from 'mdast';
 import { WORD_MOTION, WordTimeline } from '../src/client/word-timeline.js';
 import { IncrementalMarkdownParser } from '../src/client/markdown/incremental.js';

package/tsdown.config.ts

@@ -40,12 +40,60 @@ const portableOutput: TsdownPlugin = {
   },
 };
 
+/**
+ * Guard against the 0.3.7 regression class: the host entry must not ship a
+ * relative specifier that cannot resolve inside the published tarball.
+ *
+ * The specific failure was `import ... from "./skill-roots.ts"` — a path to the
+ * TypeScript source that is never emitted next to the entry, so the host died
+ * with ERR_MODULE_NOT_FOUND on every start while the market still reported the
+ * plugin as installed. A build-time assertion turns that silent publish-time
+ * mistake into a red build.
+ */
+const hostPortableOutput: TsdownPlugin = {
+  name: 'dsh-better-display-host-portable-output',
+  generateBundle(_options, output) {
+    for (const [fileName, chunk] of Object.entries(output)) {
+      if (chunk.type !== 'chunk') continue;
+      const offenders = [
+        // Relative specifiers that still point at TS sources.
+        ...chunk.code.matchAll(/from\s*["'](\.[^"']*\.ts)["']/g),
+        // Relative specifiers reaching into node_modules-written shapes.
+        ...chunk.code.matchAll(/from\s*["'](\.\.?\/[^"']*node_modules\/[^"']*)["']/g),
+      ].map((match) => match[1]);
+      if (offenders.length > 0) {
+        this.error(
+          `${fileName} contains relative specifiers that will not resolve in the published package: ` +
+            `${[...new Set(offenders)].join(', ')}. Relative imports must be bundled, not externalised ` +
+            `(see the neverBundle note above).`,
+        );
+      }
+    }
+  },
+};
+
 export default bundle.map((config) => {
   if (config.name === 'dsh-better-display') {
     const { external: _external, ...hostConfig } = config;
     return {
       ...hostConfig,
-      deps: { ...hostConfig.deps, neverBundle: (specifier: string) => !specifier.startsWith('.') },
+      plugins: [
+        ...(Array.isArray(hostConfig.plugins)
+          ? hostConfig.plugins
+          : hostConfig.plugins === undefined
+            ? []
+            : [hostConfig.plugins]),
+        hostPortableOutput,
+      ],
+      // NEVER re-introduce a resolved-id predicate here. tsdown may hand this
+      // callback an already-resolved absolute path, in which case a
+      // `!specifier.startsWith('.')` test is true for EVERY module and the
+      // relative source imports get externalised instead of bundled — the
+      // host entry then ships as `import ... from "./skill-roots.ts"`, which
+      // no longer exists in the package (0.3.7 regression, ERR_MODULE_NOT_FOUND).
+      // `true` keeps the documented semantics: bare npm specifiers stay
+      // external "as written", relative imports keep being bundled.
+      deps: { ...hostConfig.deps, neverBundle: true },
     };
   }
   if (config.name !== 'dsh-better-display/client') return config;