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

package/lib/index.js

@@ -0,0 +1,25 @@
+import { settingsNamespace } from "@prettier-ai/dsh-settings";
+import z from "@prettier-ai/schemastery";
+//#region lib/types/chat-settings.js
+/** Chat transcript preferences stored in the Host user-settings document. */
+/** Settings namespace owned by the Chat target. */
+const CHAT_SETTINGS_NAMESPACE = "ui-chat";
+/** Field carrying the completed-Turn transcript presentation mode. */
+const TRANSCRIPT_VIEW_FIELD = "transcriptView";
+/** Transcript presentation modes accepted at settings boundaries. */
+const TRANSCRIPT_VIEW_MODES = ["normal", "compact"];
+/** Default preserves the compact process disclosure introduced by Chat. */
+const DEFAULT_TRANSCRIPT_VIEW_MODE = "compact";
+/** Durable Chat schema; also the wire envelope the browser scope validates against. */
+const ChatSettingsSchema = z.object({ [TRANSCRIPT_VIEW_FIELD]: z.union([...TRANSCRIPT_VIEW_MODES]).default(DEFAULT_TRANSCRIPT_VIEW_MODE) });
+//#endregion
+//#region lib/types/index.js
+/** Host registration for browser Chat preferences. */
+/** Register the durable Chat settings section when a provider exists. */
+function apply(ctx) {
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.register(settingsNamespace(CHAT_SETTINGS_NAMESPACE), ChatSettingsSchema);
+	});
+}
+//#endregion
+export { CHAT_SETTINGS_NAMESPACE, DEFAULT_TRANSCRIPT_VIEW_MODE, TRANSCRIPT_VIEW_FIELD, TRANSCRIPT_VIEW_MODES, apply };

package/lib/invariant.js

@@ -0,0 +1,16 @@
+//#region lib/types/invariant.js
+const PACKAGE_NAME = "@prettier-ai/dsh-client-ui-chat";
+/** Cordis companion plugin name. */
+const name = "client-ui-chat-invariant";
+/** Service required before the companion reserves package ownership. */
+const inject = ["invariants"];
+/** No runtime invariant: Conversation and Slot registration enforce Chat target consistency. */
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/chat-settings.d.ts

@@ -0,0 +1,20 @@
+/** Chat transcript preferences stored in the Host user-settings document. */
+import z from '@prettier-ai/schemastery';
+/** Settings namespace owned by the Chat target. */
+export declare const CHAT_SETTINGS_NAMESPACE = "ui-chat";
+/** Field carrying the completed-Turn transcript presentation mode. */
+export declare const TRANSCRIPT_VIEW_FIELD = "transcriptView";
+/** Transcript presentation modes accepted at settings boundaries. */
+export declare const TRANSCRIPT_VIEW_MODES: readonly ["normal", "compact"];
+/** Completed-Turn transcript presentation. */
+export type TranscriptViewMode = typeof TRANSCRIPT_VIEW_MODES[number];
+/** Default preserves the compact process disclosure introduced by Chat. */
+export declare const DEFAULT_TRANSCRIPT_VIEW_MODE: TranscriptViewMode;
+/** Durable Chat section shared by the Host schema and browser scope. */
+export interface ChatSettings {
+    /** Presentation mode for completed Turn process content. */
+    transcriptView: TranscriptViewMode;
+}
+/** Durable Chat schema; also the wire envelope the browser scope validates against. */
+export declare const ChatSettingsSchema: z<ChatSettings>;
+//# sourceMappingURL=chat-settings.d.ts.map

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

@@ -0,0 +1,10 @@
+/** Register the Chat Conversation target, renderers, stats, and details surface. */
+import type { Context } from '@prettier-ai/cordis';
+/** Services required by the Chat target and its presentation registrations. */
+export declare const inject: string[];
+/**
+ * Mount all Chat-owned contributions.
+ * @param ctx - Client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=apply.d.ts.map

package/lib/types/client/chat/ApprovalCommand.d.ts

@@ -0,0 +1,20 @@
+/** Chat-owned approval detail resolving a correlated Tool call's command. */
+import type { PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+interface ApprovalToolCall {
+    readonly callId: string;
+    readonly argsRaw: string;
+}
+/**
+ * Extract a shell command from a correlated Tool call when its arguments carry one.
+ * @param call - Tool call arguments, when a correlated call exists.
+ * @returns command text, or undefined for absent, malformed, or unrelated arguments.
+ */
+export declare function commandOf(call: ApprovalToolCall | undefined): string | undefined;
+/**
+ * Render the command of the Chat Tool node correlated with an approval.
+ * @param props - Approval identity and Session-standard Chat selector hook.
+ * @returns command text when the correlated call carries one.
+ */
+export declare function ApprovalCommand({ callId, useChat }: PropsRuntime<'conversation.approval.detail'>): string | null;
+export {};
+//# sourceMappingURL=ApprovalCommand.d.ts.map

package/lib/types/client/chat/AssistantMarkdown.d.ts

@@ -0,0 +1,22 @@
+import type { MarkdownFileMentions } from '@prettier-ai/dsh-client-ui-primitives';
+import type { ChatNodeOwnerProps, ChatViewSlotProps } from '../contract/slots.ts';
+import type { AssistantBlock } from '../contract/snapshot.ts';
+export interface AssistantMarkdownProps {
+    blocks: readonly AssistantBlock[];
+    streaming: boolean;
+    /** Frozen partial of an aborted turn: rendered with a stopped marker. */
+    interrupted?: boolean | undefined;
+    /** Render consecutive image blocks through the attachment slot. */
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    /** Hide reasoning that belongs to the Turn-level process disclosure. */
+    reasoningHidden?: boolean | undefined;
+    /** Reveal the owning Turn-level process disclosure. */
+    revealProcess?: (() => void) | undefined;
+    /** Resolved prose file mentions for this Assistant's closing turn. */
+    mentions?: MarkdownFileMentions | undefined;
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/** Reasoning block as the Think variant summary row (figma 39:28304). */
+export declare const AssistantMarkdown: import("react").MemoExoticComponent<({ blocks, streaming, interrupted, renderMessageImages, reasoningHidden, revealProcess, mentions, t, }: AssistantMarkdownProps) => import("react").JSX.Element | null>;
+//# sourceMappingURL=AssistantMarkdown.d.ts.map

package/lib/types/client/chat/AssistantNodeView.d.ts

@@ -0,0 +1,4 @@
+import type { ChatNodeViewProps } from '../contract/slots.ts';
+/** Streaming, settled, and interrupted Assistant states share one keyed renderer instance. */
+export declare const AssistantNodeView: import("react").MemoExoticComponent<({ node, useTurnData, turnProcess, openFile, renderMessageImages, fileMentions, t, }: ChatNodeViewProps<"assistant-step">) => import("react").JSX.Element>;
+//# sourceMappingURL=AssistantNodeView.d.ts.map

package/lib/types/client/chat/ChatNodeSeat.d.ts

@@ -0,0 +1,15 @@
+import type { ChatNodeOwnerProps, ChatViewSlotProps } from '../contract/slots.ts';
+interface ChatNodeSeatProps extends ChatNodeOwnerProps {
+    readonly nodeKey: string;
+    readonly historyIncomplete: boolean;
+    readonly compactTranscript: boolean;
+    readonly useChat: ChatViewSlotProps['useChat'];
+    readonly useStore: ChatViewSlotProps['useStore'];
+    readonly actions: ChatViewSlotProps['actions'];
+    readonly renderSlot: ChatViewSlotProps['renderSlot'];
+    readonly t: ChatViewSlotProps['t'];
+}
+/** Subscribe, apply Turn-process visibility, and dispatch one stable Context key. */
+export declare const ChatNodeSeat: import("react").MemoExoticComponent<({ nodeKey, historyIncomplete, compactTranscript, selectedCallId, cwd, openFile, inspectCall, forkAt, renderMessageImages, fileMentions, useChat, useStore, actions, renderSlot, t, }: ChatNodeSeatProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=ChatNodeSeat.d.ts.map

package/lib/types/client/chat/ChatView.d.ts

@@ -0,0 +1,7 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * The chat view slot entry: pure component over the composed props; each
+ * ordered business Node crosses the keyed renderer seat.
+ */
+export declare function ChatView({ useSession, useChat, useSessions, useStore, actions, renderSlot, sessionId, openFile, loadOlder, loadImage, openView, chatScroll, forkAt, fileMentions, useTranscriptView, t, }: ChatViewSlotProps): import("react").JSX.Element;
+//# sourceMappingURL=ChatView.d.ts.map

package/lib/types/client/chat/CommandNodeView.d.ts

@@ -0,0 +1,9 @@
+import type { PropsRenderSlots } from '@prettier-ai/dsh-client-ui-slots';
+import type { ChatNodeViewProps } from '../contract/slots.ts';
+type CommandNodeViewProps = ChatNodeViewProps<'command'> & PropsRenderSlots<'conversation.chat.commandview'>;
+/** Ordinary command lifecycle renderer with command-name keyed specialization. */
+export declare const CommandNodeView: import("react").MemoExoticComponent<({ node, renderSlot, t }: CommandNodeViewProps) => import("react").JSX.Element>;
+/** One integrated `/compact` command and compaction transaction renderer. */
+export declare const ManualCompactionNodeView: import("react").MemoExoticComponent<({ node, t, }: ChatNodeViewProps<"manual-compaction">) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=CommandNodeView.d.ts.map

package/lib/types/client/chat/CompactionCommandCard.d.ts

@@ -0,0 +1,8 @@
+import type { ChatViewSlotProps, CommandRowOwnerProps } from '../contract/slots.ts';
+interface CompactionCommandCardProps extends CommandRowOwnerProps {
+    t: ChatViewSlotProps['t'];
+}
+/** Render one manual compaction lifecycle without duplicating its checkpoint marker. */
+export declare function CompactionCommandCard({ node, compaction, t }: CompactionCommandCardProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=CompactionCommandCard.d.ts.map

package/lib/types/client/chat/CompactionItem.d.ts

@@ -0,0 +1,19 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { CompactionSummaryNode } from '../contract/snapshot.ts';
+interface CompactionItemProps {
+    node: CompactionSummaryNode;
+    /** Optional command title for a manual compaction folded into this marker. */
+    title?: string;
+    /** Command settlement text used when structured compaction counts are unavailable. */
+    fallbackSummary?: string | null;
+    /** The owning view's locale seat. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Renders the model-history compaction marker.
+ * @param props - the marker node off the snapshot cache.
+ * @returns the marker row, with the summary disclosure when one is available.
+ */
+export declare const CompactionItem: import("react").MemoExoticComponent<({ node, title, fallbackSummary, t, }: CompactionItemProps) => import("react").JSX.Element>;
+export {};
+//# sourceMappingURL=CompactionItem.d.ts.map

package/lib/types/client/chat/ContextBody.d.ts

@@ -0,0 +1,131 @@
+import type { ReactNode } from 'react';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ContextMessageNode } from '../contract/snapshot.ts';
+import type { KnownContextForm } from '@prettier-ai/dsh-client-ui-conversation/client';
+type Translate = ChatViewSlotProps['t'];
+/**
+ * Default presentation: the model-facing text as text, with its real line
+ * breaks, and the remaining source fields beneath it. This is what every form
+ * this UI version does not recognize renders as.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The opaque context body.
+ */
+export declare function OpaqueBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `instructions` form: the files this context reconciled, then their text.
+ *
+ * The text keeps its `<system-reminder>` framing verbatim — the framing is part
+ * of what the model read, so hiding it would misreport the request.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The instructions context body, or the opaque body when the change
+ * list is unreadable.
+ */
+export declare function InstructionsBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `catalog` form: the published entries as a list, read from the source rather
+ * than re-parsed out of the model-facing prose.
+ *
+ * A catalog whose source carries no usable entries falls through to the opaque
+ * body, so an older or hand-edited log still shows its text.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The catalog context body, or the opaque body when the entry list is
+ * unreadable.
+ */
+export declare function CatalogBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `snapshot` form: the named contributions this snapshot assembled, in order.
+ *
+ * The sections are the same bytes the model read, split at the boundaries the
+ * producer assembled them on, so a reader sees which subsystem contributed
+ * which state instead of one undifferentiated wall.
+ *
+ * One sentence of the model-facing text is NOT in any section: the producer's
+ * framing line declaring that this snapshot supersedes earlier ones. Unlike the
+ * `<system-reminder>` wrapper an instruction context carries — which wraps
+ * content and cannot be separated from it — that line states the form's own
+ * semantics, so the body states them as a caption instead of reprinting the
+ * joined prose beside the sections it was split from.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The snapshot context body, or the opaque body when unreadable.
+ */
+export declare function SnapshotBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `notice` form: what just happened, with the model-facing text beneath it.
+ *
+ * The one-line account also rides the collapsed row ({@link contextBody}), so a
+ * notice is usually readable without expanding at all.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The notice context body.
+ */
+export declare function NoticeBody({ content, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `relay` form: which agent sent this, then what it said.
+ *
+ * The sender is an opaque session id; it is shown as a field rather than a
+ * label, because this client cannot resolve it to a title.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The relay context body.
+ */
+export declare function RelayBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * `recall` form: which sessions this material came from and how much of each
+ * survived the read, then the material itself.
+ *
+ * Completeness is the fact a reader needs first: recalled context is bounded on
+ * the way in, so a card that hid the omitted count would overstate what the
+ * model received.
+ * @param props - Durable content, its source, and the locale seat.
+ * @returns The recall context body, or the opaque body when unreadable.
+ */
+export declare function RecallBody({ content, source, t }: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): ReactNode;
+/**
+ * Choose the body for one context node.
+ *
+ * Returns the form the body actually rendered as, which is not always the
+ * declared one: a declared form whose fields are unreadable falls back to
+ * opaque, and the caller labels the row with what it really shows.
+ * `summary` is the collapsed row's one-line account, which only a `notice`
+ * records: its whole point is being readable without expanding.
+ * @param form - the producer-declared form projected onto the node.
+ * @param props - durable content, its source, and the locale seat.
+ * @returns the rendered form (null for opaque), its collapsed summary, and its body.
+ */
+export declare function contextBody(form: ContextMessageNode['form'], props: {
+    content: ContextMessageNode['content'];
+    source: unknown;
+    t: Translate;
+}): {
+    rendered: KnownContextForm | null;
+    summary: string | null;
+    body: ReactNode;
+};
+export {};
+//# sourceMappingURL=ContextBody.d.ts.map

package/lib/types/client/chat/ContextInjectionRow.d.ts

@@ -0,0 +1,26 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ContextMessageNode } from '../contract/snapshot.ts';
+/** Props for the logged non-user message presentation. */
+export interface ContextInjectionRowProps {
+    content: ContextMessageNode['content'];
+    source: ContextMessageNode['source'];
+    /** Role and producer name projected from the durable source. */
+    provenance: ContextMessageNode['provenance'];
+    /** Producer-declared information form; null renders the opaque body. */
+    form: ContextMessageNode['form'];
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Render logged context with the Tool calls disclosure chrome from Figma.
+ *
+ * The header names the role the context plays and, beside it, the producer the
+ * durable source identifies, so a reader can tell an injected skill catalog
+ * from a workspace instruction file or a recalled session without expanding.
+ * The expanded body follows the producer-declared form; an absent or unknown
+ * form renders the opaque body.
+ * @param props - Durable content, its projected producer role/name and form, and the locale seat.
+ * @returns A collapsed context row with a bounded, form-specific body.
+ */
+export declare function ContextInjectionRow({ content, source, provenance, form, t }: ContextInjectionRowProps): import("react").JSX.Element;
+//# sourceMappingURL=ContextInjectionRow.d.ts.map

package/lib/types/client/chat/GenericCommandCard.d.ts

@@ -0,0 +1,9 @@
+import type { ChatViewSlotProps, CommandRowOwnerProps } from '../contract/slots.ts';
+/** Card props: the owner payload plus the render site's locale seat (plain prop). */
+export interface GenericCommandCardProps extends CommandRowOwnerProps {
+    t: ChatViewSlotProps['t'];
+    /** Command-specific running copy; absent uses the generic command label. */
+    runningSummary?: string | undefined;
+}
+export declare function GenericCommandCard({ node, t, runningSummary }: GenericCommandCardProps): import("react").JSX.Element;
+//# sourceMappingURL=GenericCommandCard.d.ts.map

package/lib/types/client/chat/MessageIconActions.d.ts

@@ -0,0 +1,36 @@
+import { type ReactNode } from 'react';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+export interface MessageIconActionsProps {
+    /** Plain text the copy action writes. */
+    text: string;
+    /** Unix epoch ms for the clock label; omitted for transient messages. */
+    time?: number | undefined;
+    /** Turn wall time in ms, appended to the clock as `· Ran for 15s`; omitted when the turn's start is unknown. */
+    runMs?: number | undefined;
+    /** Turn first-step TTFT in ms, appended as `· TTFT 1.2s`; omitted when unrecorded. */
+    ttftMs?: number | undefined;
+    /** Turn decode throughput, appended as `· 34 tok/s`; omitted when unrecorded. */
+    tokensPerSecond?: number | undefined;
+    /** Clock before icons (user) or after (assistant). */
+    clock: 'start' | 'end';
+    /** Fork the session at this message; omission hides the branch action. */
+    onBranch?: (() => void) | undefined;
+    /** The message is not a completed transcript tail, so branch stays visible but unavailable. */
+    branchUnavailable?: boolean | undefined;
+    /** Parent layout class composed onto the actions row. */
+    className?: string | undefined;
+    /**
+     * Slot-rendered actions owned by independent plugins, placed between the
+     * built-in copy and branch controls.
+     */
+    extraActions?: ReactNode;
+    /** The owning view's locale seat, passed down as a plain prop. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Copy / branch (/ clock) IconActions row shared by user and assistant chrome.
+ * @param props - Copy text, event time, clock side, branch callback, className.
+ * @returns The actions row element.
+ */
+export declare function MessageIconActions({ text, time, runMs, ttftMs, tokensPerSecond, clock, onBranch, branchUnavailable, className, extraActions, t, }: MessageIconActionsProps): import("react").JSX.Element;
+//# sourceMappingURL=MessageIconActions.d.ts.map

package/lib/types/client/chat/MessageItem.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+import type { PendingSubmission } from '@prettier-ai/dsh-api-session-controller/client';
+import type { ChatNodeOwnerProps, ChatNodeViewProps, ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * Render one Host-authoritative pending steering item with the same visual
+ * language as its eventual durable transcript node.
+ * @param props - Pending message content and conversation translator.
+ * @returns the pending steering bubble.
+ */
+export declare function PendingSteeringBubble({ content, renderMessageImages, t }: {
+    content: readonly unknown[];
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    t: ChatViewSlotProps['t'];
+}): ReactNode;
+/**
+ * Render one local submission echo with the exact visual language of the
+ * durable user node that replaces it: draft text plus object-URL previews,
+ * visible from the submit click until the durable `user/message` (or its
+ * queue occurrence) renders.
+ * @param props - the session snapshot's pending submission and render seats.
+ * @returns the echoed user bubble.
+ */
+export declare function PendingSubmissionBubble({ submission, renderMessageImages, t }: {
+    submission: PendingSubmission;
+    renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
+    t: ChatViewSlotProps['t'];
+}): ReactNode;
+/** User and admitted-steering keyed Chat renderer. */
+export declare const UserMessageNodeView: import("react").MemoExoticComponent<({ node, renderMessageImages, t, }: ChatNodeViewProps<"user" | "steering">) => import("react").JSX.Element>;
+/** Injected-context keyed Chat renderer. */
+export declare const ContextMessageNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"context">) => import("react").JSX.Element>;
+/** Automatic compaction keyed Chat renderer. */
+export declare const CompactionNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"compaction">) => import("react").JSX.Element>;
+/** Correlated retry-chain keyed Chat renderer. */
+export declare const RetryNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"model-retry">) => import("react").JSX.Element>;
+/** Terminal turn-error keyed Chat renderer. */
+export declare const TurnErrorNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"turn-error">) => import("react").JSX.Element>;
+/** Max-tokens turn-end notice keyed Chat renderer. */
+export declare const TurnMaxTokensNodeView: import("react").MemoExoticComponent<({ t }: ChatNodeViewProps<"turn-max-tokens">) => import("react").JSX.Element>;
+/** Explicit unknown-surface keyed Chat renderer. */
+export declare const UnknownNodeView: import("react").MemoExoticComponent<({ node, t }: ChatNodeViewProps<"unknown">) => import("react").JSX.Element>;
+//# sourceMappingURL=MessageItem.d.ts.map

package/lib/types/client/chat/ReasoningRow.d.ts

@@ -0,0 +1,14 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * Render one assistant reasoning block as the Think disclosure row.
+ * @param props.text - complete or streaming reasoning text.
+ * @param props.running - whether this block is the streaming tail.
+ * @param props.t - conversation locale seat for the running status.
+ * @returns the reasoning disclosure.
+ */
+export declare function ReasoningRow({ text, running, t }: {
+    text: string;
+    running: boolean;
+    t: ChatViewSlotProps['t'];
+}): import("react").JSX.Element;
+//# sourceMappingURL=ReasoningRow.d.ts.map

package/lib/types/client/chat/StatsLine.d.ts

@@ -0,0 +1,64 @@
+import type { UseProjection } from '@prettier-ai/dsh-api-session-controller/client';
+import type { SnapshotSelectorHook } from '@prettier-ai/dsh-client-ui-slots';
+import type { TokenUsageProjection } from '@prettier-ai/dsh-token-meter/client';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+interface WindowStats {
+    turns: number;
+    steps: number;
+    /** Summed request wall time (step/start → assistant/message); 0 when no node carries timing. */
+    llmMs: number;
+    /** Summed tool wall time (tool/call → tool/result); 0 when no pair is in-window. */
+    toolMs: number;
+    /** Summed first-token latency over `ttftSteps`; 0 when no step records it. */
+    ttftMs: number;
+    /** Steps carrying a recorded TTFT. */
+    ttftSteps: number;
+    /** Summed decode wall time over steps that also report output tokens. */
+    decodeMs: number;
+    /** Summed output tokens over the same decode-timed steps. */
+    decodeTokens: number;
+}
+/**
+ * Fold assistant and tool-result nodes into window-scoped display totals —
+ * the FALLBACK for assemblies without the `sessionStats` projection.
+ *
+ * Every displayed figure rides that durable whole-log projection (and token
+ * accounting rides `tokenUsage`) because the window is paged and compaction
+ * rewrites it; this fold answers "what is on screen" only when no projection
+ * value is served. Its field names deliberately mirror the projection's so
+ * the two swap wholesale.
+ * @param nodes - snapshot nodes.
+ * @returns fallback counts and summed wall times.
+ */
+export declare function deriveStats(nodes: ChatSnapshot['legacy']['nodes']): WindowStats;
+/**
+ * Compact duration: 45.2s under a minute, 2m42s from there on.
+ * @param ms - duration in milliseconds.
+ * @returns display string.
+ */
+export declare function formatDuration(ms: number, t: ChatViewSlotProps['t']): string;
+/**
+ * Display-ready cache-hit share of prompt-side input over the whole durable log.
+ * @param usage - the session's token-usage projection value.
+ * @returns integer text when integer rounding stays below 100, otherwise the
+ * minimum decimal precision that still rounds below 100; a full hit returns
+ * 100, and no billed input returns null.
+ */
+export declare function cacheHitPercent(usage: TokenUsageProjection): string | null;
+/**
+ * Sum the three disjoint prompt-side billing buckets.
+ * @param usage - the session's token-usage projection value.
+ * @returns billed input tokens.
+ */
+export declare function billedInputTokens(usage: TokenUsageProjection): number;
+/** Props: the conversation-snapshot selector plus the projection read seat. */
+export interface StatsLineProps {
+    useChat: SnapshotSelectorHook<ChatSnapshot>;
+    useProjection: UseProjection;
+    /** The owning dock's locale seat. */
+    t: ChatViewSlotProps['t'];
+}
+export declare const StatsLine: import("react").MemoExoticComponent<({ useChat, useProjection, t }: StatsLineProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=StatsLine.d.ts.map

package/lib/types/client/chat/SystemPromptRow.d.ts

@@ -0,0 +1,19 @@
+import type { ChatNodeViewProps, ChatViewSlotProps } from '../contract/slots.ts';
+/** Props for one complete system prompt disclosure. */
+export interface SystemPromptRowProps {
+    /** Complete model-visible prompt text. */
+    text: string;
+    /** The owning view's locale seat. */
+    t: ChatViewSlotProps['t'];
+}
+/**
+ * Render one complete system prompt as a collapsed disclosure whose expanded
+ * body is the same opaque context chrome: 141px code-block scrollport and
+ * model-facing text with its real line breaks.
+ * @param props - Complete prompt text and the locale seat.
+ * @returns The system-prompt disclosure row.
+ */
+export declare function SystemPromptRow({ text, t }: SystemPromptRowProps): import("react").JSX.Element;
+/** System-prompt keyed Chat renderer. */
+export declare const SystemPromptNodeView: import("react").MemoExoticComponent<({ node, t, }: Pick<ChatNodeViewProps<"system-prompt">, "node" | "t">) => import("react").JSX.Element>;
+//# sourceMappingURL=SystemPromptRow.d.ts.map

package/lib/types/client/chat/TurnNavigator.d.ts

@@ -0,0 +1,21 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { TurnNavigationItem } from '../contract/snapshot.ts';
+interface TurnNavigatorProps {
+    readonly items: readonly TurnNavigationItem[];
+    readonly activeTurn: number | null;
+    readonly onNavigate: (item: TurnNavigationItem) => void;
+    readonly t: ChatViewSlotProps['t'];
+}
+declare function TurnNavigatorRail({ items, activeTurn, onNavigate, t }: TurnNavigatorProps): import("react").JSX.Element | null;
+/**
+ * Compact rail of the currently loaded Turns with hover and focus previews.
+ *
+ * Memoized because it renders two host elements per loaded Turn while the
+ * enclosing view re-renders on every streaming delta: without the guard a long
+ * session rebuilds hundreds of marks per commit for a rail that only changes
+ * when a Turn is added, removed, or becomes active. Its props must therefore
+ * stay referentially stable across those commits.
+ */
+export declare const TurnNavigator: import("react").MemoExoticComponent<typeof TurnNavigatorRail>;
+export {};
+//# sourceMappingURL=TurnNavigator.d.ts.map

package/lib/types/client/chat/TurnProcessNodeView.d.ts

@@ -0,0 +1,4 @@
+import type { ChatNodeViewProps } from '../contract/slots.ts';
+/** Turn-level process disclosure controller. */
+export declare const TurnProcessNodeView: import("react").MemoExoticComponent<({ node, turnProcess, t, }: ChatNodeViewProps<"turn-process">) => import("react").JSX.Element | null>;
+//# sourceMappingURL=TurnProcessNodeView.d.ts.map

package/lib/types/client/chat/TurnTailNodeView.d.ts

@@ -0,0 +1,7 @@
+import type { PropsRenderSlots } from '@prettier-ai/dsh-client-ui-slots';
+import type { ChatNodeViewProps } from '../contract/slots.ts';
+type TurnTailNodeViewProps = ChatNodeViewProps<'turn-tail'> & PropsRenderSlots<'conversation.chat.turnTail' | 'conversation.chat.assistant-actions'>;
+/** Turn-local actions and feature tail over the Location index, independent of Assistant placement. */
+export declare const TurnTailNodeView: import("react").MemoExoticComponent<({ node, openFile, forkAt, renderSlot, renderSlotChain, t, useChat, }: TurnTailNodeViewProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=TurnTailNodeView.d.ts.map

package/lib/types/client/chat/TurnUsageDisclosure.d.ts

@@ -0,0 +1,9 @@
+import type { TurnTokenUsage } from '../contract/chat-nodes.ts';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+export interface TurnUsageDisclosureProps {
+    usage: TurnTokenUsage;
+    t: ChatViewSlotProps['t'];
+}
+/** Compact per-Turn usage summary with an opt-in bucket breakdown. */
+export declare function TurnUsageDisclosure({ usage, t }: TurnUsageDisclosureProps): import("react").JSX.Element;
+//# sourceMappingURL=TurnUsageDisclosure.d.ts.map