@toddzheng024/dscode-bundle 0.1.0

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

@@ -0,0 +1,265 @@
+/**
+ * Terminal animation helpers derived from the web design language:
+ * thinking uses Codex's slow shimmer sweep, the busy composer marker uses the
+ * original braille chase, and the streaming caret blink is the Claude-Code
+ * convention.
+ *
+ * The DeepSeek model-switch easter egg ports Codex's effort-ignition "Wave"
+ * style (`codex-rs/tui/src/bottom_pane/effort_ignition_styles.rs`): switching
+ * INTO an official DeepSeek route sweeps a blue wave across the composer's
+ * input row — one column per cell, `backgroundColor` = the sampled wave
+ * color — then, on the deepseek (Ultra-equivalent) tier, drops the `· ✦ ✧`
+ * sparkle sequence into the rightmost blank cell before fading. The prompt
+ * marker keeps the tier accent afterwards (persistent, like Codex's prompt
+ * charge). Pure functions only — the Ink layer owns timers and colors.
+ *
+ * Wave and Pulse deliberately extend the Codex port after in-terminal
+ * testing: the per-row phase cascade was removed (Codex tints each column
+ * across the whole band), Wave became a WATER SURFACE — one continuous sine
+ * swell spanning the band, mirror-symmetric about the center column, its
+ * crests flowing outward from the center with a symmetric fade envelope
+ * (the deepseek tier adds one faster harmonic crossing it), painted with
+ * Aurora's recipe: wide soft gradients, mirrored second-hue mixing, and a
+ * low alpha cap — no hard core line — while Pulse became true
+ * two-dimensional, cell-aspect-corrected detonations: soft wide rings whose
+ * color grades across their width, expanding outward through a symmetric
+ * fade envelope and each trailing an echo ripple in the next blue. Aurora
+ * keeps Codex's geometry verbatim.
+ *
+ * @module @deepseek-ai/dsh-code/render/animations
+ */
+import type { RgbTriple } from '../theme.ts';
+/** Cadence for the original busy braille chase (8 frames × 125ms = 1s). */
+export declare const BUSY_CHASE_TICK_MS = 125;
+/** Original terminal StateDot chase frames. */
+export declare const BUSY_CHASE_FRAMES: readonly ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+/** Chase frame for a monotonic tick. */
+export declare function busyChaseFrame(tick: number): string;
+/** Clock cadence for the Codex-style Deep diving shimmer. */
+export declare const DEEP_DIVING_SHIMMER_TICK_MS = 33;
+/** Codex shimmer timing and geometry. */
+export declare const DEEP_DIVING_SHIMMER_DURATION_MS = 2000;
+export declare const DEEP_DIVING_SHIMMER_PADDING = 10;
+export declare const DEEP_DIVING_SHIMMER_HALF_WIDTH = 5;
+export declare const DEEP_DIVING_SPARK_BREATH_DURATION_MS = 2000;
+/**
+ * Codex's 2-second shimmer sweep, expressed in terminal ticks. The sweep has
+ * ten virtual columns of padding on either side and a five-column cosine
+ * highlight band, so the text changes gently rather than cycling rapidly.
+ */
+export declare function deepDivingShimmerIntensity(index: number, tick: number, graphemeCount: number): number;
+/** Blue RGB color for one grapheme in the Codex-style shimmer. */
+export declare function deepDivingGradientColor(index: number, tick: number, graphemeCount: number, base: RgbTriple, highlight: RgbTriple): RgbTriple;
+/** Smooth breathing intensity for the always-visible Deep diving sparkle. */
+export declare function deepDivingSparkIntensity(tick: number): number;
+/** Blue RGB color for the breathing Deep diving sparkle. */
+export declare function deepDivingSparkColor(tick: number, base: RgbTriple, highlight: RgbTriple): RgbTriple;
+/** Caret blink cadence: one blink step (on or off) per tick. */
+export declare const CARET_BLINK_TICK_MS = 530;
+/** Caret visibility: half the ticks on, half off (530ms blink). */
+export declare function caretVisible(tick: number): boolean;
+/**
+ * The one-shot DeepSeek model-switch easter egg: when the status bar model
+ * label switches to an official DeepSeek route, the composer's input row
+ * plays Codex's effort-ignition "Wave" — a blue crest sweeping the content
+ * row column by column (background tint ≤ 0.55 under the draft), plus the
+ * Ultra-style `· ✦ ✧` sparkles on the deepseek tier — and the prompt marker
+ * keeps the tier accent afterwards. The Ink layer owns the timer and reads
+ * the ACTIVE palette anchors (`getPalette`); everything below is pure
+ * interpolation over the colors it is given.
+ */
+/** Frame cadence of the DeepSeek wave: Codex's IGNITION_FRAME_TICK (33ms ≈ 30fps). */
+export declare const DEEPSEEK_WAVE_TICK_MS = 33;
+/**
+ * The DeepSeek wave tiers. The concept maps Codex's reasoning tiers to
+ * model ids: `flash` runs the Max parameters, `deepseek` (pro models) runs
+ * the Ultra parameters (dual band + tail sparkles on the Wave style).
+ * `unknown` is the "Into the Unknown" variant: it reuses the deepseek tier's
+ * exact parameters (dual band, durations, sparkles) for NON-DeepSeek models
+ * running a reasoning effort above high — the wordmark renders differently
+ * but the motion is identical.
+ */
+export type DeepseekWaveTier = 'flash' | 'deepseek' | 'unknown';
+/**
+ * The three ignition styles — Codex `IgnitionStyle`: a traveling crest
+ * (Wave), a drifting multi-hue band (Aurora), and an expanding ring (Pulse).
+ * One style is picked at random per trigger and never repeats the previous.
+ */
+export type DeepseekWaveStyle = 'wave' | 'aurora' | 'pulse';
+/**
+ * The water surface: ONE continuous sine line spanning the whole band,
+ * mirror-symmetric about the center column, its crests flowing OUTWARD from
+ * the center (phase k·|x − center| − ω·t). No sweep window, no return trip —
+ * the surface fades in, flows, and fades out, symmetric in both space and
+ * time. The deepseek tier adds one faster, finer HARMONIC line whose crests
+ * cross the fundamental's: interleaved richness with both lines still
+ * symmetric and still only ever flowing outward.
+ */
+export declare const WAVE_SURFACE_AMPLITUDE = 0.8;
+export declare const WAVE_SURFACE_HARMONIC = 0.45;
+export declare const WAVE_SURFACE_WAVELENGTH = 40;
+export declare const WAVE_SURFACE_OMEGA = 9;
+/** Vertical thickness in lane units — Aurora-wide: soft gradients, no hard edges. */
+export declare const WAVE_SURFACE_THICKNESS = 1.2;
+/**
+ * The mirrored second-hue profile: the space BELOW the surface carries a
+ * second blue at this strength, so color (not just brightness) varies
+ * continuously across the wave — Aurora-style hue mixing instead of a
+ * single flat tint.
+ */
+export declare const WAVE_SURFACE_MIRROR = 0.6;
+/** Aurora-style soft alpha: low gain, capped well under the pulse ring's. */
+export declare const WAVE_SURFACE_ALPHA_GAIN = 0.45;
+export declare const WAVE_SURFACE_ALPHA_CAP = 0.68;
+/** Aurora-grade soft alpha for the detonation — a notch above the swell. */
+export declare const PULSE_ALPHA_GAIN = 0.45;
+export declare const PULSE_ALPHA_CAP = 0.72;
+/** Sparkle glyphs in frame order — Codex SPARK_GLYPHS (`· ✦ ✧`). */
+export declare const SPARK_GLYPHS: readonly ["·", "✦", "✧"];
+/**
+ * Band tables — Codex `bands(style, tier)`. Each entry is a triple whose
+ * meaning depends on the style: Wave/Pulse use `(launch, travel, strength)`;
+ * Aurora uses `(speed, phase, hueIndex)`.
+ */
+export type DeepseekWaveBand = readonly [number, number, number];
+export declare const DEEPSEEK_WAVE_BANDS: Readonly<Record<DeepseekWaveStyle, Readonly<Record<DeepseekWaveTier, readonly DeepseekWaveBand[]>>>>;
+/**
+ * Total visible duration: the Codex ignition duration plus 200ms so its motion
+ * remains readable in a busy terminal.
+ * @param tier - the active wave tier.
+ * @param style - the active ignition style.
+ * @returns the duration in milliseconds.
+ */
+export declare function deepseekWaveDuration(tier: DeepseekWaveTier, style?: DeepseekWaveStyle): number;
+/**
+ * Pick one ignition style at random, never repeating the previous one —
+ * Codex `IgnitionStyle::random`. Falls back to the remaining styles.
+ * @param previous - the style of the last trigger, if any.
+ * @returns a style different from `previous`.
+ */
+export declare function deepseekWaveStyleRandom(previous: DeepseekWaveStyle | undefined): DeepseekWaveStyle;
+/**
+ * Tier for a `provider/model` label: a MODEL ID containing `flash` runs the
+ * single-band flash tier; everything else (pro/reasoner/chat) runs the
+ * dual-band deepseek tier. Mirrors Codex's Max→Ultra mapping. Only the model
+ * segment (after the `/`) is matched, so a provider whose name contains
+ * `flash` cannot flip an unrelated model onto the flash tier.
+ * @param model - the `provider/model` label of the applied model.
+ * @returns the wave tier for that model.
+ */
+export declare function deepseekWaveTier(model: string): DeepseekWaveTier;
+/**
+ * Cosine window — Codex `crest`: 1 exactly under the wave center, 0 from
+ * one half-width away.
+ * @param distance - distance from the crest center in half-widths.
+ * @returns the crest strength in 0..1.
+ */
+export declare function crest(distance: number): number;
+/**
+ * Cubic ease-in-out — Codex `ease_in_out`: flat at both ends, steepest in
+ * the middle, so the crest accelerates and eases instead of sliding linearly.
+ * @param progress - raw progress (clamped to 0..1).
+ * @returns the eased progress in 0..1.
+ */
+export declare function easeInOut(progress: number): number;
+/**
+ * Fade-in/fade-out envelope — Codex `envelope`: linear ramp over `fadeIn`
+ * at the start and `fadeOut` at the end, plateau at 1 between, 0 outside the
+ * total. The Wave style keeps the envelope at 1 (Codex paints Wave without
+ * an envelope); exported for the Aurora-style fades and for tests.
+ * @param elapsed - seconds since the animation started.
+ * @param total - total duration in seconds.
+ * @param fadeIn - seconds of fade-in.
+ * @param fadeOut - seconds of fade-out.
+ * @returns the envelope value in 0..1.
+ */
+export declare function envelope(elapsed: number, total: number, fadeIn: number, fadeOut: number): number;
+/**
+ * The background color for one composer-band column at a tick — Codex
+ * `paint_bands` + `Canvas::tint` for all three styles. Bands overlap with a
+ * max for Wave/Pulse and a SUM for Aurora (Codex differs by style), the
+ * weighted hues mix per column (Wave/Pulse always end on hue 0), the tint
+ * blends the mixed hue toward the blank-cell base at the style's alpha cap,
+ * and Aurora applies its own fade envelope. Returns `null` when the column
+ * should stay transparent, so the row returns to no `backgroundColor` on
+ * both ends. With `rows > 1`: Wave is a water surface — every column
+ * lights the row nearest the surface's current height, so the light reads
+ * as ONE continuous wavy line spanning the band, symmetric about the center
+ * column and flowing outward (a single-row band falls back to a flat glow);
+ * Pulse rings in two dimensions around the band's center cell with trailing
+ * echo ripples; only Aurora samples the timeline shifted by a per-row phase
+ * offset.
+ * @param tick - wave frame (0, 1, … at DEEPSEEK_WAVE_TICK_MS).
+ * @param column - column index in the content row (0..width-1).
+ * @param width - content-row width in columns.
+ * @param tier - the wave tier (flash = Max, deepseek = Ultra parameters).
+ * @param style - the ignition style.
+ * @param hues - the tier's three hues.
+ * @param base - the blank-cell base color the tint blends toward.
+ * @param row - row index in the band (0..rows-1; default 0 = old single-row).
+ * @param rows - band height in rows (default 1).
+ * @returns the blended RGB background, or null for transparent.
+ */
+export declare function deepseekWaveColumnBg(tick: number, column: number, width: number, tier: DeepseekWaveTier, style: DeepseekWaveStyle, hues: readonly [RgbTriple, RgbTriple, RgbTriple], base: RgbTriple, row?: number, rows?: number): RgbTriple | null;
+/**
+ * The sparkle glyph for a tick — Codex `spark_frame`, sampled on the same
+ * proportionally slowed DeepSeek Wave timeline as the composer background.
+ * The Ink layer still must skip occupied cells.
+ * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
+ * @returns the sparkle glyph, or null outside the stretched tail window.
+ */
+export declare function deepseekWaveSpark(tick: number): string | null;
+/**
+ * Whether the `deepseek` wordmark rides the wave at this tick: it fades in
+ * shortly after the first crest launches and out before the wave settles,
+ * so the brand name surfaces through the sweep's middle. The Ink layer
+ * places it in the row's blank mid-section (never over real draft text).
+ * @param tick - wave frame at DEEPSEEK_WAVE_TICK_MS.
+ * @param tier - the wave tier.
+ * @returns true while the wordmark should be visible.
+ */
+export declare function deepseekWaveWordVisible(tick: number, tier: DeepseekWaveTier, style?: DeepseekWaveStyle): boolean;
+/**
+ * The per-character color for the `deepseek` wordmark: the tier's hues
+ * cycled per character (d→hue0, e→hue1, e→hue2, …), a brand-gradient text.
+ * @param index - character index in the wordmark.
+ * @param hues - the tier's three hues.
+ * @returns the hue for that character.
+ */
+export declare function deepseekWaveWordHue(index: number, hues: readonly [RgbTriple, RgbTriple, RgbTriple]): RgbTriple;
+/**
+ * True when a `provider/model` status label addresses the official DeepSeek
+ * route: either segment contains `deepseek` (case-insensitive), covering the
+ * `deepseek-official` provider route and its `deepseek-*` model ids.
+ * @param label - the status bar model label (`provider/model`).
+ * @returns whether the label names an official DeepSeek model.
+ */
+export declare function isOfficialDeepSeekLabel(label: string): boolean;
+/**
+ * True when an effective reasoning effort is STRICTLY above `high` — the
+ * trigger gate for the "Into the Unknown" wave on non-DeepSeek routes.
+ * Absent efforts and unrecognized ids never qualify.
+ * @param effort - the effective reasoning-effort id ('' or undefined when none).
+ * @returns whether the effort ranks above high.
+ */
+export declare function effortAboveHigh(effort: string | undefined): boolean;
+/**
+ * Parse a persisted animations preference (`animations.json`): timed
+ * animations are on by default and only an explicit `false` disables them —
+ * a missing key, corrupt value, or absent file all mean enabled, so the
+ * /animation toggle degrades exactly like every other user preference.
+ * @param value - the raw parsed JSON value (expected boolean).
+ * @returns whether timed animations should run.
+ */
+export declare function parseAnimationsPref(value: unknown): boolean;
+/**
+ * One parsed `/animation` argument: '' toggles, `on|true|1` enables,
+ * `off|false|0` disables (case-insensitive, surrounding whitespace ignored),
+ * and anything else is a usage error the caller surfaces. Kept pure so the
+ * command's entire decision table is unit-testable.
+ * @param argument - the raw text after `/animation`.
+ * @returns `{ enabled }`, `'toggle'`, or `'usage'`.
+ */
+export declare function parseAnimationsArgument(argument: string): {
+    enabled: boolean;
+} | 'toggle' | 'usage';

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

@@ -0,0 +1,162 @@
+/**
+ * Pure composer editor model with Codex textarea semantics: a grapheme
+ * cursor over a column-safe multiline layout, word/piece motion, single-entry
+ * kill + yank, and the shell-recall boundary gate that keeps Up/Down usable
+ * inside a multiline draft.
+ *
+ * The model is intentionally string-offset based (UTF-16 indices clamped to
+ * grapheme boundaries) so the React state stays two primitives
+ * (value, cursor) and every operation here stays pure and testable.
+ *
+ * Word motion follows Codex's piece semantics: whitespace separates runs,
+ * punctuation runs stay atomic, and each Han grapheme is its own boundary.
+ *
+ * @module @deepseek-ai/dsh-code/render/editor
+ */
+/** One grapheme cluster with its source span and display width in cells. */
+export interface GraphemeSpan {
+    text: string;
+    start: number;
+    end: number;
+    width: number;
+}
+/**
+ * Split text into grapheme clusters. Falls back to code points when
+ * Intl.Segmenter is unavailable; the fallback still keeps surrogate pairs
+ * (emoji) atomic so the cursor can never split one.
+ */
+export declare function splitGraphemes(text: string): readonly GraphemeSpan[];
+/** Clamp a cursor offset to the nearest grapheme boundary (surrogates, ZWJ, marks stay whole). */
+export declare function clampCursor(value: string, offset: number): number;
+/**
+ * Delete the final grapheme cluster (append-only drafts without a cursor).
+ * Surrogate pairs and multi-codepoint emoji stay whole instead of leaving a
+ * lone trailing code unit behind.
+ */
+export declare function deleteLastGrapheme(text: string): string;
+/**
+ * Step the cursor by whole graphemes (negative steps left). The cursor is
+ * assumed to sit on a boundary; any drift is clamped first.
+ */
+export declare function moveCursorBy(value: string, offset: number, delta: number): number;
+/**
+ * Normalize text entering the draft: CRLF/CR become LF, tabs become two
+ * spaces (terminal tab stops are contextual and cannot join a deterministic
+ * row budget), and every other C0 control byte plus DEL is REMOVED — the
+ * draft is data, so a stray ESC (Windows Terminal file drops) disappears
+ * instead of rendering as literal backslash-x-1-b text. Newlines survive.
+ */
+export declare function sanitizeDraftText(text: string): string;
+/** One physical editor row: wrapped text plus its boundary map. */
+export interface EditorRowModel {
+    /** Display text of the row (never contains `\n`; sanitized upstream). */
+    readonly text: string;
+    /** Source offset of the first grapheme on the row. */
+    readonly start: number;
+    /** Source offset just past the last grapheme on the row (before its newline). */
+    readonly end: number;
+    /** Boundary offsets on the row, start to end inclusive. */
+    readonly offsets: readonly number[];
+    /** Display column of each boundary; `columns[i]` pairs with `offsets[i]`. */
+    readonly columns: readonly number[];
+    /** Code-unit cut in `text` at each boundary; `cuts[i]` pairs with `offsets[i]`. */
+    readonly cuts: readonly number[];
+}
+/** The wrapped physical-row model of one draft. */
+export interface EditorModel {
+    readonly rows: readonly EditorRowModel[];
+    readonly length: number;
+}
+/**
+ * Hard-wrap the draft into column-safe physical rows. Wide graphemes never
+ * split across rows (a grapheme that does not fit flushes the row first) and
+ * explicit newlines end their row without occupying a cell.
+ */
+export declare function editorModel(value: string, columns: number): EditorModel;
+/** Where a cursor offset renders: the physical row and its display column. */
+export interface CaretSite {
+    row: number;
+    column: number;
+}
+/** Text slices for rendering one physical row with at most one caret. */
+export interface EditorRowParts {
+    readonly before: string;
+    readonly caret: string;
+    readonly after: string;
+    readonly hasCaret: boolean;
+}
+/** Split one row around the authoritative caret; every other row stays whole. */
+export declare function editorRowParts(row: EditorRowModel, rowIndex: number, caretRow: number, cursor: number, caretEnabled?: boolean): EditorRowParts;
+/** Map a cursor offset to its caret site on the wrapped rows. */
+export declare function caretSite(model: EditorModel, offset: number): CaretSite;
+/**
+ * Move the caret across physical rows keeping a preferred display column
+ * (Codex `preferred_col`): horizontal moves reset the preference, vertical
+ * moves reuse it, clamped to each row's width.
+ */
+export declare function moveCursorVertically(model: EditorModel, offset: number, preferredColumn: number, delta: number): number;
+/** The start/end offsets of the logical line containing the cursor. */
+export declare function lineBounds(value: string, offset: number): {
+    start: number;
+    end: number;
+};
+/**
+ * Codex `beginning_of_previous_word`: skip whitespace left, then land on the
+ * START of the trailing non-space piece (extending over separator pieces).
+ */
+export declare function moveWordLeft(value: string, offset: number): number;
+/**
+ * Codex `end_of_next_word`: skip whitespace right, then land on the END of
+ * the leading non-space piece (extending over separator pieces).
+ */
+export declare function moveWordRight(value: string, offset: number): number;
+/** One edit outcome: the next draft value, cursor, and killed span (if any). */
+export interface EditResult {
+    value: string;
+    cursor: number;
+    /** Text removed into the kill buffer; undefined when nothing was killed. */
+    killed: string | undefined;
+}
+/** Delete the grapheme cluster before the cursor. */
+export declare function deleteBackward(value: string, cursor: number): EditResult;
+/** Delete the grapheme cluster at the cursor. */
+export declare function deleteForward(value: string, cursor: number): EditResult;
+/** Delete back to the start of the previous word (fills the kill buffer). */
+export declare function deleteWordBackward(value: string, cursor: number): EditResult;
+/** Delete forward to the end of the next word (fills the kill buffer). */
+export declare function deleteWordForward(value: string, cursor: number): EditResult;
+/** Ctrl+U: kill from the line start to the cursor; at BOL, kill the newline. */
+export declare function killToLineStart(value: string, cursor: number): EditResult;
+/** Ctrl+K: kill from the cursor to the line end; at EOL, kill the newline. */
+export declare function killToLineEnd(value: string, cursor: number): EditResult;
+/** Insert sanitized text at the cursor. */
+export declare function insertText(value: string, cursor: number, text: string): EditResult;
+/** Ctrl+A: current logical line start, then the previous line start on repeat. */
+export declare function moveToLineStart(value: string, cursor: number, crossOnRepeat: boolean): number;
+/** Ctrl+E: current logical line end, then the next line end on repeat. */
+export declare function moveToLineEnd(value: string, cursor: number, crossOnRepeat: boolean): number;
+/** One stable text range captured before an asynchronous draft operation. */
+export interface DraftRange {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Remap a captured range when all intervening edits are wholly before or
+ * wholly after it. An edit overlapping either boundary invalidates the
+ * anchor instead of guessing and inserting content at a surprising place.
+ */
+export declare function remapStableRange(original: string, current: string, range: DraftRange): DraftRange | undefined;
+/** Replace a current range while preserving a cursor moved after capture. */
+export declare function replaceRangePreservingCursor(value: string, cursor: number, range: DraftRange, replacement: string): EditResult;
+/**
+ * Composer editor row budget: the editor itself never grows past this many
+ * physical rows; deeper drafts scroll internally to keep the caret visible.
+ * Short terminals collapse toward one row so the live transcript keeps room.
+ */
+export declare function composerMaxRows(terminalRows: number): number;
+/**
+ * History navigation starts with Up on an empty draft, or after visual
+ * movement has reached the directional text edge of an unchanged recalled
+ * entry. Every other position remains under textarea movement.
+ */
+export declare function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean;

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

@@ -0,0 +1,9 @@
+/**
+ * Markdown export of one transcript view: the /export command's pure
+ * formatter. Deterministic and side-effect free — the runner owns the file
+ * write, so tests drive the builder with folded views directly.
+ *
+ * @module @deepseek-ai/dsh-code/render/export
+ */
+import { type TranscriptView } from './projection.ts';
+export declare function buildExportMarkdown(view: TranscriptView, sessionId: string): string;

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

@@ -0,0 +1,21 @@
+/**
+ * Shared fuzzy ranking for `/` and `@` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name. Prefix hits
+ * rank first, then the strongest alignment score, then the source order of
+ * the input. Ported from the upstream web client's ui-primitives
+ * (rank-by-name.ts) so the terminal matches the web menu's discovery feel;
+ * the algorithm is unchanged, only the module's home moved.
+ *
+ * @module @deepseek-ai/dsh-code/render/fuzzy
+ */
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (the caller's composition order
+ * is the final tie-breaker, e.g. local commands before registry entries).
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export declare function rankByName<T extends {
+    readonly name: string;
+}>(items: readonly T[], rawQuery: string): readonly T[];

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

@@ -0,0 +1,36 @@
+/** Pure viewport, selection, and scrolling rules for exclusive TUI panels. */
+/** Terminal-space allocation for the inspector's one dynamic screen. */
+export interface InspectorViewport {
+    /** Maximum dynamic rows, kept strictly below the terminal height. */
+    maxHeight: number;
+    /** Rows available to the selected entry after border, title, and footer. */
+    bodyRows: number;
+    /** Optional blank rows separating title/body/footer on roomy terminals. */
+    gapRows: 0 | 2;
+    /** Columns available inside the horizontal border and padding. */
+    contentColumns: number;
+    /** Safe outer width for a bordered dynamic panel; never writes column N. */
+    outerColumns: number;
+    /** Tiny terminals use a borderless one-line close hint. */
+    compact: boolean;
+}
+/** One transcript-to-composer gutter, collapsed on short terminals. */
+export declare function layoutGutterRows(rows: number): 0 | 1;
+/**
+ * Keep the inspector plus its persistent status/composer chrome below
+ * `stdout.rows`: at equality Ink clears the terminal and rewrites all
+ * accumulated `<Static>` output on every frame.
+ */
+export declare function panelViewport(columns: number, rows: number): InspectorViewport;
+/** Backward-compatible name for the Ctrl+O-specific caller and tests. */
+export declare function inspectorViewport(columns: number, rows: number): InspectorViewport;
+/** Clamp a first-visible row to the range representable by one viewport. */
+export declare function clampScroll(offset: number, totalRows: number, visibleRows: number): number;
+/** Move a viewport by a signed row delta without escaping its content. */
+export declare function moveScroll(offset: number, delta: number, totalRows: number, visibleRows: number): number;
+/** Keep one focused row visible while preserving the current window when possible. */
+export declare function revealRow(offset: number, row: number, totalRows: number, visibleRows: number): number;
+/** Center a selected list row where possible, clamped at both ends. */
+export declare function selectionWindow(cursor: number, totalRows: number, visibleRows: number): number;
+/** Follow appended history only while the inspector cursor was at the tail. */
+export declare function followInspectorCursor(cursor: number, previousLength: number, nextLength: number): number;

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

@@ -0,0 +1,66 @@
+/** Width-safe styled physical rows for bounded terminal panels. */
+import { type TranscriptEntry } from './projection.ts';
+import { type MdStyle } from './markdown.ts';
+/** Presentation classes mapped to Ink colors by the app boundary. */
+export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic';
+/** One styled run within a physical terminal row. */
+export interface StyledSegment {
+    text: string;
+    style: LineStyle;
+}
+/** One row guaranteed not to exceed the requested terminal width. */
+export interface StyledLine {
+    segments: readonly StyledSegment[];
+}
+/** Construct one segment without leaking mutable objects into cached rows. */
+export declare function lineSegment(text: string, style?: LineStyle): StyledSegment;
+/**
+ * Sanitize and hard-wrap styled content into exact physical rows.
+ * Tabs become two visible spaces because terminal tab stops are contextual
+ * and therefore cannot participate in a deterministic row budget.
+ */
+export declare function styledLines(segments: readonly StyledSegment[], columns: number): readonly StyledLine[];
+/** Plain/dim text convenience over {@link styledLines}. */
+export declare function textLines(text: string, columns: number, style?: LineStyle): readonly StyledLine[];
+/** Markdown rows re-hardened so a single long word cannot escape the budget. */
+export declare function markdownLines(text: string, columns: number): readonly StyledLine[];
+/**
+ * Codex-style reasoning rows: the marker occupies the reply gutter and every
+ * wrapped or explicit continuation starts with the same two-column indent, so
+ * reasoning content and assistant Markdown share one left edge.
+ */
+export declare function reasoningLines(text: string, columns: number): readonly StyledLine[];
+/**
+ * Convert one durable transcript entry to its complete scrollable row model.
+ * The source entry stays intact; only the caller's visible slice is rendered.
+ * Wrapped continuations keep a hanging indent aligned under each row's
+ * content (Codex history-cell alignment) instead of resetting to column 0.
+ */
+export declare function transcriptEntryLines(entry: TranscriptEntry, columns: number, showReasoning?: boolean, reasoningToggleHint?: boolean, showToolDetails?: boolean): readonly StyledLine[];
+/** Settled-history variant carrying the Ctrl+R reasoning fold. */
+export declare function settledEntryLines(entry: TranscriptEntry, columns: number, showReasoning: boolean): readonly StyledLine[];
+/** The flexible rows of the live region; chrome (composer/notice/status) is never reduced. */
+export interface LiveAllocation {
+    /** Settled tail rows currently rendered in the live tree. */
+    readonly live: number;
+    /** Rows reserved for the streaming reasoning tail or its marker. */
+    readonly reasoning: number;
+    /** Rows reserved for the streaming answer tail. */
+    readonly answer: number;
+}
+/** A clamped allocation plus the invariant-trip warning that triggered it. */
+export interface LiveAllocationAudit {
+    readonly allocation: LiveAllocation;
+    readonly warning?: string;
+}
+/**
+ * Clamp the live-region allocation so the flexible dynamic rows never exceed
+ * the post-chrome budget. By construction the caller derives these rows from
+ * the same budget; this is the runtime tripwire for a future edit that breaks
+ * that derivation. Reduction order: answer first (the freshest content is the
+ * live tail), then reasoning, then settled live rows; nothing goes negative.
+ * @param allocation - the intended row allocation.
+ * @param dynamicRows - the post-chrome row budget.
+ * @returns the clamped allocation and a warning string when clamping fired.
+ */
+export declare function clampLiveAllocation(allocation: LiveAllocation, dynamicRows: number): LiveAllocationAudit;

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

@@ -0,0 +1,29 @@
+/**
+ * Terminal markdown renderer for assistant replies: a pure GFM-subset
+ * block/inline parser producing styled line segments the Ink renderer maps
+ * to colored text. No ANSI here — the app owns color mapping, tests own the
+ * structure. The subset mirrors what agent replies actually emit: headings,
+ * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, GFM
+ * tables, and wrapped paragraphs. Unknown syntax degrades to plain text.
+ *
+ * @module @deepseek-ai/dsh-code/render/markdown
+ */
+/** Style classes the renderer emits; the app maps them to colors/props. */
+export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'accentBold' | 'dim' | 'strike';
+/** One styled run of text. */
+export interface MdSegment {
+    /** Visible text (no ANSI). */
+    text: string;
+    /** Presentation class for the app's color map. */
+    style: MdStyle;
+}
+/** One rendered line: a sequence of styled runs. */
+export interface MdLine {
+    segments: readonly MdSegment[];
+}
+/** Visible width of a run in columns (grapheme-cluster and emoji aware). */
+export declare function visibleColumns(text: string): number;
+/** Render markdown text into styled lines of at most `width` columns. */
+export declare function renderMarkdown(text: string, width: number, options?: {
+    physicalWrap?: boolean;
+}): readonly MdLine[];