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

package/tests/deliverables.test.ts

@@ -0,0 +1,128 @@
+import { test } from 'node:test';
+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';
+import type { ReaderFlowEntry } from '../src/client/tool-activity.ts';
+
+test('basename and dirname handle POSIX and Windows style paths', () => {
+  assert.equal(basename('src/client/Reader.tsx'), 'Reader.tsx');
+  assert.equal(dirname('src/client/Reader.tsx'), 'src/client');
+  assert.equal(basename('C:\\project\\src\\index.ts'), 'index.ts');
+  assert.equal(dirname('C:\\project\\src\\index.ts'), 'C:\\project\\src');
+  assert.equal(basename('simple.txt'), 'simple.txt');
+  assert.equal(dirname('simple.txt'), '.');
+  assert.equal(basename('/root/file.md/'), 'file.md');
+  assert.equal(dirname('/root/file.md/'), '/root');
+});
+
+test('getTurnDeliverables extracts produced paths from turn deliverables data', () => {
+  const map = new Map<string, unknown>();
+  map.set('deliverables', {
+    produced: [
+      { seq: 1, path: 'src/client/Reader.tsx' },
+      { seq: 2, path: 'src/client/Reader.module.css' },
+      { seq: 3, path: 'src/client/Reader.tsx' }, // duplicate
+    ],
+  });
+  const turn = { data: map } as unknown as TurnLocation;
+  const paths = getTurnDeliverables(turn);
+  assert.deepEqual(paths, ['src/client/Reader.tsx', 'src/client/Reader.module.css']);
+});
+
+test('getTurnDeliverables falls back to tool flow when turn data is absent', () => {
+  const flow: ReaderFlowEntry[] = [
+    {
+      kind: 'tool',
+      key: 'tool:1',
+      callId: 'call:1',
+      step: 1,
+      order: 0,
+      block: {
+        kind: 'tool-call',
+        name: 'write',
+        argsRaw: JSON.stringify({ file_path: 'src/client/new-feature.ts', content: 'hello' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:2',
+      callId: 'call:2',
+      step: 2,
+      order: 1,
+      block: {
+        kind: 'tool-call',
+        name: 'edit',
+        argsRaw: JSON.stringify({ file_path: 'src/client/Reader.tsx', old_string: 'a', new_string: 'b' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:3',
+      callId: 'call:3',
+      step: 3,
+      order: 2,
+      block: {
+        kind: 'tool-result',
+        isError: true, // error result should be skipped
+        name: 'write',
+        argsRaw: JSON.stringify({ file_path: 'bad.txt', content: 'err' }),
+      } as any,
+    },
+    {
+      kind: 'tool',
+      key: 'tool:4',
+      callId: 'call:4',
+      step: 4,
+      order: 3,
+      block: {
+        kind: 'tool-call',
+        name: 'read', // read should not be considered a deliverable
+        argsRaw: JSON.stringify({ file_path: 'package.json' }),
+      } as any,
+    },
+  ];
+
+  const paths = getTurnDeliverables(undefined, flow);
+  assert.deepEqual(paths, ['src/client/new-feature.ts', 'src/client/Reader.tsx']);
+});
+
+test('createProducedFileMentions resolves exact paths and unique basenames, leaving ambiguous basenames inert', () => {
+  const opened: string[] = [];
+  const openFile = (p: string) => { opened.push(p); };
+  const paths = [
+    'src/client/Reader.tsx',
+    'src/server/Reader.tsx', // duplicate basename
+    'src/client/Reader.module.css', // unique basename
+  ];
+  const mentions = createProducedFileMentions(paths, openFile);
+
+  // Exact path resolves
+  const exact = mentions.resolve('src/client/Reader.tsx');
+  assert.ok(exact);
+  assert.equal(exact.title, 'src/client/Reader.tsx');
+  assert.equal(exact.label, '打开 src/client/Reader.tsx');
+  exact.open();
+  assert.deepEqual(opened, ['src/client/Reader.tsx']);
+
+  // Unique basename resolves
+  const unique = mentions.resolve('Reader.module.css');
+  assert.ok(unique);
+  assert.equal(unique.title, 'src/client/Reader.module.css');
+  unique.open();
+  assert.deepEqual(opened, ['src/client/Reader.tsx', 'src/client/Reader.module.css']);
+
+  // Ambiguous basename leaves undefined (never guess or open the wrong file)
+  const ambiguous = mentions.resolve('Reader.tsx');
+  assert.equal(ambiguous, undefined);
+
+  // Unrelated file leaves undefined
+  const unrelated = mentions.resolve('unknown.js');
+  assert.equal(unrelated, undefined);
+});
+
+test('produced-files row waits for turn close even when paths already exist', () => {
+  const paths = ['src/client/Watcher.tsx'];
+  assert.equal(showDeliverablesRow('open', paths), false);
+  assert.equal(showDeliverablesRow('closed', paths), true);
+  assert.equal(showDeliverablesRow('closed', []), false);
+});

package/tests/entry.test.ts

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { ReaderEntryPolicy, readerEntryRequested } from '../src/client/entry-policy.js';
+
+test('fresh sessions default to reading, without requiring a special URL', () => {
+  const policy = new ReaderEntryPolicy(false);
+  assert.equal(policy.select(null), 'reader');
+  assert.equal(policy.select('reader'), null);
+  assert.equal(policy.select(undefined), 'reader');
+});
+
+test('an explicit native or third-party tab selection is not overwritten', () => {
+  const policy = new ReaderEntryPolicy(false);
+  for (const view of ['chat', 'trajectory', 'other-plugin']) assert.equal(policy.select(view), null);
+  assert.equal(policy.select(null), 'reader');
+  assert.equal(policy.select('chat'), null);
+});
+
+test('the trial URL enters reading once and releases later tab choices', () => {
+  let consumed = 0;
+  const policy = new ReaderEntryPolicy(true, () => { consumed++; });
+  assert.equal(policy.select('chat'), 'reader');
+  assert.equal(consumed, 1);
+  assert.equal(policy.select('reader'), null);
+  assert.equal(policy.select('chat'), null);
+  assert.equal(policy.select('trajectory'), null);
+  assert.equal(consumed, 1);
+  assert.equal(policy.select(null), 'reader');
+});
+
+test('already-selected reading still consumes the entry request', () => {
+  let consumed = false;
+  const policy = new ReaderEntryPolicy(true, () => { consumed = true; });
+  assert.equal(policy.select('reader'), null);
+  assert.equal(consumed, true);
+  assert.equal(policy.select('chat'), null);
+});
+
+test('current and previously delivered trial links have real entry semantics', () => {
+  for (const query of ['?reader=1', '?reader=0.1.0-trial.2', '?reader=0.1.0-trial.3']) assert.equal(readerEntryRequested(query), true);
+  for (const query of ['', '?reader=0', '?reader=unrelated', '?other=reader']) assert.equal(readerEntryRequested(query), false);
+});

package/tests/fixtures/maid-composer-hide.html

@@ -0,0 +1,31 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Reader chat-flow hook vs maid-atelier composer hide</title>
+<style>
+  [data-conversation-scroll] { display: flex; flex-direction: column; min-height: 120px; }
+  [data-composer-seat] { display: flex; min-height: 28px; }
+  /* Exact maid-atelier / phoebe-atelier empty-state hide (issue #10). */
+  [data-phase="active"]
+    [data-conversation-scroll]:not(:has([data-chat-flow]))
+    > [data-composer-seat] { display: none; }
+</style>
+<body>
+  <section id="inspect" data-phase="active">
+    <div data-conversation-scroll>
+      <div data-dsh-better-display="fixture"><section data-reader-turn="1">turn</section></div>
+      <div data-composer-seat id="inspect-seat">composer</div>
+    </div>
+  </section>
+  <section id="reader" data-phase="active">
+    <div data-conversation-scroll>
+      <div data-dsh-better-display="0.1.1">
+        <div data-chat-flow=""><section data-reader-turn="1">turn</section></div>
+      </div>
+      <div data-composer-seat id="reader-seat">composer</div>
+    </div>
+  </section>
+  <script>
+    document.body.dataset.inspectDisplay = getComputedStyle(document.getElementById('inspect-seat')).display;
+    document.body.dataset.readerDisplay = getComputedStyle(document.getElementById('reader-seat')).display;
+  </script>
+</body>

package/tests/fold-choreography.test.ts

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { collapseRows, containsNewUser, flowRows, FOLD_TIMING, retiringKeys } from '../src/client/fold-choreography.js';
+import { presentLiveTurn } from '../src/client/live-turn.js';
+import type { LiveStep } from '../src/client/live-turn.js';
+const reasoning = (n: number): LiveStep => ({ kind: 'reasoning', key: `r${n}`, nodeKey: `n${n}`, start: 0, blocks: [], step: n });
+const body: LiveStep = { kind: 'body', key: 'b1', nodeKey: 'n1', start: 1, blocks: [], step: 1 };
+const open = { status: 'open' } as const;
+test('first fold retains every visible step key and admits no incoming reasoning', () => {
+  const before = presentLiveTurn([reasoning(1), body], open);
+  const after = presentLiveTurn([reasoning(1), body, reasoning(2)], open);
+  assert.deepEqual(retiringKeys(before, after, {}), ['r1', 'b1']);
+  const rows = collapseRows(before, after);
+  assert.deepEqual(rows.filter(x => x.kind === 'step').map(x => x.key), ['r1', 'b1']);
+  assert.equal(rows[0].kind, 'summary');
+  assert.equal(rows[0].kind === 'summary' && rows[0].item.summary, '思考×0 · 输出×0');
+  assert.equal(new Set(flowRows(after).map(row => row.key)).size, flowRows(after).length);
+});
+test('repeat fold retires only displayed open rows, retaining the same summary identity', () => {
+  const before = presentLiveTurn([reasoning(1), body, reasoning(2)], open);
+  const after = presentLiveTurn([reasoning(1), body, reasoning(2), reasoning(3)], open);
+  assert.deepEqual(retiringKeys(before, after, {}), ['r2']);
+  assert.equal(collapseRows(before, after)[0].key, flowRows(before)[0].key);
+  assert.deepEqual(retiringKeys(before, after, { 'live-fold:r1': true }), []);
+});
+test('user admission bypasses buffered choreography and preserves source ordering', () => {
+  const before = presentLiveTurn([reasoning(1)], open);
+  const user: LiveStep = { kind: 'user', key: 'u2', nodeKey: 'u2' };
+  const after = presentLiveTurn([reasoning(1), user, reasoning(2)], open);
+  assert.equal(containsNewUser(before, after), true);
+  assert.deepEqual(retiringKeys(before, after, {}), []);
+  assert.deepEqual(flowRows(after).map(row => row.key), ['r1', 'u2', 'r2']);
+});
+test('disabling fold preserves all source steps; phase budget is bounded', () => {
+  const items = presentLiveTurn([reasoning(1), body, reasoning(2)], open, false);
+  assert.equal(items.some(item => item.kind === 'fold'), false);
+  assert.equal(FOLD_TIMING.collapse + FOLD_TIMING.count + FOLD_TIMING.settle, 560);
+});
+
+// Every phase must be escapable without cooperating animations or frames. A
+// non-idle phase holds the frame source at `shown` and pauses the text reveal, so
+// a phase that cannot advance freezes the whole turn until the view remounts —
+// which is exactly the reported "output stalls at the end, refresh fixes it".
+// The slack is what makes the deadline strictly later than the nominal phase.
+test('every phase has a bounded budget and a watchdog strictly beyond it', () => {
+  assert.ok(FOLD_TIMING.watchdogSlack > 0, 'watchdog slack must be positive');
+  for (const phase of ['collapse', 'count', 'settle', 'reveal'] as const) {
+    const budget = FOLD_TIMING[phase];
+    assert.ok(Number.isFinite(budget) && budget > 0, phase + ' needs a positive budget');
+    assert.ok(budget + FOLD_TIMING.watchdogSlack > budget, phase + ' deadline must exceed its budget');
+    // Far below any plausible user perception of "stuck".
+    assert.ok(budget + FOLD_TIMING.watchdogSlack < 1000, phase + ' must not read as a stall');
+  }
+});

package/tests/fold-intensity.test.ts

@@ -0,0 +1,94 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  FOLD_INTENSITY_DEFAULT,
+  autoFoldFromIntensity,
+  foldIntensityOf,
+  frostedGlassOf,
+  processOnlyFromIntensity,
+} from '../src/client/fold-intensity.ts';
+import { presentLiveTurn } from '../src/client/live-turn.ts';
+import type { LiveStep } from '../src/client/live-turn.ts';
+import { en, zh } from '../src/client/settings-copy.ts';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const reasoning = (n: number): LiveStep => ({ kind: 'reasoning', key: `r${n}`, nodeKey: `n${n}`, start: 0, blocks: [], step: n });
+const body: LiveStep = { kind: 'body', key: 'b1', nodeKey: 'n1', start: 1, blocks: [{ kind: 'text', text: 'answer' }], step: 1 };
+const tool: LiveStep = {
+  kind: 'tool',
+  key: 't1',
+  entry: {
+    kind: 'tool',
+    key: 't1',
+    callId: 'c1',
+    step: 0,
+    order: 0,
+    draft: { kind: 'tool-call', callId: 'c1', name: 'read', argsRaw: '{"path":"Reader.tsx"}' },
+  },
+};
+const open = { status: 'open' } as const;
+const closed = { status: 'closed', reason: 'completed', latestStep: 2, closingStep: 2 } as const;
+
+test('fold intensity defaults to standard (1) and glass defaults off', () => {
+  assert.equal(FOLD_INTENSITY_DEFAULT, 1);
+  assert.equal(foldIntensityOf(undefined), 1);
+  assert.equal(foldIntensityOf({}), 1);
+  assert.equal(frostedGlassOf(undefined), false);
+  assert.equal(frostedGlassOf({}), false);
+  assert.equal(frostedGlassOf({ frostedGlass: false }), false);
+  assert.equal(frostedGlassOf({ frostedGlass: true }), true);
+});
+
+test('fold slider maps 0/1/2 and migrates older persist flags', () => {
+  assert.equal(foldIntensityOf({ foldIntensity: 0 }), 0);
+  assert.equal(foldIntensityOf({ foldIntensity: 1 }), 1);
+  assert.equal(foldIntensityOf({ foldIntensity: 2 }), 2);
+  assert.equal(foldIntensityOf({ autoFold: false }), 0);
+  assert.equal(foldIntensityOf({ processOnly: true }), 2);
+  assert.equal(foldIntensityOf({ autoFold: true, processOnly: false }), 1);
+  assert.equal(autoFoldFromIntensity(0), false);
+  assert.equal(autoFoldFromIntensity(1), true);
+  assert.equal(autoFoldFromIntensity(2), true);
+  assert.equal(processOnlyFromIntensity(0), false);
+  assert.equal(processOnlyFromIntensity(1), false);
+  assert.equal(processOnlyFromIntensity(2), true);
+});
+
+test('autoFold false keeps every step open; autoFold true is current-main fold-on-next-reasoning', () => {
+  const steps = [reasoning(1), body, tool, reasoning(2)];
+  const none = presentLiveTurn(steps, open, false);
+  assert.equal(none.some(item => item.kind === 'fold'), false);
+  assert.deepEqual(none.map(item => item.key), ['r1', 'b1', 't1', 'r2']);
+
+  const standard = presentLiveTurn(steps, open, true);
+  assert.equal(standard[0]?.kind, 'fold');
+  if (standard[0]?.kind !== 'fold') throw new Error('expected standard fold');
+  assert.deepEqual(standard[0].steps.map(step => step.key), ['r1', 'b1', 't1']);
+  assert.deepEqual(standard.filter(item => item.kind === 'open').map(item => item.key), ['r2']);
+});
+
+test('root reader store persists glass off and standard fold on dsh.reader.v1', () => {
+  const store = readFileSync(resolve(root, 'src/client/store.ts'), 'utf8');
+  assert.match(store, /persist:\s*'dsh\.reader\.v1'/);
+  assert.match(store, /frostedGlass:\s*false/);
+  assert.match(store, /foldIntensity:\s*FOLD_INTENSITY_DEFAULT/);
+  assert.match(store, /deliverableOpenMode:\s*'external'/);
+  assert.match(store, /setFrostedGlass/);
+  assert.match(store, /setFoldIntensity/);
+  assert.match(store, /setDeliverableOpenMode/);
+});
+
+test('settings copy names fold switch and glass without leaking home paths', () => {
+  for (const copy of [en, zh]) {
+    assert.match(copy.glassTitle, /毛玻璃|Frosted glass/i);
+    assert.match(copy.foldTitle, /折叠|fold/i);
+    assert.doesNotMatch(Object.values(copy).join('\n'), /\/Users\/|\$HOME\b/);
+  }
+  const reader = readFileSync(resolve(root, 'src/client/Reader.tsx'), 'utf8');
+  assert.match(reader, /data-reader-glass=\{frostedGlass/);
+  assert.match(reader, /data-reader-auto-fold=\{autoFold/);
+  assert.doesNotMatch(reader, /setProcessOnly/);
+});

package/tests/footer-precedence.test.ts

@@ -0,0 +1,129 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const css = readFileSync(resolve(root, 'src/client/Reader.module.css'), 'utf8');
+const bundle = readFileSync(resolve(root, 'lib/client.js'), 'utf8');
+
+/**
+ * Host ConversationRoot owns the footer band: `.composerSeat` is `position:
+ * sticky; bottom: 0; z-index: 7`, its own markdown code banner is 6 and the
+ * floating controls are 8. A scrolling reader clamps every turn-level sticky
+ * lane down into that band (the lane stops at its containing block's bottom,
+ * which passes behind the input card), so a lane at 7 or above paints the
+ * reader's own opaque plate over the composer. Everything the reader pins
+ * inside the transcript therefore has to stay strictly below 7.
+ */
+const HOST_FOOTER_Z = 7;
+
+/** Lanes a scroll can clamp into the footer band. */
+const CLAMPED_LANES = [
+  '.turnProcessSticky',
+  '.liveFoldContainer',
+  '.flowCell[data-flow-summary]',
+  '.closedProcessSummary',
+];
+
+/** The one lane allowed at 7: it pins to the scrollport's first lane and can never reach the band. */
+const TOP_LANE = '.toolbar';
+
+function mergedDeclarations(source: string, selector: string, { hashed = false } = {}): Map<string, string> {
+  const declarations = new Map<string, string>();
+  const body = source.replace(/\/\*[\s\S]*?\*\//g, '');
+  const rule = /([^{}]+)\{([^{}]*)\}/g;
+  let match: RegExpExecArray | null;
+  while ((match = rule.exec(body)) !== null) {
+    const selectors = match[1]!.split(',').map(part => part.trim());
+    const wanted = hashed
+      ? selectors.some(part => part.endsWith(selector) || part.endsWith(selector.replace(/^\./, '')))
+      : selectors.includes(selector);
+    if (!wanted) continue;
+    for (const declaration of match[2]!.split(';')) {
+      const separator = declaration.indexOf(':');
+      if (separator < 0) continue;
+      const property = declaration.slice(0, separator).trim();
+      const value = declaration.slice(separator + 1).trim();
+      if (property) declarations.set(property, value);
+    }
+  }
+  return declarations;
+}
+
+/** Minified CSS inside the committed bundle keeps the hashed prefix on each class. */
+function bundledDeclarations(className: string): Map<string, string> {
+  const declarations = new Map<string, string>();
+  const rule = new RegExp(`(?:^|[.,}])[.#]?[\\w-]*${className}\\{([^{}]*)\\}`, 'g');
+  let match: RegExpExecArray | null;
+  while ((match = rule.exec(bundle)) !== null) {
+    for (const declaration of match[1]!.split(';')) {
+      const separator = declaration.indexOf(':');
+      if (separator < 0) continue;
+      declarations.set(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+    }
+  }
+  return declarations;
+}
+
+test('clamped reader lanes stay strictly below the host footer band', () => {
+  for (const lane of CLAMPED_LANES) {
+    const declarations = mergedDeclarations(css, lane);
+    const zIndex = declarations.get('z-index');
+    assert.ok(zIndex, `${lane} still declares its lane z-index`);
+    assert.ok(
+      Number(zIndex) < HOST_FOOTER_Z,
+      `${lane} must stay below the host composer seat (z-index ${HOST_FOOTER_Z}), got ${zIndex}`,
+    );
+  }
+});
+
+test('the top toolbar lane stays at 7 and pins to the scrollport top', () => {
+  const declarations = mergedDeclarations(css, TOP_LANE);
+  assert.equal(declarations.get('z-index'), String(HOST_FOOTER_Z));
+  assert.equal(declarations.get('top'), '0');
+});
+
+test('the live status lane pins below the toolbar lane instead of over it', () => {
+  const declarations = mergedDeclarations(css, '.turnProcessSticky');
+  assert.match(
+    declarations.get('top') ?? '',
+    /var\(--reader-toolbar-height/,
+    'the status lane shares the measured lane below the toolbar',
+  );
+});
+
+test('the closed summary lane shares that same measured lane', () => {
+  const declarations = mergedDeclarations(css, '.flowCell[data-flow-summary]');
+  assert.match(declarations.get('top') ?? '', /var\(--reader-toolbar-height/);
+});
+
+test('skin mode does not reintroduce a lane above the footer band', () => {
+  for (const lane of CLAMPED_LANES) {
+    const zIndex = mergedDeclarations(css, `.root[data-reader-glass] ${lane}`).get('z-index');
+    if (zIndex === undefined || zIndex === 'auto') continue;
+    assert.ok(
+      Number(zIndex) < HOST_FOOTER_Z,
+      `glass override for ${lane} must not lift above ${HOST_FOOTER_Z}, got ${zIndex}`,
+    );
+  }
+  assert.equal(
+    mergedDeclarations(css, '.root[data-reader-glass] .toolbar').get('z-index'),
+    undefined,
+    'the toolbar keeps its single ladder value in both modes',
+  );
+});
+
+test('the committed client bundle carries the same lane ladder', () => {
+  for (const lane of ['turnProcessSticky', 'liveFoldContainer']) {
+    const bundled = bundledDeclarations(lane);
+    const zIndex = bundled.get('z-index');
+    assert.ok(zIndex, `${lane} is present in the built bundle`);
+    assert.ok(
+      Number(zIndex) < HOST_FOOTER_Z,
+      `${lane} in lib/client.js must stay below ${HOST_FOOTER_Z}, got ${zIndex}`,
+    );
+  }
+  assert.equal(bundledDeclarations('toolbar').get('z-index'), String(HOST_FOOTER_Z));
+});

package/tests/history-word-regression.test.ts

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { WordTimeline } from '../src/client/word-timeline.js';
+
+test('opening a long existing answer does not animate every historical word', () => {
+  const timeline = new WordTimeline();
+  const history = '已经接收的历史文字。'.repeat(20000);
+  timeline.begin(history, true, 0, 100);
+  assert.equal(timeline.hasLiveText, false, 'history must bypass per-word components');
+
+  timeline.begin(history + '新内容', true, 0, 200);
+  assert.equal(timeline.hasLiveText, true);
+  const words = timeline.words(history + '新内容', 0);
+  assert.ok(words.length < 10, `historical prefix expanded into ${words.length} words`);
+  assert.equal(words.map(word => word.text).join(''), history + '新内容');
+});