@prettier-ai/dsh-client-ui-chat 0.1.2-alpha.1

package/lib/types/client/conversation-nodes/chat-snapshot-builder.d.ts

@@ -0,0 +1,42 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationTimelineSnapshot, ConversationViewBuilder, ConversationViewDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ChatConversationViewNode } from '../contract/chat-nodes.ts';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+/**
+ * Order visible Chat Nodes without changing existing relative order as process
+ * eligibility changes. Opening human input precedes process candidates, while
+ * each synthetic process control sits between them.
+ * @param nodes - currently materialized Chat Nodes.
+ * @returns visible Nodes in presentation order.
+ */
+export declare function orderedVisibleChatNodes(nodes: readonly ChatConversationViewNode[]): ChatConversationViewNode[];
+/** Incremental keyed Chat builder registered under the `chat` target. */
+export declare class ChatSnapshotBuilder implements ConversationViewBuilder<ChatConversationViewNode, ChatSnapshot> {
+    private readonly store;
+    private readonly locations;
+    private readonly navigation;
+    private readonly legacy;
+    private readonly referenceLabels;
+    private order;
+    /** Last published timeline: a Turn boundary can land without a new node. */
+    private timeline;
+    readonly empty: ChatSnapshot;
+    constructor();
+    replace(input: {
+        readonly nodes: readonly ChatConversationViewNode[];
+        readonly timeline: ConversationTimelineSnapshot;
+    }): ChatSnapshot;
+    apply(input: {
+        readonly upserts: readonly ChatConversationViewNode[];
+        readonly timeline: ConversationTimelineSnapshot;
+    }): ChatSnapshot;
+    private snapshot;
+}
+/** Chat target factory contributed to the Conversation view registry. */
+export declare const chatViewDefinition: ConversationViewDefinition<ChatConversationViewNode, ChatSnapshot>;
+/**
+ * Register the incremental Chat target builder.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerChatConversationView(ctx: Context): void;
+//# sourceMappingURL=chat-snapshot-builder.d.ts.map

package/lib/types/client/conversation-nodes/command.d.ts

@@ -0,0 +1,54 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationMatch, ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { CommandNode, CompactionSummaryNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Ordinary slash-command lifecycle. */
+        command: CommandNode;
+        /** Manual compact command combined with its compaction transaction. */
+        'manual-compaction': ManualCompactionChatData;
+    }
+}
+type CommandId = CommandNode['commandId'];
+interface CommandState {
+    readonly command: CommandNode;
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+interface CompactionEvidence {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/**
+ * Read correlation identity from a compaction replacement checkpoint.
+ * @param event - candidate Session event.
+ * @returns correlated compaction and optional command identity.
+ */
+declare function compactSource(event: Parameters<ConversationNodeDefinition['match']>[0]): {
+    compactionId: string;
+    sourceCommandId?: CommandId;
+} | undefined;
+/**
+ * Build the visible summary marker from optional lifecycle evidence.
+ * @param match - compaction/summary Match, when loaded.
+ * @param checkpoint - replacement checkpoint Match.
+ * @returns final compaction summary Node data.
+ */
+declare function compactSummary(match: ConversationMatch | undefined, checkpoint: ConversationMatch): CompactionSummaryNode;
+/**
+ * Fold shared compaction evidence into a Definition-owned State.
+ * @param state - current business State carrying optional compaction evidence.
+ * @param match - next compaction lifecycle Match.
+ * @returns adopted State, preserving reference identity when the Match adds no evidence.
+ */
+export declare function updateCompactionState<State extends CompactionEvidence>(state: State, match: ConversationMatch): State;
+/** Slash-command lifecycle, including integrated manual compaction, Definition. */
+export declare const commandDefinition: ConversationNodeDefinition<CommandState>;
+/**
+ * Register the command lifecycle business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCommandConversationNode(ctx: Context): void;
+/** Shared structural checkpoint recognizer for automatic compaction. */
+export { compactSource, compactSummary };
+//# sourceMappingURL=command.d.ts.map

package/lib/types/client/conversation-nodes/common.d.ts

@@ -0,0 +1,41 @@
+import type { ConversationLocation, ConversationNodeContext } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ChatNode, ChatNodeDataMap, ChatNodeKind } from '../contract/chat-nodes.ts';
+/**
+ * Relative positions in one durable event's seq neighborhood: interrupted
+ * Assistant, its follow-up Nodes, then follow-ups to an ordinary final. The
+ * max-tokens notice sits between a closing Assistant and the turn-tail so the
+ * tail stays the turn's last node and keeps its branch action enabled.
+ */
+export declare const CHAT_SYNTHETIC_SEQ_OFFSETS: {
+    readonly interruptedAssistant: -0.9;
+    readonly interruptedFollowup: -0.8;
+    readonly processControl: -0.1;
+    readonly maxTokensNotice: 0.05;
+    readonly finalizedFollowup: 0.1;
+};
+/**
+ * Resolve one Context's best currently loaded event Location.
+ * @param context - assembled business Context.
+ * @returns start or first-match Location, otherwise unresolved.
+ */
+export declare function contextLocation(context: ConversationNodeContext): ConversationLocation;
+/**
+ * Build one final Chat target Node with the engine-owned stable key.
+ * @param context - assembled business Context.
+ * @param kind - Chat renderer dispatch key.
+ * @param anchorSeq - sortable render position.
+ * @param data - renderer-owned payload.
+ * @param options - optional Location and visibility overrides.
+ * @returns final Chat view Node.
+ */
+export declare function chatNode<Kind extends ChatNodeKind>(context: ConversationNodeContext, kind: Kind, anchorSeq: number, data: ChatNodeDataMap[Kind], options?: {
+    readonly location?: ConversationLocation;
+    readonly visibility?: 'visible' | 'hidden';
+}): ChatNode<Kind>;
+/**
+ * Read a finite non-negative integer from a structurally narrowed payload.
+ * @param value - untrusted payload field.
+ * @returns valid coordinate, otherwise undefined.
+ */
+export declare function coordinate(value: unknown): number | undefined;
+//# sourceMappingURL=common.d.ts.map

package/lib/types/client/conversation-nodes/compaction.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationMatch, ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { CompactionSummaryNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Automatic compaction checkpoint marker. */
+        compaction: CompactionSummaryNode;
+    }
+}
+interface CompactionState {
+    readonly summary?: ConversationMatch;
+    readonly checkpoint?: ConversationMatch;
+}
+/** Automatic compaction lifecycle and landed checkpoint Definition. */
+export declare const compactionDefinition: ConversationNodeDefinition<CompactionState>;
+/**
+ * Register the automatic-compaction business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerCompactionConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=compaction.d.ts.map

package/lib/types/client/conversation-nodes/event-projection.d.ts

@@ -0,0 +1,57 @@
+/** Chat-owned conversion from durable Session events to Chat view data. */
+import type { ContentBlock, StreamChunk } from '@prettier-ai/dsh-llm/types';
+import type { AssistantBlock, ContextProvenanceView, KnownContextForm } from '@prettier-ai/dsh-client-ui-conversation/client';
+/**
+ * Read the target-supported presentation form from a durable message source.
+ * @param source - Logged `user/message` source.
+ * @returns Supported form, or null for the opaque presentation.
+ */
+export declare function contextForm(source: unknown): KnownContextForm | null;
+/**
+ * Project a durable message source to the Chat row's role and producer label.
+ * @param source - Logged `user/message` source.
+ * @returns Role and label rendered by Chat.
+ */
+export declare function contextProvenance(source: unknown): ContextProvenanceView;
+/**
+ * Read distinct labels cited by a durable cross-session recall source.
+ * @param source - Logged `user/message` source.
+ * @returns Labels in first-seen order.
+ */
+export declare function sessionRecallLabels(source: unknown): string[];
+/**
+ * Classify finalized Assistant content for Chat rendering.
+ * @param content - Core content blocks.
+ * @returns Chat blocks in source order.
+ */
+export declare function toAssistantBlocks(content: readonly ContentBlock[]): AssistantBlock[];
+/**
+ * Classify one finalized Assistant block for Chat rendering.
+ * @param block - Core content block.
+ * @returns Chat block.
+ */
+export declare function toAssistantBlock(block: ContentBlock): AssistantBlock;
+/**
+ * Create the initial Chat block for one streamed Assistant block kind.
+ * @param blockType - Wire block kind.
+ * @returns Empty block ready to receive deltas.
+ */
+export declare function emptyAssistantBlock(blockType: string): AssistantBlock;
+/** Display-safe failure fields retained by Chat projections. */
+export interface DisplayFailure {
+    readonly code?: string;
+    readonly message: string;
+}
+/**
+ * Convert a durable failure to locale-independent fields safe for Chat.
+ * @param failure - Failure preserved by a Session event.
+ * @returns Sanitized message and optional stable provider code.
+ */
+export declare function displayFailure(failure: unknown): DisplayFailure;
+/**
+ * Whether a stream chunk carries visible model output for Chat timing.
+ * @param chunk - Stream chunk to inspect.
+ * @returns true for a non-empty text, reasoning, or Tool-call delta.
+ */
+export declare function isTokenDelta(chunk: StreamChunk): boolean;
+//# sourceMappingURL=event-projection.d.ts.map

package/lib/types/client/conversation-nodes/fallback.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { UnknownSurfaceNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Generic presentation of an unclaimed append-surface event. */
+        unknown: UnknownSurfaceNode;
+    }
+}
+/** Unclaimed append-surface fallback Definition. */
+export declare const unknownFallbackDefinition: ConversationNodeDefinition<UnknownSurfaceNode>;
+/**
+ * Register the unmatched append-surface fallback contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerUnknownConversationFallback(ctx: Context): void;
+//# sourceMappingURL=fallback.d.ts.map

package/lib/types/client/conversation-nodes/inbox.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+interface InboxIdentity {
+    readonly id: string;
+}
+/** Cumulative state after one durable inbox splice. */
+export interface InboxState {
+    readonly pending: readonly InboxIdentity[];
+    readonly claimed: ReadonlySet<string>;
+}
+/** Cumulative next-turn inbox splice Definition. */
+export declare const nextTurnInboxDefinition: ConversationNodeDefinition<InboxState>;
+/** Cumulative next-step inbox splice Definition used to classify steering. */
+export declare const nextStepInboxDefinition: ConversationNodeDefinition<InboxState>;
+/**
+ * Register the two durable Inbox-state contributions.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerInboxConversationNodes(ctx: Context): void;
+export {};
+//# sourceMappingURL=inbox.d.ts.map

package/lib/types/client/conversation-nodes/message.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ContextMessageNode, SteeringMessageNode, UserMessageNode } from '../contract/snapshot.ts';
+interface ReferencedUserMessageNode extends UserMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+}
+interface ReferencedSteeringMessageNode extends SteeringMessageNode {
+    /** Labels cited by the immediately following session-reference context. */
+    readonly referenceLabels?: readonly string[];
+}
+type MessageNode = ReferencedUserMessageNode | ReferencedSteeringMessageNode | ContextMessageNode;
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Ordinary turn-opening user message. */
+        user: ReferencedUserMessageNode;
+        /** User message admitted into an active turn. */
+        steering: ReferencedSteeringMessageNode;
+        /** Non-user context injected into model history. */
+        context: ContextMessageNode;
+    }
+}
+/** User, steering, and injected-context message classification Definition. */
+export declare const messageDefinition: ConversationNodeDefinition<MessageNode>;
+/**
+ * Register the user, steering, and injected-context message contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerMessageConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=message.d.ts.map

package/lib/types/client/conversation-nodes/partial.d.ts

@@ -0,0 +1,34 @@
+import type { StreamChunk } from '@prettier-ai/dsh-llm/types';
+import type { AssistantBlock, PartialAssistant } from '../contract/snapshot.ts';
+/**
+ * Whether a stream chunk changes the partial assistant projection shown by the UI.
+ * @param type - Stream chunk discriminant.
+ * @returns Whether publishing the accumulated partial can change the visible snapshot.
+ */
+export declare function isVisibleAssistantChunk(type: string): boolean;
+/** assistant/chunk accumulator: folds StreamChunks into AssistantBlock[] with block-level immutability. */
+export declare class PartialAccumulator {
+    readonly turn: number;
+    readonly step: number;
+    private blocks;
+    private changed;
+    private snapshot;
+    /**
+     * @param turn - Owning agent turn.
+     * @param step - Owning model step.
+     * @param initialBlocks - Materialized prefix when accumulation begins after history replay.
+     */
+    constructor(turn: number, step: number, initialBlocks?: readonly AssistantBlock[]);
+    /**
+     * Fold one chunk.
+     * @param chunk - the stream chunk.
+     * @returns whether it caused a visible change (usage/finish return false, skipping notification).
+     */
+    push(chunk: StreamChunk): boolean;
+    /**
+     * Current partial projection.
+     * @returns the cached snapshot (the blocks array reference only changes after a mutation).
+     */
+    toPartial(): PartialAssistant;
+}
+//# sourceMappingURL=partial.d.ts.map

package/lib/types/client/conversation-nodes/register.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@prettier-ai/cordis';
+/**
+ * Register the Chat business Definitions and target builder contributed by this package.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerConversationNodes(ctx: Context): void;
+//# sourceMappingURL=register.d.ts.map

package/lib/types/client/conversation-nodes/request-prompt.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition, RequestPromptInspector } from '@prettier-ai/dsh-client-ui-conversation/client';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Complete system prompt rendered for one model request. */
+        'system-prompt': {
+            readonly text: string;
+        };
+    }
+}
+interface RequestPromptState extends ReturnType<RequestPromptInspector> {
+    readonly anchorSeq: number;
+    readonly showsPrompt: boolean;
+    readonly turn?: number;
+    readonly step?: number;
+}
+/**
+ * Request-header prompt Definition for the Chat target.
+ * @param inspect - the shared prompt interpretation, supplied by the
+ * uiConversation service (a client bundle cannot value-import it).
+ * @returns the Chat request-prompt Definition.
+ */
+export declare function requestPromptDefinition(inspect: RequestPromptInspector): ConversationNodeDefinition<RequestPromptState>;
+/**
+ * Register model-request system prompts in the Chat flow.
+ * @param ctx - Owning UI Conversation context.
+ */
+export declare function registerRequestPromptConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=request-prompt.d.ts.map

package/lib/types/client/conversation-nodes/retry.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ModelRetryNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Producer-correlated model retry chain. */
+        'model-retry': RetryChatData;
+    }
+}
+/** Accumulated retry attempts sharing one producer-owned RetryId. */
+export interface RetryState {
+    readonly turn: number;
+    readonly step: number;
+    readonly attempts: readonly ModelRetryNode[];
+}
+/** Producer-correlated model retry chain Definition. */
+export declare const retryDefinition: ConversationNodeDefinition<RetryState>;
+/**
+ * Register the correlated model-retry business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerRetryConversationNode(ctx: Context): void;
+//# sourceMappingURL=retry.d.ts.map

package/lib/types/client/conversation-nodes/tool.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ToolCallBlock } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Root Tool lifecycle with recursively nested subcalls. */
+        'tool-call': ToolChatData;
+    }
+}
+interface ToolState {
+    readonly root: ToolCallBlock;
+    readonly children: ReadonlyMap<string, readonly ToolCallBlock[]>;
+    readonly parents: ReadonlyMap<string, string>;
+}
+/** Root Tool lifecycle and nested Code Dispatch Definition. */
+export declare const toolDefinition: ConversationNodeDefinition<ToolState>;
+/**
+ * Register the root Tool lifecycle and nested-subcall contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerToolConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=tool.d.ts.map

package/lib/types/client/conversation-nodes/turn-error.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { TurnErrorNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Terminal turn failure recorded on the turn's end reason. */
+        'turn-error': TurnErrorNode;
+    }
+}
+interface TurnErrorState {
+    readonly turn: number;
+    readonly failure?: {
+        readonly seq: number;
+        readonly time: number;
+        readonly message: string;
+        readonly code?: string;
+    };
+}
+/**
+ * Terminal turn failure Definition. Retries run inside the failing turn, so the
+ * turn's `llm/retry` history never suppresses this terminal row; the model-retry
+ * node renders that history separately.
+ */
+export declare const turnErrorDefinition: ConversationNodeDefinition<TurnErrorState>;
+/**
+ * Register the terminal Turn-error business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnErrorConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-error.d.ts.map

package/lib/types/client/conversation-nodes/turn-max-tokens.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { TurnMaxTokensNode } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Turn ended by the per-request output-token cap. */
+        'turn-max-tokens': TurnMaxTokensNode;
+    }
+}
+interface TurnMaxTokensState {
+    readonly turn: number;
+    readonly seq: number;
+    readonly time: number;
+}
+/** Notice Definition for a turn the provider ended at its output-token cap. */
+export declare const turnMaxTokensDefinition: ConversationNodeDefinition<TurnMaxTokensState>;
+/**
+ * Register the max-tokens turn-end notice contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnMaxTokensConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-max-tokens.d.ts.map

package/lib/types/client/conversation-nodes/turn-navigation.d.ts

@@ -0,0 +1,17 @@
+import type { ChatLocationNodeIndex, ChatNodeStore, TurnNavigationItem } from '../contract/snapshot.ts';
+/**
+ * Whether two items carry the same rail state, so the reader can keep its array.
+ * @param left - previously published item, when the Turn had one.
+ * @param right - freshly derived item, when the Turn still has one.
+ * @returns whether both sides describe the same mark.
+ */
+export declare function sameTurnNavigationItem(left: TurnNavigationItem | undefined, right: TurnNavigationItem | undefined): boolean;
+/**
+ * Project one loaded Turn into its rail item.
+ * @param turn - Turn number the item addresses.
+ * @param locations - live Location index supplying the Turn's node keys.
+ * @param nodes - live Chat node store.
+ * @returns the item, or undefined when the Turn has no visible loaded node.
+ */
+export declare function turnNavigationItem(turn: number, locations: ChatLocationNodeIndex, nodes: ChatNodeStore): TurnNavigationItem | undefined;
+//# sourceMappingURL=turn-navigation.d.ts.map

package/lib/types/client/conversation-nodes/turn-process.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import { type TurnProcessSignature } from '../contract/turn-process.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Turn-level disclosure controlling process rows before the finalized answer. */
+        'turn-process': import('../contract/chat-nodes.ts').TurnProcessChatData;
+    }
+}
+declare module '@prettier-ai/dsh-client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        /** Encoded process range and finalized answer boundary for this Turn. */
+        'turn-process': TurnProcessSignature;
+    }
+}
+interface TurnProcessState {
+    readonly turn: number;
+    readonly assistantStartByStep: ReadonlyMap<number, number>;
+    readonly messageCountByStep: ReadonlyMap<number, number>;
+    readonly otherStartSeq?: number;
+    readonly toolCallCount: number;
+    readonly subagentCount: number;
+}
+/** Turn-scoped process range and answer-boundary Definition. */
+export declare const turnProcessDefinition: ConversationNodeDefinition<TurnProcessState>;
+/**
+ * Register the Turn-scoped process disclosure projection.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnProcess(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-process.d.ts.map

package/lib/types/client/conversation-nodes/turn-tail.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationMatch, ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { TurnTailChatData } from '../contract/chat-nodes.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Completed-turn actions and extension tail. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+declare module '@prettier-ai/dsh-client-ui-conversation/client' {
+    interface ConversationTurnDataMap {
+        /** Closing Assistant and footer facts derived for this completed Turn. */
+        'turn-tail': TurnTailChatData;
+    }
+}
+interface TurnTailState {
+    readonly turn: number;
+    readonly end?: ConversationMatch;
+}
+/** Completed-turn footer Definition independent of any Assistant row. */
+export declare const turnTailDefinition: ConversationNodeDefinition<TurnTailState>;
+/**
+ * Register completed-Turn footer data and its Chat node contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerTurnTailConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=turn-tail.d.ts.map

package/lib/types/client/details/DetailsPanel.d.ts

@@ -0,0 +1,4 @@
+import type { DetailsSlotProps } from '../contract/slots.ts';
+export type DetailsPanelProps = DetailsSlotProps;
+export declare function DetailsPanel({ useChat, useSessions, sessionId, useStore, renderSlot, closeDetails, t }: DetailsPanelProps): import("react").JSX.Element;
+//# sourceMappingURL=DetailsPanel.d.ts.map

package/lib/types/client/details/tool-node-reader.d.ts

@@ -0,0 +1,9 @@
+import type { ChatSnapshot, ToolCallBlock } from '../contract/snapshot.ts';
+/**
+ * Find any root or nested Tool lifecycle through the internal Node store.
+ * @param snapshot - current Conversation snapshot.
+ * @param callId - root or nested call identity.
+ * @returns current Tool lifecycle when materialized in the loaded window.
+ */
+export declare function findToolCall(snapshot: ChatSnapshot, callId: string): ToolCallBlock | undefined;
+//# sourceMappingURL=tool-node-reader.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,36 @@
+/** Browser Chat target plugin. */
+export { apply, inject } from './apply.ts';
+export type {} from './conversation-nodes/assistant.ts';
+export type {} from './conversation-nodes/command.ts';
+export type {} from './conversation-nodes/compaction.ts';
+export type {} from './conversation-nodes/fallback.ts';
+export type {} from './conversation-nodes/message.ts';
+export type {} from './conversation-nodes/request-prompt.ts';
+export type {} from './conversation-nodes/retry.ts';
+export type {} from './conversation-nodes/tool.ts';
+export type {} from './conversation-nodes/turn-error.ts';
+export type {} from './conversation-nodes/turn-max-tokens.ts';
+export type {} from './conversation-nodes/turn-process.ts';
+export type {} from './conversation-nodes/turn-tail.ts';
+export type { AssistantBlock, AssistantMessageNode, AssistantProvenanceView, AssistantRequestConfig, AssistantTiming, ChatLocationNodeIndex, ChatNodeStore, ChatSnapshot, ChatTurnNavigationIndex, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, LegacyConversationSlice, ModelRetryNode, PartialAssistant, RunningToolCall, SteeringMessageNode, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, TurnNavigationItem, UnknownSurfaceNode, UserMessageNode, } from './contract/snapshot.ts';
+export type { AssistantChatData, ChatConversationViewNode, ChatNode, ChatNodeKind, FinalAssistantChatData, ManualCompactionChatData, RetryChatData, ToolChatData, TurnProcessChatData, TurnTailChatData, } from './contract/chat-nodes.ts';
+export type { ChatStoreState, SelectionTarget, ToolCallId, TurnProcessViewEntry } from './contract/store.ts';
+export type { TranscriptViewRowInjected, TranscriptViewRowProps } from './settings/TranscriptViewRow.tsx';
+export type { TranscriptViewMode } from '../chat-settings.ts';
+export type { AssistantActionOwnerProps, ChatFileMentions, ChatNodeOwnerProps, ChatNodeTurnDataInjected, ChatNodeViewProps, ChatScrollPosition, ChatStore, ChatViewInjected, ChatViewSlotProps, CommandRowOwnerProps, CommandRowProps, DetailsInjected, DetailsSlotProps, DetailsToolOwnerProps, MessageImagesProps, TurnProcessOwnerProps, TurnTailOwnerProps, UseChat, UseChatNodeTurnData, } from './contract/slots.ts';
+export type { TurnProcessGeneration, TurnProcessSignature, TurnProcessSpec, } from './contract/turn-process.ts';
+export type { ChatKey } from './locale.ts';
+export type { ConversationContext, ConversationContextOriginKind } from './model/conversation-context.ts';
+export type { ContextProvenanceView, ContextRole, KnownContextForm, } from '@prettier-ai/dsh-client-ui-conversation/client';
+export type { ConversationPromptSnapshot, RequestInspectionSnapshot, RequestPromptChange, RequestView, } from '@prettier-ai/dsh-client-ui-conversation/client';
+export { isRunningTool, isSettledTool } from './contract/chat-nodes.ts';
+export { EMPTY_CHAT_SNAPSHOT } from './contract/snapshot.ts';
+/** Public merge surface for Chat renderer payloads contributed by other plugins. */
+export interface ChatNodeDataMap {
+}
+type PublicChatNodeDataMap = ChatNodeDataMap;
+declare module './contract/chat-nodes.ts' {
+    interface ChatNodeDataMap extends PublicChatNodeDataMap {
+    }
+}
+//# sourceMappingURL=index.d.ts.map