dsh-better-display 0.3.7 → 0.3.9

package/src/client/live-turn.ts

@@ -2,7 +2,6 @@ import type { AssistantChatData, ChatConversationViewNode } from '@deepseek-ai/d
 import type { AssistantBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import { assistantSegments, hasVisibleBody } from './projection.js';
 import type { TurnBoundary } from './projection.js';
-import { activitySummary, stringValue } from './tool-activity.js';
 import type { ReaderFlowEntry, ToolActivityEntry } from './tool-activity.js';
 
 export type LiveStep =
@@ -40,17 +39,6 @@ export function foldSummary(steps: readonly LiveStep[]): string {
   return parts.join(' · ') || '此前步骤';
 }
 
-/** One chain: fold only when a new reasoning step has prior body/tool/reasoning. */
-export function splitChain(chain: readonly LiveStep[]): { fold: readonly LiveStep[] | null; open: readonly LiveStep[] } {
-  const lastReasoning = chain.findLastIndex(step => step.kind === 'reasoning');
-  if (lastReasoning < 0) return { fold: null, open: chain };
-  const prior = chain.slice(0, lastReasoning);
-  if (!prior.length) return { fold: null, open: chain };
-  const trigger = prior.some(step => step.kind === 'reasoning' || step.kind === 'body' || step.kind === 'tool');
-  if (!trigger) return { fold: null, open: chain };
-  return { fold: prior, open: chain.slice(lastReasoning) };
-}
-
 function skipReasoning(part: { kind: string; blocks: AssistantBlock[] }): boolean {
   return part.kind === 'reasoning' && !part.blocks.some(block => block.kind === 'reasoning' && block.text.trim() !== '');
 }
@@ -125,74 +113,117 @@ export function segmentLiveTurn(
   return steps;
 }
 
-/** One finished tool call, described by what it actually did. */
-function toolSummary(entry: ToolActivityEntry): string {
-  const info = activitySummary(entry);
-  const clip = (value: string | undefined, max = 38): string | undefined => {
-    if (!value) return undefined;
-    const flat = value.replace(/\s+/gu, ' ').trim();
-    if (!flat) return undefined;
-    return flat.length > max ? flat.slice(0, max - 1) + '\u2026' : flat;
-  };
-  const base = info.target ? clip(info.target.split(/[/\\]/u).at(-1), 28) : undefined;
-  const said = clip(stringValue(info.args, 'description'), 40);
-  switch (info.category) {
-    case 'read': return '读取 ' + (base ?? '文件');
-    case 'write': return clip(info.title, 40) ?? '写入文件';
-    case 'terminal': {
-      const cmd = clip(info.command, 32);
-      return said ?? (cmd ? '运行 ' + cmd : '运行命令');
-    }
-    case 'search': {
-      const needle = clip(stringValue(info.args, 'pattern', 'query'), 26);
-      return info.name === 'glob' ? '查找 ' + (needle ?? '文件') : '搜索 ' + (needle ?? '内容');
-    }
-    case 'web': {
-      const query = clip(info.target, 30);
-      return (info.name === 'web_search' ? '搜索网页' : '读取网页') + (query ? ' ' + query : '');
-    }
-    default: {
-      // Schema-less tools (run_code and friends) describe themselves in an
-      // argument rather than a known field: prefer the model's own
-      // description, then the first meaningful line of the code it ran.
-      if (said) return said;
-      const code = stringValue(info.args, 'code', 'source', 'script');
-      if (code) {
-        const line = code.split('\n').map(part => part.trim())
-          .find(part => part && !/^[)\]}]/.test(part) && !/^(\/\/|\*|\/\*|#)/.test(part));
-        if (line) return clip(line.replace(/\s+/gu, ' '), 44) ?? '运行代码';
-      }
-      return clip(info.title ?? info.name, 32) ?? '工具调用';
-    }
-  }
+/** Only a run that contains real thinking/tool work is worth folding. */
+function foldableRun(run: readonly LiveStep[]): boolean {
+  return run.some(step => step.kind === 'reasoning' || step.kind === 'tool');
 }
 
+/**
+ * One live chain: narration stays visible, while every earlier reasoning/tool
+ * run collapses into its own box at its original position.
+ */
 export function presentLiveTurn(steps: readonly LiveStep[], boundary: TurnBoundary, autoFold = true): LiveTurnItem[] {
   const live = autoFold && liveFoldEnabled(boundary);
   const items: LiveTurnItem[] = [];
-  let chain: LiveStep[] = [];
-  const flush = () => {
-    if (!chain.length) return;
-    if (!live) {
-      for (const step of chain) items.push({ kind: 'open', key: step.key, step });
-      chain = [];
-      return;
-    }
-    const { fold, open } = splitChain(chain);
-    if (fold?.length) {
-      items.push({ kind: 'fold', key: `live-fold:${chain[0]!.key}`, steps: fold, summary: foldSummary(fold) });
+  const open = (step: LiveStep) => items.push({ kind: 'open', key: step.key, step });
+  const fold = (run: readonly LiveStep[]) => {
+    if (!run.length) return;
+    if (live && foldableRun(run)) {
+      items.push({ kind: 'fold', key: `live-fold:${run[0]!.key}`, steps: run, summary: foldSummary(run) });
+    } else {
+      for (const step of run) open(step);
     }
-    for (const step of open) items.push({ kind: 'open', key: step.key, step });
-    chain = [];
   };
+  let run: LiveStep[] = [];
+  const flush = () => { fold(run); run = []; };
+
+  // A user insert resets the chain: steps before it are never folded by
+  // reasoning after it. Split into user-delimited segments and walk each one.
+  const segments: LiveStep[][] = [];
+  let segment: LiveStep[] = [];
   for (const step of steps) {
     if (step.kind === 'user') {
-      flush();
-      items.push({ kind: 'user', key: step.key, step });
+      segments.push(segment); segments.push([step]); segment = [];
     } else {
-      chain.push(step);
+      segment.push(step);
     }
   }
-  flush();
+  segments.push(segment);
+
+  for (const part of segments) {
+    if (!part.length) continue;
+    const first = part[0]!;
+    if (part.length === 1 && first.kind === 'user') {
+      items.push({ kind: 'user', key: first.key, step: first });
+      continue;
+    }
+    if (!live) {
+      for (const step of part) open(step);
+      continue;
+    }
+    // Narration is never folded. Once a later reasoning step exists, every
+    // reasoning/tool run before it folds at its own position, so the latest
+    // thinking and everything after it stay open while earlier steps collapse —
+    // even across narration blocks, which the reader still renders in place.
+    const lastReasoning = part.findLastIndex(step => step.kind === 'reasoning');
+    if (lastReasoning <= 0) {
+      for (const step of part) open(step);
+      continue;
+    }
+    for (let index = 0; index < part.length; index++) {
+      const step = part[index]!;
+      if (index < lastReasoning) {
+        if (step.kind === 'body') { flush(); open(step); }
+        else run.push(step);
+      } else {
+        if (index === lastReasoning) flush();
+        open(step);
+      }
+    }
+    flush();
+  }
   return items;
 }
+
+/**
+ * Summaries for collapsed process that sits between two narration blocks.
+ *
+ * A live-fold cell already shows that summary while the turn is open. Drawing
+ * the seam as well repeats the same counts, so a run whose every step is
+ * already inside a fold cell contributes neither a seam nor `after`. `after`
+ * is what marks the previous body with `data-reader-seam-after` and drops its
+ * bottom padding; skipping the seam must leave that spacing alone.
+ */
+export function planProcessSeams(
+  steps: readonly LiveStep[],
+  liveItems: readonly LiveTurnItem[],
+  expanded: boolean,
+): { before: Map<string, string>; after: Set<string> } {
+  const before = new Map<string, string>();
+  const after = new Set<string>();
+  if (expanded) return { before, after };
+  const liveFolded = new Set(
+    liveItems.flatMap(item => item.kind === 'fold' ? item.steps.map(step => step.key) : []),
+  );
+  let previousBody: Extract<LiveStep, { kind: 'body' }> | undefined;
+  let process: LiveStep[] = [];
+  for (const step of steps) {
+    if (step.kind === 'body') {
+      const folded = process.filter(item => item.kind !== 'user');
+      const coveredByLiveFold = folded.length > 0 && folded.every(item => liveFolded.has(item.key));
+      if (!coveredByLiveFold && previousBody
+        && folded.some(item => item.kind === 'reasoning' || item.kind === 'tool' || item.kind === 'other')) {
+        before.set(step.key, foldSummary(folded));
+        after.add(previousBody.key);
+      }
+      previousBody = step;
+      process = [];
+    } else if (step.kind === 'user') {
+      previousBody = undefined;
+      process = [];
+    } else {
+      process.push(step);
+    }
+  }
+  return { before, after };
+}

package/src/client/motion.tsx

@@ -2,6 +2,7 @@ import { useCallback, useContext, useEffect, useLayoutEffect, useRef, useState }
 import type { ReactNode, RefObject } from 'react';
 import css from './Reader.module.css';
 import { StreamMotionContext } from './streaming.js';
+import { reconcileTurnSlots, type TurnSlot } from './turn-slots.js';
 
 const EASING = 'cubic-bezier(.22,1,.36,1)';
 
@@ -16,7 +17,7 @@ export function useMotionAllowed(enabled: boolean): boolean {
   return enabled && !reduced;
 }
 
-export function usePinnedSelection(root: RefObject<HTMLElement>, selector = '[data-reader-answer], [data-reader-process]'): readonly string[] {
+export function usePinnedSelection(root: RefObject<HTMLElement>, selector = '[data-reader-answer], [data-reader-body], [data-reader-process]'): readonly string[] {
   const [keys, setKeys] = useState<readonly string[]>([]);
   useEffect(() => {
     const update = () => {
@@ -89,7 +90,7 @@ export function StatusText({ text, motion, shimmer = false }: { text: string; mo
 
 export function Disclosure({ open, onChange, label, controls, buttonRef, ariaLabel }: {
   open: boolean; onChange: (value: boolean) => void; label: ReactNode;
-  controls?: string; buttonRef: RefObject<HTMLButtonElement>;
+  controls?: string; buttonRef?: RefObject<HTMLButtonElement>;
   ariaLabel?: string;
 }) {
   const name = ariaLabel ?? '思考与过程';
@@ -170,12 +171,16 @@ export function ProcessFragment({ open, motion, onRead, returnFocusTo, nodeKey,
 }
 
 /** Retire only narration that was actually visible; historical rows stay folded. */
-export function RetiringContent({ visible, children }: { visible: boolean; children: ReactNode }) {
+export function RetiringContent({ visible, children, onRetired }: { visible: boolean; children: ReactNode; onRetired?: () => void }) {
   const { enabled } = useContext(StreamMotionContext);
   const root = useRef<HTMLDivElement>(null);
   const animation = useRef<Animation | null>(null);
   const [present, setPresent] = useState(visible);
   const [focusHeld, setFocusHeld] = useState(false);
+  // Held in a ref so a caller passing an inline closure does not restart the
+  // collapse every render, and so the settle path always sees the latest one.
+  const retired = useRef(onRetired);
+  retired.current = onRetired;
   useLayoutEffect(() => {
     const element = root.current;
     if (visible) {
@@ -184,14 +189,52 @@ export function RetiringContent({ visible, children }: { visible: boolean; child
       return;
     }
     if (!element) return;
-    if (element.contains(document.activeElement)) { setFocusHeld(true); return; }
-    if (focusHeld) return;
+    // Reduced motion and a hidden page settle immediately. Focus may defer a
+    // collapse that will actually play; it must not pin a reduced-motion rewind.
+    // Move it to a surviving turn or the reading column first, or the browser
+    // drops it on the document when this subtree unmounts.
+    let retiredNow = false;
+    const retireNow = () => {
+      if (retiredNow) return;
+      retiredNow = true;
+      animation.current?.cancel(); animation.current = null;
+      focusSurvivesRetire(element);
+      setPresent(false); retired.current?.();
+    };
+    if (!enabled || document.hidden) { retireNow(); return; }
+    // The retiring-content harness stubs document without addEventListener.
+    const canListen = typeof document.addEventListener === 'function';
+    const holdsFocus = element.contains(document.activeElement);
+    if (holdsFocus || focusHeld) {
+      if (holdsFocus) setFocusHeld(true);
+      // Focus defers only a collapse that will play. `document.hidden` is not
+      // state, so a page hidden while focus waits must retire from here.
+      const onHiddenWhileHeld = () => { if (document.hidden) retireNow(); };
+      if (canListen) document.addEventListener('visibilitychange', onHiddenWhileHeld);
+      return () => { if (canListen) document.removeEventListener('visibilitychange', onHiddenWhileHeld); };
+    }
     const from = element.getBoundingClientRect().height;
     animation.current?.cancel(); animation.current = null;
-    if (!enabled || from < 1) { setPresent(false); return; }
+    if (from < 1) { setPresent(false); retired.current?.(); return; }
     const next = element.animate([{ height: `${from}px`, opacity: 1 }, { height: '0px', opacity: 0 }], { duration: 220, easing: EASING, fill: 'both' });
     animation.current = next;
-    next.onfinish = () => { if (animation.current === next) { animation.current = null; next.cancel(); setPresent(false); } };
+    let settled = false;
+    const settle = () => {
+      if (settled || animation.current !== next) return;
+      settled = true;
+      animation.current = null; next.cancel(); setPresent(false); retired.current?.();
+    };
+    next.onfinish = settle;
+    // #60: a stalled WAAPI finish must not leave the row mounted.
+    const deadline = window.setTimeout(settle, 220 + 240);
+    const onHide = () => { if (document.hidden) settle(); };
+    if (canListen) document.addEventListener('visibilitychange', onHide);
+    return () => {
+      window.clearTimeout(deadline);
+      if (canListen) document.removeEventListener('visibilitychange', onHide);
+      if (animation.current === next) animation.current = null;
+      next.cancel();
+    };
   }, [visible, enabled, focusHeld]);
   useEffect(() => () => animation.current?.cancel(), []);
   if (!visible && !present) return null;
@@ -201,6 +244,98 @@ export function RetiringContent({ visible, children }: { visible: boolean; child
   </div>;
 }
 
+/**
+ * Keeps a departing turn mounted for the length of its own collapse.
+ *
+ * A rewind removes turns from the visible order, and unmounting them outright
+ * snapped the transcript: every withdrawn row disappeared in one frame with
+ * nothing to scroll. Instead each departing turn is retained, rendered with
+ * `visible={false}` so it animates to zero height, and released only once the
+ * collapse has settled — so the reader watches the rows fold away and the rows
+ * below glide up into their place.
+ *
+ * Live slots follow the incoming group order, so older history stays above the
+ * tail. A collapsing turn stays next to the live neighbour that preceded it;
+ * appending it would jump it to the bottom for the length of the animation.
+ * Retention is bounded by the animation itself: `onRetired`
+ * drops the slot, so a departing turn lives for one collapse and no longer —
+ * and a key that comes back later is re-added as a live slot.
+ */
+export function RetiringTurns<T extends { readonly key: string }>({ groups, render }: {
+  groups: readonly T[];
+  render: (group: T) => ReactNode;
+}) {
+  const [slots, setSlots] = useState<readonly TurnSlot<T>[]>(() =>
+    groups.map((group) => ({ group, live: true })),
+  );
+  // Reconcile after every commit rather than during render: a key that left the
+  // order becomes `live: false` and keeps its index, which is what lets the
+  // collapse play in place instead of jumping the turn to the bottom.
+  useLayoutEffect(() => {
+    setSlots(current => reconcileTurnSlots(current, groups));
+  }, [groups]);
+  return (
+    <>
+      {slots.map((slot) => (
+        <RetiringContent
+          key={slot.group.key}
+          visible={slot.live}
+          onRetired={() => setSlots((current) => current.filter((candidate) =>
+            candidate.live || candidate.group.key !== slot.group.key))}
+        >
+          {render(slot.group)}
+        </RetiringContent>
+      ))}
+    </>
+  );
+}
+
+/** A turn that is still on screen, not one this commit is about to unmount. */
+function survivingTurn(node: Element): HTMLElement | null {
+  if (!(node instanceof HTMLElement) || node.dataset.readerRetiring === 'retiring') return null;
+  const turn = node.hasAttribute('data-reader-turn') ? node : node.querySelector<HTMLElement>('[data-reader-turn]');
+  if (turn === null) return null;
+  const retiring = turn.closest('[data-reader-retiring]');
+  if (retiring instanceof HTMLElement && retiring.dataset.readerRetiring === 'retiring') return null;
+  return turn;
+}
+
+/**
+ * Where focus goes when cut content is removed without an animation.
+ * Prefer the nearest turn that is still live. Otherwise the reading column
+ * (or the host scrollport) so focus does not fall through to the document.
+ */
+function retireFocusTarget(element: HTMLElement): HTMLElement | null {
+  const parent = element.parentElement;
+  if (parent) {
+    const siblings = [...parent.children];
+    const index = siblings.indexOf(element);
+    for (let cursor = index - 1; cursor >= 0; cursor--) {
+      const turn = survivingTurn(siblings[cursor]!);
+      if (turn) return turn;
+    }
+    for (let cursor = index + 1; cursor < siblings.length; cursor++) {
+      const turn = survivingTurn(siblings[cursor]!);
+      if (turn) return turn;
+    }
+  }
+  const column = element.closest<HTMLElement>('[data-chat-flow]');
+  if (column && !element.contains(column)) return column;
+  const scroll = element.closest<HTMLElement>('[data-conversation-scroll]');
+  if (scroll && !element.contains(scroll)) return scroll;
+  return null;
+}
+
+/** Move focus out of `element` before it unmounts. A no-op when focus is elsewhere. */
+function focusSurvivesRetire(element: HTMLElement): void {
+  const active = document.activeElement;
+  if (active === null || !element.contains(active)) return;
+  const target = retireFocusTarget(element);
+  if (target === null || element.contains(target)) return;
+  if (target.tabIndex < 0) target.tabIndex = -1;
+  target.focus({ preventScroll: true });
+}
+
 // DOM-only behavior: the native Session remains the sole source of business data.
 export function useReadingScroll(root: RefObject<HTMLElement>, motion: boolean): {
   detached: boolean;

package/src/client/official-slots.tsx

@@ -56,9 +56,28 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
   }
 }
 
-// Existing Reader presentations own these rows. All other node kinds, including
-// future registrations, reach the official renderer through the fallback seat.
-const READER_NODES = new Set(['user', 'steering', 'assistant-step', 'tool-call', 'turn-tail', 'turn-process']);
+// Reader draws these rows itself. Everything else, including future kinds, is
+// mirrored so the official renderer still runs inside the reading view.
+// 'user' and 'steering' stay mirrored (message-recall buttons and the like).
+// 'assistant-step' is special: the official renderer is priority 0 and Reader
+// keeps that presentation. A strictly lower priority is a keyed-slot
+// replacement (lowest priority renders) and is mirrored for body content.
+const READER_OWNED_NODES = new Set(['tool-call', 'turn-tail', 'turn-process']);
+
+/** Official `AssistantNodeView` registers at priority 0. Lower wins. */
+export const OFFICIAL_ASSISTANT_PRIORITY = 0;
+
+/**
+ * Mirror a chat-node registration into the Reader seat.
+ * Assistant replacements are the entries that would actually replace the
+ * official renderer on the host. The official priority itself stays out, so
+ * Reader keeps its own answer markdown until a plugin opts in.
+ */
+export function acceptMirroredChatNode(entry: StoredEntry): boolean {
+  const key = entry.options.key ?? '';
+  if (key === 'assistant-step') return (entry.options.priority ?? OFFICIAL_ASSISTANT_PRIORITY) < OFFICIAL_ASSISTANT_PRIORITY;
+  return !READER_OWNED_NODES.has(key);
+}
 const EXPECTED: Record<OfficialFamily, Spec> = {
   actions: { kind: 'list', scope: 'session' },
   tools: { kind: 'keyed', scope: 'session' },
@@ -198,7 +217,7 @@ export function installOfficialSlots(ctx: Context): () => void {
           throw new Error(`Official slot contract changed: ${source}`);
         }
         return mirrorOfficialSlot(slots, source, target, `dsh-better-display.official.${family}`,
-          family === 'nodes' ? entry => !READER_NODES.has(entry.options.key ?? '') : undefined);
+          family === 'nodes' ? acceptMirroredChatNode : undefined);
       }));
     }
   } catch (error) {

package/src/client/open-file.ts

@@ -1,3 +1,5 @@
+import { isAbsoluteWorkspacePath } from '../workspace-path.js';
+
 export type DeliverableOpenMode = 'external' | 'sidebar';
 
 export interface OpenModeSnapshot {
@@ -22,14 +24,6 @@ export function isFolderOpenPath(path: string): boolean {
   return path === '.' || path === '';
 }
 
-function isWindowsStylePath(value: string): boolean {
-  return /^[A-Za-z]:[/\\]/.test(value) || value.startsWith('\\\\');
-}
-
-function isAbsoluteWorkspacePath(path: string): boolean {
-  return path.startsWith('/') || isWindowsStylePath(path);
-}
-
 function encodeSegment(segment: string): string {
   return encodeURIComponent(segment).replace(/%3A/gi, ':');
 }

package/src/client/projection.ts

@@ -33,6 +33,13 @@ export function boundaryOf(turn: TurnLocation | undefined): TurnBoundary {
   };
 }
 
+/**
+ * A settled body step before the closing step of a successful turn.
+ *
+ * This is presentation classification only. Narration is never process content
+ * and never folds. The flag only marks body text that is no longer the turn's
+ * final answer, so copy and fork stay on that final answer.
+ */
 export function isEarlierNarration(data: AssistantChatData, boundary: TurnBoundary): boolean {
   // New body text, a tool call, or a settled step is not a completed turn.
   if (data.status !== 'settled' || boundary.status !== 'closed' || boundary.reason !== 'completed') return false;
@@ -49,13 +56,18 @@ export function processChoiceKey(groupKey: string, boundary: TurnBoundary): stri
   return `${groupKey}:${boundary.status}:${boundary.reason ?? 'pending'}`;
 }
 
-/** A body-only assistant step is not a thinking/process disclosure. */
-export function hasProcessContent(node: ChatConversationViewNode | undefined, boundary: TurnBoundary): boolean {
+/**
+ * A body-only assistant step is not a thinking/process disclosure.
+ *
+ * Narration (text/image/other blocks) is always visible, so it never counts as
+ * foldable process content; only literal reasoning does. Tool calls arrive as
+ * their own flow entries and are checked separately by the reader.
+ */
+export function hasProcessContent(node: ChatConversationViewNode | undefined, _boundary: TurnBoundary): boolean {
   if (!node || node.visibility === 'hidden') return false;
   if (node.kind === 'assistant-step') {
     const data = node.data as AssistantChatData;
-    return data.blocks.some(block => block.kind === 'reasoning' && block.text.trim() !== '')
-      || (isEarlierNarration(data, boundary) && hasVisibleBody(data.blocks));
+    return data.blocks.some(block => block.kind === 'reasoning' && block.text.trim() !== '');
   }
   return node.kind === 'context' || node.kind === 'model-retry' || node.kind === 'system-prompt' || node.kind === 'turn-process'
     || node.kind === 'command' || node.kind === 'manual-compaction' || node.kind === 'compaction';