@toddzheng024/dscode-bundle 0.1.0

package/vendor/tui/types/render/text.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Display-boundary sanitization for externally sourced text (model output,
+ * tool payloads, skill descriptions). Control characters — including ANSI
+ * CSI/OSC escape sequences — would otherwise pass through Ink into the
+ * terminal, letting output rewrite the screen or inject prompts. Newlines
+ * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+ * escape, and bidi overrides / invisible format controls / Unicode line and
+ * paragraph separators become a visible `\uXXXX` escape (terminal emulators
+ * that render bidirectional text would otherwise reorder the displayed
+ * glyphs and let a command read as something it is not).
+ *
+ * @module @deepseek-ai/dsh-code/render/text
+ */
+/**
+ * Escape control and deceptive characters so externally sourced text cannot
+ * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+ * invisible-format, and separator controls render as a literal `\uXXXX`
+ * escape. Newlines and tabs survive (budgeted callers normalize tabs).
+ * @param text - raw text from a session event, tool payload, or catalog.
+ * @returns display-safe text with every injectable character made visible.
+ */
+export declare function displayText(text: string): string;
+/** Collapse external text to one terminal-safe logical row. */
+export declare function singleLineText(text: string): string;
+/**
+ * Truncate one display-safe row without ever exceeding its physical-column
+ * budget. The ellipsis is included inside the budget, matching Codex's popup
+ * truncation contract; the cut walks grapheme clusters so emoji and
+ * combining sequences never split mid-cluster.
+ */
+export declare function truncateColumns(text: string, columns: number): string;
+/** A display-safe suffix bounded by terminal rows and columns. */
+export interface DisplayTail {
+    /** Sanitized suffix suitable for direct terminal rendering. */
+    text: string;
+    /** Whether content before the returned suffix was omitted. */
+    truncated: boolean;
+}
+/**
+ * Keep the newest display-safe text that fits a terminal rectangle, wrapping
+ * FORWARD from the start of the text and slicing the tail rows.
+ *
+ * Forward wrapping is what keeps a streaming tail calm: rows already produced
+ * never re-wrap as tokens append (a backward scan recomputes every wrap point
+ * per chunk and the whole visible block jumps), and the wrap rules match the
+ * settled text's renderer so the flush at turn end does not reflow the block
+ * a second time. CJK kinsoku applies at both edges: closing punctuation
+ * overhangs up to two cells onto the filled row instead of starting the next
+ * one (within the caret column the caller reserves), and opening punctuation
+ * moves down instead of dangling at a row end. Tabs expand to two spaces so
+ * terminal tab stops cannot inflate the physical row count; clusters carry
+ * emoji presentation and combining marks whole.
+ * @param text - raw externally sourced text.
+ * @param columns - available terminal columns.
+ * @param rows - available terminal rows.
+ * @returns a sanitized bounded suffix and whether an earlier prefix was cut.
+ */
+export declare function displayTail(text: string, columns: number, rows: number): DisplayTail;

package/vendor/tui/types/render/tool-detail.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Expansion payloads for tool cards (the Ctrl+O verbose transcript): the
+ * TUI-side consumption of the harness presentation contract. Mutation and
+ * read tools persist a structured `tool/result.meta` (`diffs`, read
+ * windows, web sources) exactly so a capable UI can replay richer cards than
+ * the model-facing text; this module narrows that opaque JSON defensively —
+ * mirroring the upstream validators — and pre-formats bounded, render-ready
+ * rows. Malformed or absent metadata always degrades to the bounded raw
+ * result text, never throws during replay.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-detail
+ */
+/** One rendered diff row: removed, added, or shared context. */
+export interface DiffLine {
+    /** '-' removed, '+' added, ' ' context. */
+    mark: '-' | '+' | ' ';
+    /** The line text, truncated to the column budget. */
+    text: string;
+}
+/** One file's bounded inline diff. */
+export interface ToolDiff {
+    /** File path the change belongs to. */
+    path: string;
+    /** Rendered rows in order; '-' block before the '+' block. */
+    lines: readonly DiffLine[];
+    /** True when the line budget cut the hunk. */
+    truncated: boolean;
+}
+/** One numbered line of a read window. */
+export interface ToolReadLine {
+    /** 1-based file line number. */
+    number: number;
+    /** The line text, truncated to the column budget. */
+    text: string;
+}
+/** One web-search source row. */
+export interface ToolWebSource {
+    /** Source URL. */
+    url: string;
+    /** Source title, when the provider returned one. */
+    title: string | undefined;
+    /** Short excerpt, truncated to the column budget. */
+    snippet: string;
+}
+/** The expansion payload a verbose tool card renders; a discriminated union. */
+export type ToolDetail = {
+    kind: 'diff';
+    diffs: readonly ToolDiff[];
+} | {
+    kind: 'read';
+    path: string;
+    offset: number;
+    lines: readonly ToolReadLine[];
+    totalLines: number;
+    truncated: boolean;
+} | {
+    kind: 'web-search';
+    sources: readonly ToolWebSource[];
+    truncated: boolean;
+} | {
+    kind: 'web-fetch';
+    url: string;
+    statusCode: number;
+} | {
+    kind: 'raw';
+    text: string;
+    truncated: boolean;
+};
+/**
+ * Render one change as removed-then-added rows, hunked by common prefix and
+ * suffix. A null before-image (file create) renders as pure additions. The
+ * budget caps emitted rows and reports the cut, so a whole-file overwrite
+ * never floods the transcript. Inputs are hard-capped before line splitting
+ * and the row list is built incrementally up to the budget — a crafted or
+ * replayed giant diff cannot force a full intermediate rows array.
+ * @param oldText - prior content, or null for a create.
+ * @param newText - content after the change.
+ * @param budget - maximum rows to emit.
+ * @returns the bounded rows and whether they were cut.
+ */
+export declare function diffRows(oldText: string | null, newText: string, budget: number): {
+    lines: readonly DiffLine[];
+    truncated: boolean;
+};
+/**
+ * Narrow the opaque `tool/result.meta` into one bounded expansion payload,
+ * mirroring the upstream presenters' degradation ladder: diffs (write/edit),
+ * read windows (read), sources (web_search), fetch summaries (web_fetch), and
+ * the bounded raw result text as the universal fallback.
+ * @param meta - the persisted presentation metadata, when the tool attached one.
+ * @param rawText - the joined text blocks of the result message.
+ * @returns the expansion payload, or undefined when nothing renderable exists.
+ */
+export declare function toolResultDetail(meta: unknown, rawText: string): ToolDetail | undefined;

package/vendor/tui/types/render/tool-preview.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bounded preview line for a tool invocation's raw JSON arguments: the first
+ * human-meaningful string among the well-known keys (command, path, query, …)
+ * with a fallback to the bounded raw JSON. Shared by the tool card in the
+ * transcript and the approval bar's command preview. Arguments longer than
+ * {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+ * and a synchronous `JSON.parse` plus string copies of an unbounded model
+ * payload must not run on the approval or projection paths.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-preview
+ */
+/**
+ * Resolve one bounded preview for raw tool arguments.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @param toolName - the tool the arguments belong to (fallback label).
+ * @returns the preview line; empty when nothing useful resolves.
+ */
+export declare function toolArgumentsPreview(args: string, toolName: string): string;
+/**
+ * Bounded prompt preview for delegation-style tools (`subagent`): the
+ * `prompt` argument rendered as the card's second row, so the transcript
+ * shows what the child agent was asked — not just its description label —
+ * while it runs (Codex's SpawnAgent card preview). Anything else returns ''.
+ * @param toolName - the tool the arguments belong to.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @returns the one-line prompt preview, or '' when none applies.
+ */
+export declare function toolPromptPreview(toolName: string, args: string): string;

package/vendor/tui/types/render/width.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Precise terminal-cell width measurement — the single authority every
+ * budget, wrap, and truncation path shares. The previous heuristic
+ * (`codePoint > 0x2e7f ? 2 : 1)) mis-sized Hangul Jamo (narrow), high
+ * non-CJK code points (wide), and emoji: text-default glyphs like ✳ ⚠ ❤
+ * counted 2 while terminals draw 1, and VS16 sequences counted 1 while
+ * terminals draw 2 — the exact drift class the community dsh-TUI string
+ * engine documents (a spinner glyph drifting one column per frame). This
+ * module adapts that engine's rules without its Ink-fork renderer: an ASCII
+ * fast path, grapheme-cluster iteration via Intl.Segmenter (code-point
+ * fallback), a merged East-Asian-Wide/Fullwidth + Emoji_Presentation range
+ * table, text-default emoji = 1, VS16 = 2, marks/selectors/ZWJ = 0.
+ * @module @deepseek-ai/dsh-code/render/width
+ */
+/** Split text into grapheme clusters (code points when Segmenter is absent). */
+export declare function splitGraphemes(text: string): string[];
+/** Terminal-cell width of one grapheme cluster. */
+export declare function graphemeWidth(cluster: string): number;
+/** Terminal-cell width of one code point (surrogate pairs must stay paired). */
+export declare function codePointWidth(char: string): number;
+/**
+ * Terminal-cell width of a string: an ASCII fast path avoids the segmenter
+ * for the overwhelmingly common case; everything else sums grapheme clusters.
+ * Control characters occupy no cells (display sanitization makes them
+ * visible escapes before they ever reach a budget).
+ * @param text - display-safe or raw text to measure.
+ * @returns the column count the terminal will draw.
+ */
+export declare function stringWidth(text: string): number;

package/vendor/tui/types/session-directory.d.ts

@@ -0,0 +1,173 @@
+/** Lightweight session-directory projection for the /resume picker. */
+import { type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
+export interface SessionRecord {
+    readonly header: SessionHeader;
+    readonly live: boolean;
+    readonly persisted: boolean;
+}
+export interface TitleObservationResult {
+    readonly sessionId: string;
+    readonly status: 'fulfilled' | 'rejected';
+    readonly value?: {
+        readonly title?: {
+            readonly title?: string;
+            readonly text?: string;
+        };
+    };
+}
+export interface SessionLogSnapshot {
+    readonly session: SessionHeader;
+    readonly events: SessionEvent[];
+}
+/** Structural upstream SessionQuery surface used by the TUI. */
+export interface SessionQueryService {
+    listSessions(signal?: AbortSignal): Promise<SessionRecord[]>;
+    readTitleSnapshots(ids: readonly string[], signal?: AbortSignal): Promise<TitleObservationResult[]>;
+    readSession(id: string, signal?: AbortSignal): Promise<SessionLogSnapshot>;
+}
+export type SessionScope = 'roots' | 'all';
+export type CwdScope = 'all' | 'current';
+export type SessionSort = 'newest' | 'oldest';
+export interface SessionDirectoryOptions {
+    readonly sessions: SessionScope;
+    readonly cwd: CwdScope;
+    readonly sort: SessionSort;
+    readonly currentCwd: string;
+    readonly query: string;
+}
+export interface SessionRow {
+    readonly id: string;
+    readonly createdAt: number;
+    /** Last-activity timestamp: artifact mtime when known, else createdAt. */
+    readonly updatedAt: number;
+    readonly cwd: string;
+    readonly workspace: string;
+    readonly parent?: string;
+    readonly subagent: boolean;
+    readonly resumable: boolean;
+    readonly live: boolean;
+    readonly persisted: boolean;
+    readonly preset: string;
+    readonly title?: string;
+}
+/** True only for delegated subagents; ordinary forks also carry lineage. */
+export declare function isSubagentSession(header: SessionHeader): boolean;
+/**
+ * Unique header match by exact id or unique id prefix (root and subagent
+ * headers alike); the caller applies any lineage gate.
+ * @param headers - the persisted headers.
+ * @param wanted - the id or id prefix.
+ * @returns the uniquely matched header.
+ * @throws when nothing matches or the prefix is ambiguous.
+ */
+export declare function matchSessionId(headers: readonly SessionHeader[], wanted: string): SessionHeader;
+/** The newest persisted ROOT session pinned to this cwd, or undefined. */
+export declare function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined;
+/**
+ * Filter/sort header-only records. No session log is loaded here. Sorting is
+ * by LAST ACTIVITY (`updated` — artifact mtime when the caller resolved one,
+ * else createdAt), matching the codex resume picker's default UpdatedAt
+ * ordering: a session you kept talking in outranks one created later but idle.
+ * @param records - the header-only records.
+ * @param options - filter/sort options.
+ * @param updated - per-session last-activity timestamps, when resolved.
+ */
+export declare function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions, updated?: ReadonlyMap<string, number>): SessionRow[];
+/** Merge page-local title observations without disturbing directory order. */
+export declare function mergeSessionTitles(rows: readonly SessionRow[], observations: readonly TitleObservationResult[]): SessionRow[];
+/**
+ * Encode a session id the way the JSONL backend does for its on-disk layout
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used to
+ * validate and derive session directories — a local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export declare function encodeSessionSegment(raw: string): string;
+/**
+ * Encode a project cwd the way the JSONL backend groups sessions on disk
+ * (`projectKey`: separators collapse to one `-`, everything else mirrors
+ * `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export declare function encodeProjectKey(cwd: string): string;
+/**
+ * Derive one session's artifact directory under the JSONL backend root,
+ * mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
+ * layout (0.1.5 `sessionDir`/`projectDir`).
+ * @param root - the JSONL backend's configured session root.
+ * @param cwd - the session's pinned working directory, when the header has one.
+ * @param id - the session id.
+ * @returns the absolute session directory path.
+ */
+export declare function sessionDirectoryFor(root: string, cwd: string | undefined, id: string): string;
+/**
+ * The canonical session-log artifact filenames the JSONL backend may create:
+ * format v0 writes the bare `session.jsonl` name; v1+ write
+ * `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
+ * immutable generations may coexist in one session directory (0.1.5). The
+ * range follows the installed session package's `SESSION_FORMAT_VERSION`, so
+ * a future generation joins the enumeration with the dependency bump.
+ */
+export declare function sessionArtifactNames(): readonly string[];
+/** True for one canonical session-log artifact filename the backend may own. */
+export declare function isSessionArtifactName(name: string): boolean;
+/**
+ * Guard a derived session directory before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the directory's base name must be
+ * exactly `encodeSegment(id)` beneath its project grouping.
+ * @param dir - the derived session artifact directory.
+ * @param id - the session id the directory claims to belong to.
+ * @returns the guarded directory, or undefined when the layout is unexpected.
+ */
+export declare function sessionArtifactDirectory(dir: string, id: string): string | undefined;
+/**
+ * The JSONL backend's configured session root, when the mounted backend
+ * exposes one. The upstream service contract dropped `locate()` in 0.1.5
+ * (artifact paths are backend-private; only refusal diagnostics carry them),
+ * so the TUI derives artifact paths from the backend's public plugin config.
+ * Backends without a JSONL-style config (or a foreign shape) yield undefined
+ * and callers degrade: mtime sorting falls back to createdAt and /delete
+ * refuses, exactly as before.
+ */
+export declare function jsonlSessionRoot(persistence: unknown): string | undefined;
+/**
+ * Collect one session's deletion subtree: the id plus every record whose
+ * parent chain leads to it (codex deletes subagent threads with their root).
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ids to delete, root first.
+ */
+export declare function collectDeletionSubtree(records: readonly SessionRecord[], id: string): string[];
+/** One validated node of a deletion plan. */
+export interface DeletionPlanNode {
+    /** Session id to remove. */
+    readonly id: string;
+    /** Distance from the deletion root (0 for the root itself). */
+    readonly depth: number;
+}
+/** A fully preflighted subtree deletion, or the refusal that produced none. */
+export type SessionDeletionPlan = {
+    readonly ok: true;
+    readonly nodes: readonly DeletionPlanNode[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * Plan one session-subtree deletion with NO filesystem side effects: collect
+ * the doomed lineage, refuse when the root or ANY member is live (a live
+ * child would outlive its deleted parent) or missing from the listing, and
+ * order the result children-first so the executor can never leave a deleted
+ * parent behind surviving children. Artifact-location guards stay at the
+ * call site; this is the pure preflight they complete.
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ordered plan, or a user-facing refusal reason.
+ */
+export declare function planSessionDeletion(records: readonly SessionRecord[], id: string): SessionDeletionPlan;
+/**
+ * Codex-style relative time for session rows ("now", "5m ago", "3h ago",
+ * "2d ago"; older than a week falls back to the local date).
+ * @param timestamp - epoch milliseconds of the last activity.
+ * @param now - the pinned reference clock (one value per list render).
+ */
+export declare function formatRelativeTime(timestamp: number, now: number): string;

package/vendor/tui/types/session-switch.d.ts

@@ -0,0 +1,17 @@
+/** Latest-wins, idle-bound queue for safe Agent session changes. */
+export interface IdleActivity {
+    readonly status: 'idle' | 'running';
+    whenIdle(): Promise<void>;
+}
+export declare class SessionSwitchQueue<T> {
+    private readonly execute;
+    private readonly failed;
+    private pending;
+    private pumping;
+    constructor(execute: (value: T) => Promise<void>, failed: (error: unknown) => void);
+    /** Queue a request; a later request replaces any request still waiting. */
+    request(activity: IdleActivity, value: T): 'queued' | 'started';
+    /** Cancel only work that has not begun activation. */
+    cancel(): boolean;
+    private pump;
+}

package/vendor/tui/types/settings-file.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Serialized, crash-atomic persistence for the small user-level JSON files
+ * under the DSH home (statusline.json, theme.json). Two guarantees the bare
+ * floating `writeFile` path could not give:
+ *
+ * 1. Every save is appended to ONE chain, so rapid consecutive edits land
+ *    in submission order and the last snapshot is the one on disk (parallel
+ *    floating writes let an older snapshot finish last and win).
+ * 2. Each write goes to a sibling temp file first and is renamed into
+ *    place, so a crash mid-write can never leave a half-written JSON
+ *    document behind.
+ *
+ * The chain itself never rejects: a failed write is reported to that
+ * save's caller while later saves keep their turn.
+ *
+ * @module @deepseek-ai/dsh-code/settings-file
+ */
+/**
+ * Write one file atomically: create the parent directory, write to a
+ * uniquely named temp file, and rename it into place. A crash midway
+ * can never leave a half-written document behind. Unique temp names
+ * keep concurrent writers (two terminals, two chains in one process)
+ * from sharing one temp path.
+ */
+export declare function writeFileAtomically(path: string, text: string): Promise<void>;
+/** The serialized persistence surface; flush() is handed to the quit sequence. */
+export interface UserSettingsPersistence {
+    /**
+     * Queue one file snapshot. Resolves when the chain reaches (and renames)
+     * it; rejects only to THIS caller when its own write failed.
+     */
+    save(path: string, text: string): Promise<void>;
+    /** Wait for every queued write; safe to call repeatedly. */
+    flush(): Promise<void>;
+}
+/**
+ * Create the shared settings-write chain. One instance per process keeps
+ * every user-level JSON file mutually serialized.
+ * @returns the persistence handle.
+ */
+export declare function createUserSettingsPersistence(): UserSettingsPersistence;

package/vendor/tui/types/skills.d.ts

@@ -0,0 +1,47 @@
+/**
+ * User-invocable skill watch for the `/` completion menu: the in-process
+ * equivalent of the web ui-skill trigger source. Skills are NOT commands —
+ * picking one lands the literal `/name ` text in the input, and submitting
+ * it as a normal prompt lets the host's tool-skill pre-step inject the body
+ * (the only entry point for model-disabled skills). Command descriptors win
+ * on a name collision; see the runner's dispatch.
+ *
+ * @module @deepseek-ai/dsh-code/skills
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+/** One completion-menu row derived from a user-invocable skill. */
+export interface SkillRow {
+    /** Skill name; the literal `/name` text is what a pick lands. */
+    name: string;
+    /** Human-readable description (suffixed when model-invocation is off). */
+    description: string;
+    /** Whether the model may also invoke this skill by name. */
+    modelInvocable: boolean;
+}
+/** The skill-catalog snapshot the completion menu subscribes to. */
+export interface SkillsView {
+    /** Name-sorted user-invocable rows; empty until the first load lands. */
+    readonly rows: readonly SkillRow[];
+    /** Latest catalog-read failure; the help panel exposes it in place. */
+    readonly error?: string;
+    /** Subscribe to catalog changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Retarget the agent whose workspace the catalog is read for. */
+    setAgent(agent: Agent): void;
+}
+/** Internal shape shared by {@link watchSkills} and its test doubles. */
+interface SkillsWatch extends SkillsView {
+    setAgent(agent: Agent): void;
+}
+/**
+ * Watch the user-invocable skill catalog for one agent's workspace. The first
+ * load starts when the owning agent is known (`setAgent`); `skills/change`
+ * and agent retargets re-read. Read failures keep the last good rows (the
+ * next change notification is the retry surface) — a missing `skills`
+ * service leaves the view permanently empty.
+ * @param ctx - context carrying the `skills` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export declare function watchSkills(ctx: Context, fallbackCwd?: string): SkillsWatch;
+export {};

package/vendor/tui/types/startup.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The interactive terminal app's command-line provider: parses `--resume`,
+ * `--continue`, `--session`, `--mode`, `--theme`, `--image`, an optional
+ * initial prompt, and `--help`, then
+ * publishes {@link TUI_STARTUP_SERVICE} for the runner to consume lazily.
+ * Follows the headless bundle's startup shape (a commander action publishing
+ * a service through {@link parseCmdline}).
+ *
+ * Semantics:
+ * - `--resume <id|prefix>` — continue the persisted session whose id or unique
+ *   id-prefix matches; the TUI replays its transcript and appends to the same
+ *   durable log.
+ * - `--continue` / `-c` — resume the most recently modified persisted session
+ *   whose project directory matches the current working directory.
+ * - `--session <id>` — create a new session under an explicit identity (the
+ *   id must not exist yet).
+ * - `--theme <dark|light|auto>` — the color palette; auto follows the
+ *   terminal (dark fallback until OSC-11 detection lands).
+ * - no flags — a fresh session with a minted id.
+ *
+ * @module @deepseek-ai/dsh-tui/startup
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ThemeName } from './theme.ts';
+/** Stable Cordis plugin name. */
+export declare const name = "tui-startup";
+/** Services required before the invocation can be resolved. */
+export declare const inject: string[];
+/** How the runner obtains its session identity. */
+export type TuiStartup = ({
+    readonly kind: 'fresh';
+    readonly mode?: string;
+} & TuiStartupInput) | ({
+    readonly kind: 'named';
+    readonly sessionId: string;
+    readonly mode?: string;
+} & TuiStartupInput) | ({
+    readonly kind: 'resume';
+    readonly sessionId: string;
+} & TuiStartupInput) | ({
+    readonly kind: 'latest';
+} & TuiStartupInput);
+interface TuiStartupInput {
+    readonly theme?: ThemeName;
+    readonly prompt?: string;
+    readonly images?: readonly string[];
+}
+export interface TuiStartupOptions {
+    readonly resume?: string;
+    readonly continue?: boolean;
+    readonly session?: string;
+    readonly mode?: string;
+    readonly theme?: ThemeName;
+    readonly prompt?: string;
+    readonly images?: readonly string[];
+}
+/** Pure option policy shared by Commander and tests. */
+export declare function resolveTuiStartup(options: TuiStartupOptions): TuiStartup;
+/**
+ * Parse the invocation and publish the startup service. Mutual exclusions are
+ * usage errors rejected from the action before anything is provided.
+ * @param ctx - plugin context carrying the command line and exit request.
+ */
+export declare function apply(ctx: Context): void;
+export {};

package/vendor/tui/types/store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Observable transcript store: folds session events into the projection view
+ * and notifies subscribers. The renderer subscribes through
+ * `useSyncExternalStore`; the runner owns event feeding.
+ *
+ * Folding runs on the same mutable replay accumulator the persisted-log
+ * path uses (`replayProjectEvent`: id-indexed row updates, in-place
+ * appends), so a live structural event costs O(1) entry work regardless of
+ * transcript length — the copy-on-write fold rebuilt the whole entries
+ * array per event, making a growing session quadratic. An immutable
+ * `TranscriptView` snapshot is materialized only when a changed view is
+ * READ (once per rendered frame under the notification throttle, never per
+ * event), and every snapshot copies its arrays, so a view already handed
+ * out never observes later folds.
+ *
+ * Notification coalescing: the fold stays synchronous — `getView()` always
+ * returns the latest state the moment `apply` returns — but listener
+ * notification is frame-throttled (~16ms) and deduplicated. The zai/GLM
+ * adapter delivers tokens as a sustained stream of sub-millisecond,
+ * microtask-spaced bursts: per-burst notification renders at microtask
+ * cadence, which chained SyncLane `useSyncExternalStore` rerenders past
+ * React's nested-update limit ("Maximum update depth exceeded"), while a
+ * bare `setImmediate` merges a whole macrotask turn's bursts into one
+ * chunky repaint (streaming text visibly staggers). The frame budget gives
+ * both: an event ≥16ms after the last paint notifies via `setImmediate`
+ * (sub-millisecond latency for sparse/first tokens), and anything denser
+ * defers to the next 16ms boundary — a 60fps render cap that also breaks
+ * the nesting chain by construction.
+ *
+ * @module @deepseek-ai/dsh-tui/store
+ */
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import { type TranscriptView } from './render/projection.ts';
+/** The externally readable, event-fed transcript store for one session. */
+export interface TranscriptStore {
+    /** The current view; the same object identity until an event changes it. */
+    getView(): TranscriptView;
+    /** Subscribe to view changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Fold one session event; ignored events change nothing and notify nobody. */
+    apply(event: SessionEvent): void;
+    /** Fold one live assistant-stream frame; frames without visible deltas stay silent. */
+    applyStreamFrame(frame: AssistantStreamFrame): void;
+    /** Drop the folded view entirely (/clear): the next event starts a fresh one. */
+    reset(): void;
+}
+/**
+ * Create one transcript store, optionally seeded with replayed history. The
+ * seed folds synchronously BEFORE the first render, so a resumed session
+ * paints its full transcript on mount (no live `session/event` fires for
+ * constructor seeds — the store's `session/event` feed only carries new
+ * appends).
+ * @param replay - persisted events in `seq` order (e.g. a resumed session's
+ * constructor seed); folded once and never re-notified.
+ * @returns the store the runner feeds and the renderer subscribes to.
+ */
+export declare function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore;