@deepseek-ai/dsh-client-ui-conversation 0.0.1-rc.1

package/lib/index.js

@@ -0,0 +1,28 @@
+import { settingsNamespace } from "@deepseek-ai/dsh-settings";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/submission-settings.js
+/** Busy-Enter preference stored in the Host user-settings document. */
+/** Settings namespace owned by the conversation plugin. */
+const CONVERSATION_SETTINGS_NAMESPACE = "ui-conversation";
+/** Field carrying the delivery mode for plain Enter while an agent is busy. */
+const BUSY_ENTER_FIELD = "busyEnter";
+/** Busy-Enter behaviors accepted at settings and input boundaries. */
+const BUSY_ENTER_BEHAVIORS = ["queue", "steer"];
+/** Default preserves Enter-as-Queue for running conversations. */
+const DEFAULT_BUSY_ENTER_BEHAVIOR = "queue";
+/** Durable conversation schema; also the wire envelope the browser scope validates against. */
+const ConversationSettingsSchema = z.object({ [BUSY_ENTER_FIELD]: z.union([...BUSY_ENTER_BEHAVIORS]).default(DEFAULT_BUSY_ENTER_BEHAVIOR) });
+//#endregion
+//#region lib/types/index.js
+/** Host registration for browser conversation preferences. */
+/**
+* Register the durable conversation section when a settings provider exists.
+* @param ctx - Host context whose optional settings service owns the section.
+*/
+function apply(ctx) {
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.register(settingsNamespace(CONVERSATION_SETTINGS_NAMESPACE), ConversationSettingsSchema);
+	});
+}
+//#endregion
+export { BUSY_ENTER_BEHAVIORS, BUSY_ENTER_FIELD, CONVERSATION_SETTINGS_NAMESPACE, DEFAULT_BUSY_ENTER_BEHAVIOR, apply };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-conversation`.
+* @module @deepseek-ai/dsh-client-ui-conversation/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-ui-conversation";
+/** Cordis companion plugin name. */
+const name = "client-ui-conversation-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the conversation service emits no cordis events, and
+* both rings this package owns (the 'conversation.view' tab ring and the
+* 'conversation.chat.node' business renderer seat) ride the slot system, whose ledger
+* invariants live with the runtime slots package.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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

@@ -0,0 +1,16 @@
+/** Registers the conversation components, shared store, and service callbacks. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ConversationKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The conversation skeleton, chat flow, commands, details, and docks copy. */
+        conversation: ConversationKey;
+    }
+}
+/** Services required by the conversation plugin. */
+export declare const inject: string[];
+/** Mounts the conversation plugin.
+ * @param ctx - Client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=apply.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { AssistantBlock } from '@deepseek-ai/dsh-client-runtime/client';
+import type { MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import { type ImageLoader } from './MessageImage.tsx';
+export interface AssistantMarkdownProps {
+    blocks: readonly AssistantBlock[];
+    streaming: boolean;
+    /** Frozen partial of an aborted turn: rendered with a stopped marker. */
+    interrupted?: boolean | undefined;
+    /** Session-authorized durable image loader. */
+    loadImage?: ImageLoader;
+    /** 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, loadImage, 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, openFile, loadImage, 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,11 @@
+import type { ChatNodeOwnerProps, ChatViewSlotProps } from '../contract/slots.ts';
+interface ChatNodeSeatProps extends ChatNodeOwnerProps {
+    readonly nodeKey: string;
+    readonly useSession: ChatViewSlotProps['useSession'];
+    readonly renderSlot: ChatViewSlotProps['renderSlot'];
+    readonly t: ChatViewSlotProps['t'];
+}
+/** Subscribe and dispatch one stable Context key without observing sibling Nodes. */
+export declare const ChatNodeSeat: import("react").MemoExoticComponent<({ nodeKey, selectedCallId, cwd, openFile, inspectCall, forkAt, loadImage, fileMentions, useSession, 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, useSessions, useStore, renderSlot, sessionId, openFile, loadOlder, loadImage, inspectCall, chatScroll, forkAt, fileMentions, 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 '@deepseek-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 { CompactionSummaryNode } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ChatViewSlotProps } from '../contract/slots.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'];
+}
+/**
+ * The collapsed-by-default 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,130 @@
+import type { ReactNode } from 'react';
+import type { ContextMessageNode, KnownContextForm } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+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 { ContextMessageNode } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ChatViewSlotProps } from '../contract/slots.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,30 @@
+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;
+    /** 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, t, }: MessageIconActionsProps): import("react").JSX.Element;
+//# sourceMappingURL=MessageIconActions.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+/** Loads a session-authorized durable image URL. */
+export type ImageLoader = (attachment: ImageAttachmentRef) => Promise<string>;
+/** Compact history renderer with retryable loading and double-click original preview. */
+export declare function MessageImage({ attachment, load, t }: {
+    attachment: ImageAttachmentRef;
+    load: ImageLoader;
+    t: ChatViewSlotProps['t'];
+}): import("react").JSX.Element;
+/** Wrapping image group shared by user and assistant history. */
+export declare function ImageGallery({ images, load, align, t }: {
+    images: readonly {
+        attachment: ImageAttachmentRef;
+    }[];
+    load: ImageLoader;
+    align: 'start' | 'end';
+    t: ChatViewSlotProps['t'];
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=MessageImage.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+import type { ChatNodeViewProps, ChatViewSlotProps } from '../contract/slots.ts';
+import { type ImageLoader } from './MessageImage.tsx';
+/**
+ * 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, loadImage, t }: {
+    content: readonly unknown[];
+    loadImage?: ImageLoader;
+    t: ChatViewSlotProps['t'];
+}): ReactNode;
+/** User and admitted-steering keyed Chat renderer. */
+export declare const UserMessageNodeView: import("react").MemoExoticComponent<({ node, loadImage, 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>;
+/** 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,83 @@
+import type { ConversationSnapshot, UseProjection } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ContextPressureProjection, TokenUsageProjection } from '@deepseek-ai/dsh-token-meter/client';
+import type { ComposerBarProps } from '../contract/slots.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 the window-scoped display totals.
+ *
+ * Counts and wall times describe the loaded window on purpose — they answer
+ * "what is on screen". Token accounting deliberately does NOT come from here:
+ * the window is paged and compaction rewrites it, so billing rides the durable
+ * `tokenUsage` projection instead.
+ * @param nodes - snapshot nodes.
+ * @returns visible counts and summed wall times.
+ */
+export declare function deriveStats(nodes: ConversationSnapshot['nodes']): WindowStats;
+/**
+ * Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three digits).
+ * @param n - token count.
+ * @returns display string.
+ */
+export declare function formatTokens(n: number): string;
+/**
+ * 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): string;
+/**
+ * Cache-hit share of prompt-side input over the whole durable log.
+ * @param usage - the session's token-usage projection value.
+ * @returns rounded integer percent, or null when no input was billed.
+ */
+export declare function cacheHitPercent(usage: TokenUsageProjection): number | 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;
+interface ContextOccupancy {
+    percent: number;
+    usedTokens: number;
+    contextWindow: number;
+}
+/**
+ * Approximate context occupancy, using the TUI's integer rounding and upper
+ * clamp. The numerator is `projectedTokens` — the provider sample carried
+ * forward over the surface's movement since — so compaction shows immediately
+ * instead of waiting for the next request to report usage; it falls back to the
+ * bare sample only for a log whose projection predates that field. Numerator
+ * and capacity remain independent last-wins projection fields, so this is a
+ * reference figure rather than an exact measurement of one request (see the
+ * token-meter README).
+ * @param pressure - the session's context-pressure projection value.
+ * @returns occupancy with its numerator and denominator, or null until both values are known.
+ */
+export declare function contextOccupancy(pressure: ContextPressureProjection | undefined): ContextOccupancy | null;
+/** Props: the conversation-snapshot selector plus the projection read seat. */
+export interface StatsLineProps {
+    useSession: SnapshotSelectorHook<ConversationSnapshot>;
+    useProjection: UseProjection;
+    /** The owning dock's locale seat. */
+    t: ComposerBarProps['t'];
+}
+export declare const StatsLine: import("react").MemoExoticComponent<({ useSession, useProjection, t }: StatsLineProps) => import("react").JSX.Element | null>;
+export {};
+//# sourceMappingURL=StatsLine.d.ts.map

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

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

package/lib/types/client/chat/message-chrome.d.ts

@@ -0,0 +1,49 @@
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+/** The date-template share of the conversation dictionary the clock consumes. */
+export type ClockTranslate = Translate<'clock.md' | 'clock.ymd'>;
+/** The elapsed-duration share of the conversation dictionary. */
+export type RunDurationTranslate = Translate<'duration.seconds' | 'duration.minutes'>;
+/**
+ * Local calendar-day epoch (ms at local midnight) for an instant.
+ * @param ms - Unix epoch ms.
+ * @returns Midnight of that local calendar day.
+ */
+export declare function startOfLocalDay(ms: number): number;
+/**
+ * Delay until the next local midnight after `ms` (at least 1ms).
+ * @param ms - Unix epoch ms.
+ * @returns Milliseconds until the following local midnight.
+ */
+export declare function msUntilNextLocalMidnight(ms: number): number;
+/**
+ * Localized elapsed-time label shared by running and settled turn chrome.
+ * @param ms - Elapsed duration in milliseconds (negatives clamp to zero).
+ * @param t - Translate seat supplying the duration templates.
+ * @returns Display string in whole seconds.
+ */
+export declare function formatRunDuration(ms: number, t: RunDurationTranslate): string;
+/**
+ * Sub-turn latency figure: one decimal under ten seconds, whole seconds
+ * beyond. Unit-less so the locale template owns the second suffix.
+ * @param ms - Latency in milliseconds (negatives clamp to zero).
+ * @returns Display number in seconds without unit.
+ */
+export declare function formatLatencySeconds(ms: number): string;
+/**
+ * Decode-throughput figure: whole tokens from ten up, one decimal below.
+ * @param tps - Tokens per second.
+ * @returns Display number without unit.
+ */
+export declare function formatTokensPerSecond(tps: number): string;
+/**
+ * Compact local timestamp for message IconActions. Same calendar day →
+ * `HH:mm`; earlier this year → the `clock.md` date template + clock; other
+ * years → the `clock.ymd` template + clock. Pure: the date templates arrive
+ * through the caller's locale seat.
+ * @param time - Unix epoch ms from the source session event.
+ * @param t - translate seat supplying the `clock.md` / `clock.ymd` templates.
+ * @param now - Reference instant for the day/year cut (defaults to wall clock).
+ * @returns Date-aware clock string (24-hour, zero-padded time).
+ */
+export declare function formatMessageClock(time: number, t: ClockTranslate, now?: number): string;
+//# sourceMappingURL=message-chrome.d.ts.map

package/lib/types/client/chat/register-node-renderers.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Register this package's business renderers behind the keyed Chat Node seat.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerChatNodeRenderers(ctx: Context): void;
+//# sourceMappingURL=register-node-renderers.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { ConversationSnapshot, ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+/**
+ * Read one root Tool lifecycle through the internal Chat Node index.
+ * @param snapshot - current Conversation snapshot.
+ * @param rootCallId - root call identity and Tool Context identity.
+ * @returns root lifecycle when it is materialized in the current window.
+ */
+export declare function rootToolCall(snapshot: ConversationSnapshot, rootCallId: string): ToolCallBlock | undefined;
+/**
+ * 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: ConversationSnapshot, callId: string): ToolCallBlock | undefined;
+//# sourceMappingURL=tool-node-reader.d.ts.map

package/lib/types/client/chat/turn-assistant.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantBlock } from '@deepseek-ai/dsh-client-runtime/client';
+/**
+ * Collect visible prose from one Assistant lifecycle.
+ * @param blocks - Assistant content blocks.
+ * @returns concatenated text blocks.
+ */
+export declare function assistantText(blocks: readonly AssistantBlock[]): string;
+//# sourceMappingURL=turn-assistant.d.ts.map

package/lib/types/client/chat/turn-metrics.d.ts

@@ -0,0 +1,38 @@
+import type { AssistantMessageNode, ConversationNode } from '@deepseek-ai/dsh-client-runtime/client';
+/** Latency and decode-throughput readings for one turn's footer. */
+export interface TurnMetrics {
+    /** First-step TTFT in ms; absent when that step carries no recorded timing. */
+    ttftMs?: number;
+    /** Decode throughput over steps carrying both timing and provider usage. */
+    tokensPerSecond?: number;
+}
+/** One assistant step's derivable latency facts; null marks an unrecorded part. */
+export interface StepReading {
+    /** step/start → first token delta, in ms. */
+    ttftMs: number | null;
+    /** First token delta → final message, in ms. */
+    decodeMs: number | null;
+    /** Provider-reported completion tokens. */
+    outputTokens: number | null;
+}
+type AssistantNode = AssistantMessageNode;
+/**
+ * Read one assistant node's TTFT, decode wall time, and output tokens.
+ * @param node - A settled assistant node.
+ * @returns Per-part readings with `null` for unrecorded values.
+ */
+export declare function assistantStepReading(node: AssistantNode): StepReading;
+/**
+ * Fold assistant nodes into per-turn footer metrics.
+ *
+ * TTFT is the turn's lowest-step request-dispatch-to-first-token reading, so
+ * it is only meaningful when the turn's start is inside
+ * the loaded window (the caller gates on `turnTimings`, which shares that
+ * window). Throughput divides summed output tokens by summed decode wall time,
+ * counting only steps that carry both.
+ * @param nodes - Snapshot nodes of the loaded window.
+ * @returns Turn number → available metrics; turns with none are absent.
+ */
+export declare function deriveTurnMetrics(nodes: readonly ConversationNode[]): Map<number, TurnMetrics>;
+export {};
+//# sourceMappingURL=turn-metrics.d.ts.map