dsh-better-display 0.3.7 → 0.3.9

package/tests/reader-theme-overlap.test.ts

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { inflateSync } from 'node:zlib';
+import { test } from 'vitest';
+
+const browserRuntime = join(homedir(), '.codex/playwright-runtime/runtime.mjs');
+const skip = existsSync(browserRuntime) ? false : 'pinned Chromium runtime not available';
+
+function paeth(left: number, up: number, upLeft: number) {
+  const estimate = left + up - upLeft;
+  const leftDistance = Math.abs(estimate - left);
+  const upDistance = Math.abs(estimate - up);
+  const diagonal = Math.abs(estimate - upLeft);
+  if (leftDistance <= upDistance && leftDistance <= diagonal) return left;
+  if (upDistance <= diagonal) return up;
+  return upLeft;
+}
+
+function pngPixel(buffer: Buffer, x: number, y: number) {
+  let offset = 8;
+  const chunks: Buffer[] = [];
+  let width = 0;
+  let height = 0;
+  let colorType = 0;
+  while (offset < buffer.length) {
+    const length = buffer.readUInt32BE(offset);
+    const type = buffer.toString('ascii', offset + 4, offset + 8);
+    const data = buffer.subarray(offset + 8, offset + 8 + length);
+    if (type === 'IHDR') {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      colorType = data[9] ?? 0;
+    } else if (type === 'IDAT') chunks.push(data);
+    else if (type === 'IEND') break;
+    offset += 12 + length;
+  }
+  const bytesPerPixel = colorType === 6 ? 4 : 3;
+  const raw = inflateSync(Buffer.concat(chunks));
+  const stride = width * bytesPerPixel;
+  let source = 0;
+  let previous = Buffer.alloc(stride);
+  const rows: Buffer[] = [];
+  for (let rowIndex = 0; rowIndex < height; rowIndex += 1) {
+    const filter = raw[source] ?? 0;
+    source += 1;
+    const row = Buffer.alloc(stride);
+    for (let index = 0; index < stride; index += 1) {
+      const value = raw[source] ?? 0;
+      source += 1;
+      const left = index >= bytesPerPixel ? row[index - bytesPerPixel] ?? 0 : 0;
+      const up = previous[index] ?? 0;
+      const upLeft = index >= bytesPerPixel ? previous[index - bytesPerPixel] ?? 0 : 0;
+      let decoded = value;
+      if (filter === 1) decoded = value + left;
+      else if (filter === 2) decoded = value + up;
+      else if (filter === 3) decoded = value + Math.floor((left + up) / 2);
+      else if (filter === 4) decoded = value + paeth(left, up, upLeft);
+      else if (filter !== 0) throw new Error(`unsupported png filter ${filter}`);
+      row[index] = decoded & 255;
+    }
+    rows.push(row);
+    previous = row;
+  }
+  const pixel = rows[y];
+  const start = x * bytesPerPixel;
+  return [pixel?.[start] ?? 0, pixel?.[start + 1] ?? 0, pixel?.[start + 2] ?? 0];
+}
+
+test('enlarged theme tokens do not let the answer heading share a lane', { skip }, async () => {
+  const root = resolve(import.meta.dirname, '..');
+  const files = new Map([
+    ['/Reader.module.css', readFileSync(join(root, 'src/client/Reader.module.css'))],
+    ['/MarkdownText.module.css', readFileSync(join(root, 'src/client/markdown/MarkdownText.module.css'))],
+    ['/', readFileSync(join(root, 'tests/fixtures/reader-theme-overlap.html'))],
+  ]);
+  const server = createServer((request, response) => {
+    const body = files.get(request.url ?? '/');
+    if (!body) { response.statusCode = 404; response.end(); return; }
+    response.setHeader('Content-Type', request.url?.endsWith('.css') ? 'text/css' : 'text/html');
+    response.end(body);
+  });
+  await new Promise<void>(resolveListen => server.listen(0, '127.0.0.1', resolveListen));
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  const { launchPinnedChromium } = await import(pathToFileURL(browserRuntime).href);
+  const browser = await launchPinnedChromium();
+  try {
+    const page = await browser.newPage({ viewport: { width: 1000, height: 320 }, deviceScaleFactor: 1 });
+    const errors: string[] = [];
+    page.on('pageerror', (error: Error) => errors.push(String(error)));
+    await page.goto(`http://127.0.0.1:${address.port}/`);
+    await page.waitForFunction(() => Reflect.get(window, '__themeOverlapReady') === true);
+    const atRest = await page.evaluate(() => {
+      const box = (selector: string) => {
+        const rect = document.querySelector(selector)!.getBoundingClientRect();
+        return { top: rect.top, right: rect.right, bottom: rect.bottom, left: rect.left };
+      };
+      const overlaps = (a: { top: number; right: number; bottom: number; left: number }, b: typeof a) =>
+        a.left < b.right - 1 && a.right > b.left + 1 && a.top < b.bottom - 1 && a.bottom > b.top + 1;
+      const status = box('[data-reader-lane="status"]');
+      const summary = box('#summary');
+      const heading = box('#heading');
+      return {
+        statusOverlapsSummary: overlaps(status, summary),
+        headingOverlapsSummary: overlaps(heading, summary),
+        headingBelowSummary: heading.top >= summary.bottom - 1,
+      };
+    });
+    assert.equal(atRest.statusOverlapsSummary, false);
+    assert.equal(atRest.headingOverlapsSummary, false);
+    assert.equal(atRest.headingBelowSummary, true);
+
+    await page.evaluate(() => {
+      const scroll = document.querySelector<HTMLElement>('#scroll')!;
+      const summary = document.querySelector('#summary')!.getBoundingClientRect();
+      const heading = document.querySelector('#heading')!.getBoundingClientRect();
+      scroll.scrollTop += heading.top - summary.top + 8;
+    });
+    const sample = await page.evaluate(() => {
+      const summary = document.querySelector('#summary')!.getBoundingClientRect();
+      const diff = document.querySelector('#summary .diffStatRoot')!.getBoundingClientRect();
+      return { x: Math.max(summary.left + 8, diff.left - 24), y: summary.top + 2 };
+    });
+    const shot = await page.screenshot({
+      clip: { x: sample.x, y: sample.y, width: 1, height: 1 },
+      scale: 'css',
+    });
+    const [red, green, blue] = pngPixel(shot, 0, 0);
+    assert.ok(Math.abs(red - 16) < 12 && Math.abs(green - 32) < 12 && Math.abs(blue - 64) < 12, `lane plate pixel was ${red},${green},${blue}`);
+
+    await page.evaluate(() => {
+      const scroll = document.querySelector<HTMLElement>('#scroll')!;
+      scroll.scrollTop = scroll.scrollHeight;
+    });
+    const stuck = await page.evaluate(() => {
+      const status = document.querySelector('#flow-status')!.getBoundingClientRect();
+      const summary = document.querySelector('#flow-summary')!.getBoundingClientRect();
+      return { statusBottom: status.bottom, summaryTop: summary.top, statusHeight: status.height };
+    });
+    assert.ok(stuck.statusHeight > 40, `expected the enlarged status row to exceed 40px, got ${stuck.statusHeight}`);
+    assert.ok(stuck.summaryTop >= stuck.statusBottom - 1, `summary top ${stuck.summaryTop} overlaps status bottom ${stuck.statusBottom}`);
+    assert.deepEqual(errors, []);
+  } finally {
+    await browser.close();
+    await new Promise<void>(resolveClose => server.close(() => resolveClose()));
+  }
+});

package/tests/reader-user-bubble.test.ts

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { transform } from 'lightningcss';
+import { test } from 'vitest';
+import { OFFICIAL_SEATS, OFFICIAL_SLOTS } from '../src/client/official-slots.js';
+
+// Width is a layout fact of the real Reader and the host user/steering renderer.
+// This skips in CI, which has no pinned Chromium and no Harness tree.
+const harnessPointer = join(homedir(), '.config/dshx/harness');
+const harness = process.env.DSHX_HARNESS?.trim()
+  || (existsSync(harnessPointer) ? readFileSync(harnessPointer, 'utf8').trim() : '');
+const browserRuntime = join(homedir(), '.codex/playwright-runtime/runtime.mjs');
+const skip = !harness ? 'DSH Harness source not available'
+  : !existsSync(browserRuntime) ? 'pinned Chromium runtime not available' : false;
+
+interface Box { w: number; h: number; font: string; line: string }
+interface Row {
+  name: string;
+  user: Box; steering: Box; pending: Box;
+  nativeUser: Box; nativeSteering: Box;
+  readerHtml: string;
+}
+interface BubbleResult {
+  error?: string;
+  readerSlot?: string;
+  nativeSlot?: string;
+  rows?: Row[];
+}
+
+test('reader user and steering bubbles match the host column cap', { skip, timeout: 120_000 }, async () => {
+  const root = resolve(import.meta.dirname, '..');
+  const require = createRequire(join(root, 'package.json'));
+  const { build } = createRequire(require.resolve('tsx'))('esbuild');
+  const webRequire = createRequire(join(harness, 'packages/client/web/package.json'));
+  const out = mkdtempSync(join(tmpdir(), 'reader-user-bubble-'));
+  const cssParts: string[] = [];
+  try {
+    const { launchPinnedChromium } = await import(pathToFileURL(browserRuntime).href);
+    await build({
+      entryPoints: [join(root, 'tests/fixtures/reader-user-bubble.tsx')],
+      outfile: join(out, 'fixture.js'), bundle: true, platform: 'browser', format: 'esm', jsx: 'automatic',
+      alias: {
+        '@fixture/registry': join(harness, 'packages/client/ui-renderer/src/client/registry.ts'),
+        '@fixture/renderer': join(harness, 'packages/client/ui-renderer/src/client/scoped-slots.tsx'),
+        '@fixture/user-message': join(harness, 'packages/client/ui-chat/src/client/chat/MessageItem.tsx'),
+        '@deepseek-ai/dsh-client-ui-primitives': join(harness, 'packages/client/ui-primitives/src/index.ts'),
+        '@deepseek-ai/dsh-client-ui-slots': join(harness, 'packages/client/ui-slots/src/index.ts'),
+        '@deepseek-ai/dsh-client-store': join(harness, 'packages/client/store/src/index.ts'),
+        react: dirname(require.resolve('react/package.json')),
+        'react-dom': dirname(webRequire.resolve('react-dom/package.json')),
+      },
+      loader: { '.woff2': 'empty', '.woff': 'empty', '.ttf': 'empty', '.png': 'empty', '.jpg': 'empty', '.webp': 'empty' },
+      plugins: [{
+        name: 'css-modules',
+        setup(build: { onLoad: Function; onEnd: Function }) {
+          build.onLoad({ filter: /\.module\.css$/ }, (args: { path: string }) => {
+            const result = transform({ filename: args.path, code: readFileSync(args.path), cssModules: { pattern: 't[hash]_[local]' } });
+            const mapping: Record<string, string> = {};
+            for (const [key, value] of Object.entries(result.exports ?? {})) mapping[key] = value.name;
+            cssParts.push(Buffer.from(result.code).toString('utf8'));
+            return { contents: `export default ${JSON.stringify(mapping)};`, loader: 'js' };
+          });
+          build.onLoad({ filter: /\.css$/ }, (args: { path: string }) => {
+            cssParts.push(readFileSync(args.path, 'utf8'));
+            return { contents: 'export default {};', loader: 'js' };
+          });
+          build.onLoad({ filter: /\.svg$/ }, () => ({ contents: 'export default function Svg(){return null}', loader: 'js' }));
+          build.onEnd(() => { writeFileSync(join(out, 'fixture.css'), cssParts.join('\n')); });
+        },
+      }],
+      logLevel: 'silent',
+    });
+    const server = createServer((request, response) => {
+      if (request.url === '/fixture.js') {
+        response.setHeader('Content-Type', 'text/javascript');
+        response.end(readFileSync(join(out, 'fixture.js')));
+      } else if (request.url === '/fixture.css') {
+        response.setHeader('Content-Type', 'text/css');
+        response.end(readFileSync(join(out, 'fixture.css')));
+      } else {
+        response.setHeader('Content-Type', 'text/html');
+        response.end('<!doctype html><meta charset="utf-8"><link rel="stylesheet" href="/fixture.css"><style>html,body{margin:0;font-family:"PingFang SC","Hiragino Sans GB",sans-serif}</style><div id="app"></div><script type="module" src="/fixture.js"></script>');
+      }
+    });
+    await new Promise<void>(resolveListen => server.listen(0, '127.0.0.1', resolveListen));
+    let browser;
+    try {
+      browser = await launchPinnedChromium();
+      const page = await browser.newPage({ viewport: { width: 1400, height: 900 } });
+      const errors: string[] = [];
+      page.on('pageerror', (error: Error) => errors.push(String(error)));
+      page.on('console', (message: { type(): string; text(): string }) => {
+        if (message.type() === 'error') errors.push(message.text());
+      });
+      const address = server.address();
+      assert.ok(address && typeof address === 'object');
+      await page.goto(`http://127.0.0.1:${address.port}`);
+      await page.waitForFunction(() => 'readerBubbleResult' in window, undefined, { timeout: 20000 });
+      const result = await page.evaluate(() => Reflect.get(window, 'readerBubbleResult')) as BubbleResult;
+      assert.equal(result.error, undefined, result.error);
+      assert.deepEqual(errors, []);
+      assert.equal(result.readerSlot, OFFICIAL_SEATS.nodes);
+      assert.equal(result.nativeSlot, OFFICIAL_SLOTS.nodes);
+      assert.notEqual(result.readerSlot, 'conversation.chat.node');
+      for (const row of result.rows ?? []) {
+        assert.equal(row.user.w, row.nativeUser.w, `${row.name} user width ${row.user.w} != ${row.nativeUser.w} ${row.readerHtml}`);
+        assert.equal(row.user.h, row.nativeUser.h, `${row.name} user height`);
+        assert.equal(row.steering.w, row.nativeSteering.w, `${row.name} steering width`);
+        assert.equal(row.steering.h, row.nativeSteering.h, `${row.name} steering height`);
+        assert.equal(row.pending.w, row.nativeUser.w, `${row.name} pending width`);
+        assert.equal(row.pending.h, row.nativeUser.h, `${row.name} pending height`);
+        assert.equal(row.pending.font, '14px', `${row.name} pending font`);
+        assert.equal(row.pending.line, '22px', `${row.name} pending line`);
+        assert.equal(row.nativeUser.font, '14px', `${row.name} native font`);
+        assert.equal(row.nativeUser.line, '22px', `${row.name} native line`);
+      }
+      const byName = Object.fromEntries((result.rows ?? []).map(row => [row.name, row]));
+      assert.ok(byName.short.user.h < 50, 'a four-glyph message stays on one line');
+      assert.ok(byName.short.user.w < 160, 'a four-glyph message stays content-sized');
+      assert.ok(byName.thirty.user.h < 50, 'thirty glyphs fit on one line at the default column');
+      assert.ok(Math.abs(byName.long.user.w - 748 * 0.702) < 1, 'the default cap follows 748 * 0.702');
+      assert.ok(byName['wide-axis'].user.w > 540, 'a wider content axis is not stuck at 525px');
+      assert.ok(Math.abs(byName.narrow.user.w - 480 * 0.82) < 1, 'a narrow column uses 82% of the column');
+      assert.ok(byName.short.steering.h < 50, 'a short steering message stays on one line');
+    } finally {
+      await browser?.close();
+      await new Promise<void>(resolveClose => server.close(() => resolveClose()));
+    }
+  } finally {
+    rmSync(out, { recursive: true, force: true });
+  }
+});

package/tests/reasoning-follow.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { test } from 'vitest';
 import { reasoningTarget } from '../src/client/reasoning-follow.js';
 
 test('reasoning follows ordinary growth in two-line steps without passing the tail', () => {

package/tests/retiring-content.test.ts

@@ -0,0 +1,229 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { runInNewContext } from 'node:vm';
+import ts from 'typescript';
+
+const source = readFileSync(new URL('../src/client/motion.tsx', import.meta.url), 'utf8');
+const retiring = source.slice(source.indexOf('export function RetiringContent('), source.indexOf('// DOM-only behavior:'));
+const compiled = ts.transpileModule(`const EASING = 'cubic-bezier(.22,1,.36,1)';\n${retiring}`, {
+  fileName: 'retiring.tsx',
+  compilerOptions: { module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX },
+}).outputText;
+
+// Drive the component's real effect with deterministic hooks and a compositor
+// that never finishes unless the test explicitly sends onfinish.
+function mount(options?: { containsFocus?: boolean; hidden?: boolean }) {
+  let cursor = 0;
+  let enabled = true;
+  const hooks: unknown[] = [];
+  const effects = new Map<number, { deps: unknown[]; cleanup?: () => void }>();
+  let pending: Array<{ index: number; run: () => (() => void) | void; deps: unknown[] }> = [];
+  let timerId = 0;
+  const timers = new Map<number, { run: () => void; duration: number }>();
+  const animations: Array<{ onfinish?: () => void; cancelled: number }> = [];
+  const cutFocus = { id: 'focus-cut' };
+  const outside = { id: 'outside' };
+  const listeners = new Set<() => void>();
+  const column = {
+    id: 'reader-column',
+    tabIndex: -1,
+    focus() { page.active = column; },
+  };
+  const page = {
+    hidden: options?.hidden ?? false,
+    active: (options?.containsFocus ? cutFocus : null) as { id: string } | null,
+  };
+  const element = {
+    contains: (node: unknown) => node === cutFocus,
+    closest: (selector: string) => selector === '[data-chat-flow]' ? column : null,
+    parentElement: null,
+    getBoundingClientRect: () => ({ height: 64 }),
+    animate: (_frames: unknown, options: { duration: number; fill: string }) => {
+      assert.equal(options.duration, 220);
+      assert.equal(options.fill, 'both');
+      const animation = { cancelled: 0, cancel() { this.cancelled++; } };
+      animations.push(animation);
+      return animation;
+    },
+  };
+  const effect = (run: () => (() => void) | void, deps: unknown[]) => {
+    const index = cursor++;
+    const previous = effects.get(index);
+    if (!previous || deps.some((value, at) => value !== previous.deps[at])) pending.push({ index, run, deps });
+  };
+  const exports: { RetiringContent?: (props: { visible: boolean; children: string }) => unknown } = {};
+  runInNewContext(compiled, {
+    exports,
+    require: createRequire(import.meta.url),
+    css: { retiringContent: 'retiring' },
+    StreamMotionContext: {},
+    HTMLElement: globalThis.HTMLElement,
+    Element: globalThis.Element,
+    document: {
+      get activeElement() { return page.active; },
+      get hidden() { return page.hidden; },
+      addEventListener: (type: string, listener: () => void) => { if (type === 'visibilitychange') listeners.add(listener); },
+      removeEventListener: (type: string, listener: () => void) => { if (type === 'visibilitychange') listeners.delete(listener); },
+    },
+    window: {
+      setTimeout: (run: () => void, duration: number) => { timers.set(++timerId, { run, duration }); return timerId; },
+      clearTimeout: (id: number) => { timers.delete(id); },
+    },
+    useContext: () => ({ enabled }),
+    useRef: (initial: unknown) => {
+      const index = cursor++;
+      if (!(index in hooks)) hooks[index] = { current: initial };
+      return hooks[index];
+    },
+    useState: (initial: unknown) => {
+      const index = cursor++;
+      if (!(index in hooks)) hooks[index] = initial;
+      return [hooks[index], (value: unknown) => { hooks[index] = value; }];
+    },
+    useLayoutEffect: effect,
+    useEffect: effect,
+  });
+  assert.equal(typeof exports.RetiringContent, 'function');
+  type Rendered = { ref: { current: unknown }; props: { onBlur: (event: unknown) => void } };
+  let last: Rendered | null = null;
+  const render = (visible: boolean) => {
+    cursor = 0;
+    pending = [];
+    const result = exports.RetiringContent!({ visible, children: 'narration' }) as Rendered | null;
+    last = result;
+    if (result) result.ref.current = element;
+    for (const { index, run, deps } of pending) {
+      effects.get(index)?.cleanup?.();
+      effects.set(index, { deps, cleanup: run() ?? undefined });
+    }
+    return result;
+  };
+  render(true);
+  return {
+    render, timers, animations, listeners,
+    focusId: () => page.active?.id ?? '',
+    // Move focus out of the cut the way a real blur reports it.
+    blur: () => {
+      page.active = outside;
+      last?.props.onBlur({ currentTarget: element, relatedTarget: outside });
+    },
+    hide: () => {
+      page.hidden = true;
+      for (const listener of [...listeners]) listener();
+    },
+    disableMotion: () => { enabled = false; },
+    unmount: () => { for (const effect of effects.values()) effect.cleanup?.(); },
+    deadline: () => {
+      const [id, timer] = [...timers][0] ?? [];
+      assert.ok(timer, 'retiring animation must have a deadline');
+      assert.equal(timer.duration, 460);
+      timers.delete(id);
+      timer.run();
+    },
+  };
+}
+
+test('retiring narration unmounts on its deadline when onfinish never fires', () => {
+  const view = mount();
+  assert.ok(view.render(false));
+  view.deadline();
+  assert.equal(view.animations[0].cancelled, 1);
+  assert.equal(view.render(false), null);
+  view.unmount();
+});
+
+test('normal finish settles once and removes the deadline on cleanup', () => {
+  const view = mount();
+  view.render(false);
+  view.animations[0].onfinish?.();
+  view.animations[0].onfinish?.();
+  assert.equal(view.animations[0].cancelled, 1);
+  assert.equal(view.render(false), null);
+  view.unmount();
+  assert.equal(view.timers.size, 0);
+});
+
+test('visibility reversal and unmount cancel the deadline and release animation fill', () => {
+  const view = mount();
+  view.render(false);
+  const staleFinish = view.animations[0].onfinish;
+  assert.ok(view.render(true));
+  assert.equal(view.timers.size, 0);
+  assert.equal(view.animations[0].cancelled, 1);
+  staleFinish?.();
+  assert.ok(view.render(true));
+  view.render(false);
+  view.unmount();
+  assert.equal(view.timers.size, 0);
+  assert.equal(view.animations[1].cancelled, 1);
+});
+
+test('disabled motion retires immediately without an animation or timer', () => {
+  const view = mount();
+  view.disableMotion();
+  view.render(false);
+  assert.equal(view.render(false), null);
+  assert.equal(view.animations.length, 0);
+  assert.equal(view.timers.size, 0);
+  view.unmount();
+});
+
+test('reduced motion moves focus out of cut content before it unmounts', () => {
+  const reduced = mount({ containsFocus: true });
+  reduced.disableMotion();
+  reduced.render(false);
+  assert.equal(reduced.render(false), null);
+  assert.equal(reduced.focusId(), 'reader-column');
+  assert.equal(reduced.animations.length, 0);
+  reduced.unmount();
+
+  const hidden = mount({ containsFocus: true, hidden: true });
+  hidden.render(false);
+  assert.equal(hidden.render(false), null);
+  assert.equal(hidden.focusId(), 'reader-column');
+  assert.equal(hidden.animations.length, 0);
+  hidden.unmount();
+
+  // The animated path still defers while focus is inside the cut.
+  const playing = mount({ containsFocus: true });
+  assert.ok(playing.render(false));
+  assert.equal(playing.focusId(), 'focus-cut');
+  assert.equal(playing.animations.length, 0);
+  playing.unmount();
+});
+
+test('a page hidden while focus defers the collapse retires at once and keeps focus', () => {
+  const view = mount({ containsFocus: true });
+  assert.ok(view.render(false));
+  // The focus-held state re-runs the effect; it must keep waiting, not animate.
+  assert.ok(view.render(false));
+  assert.equal(view.focusId(), 'focus-cut');
+  assert.equal(view.animations.length, 0);
+  assert.equal(view.listeners.size, 1, 'the focus-held path still listens for a hidden page');
+  view.hide();
+  assert.equal(view.render(false), null);
+  assert.equal(view.focusId(), 'reader-column');
+  assert.equal(view.animations.length, 0);
+  assert.equal(view.timers.size, 0);
+  view.unmount();
+  assert.equal(view.listeners.size, 0);
+});
+
+test('focus leaving the cut still plays the collapse, bounded by its deadline', () => {
+  const view = mount({ containsFocus: true });
+  view.render(false);
+  view.render(false);
+  assert.equal(view.animations.length, 0);
+  view.blur();
+  assert.ok(view.render(false));
+  assert.equal(view.animations.length, 1);
+  assert.equal(view.listeners.size, 1);
+  view.deadline();
+  assert.equal(view.render(false), null);
+  assert.equal(view.focusId(), 'outside');
+  view.unmount();
+  assert.equal(view.listeners.size, 0);
+  assert.equal(view.timers.size, 0);
+});

package/tests/reveal.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Context } from '@deepseek-ai/cordis';
+import { createRevealHandler, resolveRevealPath, revealPath, revealRoots } from '../src/reveal.js';
+import { isAbsoluteWorkspacePath } from '../src/workspace-path.js';
+import { dirname } from '../src/client/deliverables.js';
+
+test('absolute parent predicate accepts POSIX, drive and UNC roots only', () => {
+  for (const path of ['/', '/repo', 'C:\\', 'C:/', 'D:\\5- AI\\docs', '\\\\server\\share']) {
+    assert.equal(isAbsoluteWorkspacePath(path), true, path);
+  }
+  for (const path of ['', '.', 'docs', './docs', '../docs', 'C:', 'C:docs', '\\docs']) {
+    assert.equal(isAbsoluteWorkspacePath(path), false, path);
+  }
+  assert.equal(dirname('/a.txt'), '/');
+  assert.equal(dirname('C:\\a.txt'), 'C:\\');
+  assert.equal(dirname('C:/a.txt'), 'C:/');
+  assert.equal(isAbsoluteWorkspacePath(dirname('docs/a.txt')), false);
+});
+
+async function workspace(t: { onTestFinished: (cleanup: () => Promise<void>) => void }) {
+  const root = await mkdtemp(join(tmpdir(), 'bd-reveal-'));
+  t.onTestFinished(() => rm(root, { recursive: true, force: true }));
+  await mkdir(join(root, 'docs'));
+  await writeFile(join(root, 'docs', 'report.md'), 'report');
+  return root;
+}
+
+test('relative resolution uses an existing full path, rejects missing and ambiguous matches', async t => {
+  const root = await workspace(t);
+  const other = await workspace(t);
+  assert.equal(resolveRevealPath('docs/report.md', [root]), join(root, 'docs', 'report.md'));
+  assert.equal(resolveRevealPath('docs/report.md', ['/missing-root', root, root]), join(root, 'docs', 'report.md'));
+  assert.throws(() => resolveRevealPath('docs/missing.md', [root]), /not found/);
+  assert.throws(() => resolveRevealPath('docs/report.md', []), /not found/);
+  assert.throws(() => resolveRevealPath('docs/report.md', [root, other]), /ambiguous/);
+  assert.equal(resolveRevealPath('/absolute/file', []), '/absolute/file');
+});
+
+test('relative resolution preserves Windows drive and UNC spelling', () => {
+  const exists = (path: string) => ['D:\\5- AI\\docs\\report.md', '\\\\server\\share\\docs\\report.md'].includes(path);
+  assert.equal(resolveRevealPath('docs/report.md', ['D:\\5- AI'], exists), 'D:\\5- AI\\docs\\report.md');
+  assert.equal(resolveRevealPath('docs/report.md', ['\\\\server\\share'], exists), '\\\\server\\share\\docs\\report.md');
+  assert.throws(() => resolveRevealPath('C:report.md', ['D:\\5- AI'], exists), /not workspace-relative/);
+  assert.throws(() => resolveRevealPath('\\report.md', ['D:\\5- AI'], exists), /not workspace-relative/);
+});
+
+function context(services: Record<string, unknown>): Context {
+  return { get: (name: string) => services[name] } as unknown as Context;
+}
+
+test('host roots use only the target live session or its registered workspace', async () => {
+  const ctx = context({
+    sessions: { get: (id: string) => id === 'target' ? { header: { cwd: '/target' } } : undefined },
+    workspaceRegistry: { list: () => [
+      { path: '/other', sessionIds: ['other'] },
+      { path: '/cold', sessionIds: ['cold'] },
+    ] },
+  });
+  assert.deepEqual(await revealRoots(ctx, 'target'), ['/target']);
+  assert.deepEqual(await revealRoots(ctx, 'cold'), ['/cold']);
+  assert.deepEqual(await revealRoots(ctx, 'unknown'), []);
+  assert.deepEqual(await revealRoots(ctx, undefined), ['/other', '/cold']);
+});
+
+test('cold session roots are read without projections and the observation is disposed', async () => {
+  let disposed = false;
+  const ctx = context({ sessionQuery: {
+    observeSession: async (id: string, options: unknown) => {
+      assert.equal(id, 'cold');
+      assert.deepEqual(options, { projectionMode: 'none' });
+      return { header: { cwd: '/cold' }, [Symbol.dispose]: () => { disposed = true; } };
+    },
+  } });
+  assert.deepEqual(await revealRoots(ctx, 'cold'), ['/cold']);
+  assert.equal(disposed, true);
+});
+
+async function request(handler: ReturnType<typeof createRevealHandler>, body: string, method = 'POST') {
+  const req = new IncomingMessage(new Socket());
+  req.method = method;
+  const res = new ServerResponse(req);
+  const response = new Promise<{ status: number; body: string }>(resolve => {
+    res.end = (chunk: string) => {
+      resolve({ status: res.statusCode, body: chunk ?? '' });
+      return res;
+    };
+  });
+  handler(req, res);
+  req.emit('data', body);
+  req.emit('end');
+  return response;
+}
+
+test('reveal route resolves a session-relative request and never opens a missing path', async t => {
+  const root = await workspace(t);
+  const opened: string[] = [];
+  const handler = createRevealHandler({
+    roots: async sessionId => { assert.equal(sessionId, 'target'); return [root]; },
+    reveal: path => { opened.push(path); },
+  });
+  assert.deepEqual(await request(handler, JSON.stringify({ path: 'docs/report.md', sessionId: 'target' })), {
+    status: 200, body: '{"ok":true}',
+  });
+  assert.equal((await request(handler, JSON.stringify({ path: 'docs/missing.md', sessionId: 'target' }))).status, 400);
+  assert.deepEqual(opened, [join(root, 'docs', 'report.md')]);
+  assert.equal((await request(handler, '{}')).status, 400);
+  assert.equal((await request(handler, 'invalid')).status, 400);
+  assert.equal((await request(handler, '', 'GET')).status, 405);
+});
+
+test('absolute requests bypass root lookup and Explorer receives a quoted verbatim selection', async () => {
+  const path = 'D:\\5- AI\\docs\\report.md';
+  const calls: unknown[] = [];
+  const handler = createRevealHandler({
+    roots: async () => { throw new Error('absolute requests do not need roots'); },
+    reveal: target => revealPath(target, 'win32', (...args) => { calls.push(args); }),
+  });
+  assert.equal((await request(handler, JSON.stringify({ path }))).status, 200);
+  assert.deepEqual(calls, [['explorer.exe', ['/select,"D:\\5- AI\\docs\\report.md"'], {
+    detached: true, stdio: 'ignore', windowsVerbatimArguments: true,
+  }]]);
+});