@lingxi-ai-cn/dsh-tui-runtime 0.1.0-rc.8

package/lib/types/theme.d.ts

@@ -0,0 +1,76 @@
+/** Semantic terminal colors and user settings for the native TUI. */
+import React, { type ReactNode } from 'react';
+import { z } from './host.ts';
+import { type TuiKeybindingOverrides } from './keybindings.ts';
+import type { TuiTerminalColorDepth } from './terminal-session.ts';
+/** Persisted built-in terminal theme names. */
+export declare const TUI_THEME_PREFERENCES: readonly ["dark", "light", "no-color"];
+/** One persisted built-in terminal theme name. */
+export type TuiThemePreference = typeof TUI_THEME_PREFERENCES[number];
+/** Settings namespace owned by the native TUI. */
+export declare const TUI_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+/** User settings consumed live by the native TUI. */
+export interface TuiSettings {
+    /** Built-in semantic terminal theme. */
+    theme: TuiThemePreference;
+    /** Per-action replacements for built-in key gestures. */
+    keybindings: TuiKeybindingOverrides;
+}
+/** Defaults used without a settings provider and below its user layer. */
+export declare const DEFAULT_TUI_SETTINGS: TuiSettings;
+/** Persisted native-TUI settings schema, including effective-binding validation. */
+export declare const TUI_SETTINGS_SCHEMA: z<TuiSettings>;
+/** Colors available to every native-TUI renderer. */
+export interface TuiSemanticThemeTokens {
+    readonly text: string | undefined;
+    readonly muted: string | undefined;
+    readonly accent: string | undefined;
+    readonly success: string | undefined;
+    readonly warning: string | undefined;
+    readonly error: string | undefined;
+    readonly permission: string | undefined;
+    readonly reasoning: string | undefined;
+    readonly selection: string | undefined;
+    readonly border: string | undefined;
+    readonly diffAdd: string | undefined;
+    readonly diffDelete: string | undefined;
+}
+/** Resolved theme for one negotiated terminal color depth. */
+export interface TuiTheme {
+    readonly preference: TuiThemePreference;
+    readonly colorDepth: TuiTerminalColorDepth;
+    readonly tokens: TuiSemanticThemeTokens;
+    /** Whether secondary text may use ANSI dim styling. */
+    readonly dim: boolean;
+}
+/**
+ * Omit Ink's optional text color property when a no-color theme resolves it away.
+ * @param color - one resolved semantic token.
+ * @returns an exact-optional Ink text style.
+ */
+export declare function tuiTextStyle(color: string | undefined): Readonly<{
+    color?: string;
+}>;
+/**
+ * Omit Ink's optional border color property when a no-color theme resolves it away.
+ * @param color - one resolved semantic token.
+ * @returns an exact-optional Ink box style.
+ */
+export declare function tuiBorderStyle(color: string | undefined): Readonly<{
+    borderColor?: string;
+}>;
+/**
+ * Resolve semantic colors for one persisted preference and terminal precision.
+ * @param preference - selected built-in theme.
+ * @param colorDepth - color precision negotiated for the active output stream.
+ * @returns immutable tokens that never emit colors when either input requires no color.
+ */
+export declare function resolveTuiTheme(preference: TuiThemePreference, colorDepth: TuiTerminalColorDepth): TuiTheme;
+/** Provide one resolved theme without changing descendant component identity. */
+export declare function TuiThemeProvider({ theme, children }: {
+    readonly theme: TuiTheme;
+    readonly children?: ReactNode;
+}): React.ReactElement;
+/** Read the semantic theme selected for the active terminal transaction. */
+export declare function useTuiTheme(): TuiTheme;
+//# sourceMappingURL=theme.d.ts.map

package/lib/types/todo-panel.d.ts

@@ -0,0 +1,12 @@
+/** Compact durable todo checklist for the native TUI transcript. */
+import React from 'react';
+import { type TranscriptTodoNode } from './transcript.ts';
+/** Physical rows occupied by the pinned Tasks surface. */
+export declare function todoPanelRows(node: TranscriptTodoNode | undefined): number;
+/** Render the standing todo snapshot beside the composer. */
+export declare function TodoPanel({ node, focused, emphasized, }: {
+    node: TranscriptTodoNode;
+    focused?: boolean;
+    emphasized?: ReadonlySet<string>;
+}): React.ReactElement | null;
+//# sourceMappingURL=todo-panel.d.ts.map

package/lib/types/tool-card.d.ts

@@ -0,0 +1,24 @@
+/** Ink renderers for provider-neutral tool presentation intents. */
+import React from 'react';
+import type { TranscriptToolNode } from './transcript.ts';
+/** Stable terminal symbol for one tool scheduler state. */
+export declare function toolDisplayState(node: TranscriptToolNode): TranscriptToolNode['state'];
+/** Stable terminal symbol for one tool scheduler state. */
+export declare function toolStateMark(node: TranscriptToolNode): string;
+/**
+ * Derive the compact, single-line summary shown on a collapsed tool card.
+ * @param node - paired semantic tool node.
+ * @returns terminal-safe summary text.
+ */
+export declare function toolSummary(node: TranscriptToolNode, workspace?: string): string;
+/** Return a terminal-safe logical detail listing for one tool lifecycle. */
+export declare function toolDetailLines(node: TranscriptToolNode): readonly string[];
+/** Render one paired tool lifecycle as a compact or detailed terminal card. */
+export declare function ToolCard({ node, expanded, detailOffset, detailRows, workspace }: {
+    node: TranscriptToolNode;
+    expanded: boolean;
+    detailOffset?: number;
+    detailRows?: number;
+    workspace?: string | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=tool-card.d.ts.map

package/lib/types/tool-group.d.ts

@@ -0,0 +1,10 @@
+/** Hierarchical rendering for consecutive read and search tool activity. */
+import React from 'react';
+import { type TranscriptToolGroupNode } from './transcript.ts';
+/** Render related exploration calls under one tree-like activity heading. */
+export declare function ToolGroup({ node, focusedCallId, workspace }: {
+    node: TranscriptToolGroupNode;
+    focusedCallId?: string;
+    workspace?: string | undefined;
+}): React.ReactElement;
+//# sourceMappingURL=tool-group.d.ts.map

package/lib/types/transcript-search.d.ts

@@ -0,0 +1,67 @@
+/** Cached full-transcript search over the TUI's semantic node projection. */
+import type { TranscriptNode } from './transcript.ts';
+/** One searchable semantic transcript block. */
+export interface TuiTranscriptSearchDocument {
+    /** Stable transcript-node identity. */
+    readonly key: string;
+    /** Current index in the complete folded transcript. */
+    readonly nodeIndex: number;
+    /** Terminal-safe, whitespace-normalized text used for snippets. */
+    readonly text: string;
+    /** Unicode-normalized lowercase text used for matching. */
+    readonly normalizedText: string;
+}
+/** One matching transcript block. */
+export interface TuiTranscriptSearchHit extends TuiTranscriptSearchDocument {
+    /** Start of the first match in `normalizedText`. */
+    readonly matchStart: number;
+    /** End of the first match in `normalizedText`. */
+    readonly matchEnd: number;
+}
+/** One highlighted or ordinary substring for the search-result renderer. */
+export interface TuiTranscriptSearchSegment {
+    /** Source text for this segment. */
+    readonly text: string;
+    /** Whether this segment is the first query match. */
+    readonly match: boolean;
+}
+/**
+ * Retain lowercase search documents by stable node identity. Updating the
+ * complete projection only re-normalizes blocks whose searchable text changed.
+ */
+export declare class TuiTranscriptSearchIndex {
+    private readonly cache;
+    private documents;
+    /**
+     * Reconcile the index with one complete folded transcript.
+     * @param nodes - every semantic transcript node, including unmounted pages.
+     */
+    update(nodes: readonly TranscriptNode[]): void;
+    /**
+     * Find every matching semantic block in transcript order.
+     * @param query - incremental caller query.
+     * @returns one hit per matching block; an empty query has no hits.
+     */
+    search(query: string): readonly TuiTranscriptSearchHit[];
+}
+/**
+ * Normalize terminal search text for case-insensitive incremental matching.
+ * @param value - query or projected block text.
+ * @returns terminal-safe NFKC lowercase text with collapsed whitespace.
+ */
+export declare function normalizeTuiTranscriptSearchText(value: string): string;
+/**
+ * Split display text around its first normalized query match.
+ * @param text - terminal-safe search document text.
+ * @param query - active search query.
+ * @returns immutable display segments; normalization-only matches highlight the complete text.
+ */
+export declare function tuiTranscriptSearchSegments(text: string, query: string): readonly TuiTranscriptSearchSegment[];
+/**
+ * Preserve the selected block across index refreshes while it still matches.
+ * @param hits - current transcript-ordered matches.
+ * @param selectedKey - previously selected stable node key.
+ * @returns the retained hit, the first hit, or `undefined` when no block matches.
+ */
+export declare function resolveTuiTranscriptSearchHit(hits: readonly TuiTranscriptSearchHit[], selectedKey: string | undefined): TuiTranscriptSearchHit | undefined;
+//# sourceMappingURL=transcript-search.d.ts.map

package/lib/types/transcript-view.d.ts

@@ -0,0 +1,32 @@
+/** Ink rendering for one bounded semantic transcript frame. */
+import React from 'react';
+import type { TranscriptNode } from './transcript.ts';
+import type { TranscriptWindowEntry } from './viewport.ts';
+interface TuiTranscriptViewProps {
+    entries: readonly TranscriptWindowEntry[];
+    overscanBefore?: readonly TranscriptWindowEntry[] | undefined;
+    overscanAfter?: readonly TranscriptWindowEntry[] | undefined;
+    workspace?: string | undefined;
+    focusedNode?: TranscriptNode | undefined;
+    focusedCallId?: string | undefined;
+    rewindSelectedKey?: string | undefined;
+    searchSelectedKey?: string | undefined;
+    searchQuery?: string | undefined;
+}
+/**
+ * Highlight the first normalized transcript-search match inside display text.
+ * @param props - visible text and active query.
+ * @returns segmented Ink text with the matching segment emphasized.
+ */
+export declare function TuiTranscriptSearchText({ text, query }: {
+    text: string;
+    query: string;
+}): React.ReactElement;
+/**
+ * Render the exact transcript blocks selected for one physical terminal frame.
+ * @param props - bounded entries plus process-local focus and search state.
+ * @returns one fragment containing the mounted transcript rows.
+ */
+export declare function TuiTranscriptView({ entries, overscanBefore, overscanAfter, workspace, focusedNode, focusedCallId, rewindSelectedKey, searchSelectedKey, searchQuery, }: TuiTranscriptViewProps): React.ReactElement;
+export {};
+//# sourceMappingURL=transcript-view.d.ts.map

package/lib/types/transcript.d.ts

@@ -0,0 +1,159 @@
+/** Pure Session-event to semantic terminal-node projection. */
+import { type SessionEvent, type TodoItem, type ToolCallView, type ToolDefinition, type ToolResultView } from './host.ts';
+/** Maximum child rows mounted inside one compact structured transcript block. */
+export declare const STRUCTURED_CHILD_LIMIT = 6;
+/** Terminal color/semantic class for one projected text node. */
+type TranscriptTone = 'user' | 'assistant' | 'reasoning' | 'status' | 'error';
+/** Immutable terminal projection of one durable non-tool conversation fact. */
+export interface TranscriptTextNode {
+    /** Node discriminant. */
+    kind: 'text';
+    /** Stable React identity derived from Session coordinates. */
+    key: string;
+    /** Semantic presentation class. */
+    tone: TranscriptTone;
+    /** Short row heading. */
+    label: string;
+    /** Terminal-safe display body. */
+    text: string;
+    /** Elapsed reasoning stream time for a completed Thinking block. */
+    durationMs?: number | undefined;
+    /** Internal first reasoning event timestamp used while folding a stream. */
+    reasoningStartedAt?: number | undefined;
+}
+/** One paired tool call and result, with tool-owned render intents when available. */
+export interface TranscriptToolNode {
+    /** Node discriminant. */
+    kind: 'tool';
+    /** Stable React identity derived from the call id. */
+    key: string;
+    /** Durable call identity. */
+    callId: string;
+    /** Registered tool name, or `unknown` for an unpaired result. */
+    name: string;
+    /** Parsed call arguments when valid JSON, otherwise the original string. */
+    args: unknown;
+    /** Raw model-produced argument string. */
+    rawArguments: string;
+    /** Current durable lifecycle state. */
+    state: 'queued' | 'running' | 'success' | 'error' | 'cancelled';
+    /** Tool-owned pending presentation, with a generic fallback always supplied. */
+    callView: ToolCallView;
+    /** Tool-owned completed presentation, when one was produced. */
+    resultView?: ToolResultView | undefined;
+    /** Terminal-safe model-facing result fallback. */
+    output?: string | undefined;
+    /** Internal failure code when the result event carries one. */
+    errorCode?: string | undefined;
+    /** Durable call and result timestamps used for terminal duration summaries. */
+    startedAt?: number | undefined;
+    endedAt?: number | undefined;
+    /** Service-owned delegation lifecycle attached to this parent tool call. */
+    delegation?: TranscriptDelegation | undefined;
+}
+/** Durable subagent lifecycle attached to one parent tool call. */
+interface TranscriptDelegation {
+    /** Service-owned run identity. */
+    runId: string;
+    /** Published child identity. */
+    childId: string;
+    /** Provider that established the child. */
+    provider: string;
+    /** Model-supplied short task label. */
+    label?: string | undefined;
+    /** Whether the child has an in-process Agent. */
+    local: boolean;
+    /** Start event timestamp. */
+    startedAt: number;
+    /** Terminal event timestamp, when settled. */
+    endedAt?: number | undefined;
+    /** Terminal child reason, when settled. */
+    stopReason?: string | undefined;
+    /** Terminal-safe final assistant outcome. */
+    outcome?: string | undefined;
+}
+/** Latest durable todo snapshot rendered as a checklist block. */
+export interface TranscriptTodoNode {
+    /** Node discriminant. */
+    kind: 'todo';
+    /** Stable identity for the latest snapshot. */
+    key: 'todo:latest';
+    /** Whole-list todo snapshot. */
+    todos: readonly TodoItem[];
+}
+/** Durable compaction lifecycle marker replacing a hidden history range. */
+export interface TranscriptCompactionNode {
+    /** Node discriminant. */
+    kind: 'compaction';
+    /** Stable identity derived from the compaction transaction. */
+    key: string;
+    /** Durable compaction transaction identity. */
+    compactionId: string;
+    /** Human command that initiated the compaction, when present. */
+    sourceCommandId?: string | undefined;
+    /** Current durable lifecycle state. */
+    state: 'running' | 'success' | 'failure';
+    /** Terminal-safe summary text, when summarization committed. */
+    summary?: string | undefined;
+    /** Number of surface items shadowed by the replacement. */
+    shadowedItemCount: number;
+    /** Estimated token count of the shadowed content. */
+    shadowedTokenCount: number;
+    /** Surface boundary represented by the replacement. */
+    shadowedRange?: {
+        start: number;
+        end: number;
+    } | undefined;
+    /** Terminal-safe failure text, when the transaction did not commit. */
+    error?: string | undefined;
+}
+/** One semantic exploration run or authoritative scheduler group. */
+export interface TranscriptToolGroupNode {
+    /** Node discriminant. */
+    kind: 'tool-group';
+    /** Stable identity derived from the first and last calls. */
+    key: string;
+    /** Tool nodes retained in chronological order. */
+    tools: readonly TranscriptToolNode[];
+    /** Group authority and presentation category. */
+    activity: 'explore' | 'parallel' | 'exclusive';
+    /** Whether every authoritative member is known. */
+    closed: boolean;
+}
+/** Semantic terminal transcript node. */
+export type TranscriptNode = TranscriptTextNode | TranscriptToolNode | TranscriptTodoNode | TranscriptToolGroupNode | TranscriptCompactionNode;
+/** Resolve the definition visible to this TUI-owned Agent. */
+export type ToolDefinitionResolver = (name: string) => ToolDefinition | undefined;
+/**
+ * Identify a tool whose provider-owned presentation is read/search activity.
+ * @param node - folded tool lifecycle node.
+ * @returns whether the node belongs to the Explore semantic category.
+ */
+export declare function isExplorationTool(node: TranscriptToolNode): boolean;
+/**
+ * Fold a complete ordered event prefix into stable semantic transcript nodes.
+ * Assistant completion replaces streaming output, and a result updates its
+ * `callId`-paired tool node instead of appending a second log row.
+ * @param events - ordered durable Session-event prefix.
+ * @param resolveTool - optional Agent-scoped tool-definition lookup for render intents.
+ * @returns immutable terminal nodes in display order.
+ */
+export declare function foldTranscript(events: readonly SessionEvent[], resolveTool?: ToolDefinitionResolver): readonly TranscriptNode[];
+/** Append-oriented, Session-local semantic transcript projection. */
+export declare class TuiTranscriptProjectionCache {
+    private state;
+    private resolver;
+    private eventCount;
+    private lastEvent;
+    /** Drop all process-local fold state before a Session lifecycle replacement. */
+    reset(): void;
+    /**
+     * Project an ordered durable event prefix, processing only a verified append suffix when possible.
+     * @param events - complete current Session-event prefix.
+     * @param resolveTool - exact Agent-scoped tool-definition lookup.
+     * @returns immutable semantic nodes in durable display order.
+     */
+    update(events: readonly SessionEvent[], resolveTool?: ToolDefinitionResolver): readonly TranscriptNode[];
+}
+export {};
+//# sourceMappingURL=transcript.d.ts.map

package/lib/types/viewport.d.ts

@@ -0,0 +1,211 @@
+/** Line-aware transcript selection for the fixed-height terminal viewport. */
+import { type TranscriptNode } from './transcript.ts';
+/** One transcript node plus the exact text selected for this terminal frame. */
+export interface TranscriptWindowEntry {
+    /** Durable semantic node. */
+    node: TranscriptNode;
+    /** Terminal projection for text nodes; absent for tool nodes. */
+    text?: string | undefined;
+}
+/** One navigable transcript frame and its position in the complete projection. */
+export interface TranscriptWindow {
+    /** Entries mounted in this frame. */
+    entries: readonly TranscriptWindowEntry[];
+    /** First mounted node index, or `-1` for an empty transcript. */
+    startIndex: number;
+    /** Last mounted node index, or `-1` for an empty transcript. */
+    endIndex: number;
+    /** Whether complete transcript content exists above this frame. */
+    hasOlder: boolean;
+    /** Whether complete transcript content exists below this frame. */
+    hasNewer: boolean;
+}
+/** Stable process-local position for a historical transcript viewport. */
+export interface TuiTranscriptViewportAnchor {
+    /** Semantic node key at the top of the viewport. */
+    key: string;
+    /** Previous semantic index used only when replacement removes the key. */
+    index: number;
+}
+/** A visible transcript frame plus bounded blocks mounted as render overscan. */
+export interface TuiTranscriptVirtualWindow extends TranscriptWindow {
+    /** Nearby blocks mounted before the visible frame without consuming rows. */
+    overscanBefore: readonly TranscriptWindowEntry[];
+    /** Nearby blocks mounted after the visible frame without consuming rows. */
+    overscanAfter: readonly TranscriptWindowEntry[];
+    /** First mounted semantic index including overscan, or `-1` when empty. */
+    mountedStartIndex: number;
+    /** Last mounted semantic index including overscan, or `-1` when empty. */
+    mountedEndIndex: number;
+}
+/** Diagnostic counters for one viewport index and terminal width. */
+export interface TuiTranscriptViewportStats {
+    /** Nodes with exact physical heights measured at the current width. */
+    measuredBlocks: number;
+    /** Nodes still represented by conservative height estimates. */
+    estimatedBlocks: number;
+    /** Current prefix-index row total, including estimates. */
+    indexedRows: number;
+}
+/**
+ * Wrap terminal text by grapheme display cells without splitting a grapheme cluster.
+ * @param text - logical terminal text to wrap.
+ * @param width - available terminal cells per physical row.
+ * @returns wrapped physical display rows.
+ */
+export declare function terminalWrappedLines(text: string, width: number): string[];
+/**
+ * Select the newest complete transcript blocks that fit the available terminal rows.
+ * A final oversized text block retains its label and a marked tail instead of letting
+ * Ink flex-shrink unrelated tool cards into border fragments.
+ * @param nodes - complete semantic transcript.
+ * @param maxRows - physical terminal rows available to the transcript region.
+ * @param columns - physical columns available inside the transcript padding.
+ * @returns display entries in chronological order.
+ */
+export declare function selectTranscriptWindow(nodes: readonly TranscriptNode[], maxRows: number, columns: number): readonly TranscriptWindowEntry[];
+/**
+ * Select a transcript page from a stable semantic top anchor, or the live tail when absent.
+ * @param nodes - complete semantic transcript.
+ * @param maxRows - physical rows available to the transcript region.
+ * @param columns - physical columns available inside transcript padding.
+ * @param startKey - historical page's first node key; absent follows the live tail.
+ * @param startIndexHint - previous index used only when node replacement removes `startKey`.
+ * @returns mounted entries and navigation boundaries.
+ */
+export declare function selectTranscriptPage(nodes: readonly TranscriptNode[], maxRows: number, columns: number, startKey?: string, startIndexHint?: number): TranscriptWindow;
+/**
+ * Resolve the preceding page's stable top anchor without skipping a complete node.
+ * @param nodes - complete semantic transcript.
+ * @param currentStart - first node index in the current frame.
+ * @param maxRows - physical rows available to one frame.
+ * @param columns - physical columns available inside transcript padding.
+ * @returns preceding frame's first node key, or the oldest key.
+ */
+export declare function previousTranscriptPageAnchor(nodes: readonly TranscriptNode[], currentStart: number, maxRows: number, columns: number): string | undefined;
+/**
+ * Agent-local physical-row index with node-identity and width-aware measurement caches.
+ * Unmounted blocks retain conservative estimates until a viewport operation measures them.
+ */
+export declare class TuiTranscriptViewportIndex {
+    private readonly overscanBlocks;
+    private readonly measurementCache;
+    private nodes;
+    private width;
+    private heights;
+    private exact;
+    private rows;
+    private keyIndices;
+    private nodeIndices;
+    constructor(overscanBlocks?: number);
+    /**
+     * Reconcile the complete semantic projection and current terminal width.
+     * @param nodes - complete immutable semantic projection.
+     * @param columns - available terminal cells inside transcript padding.
+     */
+    update(nodes: readonly TranscriptNode[], columns: number): void;
+    /**
+     * Select one visible frame and its bounded render overscan.
+     * @param maxRows - physical-row budget for visible transcript content.
+     * @param anchor - historical semantic top anchor; absent follows the live tail.
+     * @returns visible entries, boundaries, and nearby mounted blocks.
+     */
+    page(maxRows: number, anchor?: TuiTranscriptViewportAnchor): TuiTranscriptVirtualWindow;
+    /**
+     * Resolve a stable key, falling back to the nearest surviving semantic index.
+     * @param key - preferred semantic node key.
+     * @param indexHint - previous index used when replacement removes the key.
+     * @returns replacement-safe anchor, or undefined for an empty projection.
+     */
+    anchor(key: string, indexHint: number): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Resolve the previous complete physical-row page.
+     * @param currentStart - first semantic index in the current frame.
+     * @param maxRows - physical-row budget for the preceding frame.
+     * @returns preceding semantic anchor, or undefined for an empty projection.
+     */
+    previousAnchor(currentStart: number, maxRows: number): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Read the exact-or-estimated physical-row prefix for a semantic block.
+     * @param index - semantic block index.
+     * @returns indexed rows before that block.
+     */
+    physicalRowAt(index: number): number;
+    /**
+     * Locate the semantic block covering one indexed physical row.
+     * @param row - zero-based exact-or-estimated physical row.
+     * @returns semantic block index, or `-1` for an empty projection.
+     */
+    indexAtPhysicalRow(row: number): number;
+    /**
+     * Perform an O(1) semantic-key lookup for navigation and replacement recovery.
+     * @param key - semantic node key.
+     * @returns semantic index, or `-1` when absent.
+     */
+    indexOfKey(key: string): number;
+    /**
+     * Perform an O(1) immutable-node lookup for focus navigation.
+     * @param node - exact node reference from the current projection.
+     * @returns semantic index, or `-1` when absent.
+     */
+    indexOfNode(node: TranscriptNode): number;
+    /**
+     * Read current measurement coverage for benchmark and regression evidence.
+     * @returns exact/estimated block counts and the indexed physical-row total.
+     */
+    stats(): TuiTranscriptViewportStats;
+    private resolveIndex;
+    private anchorAt;
+    private measure;
+    private measuredEntry;
+    private overscanEntry;
+    private selectFromStart;
+    private selectTail;
+    private virtualize;
+}
+/** One navigation authority for tail, paging, focus, search, mouse, and boundary jumps. */
+export declare class TuiTranscriptScrollController {
+    private readonly viewport;
+    constructor(viewport: TuiTranscriptViewportIndex);
+    /**
+     * Follow the live transcript tail.
+     * @returns the absent-anchor representation of tail-follow mode.
+     */
+    latest(): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Anchor the oldest surviving semantic block.
+     * @returns oldest anchor, or undefined for an empty projection.
+     */
+    oldest(): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Anchor one key with replacement-safe fallback.
+     * @param key - preferred semantic node key.
+     * @param indexHint - previous index used when replacement removes the key.
+     * @returns resolved anchor, or undefined for an empty projection.
+     */
+    reveal(key: string, indexHint: number): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Move backward by one physical-row page.
+     * @param page - current visible frame.
+     * @param maxRows - physical-row budget for one frame.
+     * @returns preceding anchor, or undefined for an empty projection.
+     */
+    previous(page: TranscriptWindow, maxRows: number): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Move forward by one physical-row page, returning to tail-follow on the final page.
+     * @param page - current visible frame.
+     * @param maxRows - physical-row budget for one frame.
+     * @returns next historical anchor, or undefined for tail-follow mode.
+     */
+    next(page: TranscriptWindow, maxRows: number): TuiTranscriptViewportAnchor | undefined;
+    /**
+     * Preserve the current anchor when a target is visible, otherwise reveal it.
+     * @param current - current historical anchor, or undefined for tail-follow.
+     * @param page - current visible frame.
+     * @param key - target semantic key.
+     * @param indexHint - target index from the current projection.
+     * @returns unchanged current state or a replacement-safe target anchor.
+     */
+    ensureVisible(current: TuiTranscriptViewportAnchor | undefined, page: TranscriptWindow, key: string, indexHint: number): TuiTranscriptViewportAnchor | undefined;
+}
+//# sourceMappingURL=viewport.d.ts.map

package/lib/types/work-panel.d.ts

@@ -0,0 +1,28 @@
+/** Bounded native-TUI background-work panel. */
+import React from 'react';
+import type { TuiWorkItemView, TuiWorkSnapshot } from './work.ts';
+/**
+ * Format one work duration from authoritative timestamps or durable subagent timing.
+ * @param item - projected work row.
+ * @param now - current local clock used only for a still-live interval.
+ * @returns compact elapsed duration, or `--` when the source exposes none.
+ */
+export declare function formatTuiWorkElapsed(item: TuiWorkItemView, now: number): string;
+/**
+ * Format the owning Agent fact carried by one work row.
+ * @param item - projected work row.
+ * @returns the owner Session id, or an explicit absence marker.
+ */
+export declare function formatTuiWorkOwner(item: TuiWorkItemView): string;
+/**
+ * Render the selectable slice of one work snapshot.
+ * @param props - snapshot, selection, dimensions, and current clock.
+ * @returns one stable-height panel.
+ */
+export declare function TuiWorkPanel(props: {
+    readonly snapshot: TuiWorkSnapshot;
+    readonly selectedIndex: number;
+    readonly maxRows: number;
+    readonly now: number;
+}): React.ReactElement;
+//# sourceMappingURL=work-panel.d.ts.map