@visulima/tui 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/packem_shared/render.d-CNIzVQTh.d.ts

@@ -0,0 +1,1257 @@
+import { ReactNode } from 'react';
+import { Node } from 'yoga-layout';
+import { AnsiColors } from '@visulima/colorize';
+import { LiteralUnion } from 'type-fest';
+import 'node:stream';
+type StyleSpan = {
+  bgColor?: string;
+  fgColor?: string;
+  formatFlags: number;
+  length: number;
+  link?: string;
+};
+declare class StyledLine {
+  length: number;
+  private static readonly emptyCache;
+  private text;
+  private charData;
+  private spans;
+  private _cachedTrimmedLength?;
+  static empty(length: number): StyledLine;
+  getValue(index: number): string;
+  /**
+  * Get the raw text for a range of characters as a single string slice.
+  * Much faster than calling getValue() per character.
+  */
+  getTextRange(start: number, end: number): string;
+  getSpan(index: number): StyleSpan | undefined;
+  getFullWidth(index: number): boolean;
+  hasStyles(index: number): boolean;
+  getFormatFlags(index: number): number;
+  getFgColor(index: number): string | undefined;
+  getBgColor(index: number): string | undefined;
+  getLink(index: number): string | undefined;
+  setInverted(index: number, inverted: boolean): void;
+  setBackgroundColor(index: number, color: string | undefined): void;
+  setForegroundColor(index: number, color: string | undefined): void;
+  setChar(index: number, value: string, formatFlags: number, fgColor?: string, bgColor?: string, link?: string): void;
+  /**
+  * Optimized setChar for same-length single-byte replacement.
+  * Skips string rebuild and offset adjustment when old and new values
+  * have the same byte length (the common case for ASCII overwrites on empty lines).
+  */
+  setCharFast(index: number, value: string, formatFlags: number, fgColor?: string, bgColor?: string, link?: string): void;
+  /**
+  * Overwrite a range of this line with content from a source StyledLine.
+  * More efficient than calling setChar() per character because it does
+  * a single span split + rebuild instead of per-character span manipulation.
+  * @param destinationStart — start index in this line
+  * @param source — the StyledLine to copy from
+  * @param srcStart — start index in source (default 0)
+  * @param count — number of characters to copy (default: source.length)
+  */
+  writeFrom(destinationStart: number, source: StyledLine, srcStart?: number, count?: number): void;
+  pushChar(value: string, formatFlags: number, fgColor?: string, bgColor?: string, link?: string): void;
+  clone(): StyledLine;
+  slice(start: number, end?: number): StyledLine;
+  combine(...others: StyledLine[]): StyledLine;
+  getTrimmedLength(): number;
+  trimEnd(): StyledLine;
+  equals(other: StyledLine): boolean;
+  getText(): string;
+  getSpans(): StyleSpan[];
+  getValues(): string[];
+  [Symbol.iterator](): Iterator<{
+    bgColor?: string;
+    fgColor?: string;
+    formatFlags: number;
+    fullWidth: boolean;
+    hasStyles: boolean;
+    link?: string;
+    value: string;
+  }>;
+  /**
+  * Split the span at `index` into a single-char span, apply the updater,
+  * then merge adjacent spans. Shared by setInverted/setBackgroundColor/setForegroundColor.
+  */
+  private updateSpanAt;
+  /**
+  * Grow the line to at least `minWidth` columns, filling new cells with
+  * empty strings (zero-width placeholders). This matches the behavior of
+  * sparse JS arrays in the original ink Output where out-of-bounds writes
+  * created gaps that produced no visible output.
+  */
+  ensureWidth(minWidth: number): void;
+  private ensureInitialized;
+  private splitSpansAt;
+  /**
+  * Try to apply a single-char style at `index` by matching or merging
+  * with an adjacent span, avoiding splitSpansAt + mergeSpans.
+  *
+  * Returns true if the style was applied (or was already correct),
+  * false if the caller must fall through to the split/update/merge path.
+  *
+  * Ported from jacob314/ink PR #123 (Google LLC, Apache-2.0).
+  */
+  private trySetStyleAtIndex;
+  private mergeSpans;
+}
+type Region = {
+  backgroundColor?: string;
+  borderBottom?: number;
+  borderTop?: number;
+  cachedStickyHeaders?: StickyHeader$1[]; /** Child regions (nested content areas) */
+  children: Region[];
+  /** Cursor position within this region */
+  cursorPosition?: {
+    col: number;
+    row: number;
+  };
+  height: number; /** Unique identifier for this region (used for dirty tracking) */
+  id: number | string;
+  isHorizontallyScrollable?: boolean; /** Whether this region supports scrolling */
+  isScrollable: boolean;
+  isVerticallyScrollable?: boolean; /** Content buffer — StyledLine per row, relative to (0,0) of this region */
+  readonly lines: ReadonlyArray<StyledLine>;
+  marginBottom?: number;
+  marginRight?: number; /** DOM node reference for debugging/caching */
+  nodeId?: number;
+  opaque?: boolean; /** Layout properties */
+  overflowToBackbuffer?: boolean;
+  scrollbarThumbColor?: string;
+  scrollbarVisible?: boolean;
+  scrollHeight?: number;
+  scrollLeft?: number; /** Scroll state */
+  scrollTop?: number;
+  scrollWidth?: number; /** Selectable text spans for text selection */
+  selectableSpans: SelectableSpan[];
+  selectableText?: string; /** Whether the scrollback position is stable */
+  stableScrollback?: boolean;
+  /** Sticky headers for this region */
+  stickyHeaders: StickyHeader$1[];
+  /** Trimmed output (trailing spaces removed) for final rendering */
+  readonly styledOutput: ReadonlyArray<StyledLine>;
+  /** Dimensions */
+  width: number;
+  /** Position relative to parent region */
+  x: number;
+  y: number;
+};
+type SelectableSpan = {
+  endX: number;
+  startX: number;
+  text: string;
+  y: number;
+};
+type StickyHeader$1 = {
+  /** Lines in the natural (scrolling) position */
+  lines: ReadonlyArray<StyledLine>;
+  /** Height of the header in lines */
+  maxHeaderHeight: number;
+  /** Natural row offset relative to content start */
+  naturalRow: number;
+  /** Node ID for identification */
+  nodeId: number;
+  /** Lines in the stuck (fixed) position */
+  stuckLines?: ReadonlyArray<StyledLine>;
+  /** Stuck X position relative to region */
+  x: number;
+  /** Stuck Y position relative to region */
+  y: number;
+};
+type OutputTransformer = (s: string, index: number) => string;
+type ResizeObserverCallback = (entries: ResizeObserverEntry[], observer: ResizeObserver) => void;
+declare class ResizeObserverEntry {
+  readonly target: DOMElement;
+  readonly contentRect: Readonly<{
+    height: number;
+    width: number;
+  }>;
+  constructor(target: DOMElement, contentRect: Readonly<{
+    height: number;
+    width: number;
+  }>);
+}
+declare class ResizeObserver {
+  private readonly callback;
+  private readonly observedElements;
+  constructor(callback: ResizeObserverCallback);
+  observe(element: DOMElement): void;
+  unobserve(element: DOMElement): void;
+  disconnect(): void;
+  /**
+  * Internal method called by the layout engine after computing layout.
+  */
+  internalTrigger(entries: ResizeObserverEntry[]): void;
+}
+/**
+* Measure a node and collect resize observer entries for it.
+* Used by both the main render loop and static render processing.
+*/
+type ScrollState = {
+  actualScrollHeight: number;
+  clientHeight: number;
+  clientWidth: number;
+  scrollHeight: number;
+  scrollLeft: number;
+  scrollTop: number;
+  scrollWidth: number;
+};
+declare const getScrollHeight: (node: DOMElement) => number;
+declare const getScrollWidth: (node: DOMElement) => number;
+declare const calculateScroll: (node: DOMElement) => void;
+/**
+* Get the effective scroll top position from the pre-computed scroll state.
+* Falls back to computing from style if scroll state hasn't been calculated yet.
+*/
+declare const getScrollTop: (node: DOMElement) => number;
+/**
+* Get the effective scroll left position from the pre-computed scroll state.
+* Falls back to computing from style if scroll state hasn't been calculated yet.
+*/
+declare const getScrollLeft: (node: DOMElement) => number;
+/**
+Style of the box border.
+*/
+type BoxStyle = {
+  readonly topLeft: string;
+  readonly top: string;
+  readonly topRight: string;
+  readonly right: string;
+  readonly bottomRight: string;
+  readonly bottom: string;
+  readonly bottomLeft: string;
+  readonly left: string;
+};
+/**
+All box styles.
+*/
+type Boxes = {
+  /**
+  @example
+  ```
+  ┌────┐
+  │    │
+  └────┘
+  ```
+  */
+  readonly single: BoxStyle;
+
+  /**
+  @example
+  ```
+  ╔════╗
+  ║    ║
+  ╚════╝
+  ```
+  */
+  readonly double: BoxStyle;
+
+  /**
+  @example
+  ```
+  ╭────╮
+  │    │
+  ╰────╯
+  ```
+  */
+  readonly round: BoxStyle;
+
+  /**
+  @example
+  ```
+  ┏━━━━┓
+  ┃    ┃
+  ┗━━━━┛
+  ```
+  */
+  readonly bold: BoxStyle;
+
+  /**
+  @example
+  ```
+  ╓────╖
+  ║    ║
+  ╙────╜
+  ```
+  */
+  readonly singleDouble: BoxStyle;
+
+  /**
+  @example
+  ```
+  ╒════╕
+  │    │
+  ╘════╛
+  ```
+  */
+  readonly doubleSingle: BoxStyle;
+
+  /**
+  @example
+  ```
+  +----+
+  |    |
+  +----+
+  ```
+  */
+  readonly classic: BoxStyle;
+
+  /**
+  @example
+  ```
+  ↘↓↓↓↓↙
+  →    ←
+  ↗↑↑↑↑↖
+  ```
+  */
+  readonly arrow: BoxStyle;
+};
+type Styles = {
+  /**
+  * It defines the alignment along the cross axis when there are multiple lines of flex items (when using flex-wrap).
+  * See [align-content](https://css-tricks.com/almanac/properties/a/align-content/).
+  */
+  readonly alignContent?: "flex-start" | "flex-end" | "center" | "stretch" | "space-between" | "space-around" | "space-evenly";
+  /**
+  * The align-items property defines the default behavior for how items are laid out along the cross axis (perpendicular to the main axis).
+  * See [align-items](https://css-tricks.com/almanac/properties/a/align-items/).
+  */
+  readonly alignItems?: "flex-start" | "center" | "flex-end" | "stretch" | "baseline";
+  /**
+  * It makes possible to override the align-items value for specific flex items.
+  * See [align-self](https://css-tricks.com/almanac/properties/a/align-self/).
+  */
+  readonly alignSelf?: "flex-start" | "center" | "flex-end" | "auto" | "stretch" | "baseline";
+  /**
+  * Defines the aspect ratio (width/height) for the element.
+  *
+  * Use it with at least one size constraint (`width`, `height`, `minHeight`, or `maxHeight`) so Ink can derive the missing dimension.
+  */
+  readonly aspectRatio?: number;
+  /**
+  * Background color for the element.
+  *
+  * Accepts the same values as `color` in the `&lt;Text>` component.
+  */
+  readonly backgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Change border background color. A shorthand for setting `borderTopBackgroundColor`, `borderRightBackgroundColor`, `borderBottomBackgroundColor`, and `borderLeftBackgroundColor`.
+  */
+  readonly borderBackgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Determines whether the bottom border is visible.
+  * @default true
+  */
+  readonly borderBottom?: boolean;
+  /**
+  * Change the bottom border background color. Accepts the same values as `backgroundColor` in `Text` component.
+  */
+  readonly borderBottomBackgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Change the bottom border color. Accepts the same values as `color` in `Text` component.
+  */
+  readonly borderBottomColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Dim the bottom border color.
+  * @default false
+  */
+  readonly borderBottomDimColor?: boolean;
+  /**
+  * Text to display embedded in the bottom border line.
+  * Rendered as: `└─ title ─────────┘`
+  */
+  readonly borderBottomTitle?: string;
+  /**
+  * Alignment of the bottom border title.
+  * @default "left"
+  */
+  readonly borderBottomTitleAlignment?: "center" | "left" | "right";
+  /**
+  * Change border color. A shorthand for setting `borderTopColor`, `borderRightColor`, `borderBottomColor`, and `borderLeftColor`.
+  */
+  readonly borderColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Dim the border color. A shorthand for setting `borderTopDimColor`, `borderBottomDimColor`, `borderLeftDimColor`, and `borderRightDimColor`.
+  * @default false
+  */
+  readonly borderDimColor?: boolean;
+  /**
+  * Determines whether the left border is visible.
+  * @default true
+  */
+  readonly borderLeft?: boolean;
+  /**
+  * Change the left border background color. Accepts the same values as `backgroundColor` in `Text` component.
+  */
+  readonly borderLeftBackgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Change the left border color. Accepts the same values as `color` in `Text` component.
+  */
+  readonly borderLeftColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Dim the left border color.
+  * @default false
+  */
+  readonly borderLeftDimColor?: boolean;
+  /**
+  * Determines whether the right border is visible.
+  * @default true
+  */
+  readonly borderRight?: boolean;
+  /**
+  * Change the right border background color. Accepts the same values as `backgroundColor` in `Text` component.
+  */
+  readonly borderRightBackgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Change the right border color. Accepts the same values as `color` in `Text` component.
+  */
+  readonly borderRightColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Dim the right border color.
+  * @default false
+  */
+  readonly borderRightDimColor?: boolean;
+  /**
+  * Add a border with a specified style. If `borderStyle` is `undefined` (the default), no border will be added.
+  */
+  readonly borderStyle?: keyof Boxes | BoxStyle;
+  /**
+  * Determines whether the top border is visible.
+  * @default true
+  */
+  readonly borderTop?: boolean;
+  /**
+  * Change the top border background color. Accepts the same values as `backgroundColor` in `Text` component.
+  */
+  readonly borderTopBackgroundColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Change the top border color. Accepts the same values as `color` in `Text` component.
+  */
+  readonly borderTopColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Dim the top border color.
+  * @default false
+  */
+  readonly borderTopDimColor?: boolean;
+  /**
+  * Text to display on the right side of the top border line.
+  * Rendered as: `┌─ title ──── rightTitle ─┐`
+  */
+  readonly borderTopRightTitle?: string;
+  /**
+  * Text to display embedded in the top border line.
+  * Rendered as: `┌─ title ─────────┐`
+  */
+  readonly borderTopTitle?: string;
+  /**
+  * Alignment of the top border title.
+  * @default "left"
+  */
+  readonly borderTopTitleAlignment?: "center" | "left" | "right";
+  /**
+  * Bottom offset for positioned elements.
+  */
+  readonly bottom?: number | string;
+  /**
+  * Size of the gap between an element's columns.
+  */
+  readonly columnGap?: number;
+  /**
+  * Set this property to `none` to hide the element.
+  */
+  readonly display?: "flex" | "none";
+  /**
+  * It specifies the initial size of the flex item, before any available space is distributed according to the flex factors.
+  * See [flex-basis](https://css-tricks.com/almanac/properties/f/flex-basis/).
+  */
+  readonly flexBasis?: number | string;
+  /**
+  * It establishes the main-axis, thus defining the direction flex items are placed in the flex container.
+  * See [flex-direction](https://css-tricks.com/almanac/properties/f/flex-direction/).
+  */
+  readonly flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+  /**
+  * This property defines the ability for a flex item to grow if necessary.
+  * See [flex-grow](https://css-tricks.com/almanac/properties/f/flex-grow/).
+  */
+  readonly flexGrow?: number;
+  /**
+  * It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn’t enough space on the row.
+  * See [flex-shrink](https://css-tricks.com/almanac/properties/f/flex-shrink/).
+  */
+  readonly flexShrink?: number;
+  /**
+  * It defines whether the flex items are forced in a single line or can be flowed into multiple lines. If set to multiple lines, it also defines the cross-axis which determines the direction new lines are stacked in.
+  * See [flex-wrap](https://css-tricks.com/almanac/properties/f/flex-wrap/).
+  */
+  readonly flexWrap?: "nowrap" | "wrap" | "wrap-reverse";
+  /**
+  * Size of the gap between an element's columns and rows. A shorthand for `columnGap` and `rowGap`.
+  */
+  readonly gap?: number;
+  /**
+  * Height of the element in lines (rows). You can also set it as a percentage, which will calculate the height based on the height of the parent element.
+  */
+  readonly height?: number | string;
+  /**
+  * It defines the alignment along the main axis.
+  * See [justify-content](https://css-tricks.com/almanac/properties/j/justify-content/).
+  */
+  readonly justifyContent?: "flex-start" | "flex-end" | "space-between" | "space-around" | "space-evenly" | "center";
+  /**
+  * Left offset for positioned elements.
+  */
+  readonly left?: number | string;
+  /**
+  * Margin on all sides. Equivalent to setting `marginTop`, `marginBottom`, `marginLeft`, and `marginRight`.
+  */
+  readonly margin?: number;
+  /**
+  * Bottom margin.
+  */
+  readonly marginBottom?: number;
+  /**
+  * Left margin.
+  */
+  readonly marginLeft?: number;
+  /**
+  * Right margin.
+  */
+  readonly marginRight?: number;
+  /**
+  * Top margin.
+  */
+  readonly marginTop?: number;
+  /**
+  * Horizontal margin. Equivalent to setting `marginLeft` and `marginRight`.
+  */
+  readonly marginX?: number;
+  /**
+  * Vertical margin. Equivalent to setting `marginTop` and `marginBottom`.
+  */
+  readonly marginY?: number;
+  /**
+  * Sets a maximum height of the element in lines (rows). You can also set it as a percentage, which will calculate the maximum height based on the height of the parent element.
+  */
+  readonly maxHeight?: number | string;
+  /**
+  * Sets a maximum width of the element.
+  * Percentages aren't supported yet; see https://github.com/facebook/yoga/issues/872.
+  */
+  readonly maxWidth?: number | string;
+  /**
+  * Sets a minimum height of the element in lines (rows). You can also set it as a percentage, which will calculate the minimum height based on the height of the parent element.
+  */
+  readonly minHeight?: number | string;
+  /**
+  * Sets a minimum width of the element.
+  * Percentages aren't supported yet; see https://github.com/facebook/yoga/issues/872.
+  */
+  readonly minWidth?: number | string;
+  /**
+  * Behavior for an element's overflow in both directions.
+  * @default 'visible'
+  */
+  readonly overflow?: "visible" | "hidden" | "scroll";
+  /**
+  * If true, content that is scrolled out of the top of the box (when overflowY is 'scroll')
+  * will be added to the terminal's scrollback history.
+  *
+  * Results are undefined if more than one scrollable region in the app has
+  * overflowToBackbuffer enabled.
+  *
+  * Note: Scroll height tracking is implemented but actual backbuffer writes
+  * require worker-based rendering (not yet ported).
+  * @default false
+  */
+  readonly overflowToBackbuffer?: boolean;
+  /**
+  * Behavior for an element's overflow in the horizontal direction.
+  * @default 'visible'
+  */
+  readonly overflowX?: "visible" | "hidden" | "scroll";
+  /**
+  * Behavior for an element's overflow in the vertical direction.
+  * @default 'visible'
+  */
+  readonly overflowY?: "visible" | "hidden" | "scroll";
+  /**
+  * Padding on all sides. Equivalent to setting `paddingTop`, `paddingBottom`, `paddingLeft`, and `paddingRight`.
+  */
+  readonly padding?: number;
+  /**
+  * Bottom padding.
+  */
+  readonly paddingBottom?: number;
+  /**
+  * Left padding.
+  */
+  readonly paddingLeft?: number;
+  /**
+  * Right padding.
+  */
+  readonly paddingRight?: number;
+  /**
+  * Top padding.
+  */
+  readonly paddingTop?: number;
+  /**
+  * Horizontal padding. Equivalent to setting `paddingLeft` and `paddingRight`.
+  */
+  readonly paddingX?: number;
+  /**
+  * Vertical padding. Equivalent to setting `paddingTop` and `paddingBottom`.
+  */
+  readonly paddingY?: number;
+  /**
+  * Controls how the element is positioned.
+  *
+  * When `position` is `static`, `top`, `right`, `bottom`, and `left` are ignored.
+  */
+  readonly position?: "absolute" | "relative" | "static";
+  /**
+  * Right offset for positioned elements.
+  */
+  readonly right?: number | string;
+  /**
+  * Size of the gap between an element's rows.
+  */
+  readonly rowGap?: number;
+  /**
+  * Color of the scrollbar thumb when overflow is set to 'scroll'.
+  */
+  readonly scrollbarThumbColor?: LiteralUnion<AnsiColors, string>;
+  /**
+  * Horizontal scroll position (in columns). Only applies when overflowX or overflow is 'scroll'.
+  */
+  readonly scrollLeft?: number;
+  /**
+  * Vertical scroll position (in rows). Only applies when overflowY or overflow is 'scroll'.
+  */
+  readonly scrollTop?: number;
+  /**
+  * If true, and `overflowToBackbuffer` is also enabled, the `scrollHeight` of the box
+  * will never decrease as long as the existing history remains valid.
+  * This prevents the terminal's scrollback from being corrupted when content shrinks.
+  *
+  * Note: Scroll height tracking is implemented but actual backbuffer writes
+  * require worker-based rendering (not yet ported).
+  * @default false
+  */
+  readonly stableScrollback?: boolean;
+  /**
+  * Controls how text wraps when it exceeds the container width.
+  *
+  * - `wrap` (default) — Wrap at word boundaries; break inside words only when a single word exceeds the width.
+  * - `wrap-anywhere` — Break at any character boundary, even when a whitespace break exists earlier.
+  * - `wrap-preserve-words` — Wrap at word boundaries; never break inside words (long words may overflow).
+  * - `wrap-strict` — Enforce exact width; always break at the column limit.
+  * - `hard` — Alias for `wrap-strict`. Fills each line to the full column width, breaking words mid-word as needed.
+  * - `truncate` / `truncate-end` — Truncate at the end with an ellipsis.
+  * - `truncate-start` — Truncate at the start with an ellipsis.
+  * - `truncate-middle` — Truncate in the middle with an ellipsis.
+  */
+  readonly textWrap?: "hard" | "wrap" | "wrap-anywhere" | "wrap-preserve-words" | "wrap-strict" | "end" | "middle" | "truncate-end" | "truncate" | "truncate-middle" | "truncate-start";
+  /**
+  * Top offset for positioned elements.
+  */
+  readonly top?: number | string;
+  /**
+  * Determines whether the user can select text within this element.
+  * - `auto`: Default behavior, text is selectable.
+  * - `none`: Text cannot be selected.
+  * - `text`: Only text can be selected.
+  * - `all`: All content is selected on click.
+  */
+  readonly userSelect?: "auto" | "none" | "text" | "all";
+  /**
+  * Width of the element in spaces. You can also set it as a percentage, which will calculate the width based on the width of the parent element.
+  */
+  readonly width?: number | string;
+};
+type InkNode = {
+  internal_static?: boolean;
+  parentNode: DOMElement | undefined;
+  style: Styles;
+  yogaNode?: Node;
+};
+type LayoutListener = () => void;
+type TextName = "#text";
+type ElementNames = "ink-root" | "ink-box" | "ink-text" | "ink-cursor" | "ink-virtual-text" | "ink-static-render";
+/**
+* Describes a sticky header that should be composited on top of scrolled content.
+* Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+*/
+type StickyHeader = {
+  /** Content-relative end row. */
+  endRow: number;
+  /** Height in rows. */
+  height?: number;
+  /** If true, natural 'lines' are already in background content. */
+  isStuckOnly: boolean;
+  /** Lines rendered in the natural (scrolling) position. */
+  lines: ReadonlyArray<StyledLine>;
+  /** Natural row offset relative to content start. */
+  naturalRow: number;
+  /** Reference to the DOM node for this header. */
+  node?: DOMElement;
+  /** Unique ID of the sticky node. */
+  nodeId: number;
+  /** ID of the scroll container this header belongs to. */
+  scrollContainerId: number | string;
+  /** Content-relative start row. */
+  startRow: number;
+  /** Lines rendered in the stuck (pinned) position, if different. */
+  stuckLines?: ReadonlyArray<StyledLine>;
+  /** Sticky type: top-pinned or bottom-pinned. */
+  type?: "top" | "bottom";
+  /** Stuck X position relative to region. */
+  x: number;
+  /** Stuck Y position relative to region. */
+  y: number;
+};
+type NodeNames = ElementNames | TextName;
+type CursorAnchorRef = {
+  readonly current: DOMElement | undefined | null;
+};
+type CursorMarker = {
+  anchorRef?: CursorAnchorRef;
+  inline?: boolean;
+  x: number;
+  y: number;
+};
+type DOMElement = InkNode & {
+  attributes: Record<string, DOMNodeAttribute>;
+  /**
+  * Cached render result (a Region). When set, the entire subtree is
+  * skipped during rendering and the cached region is composited directly.
+  * Set by setCachedRender(), cleared on unmount by cleanupNodeTree().
+  */
+  cachedRender?: Region;
+  childNodes: DOMNode[];
+  internal_accessibility?: {
+    role?: "button" | "checkbox" | "combobox" | "list" | "listbox" | "listitem" | "menu" | "menuitem" | "option" | "progressbar" | "radio" | "radiogroup" | "tab" | "tablist" | "table" | "textbox" | "timer" | "toolbar";
+    state?: {
+      busy?: boolean;
+      checked?: boolean;
+      disabled?: boolean;
+      expanded?: boolean;
+      multiline?: boolean;
+      multiselectable?: boolean;
+      readonly?: boolean;
+      required?: boolean;
+      selected?: boolean;
+    };
+  };
+  internal_cursor?: CursorMarker;
+  internal_hidden?: boolean;
+  /**
+  * Auto-incrementing unique identifier for this node.
+  */
+  internal_id: number;
+  /**
+  * Whether this element's scrollback buffer is dirty (needs recalculation).
+  */
+  internal_isScrollbackDirty?: boolean;
+  /**
+  * Last measured size for ResizeObserver tracking.
+  */
+  internal_lastMeasuredSize?: {
+    height: number;
+    width: number;
+  };
+  internal_layoutListeners?: Set<LayoutListener>;
+  /**
+  * Maximum scrollTop ever reached, used with stableScrollback.
+  */
+  internal_maxScrollTop?: number;
+  /**
+  * Callback invoked after prepareYogaTree() caches the render output for
+  * an ink-static-render node. StaticRender uses this to set `isRendered`
+  * state, which prevents React from re-reconciling children once cached.
+  */
+  internal_onRendered?: () => void;
+  /**
+  * Whether this element is opaque (prevents rendering of covered content beneath it).
+  */
+  internal_opaque?: boolean;
+  /**
+  * Whether the scrollbar should be rendered for this scrollable element.
+  * Defaults to true for elements with overflow: 'scroll'.
+  */
+  internal_scrollbar?: boolean;
+  /**
+  * Scroll state computed by calculateScroll() for elements with overflow: 'scroll'.
+  */
+  internal_scrollState?: ScrollState;
+  /**
+  * Whether this element is sticky (pinned during scroll).
+  * - `true` or `'top'`: pinned to the top of the scroll container
+  * - `'bottom'`: pinned to the bottom of the scroll container
+  */
+  internal_sticky?: boolean | "top" | "bottom";
+  /**
+  * Whether this element is the alternate (stuck) version of a sticky header.
+  * The stuck version is rendered when the header is pinned.
+  */
+  internal_stickyAlternate?: boolean;
+  /**
+  * Whether this element should receive the terminal cursor focus.
+  */
+  internal_terminalCursorFocus?: boolean;
+  /**
+  * Terminal cursor position offset within this element.
+  */
+  internal_terminalCursorPosition?: number;
+  /**
+  * Cached text squash result for this node's subtree.
+  * Invalidated by markNodeAsDirty() when children change.
+  */
+  internal_textCache?: {
+    map: Map<DOMNode, {
+      end: number;
+      start: number;
+    }>;
+    text: string;
+  };
+  internal_transform?: OutputTransformer;
+  isStaticDirty?: boolean;
+  /**
+  * Whether the Yoga subtree has been detached (children removed from Yoga layout)
+  * because a cachedRender was set. When cachedRender is invalidated,
+  * prepareYogaTree() re-attaches the children before the next layout pass.
+  */
+  isYogaTreeDetached?: boolean;
+  nodeName: ElementNames;
+  onComputeLayout?: () => void;
+  onImmediateRender?: () => void;
+  onRender?: () => void;
+  /**
+  * Set of ResizeObservers attached to this element.
+  */
+  resizeObservers?: Set<ResizeObserver>;
+  staticNode?: DOMElement;
+};
+type TextNode = InkNode & {
+  nodeName: TextName;
+  nodeValue: string;
+};
+type DOMNode<T = {
+  nodeName: NodeNames;
+}> = T extends {
+  nodeName: infer U;
+} ? U extends "#text" ? TextNode : DOMElement : never;
+type DOMNodeAttribute = boolean | string | number;
+/**
+* Get the path from the root to this node (inclusive).
+* Returns an array starting with the root and ending with the node.
+*
+* Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+*/
+declare const getPathToRoot: (node: DOMNode) => DOMNode[];
+/**
+* Check if a node is selectable by walking up the tree checking `userSelect` style.
+* Returns true by default unless an ancestor has `userSelect: 'none'`.
+*
+* Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+*/
+declare const isNodeSelectable: (node: DOMElement) => boolean;
+declare const kittyFlags: {
+  readonly disambiguateEscapeCodes: 1;
+  readonly reportAllKeysAsEscapeCodes: 8;
+  readonly reportAlternateKeys: 4;
+  readonly reportAssociatedText: 16;
+  readonly reportEventTypes: 2;
+};
+type KittyFlagName = keyof typeof kittyFlags;
+declare const kittyModifiers: {
+  readonly alt: 2;
+  readonly capsLock: 64;
+  readonly ctrl: 4;
+  readonly hyper: 16;
+  readonly meta: 32;
+  readonly numLock: 128;
+  readonly shift: 1;
+  readonly super: 8;
+};
+type KittyKeyboardOptions = {
+  flags?: KittyFlagName[];
+  mode?: "auto" | "enabled" | "disabled";
+};
+type CursorPosition = {
+  x: number;
+  y: number;
+};
+/**
+* Performance metrics for a render operation.
+*/
+type RenderMetrics = {
+  /**
+  * Time spent rendering in milliseconds.
+  */
+  renderTime: number;
+};
+type Options = {
+  /**
+  * Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
+  *
+  * Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
+  *
+  * Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
+  *
+  Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
+  
+  Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+  
+  @default false
+  
+  @see {@link RenderOptions.alternateScreen}
+  */
+  alternateScreen?: boolean;
+  /**
+  * Enable React Concurrent Rendering mode.
+  *
+  * When enabled:
+  * - Suspense boundaries work correctly with async data
+  * - `useTransition` and `useDeferredValue` are fully functional
+  - Updates can be interrupted for higher priority work
+  
+  Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
+  
+  @default false
+  @experimental
+  */
+  concurrent?: boolean;
+  debug: boolean;
+  exitOnCtrlC: boolean;
+  incrementalRendering?: boolean;
+  /**
+  * Override automatic interactive mode detection.
+  *
+  * By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+  *
+  * When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
+  *
+  Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
+  
+  Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+  
+  @default true (false if in CI or `stdout.isTTY` is falsy)
+  
+  @see {@link RenderOptions.interactive}
+  */
+  interactive?: boolean;
+  isScreenReaderEnabled?: boolean;
+  kittyKeyboard?: KittyKeyboardOptions;
+  maxFps?: number;
+  onRender?: (metrics: RenderMetrics) => void;
+  patchConsole: boolean;
+  standardReactLayoutTiming?: boolean;
+  stderr: NodeJS.WriteStream;
+  stdin: NodeJS.ReadStream;
+  stdout: NodeJS.WriteStream;
+  /**
+  * Whether to track text selection state during rendering.
+  *
+  * @default false
+  */
+  trackSelection?: boolean;
+  /**
+  * Use the native Rust cell-diff renderer instead of ANSI string-based log-update.
+  * Produces a Uint32Array buffer that the Rust renderer diffs cell-by-cell,
+  * generating minimal ANSI escape sequences. Significantly reduces GC pressure
+  * and improves rendering performance for complex UIs.
+  *
+  * Falls back to the string-based path if native bindings are not available.
+  * @default false
+  */
+  useNativeRenderer?: boolean;
+  waitUntilExit?: () => Promise<unknown>;
+};
+declare class Ink {
+  /**
+  * Whether this instance is using concurrent rendering mode.
+  */
+  readonly isConcurrent: boolean;
+  private readonly options;
+  private readonly log;
+  private manualCursorPosition;
+  private renderedCursorPosition;
+  private renderedCursorRequested;
+  private readonly throttledLog;
+  private readonly isScreenReaderEnabled;
+  private readonly interactive;
+  private readonly renderThrottleMs;
+  private alternateScreen;
+  private isUnmounted;
+  private isUnmounting;
+  private lastOutput;
+  private lastOutputToRender;
+  private lastOutputHeight;
+  private lastTerminalWidth;
+  private readonly nativeLog;
+  private readonly useNativeRenderer;
+  private readonly container;
+  readonly rootNode: DOMElement;
+  private fullStaticOutput;
+  private readonly exitPromise!;
+  private exitResult;
+  private beforeExitHandler?;
+  private restoreConsole?;
+  private unsubscribeResize?;
+  private readonly throttledOnRender?;
+  private hasPendingThrottledRender;
+  private kittyProtocolEnabled;
+  private cancelKittyDetection?;
+  private nextRenderCommit?;
+  private deferredInitDone;
+  constructor(options: Options);
+  /**
+  * Perform deferred initialization on the first render frame.
+  * Kitty keyboard auto-detection is deferred here because the CSI ? u
+  * query sets up a synchronous stdin listener with a 200ms timeout.
+  * "enabled" mode runs immediately in the constructor (it's just a write).
+  */
+  private runDeferredInit;
+  resized: () => void;
+  resolveExitPromise: (result?: unknown) => void;
+  rejectExitPromise: (reason?: Error) => void;
+  unsubscribeExit: () => void;
+  handleAppExit: (errorOrResult?: unknown) => void;
+  getActiveCursorPosition: () => CursorPosition | undefined;
+  setCursorPosition: (position: CursorPosition | undefined) => void;
+  restoreLastOutput: () => void;
+  calculateLayout: () => void;
+  private calculateScrollAndTriggerObservers;
+  /**
+  * Force a full layout recalculation by marking all text nodes dirty.
+  * Useful when the string width function changes or terminal font changes.
+  */
+  recalculateLayout(): void;
+  /**
+  * Walks the DOM tree before Yoga layout to handle StaticRender nodes.
+  *
+  * - Re-attach Yoga children if a cached render was invalidated.
+  * - Pre-render ink-static-render nodes that don't have a cached render yet.
+  */
+  private prepareYogaTree;
+  private markAllTextNodesDirty;
+  onRender: () => void;
+  private accessibilityContextValue;
+  render(node: ReactNode): void;
+  writeToStdout: (data: string) => void;
+  writeToStderr: (data: string) => void;
+  unmount: (error?: Error | number | null) => void;
+  waitUntilExit(): Promise<unknown>;
+  waitUntilRenderFlush(): Promise<void>;
+  clear(): void;
+  patchConsole(): void;
+  private setAlternateScreen;
+  private resolveInteractiveOption;
+  private resolveAlternateScreenOption;
+  private shouldSync;
+  private writeBestEffort;
+  private awaitExit;
+  private hasPendingConcurrentWork;
+  private awaitNextRender;
+  private renderInteractiveFrame;
+  /**
+  * Handle kitty keyboard "enabled" mode immediately (just a stdout.write).
+  * Called from the constructor.
+  */
+  private initImmediateKittyKeyboard;
+  /**
+  * Handle kitty keyboard "auto" mode detection. Deferred to first render
+  * because the CSI ? u query sets up a stdin listener with a 200ms timeout.
+  */
+  private initDeferredKittyKeyboard;
+  private confirmKittySupport;
+  private enableKittyProtocol;
+}
+type RenderOptions = {
+  /**
+  * Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
+  *
+  * Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
+  *
+  * Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
+  *
+  * Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
+  *
+  *Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+  * @default false
+  */
+  alternateScreen?: boolean;
+  /**
+  * Enable React Concurrent Rendering mode.
+  *
+  * When enabled:
+  * - Suspense boundaries work correctly with async data
+  * - `useTransition` and `useDeferredValue` are fully functional
+  * - Updates can be interrupted for higher priority work
+  *
+  *Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
+  * @default false
+  */
+  concurrent?: boolean;
+  /**
+  * If true, each update will be rendered as separate output, without replacing the previous one.
+  * @default false
+  */
+  debug?: boolean;
+  /**
+  * Configure whether Ink should listen for Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and the process is expected to handle it manually.
+  * @default true
+  */
+  exitOnCtrlC?: boolean;
+  /**
+  * Enable incremental rendering mode which only updates changed lines instead of redrawing the entire output.
+  *This can reduce flickering and improve performance for frequently updating UIs.
+  * @default false
+  */
+  incrementalRendering?: boolean;
+  /**
+  * Override automatic interactive mode detection.
+  *
+  * By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+  *
+  * When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
+  *
+  * Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
+  *
+  *Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
+  * @default true (false if in CI or `stdout.isTTY` is falsy)
+  */
+  interactive?: boolean;
+  /**
+  * Enable screen reader support. See https://github.com/vadimdemedes/ink/blob/master/readme.md#screen-reader-support
+  * @default process.env['INK_SCREEN_READER'] === 'true'
+  */
+  isScreenReaderEnabled?: boolean;
+  /**
+  * Configure kitty keyboard protocol support for enhanced keyboard input.
+  * Enables additional modifiers (super, hyper, capsLock, numLock) and
+  *disambiguated key events in terminals that support the protocol.
+  * @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+  */
+  kittyKeyboard?: KittyKeyboardOptions;
+  /**
+  * Maximum frames per second for render updates.
+  * This controls how frequently the UI can update to prevent excessive re-rendering.
+  *Higher values allow more frequent updates but may impact performance.
+  * @default 30
+  */
+  maxFps?: number;
+  /**
+  * Runs the given callback after each render and re-render with render metrics.
+  *
+  * Note: this callback runs after Ink commits a frame, but it does not wait for `stdout`/`stderr` stream callbacks.
+  * To run code after output is flushed, use `waitUntilRenderFlush()`.
+  */
+  onRender?: (metrics: RenderMetrics) => void;
+  /**
+  * Patch console methods to ensure console output doesn't mix with Ink's output.
+  *
+  *Note: Once unmount starts, Ink restores the native console before React cleanup runs. Teardown-time `console.*` output then follows the normal console behavior instead of being rerouted through Ink.
+  * @default true
+  */
+  patchConsole?: boolean;
+  /**
+  * If true, Ink defers frame output until after React's commit phase completes,
+  * ensuring `useLayoutEffect` hooks run before the frame is written to the terminal.
+  *
+  * This eliminates the one-frame flicker when components measure layout
+  * (e.g., scroll position, element size) in `useLayoutEffect` and adjust state.
+  *
+  * **Warning:** Incompatible with the `&lt;Static>` component, which relies on
+  * immediate render timing to append output.
+  * @default false
+  */
+  standardReactLayoutTiming?: boolean;
+  /**
+  * Error stream.
+  * @default process.stderr
+  */
+  stderr?: NodeJS.WriteStream;
+  /**
+  * Input stream where app will listen for input.
+  * @default process.stdin
+  */
+  stdin?: NodeJS.ReadStream;
+  /**
+  * Output stream where the app will be rendered.
+  * @default process.stdout
+  */
+  stdout?: NodeJS.WriteStream;
+  /**
+  * Use the native Rust cell-diff renderer for terminal output.
+  * Produces a Uint32Array buffer that the Rust renderer diffs cell-by-cell,
+  * generating minimal ANSI escape sequences. Reduces GC pressure and
+  * improves rendering performance for complex UIs.
+  *
+  * Falls back to string-based rendering if native bindings are not available.
+  * @default false
+  */
+  useNativeRenderer?: boolean;
+};
+type Instance = {
+  /**
+  * Unmount the current app and remove the internal Ink instance for this stdout.
+  *
+  * This is mostly useful for advanced cases where you need `render()` to create a fresh instance for the same stream without leaving terminal state such as the alternate screen behind.
+  */
+  cleanup: () => void;
+  /**
+  * Clear output.
+  */
+  clear: () => void;
+  /**
+  * Replace the previous root node with a new one or update props of the current root node.
+  */
+  rerender: Ink["render"];
+  /**
+  * The root DOM element of the rendered tree.
+  * Useful for programmatic DOM inspection and advanced measurement.
+  */
+  rootNode: DOMElement;
+  /**
+  * Manually unmount the whole Ink app.
+  */
+  unmount: Ink["unmount"];
+  /**
+  * Returns a promise that settles when the app is unmounted.
+  *
+  * It resolves with the value passed to `exit(value)` and rejects with the error passed to `exit(error)`.
+  *When `unmount()` is called manually, it settles after unmount-related stdout writes complete.
+  * @example
+  * ```jsx
+  * const {unmount, waitUntilExit} = render(<MyApp />);
+  *
+  * setTimeout(unmount, 1000);
+  *
+  * await waitUntilExit(); // resolves after `unmount()` is called
+  * ```
+  */
+  waitUntilExit: Ink["waitUntilExit"];
+  /**
+  * Returns a promise that settles after pending render output is flushed to stdout.
+  *
+  *This can be used after `rerender()` when you need to run code only after the frame is written.
+  * @example
+  * ```jsx
+  * const {rerender, waitUntilRenderFlush} = render(<MyApp step="loading" />);
+  *
+  * rerender(<MyApp step="ready" />);
+  * await waitUntilRenderFlush(); // output for "ready" is flushed
+  *
+  * runNextCommand();
+  * ```
+  */
+  waitUntilRenderFlush: Ink["waitUntilRenderFlush"];
+};
+/**
+* Mount a component and render the output.
+*/
+declare const render: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
+export { CursorPosition as C, DOMElement as D, Instance as I, KittyFlagName as K, RenderOptions as R, Styles as S, DOMNode as a, StyledLine as b, KittyKeyboardOptions as c, ResizeObserver as d, ResizeObserverCallback as e, ResizeObserverEntry as f, ScrollState as g, StickyHeader as h, calculateScroll as i, getPathToRoot as j, getScrollHeight as k, getScrollLeft as l, getScrollTop as m, getScrollWidth as n, isNodeSelectable as o, kittyFlags as p, kittyModifiers as q, render as r };