@deepseek-ai/dsh-client-ui-chat 0.1.6-alpha.2 → 0.1.7-alpha.2

package/lib/types/client/chat/use-chat-reading.d.ts

@@ -0,0 +1,96 @@
+import type { ChatScrollPosition, ChatViewSlotProps } from '../contract/slots.ts';
+import type { ChatViewport, ViewportLanding, ViewportScroll } from './use-chat-viewport.ts';
+import { type ScrollFollow } from './use-scroll-follow.ts';
+/** Reading facts that affect Chat chrome and initial rail placement. */
+export interface ChatReadingState {
+    readonly initialized: boolean;
+    readonly followingTail: boolean;
+    readonly activeTurn: number | null;
+}
+/** Settled reader position delivered to history-navigation policy. */
+export interface ReadingSample {
+    readonly position: ChatScrollPosition | null;
+    readonly movedByReader: boolean;
+    readonly followingTail: boolean;
+}
+type PositionStore = ChatViewSlotProps['chatScroll'];
+/** Owns reading policy and its cancellable sampling work, without DOM access. */
+export declare class ChatReading {
+    private readonly viewport;
+    private store;
+    private state;
+    private readonly onChange;
+    private readonly follow;
+    private sampleTimer;
+    private probeFrame;
+    private sampled;
+    constructor(viewport: ChatViewport, store: PositionStore, state: ChatReadingState, onChange: (state: ChatReadingState) => void, follow: ScrollFollow);
+    /**
+     * Expose pending reader ownership to navigation and resize handlers.
+     * @returns whether reader input still awaits interval or scrollend sampling.
+     */
+    get pending(): boolean;
+    /**
+     * Expose the active follow policy.
+     * @returns whether content growth retains bottom-follow ownership.
+     */
+    get followingTail(): boolean;
+    /**
+     * Adopt the committed Session's scroll memory.
+     * @param store - scroll memory for the current Session.
+     */
+    setStore(store: PositionStore): void;
+    /**
+     * Connect history policy to settled reading observations.
+     * @param sampled - receives settled reader positions.
+     * @returns a disposer that disconnects only this listener.
+     */
+    connect(sampled: (sample: ReadingSample) => void): () => void;
+    /** Cancel timers and animation frames and detach the sample listener. */
+    dispose(): void;
+    /** Release bottom follow and pending sampling for an explicit navigation. */
+    pauseFollowing(): void;
+    /** Land at the current floor and clear saved reader position. */
+    followTail(): void;
+    /** Restore the Session's semantic position, or follow the tail when none is saved. */
+    restore(): void;
+    /**
+     * Adopt a known landing without rediscovering its anchor.
+     * @param landing - measured navigation result that replaces pending reader input.
+     */
+    acceptNavigation(landing: ViewportLanding): void;
+    /**
+     * Retain reading policy while history changes the anchor's geometry.
+     * @param landing - compensated position that retains the current reading policy.
+     */
+    preservePosition(landing: ViewportLanding): void;
+    /**
+     * Handle pinned layout movement and reader arrivals at the floor immediately.
+     * @param scroll - attributed scroll delivery; other reader movement remains pending until sampled.
+     */
+    readonly onScroll: (scroll: ViewportScroll) => void;
+    /** Settle pending reader movement at the browser's scrollend. */
+    readonly onScrollEnd: () => void;
+    /** Reconcile a layout change without overriding unsampled reader input. */
+    onResize(): void;
+    /** Resolve the active turn from tail ownership or a coalesced reading-line probe. */
+    refreshActiveTurn(): void;
+    private commit;
+    private publish;
+    private cancelPending;
+    private readonly probe;
+    private readonly flushSample;
+}
+/**
+ * Retain reading policy and expose only changes in visible reading state.
+ * @param viewport - turn-aware DOM operations.
+ * @param store - Session-owned semantic scroll memory.
+ * @param initialTurn - latest loaded turn before the first landing.
+ * @returns the reading owner and its React-visible state.
+ */
+export declare function useChatReading(viewport: ChatViewport, store: PositionStore, initialTurn: number | null): {
+    reading: ChatReading;
+    state: ChatReadingState;
+};
+export {};
+//# sourceMappingURL=use-chat-reading.d.ts.map

package/lib/types/client/chat/use-chat-scroll.d.ts

@@ -0,0 +1,35 @@
+/** Composes viewport operations, reading policy, and history navigation for Chat. */
+import { type RefObject } from 'react';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import { type ChatNavigation, type ChatNavigationInput } from './use-chat-navigation.ts';
+import { type ChatReadingState } from './use-chat-reading.ts';
+/** Committed content and Session operations used to reconcile scroll ownership. */
+export interface ChatScrollInput extends ChatNavigationInput {
+    readonly chatScroll: ChatViewSlotProps['chatScroll'];
+    readonly ready: boolean;
+    readonly order: readonly string[];
+    readonly lastKey: string | null;
+    readonly lastIsUser: boolean;
+    readonly steeringId: string | null;
+    readonly submissionId: string | null;
+    readonly running: boolean;
+    readonly loadedTurns: ReturnType<ChatSnapshot['navigation']['items']>;
+}
+interface ChatScrollState extends ChatReadingState {
+    readonly listRef: RefObject<HTMLDivElement>;
+    readonly columnRef: RefObject<HTMLDivElement>;
+    readonly busyTurn: number | null;
+    readonly navigateToTurn: ChatNavigation['navigateToTurn'];
+    readonly loadEarlier: ChatNavigation['loadEarlier'];
+    readonly returnToBottom: () => void;
+}
+/**
+ * Coordinate scroll policy after Chat content commits.
+ * New submitted input supersedes pending reader sampling.
+ * @param input - current Chat content, scroll memory, and history operations.
+ * @returns element refs, visible reading state, and navigation callbacks.
+ */
+export declare function useChatScroll(input: ChatScrollInput): ChatScrollState;
+export {};
+//# sourceMappingURL=use-chat-scroll.d.ts.map

package/lib/types/client/chat/use-chat-viewport.d.ts

@@ -0,0 +1,144 @@
+/** Turn-aware DOM scrolling and geometry, without history-loading or follow policy. */
+import { type RefObject } from 'react';
+import type { ChatScrollPosition } from '../contract/slots.ts';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+import { ScrollFollow, type ViewportMetrics } from './use-scroll-follow.ts';
+export type { ViewportMetrics } from './use-scroll-follow.ts';
+/** Scroll geometry attributed against the last acknowledged position. */
+export interface ViewportScroll {
+    readonly metrics: ViewportMetrics;
+    readonly movedByReader: boolean;
+}
+/** Actual clamped scroll result, including any known semantic anchor and turn. */
+export interface ViewportLanding {
+    readonly metrics: ViewportMetrics;
+    readonly position: ChatScrollPosition | null;
+    readonly turn: number | null;
+}
+interface ViewportEvents {
+    scroll: (event: ViewportScroll) => void;
+    scrollEnd: () => void;
+    resize: () => void;
+    interact: () => void;
+}
+/** Owns one Chat scrollport's DOM operations, event listeners, and size observer. */
+export declare class ChatViewport {
+    private elements;
+    private observer;
+    private events;
+    private turns;
+    private observation;
+    private paging;
+    /**
+     * Bind to the containing scrollport and observe content and viewport sizes.
+     * @param list - Chat root inside an optional shared conversation scrollport.
+     * @param column - ordered outer Node/Group boxes; its size changes invalidate cached landings.
+     */
+    attach(list: HTMLElement, column: HTMLElement): void;
+    /** Disconnect DOM resources and clear observations for the detached view. */
+    detach(): void;
+    /**
+     * Connect business policy without changing DOM listener ownership.
+     * @param events - business handlers for scroll and layout changes.
+     * @returns a disposer that disconnects only these handlers.
+     */
+    connect(events: ViewportEvents): () => void;
+    /**
+     * Adopt the loaded turn anchors without querying the DOM.
+     * @param turns - ordered loaded turns from the committed Chat snapshot.
+     */
+    updateTurns(turns: ReturnType<ChatSnapshot['navigation']['items']>): void;
+    /**
+     * Resolve the tail from the committed turn index.
+     * @returns the latest loaded turn, or null for an empty window.
+     */
+    get latestTurn(): number | null;
+    /** Discard geometry-dependent landing knowledge while retaining scroll attribution. */
+    invalidate(): void;
+    /**
+     * Accept a sampled reader position without retaining a known landing.
+     * @param metrics - settled reader position used as the next attribution baseline.
+     */
+    acknowledge(metrics: ViewportMetrics): void;
+    /**
+     * Compare the current scroll geometry with the last acknowledged position.
+     * @returns current metrics and movement attribution, or null while detached.
+     */
+    readScroll(): ViewportScroll | null;
+    private metrics;
+    private anchor;
+    /**
+     * Capture visible transcript content, excluding Turn controls that relocate when history expands.
+     * @returns a visible semantic anchor, or null when no anchor can be resolved.
+     */
+    capturePosition(): ChatScrollPosition | null;
+    /**
+     * Approximate the active Turn by binary-searching outer Node/Group boxes.
+     * Gaps retain the last visited Turn candidate, not necessarily the immediate predecessor.
+     * A known landing bypasses measurement while its position is unchanged.
+     * @param metrics - reusable scroll metrics; omitted callers request a fresh read.
+     * @returns the Turn near the reading line, or null while detached or empty.
+     */
+    readVisibleTurn(metrics?: ViewportMetrics | null): number | null;
+    /**
+     * Align a known loaded turn and return its actual clamped position.
+     * A split Node anchor selects its first visible part.
+     * @param turn - loaded turn to align below the scrollport's top edge.
+     * @returns the actual landing, or null when its anchor is unavailable.
+     */
+    scrollToTurn(turn: number): ViewportLanding | null;
+    /**
+     * Align the nearest available fallback for an unavailable turn anchor.
+     * @param turn - minimum turn number for a mounted fallback row.
+     * @returns the fallback landing, or null when no eligible row exists.
+     */
+    scrollToTurnAtOrAfter(turn: number): ViewportLanding | null;
+    /**
+     * Restore a semantic anchor with a raw-position fallback.
+     * @param position - semantic scroll memory; raw top is used only if its row is absent.
+     * @returns the actual landing, or null while detached.
+     */
+    restore(position: ChatScrollPosition): ViewportLanding | null;
+    /** Retain the first eligible transcript seat in DOM order; selection reads no geometry. */
+    beginPaging(): void;
+    /**
+     * Retain one old row and its inner/outer offsets for paging and later content growth.
+     * @param position - an explicit landing to retain; omitted callers capture the current reading position.
+     */
+    beginPreserving(position?: ChatScrollPosition | null): void;
+    private retain;
+    /** Release paging ownership and its content-size observation. */
+    stopPreserving(): void;
+    /**
+     * Expose retained paging ownership to navigation and resize policy.
+     * @returns whether a paging row is retained for subsequent layout changes.
+     */
+    get preserving(): boolean;
+    /**
+     * Compensate inner scrolling first, then the outer scrollport, within their actual scroll ranges.
+     * An inner write pauses its bound follow controller so the reading anchor takes priority.
+     * @returns the actual landing, or null when no visible retained row remains.
+     */
+    preserve(): ViewportLanding | null;
+    /**
+     * Align the scrollport with its current floor.
+     * @param follow - independent follow intent and scrolling controller.
+     * @returns the actual floor landing, or null while detached.
+     */
+    scrollToBottom(follow: ScrollFollow): ViewportLanding | null;
+    private align;
+    private write;
+    private readonly onScroll;
+    private readonly onScrollEnd;
+    private readonly onIntent;
+}
+/**
+ * Bind viewport resource ownership to the component's layout lifetime.
+ * @returns one viewport owner and the element refs attached for this mount.
+ */
+export declare function useChatViewport(): {
+    viewport: ChatViewport;
+    listRef: RefObject<HTMLDivElement>;
+    columnRef: RefObject<HTMLDivElement>;
+};
+//# sourceMappingURL=use-chat-viewport.d.ts.map

package/lib/types/client/chat/use-disclosure.d.ts

@@ -0,0 +1,15 @@
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { UseDisclosure } from '../contract/slots.ts';
+/**
+ * Own one initially collapsed disclosure without an external subscription.
+ * @param version - reset generation; unchanged generations retain local open state.
+ * @returns the open state, an explicit setter, and a toggle action.
+ */
+export declare function useDisclosure(version?: number): ReturnType<UseDisclosure>;
+/**
+ * Bind a Hook without subscribing until a component calls it.
+ * @param reset - stable source whose version advances when the seat is hidden by its Turn.
+ * @returns a Hook with independent open state for each invocation.
+ */
+export declare function bindDisclosure(reset: ObservableSnapshot<number>): UseDisclosure;
+//# sourceMappingURL=use-disclosure.d.ts.map

package/lib/types/client/chat/use-process-scroll.d.ts

@@ -0,0 +1,23 @@
+/** Capped process-group scrolling and fades over the shared follow controller. */
+import { type DOMAttributes, type RefObject } from 'react';
+interface ScrollEdges {
+    readonly canScrollUp: boolean;
+    readonly canScrollDown: boolean;
+}
+/**
+ * Observe one group's body and content without coupling its follow intent to the outer transcript.
+ * Wheel, touchstart, any pointerdown, and unprevented scroll keys interrupt active animations,
+ * including events from editable controls; subsequent position sampling determines follow intent.
+ * @param bodyRef - capped scrolling body.
+ * @param contentRef - uncapped content whose size reports growth.
+ * @param open - local disclosure state.
+ * @param grouped - whether the display mode retains the group's height cap.
+ * @returns edge fades, DOM event bindings, and one-shot positioning for manual opening.
+ */
+export declare function useProcessScroll(bodyRef: RefObject<HTMLDivElement>, contentRef: RefObject<HTMLDivElement>, open: boolean, grouped: boolean): {
+    edges: ScrollEdges;
+    events: Pick<DOMAttributes<HTMLDivElement>, 'onScroll' | 'onWheel' | 'onTouchStart' | 'onPointerDown' | 'onKeyDown'>;
+    initialize: (position: 'top' | 'bottom') => void;
+};
+export {};
+//# sourceMappingURL=use-process-scroll.d.ts.map

package/lib/types/client/chat/use-scroll-follow.d.ts

@@ -0,0 +1,105 @@
+/** Scroll position, maximum top, and viewport height from one geometry read. */
+export interface ViewportMetrics {
+    readonly top: number;
+    readonly floor: number;
+    readonly height: number;
+}
+/**
+ * Read one scrollport without measuring its children.
+ * @param element - scrolling element.
+ * @returns current position and range.
+ */
+export declare function scrollMetrics(element: HTMLElement): ViewportMetrics;
+/** One scrollport's follow intent; native animation progress does not count as reader movement. */
+export declare class ScrollFollow {
+    private following;
+    private readonly threshold;
+    private static readonly owners;
+    private target;
+    private sampledTop;
+    /**
+     * @param following - initial follow intent.
+     * @param threshold - accepted distance from the floor, in pixels.
+     */
+    constructor(following: boolean, threshold: number);
+    /**
+     * Find the mounted controller for reading-position compensation.
+     * @param element - scrollport with an optional follow owner.
+     * @returns its controller, when bound.
+     */
+    static forElement(element: HTMLElement): ScrollFollow | undefined;
+    /**
+     * Share this controller with reading-position compensation for the same scrollport.
+     * @param element - owned scrollport.
+     * @returns release the association on unmount or close.
+     */
+    bind(element: HTMLElement): () => void;
+    /**
+     * Expose follow intent independently of the current offset.
+     * @returns whether content growth should follow the floor.
+     */
+    get active(): boolean;
+    /**
+     * Expose outstanding native motion before accepting reader input.
+     * @returns whether a native follow animation has an outstanding target.
+     */
+    get animating(): boolean;
+    /**
+     * Classify bottom arrivals using this scrollport's own tolerance.
+     * @param metrics - current scroll geometry.
+     * @returns whether the position is within the follow threshold.
+     */
+    nearBottom(metrics: ViewportMetrics): boolean;
+    /**
+     * Commit caller-owned follow decisions without moving the scrollport.
+     * @param active - externally committed follow intent.
+     */
+    setFollowing(active: boolean): void;
+    /** Adopt the next visible layout as a fresh reader position. */
+    reset(): void;
+    /**
+     * Adopt delivered scrolling while retaining intent during native animation.
+     * @param metrics - current geometry.
+     * @param movedByReader - caller attribution; omitted callers compare the last sampled position.
+     * @returns updated follow intent.
+     */
+    sample(metrics: ViewportMetrics, movedByReader?: boolean): boolean;
+    /**
+     * Settle native scrolling; an off-target stop releases follow intent.
+     * @param metrics - actual geometry delivered at scrollend.
+     * @returns follow intent after completing or interrupting native motion.
+     */
+    settle(metrics: ViewportMetrics): boolean;
+    /**
+     * Position immediately and adopt the resulting follow intent.
+     * @param element - scrolling element.
+     * @param metrics - geometry before positioning.
+     * @param top - requested offset, clamped to the measured range.
+     * @returns geometry after positioning.
+     */
+    jump(element: HTMLElement, metrics: ViewportMetrics, top: number): ViewportMetrics;
+    /**
+     * Follow the measured floor, respecting reduced motion for smooth requests.
+     * An outstanding smooth target finishes before another is issued.
+     * Within-tolerance positioning is immediate while no animation is outstanding.
+     * @param element - scrolling element.
+     * @param metrics - current geometry.
+     * @param behavior - native animation for growth, or immediate positioning.
+     * @returns current geometry; smooth requests retain their starting position until native scroll delivery.
+     */
+    toBottom(element: HTMLElement, metrics: ViewportMetrics, behavior: 'instant' | 'smooth'): ViewportMetrics;
+    /**
+     * Cancel native motion before a reader gesture; only subsequent actual movement changes follow intent.
+     * @param element - scrolling element.
+     * @param metrics - position at interruption.
+     */
+    interrupt(element: HTMLElement, metrics: ViewportMetrics): void;
+}
+/**
+ * Retain one independent follow controller without React updates for scroll samples.
+ * @param initial - initial follow intent.
+ * @param threshold - accepted distance from the floor, in pixels.
+ * @returns the stable controller shared by the caller's scroll and resize handlers.
+ */
+export declare function useScrollFollow(initial: boolean, threshold: number): ScrollFollow;
+//# sourceMappingURL=use-scroll-follow.d.ts.map

package/lib/types/client/contract/chat-nodes.d.ts

@@ -76,8 +76,6 @@ export interface TurnTailChatData {
     readonly closing: FinalAssistantChatData | null;
     /** Whether non-rendered later evidence makes the closing seq non-tail. */
     readonly branchUnavailable: boolean;
-    readonly ttftMs?: number;
-    readonly tokensPerSecond?: number;
     /** Exact per-Turn accounting; absent when the loaded evidence is incomplete. */
     readonly tokenUsage?: TurnTokenUsage;
 }

package/lib/types/client/contract/chat-visibility.d.ts

@@ -0,0 +1,9 @@
+/** Chat-only row visibility; durable events and trajectory inspection remain intact. */
+import type { ChatNode } from './chat-nodes.ts';
+/**
+ * Exclude system prompts, ordinary Context, and permission commands from visible Chat rows.
+ * @param node - projected Chat node.
+ * @returns whether the node contributes a visible Chat row.
+ */
+export declare function isVisibleChatNode(node: ChatNode): boolean;
+//# sourceMappingURL=chat-visibility.d.ts.map

package/lib/types/client/contract/process-groups.d.ts

@@ -0,0 +1,23 @@
+/** Business data for Chat process groups; source Nodes remain in the Chat store. */
+export type ProcessActivity = 'read' | 'search' | 'edit' | 'commands' | 'code' | 'webSearch' | 'webFetch' | 'subagents' | 'plan' | 'questions' | 'tools';
+/** Distinct-call category ranking and the current live task detail. */
+export interface ProcessActivitySummary {
+    readonly counts: readonly {
+        readonly kind: ProcessActivity;
+        readonly count: number;
+    }[];
+    readonly running: ProcessActivity | undefined;
+    readonly runningDetail: string;
+}
+/** Presentation facts for one group between independent replies or input. */
+export interface ProcessGroupData {
+    readonly turn: number;
+    readonly closed: boolean;
+    readonly summary: ProcessActivitySummary;
+}
+declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
+    interface ConversationGroupDataMap {
+        chat: ProcessGroupData;
+    }
+}
+//# sourceMappingURL=process-groups.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -1,22 +1,29 @@
 /** Chat-owned Slot declarations and composed component props. */
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionId, SessionSeq } from '@deepseek-ai/dsh-session/types';
-import type { CommandNode, CompactionSummaryNode, ConversationLocationDataStore, ConversationTurnDataMap, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { CommandNode, CompactionSummaryNode, ConversationLocationDataStore, ConversationTurnDataMap, ConversationGroupData, GroupSnapshot, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { InjectFace, KeyedSnapshotSelectorHook, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore, SlotHookFactory, SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
 import type { createChatStore } from '../stores.ts';
+import type { ChatPresentationPolicy } from '../presentation-policy.ts';
 import type { ToolCallId } from './store.ts';
 import type { ChatConversationViewNode, ChatNode, ChatNodeKind } from './chat-nodes.ts';
 import type { ChatNodeProcessSource, ChatNodeSource, ChatSnapshot, ChatTurnProcessPresentation } from './snapshot.ts';
 import type { TurnProcessSpec } from './turn-process.ts';
-import type { TranscriptViewMode } from '../../chat-settings.ts';
+import type { PerformanceUsageMode } from '../../chat-settings.ts';
 /** Selector hook over the current Conversation binding's Chat target. */
 export type UseChat = SnapshotSelectorHook<ChatSnapshot>;
 /** Per-key selector hook over one Chat Node. */
 export type UseChatNode = KeyedSnapshotSelectorHook<ChatConversationViewNode | undefined>;
 /** Per-key selector hook over one Chat Node's Turn-process presentation. */
 export type UseChatNodeProcess = KeyedSnapshotSelectorHook<ChatTurnProcessPresentation | undefined>;
+/**
+ * Selector hook over the live presentation policy. Callers select one field or
+ * a derived conclusion, never the whole policy, so a mode change re-renders
+ * only components whose selected value changed.
+ */
+export type UsePresentation = SnapshotSelectorHook<ChatPresentationPolicy>;
 /** Where in a file an open should land. */
 export interface OpenFileOptions {
     /** 1-based line to reveal; absent = the file's beginning. */
@@ -50,19 +57,38 @@ declare module '@deepseek-ai/cordis' {
 }
 /** Hook constrained to business data published on the current Chat Node's Turn. */
 export type UseChatNodeTurnData = <Key extends Extract<keyof ConversationTurnDataMap, string>>(key: Key) => Readonly<ConversationTurnDataMap[Key]> | undefined;
-/** Slot-level Hook factory for keyed Chat renderers. */
-export interface ChatNodeTurnDataInjected {
+/**
+ * Subscribe to enclosing-Turn resets and own one initially collapsed disclosure.
+ * Each invocation has independent open state; display-mode changes do not reset it.
+ * @returns the current open state, explicit setter, and toggle action.
+ */
+export type UseDisclosure = () => {
+    readonly expanded: boolean;
+    /** @param open - whether this disclosure is expanded. */
+    readonly setExpanded: (open: boolean) => void;
+    readonly toggle: () => void;
+};
+/** Stable sources bound to one rendered Chat Node. */
+export interface ChatNodeHookContext {
+    readonly turnData: ConversationLocationDataStore<ConversationTurnDataMap> | undefined;
+    readonly disclosureReset: ObservableSnapshot<number>;
+}
+/** Slot-level Hook factories for keyed Chat renderers. */
+export interface ChatNodeInjected {
     hooks: {
         turnData: SlotHookFactory<'conversation.chat.node', UseChatNodeTurnData>;
+        disclosure: SlotHookFactory<'conversation.chat.node', UseDisclosure>;
     };
 }
 /** Stable owner currency delivered to a keyed Chat renderer. */
 export interface ChatNodeOwnerProps {
+    /** Renderer-owned Node portion selected by the grouping Definition. */
+    groupPart?: string;
     cwd?: string | undefined;
     /** Open the current source file of a skill referenced by a sent message. */
     openSkill: (name: string) => void;
     openFile: (path: string, options?: OpenFileOptions) => void;
-    inspectCall: (callId: ToolCallId) => void;
+    inspectCall: ((callId: ToolCallId) => void) | undefined;
     forkAt: (seq: number) => void;
     /**
      * Session-authorized image loader, down-threaded from the Chat view so a
@@ -78,11 +104,20 @@ export interface ChatNodeOwnerProps {
 }
 /** Shared presentation state for one Turn-process answer generation. */
 export interface TurnProcessOwnerProps {
+    /** Process content eligible to share one Turn-level disclosure. */
+    readonly hasContent: boolean;
     readonly spec: TurnProcessSpec;
     readonly foldable: boolean;
     readonly open: boolean;
     setOpen(open: boolean): void;
 }
+/** Shared presentation policy source for renderers that depend on the work-details mode. */
+export interface PresentationInjected {
+    hooks: {
+        /** Live presentation policy derived from the accepted work-details mode. */
+        presentation: ObservableSnapshot<ChatPresentationPolicy>;
+    };
+}
 /** Full props of one keyed Chat renderer. */
 export type ChatNodeViewProps<Kind extends ChatNodeKind = ChatNodeKind> = PropsRuntime<'conversation.chat.node', Kind> & PropsLocale<'chat'>;
 /** Command-row owner share. */
@@ -100,21 +135,30 @@ export interface ChatScrollPosition {
     readonly anchorTop: number;
     readonly scrollTop: number;
 }
+/** Shared settings source for the performance row, composer, and turn tail. */
+export interface PerformanceUsageInjected {
+    hooks: {
+        /** Accepted performance and usage detail preference. */
+        performanceUsage: ObservableSnapshot<PerformanceUsageMode>;
+    };
+}
 /** Business callbacks injected into the Chat view. */
 export interface ChatViewInjected {
     hooks: {
-        /** Persisted completed-Turn transcript presentation. */
-        transcriptView: SnapshotStore<TranscriptViewMode>;
+        /** Live presentation policy derived from the accepted work-details mode. */
+        presentation: ObservableSnapshot<ChatPresentationPolicy>;
     };
     keyedHooks: {
         /** Resolve the stable source for one Chat Node key. */
         chatNode: (key: string) => ChatNodeSource;
         /** Resolve the stable Turn-process source for one Chat Node key. */
         chatNodeProcess: (key: string) => ChatNodeProcessSource;
+        /** Resolve one optional group without subscribing the root View to its data. */
+        chatGroup: (key: string) => ObservableSnapshot<GroupSnapshot<ConversationGroupData<'chat'>> | undefined> | undefined;
     };
     /** Open the current source file of a skill referenced by a sent message. */
     openSkill: (name: string) => void;
-    /** Open one HTTP(S) message link in a Sidebar Browser tab. */
+    /** Open one HTTP(S) message link at the selected destination, using an external tab if Sidebar Browser is unavailable. */
     openExternalLink: (url: string) => void;
     openFile: (path: string, options?: OpenFileOptions) => Promise<void>;
     loadOlder: () => void;
@@ -156,8 +200,8 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
                     node: ChatNode<Kind>;
                 };
             };
-            hookContext: ConversationLocationDataStore<ConversationTurnDataMap> | undefined;
-            inject: ChatNodeTurnDataInjected;
+            hookContext: ChatNodeHookContext;
+            inject: ChatNodeInjected;
         };
         /**
          * Renderer for one consecutive group of durable message images. The owner

package/lib/types/client/contract/snapshot.d.ts

@@ -1,5 +1,6 @@
 import type { ConversationNode, ConversationTimelineSnapshot, PartialAssistant, RunningToolCall } from '@deepseek-ai/dsh-client-ui-conversation/client';
-import type { ChatConversationViewNode } from './chat-nodes.ts';
+import type { ChatConversationViewNode, ChatNodeDataMap, ChatNodeKind } from './chat-nodes.ts';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { TurnProcessSpec } from './turn-process.ts';
 export type { AssistantBlock, AssistantMessageNode, AssistantProviderMetadataView, AssistantRequestConfig, AssistantTiming, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, ModelRetryNode, PartialAssistant, RunningToolCall, SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, UnknownSurfaceNode, UserMessageNode, } from '@deepseek-ai/dsh-client-ui-conversation/client';
 /** Per-key observable used by one mounted Chat Node Seat. */
@@ -22,6 +23,14 @@ export interface ChatNodeStore {
     get(key: string): ChatConversationViewNode | undefined;
     /** @param key - stable Conversation Context key. @returns its identity-stable observable source. */
     source(key: string): ChatNodeSource;
+    /**
+     * Observe one Turn's data for a single Node kind, including hidden Nodes, in anchor order.
+     * Other Turns and kinds do not notify this source.
+     * @param turn - resolved owning Turn.
+     * @param kind - business Node kind.
+     * @returns an identity-stable source whose array changes only with its members.
+     */
+    turnDataSource<Kind extends ChatNodeKind>(turn: number, kind: Kind): ObservableSnapshot<readonly ChatNodeDataMap[Kind][]>;
     /** @param key - stable Conversation Context key. @returns its Turn-process presentation source. */
     processSource(key: string): ChatNodeProcessSource;
     /** @returns all currently materialized Nodes without imposing render order. */
@@ -58,8 +67,12 @@ export interface ChatLocationNodeIndex {
 export interface ChatTurnProcessPresentation {
     readonly turn: number;
     readonly spec: TurnProcessSpec;
+    /** Whether the loaded window contains this Turn's `turn/start`; folding is decided per Turn on this fact. */
+    readonly turnStarted: boolean;
     readonly turnClosed: boolean;
     readonly hasExternalProcess: boolean;
+    /** A visible input after process output prevents one disclosure from hiding its surrounding groups. */
+    readonly hasInterleavedInput: boolean;
     readonly compactAnswer: boolean;
 }
 /** Compatibility projection backing StatsPills and the legacy top-level snapshot fields. */