@toddzheng024/dscode-bundle 0.1.0

package/vendor/tui/types/git-workflow.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Read-only Git inspection used by /diff and /review. Every diff
+ * invocation carries --no-ext-diff and --no-textconv, so configured
+ * external diff drivers and text converters can never execute as a
+ * side effect of reading a diff.
+ */
+export interface GitDiffSpec {
+    readonly label: string;
+    readonly args: readonly string[];
+}
+/** One file section from a unified diff, retained in source order. */
+export interface GitDiffFile {
+    readonly path: string;
+    readonly lines: readonly string[];
+}
+/** A parsed diff ready for a file-oriented terminal viewport. */
+export interface GitDiffView {
+    readonly title: string;
+    readonly files: readonly GitDiffFile[];
+}
+/** Split Git's stable `diff --git` framing without interpreting patch content. */
+export declare function parseGitDiffFiles(text: string): readonly GitDiffFile[];
+/** Parse the intentionally small, option-safe /diff argument vocabulary. */
+export declare function parseGitDiffSpec(argument: string): GitDiffSpec;
+/**
+ * Load one complete textual diff without invoking external programs.
+ * @param signal - aborted by the caller on session switches/quit, killing the
+ * git subprocess instead of letting a stale repository's diff land later.
+ */
+export declare function loadGitDiff(cwd: string, argument: string, signal?: AbortSignal): Promise<GitDiffView>;
+/** Review prompt capped before it reaches a provider context window. */
+export declare function buildReviewPrompt(diff: string, label: string, maxChars?: number): string;

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

@@ -0,0 +1,97 @@
+/**
+ * Global input recall: persistent cross-session entries plus this process's
+ * submissions, with Codex `ChatComposerHistory` semantics — empty submissions
+ * are ignored, adjacent duplicates collapse, the recall space skips
+ * persistent entries that duplicate a local one (local wins), and Up/Down
+ * navigation is gated so interior cursor movement never hijacks the draft.
+ *
+ * @module @deepseek-ai/dsh-tui/history
+ */
+/** Maximum entries retained in the persistent history file and the local recall pool. */
+export declare const HISTORY_MAX_ENTRIES = 100;
+/** Encode one entry for the history file (JSON keeps multi-line drafts intact). */
+export declare function serializeHistoryEntry(text: string): string;
+/**
+ * Parse a persisted history file (one JSON entry per line): invalid lines
+ * drop out, empty entries are ignored, adjacent duplicates collapse, and the
+ * result keeps only the newest `max` entries.
+ * @param raw - file content, empty for a missing file.
+ * @param max - entry cap.
+ * @returns persistent entries, oldest first.
+ */
+export declare function parseHistoryFile(raw: string, max?: number): readonly string[];
+/**
+ * The append unit for the persistent file: one JSON line, so a multi-line
+ * draft still occupies exactly one physical line. Each submission appends
+ * this unit at the end of the file, so concurrent terminals add entries
+ * after each other. Node chunks one append at 512 KiB: a pasted entry
+ * beyond that size could interleave mid-line with another writer's
+ * chunks, and the damaged line then drops out at the next parse —
+ * recall tolerates the loss by design.
+ */
+export declare function historyLine(text: string): string;
+/**
+ * Whether the file on disk differs from its canonical form (deduped and
+ * capped). True means stale lines have accumulated and the next boot
+ * should rewrite it once, atomically.
+ */
+export declare function needsCompaction(raw: string, max?: number): boolean;
+/**
+ * Record one in-session submission: empty text is ignored and an adjacent
+ * duplicate collapses (Codex `record_local_submission` semantics). The local
+ * pool shares the persistent pool's cap so the recall space stays bounded.
+ * @param local - current in-session entries, oldest first.
+ * @param text - the submitted prompt.
+ * @param max - the local pool cap.
+ * @returns the updated local list.
+ */
+export declare function recordLocalEntry(local: readonly string[], text: string, max?: number): readonly string[];
+/**
+ * Serialize a capped entry list to the history file format (one JSON line
+ * per entry, trailing newline). The boot-time compaction writes this
+ * canonical form once when stale lines have accumulated; submissions
+ * themselves only ever append a single line.
+ * @param entries - the entries to persist, oldest first.
+ * @returns the file content, '' for an empty list.
+ */
+export declare function serializeHistoryList(entries: readonly string[]): string;
+/**
+ * Build the recall space, newest first: local entries, then persistent
+ * entries whose text is not duplicated locally (the local copy wins and the
+ * persistent twin is skipped — Codex's replay-seed dedup, applied to the
+ * whole local set).
+ * @param persistent - cross-session entries, oldest first.
+ * @param local - this process's submissions, oldest first.
+ * @returns recall entries, newest first.
+ */
+export declare function recallEntries(persistent: readonly string[], local: readonly string[]): readonly string[];
+/** Shell-style recall navigation over a fixed recall space. */
+export interface RecallState {
+    /** Recall entries, newest first (frozen at navigation start). */
+    entries: readonly string[];
+    /** Current recall index; null when not browsing. */
+    index: number | null;
+    /** Draft saved when browsing started; restored on Down past the newest. */
+    savedDraft: string;
+    /** The recalled text currently in the composer (the boundary gate's anchor). */
+    lastRecalled: string | null;
+}
+/** Fresh navigation state over one recall space. */
+export declare function beginRecall(entries: readonly string[], draft: string): RecallState;
+/** The outcome of one recall step. */
+export interface RecallStep {
+    state: RecallState;
+    /** The text to place in the composer; undefined means "no movement". */
+    entry: string | undefined;
+}
+/**
+ * Move one entry older (Up, toward index +1 in the newest-first space). The
+ * first Up saves the current draft so Down past the newest can restore it
+ * (Claude-Code shell recall — the draft is never lost); the oldest entry
+ * stays put.
+ * @param state - current navigation state.
+ * @param draft - the composer text to preserve when browsing starts.
+ */
+export declare function recallOlder(state: RecallState, draft: string): RecallStep;
+/** Move one entry newer (Down, toward index 0); past the newest, browsing ends and the saved draft returns. */
+export declare function recallNewer(state: RecallState): RecallStep;

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

@@ -0,0 +1,124 @@
+/**
+ * @deepseek-ai/dsh-code — the interactive terminal driver. The bundle patch
+ * rides over dsh-base without Host, HTTP, or browser plugins; this runner
+ * creates or resumes preset-composed Agents through the core registry, keeps
+ * one Ink owner while the active session changes, folds submitted prompts
+ * into the selected durable session, answers approval asks with a y/n bar,
+ * dispatches slash commands, and on quit flushes and requests process exit.
+ *
+ * @module @deepseek-ai/dsh-code
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type ContentBlock } from '@deepseek-ai/dsh-llm';
+import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session';
+import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
+import type { TuiStartup } from './startup.ts';
+/** Stable Cordis plugin name. */
+export declare const name = "tui-runner";
+/** Core services required before the interactive session can start. */
+export declare const inject: string[];
+/** Plugin config: the startup resolved from this app's injected provider service. */
+export interface Config {
+    /** How this invocation obtains its session identity (validated loosely; narrowed in {@link apply}). */
+    startup: {
+        kind: string;
+        sessionId?: string;
+        mode?: string;
+        theme?: string;
+        prompt?: string;
+        images?: string[];
+    };
+}
+export declare const Config: z<Config>;
+/** The session identity this invocation will run, plus whether it is resumed. */
+interface Target {
+    sessionId: string;
+    resume: boolean;
+    mode?: string;
+    cwd?: string;
+    seed?: readonly SessionEvent[];
+    parentSession?: SessionId;
+    seedLength?: number;
+}
+/**
+ * Reduce a session id to a filename-safe /export default-name suffix. Session
+ * ids are normally minted `session-<uuid>`, but `--session` accepts arbitrary
+ * user text: path separators must never leak into the default export filename
+ * (which would escape the session cwd).
+ * @param id - the session id.
+ * @returns at most the last 8 filename-safe characters.
+ */
+export declare function exportSessionIdSuffix(id: string): string;
+/** One ordered step of the terminal quit cleanup. */
+export interface QuitCleanupStep {
+    /** Step label used in diagnostics and tests. */
+    readonly name: string;
+    /** The step's async work; a rejection is contained by the sequence. */
+    readonly run: () => Promise<void>;
+}
+/**
+ * Run the ordered quit cleanup, then request exit. Every step rejection is
+ * contained (reported through `onError`) so a failed flush or dispose never
+ * skips the remaining cleanup; the exit request is always reached exactly
+ * once.
+ * @param steps - the cleanup steps in dependency order (settle the visible
+ * session, await the final in-flight composition, await durable recall).
+ * @param exit - the terminal exit request (code 0).
+ * @param onError - optional failure sink; called once per failing step and
+ * itself contained, so a throwing sink cannot abort the sequence.
+ * @returns the names of the steps that started, in order (for tests).
+ */
+export declare function runQuitSequence(steps: readonly QuitCleanupStep[], exit: (code: number) => void, onError?: (name: string, error: unknown) => void): Promise<readonly string[]>;
+/** One composer submission waiting behind the startup delivery. */
+export interface QueuedSubmission {
+    readonly text: string;
+    readonly mode: 'followup' | 'steer';
+    readonly images: readonly ContentBlock[];
+}
+/**
+ * Whether a tagged submission still belongs to the active session. Attachment
+ * prepares resolve on the microtask timeline, while a queued session switch
+ * remounts the app asynchronously — the composing instance's unmount cleanup
+ * runs too late to abort, so the delivery itself carries the composing
+ * session's full id and the runner drops it here when the world moved on.
+ * An untagged (synchronous) or pending-session ('') submission always passes.
+ */
+export declare function submissionBelongsToSession(origin: string | undefined, activeSessionId: string | undefined): boolean;
+/**
+ * Order-preserving gate for composer input while the startup prompt/images
+ * are still preparing. Anything submitted before the startup delivery settles
+ * queues and flushes afterwards in submit order, so the initial request can
+ * never be overtaken by typing that raced a slow image preparation. The flush
+ * also runs when the startup delivery fails: user input is never stranded.
+ */
+export declare class StartupInputGate {
+    private readonly deliver;
+    private readonly queued;
+    private pending;
+    constructor(deliver: (submission: QueuedSubmission) => void);
+    /** Submit one line: delivered now while idle, queued behind the startup delivery otherwise. */
+    submit(submission: QueuedSubmission): void;
+    /**
+     * Run the startup delivery — the callback receives the direct-delivery sink
+     * for the startup prompt itself — then flush everything that queued behind
+     * it, in order, even when the callback rejects.
+     */
+    run(startup: (deliver: (submission: QueuedSubmission) => void) => Promise<void>): Promise<void>;
+}
+/**
+ * Resolve the invocation's target session against the persisted headers.
+ * @param startup - the parsed startup flags.
+ * @param persistence - the persistence service; required for resume/latest.
+ * @param cwd - the working directory `--continue` filters by.
+ * @returns the target identity.
+ * @throws with a user-facing message when the flags name nothing resolvable.
+ */
+export declare function resolveTarget(startup: TuiStartup, persistence: SessionPersistence | undefined, cwd: string): Promise<Target>;
+/**
+ * Mount the interactive terminal driver.
+ * @param ctx - plugin context carrying core services and the launcher-provided exit request.
+ * @param config - validated startup config resolved from the tuiStartup provider.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/vendor/tui/types/input-split.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Terminal input arrives as byte chunks, and one chunk can carry several
+ * keypresses: a fast space-then-enter, a bridged stdin that batches reads, a
+ * middle-click paste. Ink parses each chunk as exactly one keypress —
+ * `parseKeypress(' \r')` matches neither member, so both keys silently
+ * vanish (a multi-select question answered with an empty set). The splitter
+ * below cuts every chunk into the individual keypress units Ink's parser
+ * expects, keeping escape sequences and bracketed-paste blocks intact, and
+ * the stdin proxy feeds the split stream to the Ink mount.
+ *
+ * @module @deepseek-ai/dsh-tui/input-split
+ */
+import { PassThrough } from 'node:stream';
+/** One keypress cut from the input stream. */
+export interface KeypressSplitter {
+    /** Feed one chunk; returns every keypress unit this chunk completed. */
+    push(chunk: string): string[];
+    /** Whether an unterminated bracketed-paste block is currently held. */
+    openPaste(): boolean;
+    /**
+     * Last-resort escape hatch for a paste whose end marker never arrived:
+     * drop the start marker and emit the held bytes as plain keypress units so
+     * nothing (Esc and Ctrl+C included) stays hostage. Inert when no paste is
+     * open.
+     */
+    releaseStalePaste(): string[];
+}
+/**
+ * Build a stateful chunk splitter. A partial unit at the end of one chunk
+ * (a cut CSI sequence, an open paste block) waits in the buffer for the
+ * rest. A chunk-trailing lone ESC emits as the Escape key right away:
+ * terminals send Escape as its own chunk, and holding it hostage for a
+ * sequence that may never continue would break every Esc cancel.
+ */
+export declare function createKeypressSplitter(): KeypressSplitter;
+/** The stdin-shaped stream the Ink mount renders through. */
+export interface TuiStdin extends PassThrough {
+    /** Mirrors the real stdin so Ink's raw-mode gate passes. */
+    isTTY: boolean;
+    /** Forwarded to the real stdin; Ink toggles it around focus. */
+    setRawMode(value: boolean): unknown;
+    ref(): void;
+    unref(): void;
+}
+/**
+ * Wrap one real stdin in the splitting proxy: keypress units flow into a
+ * PassThrough Ink reads, while raw-mode/ref calls forward to the source.
+ * @param source - the process (or harness) input stream in raw mode.
+ * @returns the proxy stream plus a dispose that detaches the tap.
+ */
+export declare function createSplitStdin(source: NodeJS.ReadStream): {
+    stdin: TuiStdin;
+    dispose(): void;
+};

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

@@ -0,0 +1,26 @@
+/**
+ * Injectable process-facing effects for the TUI runner. Tests substitute the
+ * Ink mount with a capturing fake and the streams with string sinks, keeping
+ * the runner's lifecycle testable without a terminal.
+ *
+ * @module @deepseek-ai/dsh-tui/internals
+ */
+import type { ReactElement } from 'react';
+/** A mounted terminal app instance; the runner owns unmount ordering. */
+export interface TuiMount {
+    /** Replace the root element while preserving Ink's single terminal owner. */
+    rerender(element: ReactElement): void;
+    /** Tear the terminal app down before flush and exit. */
+    unmount(): void;
+}
+/** The Ink mount seam: renders the app element and returns its handle. */
+export type Mount = (element: ReactElement) => TuiMount;
+/** Substitutable runner effects; production values write to the real terminal. */
+export declare const internals: {
+    /** Ink renderer mount; tests substitute a fake that captures the element. */
+    mount: Mount;
+    /** Diagnostics stream for direct-driver failures. */
+    stderr: {
+        write(chunk: string): unknown;
+    };
+};

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

@@ -0,0 +1,15 @@
+/**
+ * Package-owned invariant companion for `dsh-code`.
+ * @module dsh-code/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "tui-invariant";
+/** Service required before the companion can register. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;

package/vendor/tui/types/kernel-panels.d.ts

@@ -0,0 +1,167 @@
+/** Bounded, composer-safe panels for preset, session, and plugin kernel views. */
+import { type ReactElement } from 'react';
+import type { ModelDirectory, ModelRow } from './models.ts';
+import type { SubagentRow } from './subagents.ts';
+import type { PermissionRow } from './permissions.ts';
+import type { PresetRow } from './presets.ts';
+import type { PluginRow } from './plugin-inventory.ts';
+import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
+import { type StatusItemId } from './render/status.ts';
+/**
+ * Apply one keystroke to a panel search query. IME commits arrive as one
+ * multi-character chunk, so the whole printable run is appended; paste
+ * markers are stripped and control-laden chunks are ignored.
+ */
+export declare function editQuery(query: string, input: string, key: {
+    backspace?: boolean;
+    delete?: boolean;
+}): string | undefined;
+export declare function ModePanel({ current, load, select, close }: {
+    current: string;
+    load(): Promise<readonly PresetRow[]>;
+    select(id: string): void;
+    close(): void;
+}): ReactElement;
+export declare function PermissionPanel({ current, load, select, close }: {
+    current: string;
+    load(): Promise<readonly PermissionRow[]>;
+    select(id: string): void;
+    close(): void;
+}): ReactElement;
+export declare function PluginPanel({ load, close, initialQuery }: {
+    load(): readonly PluginRow[];
+    close(): void;
+    initialQuery?: string;
+}): ReactElement;
+/** One background job snapshot for the /jobs panel (the registry's read-only view). */
+export interface JobRow {
+    /** The registry-issued id (`<kind>-N`). */
+    readonly id: string;
+    /** Producer kind (bash, subagent, …). */
+    readonly kind: string;
+    /** One-line model-facing label (the command; the delegation description). */
+    readonly label: string;
+    /** Lifecycle state. */
+    readonly status: 'running' | 'stopping' | 'completed' | 'killed' | 'failed';
+    /** Kind-specific status detail once the producer supplied one. */
+    readonly detail?: string;
+    /** Epoch ms when the job was registered. */
+    readonly startedAt: number;
+    /** Epoch ms when the job settled; absent while running/stopping. */
+    readonly finishedAt?: number;
+}
+/** Web TurnStatus elapsed format: `45s` under a minute, `2m03s` beyond. */
+export declare function runClock(ms: number): string;
+/**
+ * The read-only background-job panel: caller-owned and unowned jobs from the
+ * host `jobs` registry in registration order, with a local second-hand while
+ * the panel is open (elapsed clocks advance and the snapshot re-reads; the
+ * interval dies with the panel). Cancel stays upstream-only; an absent
+ * registry renders as the plain empty state (a harmless missing service).
+ */
+export declare function JobsPanel({ load, close }: {
+    load(): readonly JobRow[];
+    close(): void;
+}): ReactElement;
+export declare function ResumePanel({ currentCwd, load, readTranscript, select, requestDelete, deleteConfirmId, reloadToken, deleteMode, close }: {
+    currentCwd: string;
+    load(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
+    readTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    select(row: SessionRow): void;
+    /** Arm the composer-based delete confirm for one row (App owns the keys). */
+    requestDelete?(row: SessionRow): void;
+    /** The row id awaiting y/n in the composer, when any (App-owned). */
+    deleteConfirmId?: string;
+    /** Bump to reload the listing (e.g. after a deletion). */
+    reloadToken?: number;
+    /** Opened via /delete: hint-first delete mode. */
+    deleteMode?: boolean;
+    close(): void;
+}): ReactElement;
+/**
+ * The /history recall panel (Codex composer-history search, bounded): one
+ * query line over the newest-first recall space, filtered by substring, with
+ * arrow selection and enter to fill the composer. Editing the query restarts
+ * from the newest match; Esc closes without touching the draft.
+ */
+export declare function HistoryPanel({ entries, fill, close }: {
+    /** Newest-first recall entries (persistent + in-session, deduped). */
+    entries: readonly string[];
+    /** Accept one entry: its text plus its recall-space index (browsing resumes there). */
+    fill(text: string, index: number): void;
+    close(): void;
+}): ReactElement;
+/**
+ * The /statusline picker (the Codex setup-view contract): one bounded list
+ * of every status item with its enabled mark, arrow reordering, and a
+ * live preview — the real status line under the composer updates as you
+ * edit, so the panel itself carries no duplicate preview row.
+ */
+export declare function StatuslinePanel({ enabled, change, close }: {
+    enabled: readonly StatusItemId[];
+    change(items: readonly StatusItemId[]): void;
+    close(): void;
+}): ReactElement;
+/**
+ * The `/model` reasoning-effort stage (the Codex model → reasoning popup
+ * contract): one bounded list over the selected model's adapter-advertised
+ * effort levels — in the adapter's own display order, ids verbatim (the
+ * kernel treats them as opaque and rejects anything else) — with the
+ * effective effort and the model default marked. A model WITHOUT an
+ * adapter-declared default leads with a "Default" (provider-default) row —
+ * the web effort pane's first entry — so the user can clear a picked level
+ * back to provider behavior. A model advertising no levels opens the same
+ * stage with an explicit empty state (the web pane's "no levels" copy)
+ * instead of a bare failure notice. Enter applies one level; Esc returns to
+ * the model list without applying.
+ */
+export declare function EffortPanel({ row, current, select, back, onExit }: {
+    /** The model row whose advertised levels this stage lists. */
+    row: ModelRow;
+    /** Effective effort currently in force ('' when none), for the ● mark. */
+    current: string | undefined;
+    /** Accept one advertised effort id, or '' for the provider default. */
+    select(effortId: string): void;
+    /** Return to the model list without applying. */
+    back(): void;
+    /** Leave the whole /model flow (Ctrl+C). */
+    onExit(): void;
+}): ReactElement;
+/**
+ * The /agents panel (the Codex agent-picker contract, read-only): this
+ * conversation's subagent conversations — live rows from the activity feed
+ * first, persisted children the feed has not seen this process after — with
+ * Enter/t opening the child's full transcript in the shared read-only
+ * document view (the same projection the exporter uses).
+ */
+export declare function AgentsPanel({ live, load, readTranscript, close }: {
+    /** Live feed rows (child sessions observed this process). */
+    live: readonly SubagentRow[];
+    /** Load this session's persisted child sessions by lineage. */
+    load(): Promise<readonly SessionRow[]>;
+    /** Read one child session's full transcript as markdown. */
+    readTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    close(): void;
+}): ReactElement;
+/**
+ * The /subagent model panel: which model configuration delegated subagents
+ * run on. The kernel seeds child agents from the parent's CREATE-TIME
+ * AgentOptions, so a mid-session /model switch would otherwise leave them on
+ * the launch-time route; the TUI mirrors the selection onto subagent-origin
+ * requests (or an explicit override picked here) via an agent/request
+ * listener. The leading "inherit" row restores follow-the-current-model
+ * behavior; picking a model with several advertised efforts opens the same
+ * effort stage /model uses. Effort overrides are not offered separately —
+ * the kernel's AgentOptions has no effort channel for children, so the level
+ * rides the selected model exactly as /model applies it.
+ */
+export declare function SubagentPanel({ current, load, pick, inherit, close }: {
+    /** Display label of the override in force, '' when following the current model. */
+    current: string;
+    load(): Promise<ModelDirectory>;
+    /** Apply one model (with an advertised effort, when picked) as the override. */
+    pick(row: ModelRow, effortId?: string): void;
+    /** Drop the override: subagents follow the current model again. */
+    inherit(): void;
+    close(): void;
+}): ReactElement;

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

@@ -0,0 +1,80 @@
+/**
+ * Keyboard enhancement protocol (Codex `keyboard_modes` parity) and the
+ * kitty CSI-u normalization layer.
+ *
+ * The TUI pushes the kitty keyboard protocol with DISAMBIGUATE_ESCAPE_CODES
+ * and REPORT_ALTERNATE_KEYS (flags 1|4 = `\x1b[>5u`). Event types are
+ * deliberately NOT requested: Ink 5's parser cannot decode the
+ * `:event-type` suffix, and repeat/release reporting buys this surface
+ * nothing.
+ *
+ * Ink 5 also cannot parse most CSI-u forms at all — they fall through its
+ * regex as unnamed sequences and get INSERTED AS DRAFT TEXT. The composer's
+ * stdin read patch therefore rewrites every CSI-u form it can decode back
+ * to the legacy byte or canonical sequence the existing key handling
+ * already understands, before Ink ever parses the chunk.
+ * @module @deepseek-ai/dsh-code/keyboard
+ */
+/** Push keyboard enhancement (modifyOtherKeys off, kitty flags 1|4). */
+export declare const KEYBOARD_ENHANCE_ENABLE = "\u001B[>4;0m\u001B[>5u";
+/** Pop the enhancement stack and reset modifyOtherKeys (exit path). */
+export declare const KEYBOARD_ENHANCE_DISABLE = "\u001B[<u\u001B[>4;0m";
+/** Explicit environment overrides for terminal keyboard enhancement. */
+export declare const DSH_DISABLE_KEYBOARD_ENHANCEMENT = "DSH_DISABLE_KEYBOARD_ENHANCEMENT";
+export declare const DSH_ENABLE_KEYBOARD_ENHANCEMENT = "DSH_ENABLE_KEYBOARD_ENHANCEMENT";
+/** True when the process is running inside the VS Code integrated terminal. */
+export declare function isVsCodeTerminalEnv(env?: NodeJS.ProcessEnv): boolean;
+/** Whether to push Kitty keyboard enhancement for the current terminal. */
+export declare function shouldEnableKeyboardEnhancement(env?: NodeJS.ProcessEnv): boolean;
+/** Enable bracketed paste reporting. */
+export declare const BRACKETED_PASTE_ENABLE = "\u001B[?2004h";
+/** Disable bracketed paste reporting. */
+export declare const BRACKETED_PASTE_DISABLE = "\u001B[?2004l";
+/** Enable terminal focus-in/focus-out reporting (xterm focus protocol). */
+export declare const TERMINAL_FOCUS_REPORT_ENABLE = "\u001B[?1004h";
+/** Disable terminal focus-in/focus-out reporting. */
+export declare const TERMINAL_FOCUS_REPORT_DISABLE = "\u001B[?1004l";
+/**
+ * Remove xterm focus reports from one input chunk and update the caller's
+ * focus state. Focus reports are terminal protocol, not composer text.
+ */
+export declare function stripTerminalFocusEvents(chunk: string, onFocus: (focused: boolean) => void): string;
+/** Bracketed paste markers as Ink delivers them (it strips the leading ESC). */
+export declare const PASTE_START_MARKER = "[200~";
+export declare const PASTE_END_MARKER = "[201~";
+/**
+ * How long an unterminated bracketed-paste block may hold buffered bytes
+ * before the input splitter strips its start marker and releases them: a
+ * terminal that loses the end marker must never take the whole keyboard
+ * hostage (Esc/Ctrl+C included). Shared by the splitter and the composer's
+ * lost-paste safety net so both use one window.
+ */
+export declare const PASTE_BRACKET_TIMEOUT_MS = 1000;
+/**
+ * Remove bracketed paste markers from one input chunk. Panel drafts accept raw
+ * `input` text, where an unhandled paste would otherwise persist the literal
+ * "[200~"/"[201~" markers Ink leaves after stripping the ESC byte.
+ */
+export declare function stripPasteMarkers(text: string): string;
+/**
+ * Rewrite every decodable kitty CSI-u sequence in one stdin chunk to the
+ * legacy form the input layer already handles. Undecodable or non-key
+ * sequences pass through untouched, so terminals without the protocol are
+ * unaffected.
+ */
+export declare function normalizeKeyboardChunk(chunk: string): string;
+/** Editor actions Ink cannot distinguish reliably when terminal bytes batch. */
+export type RawEditorToken = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'home' | 'end' | 'delete-backward' | 'delete-word-backward' | 'delete-forward' | 'delete-word-forward';
+};
+/**
+ * Tokenize a stdin chunk containing at least one editor-only key. Ink calls
+ * `useInput` once for a pasted/batched chunk, so preserving each action here
+ * prevents repeated Backspace/Home/End/Delete presses from collapsing into
+ * one blurred key event. Unknown escape sequences return undefined and stay
+ * under Ink's ownership.
+ */
+export declare function tokenizeRawEditorChunk(chunk: string): readonly RawEditorToken[] | undefined;