@huanlin/dsh-focus-chat 0.1.23

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

@@ -0,0 +1,289 @@
+/** Pure type face of the focus flow model (React-free). */
+import type { DiffHunk, ReadBlockLine, SearchBlockProps, WebBlockProps } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { AssistantBlock, ChatNodeDataMap, ContextMessageNode } from '@deepseek-ai/dsh-client-ui-chat/client';
+import type { TurnTokenUsage } from '@deepseek-ai/dsh-client-ui-chat/src/client/contract/chat-nodes.ts';
+/** Locale-owned label surfaces the render sites add to the shared card primitives. */
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/** Search-card data the model owns; render adds `labels`/`maxLines`/`className`. */
+export type FocusSearchBlockProps = DistributiveOmit<SearchBlockProps, 'labels' | 'maxLines' | 'className'>;
+/** Web-card data the model owns; render adds `labels`/`className`. */
+export type FocusWebBlockProps = DistributiveOmit<WebBlockProps, 'labels' | 'className'>;
+export type FocusCard = {
+    kind: 'terminal';
+    command: string;
+    cwd: string | undefined;
+    output: string | undefined;
+    exitCode: number | undefined;
+    signal: string | undefined;
+    running: boolean;
+    description: string | undefined;
+} | {
+    kind: 'diff';
+    diffs: DiffHunk[];
+} | {
+    kind: 'read';
+    label: string;
+    lines: ReadBlockLine[];
+    totalLines: number;
+    lang: string | undefined;
+} | {
+    kind: 'search';
+    props: FocusSearchBlockProps;
+    recovery: string | undefined;
+} | {
+    kind: 'web';
+    props: FocusWebBlockProps;
+};
+/** Tool-row state semantics; colors self-supplied by the view. */
+export type FocusToolState = 'running' | 'ok' | 'error' | 'stopped';
+/** Tool-call row variants selected by the generic renderer (the chat table). */
+export type FocusToolVariant = 'search' | 'read' | 'bash' | 'write' | 'edit' | 'code' | 'question' | 'todo' | 'skill' | 'others';
+/** One Tool call's condensed row model, derived from the frozen block. */
+export interface FocusToolRow {
+    callId: string;
+    /** Wire Tool name ('' when the window dropped the call head). */
+    name: string;
+    /** Row variant (the chat row's classification). */
+    variant: FocusToolVariant;
+    /** Row title: the tool-owned or variant design literal (the chat row's). */
+    title: string;
+    /** Args-derived one-line summary (falls back to the call id). */
+    summary: string;
+    /** Filesystem path from args for single-file tools; undefined otherwise. */
+    filePath: string | undefined;
+    state: FocusToolState;
+    /** Flattened result text; null while running or when the result has none. */
+    output: string | null;
+    /** First result line on an error row; null otherwise. */
+    errorSummary: string | null;
+    /** Settled call's structured error code; null while running or when the
+     *  result carries no error (the ask-question row's verdict codes). */
+    errorCode: string | null;
+    /** Call start wall-clock time; null once settled. The view's live-row
+     *  debounce reads it (a young running call paints nothing). */
+    time: number | null;
+    /** Expanded-body input text (pretty args); null = no input section. */
+    body: string | null;
+    /** Card render material from the host-computed views; null = generic sections. */
+    card: FocusCard | null;
+    /** Recursive child rows (the sub-call tree), in dispatch order. */
+    subcalls: readonly FocusToolRow[];
+}
+/** One reasoning row absorbed into a tool group (the chat Think disclosure). */
+export interface FocusGroupThink {
+    /** Complete or streaming reasoning text. */
+    text: string;
+    /** Whether the reasoning is still the streaming tail (sweep + tail preview). */
+    running: boolean;
+}
+/** One folded row inside a tool group: an absorbed context row, an absorbed
+ *  Think row, or a call. */
+export type FocusGroupItem = FocusContextItem | FocusGroupThink | FocusToolRow;
+/** Step-summary metric families the group line aggregates, in display order. */
+export type FocusMetricKey = 'commands' | 'edits' | 'searches' | 'files' | 'dirs' | 'subagents' | 'todos' | 'goals' | 'workflows' | 'skills' | 'questions' | 'plans' | 'jobs';
+/** Tool name → metric family; unknown tools carry no metric. Writes fold
+ *  into the edit family (the summary line reads one "edited" segment); the
+ *  agentic families (delegation, todo, goal, workflow, skill, question,
+ *  plan) replace the generic "called N tools" remainder for their own tools. */
+export interface FocusGroupMetrics {
+    commands: number;
+    edits: number;
+    searches: number;
+    files: number;
+    dirs: number;
+    /** Delegation calls (subagent / subagent_fork): "forked N subagents". */
+    subagents: number;
+    /** Todo mutations (todo_write): "更新了待办 / updated todos". */
+    todos: number;
+    /** Goal mutations (create/update/get_goal): "更新了目标 / updated goals". */
+    goals: number;
+    /** Orchestration calls (workflow / ralph): "ran N workflows". */
+    workflows: number;
+    /** Skill loads (skill): "loaded N skills". */
+    skills: number;
+    /** User questions (ask_user_question): "asked N questions". */
+    questions: number;
+    /** Plan-mode entries (plan): "planned N times". */
+    plans: number;
+    /** Background-job activity (job_output / job_kill / job_list calls and the
+     *  tool-jobs settlements a `notice` context injection carries): the summary
+     *  line reads "N background jobs" — the settlement's own one-line account
+     *  no longer rides the line verbatim. */
+    jobs: number;
+    /** Failed calls in the failure-aware families (error-state rows): command
+     *  execution and other tools. File operations never carry a failure tally —
+     *  the edit family's count is the outcome (distinct files actually edited). */
+    commandsFailed: number;
+    searchesFailed: number;
+}
+/** One focus-mode group: the consecutive root calls folded into a summary line. */
+export interface FocusToolGroup {
+    /** Chat node keys of the folded roots, in flow order. */
+    nodeKeys: readonly string[];
+    /** Folded rows in flow order: the absorbed context rows, Think rows, and the calls. */
+    items: readonly FocusGroupItem[];
+    /** Whether any folded call is still running. */
+    running: boolean;
+    /** Per-family call counts, with failure tallies for the failure-aware families. */
+    metrics: FocusGroupMetrics;
+    /** Context injections directly preceding the run, absorbed into the group. */
+    contextCount: number;
+    context: readonly FocusContextItem[];
+    /**
+     * Thinking time of the runs folded into this group, summed when every run
+     * carries timing (the group merges directly-consecutive runs); null when
+     * unavailable.
+     */
+    thoughtMs: number | null;
+}
+/** One context-injection message row (the chat ContextInjectionRow chrome). */
+export type FocusContextItem = Extract<FocusFlowItem, {
+    kind: 'message';
+}> & {
+    role: 'context';
+};
+/** One condensed flow row; the view dispatches on `kind`. */
+export type FocusFlowItem = {
+    kind: 'message';
+    nodeKey: string;
+    role: 'user' | 'steering' | 'context';
+    content: readonly ContentBlock[];
+    time: number;
+    /** Context-injection chrome (the chat ContextInjectionRow); absent for user/steering. */
+    context?: {
+        source: ContextMessageNode['source'];
+        provenance: ContextMessageNode['provenance'];
+        form: ContextMessageNode['form'];
+    };
+} | {
+    /**
+     * One running turn's context batch: consecutive context injections
+     * folded into a single line while the turn is open (a completed turn
+     * folds them individually into the turn fold instead).
+     */
+    kind: 'context-fold';
+    nodeKey: string;
+    turn: number | null;
+    /** The merged context messages, in flow order. */
+    items: readonly FocusContextItem[];
+} | {
+    kind: 'assistant';
+    nodeKey: string;
+    /** Remaining blocks; reasoning absorbed into a directly-following tool group is filtered out. */
+    blocks: readonly AssistantBlock[];
+    running: boolean;
+    interrupted: boolean;
+    thoughtMs: number | null;
+    /** Settled assistant seq; null while streaming. */
+    finalSeq: number | null;
+} | {
+    kind: 'tools';
+    group: FocusToolGroup;
+} | {
+    kind: 'system-prompt';
+    nodeKey: string;
+    /** Complete model-visible prompt text. */
+    text: string;
+} | {
+    kind: 'turn-fold';
+    nodeKey: string;
+    turn: number;
+    /** Turn wall time (start → end); the "工作了 X 分 Y 秒" reading. */
+    durationMs: number;
+    /** The user stopped the turn: the line reads "用户 X 后停止" instead. */
+    stopped: boolean;
+    /** Turn-process counts (the official turn fold's measurement): durable
+     *  messages, tool calls, and subagent delegations in the folded turn. */
+    messageCount: number;
+    toolCallCount: number;
+    subagentCount: number;
+    /** The turn's folded rows — intermediate assistant items and tool runs — in flow order. */
+    items: readonly FocusFlowItem[];
+} | {
+    kind: 'turn-tail';
+    nodeKey: string;
+    turn: number;
+    /** Closing assistant seq — the fork anchor; null when the turn ended without one. */
+    closingSeq: number | null;
+    /** Durable identity of the closing assistant message; null when the turn
+     *  ended without one (interruption-frozen partial). */
+    closingMessageId: string | null;
+    /** Closing assistant time (the actions clock). */
+    closingTime: number | null;
+    /** Text of the closing assistant (the copy source). */
+    closingText: string;
+    /** Turn wall time for the `· Ran for Ns` reading. */
+    runMs: number | null;
+    /** Turn first-step TTFT in ms, when recorded. */
+    ttftMs: number | null;
+    /** Turn decode throughput, when recorded. */
+    tokensPerSecond: number | null;
+    /** Whether fork is unavailable (engine-computed; mirrors the chat tail). */
+    branchUnavailable: boolean;
+    /** Files produced by the closing turn, in first-seen order. */
+    produced: readonly string[];
+    /** Exact provider-reported token accounting, when the turn recorded it. */
+    tokenUsage: TurnTokenUsage | undefined;
+} | {
+    kind: 'command';
+    nodeKey: string;
+    name: string | null;
+    args: string | null;
+    outcomeText: string | null;
+    outcomeError: boolean;
+    running: boolean;
+} | {
+    kind: 'manual-compaction';
+    nodeKey: string;
+    name: string | null;
+    outcomeText: string | null;
+    outcomeError: boolean;
+    running: boolean;
+    compaction: {
+        summary: string | null;
+        shadowedItemCount: number | null;
+        shadowedTokenCount: number | null;
+    } | null;
+} | {
+    kind: 'compaction';
+    nodeKey: string;
+    summary: string | null;
+    shadowedItemCount: number | null;
+    shadowedTokenCount: number | null;
+} | {
+    kind: 'retry';
+    nodeKey: string;
+    delayMs: number;
+    retry: number;
+    /** 'always' retries never exhaust; the chat row shows ∞. */
+    maxRetries: number | null;
+    mode: 'normal' | 'always';
+    retryState: 'scheduled' | 'started' | 'cancelled';
+    failure: {
+        message: string;
+    } | null;
+} | {
+    kind: 'turn-error';
+    nodeKey: string;
+    message: string;
+    code: string | undefined;
+} | {
+    kind: 'turn-max-tokens';
+    nodeKey: string;
+} | {
+    kind: 'unknown';
+    nodeKey: string;
+    nodeKind: string;
+    data: unknown;
+};
+/** The chat node data union the focus view narrows, keyed by the merge-extensible map. */
+export type FocusNodeData = ChatNodeDataMap[Extract<keyof ChatNodeDataMap, string>];
+/** One produced-path fact (the ui-deliverables turn data contract). */
+export interface FocusDeliverablesData {
+    readonly produced: readonly {
+        readonly seq: number;
+        readonly path: string;
+    }[];
+}
+export {};

package/lib/types/client/view/FocusView.d.ts

@@ -0,0 +1,9 @@
+import type { FocusViewProps } from '../contract/props.ts';
+/**
+ * The focus view slot entry: pure component over the composed props. Scroll
+ * follows the chat view's ledger: the resolved scrollport (the shared
+ * conversation column in the app, the view itself in tests) keeps reader
+ * positions saved continuously on scroll and restored on mount.
+ * @param props - conversation view standard kit and the focus locale seat.
+ */
+export declare function FocusView({ useSession, useChat, sessionId, useSessions, loadOlder, loadImage, openFile, forkAt, fileMentions, isLoopback, scroll, useHostHome, useFeedback, ensureFeedback, rateFeedback, toggleFeedback, clearFeedbackNote, t, }: FocusViewProps): import("react").JSX.Element;

package/lib/types/client/view/chrome/ImageLightbox.d.ts

@@ -0,0 +1,26 @@
+/** Lightbox strings the owner resolves from its own locale namespace. */
+export interface ImageLightboxLabels {
+    /** Accessible name of the preview dialog. */
+    dialog: string;
+    /** Accessible label of the close control. */
+    close: string;
+}
+/**
+ * Document-level original-image preview opened by clicking a thumbnail.
+ * Closes on Escape, backdrop press, or the close control, and restores focus
+ * to the opener on unmount. Rendered through a body portal: an opener inside
+ * a transformed or filtered ancestor would otherwise trap the fixed backdrop
+ * in that ancestor's box instead of covering the viewport.
+ *
+ * @param props.src - the original image URL.
+ * @param props.alt - the image's alt text.
+ * @param props.labels - dialog and close-control strings.
+ * @param props.onClose - dismiss callback owned by the opener.
+ * @returns the modal preview dialog.
+ */
+export declare function ImageLightbox({ src, alt, labels, onClose }: {
+    src: string;
+    alt: string;
+    labels: ImageLightboxLabels;
+    onClose: () => void;
+}): import("react").ReactPortal;

package/lib/types/client/view/chrome/MessageActions.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import type { FocusTranslate } from '../../contract/props.ts';
+export declare const MessageActions: import("react").MemoExoticComponent<({ text, time, runMs, ttftMs, tokensPerSecond, clock, onBranch, branchUnavailable, extraActions, t }: {
+    /** Plain text the copy action writes. */
+    text: string;
+    /** Unix epoch ms for the clock label; null hides the clock. */
+    time: number | null;
+    /** Turn wall time, appended as `· 用时 15s`; null omits the reading. */
+    runMs: number | null;
+    /** Turn first-step TTFT in ms; null omits the reading. */
+    ttftMs: number | null;
+    /** Turn decode throughput; null omits the reading. */
+    tokensPerSecond: number | null;
+    /** Clock before the icons (user) or after (assistant tail). */
+    clock: "start" | "end";
+    /** Fork the session at this message; omission hides the branch action. */
+    onBranch?: (() => void) | undefined;
+    /** The message is not the completed turn's last row, so branch stays visible but unavailable. */
+    branchUnavailable?: boolean | undefined;
+    /** Slot-rendered actions owned by independent plugins (the chat's
+     *  assistant-actions strip), placed between copy and branch. */
+    extraActions?: ReactNode | undefined;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/chrome/MessageFeedbackActions.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Per-message feedback controls: a Like/Dislike pair plus an optional note.
+ * The buttons render inside the assistant message's IconActions row, so they
+ * reuse that row's chrome and sit between copy and branch. The note editor is
+ * a popover (portaled to `document.body`) anchored to the note trigger, not an
+ * inline expansion: a 260px textarea plus buttons cannot fit the row at any
+ * viewport, and an inline element pushed the branch action and clock out of the
+ * conversation column. Portaling out of the column also escapes its `overflow`
+ * clip, so the panel cannot be cropped or detached from the message it annotates.
+ * @module @deepseek-ai/dsh-client-ui-message-feedback/client/MessageFeedbackActions
+ */
+import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
+import type { MessageId } from '@deepseek-ai/dsh-client-connection/client';
+import type { MessageFeedbackRating } from '@deepseek-ai/dsh-message-feedback/types';
+import type { MessageFeedbackActionResult, MessageFeedbackView } from '../../model/feedback-controller.ts';
+import type { FocusTranslate } from '../../contract/props.ts';
+/** The shared feedback verbs and view hook the focus view injects (the chat
+ *  assistant-actions strip's business face, re-declared here because the view
+ *  cannot take that slot seat). */
+export interface FocusFeedbackActions {
+    /** The owning Session's feedback view, shared by every message control. */
+    useFeedback: SnapshotSelectorHook<MessageFeedbackView>;
+    /** Load the Session's feedback once, on first interaction. */
+    ensure: () => Promise<MessageFeedbackActionResult>;
+    /** Create or replace this Session's feedback for one message. */
+    rate: (messageId: MessageId, rating: MessageFeedbackRating, note?: string) => Promise<MessageFeedbackActionResult>;
+    /** Toggle or retract one message's rating. */
+    toggle: (messageId: MessageId, rating: MessageFeedbackRating) => Promise<MessageFeedbackActionResult>;
+    /** Drop the note while keeping the rating. */
+    clearNote: (messageId: MessageId) => Promise<MessageFeedbackActionResult>;
+}
+/** Full props of one assistant-message feedback entry. */
+export type FocusMessageFeedbackProps = FocusFeedbackActions & {
+    /** Target assistant-message identity. */
+    messageId: MessageId;
+    /** The owning view's locale seat. */
+    t: FocusTranslate;
+};
+/**
+ * One message's feedback controls.
+ * @param props - the owner's message identity, the injected verbs, and the
+ * shared feedback hook.
+ * @returns the rating buttons and the note trigger, with the note editor
+ * portal-open beneath the trigger while it is open.
+ */
+export declare function MessageFeedbackActions({ messageId, ensure, rate, toggle, clearNote, useFeedback, t }: FocusMessageFeedbackProps): import("react").JSX.Element;

package/lib/types/client/view/chrome/MessageImage.d.ts

@@ -0,0 +1,46 @@
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import { type ImageLightboxLabels } from './ImageLightbox.tsx';
+/** Loads a session-authorized durable image URL. */
+export type ImageLoader = (attachment: ImageAttachmentRef) => Promise<string>;
+/** Message-image strings the owner resolves from its own locale namespace. */
+export interface MessageImageLabels {
+    /** Fallback display name for an unnamed image. */
+    image: string;
+    /** Thumbnail tooltip inviting the original-image preview. */
+    open: string;
+    /** Accessible thumbnail label; receives the image's display name. */
+    openNamed: (label: string) => string;
+    /** Loading placeholder shown until bytes resolve. */
+    loading: string;
+    /** Retry-control label shown when the load fails. */
+    loadFailed: string;
+    /** Lightbox strings forwarded to the opened preview. */
+    lightbox: ImageLightboxLabels;
+}
+/**
+ * Compact history renderer with retryable loading and click-to-open original
+ * preview. A lone image renders at its `singleFit` size; an image among
+ * several renders as a fixed 64px square tile.
+ *
+ * @param props.attachment - the durable image reference to load and bound.
+ * @param props.load - session-authorized URL loader.
+ * @param props.variant - `single` for a message's lone image, `tile` otherwise.
+ * @param props.labels - resolved strings (tooltip, loading, retry, lightbox).
+ * @returns the bounded thumbnail button, or the retry control on failure.
+ */
+export declare function MessageImage({ attachment, load, variant, labels }: {
+    attachment: ImageAttachmentRef;
+    load: ImageLoader;
+    variant: 'single' | 'tile';
+    labels: MessageImageLabels;
+}): import("react").JSX.Element;
+/** Wrapping image group shared by user and assistant history: a lone image
+ * renders large, several render as 64px square tiles (DeepSeek Chat rule). */
+export declare function ImageGallery({ images, load, align, labels }: {
+    images: readonly {
+        attachment: ImageAttachmentRef;
+    }[];
+    load: ImageLoader;
+    align: 'start' | 'end';
+    labels: MessageImageLabels;
+}): import("react").JSX.Element | null;

package/lib/types/client/view/chrome/NavRail.d.ts

@@ -0,0 +1,21 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+/** One scroll-nav entry: a user / steering message's focus anchor. */
+export interface FocusNavEntry {
+    key: string;
+    /** First text line of the message (the rail's collapsed label). */
+    label: string;
+}
+/**
+ * The in-view scroll navigation rail (the DeepSeek chat's page nav): a
+ * right-edge strip of entry dashes, position:fixed at the scrollport's
+ * right-middle (pure CSS, no measuring), that expands on hover to list
+ * every user / steering message. Clicking an entry jumps the focus
+ * scrollport to that row; the active entry follows the reader (scroll-spy).
+ */
+export declare const NavRail: import("react").MemoExoticComponent<({ entries, activeKey, onSelect, t }: {
+    entries: readonly FocusNavEntry[];
+    /** The scroll-spy active entry key, or null before the first spy pass. */
+    activeKey: string | null;
+    onSelect: (key: string) => void;
+    t: FocusTranslate;
+}) => import("react").JSX.Element | null>;

package/lib/types/client/view/chrome/ReferenceIcon.d.ts

@@ -0,0 +1,17 @@
+/** The reference-domain glyphs of the official chat (session/file/folder),
+ *  reimplemented here because the npm package does not re-export them. */
+import type { ReactNode } from 'react';
+/** Reference domains with distinct composer and transcript glyphs. */
+export type ReferenceIconKind = 'session' | 'file' | 'folder';
+/** Props shared by inline reference glyphs. */
+export interface ReferenceIconProps {
+    kind: ReferenceIconKind;
+    size?: number;
+    className?: string | undefined;
+}
+/**
+ * Render the icon that identifies one inline reference domain.
+ * @param props - Reference kind, optional size, and optional CSS class.
+ * @returns The corresponding current-color SVG glyph.
+ */
+export declare function ReferenceIcon({ kind, size, className }: ReferenceIconProps): ReactNode;

package/lib/types/client/view/chrome/RunningStatus.d.ts

@@ -0,0 +1,7 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+export declare function RunningStatus({ startTime, t }: {
+    /** The running turn's logged turn/start time; null falls back to mount time. */
+    startTime: number | null;
+    t: FocusTranslate;
+}): import("react").JSX.Element;
+/** Reader-scroll following threshold (the chat view's value). */

package/lib/types/client/view/chrome/TurnNavigator.d.ts

@@ -0,0 +1,14 @@
+import type { TurnNavigationItem } from '@deepseek-ai/dsh-client-ui-chat/client';
+import type { FocusTranslate } from '../../contract/props.ts';
+interface TurnNavigatorProps {
+    readonly items: readonly TurnNavigationItem[];
+    readonly activeTurn: number | null;
+    readonly onNavigate: (item: TurnNavigationItem) => void;
+    readonly t: FocusTranslate;
+}
+/** Compact rail of the loaded Turns with hover and focus previews — the
+ *  official turn navigator's chrome, reimplemented for the focus view.
+ *  Memoized: its props stay referentially stable across streaming commits,
+ *  so a long session never rebuilds the marks per frame. */
+export declare const TurnNavigator: import("react").MemoExoticComponent<({ items, activeTurn, onNavigate, t }: TurnNavigatorProps) => import("react").JSX.Element | null>;
+export {};

package/lib/types/client/view/helpers/format.d.ts

@@ -0,0 +1,30 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+export declare function firstLine(text: string): string;
+/** The trailing `count` lines of a streaming text (the running tail preview). */
+export declare function latestLines(text: string, count: number): string;
+/** Zero-padded two-digit number (the chat clock's rhythm). */
+export declare function pad2(n: number): string;
+/** The original-image lightbox strings (the chat image-labels bridge). */
+export declare function basename(path: string): string;
+/** Decode-throughput figure: whole tokens from ten up, one decimal below. */
+export declare function formatTokensPerSecond(tps: number): string;
+/** Local calendar-day epoch (ms at local midnight) for an instant. */
+export declare function startOfLocalDay(ms: number): number;
+/** Delay until the next local midnight after `ms` (at least 1ms). */
+export declare function msUntilNextLocalMidnight(ms: number): number;
+/** The current local calendar-day epoch, re-resolved at each midnight. */
+export declare function useCalendarDay(): number;
+/**
+ * Compact local timestamp for message chrome (the chat clock): same local
+ * calendar day → `HH:mm`; earlier this year → the `clock.md` template;
+ * other years → `clock.ymd`.
+ * @param time - Unix epoch ms from the source session event.
+ * @param t - focus locale seat supplying the date templates.
+ * @param now - reference instant for the day/year cut.
+ * @returns the date-aware clock string.
+ */
+export declare function formatMessageClock(time: number, t: FocusTranslate, now?: number): string;
+/** Concatenated text blocks of a message (the chat bubble's join). */
+export declare function useThrottledVisualUpdate(update: () => void, intervalFrames?: number): () => void;
+export declare function formatElapsed(ms: number, t: FocusTranslate): string;
+/** Turn-level running signal: "Deep diving..." plus an elapsed clock past 15s. */

package/lib/types/client/view/helpers/icons.d.ts

@@ -0,0 +1,9 @@
+/** Tool-family leading icons (the chat GenericToolCard table). */
+import type { ReactNode } from 'react';
+import type { FocusToolRow } from '../../model/types.ts';
+/** Tool-family leading icons, mirroring the chat GenericToolCard table (glyphs at 14). */
+export declare const VARIANT_ICONS: Record<'search' | 'read' | 'bash' | 'write' | 'edit' | 'code' | 'question' | 'todo' | 'skill' | 'others', ReactNode>;
+/** Tool name → leading-icon family (mirrors the chat row classification). */
+export declare const TOOL_VARIANTS: Readonly<Record<string, keyof typeof VARIANT_ICONS>>;
+/** One call's leading glyph: the family icon, or the state dot for failures. */
+export declare function leadingFor(row: FocusToolRow): ReactNode;

package/lib/types/client/view/helpers/image-labels.d.ts

@@ -0,0 +1,13 @@
+/** Message-image label bridge and block extraction (the chat image-labels rule). */
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { MessageImageLabels } from '../chrome/MessageImage.tsx';
+import type { ImageLightboxLabels } from '../chrome/ImageLightbox.tsx';
+export declare function lightboxLabels(t: FocusTranslate): ImageLightboxLabels;
+/** The message-image strings, including the forwarded lightbox strings. */
+export declare function messageImageLabels(t: FocusTranslate): MessageImageLabels;
+/** Image blocks of one user message, in order (the chat gallery's input). */
+export declare function userImages(content: readonly ContentBlock[]): {
+    attachment: ImageAttachmentRef;
+}[];

package/lib/types/client/view/helpers/message.d.ts

@@ -0,0 +1,13 @@
+/** User message text projection (the chat bubble join and reference chips). */
+import type { ReactNode } from 'react';
+export declare function messageText(content: readonly {
+    type?: string;
+    text?: string;
+}[]): string;
+/**
+ * Display projection of reference forms in a user bubble: `/name` / `@name`
+ * word-boundary tokens decorate as chips, everything else stays plain text
+ * (the chat bubble's projection — sent tokens were validated at compose time,
+ * so shape alone decorates).
+ */
+export declare function projectUserText(text: string): ReactNode;

package/lib/types/client/view/helpers/terminal.d.ts

@@ -0,0 +1,20 @@
+/** JsonBlock truncation footer and card-primitive label sets bound to the focus locale. */
+import type { DiffBlockLabels, MarkdownLabels, ReadBlockLabels, SearchBlockLabels, TerminalBlockLabels, WebBlockLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+export declare function jsonTruncated(t: FocusTranslate): (total: number) => string;
+/** Card line caps the chat rows apply (design rhythm). */
+export declare const CHAT_DIFF_MAX_LINES = 8;
+export declare const CHAT_READ_MAX_LINES = 8;
+export declare const CHAT_SEARCH_MAX_LINES = 8;
+/** Markdown chrome for the primitive's document renderer (code fences + footnotes). */
+export declare function markdownLabels(t: FocusTranslate): MarkdownLabels;
+/** Terminal-card labels bound to the focus locale (the chat label seam). */
+export declare function terminalLabels(t: FocusTranslate): TerminalBlockLabels;
+/** Diff-card labels bound to the focus locale. */
+export declare function diffLabels(t: FocusTranslate): DiffBlockLabels;
+/** Read-card labels bound to the focus locale. */
+export declare function readLabels(t: FocusTranslate): ReadBlockLabels;
+/** Search-card labels bound to the focus locale. */
+export declare function searchLabels(t: FocusTranslate): SearchBlockLabels;
+/** Web-card labels bound to the focus locale. */
+export declare function webLabels(t: FocusTranslate): WebBlockLabels;

package/lib/types/client/view/rows/CommandRow.d.ts

@@ -0,0 +1,12 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+/** One command row (the chat GenericCommandCard chrome: name · settlement, expandable multiline body). */
+export declare const CommandRow: import("react").MemoExoticComponent<({ item, runningSummary, t }: {
+    item: Extract<FocusFlowItem, {
+        kind: "command";
+    }>;
+    /** Command-specific running copy; absent uses the generic running label. */
+    runningSummary?: string | undefined;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;
+/** One landed-compaction marker (the chat CompactionItem chrome). */

package/lib/types/client/view/rows/CompactionRow.d.ts

@@ -0,0 +1,24 @@
+import type { MarkdownLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+/** One landed-compaction marker (the chat CompactionItem chrome). */
+export declare const CompactionRow: import("react").MemoExoticComponent<({ item, title, fallbackSummary, t, mdLabels }: {
+    item: Extract<FocusFlowItem, {
+        kind: "compaction";
+    }>;
+    /** Optional command title for a manual compaction folded into this marker. */
+    title?: string | undefined;
+    /** Command settlement text used when structured compaction counts are unavailable. */
+    fallbackSummary?: string | null | undefined;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+}) => import("react").JSX.Element>;
+/** One manual `/compact` lifecycle: the command card, or the checkpoint marker. */
+export declare const ManualCompactionRow: import("react").MemoExoticComponent<({ item, t, mdLabels }: {
+    item: Extract<FocusFlowItem, {
+        kind: "manual-compaction";
+    }>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+}) => import("react").JSX.Element>;
+/** One model-retry row (the chat ModelRetryItem chrome: countdown + details). */