@askdkc/dsh-cli 0.11.3

package/lib/types/ink/ink.d.ts

@@ -0,0 +1,571 @@
+import { type ReactNode } from 'react';
+import * as dom from './dom.js';
+import type { DragEvent } from './events/drag-event.js';
+import { FocusManager } from './focus.js';
+import { type FrameEvent } from './frame.js';
+import type { ParsedKey } from './parse-keypress.js';
+import { type MatchPosition } from './render-to-screen.js';
+import { type FocusMove, type SelectionState } from './selection.js';
+export type Options = {
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    stderr: NodeJS.WriteStream;
+    exitOnCtrlC: boolean;
+    patchConsole: boolean;
+    terminalImages?: boolean;
+    waitUntilExit?: () => Promise<void>;
+    onFrame?: (event: FrameEvent) => void;
+};
+export default class Ink {
+    private readonly options;
+    private readonly log;
+    private readonly terminal;
+    private readonly kittyGraphicsManager;
+    private readonly sixelGraphicsManager;
+    private sixelGraphicsSupported;
+    private kittyGraphicsSupported;
+    private kittyGraphicsProbeStarted;
+    private terminalImageRequests;
+    private measuredImageCellSize;
+    private readonly terminalImageListeners;
+    private readonly terminalImages;
+    private terminalCellMetricsInFlight;
+    private terminalCellMetricsRefreshPending;
+    private terminalQueryResumeTimer;
+    private app;
+    private scheduleRender;
+    private isUnmounted;
+    private isPaused;
+    private readonly container;
+    private rootNode;
+    readonly focusManager: FocusManager;
+    private renderer;
+    private readonly stylePool;
+    private charPool;
+    private hyperlinkPool;
+    private exitPromise?;
+    private restoreConsole?;
+    private restoreStderr?;
+    private readonly unsubscribeTTYHandlers?;
+    private terminalColumns;
+    private terminalRows;
+    private currentNode;
+    private frontFrame;
+    private backFrame;
+    private lastPoolResetTime;
+    private drainTimer;
+    private renderGeneration;
+    private pendingRenderGeneration;
+    private lastYogaCounters;
+    private altScreenParkPatch;
+    readonly selection: SelectionState;
+    private searchHighlightQuery;
+    private searchPositions;
+    private readonly selectionListeners;
+    private readonly hoveredNodes;
+    private altScreenActive;
+    private altScreenMouseTracking;
+    private mainScreenFrameState;
+    private prevFrameContaminated;
+    private needsSurfaceRepaint;
+    private needsEraseBeforePaint;
+    private cursorDeclaration;
+    private displayCursor;
+    private handleStdinError;
+    constructor(options: Options);
+    private handleResume;
+    private handleResize;
+    resolveExitPromise: () => void;
+    rejectExitPromise: (reason?: Error) => void;
+    unsubscribeExit: () => void;
+    /**
+     * Pause Ink and hand the terminal over to an external TUI (e.g. git
+     * commit editor). In non-fullscreen mode this enters the alt screen;
+     * in fullscreen mode we're already in alt so we just clear it.
+     * Call `exitAlternateScreen()` when done to restore Ink.
+     */
+    enterAlternateScreen(): void;
+    /**
+     * Resume Ink after an external TUI handoff with a full repaint.
+     * In non-fullscreen mode this exits the alt screen back to main;
+     * in fullscreen mode we re-enter alt and clear + repaint.
+     *
+     * The re-enter matters: terminal editors (vim, nano, less) write
+     * smcup/rmcup (?1049h/?1049l), so even though we started in alt,
+     * the editor's rmcup on exit drops us to main screen. Without
+     * re-entering, the 2J below wipes the user's main-screen scrollback
+     * and subsequent renders land in main — native terminal scroll
+     * returns, fullscreen scroll is dead.
+     */
+    exitAlternateScreen(): void;
+    /**
+     * One-shot viewport re-anchor for the NEXT main-screen frame: repaint the
+     * visible viewport in place instead of diffing. Exposed for callers that
+     * know a layout flip just rewrote the whole frame (Ctrl+O transcript
+     * toggle): the ordinary scroll-based diff pushes rows into terminal
+     * scrollback on every expand and nothing removes them on collapse — rapid
+     * toggles drift the virtual↔scrollback mapping until writes misland.
+     * In-place repaint adds nothing to scrollback. No-op in alt-screen
+     * (already CSI H-anchored every frame). ONLY sets the flag: the caller's
+     * own state change (setExpanded) drives the render that consumes it —
+     * forcing an extra render here would paint the OLD layout once more and
+     * burn the flag before the real frame lands.
+     */
+    reanchorViewport(): void;
+    /** Render synchronously and invalidate older trailing/drain callbacks. */
+    private renderNow;
+    /**
+     * Drain scrolling at quarter-frame cadence while keeping queued output
+     * bounded on slow terminals. React-driven updates retain their normal
+     * throttle, so typing and streaming do not wait behind a scroll backlog.
+     */
+    private scheduleDrain;
+    onRender(): void;
+    pause(): void;
+    resume(): void;
+    /**
+     * Reset frame buffers so the next render writes the full screen from scratch.
+     * Call this before resume() when the terminal content has been corrupted by
+     * an external process (e.g. tmux, shell, full-screen TUI).
+     */
+    repaint(): void;
+    /**
+     * Clear the physical terminal and force a full redraw.
+     *
+     * The traditional readline ctrl+l — clears the visible screen and
+     * redraws the current content. Also the recovery path when the terminal
+     * was cleared externally (macOS Cmd+K) and Ink's diff engine thinks
+     * unchanged cells don't need repainting. Scrollback is preserved.
+     */
+    forceRedraw(): void;
+    /**
+     * Establish a genuinely fresh terminal page: clear both the visible screen
+     * and native scrollback, reset frame correspondence, then redraw the current
+     * React tree. This is intentionally stronger than Ctrl+L/forceRedraw(),
+     * which preserves history; use it only at a destructive UI boundary such as
+     * `/new`, where showing the previous conversation above the new session is
+     * misleading.
+     */
+    clearScrollbackAndRedraw(): void;
+    /**
+     * Mark the previous frame as untrustworthy for blit, forcing the next
+     * render to do a full-damage diff instead of the per-node fast path.
+     *
+     * Lighter than forceRedraw() — no screen clear, no extra write. Call
+     * from a useLayoutEffect cleanup when unmounting a tall overlay: the
+     * blit fast path can copy stale cells from the overlay frame into rows
+     * the shrunken layout no longer reaches, leaving a ghost title/divider.
+     * onRender resets the flag at frame end so it's one-shot.
+     */
+    invalidatePrevFrame(): void;
+    /**
+     * Called by the <AlternateScreen> component on mount/unmount.
+     * Controls cursor.y clamping in the renderer and gates alt-screen-aware
+     * behavior in SIGCONT/resize/unmount handlers. The first alt-screen frame
+     * redraws from blank; exit restores the saved main frame for a physical-
+     * screen-matched diff, with repaint as the resize fallback.
+     */
+    setAltScreenActive(active: boolean, mouseTracking?: boolean): void;
+    get isAltScreenActive(): boolean;
+    /**
+     * Re-assert terminal modes after a gap (>5s stdin silence or event-loop
+     * stall). Catches tmux detach→attach, ssh reconnect, and laptop
+     * sleep/wake — none of which send SIGCONT. The terminal may reset DEC
+     * private modes on reconnect; this method restores them.
+     *
+     * Always re-asserts extended key reporting and mouse tracking. Mouse
+     * tracking is idempotent (DEC private mode set-when-set is a no-op). The
+     * Kitty keyboard protocol is NOT — CSI >1u is a stack push, so we pop
+     * first to keep depth balanced (pop on empty stack is a no-op per spec,
+     * so after a terminal reset this still restores depth 0→1). Without the
+     * pop, each >5s idle gap adds a stack entry, and the single pop on exit
+     * or suspend can't drain them — the shell is left in CSI u mode where
+     * Ctrl+C/Ctrl+D leak as escape sequences. The alt-screen
+     * re-entry (ERASE_SCREEN + frame reset) is NOT idempotent — it blanks the
+     * screen — so it's opt-in via includeAltScreen. The stdin-gap caller fires
+     * on ordinary >5s idle + keypress and must not erase; the event-loop stall
+     * detector fires on genuine sleep/wake and opts in. tmux attach / ssh
+     * reconnect typically send a resize, which already covers alt-screen via
+     * handleResize.
+     */
+    reassertTerminalModes: (includeAltScreen?: boolean) => void;
+    /**
+     * Mark this instance as unmounted so future unmount() calls early-return.
+     * Called by gracefulShutdown's cleanupTerminalModes() after it has sent
+     * EXIT_ALT_SCREEN but before the remaining terminal-reset sequences.
+     * Without this, signal-exit's deferred ink.unmount() (triggered by
+     * process.exit()) runs the full unmount path: onRender() + writeSync
+     * cleanup block + updateContainerSync → AlternateScreen unmount cleanup.
+     * The result is 2-3 redundant EXIT_ALT_SCREEN sequences landing on the
+     * main screen AFTER printResumeHint(), which tmux (at least) interprets
+     * as restoring the saved cursor position — clobbering the resume hint.
+     */
+    detachForShutdown(): void;
+    /**
+     * Fully detach stdin before handing the terminal to a child process that
+     * inherits it (the /update restart). `detachForShutdown()` restores
+     * cooked mode but leaves the App's 'readable' pump attached — ordinary
+     * exits don't care because the process dies right after, but a parent
+     * that lingers waiting on the child keeps a libuv read pending on the
+     * console and races the child for every keypress: the restarted TUI
+     * sees dropped or entirely swallowed input (issues #284/#307). Remove
+     * the listeners and pause the pump so the child is the sole reader.
+     */
+    detachStdinForHandoff(): void;
+    /** @see drainStdin */
+    drainStdin(): void;
+    /**
+     * Self-heal after a terminal-side mode reset. Windows conpty drops DEC
+     * private modes on DPI changes, window moves between monitors and renderer
+     * restarts — the user sees the app "exit fullscreen" with a dead mouse
+     * while altScreenActive still claims we are in alt. Two layers:
+     *
+     * 1. Blind, idempotent mouse-tracking re-assert (covers the mode reset
+     *    without a round trip; ~30 bytes).
+     * 2. DECRQM probe of mode 1049. Re-entry (destructive: ERASE) happens
+     *    ONLY on a positive "reset" answer, so iTerm2's
+     *    enter-clears-when-already-in-alt quirk can never fire on a healthy
+     *    screen, and terminals that ignore DECRQM stay inert.
+     *
+     * Called from every interaction dispatch (click/hover/wheel/key) plus the
+     * focus/resize/stdin-gap triggers. The 250ms throttle keeps the round
+     * trip bounded while active use is going on — a dropped 1049 heals on
+     * the FIRST interaction after the drop instead of waiting for a focus
+     * event or a >5s idle gap (mouse motion keeps lastStdinTime fresh, so
+     * the gap path never fires during active use — the exact pattern that
+     * left the app broken until the user gave up).
+     */
+    private lastHealthProbeAt;
+    /**
+     * True while a mouse button is held (press seen, no release/reset yet).
+     * Set by App via setPointerGestureActive. The health probe must not write
+     * while a gesture is in flight: the blind ENABLE_MOUSE_TRACKING re-assert
+     * mid-drag resets button tracking on some emulators (WezTerm, xterm.js
+     * family), silently killing the gesture's motion stream, and a DECRQM
+     * "1049 reset" reply resolving mid-drag would erase the screen under the
+     * user's pointer.
+     */
+    private pointerGestureActive;
+    /**
+     * Protocol-candidate latch: an SGR mouse prefix is in flight (parser hold
+     * or tokenizer incomplete buffer). Cleared by App on any complete event
+     * (mouse or key), ordinary text, paste/response boundary, or the 1s hold
+     * deadline. Distinct from pointerGestureActive: a split wheel report
+     * resolves to a ParsedKey (no physical button), and a stale candidate
+     * must not leave the probe permanently blocked.
+     */
+    private protocolCandidateActive;
+    /**
+     * Set when a DECRPM reply confirmed "1049 reset" while a gesture was
+     * latched. The re-entry (ENTER_ALT_SCREEN + ERASE_SCREEN + mouse
+     * re-assert) is destructive mid-drag — it erases the screen under the
+     * user's pointer and resets button tracking — so it is deferred to the
+     * gesture's end and drained by setPointerGestureActive(false).
+     */
+    private pendingAltScreenReentry;
+    /**
+     * Set when probeAltScreenHealth was blocked by an active gesture. The
+     * probe is retried at the release tail (drainAltScreenReentry) with the
+     * original caller's skipMouseReassert semantics.
+     */
+    private pendingProbeRequest;
+    setPointerGestureActive: (active: boolean) => void;
+    setProtocolCandidateActive: (active: boolean) => void;
+    /**
+     * Execute a deferred alt-screen re-entry, if one was confirmed while a
+     * gesture was latched. Called by App after the release tail completes.
+     * Only clears the pending flag when the re-entry actually runs — a pause
+     * or alt-screen exit during the gesture keeps the recovery signal alive
+     * for the next safe boundary (resume, focus, or a later release).
+     */
+    drainAltScreenReentry: () => void;
+    /**
+     * Retry a health probe that was blocked by an active gesture. Called by
+     * App after the release tail completes, with the original caller's
+     * skipMouseReassert semantics preserved. The request is cleared ONLY
+     * after the probe actually writes — a throttle hit keeps it pending and
+     * schedules a retry once the 250ms window expires.
+     */
+    drainPendingProbe: () => void;
+    /**
+     * Combined drain for the release tail: re-entry first (destructive),
+     * then the blocked probe retry (may discover a new 1049 loss and
+     * schedule the NEXT re-entry).
+     */
+    drainReleaseTail: () => void;
+    probeAltScreenHealth: (options?: {
+        skipMouseReassert?: boolean;
+    }) => void;
+    /** Refocus = first observable moment after a conpty-side mode reset. */
+    handleTerminalFocusProbe: (focused: boolean) => void;
+    private notifyTerminalImagesChange;
+    /** Probe on image demand, before lazy consumers need to decode a source. */
+    private maybeProbeKittyGraphics;
+    /** Refresh image pixel geometry after a resize, coalescing resize bursts. */
+    private refreshTerminalCellMetrics;
+    /** Reopen terminal queries only after late handoff replies are quarantined. */
+    private resumeTerminalQueriesAfterHandoff;
+    private get terminalQueriesSuspended();
+    /**
+     * Re-enter alt-screen, clear, home, re-enable mouse tracking, and reset
+     * frame buffers so the next render repaints from scratch. Self-heal for
+     * SIGCONT, resize, and stdin-gap/event-loop-stall (sleep/wake) — any of
+     * which can leave the terminal in main-screen mode while altScreenActive
+     * stays true. ENTER_ALT_SCREEN is a terminal-side no-op if already in alt.
+     */
+    private reenterAltScreen;
+    /**
+     * Seed prev/back frames with full-size BLANK screens (rows×cols of empty
+     * cells, not 0×0). In alt-screen mode, next.screen.height is always
+     * terminalRows; if prev.screen.height is 0 (emptyFrame's default),
+     * log-update sees heightDelta > 0 ('growing') and calls renderFrameSlice,
+     * whose trailing per-row CR+LF at the last row scrolls the alt screen,
+     * permanently desyncing the virtual and physical cursors by 1 row.
+     *
+     * With a rows×cols blank prev, heightDelta === 0 → standard diffEach
+     * → moveCursorTo (CSI cursorMove, no LF, no scroll).
+     *
+     * viewport.height = rows + 1 matches the renderer's alt-screen output,
+     * preventing a spurious resize trigger on the first frame. cursor.y = 0
+     * matches the physical cursor after ENTER_ALT_SCREEN + CSI H (home).
+     */
+    private resetFramesForAltScreen;
+    /**
+     * Copy the current selection to the clipboard without clearing the
+     * highlight. Matches iTerm2's copy-on-select behavior where the selected
+     * region stays visible after the automatic copy.
+     */
+    copySelectionNoClear(): string;
+    /**
+     * Copy the current text selection to the system clipboard via OSC 52
+     * and clear the selection. Returns the copied text (empty if no selection).
+     */
+    copySelection(): string;
+    /** Clear the current text selection without copying. */
+    clearTextSelection(): void;
+    /**
+     * Set the search highlight query. Non-empty → all visible occurrences
+     * are inverted (SGR 7) on the next frame; first one also underlined.
+     * Empty → clears (prevFrameContaminated handles the frame after). Same
+     * damage-tracking machinery as selection — setCellStyleId doesn't track
+     * damage, so the overlay forces full-frame damage while active.
+     */
+    setSearchHighlight(query: string): void;
+    /** Paint an EXISTING DOM subtree to a fresh Screen at its natural
+     *  height, scan for query. Returns positions relative to the element's
+     *  bounding box (row 0 = element top).
+     *
+     *  The element comes from the MAIN tree — built with all real
+     *  providers, yoga already computed. We paint it to a fresh buffer
+     *  with offsets so it lands at (0,0). Same paint path as the main
+     *  render. Zero drift. No second React root, no context bridge.
+     *
+     *  ~1-2ms (paint only, no reconcile — the DOM is already built). */
+    scanElementSubtree(el: dom.DOMElement): MatchPosition[];
+    /** Set the position-based highlight state. Every frame, writes CURRENT
+     *  style at positions[currentIdx] + rowOffset. null clears. The scan-
+     *  highlight (inverse on all matches) still runs — this overlays yellow
+     *  on top. rowOffset changes as the user scrolls (= message's current
+     *  screen-top); positions stay stable (message-relative). */
+    setSearchPositions(state: {
+        positions: MatchPosition[];
+        rowOffset: number;
+        currentIdx: number;
+    } | null): void;
+    /**
+     * Set the selection highlight background color. Replaces the per-cell
+     * SGR-7 inverse with a solid theme-aware bg (matches native terminal
+     * selection). Accepts the same color formats as Text backgroundColor
+     * (rgb(), ansi:name, #hex, ansi256()) — colorize() routes through
+     * chalk so the tmux/xterm.js level clamps in colorize.ts apply and
+     * the emitted SGR is correct for the current terminal.
+     *
+     * Called by React-land once theme is known (ScrollKeybindingHandler's
+     * useEffect watching useTheme). Before that call, withSelectionBg
+     * falls back to withInverse so selection still renders on the first
+     * frame; the effect fires before any mouse input so the fallback is
+     * unobservable in practice.
+     */
+    /**
+     * The colour a backdrop shade (`<Box backdrop="dim">`) fades explicit
+     * colours toward — the terminal background from OSC 11, or black/white
+     * by theme lightness when unknown. See StylePool.setShadeTarget.
+     */
+    setShadeTarget(rgb: {
+        r: number;
+        g: number;
+        b: number;
+    } | null): void;
+    setSelectionBgColor(color: string): void;
+    /**
+     * Capture text from rows about to scroll out of the viewport during
+     * drag-to-scroll. Must be called BEFORE the ScrollBox scrolls so the
+     * screen buffer still holds the outgoing content. Accumulated into
+     * the selection state and joined back in by getSelectedText.
+     */
+    captureScrolledRows(firstRow: number, lastRow: number, side: 'above' | 'below'): void;
+    /**
+     * Shift anchor AND focus by dRow, clamped to [minRow, maxRow]. Used by
+     * keyboard scroll handlers (PgUp/PgDn etc.) so the highlight tracks the
+     * content instead of disappearing. Unlike shiftAnchor (drag-to-scroll),
+     * this moves BOTH endpoints — the user isn't holding the mouse at one
+     * edge. Supplies screen.width for the col-reset-on-clamp boundary.
+     */
+    shiftSelectionForScroll(dRow: number, minRow: number, maxRow: number): void;
+    /**
+     * Keyboard selection extension (shift+arrow/home/end). Moves focus;
+     * anchor stays fixed so the highlight grows or shrinks relative to it.
+     * Left/right wrap across row boundaries — native macOS text-edit
+     * behavior: shift+left at col 0 wraps to end of the previous row.
+     * Up/down clamp at viewport edges (no scroll-to-extend yet). Drops to
+     * char mode. No-op outside alt-screen or without an active selection.
+     */
+    moveSelectionFocus(move: FocusMove): void;
+    /** Whether there is an active text selection. */
+    hasTextSelection(): boolean;
+    /**
+     * Subscribe to selection state changes. Fires whenever the selection
+     * is started, updated, cleared, or copied. Returns an unsubscribe fn.
+     */
+    subscribeToSelectionChange(cb: () => void): () => void;
+    private notifySelectionChange;
+    /**
+     * Hit-test the rendered DOM tree at (col, row) and bubble a ClickEvent
+     * from the deepest hit node up through ancestors with onClick handlers.
+     * Returns true if a DOM handler consumed the click. Gated on
+     * altScreenActive — clicks only make sense with a fixed viewport where
+     * nodeCache rects map 1:1 to terminal cells (no scrollback offset).
+     * The button byte is the raw SGR release code; its modifier bits land
+     * on ClickEvent.shift/alt/ctrl.
+     */
+    /** Batch-tail probe for release-path clicks that deferred via deferProbe. */
+    clickProbeAtBatchTail: () => void;
+    dispatchClick(col: number, row: number, button?: number, deferProbe?: boolean): boolean;
+    /**
+     * Hit-test the rendered DOM tree at (col, row) and bubble a
+     * ContextMenuEvent from the deepest hit node up through ancestors with
+     * onContextMenu handlers. Returns true if a DOM handler consumed it.
+     * Gated on altScreenActive like dispatchClick. The button byte is the
+     * raw SGR press code; its low bits are 2 for the right button and the
+     * modifier bits land on ContextMenuEvent.shift/alt/ctrl.
+     */
+    dispatchContextMenu(col: number, row: number, button?: number): boolean;
+    /**
+     * Route a wheel event to the ScrollBox (any onWheel handler) under the
+     * pointer. Returns true when a handler consumed it, so App can skip the
+     * legacy global wheel-key path and exactly one layer scrolls. Gated on
+     * altScreenActive like dispatchClick — without mouse tracking there are
+     * no wheel coordinates to route by.
+     */
+    dispatchWheelAt(col: number, row: number, deltaY: number, deltaX?: number, button?: number): boolean;
+    dispatchHover(col: number, row: number): void;
+    /**
+     * Drag protocol entry: find the drag target at an unmodified left
+     * press — the deepest node at (col, row) whose ancestor chain carries
+     * an onDragStart handler. Gated on altScreenActive like dispatchClick
+     * (drag needs mouse tracking + a fixed viewport). Returns null when no
+     * drag target is under the pointer, in which case App keeps the
+     * baseline selection/click path untouched.
+     */
+    findDragTargetAt(col: number, row: number): dom.DOMElement | null;
+    /**
+     * Dispatch a drag event to the drag session target captured at press
+     * time (bubbles through its ancestors). Gated on altScreenActive like
+     * dispatchClick.
+     */
+    dispatchDrag(target: dom.DOMElement, event: DragEvent): void;
+    dispatchKeyboardEvent(parsedKey: ParsedKey): void;
+    /**
+     * Look up the URL at (col, row) in the current front frame. Checks for
+     * an OSC 8 hyperlink first, then falls back to scanning the row for a
+     * plain-text URL (mouse tracking intercepts the terminal's native
+     * Cmd+Click URL detection, so we replicate it). This is a pure lookup
+     * with no side effects — call it synchronously at click time so the
+     * result reflects the screen the user actually clicked on, then defer
+     * the browser-open action via a timer.
+     */
+    getHyperlinkAt(col: number, row: number): string | undefined;
+    /**
+     * Optional callback fired when clicking an OSC 8 hyperlink in fullscreen
+     * mode. Set by FullscreenLayout via useLayoutEffect.
+     */
+    onHyperlinkClick: ((url: string) => void) | undefined;
+    /**
+     * Stable prototype wrapper for onHyperlinkClick. Passed to <App> as
+     * onOpenHyperlink so the prop is a bound method (autoBind'd) that reads
+     * the mutable field at call time — not the undefined-at-render value.
+     */
+    openHyperlink(url: string): void;
+    /**
+     * Handle a double- or triple-click at (col, row): select the word or
+     * line under the cursor by reading the current screen buffer. Called on
+     * PRESS (not release) so the highlight appears immediately and drag can
+     * extend the selection word-by-word / line-by-line. Falls back to
+     * char-mode startSelection if the click lands on a noSelect cell.
+     */
+    handleMultiClick(col: number, row: number, count: 2 | 3): void;
+    /**
+     * Handle a drag-motion at (col, row). In char mode updates focus to the
+     * exact cell. In word/line mode snaps to word/line boundaries so the
+     * selection extends by word/line like native macOS. Gated on
+     * altScreenActive for the same reason as dispatchClick.
+     */
+    handleSelectionDrag(col: number, row: number): void;
+    private stdinListeners;
+    private wasRawMode;
+    suspendStdin(): void;
+    resumeStdin(): void;
+    private writeRaw;
+    private setCursorDeclaration;
+    private setAppRef;
+    render(node: ReactNode): void;
+    unmount(error?: Error | number | null): void;
+    waitUntilExit(): Promise<void>;
+    resetLineCount(): void;
+    /**
+     * Replace char/hyperlink pools with fresh instances to prevent unbounded
+     * growth during long sessions. Migrates the front frame's screen IDs into
+     * the new pools so diffing remains correct. The back frame doesn't need
+     * migration — resetScreen zeros it before any reads.
+     *
+     * Call between conversation turns or periodically.
+     */
+    resetPools(): void;
+    patchConsole(): () => void;
+    /**
+     * Intercept process.stderr.write so stray writes (config.ts, hooks.ts,
+     * third-party deps) don't corrupt the alt-screen buffer. patchConsole only
+     * hooks console.* methods — direct stderr writes bypass it, land at the
+     * parked cursor, scroll the alt-screen, and desync frontFrame from the
+     * physical terminal. Next diff writes only changed-in-React cells at
+     * absolute coords → interleaved garbage.
+     *
+     * Swallows the write (routes text to the debug log) and, in alt-screen,
+     * forces a full-damage repaint as a defensive recovery. Not patching
+     * process.stdout — Ink itself writes there.
+     */
+    private patchStderr;
+}
+/**
+ * Discard pending stdin bytes so in-flight escape sequences (mouse tracking
+ * reports, bracketed-paste markers) don't leak to the shell after exit.
+ *
+ * Two layers of trickiness:
+ *
+ * 1. setRawMode is termios, not fcntl — the stdin fd stays blocking, so
+ *    readSync on it would hang forever. Node doesn't expose fcntl, so we
+ *    open /dev/tty fresh with O_NONBLOCK (all fds to the controlling
+ *    terminal share one line-discipline input queue).
+ *
+ * 2. By the time forceExit calls this, detachForShutdown has already put
+ *    the TTY back in cooked (canonical) mode. Canonical mode line-buffers
+ *    input until newline, so O_NONBLOCK reads return EAGAIN even when
+ *    mouse bytes are sitting in the buffer. We briefly re-enter raw mode
+ *    so reads return any available bytes, then restore cooked mode.
+ *
+ * Safe to call multiple times. Call as LATE as possible in the exit path:
+ * DISABLE_MOUSE_TRACKING has terminal round-trip latency, so events can
+ * arrive for a few ms after it's written.
+ */
+export declare function drainStdin(stdin?: NodeJS.ReadStream): void;
+//# sourceMappingURL=ink.d.ts.map

package/lib/types/ink/ink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../src/ink/ink.tsx"],"names":[],"mappings":"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"}