silvery 0.17.0 → 0.17.2

package/dist/index-CBcSpGSM.d.mts

@@ -0,0 +1,3416 @@
+import { Nt as ColorLevel, Pt as TerminalCaps, jt as Theme } from "./index-DCVL3jHo.mjs";
+import * as _$react from "react";
+import React$1, { ReactElement } from "react";
+
+//#region packages/ag/src/drag-event-types.d.ts
+/**
+ * Drag event payload passed to handler props.
+ */
+interface DragEventPayload {
+  /** The node being dragged */
+  source: AgNode;
+  /** Current terminal position of the pointer */
+  position: {
+    x: number;
+    y: number;
+  };
+  /** The node under the cursor (the drop target receiving this event) */
+  dropTarget: AgNode | null;
+}
+interface DragEventProps {
+  /** Fired when a dragged node enters this node's bounds */
+  onDragEnter?: (event: DragEventPayload) => void;
+  /** Fired when a dragged node leaves this node's bounds */
+  onDragLeave?: (event: DragEventPayload) => void;
+  /** Fired repeatedly as a dragged node moves over this node */
+  onDragOver?: (event: DragEventPayload) => void;
+  /** Fired when a dragged node is dropped on this node */
+  onDrop?: (event: DragEventPayload) => void;
+}
+//#endregion
+//#region packages/ag/src/keys.d.ts
+/**
+ * Keyboard Constants and Utilities
+ *
+ * Single source of truth for all key parsing, mapping, and matching in silvery.
+ *
+ * ## Two-Layer Input Architecture
+ *
+ * parseKey() returns `[input, key]` where these serve DIFFERENT purposes:
+ *
+ * - `input` is **normalized for keybinding matching**. Shifted punctuation is
+ *   decomposed: '#' becomes input='3' with key.shift=true, so keybindings
+ *   like 'shift-3' can match. Uppercase letters become lowercase + shift.
+ *
+ * - `key.text` is the **actual typed character** (pre-normalization). For text
+ *   insertion, always use `key.text ?? input` — this ensures Shift+3 inserts
+ *   '#', opt+e inserts '´', and IME output inserts the composed string.
+ *
+ * Rule: keybinding resolution uses `input`. Text insertion uses `key.text`.
+ * Never reconstruct characters from key codes — trust what the terminal sent.
+ *
+ * - KEY_MAP: Playwright key names -> ANSI sequences (for sending input)
+ * - CODE_TO_KEY: ANSI escape suffixes -> key names (for parsing input)
+ * - Key interface: structured key object with boolean flags
+ * - parseKeypress(): raw terminal input -> ParsedKeypress
+ * - parseKey(): raw terminal input -> [input, Key]
+ * - keyToAnsi(): Playwright key string -> ANSI sequence
+ * - keyToName(): Key object -> named key string
+ * - keyToModifiers(): Key object -> modifier flags
+ * - parseHotkey(): "ctrl+shift+a" -> ParsedHotkey
+ * - matchHotkey(): match ParsedHotkey against Key
+ *
+ * @example
+ * ```tsx
+ * import { keyToAnsi } from '@silvery/test'
+ *
+ * // Convert key names to ANSI
+ * keyToAnsi('Enter')       // '\r'
+ * keyToAnsi('ArrowUp')     // '\x1b[A'
+ * keyToAnsi('Control+c')   // '\x03'
+ * keyToAnsi('a')           // 'a'
+ * ```
+ */
+/**
+ * Key object describing which special keys/modifiers were pressed.
+ */
+interface Key {
+  /** Up arrow key was pressed */
+  upArrow: boolean;
+  /** Down arrow key was pressed */
+  downArrow: boolean;
+  /** Left arrow key was pressed */
+  leftArrow: boolean;
+  /** Right arrow key was pressed */
+  rightArrow: boolean;
+  /** Page Down key was pressed */
+  pageDown: boolean;
+  /** Page Up key was pressed */
+  pageUp: boolean;
+  /** Home key was pressed */
+  home: boolean;
+  /** End key was pressed */
+  end: boolean;
+  /** Return (Enter) key was pressed */
+  return: boolean;
+  /** Escape key was pressed */
+  escape: boolean;
+  /** Ctrl key was pressed */
+  ctrl: boolean;
+  /** Shift key was pressed */
+  shift: boolean;
+  /** Tab key was pressed */
+  tab: boolean;
+  /** Backspace key was pressed */
+  backspace: boolean;
+  /** Delete key was pressed */
+  delete: boolean;
+  /** Meta key (Alt/Option on macOS, Alt on other platforms) was pressed */
+  meta: boolean;
+  /** Super key (Cmd on macOS, Win on Windows) was pressed. Requires Kitty protocol. */
+  super: boolean;
+  /** Hyper key was pressed. Requires Kitty protocol. */
+  hyper: boolean;
+  /** CapsLock is active. Requires Kitty protocol. */
+  capsLock: boolean;
+  /** NumLock is active. Requires Kitty protocol. */
+  numLock: boolean;
+  /** Kitty event type. Only set with Kitty flag 2 (report events). */
+  eventType?: "press" | "repeat" | "release";
+  /** The actual text character typed (pre-normalization). For text insertion,
+   *  use this instead of the normalized `input` which maps shifted chars to base keys. */
+  text?: string;
+  /** True when the key is a modifier pressed alone (Shift, Ctrl, Alt, Super, Hyper, Meta).
+   *  Set during parsing for Kitty protocol modifier-only events. */
+  isModifierOnly?: boolean;
+}
+/**
+ * Input handler callback type.
+ * Return 'exit' to exit the app.
+ */
+type InputHandler = (input: string, key: Key) => void | "exit";
+/**
+ * Parsed hotkey from a string like "ctrl+shift+a" or "Control+ArrowUp".
+ */
+interface ParsedHotkey {
+  key: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  alt: boolean;
+  super: boolean;
+  hyper: boolean;
+}
+interface ParsedKeypress {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  option: boolean;
+  super: boolean;
+  hyper: boolean;
+  /** Kitty event type. Only set with Kitty flag 2 (report events). */
+  eventType?: "press" | "repeat" | "release";
+  /** The character when Shift is held. From Kitty shifted_codepoint. */
+  shiftedKey?: string;
+  /** The key on a standard US layout (for non-Latin keyboards). From Kitty base_layout_key. */
+  baseLayoutKey?: string;
+  /** CapsLock is active. Kitty modifier bit 6. */
+  capsLock?: boolean;
+  /** NumLock is active. Kitty modifier bit 7. */
+  numLock?: boolean;
+  /** Decoded text from Kitty REPORT_TEXT mode. */
+  associatedText?: string;
+  sequence: string;
+  /** Raw input string, identical to sequence for most keys. */
+  raw?: string;
+  code?: string;
+  /** Whether this key was parsed from the Kitty keyboard protocol. */
+  isKittyProtocol?: boolean;
+  /**
+   * Whether this key represents printable text input.
+   * When false, the key is a control/function/modifier key that should not
+   * produce text input (e.g., arrows, function keys, capslock, media keys).
+   * Only set by the kitty protocol parser.
+   */
+  isPrintable?: boolean;
+  /**
+   * Text associated with the key.
+   * For printable kitty keys, defaults to the character from the codepoint.
+   * When REPORT_TEXT flag is active, contains the decoded text-as-codepoints.
+   */
+  text?: string;
+}
+/**
+ * Parse a raw input sequence into a structured keypress object.
+ * Accepts string or Buffer (Buffer support for stdin compatibility).
+ */
+declare function parseKeypress(s: string | Buffer): ParsedKeypress;
+/**
+ * Parse raw terminal input into a Key object and cleaned input string.
+ *
+ * @param rawInput Raw terminal input (string or Buffer)
+ * @returns Tuple of [cleanedInput, Key]
+ */
+declare function parseKey(rawInput: string | Buffer): [string, Key];
+/**
+ * Create an empty Key object (all fields false).
+ */
+declare function emptyKey(): Key;
+/**
+ * Convert a Key object to a named key string.
+ *
+ * Returns the Playwright-compatible name for special keys (ArrowUp, Enter, etc.)
+ * or "" if no special key is pressed.
+ */
+declare function keyToName(key: Key): string;
+/**
+ * Extract modifier flags from a Key object.
+ * `alt` is always false (terminals cannot distinguish alt from meta).
+ */
+declare function keyToModifiers(key: Key): {
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  alt: boolean;
+  super: boolean;
+  hyper: boolean;
+};
+/**
+ * Parse a hotkey string into base key and modifiers.
+ *
+ * Supports Playwright-style ("Control+c", "Shift+ArrowUp") and
+ * lowercase aliases ("ctrl+c", "shift+tab", "cmd+a").
+ *
+ * @example
+ * ```tsx
+ * parseHotkey('j')           // { key: 'j', ctrl: false, meta: false, shift: false, alt: false }
+ * parseHotkey('Control+c')   // { key: 'c', ctrl: true, ... }
+ * parseHotkey('Shift+ArrowUp') // { key: 'ArrowUp', shift: true, ... }
+ * parseHotkey('⌘j')          // { key: 'j', super: true, ... } (macOS symbol prefix)
+ * parseHotkey('⌃⇧a')         // { key: 'a', ctrl: true, shift: true, ... }
+ * ```
+ */
+declare function parseHotkey(keyStr: string): ParsedHotkey;
+/**
+ * Match a parsed hotkey against a Key object and input string.
+ *
+ * @param hotkey Parsed hotkey to match
+ * @param key Key object from input event
+ * @param input Optional input string (for matching character keys)
+ * @returns true if the hotkey matches the key event
+ */
+declare function matchHotkey(hotkey: ParsedHotkey, key: Key, input?: string): boolean;
+//#endregion
+//#region packages/ag/src/focus-events.d.ts
+/**
+ * Synthetic keyboard event, mirroring React.KeyboardEvent / DOM KeyboardEvent.
+ */
+interface SilveryKeyEvent {
+  /** The printable character, or "" for non-printable keys */
+  key: string;
+  /** Raw terminal input string */
+  input: string;
+  /** Modifier keys */
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  super: boolean;
+  hyper: boolean;
+  /** Kitty event type */
+  eventType?: "press" | "repeat" | "release";
+  /** Deepest focusable node that received this event */
+  target: AgNode;
+  /** Node whose handler is currently firing (changes during capture/bubble) */
+  currentTarget: AgNode;
+  /** Stop event from propagating further */
+  stopPropagation(): void;
+  /** Prevent default behavior */
+  preventDefault(): void;
+  /** Whether stopPropagation() was called */
+  readonly propagationStopped: boolean;
+  /** Whether preventDefault() was called */
+  readonly defaultPrevented: boolean;
+  /** Raw parsed key data */
+  nativeEvent: {
+    input: string;
+    key: Key;
+  };
+}
+/**
+ * Synthetic focus event, mirroring React.FocusEvent / DOM FocusEvent.
+ */
+interface SilveryFocusEvent {
+  /** The node gaining or losing focus */
+  target: AgNode;
+  /** The other node involved (losing focus on 'focus', gaining on 'blur') */
+  relatedTarget: AgNode | null;
+  /** Event type */
+  type: "focus" | "blur";
+  /** Node whose handler is currently firing (changes during bubble) */
+  currentTarget: AgNode;
+  /** Stop event from bubbling to parent nodes */
+  stopPropagation(): void;
+  /** Whether stopPropagation() was called */
+  readonly propagationStopped: boolean;
+}
+interface FocusEventProps {
+  /** Whether this node can receive focus */
+  focusable?: boolean;
+  /** Whether this node should receive focus on mount */
+  autoFocus?: boolean;
+  /** Whether this node creates a focus scope (focus trapping boundary) */
+  focusScope?: boolean;
+  /** ID of the node to focus when pressing Up from this node */
+  nextFocusUp?: string;
+  /** ID of the node to focus when pressing Down from this node */
+  nextFocusDown?: string;
+  /** ID of the node to focus when pressing Left from this node */
+  nextFocusLeft?: string;
+  /** ID of the node to focus when pressing Right from this node */
+  nextFocusRight?: string;
+  /** Called when this node gains focus */
+  onFocus?: (event: SilveryFocusEvent) => void;
+  /** Called when this node loses focus */
+  onBlur?: (event: SilveryFocusEvent) => void;
+  /** Called on key down (bubble phase) */
+  onKeyDown?: (event: SilveryKeyEvent, dispatch?: (msg: unknown) => void) => void;
+  /** Called on key up (bubble phase) */
+  onKeyUp?: (event: SilveryKeyEvent, dispatch?: (msg: unknown) => void) => void;
+  /** Called on key down (capture phase — fires before target) */
+  onKeyDownCapture?: (event: SilveryKeyEvent) => void;
+}
+/**
+ * Create a synthetic keyboard event.
+ */
+declare function createKeyEvent(input: string, key: Key, target: AgNode): SilveryKeyEvent;
+/**
+ * Create a synthetic focus event.
+ */
+declare function createFocusEvent(type: "focus" | "blur", target: AgNode, relatedTarget: AgNode | null): SilveryFocusEvent;
+/**
+ * Dispatch a keyboard event through the render tree with DOM-style
+ * capture/target/bubble phases.
+ *
+ * For press/repeat events:
+ *   1. Capture phase: root → target (onKeyDownCapture props)
+ *   2. Target phase: target's onKeyDown
+ *   3. Bubble phase: target parent → root (onKeyDown props)
+ *
+ * For release events:
+ *   1. Target phase: target's onKeyUp
+ *   2. Bubble phase: target parent → root (onKeyUp props)
+ *   (No capture phase for keyUp — deliberate simplification; React DOM has onKeyUpCapture)
+ *
+ * stopPropagation() halts traversal at any phase.
+ */
+declare function dispatchKeyEvent(event: SilveryKeyEvent, dispatch?: (msg: unknown) => void): void;
+/**
+ * Dispatch a focus event through the render tree.
+ *
+ * Fires onFocus/onBlur on the target, then bubbles to ancestors.
+ */
+declare function dispatchFocusEvent(event: SilveryFocusEvent): void;
+//#endregion
+//#region packages/ag/src/layout-types.d.ts
+/**
+ * Layout Type Abstractions
+ *
+ * Pure type interfaces for layout engines (Yoga, Flexily, etc.)
+ * These live in @silvery/ag because they're used by core types (AgNode).
+ * The runtime layout engine management lives in @silvery/ag-term/layout-engine.
+ */
+/**
+ * Measure mode determines how the width/height constraint should be interpreted.
+ */
+type MeasureMode = "undefined" | "exactly" | "at-most";
+/**
+ * Measure function callback for intrinsic sizing.
+ * Called when a node needs to determine its size based on content.
+ */
+type MeasureFunc = (width: number, widthMode: MeasureMode, height: number, heightMode: MeasureMode) => {
+  width: number;
+  height: number;
+};
+/**
+ * Abstract layout node interface.
+ * Represents a single node in the layout tree.
+ */
+interface LayoutNode {
+  insertChild(child: LayoutNode, index: number): void;
+  removeChild(child: LayoutNode): void;
+  free(): void;
+  setMeasureFunc(measureFunc: MeasureFunc): void;
+  markDirty(): void;
+  setWidth(value: number): void;
+  setWidthPercent(value: number): void;
+  setWidthAuto(): void;
+  setHeight(value: number): void;
+  setHeightPercent(value: number): void;
+  setHeightAuto(): void;
+  setMinWidth(value: number): void;
+  setMinWidthPercent(value: number): void;
+  setMinHeight(value: number): void;
+  setMinHeightPercent(value: number): void;
+  setMaxWidth(value: number): void;
+  setMaxWidthPercent(value: number): void;
+  setMaxHeight(value: number): void;
+  setMaxHeightPercent(value: number): void;
+  setFlexGrow(value: number): void;
+  setFlexShrink(value: number): void;
+  setFlexBasis(value: number): void;
+  setFlexBasisPercent(value: number): void;
+  setFlexBasisAuto(): void;
+  setFlexDirection(direction: number): void;
+  setFlexWrap(wrap: number): void;
+  setAlignItems(align: number): void;
+  setAlignSelf(align: number): void;
+  setAlignContent(align: number): void;
+  setJustifyContent(justify: number): void;
+  setPadding(edge: number, value: number): void;
+  setMargin(edge: number, value: number): void;
+  setBorder(edge: number, value: number): void;
+  setGap(gutter: number, value: number): void;
+  setDisplay(display: number): void;
+  setPositionType(positionType: number): void;
+  setPosition(edge: number, value: number): void;
+  setPositionPercent(edge: number, value: number): void;
+  setOverflow(overflow: number): void;
+  setAspectRatio(value: number): void;
+  calculateLayout(width: number, height: number, direction?: number): void;
+  getComputedLeft(): number;
+  getComputedTop(): number;
+  getComputedWidth(): number;
+  getComputedHeight(): number;
+}
+//#endregion
+//#region packages/ag/src/mouse-event-types.d.ts
+/**
+ * Synthetic mouse event, mirroring React.MouseEvent / DOM MouseEvent.
+ */
+interface SilveryMouseEvent {
+  /** Terminal column (0-indexed) */
+  clientX: number;
+  /** Terminal row (0-indexed) */
+  clientY: number;
+  /** Mouse button: 0=left, 1=middle, 2=right */
+  button: number;
+  /** Modifier keys */
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+  /** Deepest node under cursor */
+  target: AgNode;
+  /** Node whose handler is currently firing (changes during bubble) */
+  currentTarget: AgNode;
+  /** Event type */
+  type: "click" | "dblclick" | "mousedown" | "mouseup" | "mousemove" | "mouseenter" | "mouseleave" | "wheel";
+  /** Stop event from bubbling to parent nodes */
+  stopPropagation(): void;
+  /** Prevent default behavior */
+  preventDefault(): void;
+  /** Whether stopPropagation() was called */
+  readonly propagationStopped: boolean;
+  /** Whether preventDefault() was called */
+  readonly defaultPrevented: boolean;
+  /** Raw parsed mouse data from terminal protocol */
+  nativeEvent: unknown;
+}
+/**
+ * Synthetic wheel event, extending SilveryMouseEvent with scroll deltas.
+ */
+interface SilveryWheelEvent extends SilveryMouseEvent {
+  /** Vertical scroll: -1 (up) or +1 (down) */
+  deltaY: number;
+  /** Horizontal scroll: always 0 for terminals */
+  deltaX: number;
+}
+interface MouseEventProps {
+  onClick?: (event: SilveryMouseEvent) => void;
+  onDoubleClick?: (event: SilveryMouseEvent) => void;
+  onMouseDown?: (event: SilveryMouseEvent) => void;
+  onMouseUp?: (event: SilveryMouseEvent) => void;
+  onMouseMove?: (event: SilveryMouseEvent) => void;
+  onMouseEnter?: (event: SilveryMouseEvent) => void;
+  onMouseLeave?: (event: SilveryMouseEvent) => void;
+  onWheel?: (event: SilveryWheelEvent) => void;
+}
+//#endregion
+//#region packages/ag/src/types.d.ts
+/**
+ * CSS user-select equivalent for controlling text selectability.
+ * - "auto": inherit from parent (root resolves to "text")
+ * - "none": not selectable
+ * - "text": force selectable (overrides parent "none")
+ * - "contain": selectable, but selection cannot escape this node's bounds
+ */
+type UserSelect = "auto" | "none" | "text" | "contain";
+/**
+ * A rectangle with position and size.
+ * All values are in terminal columns/rows (integers).
+ */
+interface Rect {
+  /** X position (0-indexed terminal column) */
+  x: number;
+  /** Y position (0-indexed terminal row) */
+  y: number;
+  /** Width in terminal columns */
+  width: number;
+  /** Height in terminal rows */
+  height: number;
+}
+/**
+ * Per-node interactive state — written by pointer/selection/focus state machines,
+ * read by theme/render for automatic styling.
+ *
+ * These are plain mutable booleans, NOT reactive signals. State machines set them
+ * synchronously during event processing, and the next render reads them.
+ * React re-renders are driven by the event processing, not signal subscriptions.
+ *
+ * The object is lazily created on first write to avoid overhead on non-interactive nodes.
+ */
+interface InteractiveState {
+  /** Pointer is over this node (mouseenter/mouseleave) */
+  hovered: boolean;
+  /** Pointer-down on this node, awaiting pointer-up (will receive click) */
+  armed: boolean;
+  /** Node is in the current selection set */
+  selected: boolean;
+  /** Node has keyboard focus */
+  focused: boolean;
+  /** A drag operation is hovering over this node */
+  dropTarget: boolean;
+}
+/**
+ * Silvery node types - the primitive elements in the render tree.
+ */
+type AgNodeType = "silvery-root" | "silvery-box" | "silvery-text";
+/**
+ * Flexbox properties that can be applied to Box nodes.
+ */
+interface FlexboxProps {
+  width?: number | string;
+  height?: number | string;
+  minWidth?: number | string;
+  minHeight?: number | string;
+  maxWidth?: number | string;
+  maxHeight?: number | string;
+  flexGrow?: number;
+  flexShrink?: number;
+  flexBasis?: number | string;
+  flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+  flexWrap?: "nowrap" | "wrap" | "wrap-reverse";
+  alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+  alignSelf?: "auto" | "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+  alignContent?: "flex-start" | "flex-end" | "center" | "stretch" | "space-between" | "space-around" | "space-evenly";
+  justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
+  padding?: number;
+  paddingTop?: number;
+  paddingBottom?: number;
+  paddingLeft?: number;
+  paddingRight?: number;
+  paddingX?: number;
+  paddingY?: number;
+  margin?: number;
+  marginTop?: number;
+  marginBottom?: number;
+  marginLeft?: number;
+  marginRight?: number;
+  marginX?: number;
+  marginY?: number;
+  gap?: number;
+  columnGap?: number;
+  rowGap?: number;
+  position?: "relative" | "absolute" | "sticky" | "static";
+  top?: number | string;
+  left?: number | string;
+  bottom?: number | string;
+  right?: number | string;
+  stickyTop?: number;
+  stickyBottom?: number;
+  aspectRatio?: number;
+  display?: "flex" | "none";
+  overflow?: "visible" | "hidden" | "scroll";
+  overflowX?: "visible" | "hidden";
+  overflowY?: "visible" | "hidden";
+  /** Child index to ensure visible (edge-based: only scrolls if off-screen) */
+  scrollTo?: number;
+  /** Explicit scroll offset in rows (used when scrollTo is undefined for frozen scroll state) */
+  scrollOffset?: number;
+}
+/**
+ * Props for testing and identification.
+ * These props are stored in the node for DOM query access.
+ */
+interface TestProps {
+  /** Element ID for DOM queries and visual debugging */
+  id?: string;
+  /** Test ID for querying nodes (like Playwright's data-testid) */
+  testID?: string;
+  /** Allow arbitrary data-* attributes for testing */
+  [key: `data-${string}`]: unknown;
+}
+/**
+ * Underline style variants (SGR 4:x codes).
+ * - false: no underline
+ * - 'single': standard underline (SGR 4 or 4:1)
+ * - 'double': double underline (SGR 4:2)
+ * - 'curly': curly/wavy underline (SGR 4:3)
+ * - 'dotted': dotted underline (SGR 4:4)
+ * - 'dashed': dashed underline (SGR 4:5)
+ */
+type UnderlineStyle$1 = false | "single" | "double" | "curly" | "dotted" | "dashed";
+/**
+ * Style properties for text rendering.
+ */
+interface StyleProps {
+  color?: string;
+  backgroundColor?: string;
+  bold?: boolean;
+  dim?: boolean;
+  /** Alias for dim (Ink compatibility) */
+  dimColor?: boolean;
+  italic?: boolean;
+  /** Enable underline. Use underlineStyle for style variants. */
+  underline?: boolean;
+  /**
+   * Underline style variant: 'single' | 'double' | 'curly' | 'dotted' | 'dashed'.
+   * Setting this implies underline=true. Takes precedence over underline prop.
+   */
+  underlineStyle?: UnderlineStyle$1;
+  /**
+   * Underline color (independent of text color).
+   * Uses SGR 58 (underline color). Falls back to text color if not specified.
+   */
+  underlineColor?: string;
+  strikethrough?: boolean;
+  inverse?: boolean;
+  /**
+   * Text size scale factor via OSC 66 (Kitty v0.40+).
+   *
+   * Float multiplier: 2.0 = double (headings), 1.0 = normal, 0.5 = half (small print).
+   * The terminal renders subsequent text at this scale until reset.
+   * Requires a terminal that supports the kitty text sizing protocol.
+   * Terminals without support silently ignore the escape sequence.
+   */
+  textSize?: number;
+}
+/**
+ * Props for Box component.
+ */
+interface BoxProps extends FlexboxProps, StyleProps, TestProps, MouseEventProps, DragEventProps, FocusEventProps {
+  /** Text truncation mode for child text content (passed through to Text children). */
+  wrap?: "wrap" | "hard" | "even" | "truncate" | "truncate-start" | "truncate-middle" | "truncate-end" | "clip" | boolean;
+  borderStyle?: "single" | "double" | "round" | "bold" | "singleDouble" | "doubleSingle" | "classic";
+  borderColor?: string;
+  /** Background color for all border sides (shorthand). Per-side props override this. */
+  borderBackgroundColor?: string;
+  /** Background color for the top border (overrides borderBackgroundColor). */
+  borderTopBackgroundColor?: string;
+  /** Background color for the bottom border (overrides borderBackgroundColor). */
+  borderBottomBackgroundColor?: string;
+  /** Background color for the left border (overrides borderBackgroundColor). */
+  borderLeftBackgroundColor?: string;
+  /** Background color for the right border (overrides borderBackgroundColor). */
+  borderRightBackgroundColor?: string;
+  borderTop?: boolean;
+  borderBottom?: boolean;
+  borderLeft?: boolean;
+  borderRight?: boolean;
+  /**
+   * Outline style — renders border characters at the box edges without affecting layout.
+   *
+   * Unlike `borderStyle` which adds border dimensions to the layout (making the content
+   * area smaller), `outlineStyle` draws border characters that OVERLAP the content area.
+   * The layout engine sees no border at all — outline is purely visual.
+   *
+   * Use cases: selection indicators, hover highlights, focus rings — anything that
+   * should visually frame a box without shifting content.
+   */
+  outlineStyle?: "single" | "double" | "round" | "bold" | "singleDouble" | "doubleSingle" | "classic";
+  /** Foreground color for the outline */
+  outlineColor?: string;
+  /** Apply dim styling to the outline */
+  outlineDimColor?: boolean;
+  /** Show top outline edge (default: true) */
+  outlineTop?: boolean;
+  /** Show bottom outline edge (default: true) */
+  outlineBottom?: boolean;
+  /** Show left outline edge (default: true) */
+  outlineLeft?: boolean;
+  /** Show right outline edge (default: true) */
+  outlineRight?: boolean;
+  /**
+   * Override theme for this subtree — $token colors resolve against this theme.
+   * Pushed onto the context theme stack during render phase tree walk.
+   */
+  theme?: Theme;
+  /** CSS pointer-events equivalent. "none" makes this node and its subtree invisible to hit testing. */
+  pointerEvents?: "auto" | "none";
+  /**
+   * CSS user-select equivalent. Controls whether text in this node is selectable.
+   * - "auto" (default): inherit from parent. Root resolves to "text".
+   * - "none": not selectable. Mouse-drag on this node does not start text selection.
+   * - "text": force selectable, even if parent is "none".
+   * - "contain": selectable, but selection range cannot escape this node's bounds.
+   */
+  userSelect?: UserSelect;
+  /**
+   * Whether this node can be dragged via mouse.
+   * When true, mousedown + drag past threshold initiates a node drag gesture
+   * instead of text selection. Not inherited — only the node with draggable=true
+   * is draggable, not its children.
+   */
+  draggable?: boolean;
+  onLayout?: (layout: Rect) => void;
+  /**
+   * Show scroll overflow indicators (▲N / ▼N) for scrollable containers.
+   *
+   * For bordered containers, indicators appear on the border.
+   * For borderless containers, indicators overlay the content at top-right/bottom-right.
+   *
+   * Only applies when overflow='scroll'.
+   */
+  overflowIndicator?: boolean;
+}
+/**
+ * Props for Text component.
+ */
+interface TextProps extends StyleProps, TestProps, MouseEventProps {
+  children?: React.ReactNode;
+  wrap?: "wrap" | "hard" | "even" | "truncate" | "truncate-start" | "truncate-middle" | "truncate-end" | "clip" | boolean;
+  /** Internal transform function applied to each rendered line. Used by Transform component. */
+  internal_transform?: (line: string, index: number) => string;
+}
+/**
+ * The core Silvery node - represents an element in the render tree.
+ *
+ * Each node has:
+ * - A Yoga node for layout calculation
+ * - Computed layout after Yoga runs
+ * - Subscribers that get notified when layout changes
+ * - Dirty flags for incremental updates
+ */
+interface AgNode {
+  /** Node type */
+  type: AgNodeType;
+  /** Props passed to this node */
+  props: BoxProps | TextProps | Record<string, unknown>;
+  /** Child nodes */
+  children: AgNode[];
+  /** Parent node (null for root) */
+  parent: AgNode | null;
+  /** The layout node for layout calculation (null for raw text nodes) */
+  layoutNode: LayoutNode | null;
+  /** Computed layout from previous render (for change detection) */
+  prevLayout: Rect | null;
+  /**
+   * Content-relative position (like CSS offsetTop/offsetLeft).
+   * Position within the scrollable content, ignoring scroll offsets.
+   * Set after layout phase.
+   */
+  boxRect: Rect | null;
+  /**
+   * Screen-relative position (like CSS getBoundingClientRect).
+   * Actual position on the terminal screen, accounting for scroll offsets.
+   * Set after screen rect phase.
+   *
+   * Note: For sticky children, this reflects the node's layout position
+   * adjusted for scroll offsets, NOT the actual render position. Use
+   * `screenRect` for the actual pixel position on screen.
+   */
+  scrollRect: Rect | null;
+  /** Previous screen rect (for change detection in notifyLayoutSubscribers) */
+  prevScrollRect: Rect | null;
+  /**
+   * Actual render position on the terminal screen.
+   * For non-sticky nodes, this equals `scrollRect`.
+   * For sticky nodes (position="sticky"), this accounts for sticky render
+   * offsets — the position where pixels are actually painted.
+   *
+   * Use this for hit testing, cursor positioning, and any feature that
+   * needs to know where a node visually appears on screen.
+   * Set after screen rect phase.
+   */
+  screenRect: Rect | null;
+  /** Previous render rect (for change detection) */
+  prevScreenRect: Rect | null;
+  /** Epoch when layout changed (position or size).
+   *  Set by propagateLayout in layout phase. Compared against renderEpoch by render phase.
+   *  This is the authoritative signal for "did layout change?" — unlike
+   *  !rectEqual(prevLayout, boxRect) which becomes stale when layout
+   *  phase skips (no dirty nodes).
+   *  Value: renderEpoch when dirty, INITIAL_EPOCH (-1) when clean. */
+  layoutChangedThisFrame: number;
+  /** True if layout-affecting props changed and Yoga needs recalculation.
+   *  Set by reconciler on prop changes. Cleared after layout phase.
+   *  NOTE: layoutDirty stays boolean — it's cleared by layout phase (not render phase)
+   *  and has its own tracking set in dirty-tracking.ts. */
+  layoutDirty: boolean;
+  /**
+   * Bit-packed dirty flags for the current epoch.
+   *
+   * Seven dirty flags packed into a single number:
+   *   bit 0 (CONTENT_BIT):        content changed (text content or content-affecting props)
+   *   bit 1 (STYLE_PROPS_BIT):    visual props changed (color, bg, border, etc.)
+   *   bit 2 (BG_BIT):             backgroundColor specifically changed
+   *   bit 3 (CHILDREN_BIT):       direct children added/removed/reordered
+   *   bit 4 (SUBTREE_BIT):        this node or any descendant has dirty content/layout
+   *   bit 5 (ABS_CHILD_BIT):      absolute child had structural changes
+   *   bit 6 (DESC_OVERFLOW_BIT):  descendant overflow changed
+   *
+   * Check: `isDirty(node.dirtyBits, node.dirtyEpoch, BIT)`
+   * Set:   `node.dirtyBits = setDirtyBit(node.dirtyBits, node.dirtyEpoch, BIT); node.dirtyEpoch = getRenderEpoch()`
+   * Clear: `advanceRenderEpoch()` — all nodes instantly become clean
+   *
+   * NOTE: measure phase may clear CONTENT_BIT — STYLE_PROPS_BIT acts as the
+   * surviving witness for style changes. See render-phase.ts contentAreaAffected.
+   */
+  dirtyBits: number;
+  /**
+   * Epoch when dirtyBits was last written.
+   * When `dirtyEpoch !== renderEpoch`, all bits are stale (node is clean).
+   * Value: renderEpoch when any bit is dirty, INITIAL_EPOCH (-1) when clean.
+   */
+  dirtyEpoch: number;
+  /** Callbacks subscribed to layout changes (used by useBoxRect) */
+  layoutSubscribers: Set<() => void>;
+  /** Text content for text nodes */
+  textContent?: string;
+  /** True if this is a raw text node (created by createTextInstance) */
+  isRawText?: boolean;
+  /** True if this node is hidden (for Suspense support) */
+  hidden?: boolean;
+  /** Sticky children with computed render positions (for non-scroll containers).
+   *  When a parent has sticky children but is NOT a scroll container, this array
+   *  holds the computed render offsets. Same shape as scrollState.stickyChildren. */
+  stickyChildren?: Array<{
+    /** Index of the sticky child */index: number; /** Computed Y offset to render at (relative to parent content area) */
+    renderOffset: number; /** Original natural Y position (relative to parent content area) */
+    naturalTop: number; /** Height of the sticky element */
+    height: number;
+  }>;
+  /** Inline rects for virtual text nodes (no layout node). Computed during text rendering.
+   *  Array for wrapped text (one rect per line fragment). Enables hit testing on nested Text. */
+  inlineRects?: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }> | null;
+  /**
+   * Interactive state signals — written by pointer/selection/focus state machines,
+   * read by theme/render for automatic styling (hover highlights, focus rings, etc.).
+   *
+   * Lazily created on first write. Null means no interactive state has been set.
+   * See InteractiveState for field docs.
+   */
+  interactiveState?: InteractiveState | null;
+  /** Scroll state for overflow='scroll' containers */
+  scrollState?: {
+    /** Current scroll offset (in terminal rows) */offset: number; /** Previous scroll offset from last render (for incremental rendering) */
+    prevOffset: number; /** Total content height (all children) */
+    contentHeight: number; /** Visible height (container height minus borders/padding) */
+    viewportHeight: number; /** Index of first visible child */
+    firstVisibleChild: number; /** Index of last visible child */
+    lastVisibleChild: number; /** Previous first visible child from last render (for incremental rendering) */
+    prevFirstVisibleChild: number; /** Previous last visible child from last render (for incremental rendering) */
+    prevLastVisibleChild: number; /** Count of items hidden above viewport */
+    hiddenAbove: number; /** Count of items hidden below viewport */
+    hiddenBelow: number; /** Sticky children with their computed render positions */
+    stickyChildren?: Array<{
+      /** Index of the sticky child */index: number; /** Computed Y offset to render at (relative to viewport, not content) */
+      renderOffset: number; /** Original natural Y position (before sticky adjustment) */
+      naturalTop: number; /** Height of the sticky element */
+      height: number;
+    }>;
+  };
+}
+/**
+ * Keyboard event with key information and modifiers.
+ */
+interface KeyEvent {
+  type: "key";
+  /** The key pressed (character or key name like 'ArrowUp') */
+  key: string;
+  /** Ctrl modifier was held */
+  ctrl?: boolean;
+  /** Meta/Alt modifier was held */
+  meta?: boolean;
+  /** Shift modifier was held */
+  shift?: boolean;
+  /** Alt/Option modifier was held */
+  alt?: boolean;
+  /** Super/Cmd modifier was held. Requires Kitty protocol. */
+  super?: boolean;
+  /** Hyper modifier was held. Requires Kitty protocol. */
+  hyper?: boolean;
+  /** Kitty event type. Requires Kitty flag 2. */
+  eventType?: "press" | "repeat" | "release";
+  /** CapsLock is active. Kitty modifier bit 6. */
+  capsLock?: boolean;
+  /** NumLock is active. Kitty modifier bit 7. */
+  numLock?: boolean;
+}
+/**
+ * Mouse event with position and button information.
+ */
+interface MouseEvent {
+  type: "mouse";
+  /** X position in terminal columns (0-indexed) */
+  x: number;
+  /** Y position in terminal rows (0-indexed) */
+  y: number;
+  /** Mouse button (0=left, 1=middle, 2=right) */
+  button: number;
+  /** Event action */
+  action: "down" | "up" | "move" | "wheel";
+  /** Wheel delta for scroll events */
+  delta?: number;
+}
+/**
+ * Terminal resize event.
+ */
+interface ResizeEvent {
+  type: "resize";
+  /** New width in columns */
+  width: number;
+  /** New height in rows */
+  height: number;
+}
+/**
+ * Terminal focus event.
+ */
+interface FocusEvent {
+  type: "focus";
+}
+/**
+ * Terminal blur event.
+ */
+interface BlurEvent {
+  type: "blur";
+}
+/**
+ * Signal event (SIGINT, SIGTERM, etc.).
+ */
+interface SignalEvent {
+  type: "signal";
+  /** Signal name (e.g., 'SIGINT', 'SIGTERM') */
+  signal: string;
+}
+/**
+ * Custom event for extensibility.
+ */
+interface CustomEvent {
+  type: "custom";
+  /** Event name */
+  name: string;
+  /** Event data */
+  data: unknown;
+}
+/**
+ * Union of all event types.
+ *
+ * Events drive the render loop in interactive mode. When events are present,
+ * the render loop runs until exit() is called. When events are absent,
+ * the render completes when the UI is stable.
+ */
+type Event$1 = KeyEvent | MouseEvent | ResizeEvent | FocusEvent | BlurEvent | SignalEvent | CustomEvent;
+/**
+ * Event source that can be subscribed to and unsubscribed from.
+ */
+interface EventSource {
+  /** Subscribe to events, returns unsubscribe function */
+  subscribe(handler: (event: Event$1) => void): () => void;
+  /** Convert to async iterable */
+  [Symbol.asyncIterator](): AsyncIterator<Event$1>;
+}
+//#endregion
+//#region packages/ag-term/src/ansi/types.d.ts
+/**
+ * Console method names that can be intercepted.
+ */
+type ConsoleMethod = "log" | "info" | "warn" | "error" | "debug";
+/**
+ * Entry captured from console.
+ */
+interface ConsoleEntry {
+  method: ConsoleMethod;
+  args: unknown[];
+  stream: "stdout" | "stderr";
+}
+/**
+ * Options for createTerm().
+ */
+interface CreateTermOptions {
+  stdout?: NodeJS.WriteStream;
+  stdin?: NodeJS.ReadStream;
+  color?: ColorLevel | null;
+  unicode?: boolean;
+  cursor?: boolean;
+  caps?: Partial<TerminalCaps>;
+}
+/**
+ * A screen region — duck-type matching termless RegionView.
+ * Provides text content, line access, and cell-level queries for assertions.
+ */
+interface TermScreen {
+  getText(): string;
+  getLines(): string[];
+  containsText?(text: string): boolean;
+  /** Cell-level access — row-first order. Returns resolved RGB colors.
+   *  Only available on emulator-backed terms (createTermless). */
+  cell?(row: number, col: number): {
+    readonly fg: unknown;
+    readonly bg: unknown;
+    readonly char: string;
+  };
+}
+/**
+ * A terminal emulator — duck-type matching termless Terminal.
+ * Accepts ANSI output, provides screen/scrollback for inspection.
+ */
+interface TermEmulator {
+  readonly cols: number;
+  readonly rows: number;
+  readonly screen: TermScreen;
+  readonly scrollback: TermScreen;
+  feed(data: Uint8Array | string): void;
+  resize(cols: number, rows: number): void;
+  close(): Promise<void>;
+}
+/**
+ * A terminal emulator backend — duck-type matching termless TerminalBackend.
+ * Raw backend that needs initialization. Pass to createTerm(backend, { cols, rows }).
+ *
+ * @example
+ * ```ts
+ * import { createXtermBackend } from "@termless/xtermjs"
+ * using term = createTerm(createXtermBackend(), { cols: 80, rows: 24 })
+ * ```
+ */
+interface TermEmulatorBackend {
+  readonly name: string;
+  init(opts: {
+    cols: number;
+    rows: number;
+    scrollbackLimit?: number;
+  }): void;
+  destroy(): void;
+  feed(data: Uint8Array): void;
+  resize(cols: number, rows: number): void;
+}
+//#endregion
+//#region packages/ag/src/text-frame.d.ts
+/**
+ * TextFrame — Unified interface for a rectangular area of styled terminal text.
+ *
+ * Used by App, RunHandle, term.screen, term.scrollback — one shape everywhere.
+ * Provides plain text, ANSI-styled text, per-line access, cell-level queries,
+ * and text search.
+ *
+ * @packageDocumentation
+ */
+/**
+ * RGB color value (0-255 per channel).
+ */
+interface RGB {
+  r: number;
+  g: number;
+  b: number;
+}
+/**
+ * A single cell in a TextFrame with resolved styling.
+ *
+ * Colors are resolved to RGB (or null for default/inherit).
+ * Attributes are flattened booleans for easy testing.
+ */
+interface FrameCell {
+  /** The character/grapheme in this cell */
+  readonly char: string;
+  /** Resolved foreground color, or null for default */
+  readonly fg: RGB | null;
+  /** Resolved background color, or null for default */
+  readonly bg: RGB | null;
+  /** Bold attribute */
+  readonly bold: boolean;
+  /** Dim/faint attribute */
+  readonly dim: boolean;
+  /** Italic attribute */
+  readonly italic: boolean;
+  /** Underline style — false if none */
+  readonly underline: UnderlineStyle$1;
+  /** Underline color (independent of fg), or null to use fg */
+  readonly underlineColor: RGB | null;
+  /** Strikethrough attribute */
+  readonly strikethrough: boolean;
+  /** Inverse/reverse video attribute */
+  readonly inverse: boolean;
+  /** Blink attribute */
+  readonly blink: boolean;
+  /** Hidden/invisible attribute */
+  readonly hidden: boolean;
+  /** True if this is a wide character (CJK, emoji) */
+  readonly wide: boolean;
+  /** True if this cell is the continuation of a wide character */
+  readonly continuation: boolean;
+  /** OSC 8 hyperlink URL, or null if none */
+  readonly hyperlink: string | null;
+}
+/**
+ * Unified interface for a rectangular area of styled terminal text.
+ *
+ * Implemented by App, RunHandle, and terminal views (screen, scrollback).
+ * Provides consistent access to text content, styling, and cell-level data.
+ */
+interface TextFrame {
+  /** Plain text content (no ANSI codes). Lines separated by newlines. */
+  readonly text: string;
+  /** Text with ANSI styling escape codes. */
+  readonly ansi: string;
+  /** Per-line plain text array (no ANSI codes). */
+  readonly lines: string[];
+  /** Frame width in terminal columns. */
+  readonly width: number;
+  /** Frame height in terminal rows. */
+  readonly height: number;
+  /** Get the cell at the given column and row. */
+  cell(col: number, row: number): FrameCell;
+  /** Check whether the plain text contains the given substring. */
+  containsText(text: string): boolean;
+}
+//#endregion
+//#region packages/ag-term/src/buffer.d.ts
+/**
+ * Terminal buffer implementation for Silvery.
+ *
+ * Uses packed Uint32Array for efficient cell metadata storage,
+ * with separate string array for character storage (needed for
+ * multi-byte Unicode graphemes and combining characters).
+ */
+/**
+ * Underline style variants (SGR 4:x codes).
+ * - false: no underline
+ * - 'single': standard underline (SGR 4 or 4:1)
+ * - 'double': double underline (SGR 4:2)
+ * - 'curly': curly/wavy underline (SGR 4:3)
+ * - 'dotted': dotted underline (SGR 4:4)
+ * - 'dashed': dashed underline (SGR 4:5)
+ */
+type UnderlineStyle = false | "single" | "double" | "curly" | "dotted" | "dashed";
+/**
+ * Text attributes that can be applied to a cell.
+ */
+interface CellAttrs {
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  /** Simple underline flag (for backwards compatibility) */
+  underline?: boolean;
+  /**
+   * Underline style: 'single' | 'double' | 'curly' | 'dotted' | 'dashed'.
+   * When set, takes precedence over the underline boolean.
+   */
+  underlineStyle?: UnderlineStyle;
+  blink?: boolean;
+  inverse?: boolean;
+  hidden?: boolean;
+  strikethrough?: boolean;
+}
+/**
+ * Color representation.
+ * - number: 256-color index (0-255)
+ * - RGB object: true color
+ * - null: default/inherit
+ * - DEFAULT_BG: terminal's default background (SGR 49), opaque but uses terminal's own bg color
+ */
+type Color = number | {
+  r: number;
+  g: number;
+  b: number;
+} | null;
+/**
+ * A single cell in the terminal buffer.
+ */
+interface Cell {
+  /** The character/grapheme in this cell */
+  char: string;
+  /** Foreground color */
+  fg: Color;
+  /** Background color */
+  bg: Color;
+  /**
+   * Underline color (independent of fg).
+   * Uses SGR 58. If null, underline uses fg color.
+   */
+  underlineColor: Color;
+  /** Text attributes */
+  attrs: CellAttrs;
+  /** True if this is a wide character (CJK, emoji, etc.) */
+  wide: boolean;
+  /** True if this is the continuation cell after a wide character */
+  continuation: boolean;
+  /**
+   * OSC 8 hyperlink URL.
+   * When set, the cell is part of a clickable hyperlink in supporting terminals.
+   */
+  hyperlink?: string;
+}
+/**
+ * Style information for a cell (excludes char and position flags).
+ */
+interface Style {
+  fg: Color;
+  bg: Color;
+  /**
+   * Underline color (independent of fg).
+   * Uses SGR 58. If null, underline uses fg color.
+   */
+  underlineColor?: Color;
+  attrs: CellAttrs;
+  /**
+   * OSC 8 hyperlink URL.
+   * When set, the cell is part of a clickable hyperlink in supporting terminals.
+   */
+  hyperlink?: string;
+}
+/**
+ * Per-row metadata for text extraction correctness.
+ * Maintained by the render phase during text rendering.
+ */
+interface RowMetadata {
+  /** True if this row continues on the next row (soft wrap, not hard break) */
+  softWrapped: boolean;
+  /** Rightmost column with non-space content (for trailing space trimming) */
+  lastContentCol: number;
+}
+/**
+ * Efficient terminal cell buffer.
+ *
+ * Uses packed Uint32Array for cell metadata and separate string array
+ * for characters. This allows efficient diffing while supporting
+ * full Unicode grapheme clusters.
+ */
+declare class TerminalBuffer {
+  /** Packed cell metadata */
+  private cells;
+  /** Character storage (one per cell, may be multi-byte grapheme) */
+  private chars;
+  /** True color foreground storage (only for cells with true color fg) */
+  private fgColors;
+  /** True color background storage (only for cells with true color bg) */
+  private bgColors;
+  /** Underline color storage (independent of fg, for SGR 58) */
+  private underlineColors;
+  /** OSC 8 hyperlink URL storage (only for cells that are part of a hyperlink) */
+  private hyperlinks;
+  /**
+   * Per-row dirty tracking for diff optimization.
+   * When set, diffBuffers() can skip clean rows entirely.
+   * 0 = clean (unchanged since last resetDirtyRows), 1 = dirty (modified).
+   */
+  private _dirtyRows;
+  /** Bounding box: first dirty row (inclusive). -1 when no rows are dirty. */
+  private _minDirtyRow;
+  /** Bounding box: last dirty row (inclusive). -1 when no rows are dirty. */
+  private _maxDirtyRow;
+  /**
+   * Per-row metadata for text extraction (soft wrap, last content column).
+   * Set by the render phase, read by extractText.
+   */
+  private _rowMetadata;
+  /**
+   * When true, setCell and fill automatically stamp SELECTABLE_FLAG on written cells.
+   * Set/cleared by the render phase as it traverses nodes with different userSelect values.
+   * This avoids modifying every individual setCell call — zero overhead (single OR per cell).
+   */
+  private _selectableMode;
+  readonly width: number;
+  readonly height: number;
+  constructor(width: number, height: number);
+  /**
+   * Get the index for a cell position.
+   */
+  private index;
+  /**
+   * Check if coordinates are within bounds.
+   */
+  inBounds(x: number, y: number): boolean;
+  /**
+   * Get a cell at the given position.
+   */
+  getCell(x: number, y: number): Cell;
+  /**
+   * Get just the character at a cell position (no object allocation).
+   * Returns " " for out-of-bounds positions.
+   */
+  getCellChar(x: number, y: number): string;
+  /**
+   * Get just the background color at a cell position (no object allocation).
+   * Returns null for out-of-bounds positions.
+   */
+  getCellBg(x: number, y: number): Color;
+  /**
+   * Get just the foreground color at a cell position (no object allocation).
+   * Returns null for out-of-bounds positions.
+   */
+  getCellFg(x: number, y: number): Color;
+  /**
+   * Get the raw packed metadata at a cell position (no unpackAttrs allocation).
+   * Returns 0 for out-of-bounds positions. The packed value contains color
+   * indices, attr bits, underline style, and flags in a single Uint32.
+   */
+  getCellAttrs(x: number, y: number): number;
+  /**
+   * Check if a cell is a wide character (no object allocation).
+   * Returns false for out-of-bounds positions.
+   */
+  isCellWide(x: number, y: number): boolean;
+  /**
+   * Check if a cell is a continuation of a wide character (no object allocation).
+   * Returns false for out-of-bounds positions.
+   */
+  isCellContinuation(x: number, y: number): boolean;
+  /**
+   * Check if a cell is selectable (SELECTABLE_FLAG is set, no object allocation).
+   * Returns false for out-of-bounds positions.
+   */
+  isCellSelectable(x: number, y: number): boolean;
+  /**
+   * Set metadata for a row (soft wrap, last content column).
+   * Called by the render phase during text rendering.
+   */
+  setRowMeta(row: number, meta: Partial<RowMetadata>): void;
+  /**
+   * Get metadata for a row. Returns default values for out-of-bounds rows.
+   */
+  getRowMeta(row: number): RowMetadata;
+  /**
+   * Get the full row metadata array (for bulk access during text extraction).
+   */
+  getRowMetadataArray(): readonly RowMetadata[];
+  /**
+   * Enable/disable automatic SELECTABLE_FLAG stamping on cell writes.
+   * When true, all setCell/fill calls stamp SELECTABLE_FLAG on the packed metadata.
+   * Zero overhead: a single OR per cell when enabled.
+   */
+  setSelectableMode(selectable: boolean): void;
+  /**
+   * Get the current selectable mode.
+   */
+  getSelectableMode(): boolean;
+  /**
+   * Read cell data into a caller-provided Cell object (zero-allocation).
+   * For hot loops that need the full Cell, reuse a single object:
+   *
+   *   const cell = createMutableCell()
+   *   for (...) { buffer.readCellInto(x, y, cell) }
+   *
+   * Returns the same `out` object for chaining convenience.
+   */
+  readCellInto(x: number, y: number, out: Cell): Cell;
+  /**
+   * Set a cell at the given position.
+   *
+   * Optimized: resolves defaults and packs metadata inline to avoid
+   * allocating an intermediate Cell object.
+   */
+  setCell(x: number, y: number, cell: Partial<Cell>): void;
+  /**
+   * Fill a region with a cell.
+   *
+   * Optimized: packs cell metadata once and assigns directly to arrays,
+   * avoiding O(width*height) intermediate object allocations from setCell().
+   */
+  fill(x: number, y: number, width: number, height: number, cell: Partial<Cell>): void;
+  /**
+   * Restyle a rectangular region — update fg, bg, and attrs on existing cells
+   * without changing character content (char, wide, continuation, hyperlink).
+   *
+   * This is the style-only fast path: when only visual props changed (color,
+   * bold, dim, inverse, etc.) but text content and layout are identical, we
+   * can skip text collection/formatting and just update the style metadata.
+   *
+   * @param x      Left column (inclusive)
+   * @param y      Top row (inclusive)
+   * @param width  Region width
+   * @param height Region height
+   * @param style  New style to apply (fg, bg, attrs, underlineColor)
+   */
+  restyleRegion(x: number, y: number, width: number, height: number, style: Style): void;
+  /**
+   * Fill only the background color of a region — update bg on existing cells
+   * without changing character content, foreground, or attributes.
+   *
+   * Unlike fill() which writes space characters, this preserves existing chars.
+   * Used by the style-only fast path: when a Box's backgroundColor changes but
+   * children are unchanged, fillBg() paints the new bg without destroying child
+   * chars. Clean children can then be skipped (their chars are correct from the
+   * clone, their bg was updated by fillBg).
+   *
+   * @param x      Left column (inclusive)
+   * @param y      Top row (inclusive)
+   * @param width  Region width
+   * @param height Region height
+   * @param bg     New background color
+   */
+  fillBg(x: number, y: number, width: number, height: number, bg: Color): void;
+  /**
+   * Clear the buffer (fill with empty cells).
+   */
+  clear(): void;
+  /**
+   * Copy a region from another buffer.
+   */
+  copyFrom(source: TerminalBuffer, srcX: number, srcY: number, destX: number, destY: number, width: number, height: number): void;
+  /**
+   * Shift content within a rectangular region vertically by `delta` rows.
+   * Positive delta = shift content UP (scroll down), negative = shift DOWN (scroll up).
+   * Exposed rows (at the bottom for positive delta, top for negative) are filled
+   * with the given background cell.
+   *
+   * Uses Uint32Array.copyWithin for the packed cells (native memcpy) and
+   * Array splice for the character array.
+   */
+  scrollRegion(x: number, y: number, regionWidth: number, regionHeight: number, delta: number, clearCell?: Partial<Cell>): void;
+  /**
+   * Clone this buffer.
+   */
+  clone(): TerminalBuffer;
+  /**
+   * Check if a row has been modified since the last resetDirtyRows() call.
+   * Used by diffBuffers() to skip unchanged rows.
+   */
+  isRowDirty(y: number): boolean;
+  /** First dirty row (inclusive), or -1 if no rows are dirty. */
+  get minDirtyRow(): number;
+  /** Last dirty row (inclusive), or -1 if no rows are dirty. */
+  get maxDirtyRow(): number;
+  /**
+   * Reset all dirty row flags to clean.
+   * Call after diffing to prepare for the next frame's modifications.
+   */
+  resetDirtyRows(): void;
+  /**
+   * Mark all rows as dirty.
+   * Used when the buffer's dirty rows may not cover all changes relative
+   * to a different prev buffer (e.g., after multiple doRender calls where
+   * the runtime's prevBuffer skipped intermediate buffers).
+   */
+  markAllRowsDirty(): void;
+  /**
+   * Check if two cells at given positions are equal.
+   * Used for diffing.
+   */
+  cellEquals(x: number, y: number, other: TerminalBuffer): boolean;
+  /**
+   * Fast check: are all packed metadata values identical for a row?
+   * This is a bulk pre-check before per-cell comparison. If metadata differs,
+   * we still need per-cell diffing. If metadata matches, we only need to
+   * check chars, true color maps, underline colors, and hyperlinks.
+   * Returns true if all packed 32-bit values in the row are identical.
+   */
+  rowMetadataEquals(y: number, other: TerminalBuffer): boolean;
+  /**
+   * Fast check: are all characters identical for a row?
+   * Companion to rowMetadataEquals for a two-phase row comparison.
+   */
+  rowCharsEquals(y: number, other: TerminalBuffer): boolean;
+  /**
+   * Check Map-based extras for a row: true color fg/bg, underline colors, hyperlinks.
+   * Must be called AFTER rowMetadataEquals confirms packed metadata matches.
+   * Only checks cells that have true color flags set (the Maps are only populated
+   * for those cells). Also checks underline colors and hyperlinks for all cells.
+   */
+  rowExtrasEquals(y: number, other: TerminalBuffer): boolean;
+}
+//#endregion
+//#region packages/ag-term/src/runtime/types.d.ts
+/**
+ * Dimensions for rendering.
+ */
+interface Dims {
+  cols: number;
+  rows: number;
+}
+/**
+ * Immutable render output buffer.
+ *
+ * Contains:
+ * - text: Plain text without ANSI codes (for assertions)
+ * - ansi: Styled output with ANSI escape codes
+ * - nodes: Internal node tree for locator queries
+ */
+interface Buffer$1 {
+  /** Plain text without ANSI codes */
+  readonly text: string;
+  /** Styled output with ANSI escape codes */
+  readonly ansi: string;
+  /** Internal node tree for locator queries */
+  readonly nodes: AgNode;
+  /** Raw terminal buffer for diffing */
+  readonly _buffer: TerminalBuffer;
+}
+/**
+ * Event types from the runtime.
+ */
+type Event = {
+  type: "key";
+  key: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  shift?: boolean;
+} | {
+  type: "mouse";
+  button: number;
+  x: number;
+  y: number;
+  action: "down" | "up" | "move" | "wheel";
+  delta?: number;
+  shift: boolean;
+  meta: boolean;
+  ctrl: boolean;
+} | {
+  type: "paste";
+  content: string;
+} | {
+  type: "resize";
+  cols: number;
+  rows: number;
+} | {
+  type: "tick";
+  time: number;
+} | {
+  type: "effect";
+  id: string;
+  result: unknown;
+} | {
+  type: "error";
+  error: Error;
+};
+/**
+ * Render target interface - abstracts terminal output.
+ */
+interface RenderTarget {
+  /** Write rendered frame to output */
+  write(frame: string): void;
+  /** Get current dimensions */
+  getDims(): Dims;
+  /** Subscribe to resize events */
+  onResize?(handler: (dims: Dims) => void): () => void;
+}
+/**
+ * Runtime options for createRuntime().
+ */
+interface RuntimeOptions {
+  /** Render target (terminal, test mock, etc.) */
+  target: RenderTarget;
+  /** Abort signal for cleanup */
+  signal?: AbortSignal;
+  /** Render mode: fullscreen (alt screen) or inline (scrollback-compatible) */
+  mode?: "fullscreen" | "inline";
+  /** Scoped output phase function (from createOutputPhase/createPipeline). When provided,
+   *  runtime.render() uses this instead of the raw outputPhase — ensures measurer/caps are threaded. */
+  outputPhaseFn?: (prev: TerminalBuffer | null, next: TerminalBuffer, mode?: "fullscreen" | "inline", scrollbackOffset?: number, termRows?: number) => string;
+}
+/**
+ * The runtime kernel interface.
+ */
+interface Runtime {
+  /** Event stream - yields until disposed */
+  events(): AsyncIterable<Event>;
+  /** Schedule an effect with optional cancellation */
+  schedule<T>(effect: () => Promise<T>, opts?: {
+    signal?: AbortSignal;
+  }): void;
+  /** Render a buffer to the target */
+  render(buffer: Buffer$1): void;
+  /** Report lines written to stdout between renders (inline mode only) */
+  addScrollbackLines(lines: number): void;
+  /** Reset diff state so next render outputs a full frame */
+  invalidate(): void;
+  /** Update the output phase function (e.g., after text sizing probe changes measurer) */
+  setOutputPhaseFn(fn: RuntimeOptions["outputPhaseFn"]): void;
+  /** Reset inline cursor tracking state (inline mode only).
+   *  Called by useScrollback before re-emitting frozen items on resize. */
+  resetInlineCursor(): void;
+  /** Get inline cursor row relative to render region start. -1 if unknown. */
+  getInlineCursorRow(): number;
+  /** Promote frozen content to scrollback via the output phase.
+   *  Content is written in a single frame with the live render — no flicker. */
+  promoteScrollback(content: string, lines: number): void;
+  /** Get current dimensions */
+  getDims(): Dims;
+  /** Dispose and cleanup - idempotent */
+  [Symbol.dispose](): void;
+}
+/**
+ * Event emitted by a provider, tagged with event type.
+ */
+type ProviderEvent<Events extends Record<string, unknown>> = { [K in keyof Events]: {
+  type: K;
+  data: Events[K];
+} }[keyof Events];
+/**
+ * Provider interface - unified store + event source.
+ *
+ * Providers are the building blocks of silvery-loop applications.
+ * They encapsulate:
+ * - State (Zustand-compatible: getState/subscribe)
+ * - Events (AsyncIterable of typed events)
+ * - Cleanup (Symbol.dispose)
+ *
+ * @example
+ * ```typescript
+ * type TermProvider = Provider<
+ *   { cols: number; rows: number },
+ *   { key: { input: string; key: Key }; resize: Dims }
+ * >;
+ * ```
+ */
+interface Provider<State = unknown, Events extends Record<string, unknown> = Record<string, never>> {
+  /** Get current state (Zustand-compatible) */
+  getState(): State;
+  /** Subscribe to state changes (Zustand-compatible) */
+  subscribe(listener: (state: State) => void): () => void;
+  /** Event stream - yields typed events until disposed */
+  events(): AsyncIterable<ProviderEvent<Events>>;
+  /** Cleanup resources */
+  [Symbol.dispose](): void;
+}
+/**
+ * Extract the namespaced event type from a providers map.
+ *
+ * Given { term: TermProvider, sync: SyncProvider }, produces:
+ * | { type: 'term:key'; data: { input: string; key: Key } }
+ * | { type: 'term:resize'; data: Dims }
+ * | { type: 'sync:data'; data: Item[] }
+ * | ...
+ */
+type NamespacedEvent<Providers extends Record<string, Provider<unknown, Record<string, unknown>>>> = { [P in keyof Providers]: Providers[P] extends Provider<unknown, infer E> ? { [K in keyof E & string]: {
+  type: `${P & string}:${K}`;
+  data: E[K];
+} }[keyof E & string] : never }[keyof Providers];
+/**
+ * Extract all event keys from a providers map.
+ *
+ * Given { term: TermProvider, sync: SyncProvider }, produces:
+ * 'term:key' | 'term:resize' | 'sync:data' | ...
+ */
+type ProviderEventKey<Providers extends Record<string, Provider<unknown, Record<string, unknown>>>> = NamespacedEvent<Providers>["type"];
+/**
+ * Get the data type for a specific event key.
+ */
+type EventData<Providers extends Record<string, Provider<unknown, Record<string, unknown>>>, K extends ProviderEventKey<Providers>> = Extract<NamespacedEvent<Providers>, {
+  type: K;
+}>["data"];
+//#endregion
+//#region packages/ag-term/src/mouse.d.ts
+/**
+ * SGR mouse event parsing (mode 1006).
+ *
+ * SGR format: CSI < button;x;y M (press) or CSI < button;x;y m (release)
+ *
+ * Button encoding:
+ * - Bits 0-1: 0=left, 1=middle, 2=right, 3=release (X10 only, not SGR)
+ * - Bit 2 (+4): Shift held
+ * - Bit 3 (+8): Meta/Alt held
+ * - Bit 4 (+16): Ctrl held
+ * - Bit 5 (+32): Motion event (mouse moved while button held)
+ * - Bits 6-7: 64=wheel-up, 65=wheel-down, 66=wheel-left, 67=wheel-right
+ */
+/**
+ * Parsed mouse event from SGR mouse protocol (mode 1006).
+ */
+interface ParsedMouse {
+  /** Mouse button: 0=left, 1=middle, 2=right */
+  button: number;
+  /** Column (0-indexed) */
+  x: number;
+  /** Row (0-indexed) */
+  y: number;
+  /** Event action */
+  action: "down" | "up" | "move" | "wheel";
+  /** Wheel delta: -1 for up, +1 for down */
+  delta?: number;
+  /** Shift was held */
+  shift: boolean;
+  /** Alt/Meta was held */
+  meta: boolean;
+  /** Ctrl was held */
+  ctrl: boolean;
+}
+/**
+ * Parse an SGR mouse sequence.
+ *
+ * @returns ParsedMouse or null if not a valid mouse sequence
+ */
+declare function parseMouseSequence(input: string): ParsedMouse | null;
+/** Check if a raw input string is a mouse sequence */
+declare function isMouseSequence(input: string): boolean;
+//#endregion
+//#region packages/ag-term/src/runtime/term-provider.d.ts
+/**
+ * Terminal state.
+ */
+interface TermState {
+  cols: number;
+  rows: number;
+}
+/**
+ * Terminal events.
+ */
+interface TermEvents {
+  key: {
+    input: string;
+    key: Key;
+  };
+  mouse: ParsedMouse;
+  paste: {
+    text: string;
+  };
+  resize: Dims;
+  focus: {
+    focused: boolean;
+  };
+  [key: string]: unknown;
+}
+/**
+ * Terminal provider type.
+ */
+type TermProvider = Provider<TermState, TermEvents>;
+/**
+ * Options for createTermProvider.
+ */
+interface TermProviderOptions {
+  /** Initial columns (default: from stdout or 80) */
+  cols?: number;
+  /** Initial rows (default: from stdout or 24) */
+  rows?: number;
+}
+/**
+ * Create a terminal provider from stdin/stdout.
+ *
+ * The provider:
+ * - Exposes terminal dimensions as state
+ * - Yields keyboard and resize events
+ * - Cleans up stdin/stdout listeners on dispose
+ */
+declare function createTermProvider(stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, options?: TermProviderOptions): TermProvider;
+//#endregion
+//#region packages/ag-term/src/ansi/term.d.ts
+/**
+ * All chalk style method names that can be chained.
+ */
+type ChalkStyleName = "reset" | "bold" | "dim" | "italic" | "underline" | "overline" | "inverse" | "hidden" | "strikethrough" | "visible" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+/**
+ * StyleChain provides chainable styling methods.
+ * Each property returns a new chain, and the chain is callable.
+ */
+type StyleChain = {
+  /**
+   * Apply styles to text.
+   */
+  (text: string): string;
+  (template: TemplateStringsArray, ...values: unknown[]): string;
+  /**
+   * RGB foreground color.
+   */
+  rgb(r: number, g: number, b: number): StyleChain;
+  /**
+   * Hex foreground color.
+   */
+  hex(color: string): StyleChain;
+  /**
+   * 256-color foreground.
+   */
+  ansi256(code: number): StyleChain;
+  /**
+   * RGB background color.
+   */
+  bgRgb(r: number, g: number, b: number): StyleChain;
+  /**
+   * Hex background color.
+   */
+  bgHex(color: string): StyleChain;
+  /**
+   * 256-color background.
+   */
+  bgAnsi256(code: number): StyleChain;
+} & {
+  /**
+   * Chainable style properties.
+   */
+readonly [K in ChalkStyleName]: StyleChain };
+/**
+ * Term — the central abstraction for terminal interaction.
+ *
+ * Term is both a styling helper (chainable ANSI via Proxy) and a
+ * Provider (state + typed events). Pass it to `run()` or `createApp()`.
+ *
+ * Provides:
+ * - Capability detection (cached on creation)
+ * - Dimensions (live from stream)
+ * - I/O (stdout, stdin, write, writeLine)
+ * - Provider (getState, subscribe, events — key/mouse/resize)
+ * - Styling (chainable via Proxy)
+ * - Disposable lifecycle
+ *
+ * @example
+ * ```ts
+ * using term = createTerm()
+ * await run(<App />, term)
+ * ```
+ */
+interface Term extends Disposable, StyleChain {
+  /**
+   * Check if terminal supports cursor control (repositioning).
+   * Returns false for dumb terminals and piped output.
+   */
+  hasCursor(): boolean;
+  /**
+   * Check if terminal can read raw keystrokes.
+   * Requires stdin to be a TTY with raw mode support.
+   */
+  hasInput(): boolean;
+  /**
+   * Check color level supported by terminal.
+   * Returns null if no color support.
+   */
+  hasColor(): ColorLevel | null;
+  /**
+   * Check if terminal can render unicode symbols.
+   */
+  hasUnicode(): boolean;
+  /**
+   * Terminal capabilities profile.
+   * Detected when stdin is a TTY, undefined otherwise.
+   * Override via createTerm({ caps: { ... } }).
+   */
+  readonly caps: TerminalCaps | undefined;
+  /**
+   * Terminal width in columns.
+   * Undefined if not a TTY or dimensions unavailable.
+   */
+  readonly cols: number | undefined;
+  /**
+   * Terminal height in rows.
+   * Undefined if not a TTY or dimensions unavailable.
+   */
+  readonly rows: number | undefined;
+  /**
+   * Output stream (defaults to process.stdout).
+   */
+  readonly stdout: NodeJS.WriteStream;
+  /**
+   * Input stream (defaults to process.stdin).
+   */
+  readonly stdin: NodeJS.ReadStream;
+  /**
+   * Write string to stdout.
+   */
+  write(str: string): void;
+  /**
+   * Write string followed by newline to stdout.
+   */
+  writeLine(str: string): void;
+  /**
+   * Get current terminal state (dimensions).
+   * Always returns defined values (falls back to 80x24).
+   */
+  getState(): TermState;
+  /**
+   * Subscribe to terminal state changes (resize).
+   * Returns unsubscribe function.
+   */
+  subscribe(listener: (state: TermState) => void): () => void;
+  /**
+   * Event stream — yields typed key, mouse, and resize events.
+   * Enables raw mode on stdin when iterated. Cleans up on return.
+   */
+  events(): AsyncIterable<ProviderEvent<TermEvents>>;
+  /**
+   * Strip ANSI escape codes from string.
+   */
+  stripAnsi(str: string): string;
+  /**
+   * Visible screen region. Only available when created with a terminal backend.
+   * Provides getText(), getLines(), containsText() for assertions.
+   */
+  readonly screen?: TermScreen;
+  /**
+   * Scrollback region. Only available when created with a terminal backend.
+   * Provides getText(), getLines(), containsText() for assertions.
+   */
+  readonly scrollback?: TermScreen;
+  /**
+   * Cell-level access for the visible screen — row-first order.
+   * Returns resolved RGB colors, attributes, wide-char info.
+   * Only available on emulator-backed terms (createTermless).
+   */
+  cell?(row: number, col: number): {
+    readonly fg: unknown;
+    readonly bg: unknown;
+    readonly char: string;
+  };
+  /**
+   * Row-level access for the visible screen.
+   * Only available on emulator-backed terms (createTermless).
+   */
+  row?(n: number): {
+    getText(): string;
+    cell(col: number): {
+      readonly fg: unknown;
+      readonly bg: unknown;
+      readonly char: string;
+    };
+  };
+  /**
+   * Resize the terminal emulator. Only available when created with a terminal backend.
+   * Resizes the underlying emulator and triggers a re-render in the app.
+   */
+  resize?(cols: number, rows: number): void;
+  /**
+   * Paint a rendered buffer to produce ANSI output.
+   * Diffs buffer against prev (fresh render if prev is null).
+   * Updates term.frame with an immutable TextFrame snapshot.
+   * Returns the ANSI output string.
+   * For emulator backends, also feeds the output to the emulator.
+   * For headless terms, returns empty string.
+   */
+  paint?(buffer: TerminalBuffer, prev: TerminalBuffer | null): string;
+  /**
+   * Last painted TextFrame. Set after each paint() call.
+   * Immutable snapshot with cell-level access and resolved RGB colors.
+   */
+  readonly frame?: TextFrame;
+}
+/**
+ * Create a Term instance.
+ *
+ * Factory overloads:
+ * - `createTerm()` — Node.js terminal (auto-detect from process.stdin/stdout)
+ * - `createTerm({ stdout, stdin, ... })` — Node.js with custom streams/overrides
+ * - `createTerm({ cols, rows })` — Headless for testing (no I/O, fixed dims)
+ * - `createTerm(backend, { cols, rows })` — Terminal emulator backend (termless) for testing
+ * - `createTerm(emulator)` — Pre-created termless Terminal
+ *
+ * Detection results are cached at creation time for consistency.
+ *
+ * @example
+ * ```ts
+ * // Full terminal app
+ * using term = createTerm()
+ * await run(<App />, term)
+ *
+ * // Headless for testing
+ * const term = createTerm({ cols: 80, rows: 24 })
+ *
+ * // Terminal emulator (termless) for full ANSI testing
+ * using term = createTerm(createXtermBackend(), { cols: 80, rows: 24 })
+ * await run(<App />, term)
+ * expect(term.screen).toContainText("Hello")
+ *
+ * // Custom streams
+ * const term = createTerm({ stdout: customStream })
+ * ```
+ */
+declare function createTerm(options?: CreateTermOptions): Term;
+declare function createTerm(dims: {
+  cols: number;
+  rows: number;
+}): Term;
+declare function createTerm(backend: TermEmulatorBackend, dims: {
+  cols: number;
+  rows: number;
+}): Term;
+declare function createTerm(emulator: TermEmulator): Term;
+//#endregion
+//#region packages/ag-term/src/ansi/patch-console.d.ts
+/**
+ * Aggregate counts of console output by severity.
+ */
+interface ConsoleStats {
+  total: number;
+  errors: number;
+  warnings: number;
+}
+/**
+ * A patched console that intercepts methods and accumulates entries.
+ * Compatible with React's useSyncExternalStore.
+ */
+interface PatchedConsole extends Disposable {
+  /** Read current entries (for useSyncExternalStore). Empty when capture=false. */
+  getSnapshot(): readonly ConsoleEntry[];
+  /** Get aggregate counts (total, errors, warnings). Works in all modes. */
+  getStats(): ConsoleStats;
+  /** Subscribe to changes - called when new entry arrives. Returns unsubscribe function. */
+  subscribe(onStoreChange: () => void): () => void;
+  dispose(): void;
+  [Symbol.dispose](): void;
+}
+interface PatchConsoleOptions {
+  /**
+   * Suppress original console output when true.
+   * Use in TUI mode where you want console output only in a component.
+   */
+  suppress?: boolean;
+  /**
+   * Store full entries in memory (default: true).
+   * Set to false for count-only mode — getSnapshot() returns empty array,
+   * but getStats() still tracks counts. Avoids unbounded memory growth.
+   */
+  capture?: boolean;
+}
+/**
+ * Patch console methods to intercept and track output.
+ * Returns a disposable that restores original methods.
+ *
+ * @param console - The console object to patch
+ * @param options - Configuration options
+ * @param options.suppress - If true, don't call original methods (for TUI mode)
+ * @param options.capture - If false, only count entries (no memory storage)
+ */
+declare function patchConsole(console: Console, options?: PatchConsoleOptions): PatchedConsole;
+//#endregion
+//#region packages/ag-term/src/ansi/index.d.ts
+declare const term: Term;
+//#endregion
+//#region packages/ag-react/src/hooks/useInput.d.ts
+/**
+ * Options for useInput hook.
+ */
+interface UseInputOptions {
+  /**
+   * Enable or disable input handling.
+   * Useful when there are multiple useInput hooks and you want to disable some.
+   * @default true
+   */
+  isActive?: boolean;
+  /**
+   * Callback for bracketed paste events.
+   * When the terminal has bracketed paste mode enabled,
+   * pasted text is delivered as a single string instead of
+   * individual keystrokes.
+   */
+  onPaste?: (text: string) => void;
+  /**
+   * Callback for key release events.
+   * Requires Kitty protocol with REPORT_EVENTS flag enabled.
+   * When provided, release events are dispatched here instead of being silently dropped.
+   *
+   * @example
+   * ```tsx
+   * useInput((input, key) => {
+   *   // Handle press/repeat events
+   * }, {
+   *   onRelease: (input, key) => {
+   *     // Handle release events (e.g., stop scrolling, end drag)
+   *   },
+   * })
+   * ```
+   */
+  onRelease?: InputHandler;
+}
+/**
+ * Hook for handling user input.
+ *
+ * No-ops if RuntimeContext is not provided (i.e., outside a runtime).
+ * Components render normally without input handling in static mode.
+ * Use useRuntime() for components that need to detect interactive vs static mode.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useInput((input, key) => {
+ *     if (input === 'q') {
+ *       // Quit
+ *     }
+ *     if (key.upArrow) {
+ *       // Move up
+ *     }
+ *   }, {
+ *     onRelease: (input, key) => {
+ *       // Handle key release (requires Kitty REPORT_EVENTS)
+ *     },
+ *   });
+ *
+ *   return <Text>Press q to quit</Text>;
+ * }
+ * ```
+ */
+declare function useInput(inputHandler: InputHandler, options?: UseInputOptions): void;
+//#endregion
+//#region packages/ag-react/src/hooks/useExit.d.ts
+/**
+ * useExit — programmatic exit hook.
+ *
+ * Thin wrapper over useApp().exit that throws outside a runtime
+ * (unlike useApp which returns no-ops in static mode).
+ *
+ * Prefer `return "exit"` from useInput handlers when possible.
+ * Use useExit() for imperative exit from event handlers, timers, etc.
+ */
+/**
+ * Returns a function that exits the app.
+ * Throws if called outside a runtime (run(), createApp(), test renderer).
+ */
+declare function useExit(): () => void;
+//#endregion
+//#region packages/ag/src/focus-manager.d.ts
+type FocusOrigin = "keyboard" | "mouse" | "programmatic";
+/**
+ * Callback fired when focus changes. Used by the runtime to dispatch
+ * DOM-level focus/blur events without coupling FocusManager to the event system.
+ *
+ * @param oldNode - The node losing focus (null if nothing was focused)
+ * @param newNode - The node gaining focus (null on blur)
+ * @param origin - How focus was acquired
+ */
+type FocusChangeCallback = (oldNode: AgNode | null, newNode: AgNode | null, origin: FocusOrigin | null) => void;
+interface FocusSnapshot {
+  activeId: string | null;
+  previousId: string | null;
+  focusOrigin: FocusOrigin | null;
+  scopeStack: readonly string[];
+  /** The currently active peer scope (WPF FocusScope model) */
+  activeScopeId: string | null;
+}
+interface FocusManagerOptions {
+  /** Called when focus changes — wire up event dispatch here */
+  onFocusChange?: FocusChangeCallback;
+}
+/**
+ * Options for registering a hook-based (virtual) focusable.
+ *
+ * Hook focusables are registered via React hooks (e.g. `useFocus()` in the
+ * Ink compat layer) rather than by the `focusable` prop on a tree node. They
+ * participate in Tab cycling but don't have a backing `AgNode` — activeId
+ * tracking is by id only, and `activeElement` is null when a hook focusable
+ * is the active target.
+ */
+interface HookFocusableOptions {
+  /** Registration is inert when false — skipped in tab order, never reports focused */
+  isActive?: boolean;
+  /** Focus this id when registered (only when isActive !== false) */
+  autoFocus?: boolean;
+}
+interface FocusManager {
+  /** Currently focused node */
+  readonly activeElement: AgNode | null;
+  /** testID of the currently focused node */
+  readonly activeId: string | null;
+  /** Previously focused node */
+  readonly previousElement: AgNode | null;
+  /** testID of the previously focused node */
+  readonly previousId: string | null;
+  /** How focus was most recently acquired */
+  readonly focusOrigin: FocusOrigin | null;
+  /** Stack of active focus scope IDs */
+  readonly scopeStack: readonly string[];
+  /** Map of scope ID -> last focused testID within that scope */
+  readonly scopeMemory: Readonly<Record<string, string>>;
+  /** Focus a specific node */
+  focus(node: AgNode, origin?: FocusOrigin): void;
+  /** Focus a node by testID (requires root for tree search) */
+  focusById(id: string, root: AgNode, origin?: FocusOrigin): void;
+  /**
+   * Focus a hook-registered (virtual) id directly without tree traversal.
+   * Unlike `focusById`, this never needs a root — used by `useFocus()` hooks
+   * that track focus by id only.
+   */
+  focusVirtualId(id: string, origin?: FocusOrigin): void;
+  /** Clear focus */
+  blur(): void;
+  /**
+   * Register a hook-based focusable id (e.g. from `useFocus()` in Ink compat).
+   *
+   * Hook focusables form a flat list alongside the tree-based focusables.
+   * `focusNext`/`focusPrev` interleave: tree focusables come first (document
+   * order), then hook focusables (registration order). A single unified tab
+   * cycle walks both.
+   *
+   * Returns an unregister callback (safe to call on effect cleanup).
+   */
+  registerHookFocusable(id: string, options?: HookFocusableOptions): () => void;
+  /** Update an existing hook-focusable's active state. */
+  setHookFocusableActive(id: string, isActive: boolean): void;
+  /** Whether any hook focusables are currently registered. */
+  readonly hasHookFocusables: boolean;
+  /**
+   * Global focus enable (Ink compat). When false, `focusNext`/`focusPrev`
+   * become no-ops for hook-registered focusables. Tree-based focusables
+   * ignore this flag — apps using `useFocusable` are not affected.
+   */
+  readonly hookFocusEnabled: boolean;
+  setHookFocusEnabled(enabled: boolean): void;
+  /**
+   * Handle a subtree being removed from the tree.
+   * If the focused node (or previous node) is within the removed subtree,
+   * clear the reference to prevent dead node retention and broken navigation.
+   */
+  handleSubtreeRemoved(removedRoot: AgNode): void;
+  /** Push a focus scope onto the stack */
+  enterScope(scopeId: string): void;
+  /** Pop the current focus scope */
+  exitScope(): void;
+  /** The currently active peer scope ID (WPF FocusScope model) */
+  readonly activeScopeId: string | null;
+  /**
+   * Activate a peer focus scope. Saves current focus in the old scope's memory,
+   * switches to the new scope, and restores the remembered focus (or focuses
+   * the first focusable element in the scope subtree).
+   */
+  activateScope(scopeId: string, root: AgNode): void;
+  /** Get the testID path from focused node to root */
+  getFocusPath(root: AgNode): string[];
+  /** Check if a subtree rooted at testID contains the focused node */
+  hasFocusWithin(root: AgNode, testID: string): boolean;
+  /** Focus the next focusable node in tab order */
+  focusNext(root: AgNode, scope?: AgNode): void;
+  /** Focus the previous focusable node in tab order */
+  focusPrev(root: AgNode, scope?: AgNode): void;
+  /** Focus in a spatial direction (up/down/left/right) */
+  focusDirection(root: AgNode, direction: "up" | "down" | "left" | "right", layoutFn?: (node: AgNode) => Rect | null): void;
+  /** Subscribe for React integration (useSyncExternalStore) */
+  subscribe(listener: () => void): () => void;
+  /** Get immutable snapshot for useSyncExternalStore */
+  getSnapshot(): FocusSnapshot;
+}
+declare function createFocusManager(options?: FocusManagerOptions): FocusManager;
+//#endregion
+//#region packages/ag/src/focus-queries.d.ts
+/**
+ * Walk up from node to nearest ancestor (or self) with focusable prop.
+ * Useful for mouse clicks — find the focusable target from a deep text node.
+ */
+declare function findFocusableAncestor(node: AgNode): AgNode | null;
+/**
+ * DFS traversal of focusable nodes in tab order, optionally scoped.
+ *
+ * When scope is provided, only nodes within that scope subtree are included.
+ * If a focusScope node is encountered during traversal, its children are
+ * skipped (they belong to a different scope), unless that scope IS the
+ * provided scope node.
+ */
+declare function getTabOrder(root: AgNode, scope?: AgNode): AgNode[];
+/**
+ * Walk up from a node to find the nearest ancestor (or self) with focusScope prop.
+ * Returns the testID of the enclosing scope, or null if none found.
+ */
+declare function findEnclosingScope(node: AgNode): string | null;
+/**
+ * Find a node by testID in the subtree rooted at root.
+ * DFS, returns the first match.
+ */
+declare function findByTestID(root: AgNode, testID: string): AgNode | null;
+/**
+ * Find the nearest focusable candidate in a given direction using
+ * 45-degree cone heuristic (tvOS-style spatial navigation).
+ *
+ * From the center of the source rect, draw a cone in the target direction.
+ * Filter candidates whose center falls within the cone. Pick the closest
+ * by Euclidean distance.
+ *
+ * @param from - The currently focused node
+ * @param direction - Direction to search
+ * @param candidates - All focusable nodes to consider
+ * @param layoutFn - Function to get screen rect for a node (null if not laid out)
+ */
+declare function findSpatialTarget(from: AgNode, direction: "up" | "down" | "left" | "right", candidates: AgNode[], layoutFn: (node: AgNode) => Rect | null): AgNode | null;
+/**
+ * Check if a node has an explicit nextFocus{Direction} override prop.
+ *
+ * These props allow components to declare explicit focus targets for
+ * spatial navigation, overriding the cone heuristic.
+ *
+ * @param node - The node to check
+ * @param direction - Direction string: "up", "down", "left", "right"
+ * @returns The testID of the explicit target, or null
+ */
+declare function getExplicitFocusLink(node: AgNode, direction: string): string | null;
+//#endregion
+//#region packages/ag-react/src/context.d.ts
+/**
+ * Context that provides access to the Term instance.
+ * Used by useTerm() hook to access terminal capabilities and styling.
+ */
+declare const TermContext: _$react.Context<Term | null>;
+interface StderrContextValue {
+  /** Standard error stream */
+  stderr: NodeJS.WriteStream;
+  /** Write to stderr */
+  write: (data: string) => void;
+}
+/**
+ * Context for stderr access.
+ * Used by useStderr() hook.
+ */
+declare const StderrContext: _$react.Context<StderrContextValue | null>;
+/**
+ * Base events every runtime provides.
+ * Apps extend this to add custom events (e.g., BoardEvents adds "op").
+ */
+interface BaseRuntimeEvents {
+  /** Keyboard input: [parsedInput, keyMetadata] */
+  input: [input: string, key: Key];
+  /** Bracketed paste: [pastedText] */
+  paste: [text: string];
+  /** Terminal window focus change: [isFocused] */
+  focus: [focused: boolean];
+}
+/**
+ * Extract handler function type from an event map entry.
+ */
+type EventHandler$1<Args extends unknown[]> = (...args: Args) => void;
+/**
+ * Typed bidirectional event bus + app lifecycle controls.
+ *
+ * Replaces EventsContext, InputContext, StdinContext, and AppContext with
+ * a single typed interface. Components never see stdin or raw mode.
+ *
+ * Generic parameter E extends BaseRuntimeEvents — all runtimes provide
+ * at least "input" and "paste" events. Apps can extend with custom events:
+ *
+ * ```tsx
+ * interface BoardEvents extends BaseRuntimeEvents {
+ *   op: [BoardOp]
+ * }
+ * const rt = useRuntime<BoardEvents>()
+ * rt?.on("input", handler)              // runtime → view
+ * rt?.emit("op", { type: "cursor_down" }) // view → runtime
+ * ```
+ *
+ * Present in interactive mode (run/render/createApp/test renderer).
+ * Absent (null) in static mode (renderStatic).
+ */
+interface RuntimeContextValue<E extends BaseRuntimeEvents = BaseRuntimeEvents> {
+  /** Subscribe to a typed event. Returns cleanup function. */
+  on<K extends string & keyof E>(event: K, handler: EventHandler$1<E[K] extends unknown[] ? E[K] : never>): () => void;
+  /** Emit a typed event (view → runtime). */
+  emit<K extends string & keyof E>(event: K, ...args: E[K] extends unknown[] ? E[K] : never): void;
+  /** Exit the application with optional error. */
+  exit: (error?: Error) => void;
+  /** Pause rendering output (for screen switching). */
+  pause?: () => void;
+  /** Resume rendering after pause. */
+  resume?: () => void;
+}
+/**
+ * Context that provides the typed runtime event bus.
+ *
+ * When non-null: interactive mode — useInput works, components can subscribe
+ * to events via rt.on() and emit via rt.emit().
+ *
+ * When null: static mode — useInput throws (by design), use useRuntime()
+ * for components that need to work in both modes.
+ */
+declare const RuntimeContext: _$react.Context<RuntimeContextValue<BaseRuntimeEvents> | null>;
+/**
+ * Cache backend type — determines where ListView stores cached items.
+ * - "terminal": Write to stdout as native scrollback (inline mode)
+ * - "virtual": In-memory HistoryBuffer ring buffer (fullscreen + virtualInline)
+ * - "retain": Cache items but keep them in the render tree (plain fullscreen
+ *   without virtual scrollback — the virtualizer handles windowing)
+ */
+type CacheBackend = "terminal" | "virtual" | "retain";
+/**
+ * Context that provides the cache backend to ListView.
+ * Set by the runtime based on rendering mode:
+ * - alternateScreen: false (inline) → "terminal"
+ * - alternateScreen: true + virtualInline → "virtual"
+ * - alternateScreen: true (plain fullscreen) → "retain"
+ *
+ * Default: "virtual" (safe fallback for test renderers — items unmount as expected)
+ */
+declare const CacheBackendContext: _$react.Context<CacheBackend>;
+/**
+ * Context for the tree-based focus manager.
+ * Provides the FocusManager instance to useFocusable(), useFocusWithin(), and useFocusManager() hooks.
+ */
+declare const FocusManagerContext: _$react.Context<FocusManager | null>;
+/**
+ * Minimal capability lookup interface — matches CapabilityRegistry.get().
+ * Defined here to avoid a dependency from ag-react → @silvery/create internals.
+ */
+interface CapabilityLookup {
+  get<T>(key: symbol): T | undefined;
+}
+/**
+ * Context for the capability registry (from @silvery/create composition).
+ *
+ * Provided by createApp() when a capabilityRegistry exists on the app object.
+ * Hooks like useSelection() use this to discover interaction features
+ * (e.g., SelectionFeature) without coupling to the composition layer.
+ *
+ * Returns null in simple `run()` or `render()` apps that don't use pipe() composition.
+ */
+declare const CapabilityRegistryContext: _$react.Context<CapabilityLookup | null>;
+//#endregion
+//#region packages/create/src/signal-store.d.ts
+/**
+ * Signal Store — Zustand StoreApi-compatible store backed by alien-signals.
+ *
+ * Drop-in replacement for Zustand's createStore(). Provides the same
+ * StoreApi<T> interface so useApp()/StoreContext keep working unchanged.
+ *
+ * Also re-exports StateCreator for backward compatibility with code
+ * that imported it from "zustand".
+ */
+type SetStateInternal<T> = {
+  (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: false): void;
+  (state: T | ((state: T) => T), replace: true): void;
+};
+interface StoreApi$1<T> {
+  setState: SetStateInternal<T>;
+  getState: () => T;
+  getInitialState: () => T;
+  subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+}
+type StateCreator<T, Mis extends [StoreMutatorIdentifier, unknown][] = [], Mos extends [StoreMutatorIdentifier, unknown][] = [], U = T> = ((setState: StoreApi$1<T>["setState"], getState: StoreApi$1<T>["getState"], store: StoreApi$1<T>) => U) & {
+  $$storeMutators?: Mos;
+};
+interface StoreMutators<_S, _A> {}
+type StoreMutatorIdentifier = keyof StoreMutators<unknown, unknown>;
+//#endregion
+//#region packages/create/src/core/index.d.ts
+/**
+ * The model type that silvery manages for focus state.
+ *
+ * Applications extend this with their own model fields.
+ * The store's update function receives the full model and returns
+ * a new model + effects tuple.
+ */
+interface SilveryModel {
+  focus: {
+    activeId: string | null;
+    previousId: string | null;
+    origin: FocusOrigin | null;
+    scopeStack: string[];
+    scopeMemory: Record<string, string>;
+  };
+}
+/**
+ * Direction type used in spatial navigation messages.
+ */
+type Direction = "up" | "down" | "left" | "right";
+/**
+ * Message types that silvery understands.
+ *
+ * Applications can extend this union with their own message types.
+ * The store's update function pattern-matches on `type` to decide
+ * how to update the model.
+ */
+type SilveryMsg = {
+  type: "focus";
+  nodeId: string;
+  origin?: FocusOrigin;
+} | {
+  type: "blur";
+} | {
+  type: "focus-next";
+} | {
+  type: "focus-prev";
+} | {
+  type: "focus-direction";
+  direction: Direction;
+} | {
+  type: "scope-enter";
+  scopeId: string;
+} | {
+  type: "scope-exit";
+} | {
+  type: "term:key";
+  key: string;
+  input: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+} | {
+  type: "term:mouse";
+  action: "down" | "up" | "move" | "scroll";
+  x: number;
+  y: number;
+  button: number;
+} | {
+  type: "term:resize";
+  cols: number;
+  rows: number;
+};
+/**
+ * Effect commands returned by update functions.
+ *
+ * Effects are declarative descriptions of side effects. The store
+ * executes them after the model update, keeping the update function pure.
+ *
+ * - `none`: No effect (useful as a default)
+ * - `batch`: Multiple effects to execute
+ * - `dispatch`: Queue another message (no re-entrant dispatch)
+ */
+type Effect = {
+  type: "none";
+} | {
+  type: "batch";
+  effects: Effect[];
+} | {
+  type: "dispatch";
+  msg: SilveryMsg;
+};
+/**
+ * A plugin wraps an update function, adding behavior before/after/around it.
+ *
+ * Plugins compose via `compose()` — the outermost plugin runs first on
+ * message receive, but the innermost (original) update runs first for
+ * model updates. This is the standard middleware pattern.
+ *
+ * @example
+ * ```ts
+ * const logging: Plugin<MyModel, MyMsg> = (inner) => (msg, model) => {
+ *   console.log('msg:', msg.type)
+ *   const result = inner(msg, model)
+ *   console.log('new model:', result[0])
+ *   return result
+ * }
+ * ```
+ */
+type Plugin<Model, Msg> = (innerUpdate: (msg: Msg, model: Model) => [Model, Effect[]]) => (msg: Msg, model: Model) => [Model, Effect[]];
+//#endregion
+//#region packages/create/src/store/index.d.ts
+/**
+ * Configuration for creating a store.
+ */
+interface StoreConfig<Model extends SilveryModel, Msg extends SilveryMsg> {
+  /** Initialize model and effects. Called once on store creation. */
+  init: () => [Model, Effect[]];
+  /** Pure update function: (msg, model) -> [newModel, effects] */
+  update: (msg: Msg, model: Model) => [Model, Effect[]];
+}
+/**
+ * The store API returned by createStore.
+ */
+interface StoreApi<Model extends SilveryModel, Msg extends SilveryMsg> {
+  /** Send a message through the update function. */
+  dispatch(msg: Msg): void;
+  /** Get the current model. */
+  getModel(): Model;
+  /** Subscribe to model changes. Returns unsubscribe function. */
+  subscribe(listener: () => void): () => void;
+  /** Get a derived value from the model via selector. */
+  getSnapshot<T>(selector: (model: Model) => T): T;
+}
+/**
+ * Plugin that handles focus-related messages by updating the focus slice.
+ *
+ * Handles: focus, blur, scope-enter, scope-exit.
+ * Passes focus-next, focus-prev, focus-direction through (they need
+ * the node tree, which the store doesn't have — those are handled
+ * at the React integration layer).
+ */
+declare function withFocusManagement<Model extends SilveryModel, Msg extends SilveryMsg>(): Plugin<Model, Msg>;
+/**
+ * The default silvery update function.
+ *
+ * Returns the model unchanged with no effects for any unhandled message.
+ * Compose with plugins to add behavior.
+ */
+declare function silveryUpdate<Model extends SilveryModel, Msg extends SilveryMsg>(_msg: Msg, model: Model): [Model, Effect[]];
+/**
+ * Create a default initial SilveryModel.
+ */
+declare function defaultInit(): [SilveryModel, Effect[]];
+/**
+ * Create a TEA-style store.
+ *
+ * The store manages model state and effect execution. Messages are
+ * dispatched through the update function, which returns a new model
+ * and a list of effects. Effects are executed after each update cycle.
+ *
+ * Dispatch effects are queued to prevent re-entrant dispatch:
+ * if dispatching msg A triggers effect dispatch(B), B is queued and
+ * processed after A's full update cycle completes.
+ *
+ * @example
+ * ```ts
+ * import { createStore, withFocusManagement, silveryUpdate } from '@silvery/create/store'
+ * import { compose } from '@silvery/create/core'
+ *
+ * const store = createStore({
+ *   init: () => [{ focus: { activeId: null, ... }, count: 0 }, []],
+ *   update: compose(withFocusManagement())(silveryUpdate),
+ * })
+ *
+ * store.dispatch({ type: 'focus', nodeId: 'btn1' })
+ * console.log(store.getModel().focus.activeId) // 'btn1'
+ * ```
+ */
+declare function createStore<Model extends SilveryModel, Msg extends SilveryMsg>(config: StoreConfig<Model, Msg>): StoreApi<Model, Msg>;
+//#endregion
+//#region packages/create/src/streams/index.d.ts
+/**
+ * AsyncIterable stream helpers for event-driven TUI architecture.
+ *
+ * These are pure functions over AsyncIterables - no EventEmitters, no callbacks.
+ * All helpers properly handle cleanup via return() on early break.
+ *
+ * @example
+ * ```typescript
+ * const keys = term.keys()
+ * const resizes = term.resizes()
+ *
+ * // Merge multiple sources
+ * const events = merge(
+ *   map(keys, k => ({ type: 'key', ...k })),
+ *   map(resizes, r => ({ type: 'resize', ...r }))
+ * )
+ *
+ * // Consume until ctrl+c
+ * for await (const event of events) {
+ *   if (event.type === 'key' && event.key === 'ctrl+c') break
+ * }
+ * ```
+ */
+/**
+ * Merge multiple AsyncIterables into one.
+ *
+ * Values are emitted in arrival order (first-come). When all sources complete,
+ * the merged iterable completes. If any source throws, the error propagates
+ * and remaining sources are cleaned up.
+ *
+ * IMPORTANT: Each call to merge() creates a fresh iterable. Don't share
+ * the same merged iterable between multiple consumers.
+ *
+ * @example
+ * ```typescript
+ * const merged = merge(keys, resizes, ticks)
+ * for await (const event of merged) {
+ *   // Process events from any source
+ * }
+ * ```
+ */
+declare function merge<T>(...sources: AsyncIterable<T>[]): AsyncGenerator<T, void, undefined>;
+/**
+ * Transform each value from an AsyncIterable.
+ *
+ * @example
+ * ```typescript
+ * const keyEvents = map(keys, k => ({ type: 'key' as const, key: k }))
+ * ```
+ */
+declare function map<T, U>(source: AsyncIterable<T>, fn: (value: T) => U): AsyncGenerator<U, void, undefined>;
+/**
+ * Filter values from an AsyncIterable.
+ *
+ * @example
+ * ```typescript
+ * const letters = filter(keys, k => k.key.length === 1)
+ * ```
+ */
+declare function filter<T>(source: AsyncIterable<T>, predicate: (value: T) => boolean): AsyncGenerator<T, void, undefined>;
+/**
+ * Filter and transform in one pass (type narrowing).
+ *
+ * @example
+ * ```typescript
+ * const keyEvents = filterMap(events, e =>
+ *   e.type === 'key' ? e : undefined
+ * )
+ * ```
+ */
+declare function filterMap<T, U>(source: AsyncIterable<T>, fn: (value: T) => U | undefined): AsyncGenerator<U, void, undefined>;
+/**
+ * Take values until an AbortSignal fires.
+ *
+ * When the signal aborts, the iterator completes gracefully (no error thrown).
+ * The source iterator is properly cleaned up.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController()
+ * const events = takeUntil(allEvents, controller.signal)
+ *
+ * // Later: controller.abort() will end the iteration
+ * ```
+ */
+declare function takeUntil<T>(source: AsyncIterable<T>, signal: AbortSignal): AsyncGenerator<T, void, undefined>;
+/**
+ * Take the first n values from an AsyncIterable.
+ *
+ * @example
+ * ```typescript
+ * const firstThree = take(events, 3)
+ * ```
+ */
+declare function take<T>(source: AsyncIterable<T>, count: number): AsyncGenerator<T, void, undefined>;
+/**
+ * Create an AsyncIterable from an array (useful for testing).
+ *
+ * @example
+ * ```typescript
+ * const events = fromArray([
+ *   { type: 'key', key: 'j' },
+ *   { type: 'key', key: 'k' },
+ * ])
+ * ```
+ */
+declare function fromArray<T>(items: T[]): AsyncGenerator<T, void, undefined>;
+/**
+ * Create an AsyncIterable that yields after a delay (useful for testing).
+ *
+ * @example
+ * ```typescript
+ * const delayed = fromArrayWithDelay([1, 2, 3], 100) // 100ms between each
+ * ```
+ */
+declare function fromArrayWithDelay<T>(items: T[], delayMs: number): AsyncGenerator<T, void, undefined>;
+/**
+ * Throttle high-frequency sources.
+ *
+ * Emits the first value immediately, then ignores values for the specified
+ * duration. After the duration, the next value is emitted and the cycle repeats.
+ *
+ * @example
+ * ```typescript
+ * const throttled = throttle(mouseMoves, 16) // ~60fps
+ * ```
+ */
+declare function throttle<T>(source: AsyncIterable<T>, ms: number): AsyncGenerator<T, void, undefined>;
+/**
+ * Debounce values - only emit after source is quiet for specified duration.
+ *
+ * NOTE: With pull-based AsyncIterables, true debouncing is complex. This
+ * implementation collects all values and only yields the final value after
+ * the source completes and quiet period passes. For real-time debouncing,
+ * consider using a push-based pattern or EventEmitter.
+ *
+ * @example
+ * ```typescript
+ * const debounced = debounce(searchInput, 300) // Yields last value after source ends + delay
+ * ```
+ */
+declare function debounce<T>(source: AsyncIterable<T>, ms: number): AsyncGenerator<T, void, undefined>;
+/**
+ * Collect values into batches of specified size.
+ *
+ * @throws {Error} If size is not positive
+ *
+ * @example
+ * ```typescript
+ * const batched = batch(events, 10) // Emit arrays of 10 events
+ * ```
+ */
+declare function batch<T>(source: AsyncIterable<T>, size: number): AsyncGenerator<T[], void, undefined>;
+/**
+ * Concatenate multiple AsyncIterables in sequence.
+ *
+ * @example
+ * ```typescript
+ * const all = concat(header, body, footer)
+ * ```
+ */
+declare function concat<T>(...sources: AsyncIterable<T>[]): AsyncGenerator<T, void, undefined>;
+/**
+ * Zip multiple AsyncIterables together.
+ * Completes when the shortest source completes.
+ *
+ * @example
+ * ```typescript
+ * const pairs = zip(keys, timestamps) // [key, timestamp][]
+ * ```
+ */
+declare function zip<T extends unknown[]>(...sources: { [K in keyof T]: AsyncIterable<T[K]> }): AsyncGenerator<T, void, undefined>;
+//#endregion
+//#region packages/ag-term/src/runtime/layout.d.ts
+/**
+ * Options for the layout function.
+ */
+interface LayoutOptions {
+  /** Skip layout notifications (for static renders). Default: true */
+  skipLayoutNotifications?: boolean;
+  /** Strip ANSI codes for plain text output. Default: false */
+  plain?: boolean;
+}
+/**
+ * Ensure layout engine is initialized.
+ * Must be called before layout() in async contexts.
+ */
+declare function ensureLayoutEngine(): Promise<void>;
+/**
+ * Pure layout function - renders a React element to a Buffer.
+ *
+ * IMPORTANT: Call ensureLayoutEngine() first in async contexts.
+ * The layout engine must be initialized before calling this.
+ *
+ * @param element React element to render
+ * @param dims Terminal dimensions
+ * @param options Layout options
+ * @returns Immutable Buffer with text, ansi, and nodes
+ *
+ * @example
+ * ```typescript
+ * import { layout, ensureLayoutEngine } from '@silvery/ag-term/runtime'
+ *
+ * await ensureLayoutEngine()
+ * const buffer = layout(<Text>Hello</Text>, { cols: 80, rows: 24 })
+ * console.log(buffer.text) // "Hello"
+ * ```
+ */
+declare function layout(element: ReactElement, dims: Dims, options?: LayoutOptions): Buffer$1;
+/**
+ * Synchronous layout - assumes engine is already initialized.
+ * Throws if engine not ready.
+ */
+declare function layoutSync(element: ReactElement, dims: Dims, options?: LayoutOptions): Buffer$1;
+//#endregion
+//#region packages/ag-term/src/runtime/diff.d.ts
+/**
+ * Diff mode for ANSI output.
+ */
+type DiffMode = "fullscreen" | "inline";
+/**
+ * Compute the minimal ANSI diff between two buffers.
+ *
+ * @param prev Previous buffer (null on first render)
+ * @param next Current buffer
+ * @param mode Render mode (fullscreen or inline)
+ * @returns ANSI escape sequence string to transform prev into next
+ *
+ * @example
+ * ```typescript
+ * import { diff, layout } from '@silvery/ag-term/runtime'
+ *
+ * const prev = layout(<Text>Hello</Text>, dims)
+ * const next = layout(<Text>World</Text>, dims)
+ * const patch = diff(prev, next)
+ * process.stdout.write(patch)
+ * ```
+ */
+declare function diff(prev: Buffer$1 | null, next: Buffer$1, mode?: DiffMode, scrollbackOffset?: number, termRows?: number): string;
+/**
+ * Render a buffer to ANSI string (no diff, full render).
+ *
+ * @param buffer Buffer to render
+ * @param mode Render mode (fullscreen or inline)
+ * @returns Full ANSI output
+ */
+declare function render(buffer: Buffer$1, mode?: DiffMode): string;
+//#endregion
+//#region packages/ag-term/src/runtime/create-buffer.d.ts
+declare function createBuffer(termBuffer: TerminalBuffer, nodes: AgNode): Buffer$1;
+//#endregion
+//#region packages/ag-term/src/runtime/create-runtime.d.ts
+/**
+ * Create a runtime kernel.
+ *
+ * @param options Runtime configuration
+ * @returns Runtime instance implementing Symbol.dispose
+ */
+declare function createRuntime(options: RuntimeOptions): Runtime;
+//#endregion
+//#region packages/ag-react/src/hooks/usePasteCallback.d.ts
+/**
+ * usePasteCallback — subscribe to bracketed paste events.
+ *
+ * Simple callback-based paste hook for run() apps.
+ * For component composition with PasteProvider, use usePaste() instead.
+ *
+ * @example
+ * ```tsx
+ * usePasteCallback((text) => {
+ *   insertText(text)
+ * })
+ * ```
+ */
+type PasteCallback = (text: string) => void;
+declare function usePasteCallback(handler: PasteCallback): void;
+//#endregion
+//#region packages/ag-term/src/runtime/run.d.ts
+/**
+ * Options for run().
+ *
+ * run() auto-detects terminal capabilities and enables features by default.
+ * Pass explicit values to override. For the full list of capabilities detected,
+ * see {@link detectTerminalCaps} in terminal-caps.ts.
+ *
+ * **Mouse tracking note:** When `mouse` is enabled (the default), the terminal
+ * captures mouse events and native text selection (copy/paste) requires holding
+ * Shift (or Option on macOS in some terminals). Set `mouse: false` to restore
+ * native copy/paste behavior.
+ */
+interface RunOptions {
+  /** Terminal dimensions (default: from process.stdout) */
+  cols?: number;
+  rows?: number;
+  /** Standard output (default: process.stdout) */
+  stdout?: NodeJS.WriteStream;
+  /** Standard input (default: process.stdin) */
+  stdin?: NodeJS.ReadStream;
+  /**
+   * Plain writable sink for ANSI output. Headless mode with active output.
+   * Requires cols and rows. Input via handle.press().
+   */
+  writable?: {
+    write(data: string): void;
+  };
+  /** Abort signal for external cleanup */
+  signal?: AbortSignal;
+  /**
+   * Enable Kitty keyboard protocol for unambiguous key identification
+   * (Cmd ⌘, Hyper ✦ modifiers, key release events).
+   * - `true`: enable with DISAMBIGUATE flag (1)
+   * - number: enable with specific KittyFlags bitfield
+   * - `false`: don't enable
+   * - Default: auto-detected from terminal (enabled for Ghostty, Kitty, WezTerm, foot)
+   */
+  kitty?: boolean | number;
+  /**
+   * Enable SGR mouse tracking (mode 1006) for click, scroll, and drag events.
+   * When enabled, native text selection requires holding Shift (or Option on macOS)
+   * and native terminal scrolling is disabled.
+   * Default: `true` in fullscreen mode, `false` in inline mode (where content
+   * lives in terminal scrollback and natural scrolling is expected).
+   */
+  mouse?: boolean;
+  /**
+   * Render mode:
+   * - `"fullscreen"` — alt screen buffer (default)
+   * - `"inline"` — scrollback-compatible, no alt screen
+   * - `"virtualInline"` — alt screen with virtual scrollback (scrollable history + search)
+   */
+  mode?: "fullscreen" | "inline" | "virtualInline";
+  /**
+   * Enable Kitty text sizing protocol (OSC 66) for PUA characters.
+   * Ensures nerdfont/powerline icons are measured and rendered at the correct width.
+   * - `true`: force enable
+   * - `"auto"`: use heuristic, then probe to verify (progressive enhancement)
+   * - `"probe"`: start disabled, probe async, enable on confirmation
+   * - `false`: disabled
+   * - Default: "auto"
+   */
+  textSizing?: boolean | "auto" | "probe";
+  /**
+   * Enable DEC width mode detection (modes 1020-1023).
+   * Queries the terminal for emoji/CJK/PUA width settings at startup.
+   * - `true`: always run width detection probe
+   * - `"auto"`: run probe when caps are provided (default)
+   * - `false`: disabled
+   * Default: "auto"
+   */
+  widthDetection?: boolean | "auto";
+  /**
+   * Enable terminal focus reporting (CSI ?1004h).
+   * Dispatches 'term:focus' events with `{ focused: boolean }`.
+   * Default: true
+   */
+  focusReporting?: boolean;
+  /**
+   * Terminal capabilities for width measurement and output suppression.
+   * Default: auto-detected via detectTerminalCaps()
+   */
+  caps?: TerminalCaps;
+  /**
+   * Handle Ctrl+Z by suspending the process. Default: true
+   */
+  suspendOnCtrlZ?: boolean;
+  /**
+   * Handle Ctrl+C by restoring terminal and exiting. Default: true
+   */
+  exitOnCtrlC?: boolean;
+  /** Called before suspend. Return false to prevent. */
+  onSuspend?: () => boolean | void;
+  /** Called after resume from suspend. */
+  onResume?: () => void;
+  /** Called on Ctrl+C. Return false to prevent exit. */
+  onInterrupt?: () => boolean | void;
+}
+/**
+ * Handle returned by run() for controlling the app.
+ */
+interface RunHandle {
+  /** Current rendered text (no ANSI) */
+  readonly text: string;
+  /** Live reconciler root node (for locator queries) */
+  readonly root: AgNode;
+  /** Current terminal buffer (cell-level access) */
+  readonly buffer: TerminalBuffer | null;
+  /** Wait until the app exits */
+  waitUntilExit(): Promise<void>;
+  /** Unmount and cleanup */
+  unmount(): void;
+  /** Dispose (alias for unmount) — enables `using` */
+  [Symbol.dispose](): void;
+  /** Send a key press */
+  press(key: string): Promise<void>;
+}
+/**
+ * Run a React component with the silvery-loop runtime.
+ *
+ * Accepts either a Term instance or RunOptions:
+ * - `run(<App />, term)` — Term handles streams, createApp handles rendering
+ * - `run(<App />, { cols, rows, ... })` — classic options API
+ *
+ * Internally delegates to createApp() with an empty store.
+ * For stores and providers, use createApp() directly.
+ */
+declare function run(element: ReactElement, term: Term, termOptions?: Partial<RunOptions>): Promise<RunHandle>;
+declare function run(element: ReactElement, options?: RunOptions): Promise<RunHandle>;
+//#endregion
+//#region packages/ag-term/src/runtime/terminal-lifecycle.d.ts
+/**
+ * Terminal Lifecycle Events
+ *
+ * Handles suspend/resume (Ctrl+Z/SIGCONT) and interrupt (Ctrl+C) for TUI apps.
+ * When stdin is in raw mode, the terminal does not generate SIGTSTP/SIGINT for
+ * Ctrl+Z/Ctrl+C. This module intercepts the raw bytes and manages the full
+ * terminal state save/restore cycle.
+ *
+ * Inspired by ncurses (endwin/refresh), bubbletea, and Textual.
+ *
+ * Protocols managed:
+ * - Raw mode (stdin)
+ * - Alternate screen buffer (DEC private mode 1049)
+ * - Cursor visibility (DEC private mode 25)
+ * - Mouse tracking (modes 1000, 1002, 1006)
+ * - Kitty keyboard protocol (CSI > flags u / CSI < u)
+ * - Bracketed paste (DEC private mode 2004)
+ * - SGR attributes (reset via CSI 0 m)
+ */
+/**
+ * Options for terminal lifecycle event handling.
+ */
+interface TerminalLifecycleOptions {
+  /** Handle Ctrl+Z by suspending the process. Default: true */
+  suspendOnCtrlZ?: boolean;
+  /** Handle Ctrl+C by exiting the process. Default: true */
+  exitOnCtrlC?: boolean;
+  /** Called before suspend. Return false to prevent. */
+  onSuspend?: () => boolean | void;
+  /** Called after resume from suspend. */
+  onResume?: () => void;
+  /** Called on Ctrl+C. Return false to prevent exit. */
+  onInterrupt?: () => boolean | void;
+}
+/**
+ * Snapshot of terminal protocol state for save/restore across suspend/resume.
+ */
+interface TerminalState {
+  rawMode: boolean;
+  alternateScreen: boolean;
+  cursorHidden: boolean;
+  mouseEnabled: boolean;
+  kittyEnabled: boolean;
+  kittyFlags: number;
+  bracketedPaste: boolean;
+  focusReporting: boolean;
+}
+/**
+ * Capture the current terminal protocol state.
+ *
+ * This builds a TerminalState from the options passed to run()/createApp(),
+ * since terminal state is not directly queryable from the OS.
+ */
+declare function captureTerminalState(opts: {
+  alternateScreen?: boolean;
+  cursorHidden?: boolean;
+  mouse?: boolean;
+  kitty?: boolean;
+  kittyFlags?: number;
+  bracketedPaste?: boolean;
+  rawMode?: boolean;
+  focusReporting?: boolean;
+}): TerminalState;
+/**
+ * Restore terminal to normal state before suspending or exiting.
+ *
+ * Uses writeSync for reliability during signal handling (async write
+ * may not complete before the process suspends).
+ *
+ * Order matters: disable protocols first, then show cursor, then exit
+ * alternate screen, then disable raw mode.
+ */
+declare function restoreTerminalState(stdout: NodeJS.WriteStream, stdin: NodeJS.ReadStream): void;
+/**
+ * Re-enter TUI mode after resuming from suspend (SIGCONT).
+ *
+ * Restores all protocols that were active before suspend, in the correct
+ * order: raw mode first, then alternate screen, then protocols, then
+ * trigger a full redraw via synthetic resize.
+ */
+declare function resumeTerminalState(state: TerminalState, stdout: NodeJS.WriteStream, stdin: NodeJS.ReadStream): void;
+/**
+ * Execute the full suspend flow: save state, restore terminal, SIGTSTP,
+ * and set up SIGCONT handler to resume.
+ *
+ * @param state - Terminal state snapshot to restore on resume
+ * @param stdout - Output stream
+ * @param stdin - Input stream
+ * @param onResume - Optional callback after resume
+ */
+declare function performSuspend(state: TerminalState, stdout: NodeJS.WriteStream, stdin: NodeJS.ReadStream, onResume?: () => void): void;
+/** Ctrl+C raw byte (ETX - End of Text) */
+declare const CTRL_C = "\u0003";
+/** Ctrl+Z raw byte (SUB - Substitute) */
+declare const CTRL_Z = "\u001A";
+//#endregion
+//#region packages/ag-term/src/runtime/create-app.d.ts
+/**
+ * Event handler context passed to handlers.
+ *
+ * When the store uses `tea()` middleware, `dispatch` is available with the
+ * correct Op type inferred from the store. For non-tea stores it's `undefined`.
+ */
+interface EventHandlerContext<S> {
+  set: StoreApi$1<S>["setState"];
+  get: StoreApi$1<S>["getState"];
+  /** The tree-based focus manager */
+  focusManager: FocusManager;
+  /** Convenience: focus a node by testID */
+  focus(testID: string): void;
+  /** Activate a peer focus scope (saves/restores focus per scope) */
+  activateScope(scopeId: string): void;
+  /** Get the focus path from focused node to root */
+  getFocusPath(): string[];
+  /**
+   * Dispatch an operation through the tea() reducer.
+   *
+   * Available when the store was created with `tea()` middleware from `silvery/tea`.
+   * Type-safe: the Op type is inferred from the store's TeaSlice.
+   * For non-tea stores, this is `undefined`.
+   */
+  dispatch?: "dispatch" extends keyof S ? S["dispatch"] : undefined;
+  /** Hit-test the render tree at (x, y). Returns the deepest SilveryNode at that point, or null. */
+  hitTest(x: number, y: number): AgNode | null;
+}
+/**
+ * Generic event handler function.
+ * Return 'exit' to exit the app.
+ */
+type EventHandler<T, S> = (data: T, ctx: EventHandlerContext<S>) => void | "exit" | "flush";
+/**
+ * Event handlers map.
+ * Keys are namespaced as 'provider:event' (e.g., 'term:key', 'term:resize').
+ */
+type EventHandlers<S> = {
+  [event: `${string}:${string}`]: EventHandler<unknown, S> | undefined;
+};
+/**
+ * Options for app.run().
+ */
+interface AppRunOptions {
+  /** Terminal dimensions (default: from process.stdout) */
+  cols?: number;
+  rows?: number;
+  /** Standard output (default: process.stdout) */
+  stdout?: NodeJS.WriteStream;
+  /** Standard input (default: process.stdin) */
+  stdin?: NodeJS.ReadStream;
+  /**
+   * Plain writable sink for ANSI output. Headless mode with active output.
+   * Requires cols and rows. Input via handle.press().
+   */
+  writable?: {
+    write(data: string): void;
+  };
+  /**
+   * Subscribe to resize events in headless mode.
+   * Called with a handler that should be invoked when dimensions change.
+   * Returns an unsubscribe function.
+   */
+  onResize?: (handler: (dims: {
+    cols: number;
+    rows: number;
+  }) => void) => () => void;
+  /** Abort signal for external cleanup */
+  signal?: AbortSignal;
+  /** Enter alternate screen buffer (clean slate, restore on exit). Default: false */
+  alternateScreen?: boolean;
+  /** Use Kitty keyboard protocol encoding for press(). Default: false */
+  kittyMode?: boolean;
+  /**
+   * Enable Kitty keyboard protocol.
+   * - `true`: auto-detect and enable with DISAMBIGUATE flag (1)
+   * - number: enable with specific KittyFlags bitfield
+   * - `false`/undefined: don't enable (default)
+   */
+  kitty?: boolean | number;
+  /**
+   * Enable SGR mouse tracking (mode 1006).
+   * When true, enables mouse events and disables on cleanup.
+   * Default: false
+   */
+  mouse?: boolean;
+  /**
+   * Enable virtual inline mode: alt screen with virtual scrollback buffer.
+   * Provides scrollable history + search (Ctrl+F) while using fullscreen rendering.
+   * Default: false
+   */
+  virtualInline?: boolean;
+  /**
+   * Handle Ctrl+Z by suspending the process (save terminal state,
+   * send SIGTSTP, restore on SIGCONT). Default: true
+   */
+  suspendOnCtrlZ?: boolean;
+  /**
+   * Handle Ctrl+C by restoring terminal and exiting.
+   * Default: true
+   */
+  exitOnCtrlC?: boolean;
+  /** Called before suspend. Return false to prevent. */
+  onSuspend?: () => boolean | void;
+  /** Called after resume from suspend. */
+  onResume?: () => void;
+  /** Called on Ctrl+C. Return false to prevent exit. */
+  onInterrupt?: () => boolean | void;
+  /**
+   * Enable Kitty text sizing protocol (OSC 66) for PUA characters.
+   * When enabled, nerdfont/powerline icons are measured as 2-wide and
+   * wrapped in OSC 66 sequences so the terminal renders them at the
+   * correct width.
+   * - `true`: force enable
+   * - `"auto"`: use heuristic, then probe to verify (progressive enhancement)
+   * - `"probe"`: start disabled, probe async, enable on confirmation
+   * - `false`/undefined: disabled (default)
+   */
+  textSizing?: boolean | "auto" | "probe";
+  /**
+   * Enable DEC width mode detection (modes 1020-1023).
+   * Queries the terminal for its actual character width settings (emoji,
+   * CJK, private-use area) and updates the measurer accordingly.
+   * - `true`: always run width detection probe
+   * - `"auto"`: run probe when caps are provided (default for real terminals)
+   * - `false`/undefined: disabled (default)
+   */
+  widthDetection?: boolean | "auto";
+  /**
+   * Enable terminal focus reporting (CSI ?1004h).
+   * When enabled, the terminal sends focus-in/focus-out events that are
+   * dispatched as 'term:focus' events with `{ focused: boolean }`.
+   * Default: false
+   */
+  focusReporting?: boolean;
+  /**
+   * Enable buffer-level text selection via mouse drag.
+   * When enabled, left mouse drag selects text, and mouse up copies
+   * selected text to clipboard via OSC 52.
+   * Default: true when mouse is enabled
+   */
+  selection?: boolean;
+  /**
+   * Terminal capabilities for width measurement and output suppression.
+   * When provided, configures the render pipeline to use these caps
+   * (scoped width measurer + output phase). Typically from term.caps.
+   */
+  caps?: TerminalCaps;
+  /**
+   * Guard stdout/stderr in alt screen mode. When true (the default for
+   * alternateScreen), intercepts process.stdout.write and process.stderr.write
+   * so that only silvery's render pipeline can write to stdout. Non-silvery
+   * stderr writes are redirected to DEBUG_LOG if set, otherwise suppressed.
+   * This prevents display corruption from libraries that write directly to
+   * process.stdout/stderr (e.g., loggily, debug).
+   *
+   * - `true`: enable output guard (default when alternateScreen is true)
+   * - `false`: disable output guard
+   */
+  guardOutput?: boolean;
+  /**
+   * Root component that wraps the element tree with additional providers.
+   * Set by plugins (e.g., withInk) via the `app.Root` pattern.
+   * The Root component receives children and wraps them with providers.
+   */
+  Root?: React$1.ComponentType<{
+    children: React$1.ReactNode;
+  }>;
+  /**
+   * Capability registry from the composition layer (e.g., withDomEvents, withTerminal).
+   * When provided, exposed to React components via CapabilityRegistryContext so
+   * hooks like useSelection() can discover interaction features.
+   */
+  capabilityRegistry?: CapabilityLookup;
+  /** Providers and plain values to inject */
+  [key: string]: unknown;
+}
+/**
+ * Handle returned by app.run().
+ *
+ * Also AsyncIterable<Buffer> — iterate to get frames after each event:
+ * ```typescript
+ * for await (const frame of app.run(<App />)) {
+ *   expect(frame.text).toContain('expected')
+ * }
+ * ```
+ */
+interface AppHandle<S> {
+  /** Current rendered text (no ANSI) */
+  readonly text: string;
+  /** Live reconciler root node (for locator queries) */
+  readonly root: AgNode;
+  /** Current terminal buffer (cell-level access) */
+  readonly buffer: TerminalBuffer | null;
+  /** Access to the Zustand store */
+  readonly store: StoreApi$1<S>;
+  /** Wait until the app exits */
+  waitUntilExit(): Promise<void>;
+  /** Unmount and cleanup */
+  unmount(): void;
+  /** Dispose (alias for unmount) — enables `using` */
+  [Symbol.dispose](): void;
+  /** Send a key press (simulates term:key event) */
+  press(key: string): Promise<void>;
+  /** Iterate frames yielded after each event */
+  [Symbol.asyncIterator](): AsyncIterator<Buffer$1>;
+}
+/**
+ * App definition returned by createApp().
+ */
+interface AppDefinition<S> {
+  run(element: ReactElement, options?: AppRunOptions): AppRunner<S>;
+}
+/**
+ * Result of app.run() — both a Promise<AppHandle> and an AsyncIterable<Buffer>.
+ *
+ * - `await app.run(el)` → AppHandle (backward compat)
+ * - `for await (const frame of app.run(el))` → iterate frames
+ */
+interface AppRunner<S> extends AsyncIterable<Buffer$1>, PromiseLike<AppHandle<S>> {}
+declare const StoreContext: React$1.Context<StoreApi$1<unknown> | null>;
+/**
+ * Hook for accessing app state with selectors.
+ *
+ * @example
+ * ```tsx
+ * const count = useApp(s => s.count)
+ * const { count, increment } = useApp(s => ({ count: s.count, increment: s.increment }))
+ * ```
+ */
+declare function useApp<S, T>(selector: (state: S) => T): T;
+/**
+ * Hook for accessing app state with shallow comparison.
+ *
+ * Like useApp, but uses shallow object comparison instead of Object.is().
+ * Use when your selector returns a new object on each call — this prevents
+ * re-renders when all individual fields are unchanged.
+ *
+ * @example
+ * ```tsx
+ * const { cursor, mode } = useAppShallow(s => ({
+ *   cursor: s.cursorNodeId,
+ *   mode: s.viewMode,
+ * }))
+ * ```
+ */
+declare function useAppShallow<S, T>(selector: (state: S) => T): T;
+/**
+ * Create an app with Zustand store and provider integration.
+ *
+ * This is Layer 3 - it provides:
+ * - Zustand store with fine-grained subscriptions
+ * - Providers as unified stores + event sources
+ * - Event handlers namespaced as 'provider:event'
+ *
+ * @param factory Store factory function that receives providers
+ * @param handlers Optional event handlers (namespaced as 'provider:event')
+ */
+declare function createApp<I extends Record<string, unknown>, S extends Record<string, unknown>>(factory: (inject: I) => StateCreator<S>, handlers?: EventHandlers<S & I>): AppDefinition<S & I>;
+//#endregion
+//#region packages/ag-term/src/runtime/tick.d.ts
+/**
+ * Time/tick source for silvery-loop.
+ *
+ * Creates an AsyncIterable that yields at regular intervals.
+ * Used for animations, spinners, progress bars, etc.
+ */
+/**
+ * Create a tick source that yields at regular intervals.
+ *
+ * The tick source respects AbortSignal for cleanup and stops
+ * when the signal is aborted.
+ *
+ * @param intervalMs Interval between ticks in milliseconds
+ * @param signal Optional AbortSignal to stop the tick source
+ * @returns AsyncIterable that yields tick numbers (0, 1, 2, ...)
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController()
+ * const ticks = createTick(100, controller.signal)
+ *
+ * for await (const tick of ticks) {
+ *   console.log(`Tick ${tick}`)
+ *   if (tick >= 10) controller.abort()
+ * }
+ * ```
+ */
+declare function createTick(intervalMs: number, signal?: AbortSignal): AsyncIterable<number>;
+/**
+ * Create a tick source that yields at approximately 60fps (~16ms).
+ *
+ * @param signal Optional AbortSignal to stop the tick source
+ * @returns AsyncIterable that yields frame numbers
+ */
+declare function createFrameTick(signal?: AbortSignal): AsyncIterable<number>;
+/**
+ * Create a tick source that yields once per second.
+ *
+ * @param signal Optional AbortSignal to stop the tick source
+ * @returns AsyncIterable that yields second counts
+ */
+declare function createSecondTick(signal?: AbortSignal): AsyncIterable<number>;
+/**
+ * Create a tick source with adaptive timing based on render performance.
+ *
+ * This is useful for maintaining a target frame rate while allowing
+ * for slower frames when needed.
+ *
+ * @param targetFps Target frames per second (default: 60)
+ * @param signal Optional AbortSignal to stop the tick source
+ * @returns AsyncIterable with timing information
+ */
+declare function createAdaptiveTick(targetFps?: number, signal?: AbortSignal): AsyncIterable<{
+  tick: number;
+  elapsed: number;
+  delta: number;
+}>;
+//#endregion
+export { defaultInit as $, RuntimeOptions as $t, DiffMode as A, createKeyEvent as An, PatchedConsole as At, filter as B, matchHotkey as Bn, ParsedMouse as Bt, resumeTerminalState as C, LayoutNode as Cn, createFocusManager as Ct, usePasteCallback as D, SilveryFocusEvent as Dn, term as Dt, PasteCallback as E, FocusEventProps as En, useInput as Et, layout as F, ParsedHotkey as Fn, TermEvents as Ft, merge as G, Event as Gt, fromArray as H, parseKey as Hn, parseMouseSequence as Ht, layoutSync as I, ParsedKeypress as In, TermProvider as It, throttle as J, Provider as Jt, take as K, EventData as Kt, batch as L, emptyKey as Ln, TermProviderOptions as Lt, render as M, dispatchKeyEvent as Mn, StyleChain as Mt, LayoutOptions as N, InputHandler as Nn, Term as Nt, createRuntime as O, SilveryKeyEvent as On, ConsoleStats as Ot, ensureLayoutEngine as P, Key as Pn, createTerm as Pt, createStore as Q, Runtime as Qt, concat as R, keyToModifiers as Rn, TermState as Rt, restoreTerminalState as S, SilveryWheelEvent as Sn, FocusSnapshot as St, run as T, MeasureMode as Tn, UseInputOptions as Tt, fromArrayWithDelay as U, parseKeypress as Un, Buffer$1 as Ut, filterMap as V, parseHotkey as Vn, isMouseSequence as Vt, map as W, Dims as Wt, StoreApi as X, ProviderEventKey as Xt, zip as Y, ProviderEvent as Yt, StoreConfig as Z, RenderTarget as Zt, CTRL_Z as _, ResizeEvent as _n, getTabOrder as _t, AppDefinition as a, ConsoleEntry as an, CapabilityLookup as at, captureTerminalState as b, MouseEventProps as bn, FocusManagerOptions as bt, AppRunner as c, BoxProps as cn, RuntimeContext as ct, EventHandlers as d, EventSource as dn, TermContext as dt, Cell as en, silveryUpdate as et, StoreContext as f, FocusEvent as fn, findByTestID as ft, CTRL_C as g, Rect as gn, getExplicitFocusLink as gt, useAppShallow as h, MouseEvent as hn, findSpatialTarget as ht, createTick as i, FrameCell as in, CacheBackendContext as it, diff as j, dispatchFocusEvent as jn, patchConsole as jt, createBuffer as k, createFocusEvent as kn, PatchConsoleOptions as kt, EventHandler as l, CustomEvent as ln, RuntimeContextValue as lt, useApp as m, KeyEvent as mn, findFocusableAncestor as mt, createFrameTick as n, TerminalBuffer as nn, BaseRuntimeEvents as nt, AppHandle as o, AgNode as on, CapabilityRegistryContext as ot, createApp as p, InteractiveState as pn, findEnclosingScope as pt, takeUntil as q, NamespacedEvent as qt, createSecondTick as r, UnderlineStyle as rn, CacheBackend as rt, AppRunOptions as s, BlurEvent as sn, FocusManagerContext as st, createAdaptiveTick as t, Style as tn, withFocusManagement as tt, EventHandlerContext as u, Event$1 as un, StderrContext as ut, TerminalLifecycleOptions as v, SignalEvent as vn, FocusChangeCallback as vt, RunOptions as w, MeasureFunc as wn, useExit as wt, performSuspend as x, SilveryMouseEvent as xn, FocusOrigin as xt, TerminalState as y, TextProps as yn, FocusManager as yt, debounce as z, keyToName as zn, createTermProvider as zt };
+//# sourceMappingURL=index-CBcSpGSM.d.mts.map