@bettertui/core 0.1.0

package/index.d.mts

@@ -0,0 +1,4541 @@
+import { AlignItems, AlignItems as AlignItems$1, AlignSelf, AlignSelf as AlignSelf$1, BorderStyle, ColorValue, ColorValue as ColorValue$1, FlexDirection, FlexDirection as FlexDirection$1, Gap, Gap as Gap$1, Inset, Inset as Inset$1, JustifyContent, JustifyContent as JustifyContent$1, KeyEvent as KeyEvent$1, KeyEventSource, KeyEventType, LayoutConstraints, LayoutConstraints as LayoutConstraints$1, Margin, Margin as Margin$1, MouseButton, MouseEvent, MouseEvent as MouseEvent$1, Overflow, Overflow as Overflow$1, Padding, Padding as Padding$1, Position, Position as Position$1, Sizing, Sizing as Sizing$1, Style, Style as Style$1, Theme, ThemeColors, ThemeSpacing, ValidationError, ValidationResult, generateId, isValidColor, validate, validateLayoutConstraints, validateStyle, warnIfInvalid } from "@bettertui/shared";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { EventEmitter } from "node:events";
+import { Readable, Writable } from "node:stream";
+//#region src/geometry.types.d.ts
+/** A 2D coordinate in the terminal grid. */
+interface Point {
+  /** Column position (0-indexed from left) */
+  x: number;
+  /** Row position (0-indexed from top) */
+  y: number;
+}
+/** Width and height dimensions. */
+interface Size {
+  /** Width in columns */
+  width: number;
+  /** Height in rows */
+  height: number;
+}
+/** A rectangular region defined by position and size. */
+interface Rect {
+  /** Left column offset */
+  x: number;
+  /** Top row offset */
+  y: number;
+  /** Width in columns */
+  width: number;
+  /** Height in rows */
+  height: number;
+}
+//#endregion
+//#region src/command/command.types.d.ts
+type HostContext = Record<string, unknown>;
+interface Instance {
+  id: string;
+  type: string;
+  props: Record<string, unknown>;
+  style: Style$1;
+  layout: LayoutConstraints$1;
+  children: Instance[];
+  parent: Instance | null;
+}
+interface TextInstance {
+  id: string;
+  type: "#text";
+  text: string;
+  parent: Instance | null;
+}
+type HostConfig = {
+  type: string;
+  props: Record<string, unknown>;
+  container: Instance;
+  instance: Instance;
+  textInstance: TextInstance;
+  suspenseInstance: Instance;
+  hydratableInstance: Instance;
+  publicInstance: Instance;
+  hostContext: HostContext;
+  updatePayload: Record<string, unknown>;
+  childSet: Instance[];
+  timeoutHandle: number;
+  cornerstoneTimeoutHandle: number;
+};
+type Command = {
+  type: "CreateNode";
+  id: string;
+  kind: string;
+} | {
+  type: "RemoveNode";
+  id: string;
+} | {
+  type: "AppendChild";
+  parent: string;
+  child: string;
+} | {
+  type: "InsertBefore";
+  reference: string;
+  child: string;
+} | {
+  type: "MoveNode";
+  node: string;
+  newParent: string;
+} | {
+  type: "ReplaceNode";
+  old: string;
+  new: string;
+} | {
+  type: "DetachNode";
+  id: string;
+} | {
+  type: "SetText";
+  id: string;
+  text: string;
+} | {
+  type: "SetStyle";
+  id: string;
+  style: Style$1;
+} | {
+  type: "SetLayout";
+  id: string;
+  layout: LayoutConstraints$1;
+} | {
+  type: "SetAttribute";
+  id: string;
+  key: string;
+  value: string;
+} | {
+  type: "RemoveAttribute";
+  id: string;
+  key: string;
+} | {
+  type: "BeginFrame";
+  frameId: number;
+} | {
+  type: "CommitFrame";
+  frameId: number;
+} | {
+  type: "Invalidate";
+  id: string;
+} | {
+  type: "Shutdown";
+} | {
+  type: "SetFlexDirection";
+  id: string;
+  direction: FlexDirection$1;
+} | {
+  type: "SetJustifyContent";
+  id: string;
+  value: JustifyContent$1;
+} | {
+  type: "SetAlignItems";
+  id: string;
+  value: AlignItems$1;
+} | {
+  type: "SetAlignSelf";
+  id: string;
+  value: AlignSelf$1;
+} | {
+  type: "SetFlexGrow";
+  id: string;
+  value: number;
+} | {
+  type: "SetFlexShrink";
+  id: string;
+  value: number;
+} | {
+  type: "SetFlexBasis";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetPosition";
+  id: string;
+  value: Position$1;
+} | {
+  type: "SetWidth";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetHeight";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetMinWidth";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetMaxWidth";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetMinHeight";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetMaxHeight";
+  id: string;
+  value: Sizing$1;
+} | {
+  type: "SetOverflow";
+  id: string;
+  value: Overflow$1;
+} | {
+  type: "SetOpacity";
+  id: string;
+  value: number;
+} | {
+  type: "SetZIndex";
+  id: string;
+  value: number;
+} | {
+  type: "SetPadding";
+  id: string;
+  value: Padding$1;
+} | {
+  type: "SetMargin";
+  id: string;
+  value: Margin$1;
+} | {
+  type: "SetGap";
+  id: string;
+  value: Gap$1;
+} | {
+  type: "SetInset";
+  id: string;
+  value: Inset$1;
+} | {
+  type: "SetForeground";
+  id: string;
+  color: ColorValue$1;
+} | {
+  type: "SetBackground";
+  id: string;
+  color: ColorValue$1;
+} | {
+  type: "SetBold";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetItalic";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetUnderline";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetDim";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetStrikethrough";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetInverse";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetHidden";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetBlink";
+  id: string;
+  value: boolean;
+} | {
+  type: "SetScreenMode";
+  mode: "alternate-screen" | "main-screen" | "split-footer";
+  footerHeight?: number;
+};
+interface CommandBufferConsumer {
+  push(command: Command): void;
+}
+//#endregion
+//#region src/command/buffer.d.ts
+declare class CommandBuffer {
+  private commands;
+  push(command: Command): void;
+  drain(): Command[];
+  peek(): readonly Command[];
+  clear(): void;
+  get length(): number;
+  get isEmpty(): boolean;
+}
+//#endregion
+//#region src/command/tree.d.ts
+declare function createInstance(type: string, props: Record<string, unknown>): Instance;
+declare function createTextInstance(text: string): TextInstance;
+declare function appendChild(parent: Instance, child: Instance | TextInstance): void;
+declare function removeChild(parent: Instance, child: Instance | TextInstance): void;
+declare function insertBefore(parent: Instance, child: Instance | TextInstance, reference: Instance | TextInstance): void;
+declare function prepareUpdate(_instance: Instance, _type: string, _oldProps: Record<string, unknown>, newProps: Record<string, unknown>): Record<string, unknown> | null;
+declare function commitUpdate(instance: Instance, updatePayload: Record<string, unknown>): void;
+declare function commitTextUpdate(textInstance: TextInstance, text: string): void;
+declare function finalizeInitialChildren(_instance: Instance): boolean;
+declare function resetAfterCommit(): void;
+//#endregion
+//#region src/reconciler.d.ts
+declare function createReconciler(buffer: CommandBuffer): {
+  createInstance: (type: string, props: Record<string, unknown>) => Instance;
+  createTextInstance: (text: string) => TextInstance;
+  appendChild: (parent: Instance, child: Instance | TextInstance) => void;
+  removeChild: (parent: Instance, child: Instance | TextInstance) => void;
+  insertBefore: (parent: Instance, child: Instance | TextInstance, reference: Instance | TextInstance) => void;
+  prepareUpdate: (instance: Instance, type: string, oldProps: Record<string, unknown>, newProps: Record<string, unknown>) => Record<string, unknown> | null;
+  commitUpdate: (instance: Instance, updatePayload: Record<string, unknown>) => void;
+  commitTextUpdate: (textInstance: TextInstance, text: string) => void;
+  finalizeInitialChildren: (instance: Instance) => boolean;
+  resetAfterCommit: () => void;
+};
+//#endregion
+//#region src/lib/clock.d.ts
+type TimerHandle = ReturnType<typeof globalThis.setTimeout>;
+interface Clock {
+  now(): number;
+  setTimeout(fn: () => void, delayMs: number): TimerHandle;
+  clearTimeout(handle: TimerHandle): void;
+  setInterval(fn: () => void, delayMs: number): TimerHandle;
+  clearInterval(handle: TimerHandle): void;
+}
+declare class SystemClock implements Clock {
+  now(): number;
+  setTimeout(fn: () => void, delayMs: number): TimerHandle;
+  clearTimeout(handle: TimerHandle): void;
+  setInterval(fn: () => void, delayMs: number): TimerHandle;
+  clearInterval(handle: TimerHandle): void;
+}
+//#endregion
+//#region src/platform/platform.types.d.ts
+type ScreenMode = "alternate-screen" | "main-screen" | "split-footer";
+type ExternalOutputMode = "capture-stdout" | "passthrough";
+interface BindingInfo$1 {
+  id: string;
+  keys: string;
+  command: string;
+  description: string | null;
+  enabled: boolean;
+  layer: string;
+}
+//#endregion
+//#region src/platform/binding.d.ts
+interface TerminalCapabilities$1 {
+  brand: string;
+  true_color: boolean;
+  kitty_keyboard: boolean;
+  csi_u: boolean;
+  bracketed_paste: boolean;
+  focus_events: boolean;
+  mouse: boolean;
+  osc52: boolean;
+  osc52_support: boolean;
+  osc8: boolean;
+  sync: boolean;
+  sgr_pixel: boolean;
+  underline_color: boolean;
+  strikethrough: boolean;
+  cursor_style: boolean;
+  alternate_scroll: boolean;
+  inline_images: boolean;
+  sixel: boolean;
+  columns: number;
+  rows: number;
+}
+interface CommandResult {
+  success: number;
+  errors: string[];
+  id_mappings: Array<{
+    temp: number;
+    real: number;
+  }>;
+}
+interface RenderResult {
+  output_data: string;
+  width: number;
+  height: number;
+  dirty_region_count: number;
+}
+interface NapiEngine {
+  processCommands(commandsJson: string): CommandResult;
+  beginFrame(): void;
+  commitFrame(): void;
+  render(): RenderResult;
+  renderFull(): RenderResult;
+  resize(width: number, height: number): void;
+  setScreenMode(mode: string, footerHeight?: number | null): void;
+  setBackgroundColor?(color: string): void;
+  setStyle(id: number, styleJson: string): void;
+  setLayout(id: number, layoutJson: string): void;
+  getNode(id: number): string;
+  treeSummary(): string;
+  nodeCount(): number;
+  frameCount(): number;
+  createNode(kind: string): number;
+  appendChild(parent: number, child: number): boolean;
+  /** Fast path: insert `child` immediately before `before` in the tree. */
+  insertBefore(before: number, child: number): boolean;
+  removeNode(id: number): void;
+  setText(id: number, text: string): void;
+  setScrollOffset(id: number, scrollX: number, scrollY: number): void;
+  root(): number;
+  validate(): boolean;
+  printTree(): string;
+  shutdown(): void;
+  hitGridCheck(x: number, y: number): number;
+  hitGridIsDirty(): boolean;
+  hitGridClearCurrent(): void;
+  hitGridPushScissor(x: number, y: number, width: number, height: number): void;
+  hitGridPopScissor(): void;
+  hitGridAddCurrentClipped(x: number, y: number, width: number, height: number, id: number): void;
+  hitGridDump(): string;
+}
+interface NapiEventBus {
+  pushKey(key: string, ctrl: boolean, shift: boolean, alt: boolean): void;
+  pushMouse(button: string, x: number, y: number): void;
+  pushMouseMotion(x: number, y: number): void;
+  pushPaste(text: string): void;
+  pushResize(width: number, height: number, prevWidth: number, prevHeight: number): void;
+  drain(): string;
+  len(): number;
+  isEmpty(): boolean;
+  clear(): void;
+}
+interface NapiFocusManager {
+  focus(id: number): boolean;
+  blur(id: number): boolean;
+  blurCurrent(): boolean;
+  focused(): number;
+  isFocused(id: number): boolean;
+  traverse(direction: string): number;
+  focusOrder(): number[];
+  clear(): void;
+}
+interface NapiTextEngine {
+  insertChar(ch: string): void;
+  insertStr(text: string): void;
+  deleteChar(): void;
+  cursorLeft(): void;
+  cursorRight(): void;
+  getText(): string;
+  cursorPosition(): number;
+  setCursorPosition(pos: number): void;
+  length(): number;
+  lineCount(): number;
+  isEmpty(): boolean;
+  wordCount(): number;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  undo(): boolean;
+  redo(): boolean;
+  clear(): void;
+}
+interface NapiScheduler {
+  requestFrame(): void;
+  beginFrame(): boolean;
+  endFrame(): void;
+  shouldRender(): boolean;
+  isIdle(): boolean;
+  frameCount(): number;
+  fps(): number;
+  requestRenderCoalesced(): void;
+  requestRenderImmediate(): void;
+  hasScheduledFrame(): boolean;
+  isRendering(): boolean;
+  beginRender(): void;
+  endRender(): boolean;
+}
+interface NapiKeymap {
+  addBinding(layer: string, id: string, keys: string, command: string, description: string | null, priority: number): boolean;
+  handleKey(key: string): string;
+  hasPending(): boolean;
+  clearPending(): void;
+  setMode(mode: string): void;
+  currentMode(): string;
+  clearMode(): void;
+  removeLayer(name: string): boolean;
+  setChordTimeout(ms: number): void;
+  chordTimeout(): number;
+  pendingKeys(): string[];
+  activeBindings(): BindingInfo$1[];
+  allBindings(): BindingInfo$1[];
+  commandHistory(): string[];
+  clearHistory(): void;
+  parseKey(keyStr: string): string;
+  parseSequence(keyStr: string): string[];
+}
+declare function createEngine(width?: number, height?: number): NapiEngine;
+declare function createEventBus(): NapiEventBus;
+declare function createFocusManager(): NapiFocusManager;
+declare function createTextEngine(text?: string): NapiTextEngine;
+declare function createScheduler(fps?: number): NapiScheduler;
+declare function createKeymap(): NapiKeymap;
+declare function detectCapabilities(): TerminalCapabilities$1;
+declare function getVersion(): string;
+declare function getNativePackageName(): string;
+interface HighlightSegment {
+  text: string;
+  fg: string | null;
+  bg: string | null;
+  bold: boolean | null;
+  italic: boolean | null;
+  underline: boolean | null;
+  dim: boolean | null;
+  strikethrough: boolean | null;
+}
+interface HighlightedLine {
+  segments: HighlightSegment[];
+}
+declare function highlightCode(code: string, language: string): HighlightedLine[];
+interface NapiWidgetHost {
+  widgetCount(): number;
+}
+declare function createWidgetHost(): NapiWidgetHost;
+interface NativeSpanFeedOptions {
+  chunkSize?: number;
+  initialChunks?: number;
+  maxBytes?: number;
+  /** 0 = grow, 1 = block */
+  growthPolicy?: number;
+  autoCommitOnFull?: boolean;
+  spanQueueCapacity?: number;
+}
+interface NativeSpanFeed {
+  write(data: Buffer): number;
+  drainSpans(out: Buffer): number;
+  close(): void;
+  reset(): void;
+  pendingSpans(): number;
+  pendingBytes(): number;
+  isClosed(): boolean;
+  isBackpressured(): boolean;
+  stats(): NapiSpanFeedStats;
+  markConsumed(chunkIndex: number): void;
+}
+interface NativeHitGrid {
+  resize(width: number, height: number): void;
+  add(x: number, y: number, width: number, height: number, id: number): void;
+  check(x: number, y: number): number;
+  clearNext(): void;
+  clearCurrent(): void;
+  swap(): boolean;
+  isDirty(): boolean;
+  dimensions(): string;
+  pushScissor(x: number, y: number, width: number, height: number): void;
+  popScissor(): void;
+  clearScissors(): void;
+}
+interface NapiSpanFeedStats {
+  bytesWritten: number;
+  spansCommitted: number;
+  chunks: number;
+  pendingSpans: number;
+}
+declare class NapiSpanFeed {
+  private feed;
+  constructor(feed: NativeSpanFeed);
+  write(data: Buffer): number;
+  drainSpans(out: Buffer): number;
+  close(): void;
+  reset(): void;
+  get pendingSpans(): number;
+  get pendingBytes(): number;
+  get isClosed(): boolean;
+  get isBackpressured(): boolean;
+  stats(): NapiSpanFeedStats;
+  markConsumed(chunkIndex: number): void;
+}
+declare function createSpanFeed(options?: NativeSpanFeedOptions): NapiSpanFeed;
+declare class NapiHitGrid {
+  private grid;
+  constructor(grid: NativeHitGrid);
+  resize(width: number, height: number): void;
+  add(x: number, y: number, width: number, height: number, id: number): void;
+  check(x: number, y: number): number;
+  clearNext(): void;
+  clearCurrent(): void;
+  swap(): boolean;
+  get isDirty(): boolean;
+  pushScissor(x: number, y: number, width: number, height: number): void;
+  popScissor(): void;
+  clearScissors(): void;
+}
+declare function createHitGrid(width: number, height: number): NapiHitGrid;
+interface NapiThemeColors {
+  background: string;
+  surface: string;
+  surfaceHigh: string;
+  surfaceLow: string;
+  primary: string;
+  primaryForeground: string;
+  secondary: string;
+  secondaryForeground: string;
+  text: string;
+  textMuted: string;
+  textDim: string;
+  border: string;
+  borderFocused: string;
+  accent: string;
+  accentForeground: string;
+  error: string;
+  warning: string;
+  success: string;
+  info: string;
+  scrollbar: string;
+  scrollbarThumb: string;
+}
+interface NapiThemeSpacing {
+  none: number;
+  xxs: number;
+  xs: number;
+  sm: number;
+  md: number;
+  lg: number;
+  xl: number;
+  xxl: number;
+}
+interface NapiThemeBorders {
+  style: string;
+  fg: string;
+}
+interface NapiTheme {
+  name: string;
+  colors: NapiThemeColors;
+  spacing: NapiThemeSpacing;
+  borders: NapiThemeBorders;
+}
+declare function createDarkTheme(): NapiTheme;
+declare function createLightTheme(): NapiTheme;
+interface NapiLoggerConfig {
+  level?: string;
+  color?: boolean;
+  timestamp?: boolean;
+  module?: boolean;
+  thread?: boolean;
+  file?: string;
+  maxFileSize?: number;
+  maxFiles?: number;
+  dev?: boolean;
+}
+interface NapiDiagnosticSnapshot {
+  renderCalls: number;
+  renderBytes: number;
+  eventDispatches: number;
+  layoutComputations: number;
+  cacheHits: number;
+  cacheMisses: number;
+  allocations: number;
+  averageFrameTime: number;
+  fps: number;
+}
+declare function loggerInit(config?: NapiLoggerConfig): void;
+declare function loggerSetLevel(level: string): void;
+declare function loggerGetLevel(): string;
+declare function loggerSetModuleFilter(include?: string[], exclude?: string[]): void;
+declare function loggerGetDiagnostics(): NapiDiagnosticSnapshot;
+declare function loggerFlush(): void;
+interface NativePluginHost {
+  register(name: string, version: string, author: string, capabilities: string[]): string | null;
+  unregister(name: string): string | null;
+  initialize(name: string): string | null;
+  start(name: string): string | null;
+  stop(name: string): string | null;
+  markError(name: string): string | null;
+  state(name: string): string | null;
+  pluginNames(): string[];
+  ensureSlot(slot: string, mode: string): void;
+  slotRegister(slot: string, pluginId: string, priority: number, value: string): number;
+  slotRemove(slot: string, token: number): boolean;
+  slotResolve(slot: string): string[];
+  slotTakeDirty(slot: string): boolean;
+}
+/** Plugin lifecycle state names returned by {@link NapiPluginHost.state}. */
+type PluginStateName = "registered" | "initialized" | "running" | "stopped" | "error";
+/** Slot resolution mode. */
+type SlotMode = "append" | "single-winner" | "replace";
+/**
+ * TypeScript wrapper around the native plugin host + slot registry — the
+ * BetterTUI plugin API.
+ * methods return an error string when the transition is illegal, else `null`.
+ * Slot values are strings (typically a node id or serialized descriptor).
+ */
+declare class NapiPluginHost {
+  private host;
+  constructor(host: NativePluginHost);
+  register(name: string, version: string, author: string, capabilities?: string[]): string | null;
+  unregister(name: string): string | null;
+  initialize(name: string): string | null;
+  start(name: string): string | null;
+  stop(name: string): string | null;
+  markError(name: string): string | null;
+  state(name: string): PluginStateName | null;
+  pluginNames(): string[];
+  ensureSlot(slot: string, mode?: SlotMode): void;
+  slotRegister(slot: string, pluginId: string, priority: number, value: string): number;
+  slotRemove(slot: string, token: number): boolean;
+  slotResolve(slot: string): string[];
+  slotTakeDirty(slot: string): boolean;
+}
+declare function createPluginHost(): NapiPluginHost;
+/**
+ * TypeScript wrapper around the native tween/spring animation timeline.
+ * Wraps `NativeTimeline` from the napi-rs binary.
+ */
+declare class NapiTimeline {
+  private _tl;
+  constructor(duration?: number, looping?: boolean);
+  /**
+   * Schedule a tween from `from` → `to` over `duration` seconds starting at
+   * `startTime`. Returns the animation index for {@link animationValue}.
+   */
+  addTween(from: number, to: number, duration: number, startTime: number, easing?: string): number;
+  play(): void;
+  pause(): void;
+  restart(): void;
+  /** Advance by `dt` seconds (frame delta). Call once per frame. */
+  update(dt: number): void;
+  /** Current interpolated value of tween at `index`. */
+  animationValue(index: number): number | null;
+  currentTime(): number;
+  isComplete(): boolean;
+  isPlaying(): boolean;
+  setSpeed(speed: number): void;
+  /** Progress 0.0–1.0 if timeline has a fixed duration, else `null`. */
+  progress(): number | null;
+}
+declare function createTimeline(duration?: number, looping?: boolean): NapiTimeline;
+type GraphicsFormat = "rgb" | "rgba" | "png";
+/**
+ * Build a Kitty graphics-protocol sequence transmitting+displaying raw pixel
+ * or PNG data with the given numeric `id`.
+ */
+declare function graphicsKittyWrite(format: GraphicsFormat, width: number, height: number, data: Buffer, id: number): Buffer;
+/** Build the Kitty sequence deleting image `id`. */
+declare function graphicsKittyDelete(id: number): Buffer;
+/** Build the Kitty sequence deleting all transmitted images. */
+declare function graphicsKittyDeleteAll(): Buffer;
+/**
+ * Build an iTerm2 inline-image sequence for `fileBytes` (e.g. PNG file data).
+ */
+declare function graphicsItermWrite(fileBytes: Buffer, name?: string, width?: number, height?: number): Buffer;
+/** Build a Sixel sequence for a raw `rgb`/`rgba` image (empty for `png`). */
+declare function graphicsSixelWrite(format: GraphicsFormat, width: number, height: number, data: Buffer): Buffer;
+/**
+ * Build the probe sequence(s) that detect which graphics protocols the
+ * terminal supports (Kitty query + DA1 for Sixel). Write the returned bytes
+ * to stdout, then wait for the terminal's DA1 response.
+ */
+declare function graphicsQuery(): Buffer;
+/**
+ * Build the OSC 52 sequence that sets the terminal clipboard to `text`.
+ * Write the returned bytes to stdout.
+ * `selection`: `"clipboard"` | `"primary"` | `"secondary"` | `"tertiary"`
+ */
+declare function clipboardSetSequence(selection: string, text: string): number[];
+/**
+ * Build the OSC 52 query sequence asking the terminal to report clipboard
+ * contents. Write the returned bytes to stdout; the response arrives as an
+ * inbound OSC 52 which {@link clipboardDecode} can decode.
+ */
+declare function clipboardQuerySequence(selection: string): number[];
+/**
+ * Decode a base64 OSC 52 clipboard payload into UTF-8 text.
+ * Returns `null` for the `?` query marker or invalid base64/UTF-8.
+ */
+declare function clipboardDecode(payload: string): string | null;
+//#endregion
+//#region src/runtime.d.ts
+interface CommandRuntimeOptions {
+  frameIntervalMs?: number;
+  autoStart?: boolean;
+  engine?: NapiEngine;
+  clock?: Clock;
+}
+declare class CommandRuntime {
+  private buffer;
+  private running;
+  private frameHandle;
+  private subscribers;
+  private frameCallbacks;
+  private lastFrameTime;
+  private frameIntervalMs;
+  private engine;
+  private width;
+  private height;
+  private clock;
+  constructor(bufferOrOptions?: CommandBuffer | CommandRuntimeOptions);
+  get commandBuffer(): CommandBuffer;
+  get isRunning(): boolean;
+  get terminalWidth(): number;
+  get terminalHeight(): number;
+  drain(): Command[];
+  flush(): void;
+  subscribe(fn: (commands: Command[]) => void): () => void;
+  onFrame(callback: (deltaMs: number) => void): () => void;
+  startFrameLoop(intervalMs?: number): void;
+  stopFrameLoop(): void;
+  requestFrame(): void;
+  resize(width: number, height: number): void;
+  render(): {
+    outputData: Buffer;
+    width: number;
+    height: number;
+  } | null;
+  dispose(): void;
+}
+//#endregion
+//#region src/lib/rgba.d.ts
+/**
+ * RGBA color class with static factory methods.
+ */
+/**
+ * RGBA color type with static factory methods.
+ * r, g, b, a are in 0-255 range.
+ */
+type RGBA = {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+declare namespace RGBA {
+  /** Create RGBA from 0-255 integer components. */
+  function fromInts(r: number, g: number, b: number, a?: number): RGBA;
+  /** Create RGBA from 0.0–1.0 float components. */
+  function fromValues(r: number, g: number, b: number, a?: number): RGBA;
+  /** Parse a CSS hex color string (#rgb, #rrggbb, #rrggbbaa). */
+  function fromHex(hex: string): RGBA;
+  /** Transparent black. */
+  const transparent: RGBA;
+  /** Convert to a #rrggbb hex string (ignores alpha). */
+  function toHex(rgba: RGBA): string;
+  /** Convert to a #rrggbbaa hex string. */
+  function toHexAlpha(rgba: RGBA): string;
+  /** Convert to a CSS rgba() string. */
+  function toCSS(rgba: RGBA): string;
+  /** Get ANSI RGB components as "r;g;b" string. */
+  function toAnsiColor(rgba: RGBA): string;
+  /** Check if RGBA is transparent (a === 0). */
+  function isTransparent(rgba: RGBA): boolean;
+  /** Check equality. */
+  function equals(a: RGBA, b: RGBA): boolean;
+  /** Blend src over dst using normal alpha compositing. */
+  function blend(dst: RGBA, src: RGBA): RGBA;
+}
+/** A color input: hex string, named color string, or RGBA object. */
+type ColorInput = string | RGBA | null | undefined;
+/**
+ * Parse any color input to RGBA.
+ * Supports: hex strings (#rgb, #rrggbb, #rrggbbaa), named colors,
+ * rgb()/rgba() strings, and RGBA objects.
+ */
+declare function parseColor(input: ColorInput): RGBA;
+/** Convert RGBA to a CSS color string suitable for the engine. */
+declare function rgbaToEngineColor(rgba: RGBA): string;
+//#endregion
+//#region src/renderables/Box.d.ts
+type BorderSide = "top" | "right" | "bottom" | "left";
+type BorderStyleKind = "single" | "double" | "round" | "thick" | "dashed" | "ascii" | "none";
+interface BoxOptions {
+  id?: string;
+  options?: any;
+  width?: number | string;
+  height?: number | string;
+  minWidth?: number | string;
+  maxWidth?: number | string;
+  minHeight?: number | string;
+  maxHeight?: number | string;
+  position?: "relative" | "absolute";
+  top?: number | string;
+  right?: number | string;
+  bottom?: number | string;
+  left?: number | string;
+  zIndex?: number;
+  flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+  flexGrow?: number;
+  flexShrink?: number;
+  flexBasis?: number | string;
+  flexWrap?: "nowrap" | "wrap";
+  alignItems?: "flex-start" | "center" | "flex-end" | "stretch" | "baseline";
+  alignSelf?: "flex-start" | "center" | "flex-end" | "stretch" | "baseline";
+  justifyContent?: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | "space-evenly";
+  overflow?: "visible" | "hidden" | "scroll";
+  gap?: number;
+  rowGap?: number;
+  columnGap?: number;
+  padding?: number;
+  paddingX?: number;
+  paddingY?: number;
+  paddingTop?: number;
+  paddingRight?: number;
+  paddingBottom?: number;
+  paddingLeft?: number;
+  margin?: number;
+  marginX?: number;
+  marginY?: number;
+  marginTop?: number;
+  marginRight?: number;
+  marginBottom?: number;
+  marginLeft?: number;
+  backgroundColor?: ColorInput;
+  borderStyle?: BorderStyleKind;
+  border?: boolean | BorderSide[];
+  borderColor?: ColorInput;
+  focusedBorderColor?: ColorInput;
+  title?: string;
+  titleColor?: ColorInput;
+  titleAlignment?: "left" | "center" | "right";
+  bottomTitle?: string;
+  bottomTitleAlignment?: "left" | "center" | "right";
+  opacity?: number;
+  visible?: boolean;
+  buffered?: boolean;
+  focusable?: boolean;
+  onMouseDown?: (event: unknown) => void;
+  onMouseUp?: (event: unknown) => void;
+  onMouseMove?: (event: unknown) => void;
+  onMouseDrag?: (event: unknown) => void;
+  onMouseDragEnd?: (event: unknown) => void;
+  onMouseDrop?: (event: unknown) => void;
+  onMouseOver?: (event: unknown) => void;
+  onMouseOut?: (event: unknown) => void;
+  onMouseScroll?: (event: unknown) => void;
+  onMouse?: (event: unknown) => void;
+  onKeyDown?: (key: unknown) => void;
+  onClick?: (event: unknown) => void;
+  onSizeChange?: () => void;
+  /**
+   * Called after each render frame with a buffer handle.
+   * Bound to the Box instance (`this` = the renderable).
+   * Use this for custom per-frame drawing on top of the box.
+   */
+  renderAfter?: (this: Box, buffer: unknown, deltaTime?: number) => void;
+}
+declare class Box extends EventEmitter {
+  protected readonly _renderer: CliRenderer;
+  protected _nodeId: number;
+  protected readonly _id: string;
+  protected _focused: boolean;
+  protected _visible: boolean;
+  protected _isDestroyed: boolean;
+  protected _opacity: number;
+  protected _backgroundColor: RGBA | null;
+  protected _borderStyle: BorderStyleKind;
+  protected _border: boolean | BorderSide[];
+  protected _borderColor: RGBA;
+  protected _focusedBorderColor: RGBA;
+  protected _focusable: boolean;
+  protected _title: string | undefined;
+  protected _titleColor: RGBA | undefined;
+  protected _titleAlignment: "left" | "center" | "right";
+  protected _children: Map<string, Box>;
+  protected _childList: Box[];
+  protected _parent: Box | null;
+  protected _options: BoxOptions;
+  private _renderAfterCallback;
+  constructor(renderer: CliRenderer, options?: BoxOptions, existingNodeId?: number);
+  get id(): string;
+  get nodeId(): number;
+  get focused(): boolean;
+  get visible(): boolean;
+  get isDestroyed(): boolean;
+  get opacity(): number;
+  get backgroundColor(): RGBA | null;
+  get borderStyle(): BorderStyleKind;
+  get border(): boolean | BorderSide[];
+  get renderer(): CliRenderer;
+  get boxOptions(): BoxOptions;
+  get parent(): Box | null;
+  getEstimatedHeight(): number;
+  /** Computed layout width (from options; not the engine-resolved value). */
+  get width(): number | string | undefined;
+  /** Computed layout height (from options; not the engine-resolved value). */
+  get height(): number | string | undefined;
+  /** Screen X position (approximate; engine is the source of truth). */
+  get x(): number;
+  /** Screen Y position (approximate; engine is the source of truth). */
+  get y(): number;
+  get screenX(): number;
+  get screenY(): number;
+  set visible(value: boolean);
+  set opacity(value: number);
+  set backgroundColor(color: ColorInput);
+  set borderColor(color: ColorInput);
+  set borderStyle(style: BorderStyleKind);
+  set border(value: boolean | BorderSide[]);
+  set title(value: string | undefined);
+  set focusedBorderColor(color: ColorInput);
+  set width(value: number | string);
+  set height(value: number | string);
+  set flexDirection(value: BoxOptions["flexDirection"]);
+  set flexGrow(value: number);
+  set flexBasis(value: number | string);
+  set marginBottom(value: number);
+  set marginTop(value: number);
+  set marginLeft(value: number);
+  set marginRight(value: number);
+  set zIndex(value: number);
+  add(child: Box, index?: number): void;
+  remove(child: Box): void;
+  getRenderable(id: string): Box | undefined;
+  getChildren(): Box[];
+  focus(): void;
+  blur(): void;
+  destroy(): void;
+  destroyRecursively(): void;
+  setLayout(layout: Partial<BoxOptions>): void;
+  setPosition(pos: {
+    top?: number | string;
+    left?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+  }): void;
+  protected _applyLayout(options: Partial<BoxOptions>): void;
+  protected _applyStyle(): void;
+}
+/**
+ * Root — the scene root, wrapping the engine's root node.
+ * Created automatically by CliRenderer and exposed as `renderer.root`.
+ */
+declare class Root extends Box {
+  constructor(renderer: CliRenderer);
+  destroy(): void;
+}
+//#endregion
+//#region src/devtools/devtools.types.d.ts
+type LogLevel = "debug" | "info" | "warn" | "error" | "trace";
+interface LogEntry {
+  id: number;
+  timestamp: number;
+  level: LogLevel;
+  category: string;
+  message: string;
+  data?: unknown | undefined;
+}
+type CommandType = "CreateNode" | "RemoveNode" | "AppendChild" | "InsertBefore" | "MoveNode" | "ReplaceNode" | "DetachNode" | "SetText" | "SetStyle" | "SetLayout" | "SetAttribute" | "RemoveAttribute" | "BeginFrame" | "CommitFrame" | "Invalidate" | "Shutdown" | string;
+interface RecordedCommand {
+  id: number;
+  timestamp: number;
+  type: CommandType;
+  payload: Record<string, unknown>;
+  duration?: number | undefined;
+}
+type EventCategory = "keyboard" | "mouse" | "focus" | "resize" | "lifecycle" | "clipboard" | "animation" | "scheduler";
+interface RecordedEvent {
+  id: number;
+  timestamp: number;
+  category: EventCategory;
+  type: string;
+  target?: string | undefined;
+  data?: unknown | undefined;
+  propagation?: ("captured" | "target" | "bubbled") | undefined;
+}
+interface FrameMetrics {
+  frameNumber: number;
+  timestamp: number;
+  duration: number;
+  commandCount: number;
+  dirtyRegionCount: number;
+  renderDuration?: number | undefined;
+  layoutDuration?: number | undefined;
+  paintDuration?: number | undefined;
+  ffiDuration?: number | undefined;
+}
+interface PerformanceSnapshot {
+  fps: number;
+  avgFrameTime: number;
+  minFrameTime: number;
+  maxFrameTime: number;
+  totalFrames: number;
+  droppedFrames: number;
+  commandCount: number;
+  dirtyNodeCount: number;
+  memoryUsage?: {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+  } | undefined;
+}
+interface DevToolsNode {
+  id: string;
+  type: string;
+  props: Record<string, unknown>;
+  style?: Record<string, unknown> | undefined;
+  layout?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } | undefined;
+  children: DevToolsNode[];
+  parent?: string | undefined;
+  dirty?: boolean | undefined;
+  visible?: boolean | undefined;
+  zIndex?: number | undefined;
+}
+interface SchedulerSnapshot {
+  isRunning: boolean;
+  isRendering: boolean;
+  hasScheduledRender: boolean;
+  frameCount: number;
+  droppedFrames: number;
+  pendingFrames: number;
+  highestPriority: string;
+  idleCallbacksPending: number;
+  animationFramesPending: number;
+  frameBudgetMs: number;
+  utilization: number;
+}
+interface FocusSnapshot {
+  focusedNodeId: string | null;
+  previousNodeId: string | null;
+  focusableNodes: string[];
+  tabOrder: string[];
+  currentScope: string | null;
+}
+interface TerminalCapabilities {
+  trueColor: boolean;
+  kittyKeyboard: boolean;
+  mouseSupport: boolean;
+  osc52: boolean;
+  osc8: boolean;
+  pixelSupport: boolean;
+  alternateScreen: boolean;
+  terminalBrand: string;
+  terminalSize: {
+    columns: number;
+    rows: number;
+  };
+  syncUpdate: boolean;
+  bracketedPaste: boolean;
+  focusEvents: boolean;
+  strikethrough: boolean;
+  underlineColor: boolean;
+  cursorStyle: boolean;
+  hyperlinks: boolean;
+  inlineImages: boolean;
+  sixel: boolean;
+}
+interface TimelineEntry {
+  id: number;
+  timestamp: number;
+  category: EventCategory | "render" | "command" | "layout" | "paint";
+  type: string;
+  duration?: number | undefined;
+  data?: unknown | undefined;
+}
+interface TreeSnapshot {
+  id: number;
+  timestamp: number;
+  tree: DevToolsNode;
+  nodeCount: number;
+}
+interface SnapshotDiff {
+  added: string[];
+  removed: string[];
+  changed: Array<{
+    id: string;
+    field: string;
+    old: unknown;
+    new: unknown;
+  }>;
+}
+interface DiagnosticExport {
+  version: string;
+  timestamp: number;
+  duration: number;
+  logs: readonly LogEntry[];
+  commands: readonly RecordedCommand[];
+  events: readonly RecordedEvent[];
+  frames: readonly FrameMetrics[];
+  performance: PerformanceSnapshot;
+  tree?: DevToolsNode | undefined;
+  scheduler?: SchedulerSnapshot | undefined;
+  focus?: FocusSnapshot | undefined;
+  capabilities?: TerminalCapabilities | undefined;
+  timeline: readonly TimelineEntry[];
+  snapshots: readonly TreeSnapshot[];
+}
+//#endregion
+//#region src/devtools/logger.d.ts
+interface LoggerOptions {
+  maxEntries?: number;
+  minLevel?: LogLevel | undefined;
+  onEntry?: ((entry: LogEntry) => void) | undefined;
+}
+declare class Logger {
+  private entries;
+  private nextId;
+  private minLevel;
+  private maxEntries;
+  private onEntry;
+  constructor(options?: LoggerOptions);
+  private shouldLog;
+  private record;
+  trace(category: string, message: string, data?: unknown): LogEntry;
+  debug(category: string, message: string, data?: unknown): LogEntry;
+  info(category: string, message: string, data?: unknown): LogEntry;
+  warn(category: string, message: string, data?: unknown): LogEntry;
+  error(category: string, message: string, data?: unknown): LogEntry;
+  getEntries(): readonly LogEntry[];
+  getEntriesByLevel(level: LogLevel): LogEntry[];
+  getEntriesByCategory(category: string): LogEntry[];
+  search(query: string): LogEntry[];
+  clear(): void;
+  get count(): number;
+}
+//#endregion
+//#region src/devtools/commandInspector.d.ts
+interface CommandInspectorOptions {
+  maxCommands?: number | undefined;
+  onCommand?: ((command: RecordedCommand) => void) | undefined;
+}
+declare class CommandInspector {
+  private commands;
+  private nextId;
+  private maxCommands;
+  private onCommand;
+  private commandCounts;
+  constructor(options?: CommandInspectorOptions);
+  record(type: CommandType, payload: Record<string, unknown>, duration?: number): RecordedCommand;
+  getCommands(): readonly RecordedCommand[];
+  getCommandsByType(type: string): RecordedCommand[];
+  getCommandsInRange(start: number, end: number): RecordedCommand[];
+  getCounts(): Map<string, number>;
+  getTotalCount(): number;
+  getRecent(count: number): RecordedCommand[];
+  clear(): void;
+  /** Get a summary of command activity */
+  getSummary(frameCount?: number): {
+    total: number;
+    byType: Record<string, number>;
+    lastTimestamp: number | null;
+    avgCommandsPerFrame: number;
+  };
+}
+//#endregion
+//#region src/devtools/eventInspector.d.ts
+interface EventInspectorOptions {
+  maxEvents?: number | undefined;
+  onEvent?: ((event: RecordedEvent) => void) | undefined;
+}
+declare class EventInspector {
+  private events;
+  private nextId;
+  private maxEvents;
+  private onEvent;
+  private categoryCounts;
+  constructor(options?: EventInspectorOptions);
+  record(category: EventCategory, type: string, target?: string, data?: unknown, propagation?: "captured" | "target" | "bubbled"): RecordedEvent;
+  recordKeyboard(key: string, modifiers: {
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+  }, target?: string): RecordedEvent;
+  recordMouse(type: string, x: number, y: number, button?: string, target?: string): RecordedEvent;
+  recordFocus(type: "focus" | "blur", nodeId: string): RecordedEvent;
+  recordResize(width: number, height: number, prevWidth?: number, prevHeight?: number): RecordedEvent;
+  recordLifecycle(type: string, data?: unknown): RecordedEvent;
+  getEvents(): readonly RecordedEvent[];
+  getEventsByCategory(category: EventCategory): RecordedEvent[];
+  getEventsByType(type: string): RecordedEvent[];
+  getEventsInRange(start: number, end: number): RecordedEvent[];
+  getCategoryCounts(): Map<string, number>;
+  getRecent(count: number): RecordedEvent[];
+  clear(): void;
+  get count(): number;
+}
+//#endregion
+//#region src/devtools/performance.d.ts
+interface PerformanceTrackerOptions {
+  maxFrames?: number | undefined;
+  onFrame?: ((metrics: FrameMetrics) => void) | undefined;
+}
+declare class PerformanceTracker {
+  private frames;
+  private nextFrameNumber;
+  private maxFrames;
+  private onFrame;
+  private frameStart;
+  private commandCountAtStart;
+  constructor(options?: PerformanceTrackerOptions);
+  /** Call at the start of a frame */
+  beginFrame(commandCount: number): void;
+  /** Call at the end of a frame with metrics */
+  endFrame(options: {
+    dirtyRegionCount?: number;
+    renderDuration?: number;
+    layoutDuration?: number;
+    paintDuration?: number;
+    ffiDuration?: number;
+  }): FrameMetrics;
+  /** Record a frame with all metrics at once */
+  recordFrame(metrics: Partial<FrameMetrics> & {
+    duration: number;
+  }): FrameMetrics;
+  getFrames(): readonly FrameMetrics[];
+  getRecentFrames(count: number): FrameMetrics[];
+  /** Calculate current FPS based on recent frames */
+  getFps(sampleSize?: number): number;
+  /** Get a full performance snapshot */
+  getSnapshot(): PerformanceSnapshot;
+  clear(): void;
+  get count(): number;
+}
+//#endregion
+//#region src/devtools/treeInspector.d.ts
+interface TreeInspectorOptions {
+  onTreeUpdate?: ((root: DevToolsNode | null) => void) | undefined;
+}
+declare class TreeInspector {
+  private root;
+  private nodeIndex;
+  private dirtyNodes;
+  private onTreeUpdate;
+  constructor(options?: TreeInspectorOptions);
+  /** Build a tree from a flat list of node descriptors */
+  buildTree(nodes: Array<{
+    id: string;
+    type: string;
+    parent?: string;
+    props?: Record<string, unknown>;
+    style?: Record<string, unknown>;
+    layout?: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+    dirty?: boolean;
+    visible?: boolean;
+    zIndex?: number;
+  }>): DevToolsNode;
+  /** Update a single node's properties */
+  updateNode(id: string, updates: Partial<Omit<DevToolsNode, "id" | "children">>): void;
+  /** Mark a node as dirty */
+  markDirty(id: string): void;
+  /** Clear dirty state for all nodes */
+  clearDirty(): void;
+  getNode(id: string): DevToolsNode | undefined;
+  getRoot(): DevToolsNode | null;
+  getDirtyNodes(): DevToolsNode[];
+  /** Find nodes matching a predicate */
+  findNodes(predicate: (node: DevToolsNode) => boolean): DevToolsNode[];
+  /** Get the path from root to a given node */
+  getPath(nodeId: string): DevToolsNode[];
+  /** Count total nodes in the tree */
+  countNodes(): number;
+  /** Get all nodes as a flat array */
+  getAllNodes(): DevToolsNode[];
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/schedulerInspector.d.ts
+interface SchedulerInspectorOptions {
+  onFrameDrop?: ((droppedCount: number) => void) | undefined;
+}
+declare class SchedulerInspector {
+  private frameCount;
+  private droppedFrames;
+  private pendingFrames;
+  private isRunning;
+  private isRendering;
+  private hasScheduledRender;
+  private highestPriority;
+  private idleCallbacksPending;
+  private animationFramesPending;
+  private frameBudgetMs;
+  private utilization;
+  private onFrameDrop;
+  constructor(options?: SchedulerInspectorOptions);
+  updateState(state: Partial<SchedulerSnapshot>): void;
+  recordFrameDrop(): void;
+  incrementFrameCount(): void;
+  getSnapshot(): SchedulerSnapshot;
+  getDropRate(): number;
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/focusInspector.d.ts
+interface FocusInspectorOptions {
+  onFocusChange?: ((snapshot: FocusSnapshot) => void) | undefined;
+}
+declare class FocusInspector {
+  private focusedNodeId;
+  private previousNodeId;
+  private focusableNodes;
+  private tabOrder;
+  private currentScope;
+  private focusHistory;
+  private onFocusChange;
+  constructor(options?: FocusInspectorOptions);
+  recordFocus(nodeId: string): void;
+  recordBlur(nodeId: string): void;
+  setFocusableNodes(nodes: string[]): void;
+  setTabOrder(order: string[]): void;
+  setScope(scope: string | null): void;
+  getSnapshot(): FocusSnapshot;
+  getFocusHistory(): Array<{
+    timestamp: number;
+    nodeId: string | null;
+    type: "focus" | "blur";
+  }>;
+  getRecentFocusChanges(count: number): Array<{
+    timestamp: number;
+    nodeId: string | null;
+    type: "focus" | "blur";
+  }>;
+  isFocused(nodeId: string): boolean;
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/capabilityInspector.d.ts
+interface CapabilityInspectorOptions {
+  onCapabilitiesDetected?: ((caps: TerminalCapabilities) => void) | undefined;
+}
+declare class CapabilityInspector {
+  private capabilities;
+  private onCapabilitiesDetected;
+  constructor(options?: CapabilityInspectorOptions);
+  update(capabilities: Partial<TerminalCapabilities>): void;
+  updateFromNative(capabilitiesJson: string): void;
+  get(): TerminalCapabilities;
+  has(capability: keyof TerminalCapabilities): boolean;
+  getSummary(): string[];
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/timeline.d.ts
+interface DevToolsTimelineOptions {
+  maxEntries?: number | undefined;
+  onEntry?: ((entry: TimelineEntry) => void) | undefined;
+}
+declare class DevToolsTimeline {
+  private entries;
+  private nextId;
+  private maxEntries;
+  private onEntry;
+  constructor(options?: DevToolsTimelineOptions);
+  record(category: TimelineEntry["category"], type: string, duration?: number, data?: unknown): TimelineEntry;
+  recordRender(duration: number, data?: unknown): TimelineEntry;
+  recordCommand(type: string, duration?: number): TimelineEntry;
+  recordEvent(category: EventCategory, type: string, data?: unknown): TimelineEntry;
+  getEntries(): readonly TimelineEntry[];
+  getEntriesByCategory(category: TimelineEntry["category"]): TimelineEntry[];
+  getEntriesInRange(start: number, end: number): TimelineEntry[];
+  getRecent(count: number): TimelineEntry[];
+  /** Get entries grouped by time windows */
+  getGroupedByWindow(windowMs: number): Array<{
+    start: number;
+    end: number;
+    entries: TimelineEntry[];
+  }>;
+  clear(): void;
+  get count(): number;
+}
+//#endregion
+//#region src/devtools/snapshot.d.ts
+interface SnapshotOptions {
+  maxSnapshots?: number | undefined;
+}
+declare class SnapshotManager {
+  private snapshots;
+  private nextId;
+  private maxSnapshots;
+  constructor(options?: SnapshotOptions);
+  /** Capture a snapshot of the current tree */
+  capture(tree: DevToolsNode): TreeSnapshot;
+  /** Compare two snapshots and return the diff */
+  diff(snapshotA: number, snapshotB: number): SnapshotDiff | null;
+  /** Compare two trees */
+  diffTrees(a: DevToolsNode, b: DevToolsNode): SnapshotDiff;
+  getSnapshots(): readonly TreeSnapshot[];
+  getSnapshot(id: number): TreeSnapshot | undefined;
+  private flattenTree;
+  private countNodes;
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/export.d.ts
+interface ExportOptions {
+  /** Include logs in the export */
+  includeLogs?: boolean | undefined;
+  /** Include commands in the export */
+  includeCommands?: boolean | undefined;
+  /** Include events in the export */
+  includeEvents?: boolean | undefined;
+  /** Include frame metrics in the export */
+  includeFrames?: boolean | undefined;
+  /** Include timeline in the export */
+  includeTimeline?: boolean | undefined;
+  /** Include snapshots in the export */
+  includeSnapshots?: boolean | undefined;
+}
+interface ExportData {
+  /** Logs to include */
+  logs?: readonly LogEntry[] | undefined;
+  /** Commands to include */
+  commands?: readonly RecordedCommand[] | undefined;
+  /** Events to include */
+  events?: readonly RecordedEvent[] | undefined;
+  /** Frame metrics to include */
+  frames?: readonly FrameMetrics[] | undefined;
+  /** Performance snapshot */
+  performance?: PerformanceSnapshot | undefined;
+  /** Render tree */
+  tree?: DevToolsNode | undefined;
+  /** Scheduler snapshot */
+  scheduler?: SchedulerSnapshot | undefined;
+  /** Focus snapshot */
+  focus?: FocusSnapshot | undefined;
+  /** Terminal capabilities */
+  capabilities?: TerminalCapabilities | undefined;
+  /** Timeline entries */
+  timeline?: readonly TimelineEntry[] | undefined;
+  /** Tree snapshots */
+  snapshots?: readonly TreeSnapshot[] | undefined;
+}
+/** Create a diagnostic export from collected data */
+declare function createExport(data: ExportData, options?: ExportOptions): DiagnosticExport;
+/** Serialize a diagnostic export to JSON */
+declare function exportToJson(exportData: DiagnosticExport): string;
+/** Create a summary report from a diagnostic export */
+declare function createSummary(exportData: DiagnosticExport): string;
+//#endregion
+//#region src/lib/outputCapture.d.ts
+declare class Capture extends EventEmitter {
+  private outputCache;
+  get size(): number;
+  write(stream: "stdout" | "stderr", data: string): void;
+  claimOutput(): string;
+  clear(): void;
+}
+//#endregion
+//#region src/devtools/consoleCapture.d.ts
+declare enum ConsoleLogLevel {
+  LOG = "LOG",
+  INFO = "INFO",
+  WARN = "WARN",
+  ERROR = "ERROR",
+  DEBUG = "DEBUG"
+}
+interface CallerInfo {
+  functionName: string;
+  fullPath: string;
+  fileName: string;
+  lineNumber: number;
+  columnNumber: number;
+}
+type ConsoleLogEntry = [Date, ConsoleLogLevel, unknown[], CallerInfo | null];
+declare const capture: Capture;
+declare class TerminalConsoleCache extends EventEmitter {
+  private _cachedLogs;
+  private readonly MAX_CACHE_SIZE;
+  private _collectCallerInfo;
+  private _cachingEnabled;
+  private _originalConsole;
+  private _active;
+  get cachedLogs(): ConsoleLogEntry[];
+  activate(): void;
+  private setupConsoleCapture;
+  private overrideConsoleMethods;
+  setCollectCallerInfo(enabled: boolean): void;
+  clearConsole(): void;
+  setCachingEnabled(enabled: boolean): void;
+  deactivate(): void;
+  private restoreOriginalConsole;
+  addLogEntry(level: ConsoleLogLevel, ...args: unknown[]): ConsoleLogEntry;
+  private appendToConsole;
+  destroy(): void;
+}
+declare const terminalConsoleCache: TerminalConsoleCache;
+//#endregion
+//#region src/platform/logger.d.ts
+type LogLevel$1 = "trace" | "debug" | "info" | "warn" | "error";
+interface LoggerConfig {
+  level?: LogLevel$1;
+  color?: boolean;
+  timestamp?: boolean;
+  module?: boolean;
+  thread?: boolean;
+  /**
+   * Explicit log file path. When set, file logging is enabled in any mode and
+   * writes to exactly this path. Overridden by the `BETTERTUI_LOG_DIR` env var.
+   */
+  file?: string;
+  maxFileSize?: number;
+  maxFiles?: number;
+  /**
+   * Development mode. When `true` and no explicit `file` is given, logs are
+   * written to a daily file under the repo-root `logs/` directory (and still
+   * mirrored to the terminal). When `false` (production), file logging stays
+   * OFF unless an explicit `file` path (or `BETTERTUI_LOG_DIR`) is provided.
+   *
+   * `CliRenderer` defaults this to `process.env.NODE_ENV !== "production"` when
+   * the caller does not set it explicitly.
+   */
+  dev?: boolean;
+}
+interface DiagnosticSnapshot {
+  renderCalls: number;
+  renderBytes: number;
+  eventDispatches: number;
+  layoutComputations: number;
+  cacheHits: number;
+  cacheMisses: number;
+  allocations: number;
+  averageFrameTime: number;
+  fps: number;
+}
+interface Logger$1 {
+  init(config: LoggerConfig): void;
+  setLevel(level: LogLevel$1): void;
+  getLevel(): LogLevel$1;
+  setModuleFilter(include?: string[], exclude?: string[]): void;
+  getDiagnostics(): DiagnosticSnapshot;
+  flush(): void;
+}
+declare function cacheHitRatio(snapshot: DiagnosticSnapshot): number;
+//#endregion
+//#region src/devtools/overlay/overlayHost.d.ts
+/** Corner the overlay is anchored to. */
+type OverlayCorner = "top-right" | "top-left" | "bottom-right" | "bottom-left";
+/** The minimal renderer surface the overlay reads from. */
+interface OverlayRenderer {
+  readonly terminalWidth: number;
+  readonly viewportHeight: number;
+  getDiagnostics(): DiagnosticSnapshot;
+  write(text: string): void;
+}
+interface OverlayHostOptions {
+  /** Corner to anchor panels to. Defaults to top-right. */
+  corner?: OverlayCorner;
+  /** Inner width of each panel in columns. Defaults to 28. */
+  panelWidth?: number;
+  /** Max rows a scrolling panel (events/tree) may show. Defaults to 8. */
+  panelBodyRows?: number;
+}
+/**
+ * Owns per-frame ANSI compositing of the debug overlay.
+ *
+ * The overlay is written *over* the engine's incremental output and is not part
+ * of the engine's dirty-diff, so the host tracks the rect it painted last frame
+ * and clears any rows that are no longer covered — preventing trails when a
+ * panel shrinks, moves, or is toggled off.
+ */
+declare class OverlayHost {
+  private readonly renderer;
+  private readonly devtools;
+  private corner;
+  private panelWidth;
+  private panelBodyRows;
+  /** Rows (1-based) painted on the previous frame, and their painted width. */
+  private previousRows;
+  private lastDirtyRegionCount;
+  constructor(renderer: OverlayRenderer, devtools: DevTools, options?: OverlayHostOptions);
+  /** Whether any panel is currently visible. */
+  get visible(): boolean;
+  configure(options: OverlayHostOptions): void;
+  /** Record the engine's reported dirty-region count for the current frame. */
+  setDirtyRegionCount(count: number): void;
+  /**
+   * Composite the visible panels over the current frame. Saves the cursor,
+   * clears rows vacated since the last paint, draws each visible panel, then
+   * restores the cursor. A no-op when nothing is visible (but still clears any
+   * previously-painted rows exactly once).
+   */
+  paint(): void;
+  /**
+   * Force-clear the whole overlay region (used on toggle-off before a full
+   * redraw). Returns nothing; writes directly.
+   */
+  clear(): void;
+  private clearPreviousOnly;
+  /** Build the framed lines for all visible panels, stacked vertically. */
+  private buildFrame;
+  private startColumn;
+  private startRow;
+}
+//#endregion
+//#region src/devtools/overlay/panel.types.d.ts
+/**
+ * Identifiers for the built-in debug panels.
+ *
+ * Panels map to the six diagnostics surfaces from the design proposal (§6.2):
+ * performance, tree, layout, events, dirty-regions, and render statistics.
+ * Panels 1 and 6 (performance + render statistics) share a single rendered
+ * panel; both live under {@link DebugPanel.Performance}.
+ */
+declare enum DebugPanel {
+  /** Panel 1 + 6 — FPS, frame timing, render calls, bytes, cache, memory. */
+  Performance = "performance",
+  /** Panel 2 — node tree viewer (display-only in the all-TS pass). */
+  Tree = "tree",
+  /** Panel 3 — layout inspector (box model, flex, computed dims). */
+  Layout = "layout",
+  /** Panel 4 — event tracer (key/mouse/focus/resize log). */
+  Events = "events",
+  /** Panel 5 — dirty-region visualizer (stats-level in the all-TS pass). */
+  DirtyRegions = "dirtyRegions"
+}
+/**
+ * Context handed to a {@link Panel} each frame. Panels are pure renderers:
+ * they read from the DevTools facade and diagnostics and return lines.
+ */
+interface PanelContext {
+  /** The live DevTools facade (inspectors + queries). */
+  readonly devtools: DevTools;
+  /** Engine diagnostics snapshot for the current frame. */
+  readonly diagnostics: {
+    renderCalls: number;
+    renderBytes: number;
+    eventDispatches: number;
+    layoutComputations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    allocations: number;
+    averageFrameTime: number;
+    fps: number;
+  };
+  /** Dirty-region count reported by the last engine frame. */
+  readonly dirtyRegionCount: number;
+  /** Maximum width a panel may occupy (columns). */
+  readonly maxWidth: number;
+  /** Maximum height a panel may occupy (rows). */
+  readonly maxHeight: number;
+}
+/**
+ * A debug panel: a pure function from state to lines. The {@link OverlayHost}
+ * positions the returned lines; a panel never writes to stdout itself.
+ */
+interface Panel {
+  /** Which panel this renders. */
+  readonly id: DebugPanel;
+  /** Title shown in the panel's header. */
+  readonly title: string;
+  /** Produce the panel body as an array of plain (unpositioned) lines. */
+  render(ctx: PanelContext): string[];
+}
+declare namespace ansiUtils_d_exports {
+  export { BoxChars, DrawBoxOptions, RESET$1 as RESET, RESTORE_CURSOR, ROUNDED_BOX, SAVE_CURSOR, SHARP_BOX, bar, bg$1 as bg, displayWidth, drawBox, fg$1 as fg, moveTo, padEnd, padStart, sgr, sparkline, stripAnsi, truncate };
+}
+/**
+ * ANSI helpers for the debug overlay.
+ *
+ * The overlay is composited by writing absolute-positioned ANSI to stdout
+ * *after* the engine's frame output (the engine returns finished base64 ANSI
+ * bytes; there is no TS-accessible cell buffer). These helpers build the escape
+ * sequences and lay out box-drawn panels. All coordinates are 1-based to match
+ * the terminal's `CSI row;col H` convention.
+ */
+/** Save the cursor position (DEC save). */
+declare const SAVE_CURSOR = "7";
+/** Restore the cursor position (DEC restore). */
+declare const RESTORE_CURSOR = "8";
+/** Reset all SGR attributes. */
+declare const RESET$1 = "";
+/** Move the cursor to an absolute (row, col), both 1-based. */
+declare function moveTo(row: number, col: number): string;
+/** Wrap text in an SGR sequence and a reset. */
+declare function sgr(text: string, ...codes: number[]): string;
+/** 24-bit foreground color. */
+declare function fg$1(r: number, g: number, b: number): string;
+/** 24-bit background color. */
+declare function bg$1(r: number, g: number, b: number): string;
+/** Strip ANSI escape sequences from a string. */
+declare function stripAnsi(text: string): string;
+/** Visible width of a string (ANSI-aware, treats each code point as width 1). */
+declare function displayWidth(text: string): number;
+/**
+ * Truncate a string to a visible width, appending an ellipsis when clipped.
+ * ANSI-unaware truncation would corrupt escape sequences, so callers should
+ * pass plain text; styling is applied by the panel afterwards.
+ */
+declare function truncate(text: string, width: number, ellipsis?: string): string;
+/** Right-pad plain text to a fixed visible width. */
+declare function padEnd(text: string, width: number, fill?: string): string;
+/** Left-pad plain text to a fixed visible width. */
+declare function padStart(text: string, width: number, fill?: string): string;
+interface BoxChars {
+  topLeft: string;
+  topRight: string;
+  bottomLeft: string;
+  bottomRight: string;
+  horizontal: string;
+  vertical: string;
+}
+declare const ROUNDED_BOX: BoxChars;
+declare const SHARP_BOX: BoxChars;
+interface DrawBoxOptions {
+  title?: string | undefined;
+  /** Inner content width (columns between the vertical borders). */
+  width: number;
+  chars?: BoxChars;
+  /** Optional style codes applied to the border characters. */
+  borderSgr?: number[];
+}
+/**
+ * Draw a box around the given content lines. Content is truncated/padded to the
+ * requested inner width. Returns the framed lines (borders included), each a
+ * complete row of the panel. Lines do not include positioning; the host places
+ * them with {@link moveTo}.
+ */
+declare function drawBox(lines: string[], options: DrawBoxOptions): string[];
+/** Render a numeric series as a unicode sparkline of the given width. */
+declare function sparkline(values: number[], width: number): string;
+/** Render a 0..1 ratio as a horizontal bar of the given width. */
+declare function bar(ratio: number, width: number, filledChar?: string, emptyChar?: string): string;
+//#endregion
+//#region src/devtools/index.d.ts
+/** Memory statistics captured from the Node.js process. */
+interface MemoryStats {
+  heapUsed: number;
+  heapTotal: number;
+  external: number;
+  rss: number;
+  arrayBuffers: number;
+}
+/** A lightweight console surface backed by the DevTools logger. */
+interface DebugConsole {
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  /** Recent console entries, most-recent last. */
+  entries(): readonly LogEntry[];
+  clear(): void;
+}
+interface DevTools {
+  /** Whether DevTools is enabled */
+  readonly enabled: boolean;
+  /** Structured logger */
+  readonly logger: Logger;
+  /** Command inspector — records every command emitted */
+  readonly commands: CommandInspector;
+  /** Event inspector — tracks keyboard, mouse, focus, resize events */
+  readonly events: EventInspector;
+  /** Performance tracker — frame timing, FPS, metrics */
+  readonly performance: PerformanceTracker;
+  /** Tree inspector — render tree, props, styles, layout */
+  readonly tree: TreeInspector;
+  /** Scheduler inspector — frame budget, drops, callbacks */
+  readonly scheduler: SchedulerInspector;
+  /** Focus inspector — focused node, tab order, scopes */
+  readonly focus: FocusInspector;
+  /** Terminal capability inspector */
+  readonly capabilities: CapabilityInspector;
+  /** Timeline — chronological event recording */
+  readonly timeline: DevToolsTimeline;
+  /** Snapshot manager — capture and compare tree states */
+  readonly snapshots: SnapshotManager;
+  /** Lightweight console surface backed by the logger */
+  readonly console: DebugConsole;
+  /** Panels the host overlay should currently render. */
+  readonly visiblePanels: ReadonlySet<DebugPanel>;
+  /** Show a debug panel. */
+  show(panel: DebugPanel): void;
+  /** Hide a debug panel. */
+  hide(panel: DebugPanel): void;
+  /** Toggle a debug panel's visibility. Returns the new visibility. */
+  toggle(panel: DebugPanel): boolean;
+  /** Whether a given panel is currently visible. */
+  isVisible(panel: DebugPanel): boolean;
+  /** Current performance snapshot. */
+  getStats(): PerformanceSnapshot;
+  /** Begin capturing a profiling window. */
+  startProfiling(): void;
+  /** Stop the current profiling window and return the frames captured. */
+  stopProfiling(): readonly FrameMetrics[];
+  /** Inspect a node by id; returns its recorded tree node if known. */
+  inspect(nodeId: string): DevToolsNode | undefined;
+  /** Highlight a node (records the highlight target for the overlay). */
+  highlight(nodeId: string): void;
+  /** Clear any active highlight. */
+  clearHighlight(): void;
+  /** The currently highlighted node id, if any. */
+  readonly highlightedNodeId: string | null;
+  /** Enable or disable live event tracing. */
+  traceEvents(enabled: boolean): void;
+  /** Recorded event log. */
+  getEventLog(): readonly RecordedEvent[];
+  /** Layout box for a node, if recorded. */
+  inspectLayout(nodeId: string): DevToolsNode["layout"] | undefined;
+  /** Show the dirty-region panel (stats-level). */
+  showDirtyRegions(enabled: boolean): void;
+  /** Current process memory usage. */
+  getMemoryStats(): MemoryStats;
+  /** Capture a heap snapshot summary (memory stats point-in-time). */
+  takeHeapSnapshot(): MemoryStats;
+  /** Record a command being emitted */
+  recordCommand(type: string, payload: Record<string, unknown>, duration?: number | undefined): void;
+  /** Record a render frame */
+  recordFrame(options: {
+    duration: number;
+    commandCount?: number | undefined;
+    dirtyRegionCount?: number | undefined;
+    renderDuration?: number | undefined;
+    layoutDuration?: number | undefined;
+    paintDuration?: number | undefined;
+    ffiDuration?: number | undefined;
+  }): void;
+  /** Record a keyboard event */
+  recordKeyboard(key: string, modifiers: {
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+  }, target?: string | undefined): void;
+  /** Record a mouse event */
+  recordMouse(type: string, x: number, y: number, button?: string | undefined, target?: string | undefined): void;
+  /** Record a focus change */
+  recordFocus(type: "focus" | "blur", nodeId: string): void;
+  /** Record a resize event */
+  recordResize(width: number, height: number, prevWidth?: number | undefined, prevHeight?: number | undefined): void;
+  /** Update terminal capabilities */
+  updateCapabilities(capabilities: Partial<TerminalCapabilities>): void;
+  /** Update scheduler state */
+  updateScheduler(state: Partial<SchedulerSnapshot>): void;
+  /** Capture a tree snapshot */
+  captureSnapshot(tree: DevToolsNode): number;
+  /** Get a full diagnostic export */
+  exportData(options?: ExportOptions | undefined): DiagnosticExport;
+  /** Get export as JSON string */
+  exportJson(options?: ExportOptions | undefined): string;
+  /** Get a summary report */
+  getSummary(): string;
+  /** Reset all inspectors */
+  reset(): void;
+  /** Dispose all resources */
+  dispose(): void;
+}
+interface CreateDevToolsOptions {
+  enabled?: boolean | undefined;
+  maxEvents?: number | undefined;
+  logging?: boolean | undefined;
+  logLevel?: ("debug" | "info" | "warn" | "error" | "trace") | undefined;
+  timeline?: boolean | undefined;
+  performance?: boolean | undefined;
+  snapshots?: boolean | undefined;
+}
+/** Options accepted by the `debug` field of `CliRendererOptions`. */
+type DevToolsOptions = CreateDevToolsOptions;
+/**
+ * Create a DevTools instance.
+ *
+ * When `enabled` is false or omitted, returns a no-op implementation with
+ * near-zero overhead. When `enabled: true`, returns a fully functional
+ * DevTools instance that can record commands, events, performance metrics,
+ * and more.
+ */
+declare function createDevTools(options?: CreateDevToolsOptions): DevTools;
+//#endregion
+//#region src/lib/parseKeypress.d.ts
+declare const nonAlphanumericKeys: string[];
+declare const terminalNamedSingleStrokeKeys: string[];
+type KeyEventType$1 = "press" | "repeat" | "release";
+interface ParsedKey {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  option: boolean;
+  sequence: string;
+  number: boolean;
+  raw: string;
+  eventType: KeyEventType$1;
+  source: "raw" | "kitty";
+  code?: string;
+  super?: boolean;
+  hyper?: boolean;
+  capsLock?: boolean;
+  numLock?: boolean;
+  baseCode?: number;
+  repeated?: boolean;
+}
+type ParseKeypressOptions = {
+  useKittyKeyboard?: boolean;
+};
+declare const parseKeypress: (input?: Buffer$1 | string, options?: ParseKeypressOptions) => ParsedKey | null;
+//#endregion
+//#region src/lib/keyHandler.d.ts
+declare class KeyEvent implements ParsedKey {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  option: boolean;
+  sequence: string;
+  number: boolean;
+  raw: string;
+  eventType: KeyEventType$1;
+  source: "raw" | "kitty";
+  code?: string;
+  super?: boolean;
+  hyper?: boolean;
+  capsLock?: boolean;
+  numLock?: boolean;
+  baseCode?: number;
+  repeated?: boolean;
+  private _defaultPrevented;
+  private _propagationStopped;
+  constructor(key: ParsedKey);
+  /** Alias for `option` — backward-compatible with RawKeyEvent.alt. */
+  get alt(): boolean;
+  get defaultPrevented(): boolean;
+  get propagationStopped(): boolean;
+  preventDefault(): void;
+  stopPropagation(): void;
+}
+/**
+ * Metadata attached to a {@link PasteEvent}. Used by consumers to decide
+ * whether to insert, filter, or transform pasted content (e.g. skip binary
+ * paste into a text field).
+ */
+interface PasteMetadata$1 {
+  /** MIME type if the terminal reported one (e.g. `text/plain`). */
+  mimeType?: string;
+  /** Coarse kind of the pasted payload. */
+  kind?: "text" | "binary" | "unknown";
+}
+declare class PasteEvent {
+  type: "paste";
+  bytes: Uint8Array;
+  /** Optional metadata attached to the paste event (e.g. bracketed-paste info). */
+  metadata?: PasteMetadata$1;
+  private _defaultPrevented;
+  private _propagationStopped;
+  constructor(bytes: Uint8Array, metadata?: PasteMetadata$1);
+  get defaultPrevented(): boolean;
+  get propagationStopped(): boolean;
+  preventDefault(): void;
+  stopPropagation(): void;
+}
+type KeyHandlerEventMap = {
+  keypress: [KeyEvent];
+  keyrelease: [KeyEvent];
+  paste: [PasteEvent];
+};
+declare class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
+  processParsedKey(parsedKey: ParsedKey): boolean;
+  processPaste(bytes: Uint8Array, metadata?: PasteMetadata$1): void;
+}
+/**
+ * This class is used internally by the renderer to ensure global handlers
+ * can preventDefault before renderable handlers process events.
+ *
+ * NOTE: `emit` is overridden to route every emission through `emitWithPriority`,
+ * so that global listeners always run before renderable listeners and can
+ * `preventDefault()` / `stopPropagation()` to short-circuit them. Previously
+ * this override was missing, which meant `processParsedKey`'s direct
+ * `this.emit("keypress", …)` bypassed priority dispatch entirely.
+ */
+declare class InternalKeyHandler extends KeyHandler {
+  private renderableHandlers;
+  /**
+   * Override `emit` so that all emissions for the three domain event types go
+   * through `emitWithPriority` (global listeners first, then renderable
+   * listeners, with propagation / defaultPrevented checks in between).
+   * Unknown event names fall through to the base `EventEmitter.emit` so that
+   * Node's internal events (e.g. `newListener`, `removeListener`) are not
+   * broken.
+   */
+  emit(event: string | symbol, ...args: unknown[]): boolean;
+  emitWithPriority<K extends keyof KeyHandlerEventMap>(event: K, ...args: KeyHandlerEventMap[K]): boolean;
+  onInternal<K extends keyof KeyHandlerEventMap>(event: K, handler: (...args: KeyHandlerEventMap[K]) => void): void;
+  offInternal<K extends keyof KeyHandlerEventMap>(event: K, handler: (...args: KeyHandlerEventMap[K]) => void): void;
+}
+//#endregion
+//#region src/lib/parseMouse.d.ts
+/**
+ * Mouse event parser for X10 and SGR mouse sequences.
+ * Parses terminal mouse escape sequences into RawMouseEvent objects.
+ */
+type MouseEventType$1 = "down" | "up" | "move" | "drag" | "drag-end" | "drop" | "over" | "out" | "scroll";
+interface ScrollInfo {
+  direction: "up" | "down" | "left" | "right";
+  delta: number;
+}
+interface RawMouseEvent {
+  type: MouseEventType$1;
+  button: number;
+  x: number;
+  y: number;
+  modifiers: {
+    shift: boolean;
+    alt: boolean;
+    ctrl: boolean;
+  };
+  scroll?: ScrollInfo;
+}
+declare class MouseParser {
+  private mouseButtonsPressed;
+  private static readonly SCROLL_DIRECTIONS;
+  reset(): void;
+  private decodeInput;
+  parseMouseEvent(data: Uint8Array): RawMouseEvent | null;
+  parseAllMouseEvents(data: Uint8Array): RawMouseEvent[];
+  private parseMouseSequenceAt;
+  private parseSgrSequence;
+  private parseBasicSequence;
+  private decodeSgrEvent;
+  private decodeBasicEvent;
+}
+//#endregion
+//#region src/lib/keyInput.d.ts
+/**
+ * Events emitted by {@link KeyInput}. Mirrors the four kinds of `StdinEvent`
+ * produced by the parser so that nothing read from stdin is silently dropped.
+ *
+ * Historical bug: `KeyInput.drain` previously handled only `type === "key"`
+ * and discarded every `mouse` / `paste` / `response` event, which made mouse
+ * input, bracketed paste, and terminal-capability replies unreachable from
+ * the renderer.
+ */
+type KeyInputEvents = {
+  keypress: [KeyEvent];
+  keyrelease: [KeyEvent];
+  mouse: [RawMouseEvent, string];
+  paste: [PasteEvent];
+  response: [string, string];
+};
+declare class KeyInput extends EventEmitter<KeyInputEvents> {
+  private stdinParser;
+  private rawMode;
+  private readonly onDataBound;
+  constructor();
+  start(): void;
+  stop(): void;
+  private onData;
+  private drain;
+}
+//#endregion
+//#region src/lib/renderableEvents.d.ts
+/**
+ * Event enums for BetterTUI renderables and renderer.
+ */
+/** Events emitted by the CliRenderer. */
+declare enum CliRenderEvents {
+  RESIZE = "resize",
+  FRAME = "frame",
+  FOCUS = "focus",
+  BLUR = "blur",
+  FOCUSED_RENDERABLE = "focused_renderable",
+  FOCUSED_EDITOR = "focused_editor",
+  THEME_MODE = "theme_mode",
+  PALETTE = "palette",
+  CAPABILITIES = "capabilities",
+  SELECTION = "selection",
+  DEBUG_OVERLAY_TOGGLE = "debugOverlay:toggle",
+  DESTROY = "destroy",
+  MEMORY_SNAPSHOT = "memory:snapshot"
+}
+/** Events emitted by all Renderable instances. */
+declare enum RenderableEvents {
+  FOCUSED = "focused",
+  BLURRED = "blurred",
+  DESTROYED = "destroyed"
+}
+/** Events emitted by Input. */
+declare enum InputEvents {
+  INPUT = "input",
+  CHANGE = "change",
+  ENTER = "enter"
+}
+/** Events emitted by Select. */
+declare enum SelectEvents {
+  SELECTION_CHANGED = "selection_changed",
+  ITEM_SELECTED = "item_selected"
+}
+/** Events emitted by TabSelect. */
+declare enum TabSelectEvents {
+  SELECTION_CHANGED = "selection_changed",
+  ITEM_SELECTED = "item_selected"
+}
+/** Events emitted by Slider. */
+declare enum SliderEvents {
+  CHANGE = "change"
+}
+/** Layout-related events. */
+declare enum LayoutEvents {
+  LAYOUT_CHANGED = "layout-changed",
+  RESIZED = "resized"
+}
+//#endregion
+//#region src/platform/cliRenderer.d.ts
+interface RawKeyEvent {
+  name: string;
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  meta: boolean;
+  sequence: string;
+  preventDefault(): void;
+}
+interface CliRendererOptions {
+  width?: number;
+  height?: number;
+  autoStart?: boolean;
+  exitOnCtrlC?: boolean;
+  targetFps?: number;
+  screenMode?: ScreenMode;
+  footerHeight?: number;
+  externalOutputMode?: ExternalOutputMode;
+  logger?: LoggerConfig;
+  debug?: boolean | DevToolsOptions;
+  onDestroy?: () => void;
+  enableMouseMovement?: boolean;
+  useMouse?: boolean;
+  autoFocus?: boolean;
+  backgroundColor?: string;
+}
+/** Interactive terminal console overlay for capturing and inspecting console log output. */
+declare class TerminalConsole extends EventEmitter {
+  private _visible;
+  private _renderer;
+  keyBindings: Record<string, unknown>;
+  onCopySelection?: () => void;
+  constructor(renderer?: CliRenderer);
+  attachRenderer(renderer: CliRenderer): void;
+  show(): void;
+  hide(): void;
+  toggle(): void;
+  get visible(): boolean;
+  clear(): void;
+  entries(): readonly ConsoleLogEntry[];
+  saveLogsToFile(filepath?: string): string | null;
+}
+type ThemeMode = "light" | "dark";
+type FrameCallback = (deltaTime: number) => void | Promise<void>;
+declare class CliRenderer extends EventEmitter {
+  private engine;
+  private keymap;
+  private _keyInput;
+  private _keyDispatch;
+  private _capabilities;
+  private width;
+  private height;
+  private renderOffset;
+  private _screenMode;
+  private _externalOutputMode;
+  private externalOutputBuffer;
+  private nodes;
+  private running;
+  private paused;
+  private _devtools;
+  private overlay;
+  private lastFrameTime;
+  private _frameId;
+  private _frameInterval;
+  private _frameCallbacks;
+  private _lifecyclePasses;
+  private _root;
+  private _console;
+  private _themeMode;
+  private _targetFps;
+  private _onDestroy;
+  private _pendingRender;
+  private _resizeHandler;
+  private _liveCount;
+  constructor(options?: CliRendererOptions);
+  get frameId(): number;
+  get terminalWidth(): number;
+  get terminalHeight(): number;
+  get viewportHeight(): number;
+  get screenMode(): ScreenMode;
+  get externalOutputMode(): ExternalOutputMode;
+  get keyInput(): KeyInput;
+  /**
+   * Two-tier priority key dispatcher.
+   *
+   * - `.on("keypress", fn)` → tier-1 global handler (fires before any focused
+   *   widget).  Can call `key.preventDefault()` / `key.stopPropagation()`.
+   * - `.onInternal("keypress", fn)` → tier-2 renderable handler (used by
+   *   focusable widgets; only fires when no global handler stopped propagation).
+   *
+   * Example code that needs to intercept keys before the focused widget should
+   * use `renderer.keyHandler.on(...)`.  Widgets must use
+   * `renderer.keyHandler.onInternal(...)` inside `focus()`.
+   */
+  get keyHandler(): InternalKeyHandler;
+  get version(): string;
+  get isRunning(): boolean;
+  /** The scene root renderable. All top-level renderables should be added here. */
+  get root(): Root;
+  /** The terminal console overlay. */
+  get console(): TerminalConsole;
+  /** Current terminal theme mode (light/dark). */
+  get themeMode(): ThemeMode;
+  /** Terminal capabilities detected at startup. */
+  get capabilities(): TerminalCapabilities$1;
+  getDiagnostics(): DiagnosticSnapshot;
+  get devtools(): DevTools;
+  get debugEnabled(): boolean;
+  /** Start the render loop and keyboard input. */
+  start(): void;
+  /** Stop the render loop and exit alternate screen. */
+  stop(): void;
+  /**
+   * Auto-start / toggle mode.
+   * Starts if stopped, or pauses/resumes the loop if running.
+   */
+  auto(): void;
+  /** Pause the frame loop without stopping input. */
+  pause(): void;
+  /** Resume a paused frame loop. */
+  resume(): void;
+  /** Full suspend: stop input and frame loop. */
+  suspend(): void;
+  /** Full cleanup: stop everything and destroy engine. */
+  destroy(): void;
+  private _startFrameLoop;
+  private _stopFrameLoop;
+  /** Register a frame callback (called every frame before render). */
+  setFrameCallback(cb: FrameCallback): void;
+  /** Remove a previously registered frame callback. */
+  removeFrameCallback(cb: FrameCallback): void;
+  /** Clear all frame callbacks. */
+  clearFrameCallbacks(): void;
+  /** Register a function to be called once per frame before render (lifecycle pass). */
+  registerLifecyclePass(fn: () => void): void;
+  /** Unregister a previously registered lifecycle pass function. */
+  unregisterLifecyclePass(fn: () => void): void;
+  /** Request an immediate render (useful outside the frame loop). */
+  requestRender(): void;
+  /** Set the terminal window title via OSC 0 sequence. */
+  setTerminalTitle(title: string): void;
+  setBackgroundColor(color: string): void;
+  dumpHitGrid(): void;
+  copyToClipboardOSC52(text: string): void;
+  clearClipboardOSC52(): void;
+  /** Increment the live render counter; starts the renderer if not running. */
+  requestLive(): void;
+  /** Decrement the live render counter. */
+  dropLive(): void;
+  clearSelection(): void;
+  getSelectionContainer(): null;
+  get hasSelection(): boolean;
+  setCursorPosition(_x: number, _y: number, _visible?: boolean): void;
+  toggleDebugOverlay(panel?: DebugPanel): void;
+  configureDebugOverlay(options: Parameters<OverlayHost["configure"]>[0]): void;
+  get rootNodeId(): number;
+  getChildrenOf(id: number): number[];
+  setNodeStyle(id: number, style: Style$1): void;
+  setNodeLayout(id: number, layout: LayoutConstraints$1): void;
+  insertNodeBefore(parentId: number, childId: number, beforeId: number): void;
+  createNode(kind: string): number;
+  appendChild(parent: number, child: number): boolean;
+  removeNode(id: number): void;
+  setText(id: number, text: string): void;
+  /** Set the scroll offset on a node so its children are shifted during rendering.
+   *  Use with `overflow: "hidden"` on the same node for clipped scrolling. */
+  setScrollOffset(nodeId: number, scrollX: number, scrollY: number): void;
+  clearTree(): void;
+  setScreenMode(mode: ScreenMode, footerHeight?: number): void;
+  render(): void;
+  renderFull(): void;
+  private writeFrame;
+  clearScreen(): void;
+  write(text: string): void;
+  resize(width: number, height: number): void;
+  handleKey(sequence: string): string | null;
+  addKeyBinding(layer: string, id: string, keys: string, command: string, description?: string, priority?: number): boolean;
+  private flushExternalOutput;
+  interceptStdoutWrite: (chunk: string | Uint8Array) => boolean;
+  private enterAlternateScreen;
+  private exitAlternateScreen;
+}
+declare function createCliRenderer(options?: CliRendererOptions): Promise<CliRenderer>;
+//#endregion
+//#region src/renderable.d.ts
+interface WidgetContext {
+  buffer: CommandBufferConsumer;
+  onKey?: (handler: (key: KeyEvent$1) => boolean) => void;
+  offKey?: (handler: (key: KeyEvent$1) => boolean) => void;
+}
+interface WidgetLifecycle {
+  mount(ctx: WidgetContext): void;
+  unmount(): void;
+}
+interface ImperativeContext {
+  renderer: CliRenderer;
+  parentId: number;
+}
+declare abstract class Renderable<TOptions = Record<string, unknown>> {
+  readonly id: string;
+  protected ctx: WidgetContext | null;
+  protected opts: TOptions;
+  protected children: Renderable[];
+  protected _focused: boolean;
+  protected _visible: boolean;
+  protected _isDestroyed: boolean;
+  protected _nodeId: number | null;
+  constructor(options?: TOptions);
+  get options(): Readonly<TOptions>;
+  get visible(): boolean;
+  get focused(): boolean;
+  get isDestroyed(): boolean;
+  get nodeId(): number | null;
+  mount(ctx: WidgetContext): void;
+  unmount(): void;
+  update(options: Partial<TOptions>): void;
+  abstract renderCommands(id: string): Command[];
+  add(child: Renderable): void;
+  remove(child: Renderable): void;
+  handleKey?(key: KeyEvent$1): boolean;
+  handleMouse?(event: MouseEvent$1): boolean;
+  handleFocus?(): void;
+  handleBlur?(): void;
+  focus(): void;
+  blur(): void;
+  destroy(): void;
+  protected emitCommands(cmds: Command[]): void;
+  renderImperative(ctx: ImperativeContext): number;
+  protected getNodeKind(): string;
+  protected applyImperativeStyle(_renderer: CliRenderer, _nodeId: number): void;
+  protected applyImperativeLayout(_renderer: CliRenderer, _nodeId: number): void;
+  protected applyImperativeContent(_renderer: CliRenderer, _nodeId: number): void;
+  protected layoutCommands(id: string, layout: Record<string, unknown>): Command[];
+  protected styleCommands(id: string, style: Record<string, unknown>): Command[];
+}
+//#endregion
+//#region src/lib/keybinding.d.ts
+interface BindingInfo {
+  id: string;
+  keys: string;
+  command: string;
+  description: string | null;
+  enabled: boolean;
+  layer: string;
+}
+interface KeymapEvent {
+  phase: "sequence-start" | "sequence-advance" | "sequence-clear" | "binding-execute" | "binding-reject";
+  key: string;
+  command: string | null;
+  keys: string[];
+}
+type CommandHandler = (ctx: CommandContext) => boolean | undefined;
+interface CommandContext {
+  keymap: Keymap;
+  event: KeymapEvent;
+  command: string;
+  payload?: Record<string, unknown>;
+  data: Record<string, unknown>;
+}
+interface CommandEntry {
+  name: string;
+  handler: CommandHandler;
+}
+type InterceptHandler = (ctx: InterceptContext) => boolean | undefined;
+interface InterceptContext {
+  key: string;
+  event: KeymapEvent;
+  preventDefault(): void;
+  stopPropagation(): void;
+  defaultPrevented: boolean;
+  propagationStopped: boolean;
+}
+type KeyListener = (event: KeymapEvent) => void;
+type KeymapOptions = {
+  chordTimeoutMs?: number;
+  mode?: string;
+};
+interface ActiveKeyInfo {
+  keys: string;
+  command: string;
+  description: string | null;
+  layer: string;
+  id: string;
+}
+declare class Keymap {
+  private native;
+  private commands;
+  private keyIntercepts;
+  private keyAfterIntercepts;
+  private listeners;
+  private runtimeData;
+  private bindings;
+  private layers;
+  private currentModeValue;
+  private chordTimeoutMsValue;
+  private pendingKeysValue;
+  private commandHistoryValue;
+  constructor(native?: NapiKeymap, options?: KeymapOptions);
+  addBinding(layer: string, id: string, keys: string, command: string, description?: string, priority?: number): boolean;
+  addSimpleBinding(keys: string, command: string, description?: string): boolean;
+  removeLayer(name: string): boolean;
+  setChordTimeout(ms: number): void;
+  chordTimeout(): number;
+  registerCommand(name: string, handler: CommandHandler): void;
+  unregisterCommand(name: string): boolean;
+  getCommand(name: string): CommandHandler | undefined;
+  hasCommand(name: string): boolean;
+  getCommands(): CommandEntry[];
+  intercept(name: "key" | "key:after", handler: InterceptHandler, priority?: number): () => void;
+  on(event: "state" | "pendingSequence" | "dispatch", listener: KeyListener): () => void;
+  off(event: "state" | "pendingSequence" | "dispatch", listener: KeyListener): void;
+  private emit;
+  handleKey(keyStr: string): string | null;
+  setMode(mode: string): void;
+  currentMode(): string | null;
+  clearMode(): void;
+  hasPending(): boolean;
+  clearPending(): void;
+  pendingKeys(): string[];
+  activeBindings(): BindingInfo[];
+  allBindings(): BindingInfo[];
+  commandHistory(): string[];
+  clearHistory(): void;
+  setData(key: string, value: unknown): void;
+  getData(key: string): unknown;
+  getCommandBindings(command: string): BindingInfo[];
+  getBindingsForCommands(commands: string[]): Map<string, BindingInfo[]>;
+  runCommand(command: string, payload?: Record<string, unknown>): boolean;
+  parseKey(keyStr: string): string | null;
+  parseSequence(keyStr: string): string[];
+  formatKeySequence(keys: string[]): string;
+  stringifyKeySequence(keys: string[], options?: {
+    preferDisplay?: boolean;
+    separator?: string;
+  }): string;
+  formatBinding(binding: BindingInfo): string;
+  formatCommandBindings(entries: Array<{
+    command: string;
+    bindings: BindingInfo[];
+  }>): string[];
+  getNative(): NapiKeymap;
+}
+//#endregion
+//#region src/lib/parseKeypressKitty.d.ts
+declare const kittyNamedSingleStrokeKeys: string[];
+/**
+ * Parse Kitty keyboard protocol sequence.
+ *
+ * Format: CSI unicode-key-code:alternate-key-codes ; modifiers:event-type ; text-as-codepoints u
+ *
+ * Examples:
+ *   ESC[99;1:1u = 'c' key press
+ *   ESC[99:99:99;2:1u = 'c' key press with base layout codepoint 99
+ *   ESC[1;1:1A = up arrow press (special key format)
+ */
+declare function parseKittyKeyboard(sequence: string): ParsedKey | null;
+//#endregion
+//#region src/lib/renderableKeyBindings.d.ts
+/**
+ * Renderable-level keybinding utilities.
+ *
+ * Generic, framework-agnostic keybinding maps for renderables (Select,
+ * TabSelect, etc.). The pattern is:
+ *
+ *   1. Define a set of default {@link KeyBinding}s mapping key presses to
+ *      renderable actions.
+ *   2. Merge user-provided bindings over the defaults (user wins on key
+ *      collisions) with {@link mergeKeyBindings}.
+ *   3. Build a lookup map with {@link buildKeyBindingsMap}, optionally
+ *      applying {@link KeyAliasMap} aliases (e.g. `enter` -> `return`).
+ *   4. Resolve a parsed key event to an action with
+ *      {@link getKeyBindingAction}.
+ *
+ * `baseCode` (Kitty keyboard protocol) lets a binding match the physical
+ * base-layout key even when the event arrives with an alternate-layout
+ * character.
+ */
+interface KeyBindingLike {
+  name: string;
+  ctrl?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+  super?: boolean;
+}
+interface KeyBinding<Action extends string = string> extends KeyBindingLike {
+  action: Action;
+}
+/** The subset of {@link KeyEvent} used to resolve a keybinding. */
+type KeyBindingLookup = {
+  name: string;
+  ctrl?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+  super?: boolean;
+  /** Kitty base-layout codepoint (e.g. 99 == "c"). */
+  baseCode?: number;
+};
+/** Maps a normalized key name to another (e.g. `enter` -> `return`). */
+type KeyAliasMap = Record<string, string>;
+declare const defaultKeyAliases: KeyAliasMap;
+declare function mergeKeyAliases(defaults: KeyAliasMap, custom: KeyAliasMap): KeyAliasMap;
+/**
+ * Merge custom bindings over defaults. When a custom binding targets the same
+ * key/modifier combination as a default, the custom binding wins.
+ */
+declare function mergeKeyBindings<Action extends string>(defaults: KeyBinding<Action>[], custom: KeyBinding<Action>[]): KeyBinding<Action>[];
+declare function getKeyBindingKey(binding: KeyBindingLike): string;
+/**
+ * Return every lookup key that can represent this event. We try the parsed
+ * name first, then the base-layout key when Kitty provides one. That keeps
+ * direct character bindings precise and still lets physical-layout shortcuts
+ * resolve.
+ */
+declare function getKeyBindingKeys(binding: KeyBindingLookup): string[];
+declare function getKeyBindingAction<Action extends string>(map: Map<string, Action>, binding: KeyBindingLookup): Action | undefined;
+declare function matchesKeyBinding(binding: KeyBindingLookup, match: KeyBindingLike): boolean;
+declare function buildKeyBindingsMap<Action extends string>(bindings: KeyBinding<Action>[], aliasMap?: KeyAliasMap): Map<string, Action>;
+/**
+ * Converts a key binding to a human-readable string representation.
+ * @example keyBindingToString({ name: "c", ctrl: true }) // "ctrl+c"
+ */
+declare function keyBindingToString<Action extends string>(binding: KeyBinding<Action>): string;
+//#endregion
+//#region src/lib/stdinParser.d.ts
+type StdinResponseProtocol = "csi" | "cpr" | "osc" | "dcs" | "apc" | "unknown";
+type PasteMetadata = Record<string, never>;
+type StdinEvent = {
+  type: "key";
+  raw: string;
+  key: ParsedKey;
+} | {
+  type: "mouse";
+  raw: string;
+  encoding: "sgr" | "x10";
+  event: RawMouseEvent;
+} | {
+  type: "paste";
+  bytes: Uint8Array;
+  metadata?: PasteMetadata;
+} | {
+  type: "response";
+  protocol: StdinResponseProtocol;
+  sequence: string;
+};
+interface StdinParserProtocolContext {
+  kittyKeyboardEnabled: boolean;
+  privateCapabilityRepliesActive: boolean;
+  pixelResolutionQueryActive: boolean;
+  explicitWidthCprActive: boolean;
+  startupCursorCprActive: boolean;
+}
+interface StdinParserOptions {
+  timeoutMs?: number;
+  maxPendingBytes?: number;
+  armTimeouts?: boolean;
+  onTimeoutFlush?: () => void;
+  useKittyKeyboard?: boolean;
+  protocolContext?: Partial<StdinParserProtocolContext>;
+  clock?: Clock;
+}
+declare class StdinParser {
+  private readonly pending;
+  private readonly events;
+  private readonly timeoutMs;
+  private readonly maxPendingBytes;
+  private readonly armTimeouts;
+  private readonly onTimeoutFlush;
+  private readonly useKittyKeyboard;
+  private readonly mouseParser;
+  private readonly clock;
+  private protocolContext;
+  private timeoutId;
+  private destroyed;
+  private pendingSinceMs;
+  private forceFlush;
+  private justFlushedEsc;
+  private state;
+  private cursor;
+  private unitStart;
+  private paste;
+  constructor(options?: StdinParserOptions);
+  get bufferCapacity(): number;
+  updateProtocolContext(patch: Partial<StdinParserProtocolContext>): void;
+  private getAbortableStartupCursorCprState;
+  abortPendingStartupCursorCpr(): void;
+  push(data: Uint8Array): void;
+  read(): StdinEvent | null;
+  drain(onEvent: (event: StdinEvent) => void): void;
+  flushTimeout(nowMsValue?: number): void;
+  private tryForceFlush;
+  reset(): void;
+  resetMouseState(): void;
+  destroy(): void;
+  private ensureAlive;
+  private scanPending;
+  private consumePasteBytes;
+  private takePendingBytes;
+  private flushPendingOverflow;
+  private emitLegacyHighByte;
+  private emitKeyOrResponse;
+  private emitOpaqueResponse;
+  private emitMouse;
+  private consumePrefix;
+  private markPending;
+  private resetState;
+  private reconcileDeferredStateWithProtocolContext;
+  private reconcileTimeoutState;
+  private clearTimeout;
+}
+//#endregion
+//#region src/lib/styledText.d.ts
+/** TextAttributes bitmask constants. */
+declare const TextAttributes: {
+  readonly NONE: 0;
+  readonly BOLD: 1;
+  readonly DIM: 2;
+  readonly ITALIC: 4;
+  readonly UNDERLINE: 8;
+  readonly BLINK: 16;
+  readonly INVERSE: 32;
+  readonly HIDDEN: 64;
+  readonly STRIKETHROUGH: 128;
+};
+/** A single styled text chunk. */
+interface TextChunk {
+  __isChunk: true;
+  text: string;
+  fg?: RGBA;
+  bg?: RGBA;
+  attributes?: number;
+  link?: {
+    url: string;
+  };
+}
+declare const BrandedStyledText: unique symbol;
+/** A rich text object made of styled chunks. */
+declare class StyledText {
+  [BrandedStyledText]: boolean;
+  chunks: TextChunk[];
+  constructor(chunks: TextChunk[]);
+}
+/** Type guard for StyledText. */
+declare function isStyledText(obj: unknown): obj is StyledText;
+/** Convert a plain string to a StyledText with one chunk. */
+declare function stringToStyledText(content: string): StyledText;
+/** A value that can be used in styled text. */
+type StylableInput = string | number | boolean | TextChunk;
+/**
+ * Template literal tag for building styled text.
+ *
+ * @example
+ * t`${bold(red("Error:"))} Connection failed`
+ */
+declare function t(strings: TemplateStringsArray, ...values: StylableInput[]): StyledText;
+declare const bold: (input: StylableInput) => TextChunk;
+declare const italic: (input: StylableInput) => TextChunk;
+declare const underline: (input: StylableInput) => TextChunk;
+declare const strikethrough: (input: StylableInput) => TextChunk;
+declare const dim: (input: StylableInput) => TextChunk;
+declare const reverse: (input: StylableInput) => TextChunk;
+declare const blink: (input: StylableInput) => TextChunk;
+declare const black: (input: StylableInput) => TextChunk;
+declare const red: (input: StylableInput) => TextChunk;
+declare const green: (input: StylableInput) => TextChunk;
+declare const yellow: (input: StylableInput) => TextChunk;
+declare const blue: (input: StylableInput) => TextChunk;
+declare const magenta: (input: StylableInput) => TextChunk;
+declare const cyan: (input: StylableInput) => TextChunk;
+declare const white: (input: StylableInput) => TextChunk;
+declare const brightBlack: (input: StylableInput) => TextChunk;
+declare const brightRed: (input: StylableInput) => TextChunk;
+declare const brightGreen: (input: StylableInput) => TextChunk;
+declare const brightYellow: (input: StylableInput) => TextChunk;
+declare const brightBlue: (input: StylableInput) => TextChunk;
+declare const brightMagenta: (input: StylableInput) => TextChunk;
+declare const brightCyan: (input: StylableInput) => TextChunk;
+declare const brightWhite: (input: StylableInput) => TextChunk;
+declare const bgBlack: (input: StylableInput) => TextChunk;
+declare const bgRed: (input: StylableInput) => TextChunk;
+declare const bgGreen: (input: StylableInput) => TextChunk;
+declare const bgYellow: (input: StylableInput) => TextChunk;
+declare const bgBlue: (input: StylableInput) => TextChunk;
+declare const bgMagenta: (input: StylableInput) => TextChunk;
+declare const bgCyan: (input: StylableInput) => TextChunk;
+declare const bgWhite: (input: StylableInput) => TextChunk;
+/** Set foreground color. `fg("#ff0000")("text")` */
+declare const fg: (color: ColorInput) => (input: StylableInput) => TextChunk;
+/** Set background color. `bg("#ff0000")("text")` */
+declare const bg: (color: ColorInput) => (input: StylableInput) => TextChunk;
+/** Create a hyperlink. `link("https://example.com")("click here")` */
+declare const link: (url: string) => (input: StylableInput) => TextChunk;
+/** Convert a StyledText or string to an ANSI escape-code string. */
+declare function styledTextToAnsi(styledText: StyledText | string): string;
+/** Get the visible (non-ANSI) character width of a string. */
+declare function visibleWidth(str: string): number;
+//#endregion
+//#region src/lib/singleton.d.ts
+/**
+ * Ensures a value is initialized once per process,
+ * persists across hot reloads, and is type-safe.
+ */
+declare function singleton<T>(key: string, factory: () => T): T;
+declare function getSingleton<T>(key: string): T | undefined;
+declare function destroySingleton(key: string): void;
+declare function hasSingleton(key: string): boolean;
+//#endregion
+//#region src/lib/env.d.ts
+/**
+ * Environment variable configuration for BetterTUI.
+ */
+interface EnvVarConfig {
+  name: string;
+  description: string;
+  default?: string | boolean | number;
+  type?: "string" | "boolean" | "number";
+}
+/**
+ * Register an environment variable with type coercion and documentation metadata.
+ */
+declare function registerEnvVar(config: EnvVarConfig): void;
+/** Get a registered env var config by name. */
+declare function getEnvVarConfig(name: string): EnvVarConfig | undefined;
+/** Get all registered env var configs. */
+declare function getAllEnvVarConfigs(): EnvVarConfig[];
+declare function clearEnvCache(): void;
+declare function generateEnvMarkdown(): string;
+declare function generateEnvColored(): string;
+declare const env: Record<string, any>;
+//#endregion
+//#region src/lib/timeline.d.ts
+/**
+ * Timeline animation system.
+ * Provides a GSAP-like API for building animation sequences.
+ */
+interface TweenConfig {
+  [key: string]: unknown;
+}
+interface TimelineOptions {
+  looping?: boolean;
+  speed?: number;
+  onComplete?: () => void;
+}
+/**
+ * A simple animation timeline.
+ * Tracks progress from 0 to 1 over a duration, with looping support.
+ */
+declare class Timeline {
+  private readonly _duration;
+  private readonly _looping;
+  private _position;
+  private _isPlaying;
+  private _speed;
+  private _onComplete;
+  private _tweens;
+  private _children;
+  constructor(duration?: number, options?: TimelineOptions);
+  get position(): number;
+  set position(v: number);
+  get isPlaying(): boolean;
+  get duration(): number;
+  get speed(): number;
+  set speed(v: number);
+  get looping(): boolean;
+  /** Start or resume playback. */
+  play(): void;
+  /** Pause playback. */
+  pause(): void;
+  /** Reset to beginning and stop. */
+  stop(): void;
+  /** Reset to beginning and play. */
+  restart(): void;
+  /** Toggle play/pause. */
+  toggle(): void;
+  /**
+   * Add a tween to the timeline (GSAP-like API).
+   * @param targets - The target objects to animate
+   * @param props - The properties to tween and their target values
+   * @param offset - Time offset in seconds (or "+=N" for relative)
+   */
+  add(targets: unknown, props: TweenConfig, offset?: number): this;
+  /** Add a child timeline. */
+  addChild(child: Timeline): this;
+  /**
+   * Update the timeline by deltaTime milliseconds.
+   * Returns whether the timeline is still active.
+   */
+  update(deltaTimeMs: number): boolean;
+  /**
+   * Get the current value of a property at the current position.
+   * For simple linear interpolation between 0 and target value.
+   */
+  getValue<T = number>(prop: string): T;
+  /** Seek to a specific position (0-1). */
+  seek(position: number): void;
+  /** Get the time in seconds at the current position. */
+  get currentTime(): number;
+}
+/** Create a new Timeline instance. */
+declare function createTimeline$1(duration?: number, options?: TimelineOptions): Timeline;
+//#endregion
+//#region src/renderables/Input.d.ts
+interface InputOptions extends BoxOptions {
+  value?: string;
+  placeholder?: string;
+  placeholderColor?: ColorInput;
+  textColor?: ColorInput;
+  focusedTextColor?: ColorInput;
+  cursorColor?: ColorInput;
+  backgroundColor?: ColorInput;
+  focusedBackgroundColor?: ColorInput;
+  maxLength?: number;
+  minLength?: number;
+  showCursor?: boolean;
+  password?: boolean;
+}
+type InputRenderableOptions = InputOptions;
+declare class Input extends Box {
+  private _value;
+  private _placeholder;
+  private _placeholderColor;
+  private _textColor;
+  private _focusedTextColor;
+  private _cursorColor;
+  private _focusedBackgroundColor;
+  private _maxLength;
+  private _minLength;
+  private _showCursor;
+  private _password;
+  private _cursorPos;
+  private _lastCommittedValue;
+  private _textNodeId;
+  private readonly _keyHandler;
+  constructor(renderer: CliRenderer, options?: InputOptions);
+  get value(): string;
+  set value(v: string);
+  get plainText(): string;
+  get cursorOffset(): number;
+  set cursorOffset(pos: number);
+  set textColor(color: ColorInput);
+  set focusedTextColor(color: ColorInput);
+  set placeholder(value: string);
+  set placeholderColor(color: ColorInput);
+  set cursorColor(color: ColorInput);
+  set showCursor(value: boolean);
+  focus(): void;
+  blur(): void;
+  private _handleKey;
+  private _submit;
+  private _render;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/Select.d.ts
+interface SelectOption {
+  name: string;
+  description: string;
+  value?: unknown;
+}
+/** Selectable actions resolved from key events. */
+type SelectAction = "move-up" | "move-down" | "move-up-fast" | "move-down-fast" | "move-up-page" | "move-down-page" | "move-to-start" | "move-to-end" | "select-current";
+type SelectKeyBinding = KeyBinding<SelectAction>;
+interface SelectOptions extends BoxOptions {
+  options?: SelectOption[];
+  selectedIndex?: number;
+  backgroundColor?: ColorInput;
+  textColor?: ColorInput;
+  focusedBackgroundColor?: ColorInput;
+  focusedTextColor?: ColorInput;
+  selectedBackgroundColor?: ColorInput;
+  selectedTextColor?: ColorInput;
+  descriptionColor?: ColorInput;
+  selectedDescriptionColor?: ColorInput;
+  showScrollIndicator?: boolean;
+  showDescription?: boolean;
+  showSelectionIndicator?: boolean;
+  selectionIndicator?: string;
+  unselectedIndicator?: string;
+  wrapSelection?: boolean;
+  fastScrollStep?: number;
+  itemSpacing?: number;
+  keyBindings?: SelectKeyBinding[];
+  keyAliasMap?: KeyAliasMap;
+}
+type SelectRenderableOptions = SelectOptions;
+declare class Select extends Box {
+  private _selectOptions;
+  private _selectedIndex;
+  private _scrollOffset;
+  private _textColor;
+  private _focusedTextColor;
+  private _selectedBgColor;
+  private _selectedTextColor;
+  private _descriptionColor;
+  private _selectedDescriptionColor;
+  private _focusedBgColor;
+  private _showScrollIndicator;
+  private _showDescription;
+  private _showSelectionIndicator;
+  private _selectionIndicator;
+  private _unselectedIndicator;
+  private _wrapSelection;
+  private _fastScrollStep;
+  private _itemSpacing;
+  private _keyBindings;
+  private _keyAliasMap;
+  private _keyBindingsMap;
+  private _contentNodeId;
+  private readonly _keyHandler;
+  protected _defaultOptions: {
+    textColor: string;
+    focusedTextColor: string;
+    selectedBackgroundColor: string;
+    selectedTextColor: string;
+    descriptionColor: string;
+    selectedDescriptionColor: string;
+    showScrollIndicator: false;
+    showDescription: true;
+    showSelectionIndicator: true;
+    selectionIndicator: string;
+    unselectedIndicator: string;
+    wrapSelection: false;
+    fastScrollStep: number;
+    itemSpacing: number;
+  };
+  constructor(renderer: CliRenderer, options?: SelectOptions);
+  get options(): SelectOption[];
+  set options(opts: SelectOption[]);
+  get selectedIndex(): number;
+  set selectedIndex(idx: number);
+  get showScrollIndicator(): boolean;
+  set showScrollIndicator(v: boolean);
+  get showDescription(): boolean;
+  set showDescription(v: boolean);
+  get wrapSelection(): boolean;
+  set wrapSelection(v: boolean);
+  get showSelectionIndicator(): boolean;
+  set showSelectionIndicator(v: boolean);
+  get selectionIndicator(): string;
+  set selectionIndicator(v: string);
+  get unselectedIndicator(): string;
+  set unselectedIndicator(v: string);
+  get fastScrollStep(): number;
+  set fastScrollStep(v: number);
+  get focusedBackgroundColor(): RGBA | null;
+  set focusedBackgroundColor(color: ColorInput);
+  set selectedBackgroundColor(color: ColorInput);
+  set textColor(color: ColorInput);
+  set selectedTextColor(color: ColorInput);
+  set focusedTextColor(color: ColorInput);
+  set descriptionColor(color: ColorInput);
+  set selectedDescriptionColor(color: ColorInput);
+  set keyBindings(bindings: SelectKeyBinding[]);
+  set keyAliasMap(aliases: KeyAliasMap);
+  getSelectedOption(): SelectOption | undefined;
+  getSelectedIndex(): number;
+  /** Programmatically move the selection; emits SELECTION_CHANGED on change. */
+  setSelectedIndex(index: number): void;
+  selectCurrent(): void;
+  moveUp(steps?: number): void;
+  moveDown(steps?: number): void;
+  /**
+   * Resolve a key event against the keybinding map and dispatch the action.
+   * Returns `true` when the key was consumed.
+   */
+  handleKeyPress(key: KeyEvent): boolean;
+  focus(): void;
+  blur(): void;
+  private _resolveInitialIndex;
+  private _clampIndex;
+  private _wrapIndex;
+  private _isNonSelectable;
+  private _skipNonSelectable;
+  /** Number of rendered rows a single option occupies. */
+  private _linesPerItem;
+  private _updateScroll;
+  private _getViewHeight;
+  private _render;
+  private _ansi;
+  private static displayWidth;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/TextNode.d.ts
+interface TextNodeOptions {
+  id?: string;
+  fg?: ColorInput;
+  bg?: ColorInput;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  dim?: boolean;
+  strikethrough?: boolean;
+  blink?: boolean;
+}
+interface StyleAttrs {
+  fg?: ColorInput;
+  bg?: ColorInput;
+  /** Pre-computed attribute bitmask (TextAttributes flags). */
+  attributes?: number;
+}
+/** A child can be either a string (leaf text) or a nested node. */
+type TextNodeChild = string | TextNode;
+/**
+ * TextNode — a lightweight styled-text composition node.
+ * Can be used standalone or nested in Text.
+ */
+declare class TextNode {
+  private static _counter;
+  readonly id: string;
+  _fg: RGBA | undefined;
+  _bg: RGBA | undefined;
+  _attributes: number;
+  isDirty: boolean;
+  parent: TextNode | null;
+  /**
+   * Children are heterogeneous: strings are leaf text, TextNodeRenderables are
+   * nested nodes. Stored as a union array.
+   *
+   * NOTE: Do NOT store leaf text in a separate field — always use children.
+   * This ensures `clear()` wipes everything and the `children` setter works.
+   */
+  protected _children: TextNodeChild[];
+  constructor(options?: TextNodeOptions);
+  /**
+   * Create a leaf node from a plain string with optional style.
+   * Signature: `TextNode.fromString(text, options?)`.
+   */
+  static fromString(text: string, style?: StyleAttrs): TextNode;
+  /**
+   * Create a container node from an array of child nodes with optional root style.
+   * Signature: `fromNodes(nodes: TextNode[], options?)`.
+   *
+   * Previous implementation used variadic rest params and no options,
+   * which broke call sites that pass `([a,b,c], { fg: "..." })`.
+   */
+  static fromNodes(nodes: TextNode[], options?: StyleAttrs): TextNode;
+  get fg(): RGBA | undefined;
+  set fg(color: ColorInput);
+  get bg(): RGBA | undefined;
+  set bg(color: ColorInput);
+  get attributes(): number;
+  set attributes(v: number);
+  /**
+   * Read-only view of this node's children (strings + sub-nodes).
+   * For mutation use the setter or `add`/`remove`/`clear`.
+   */
+  get children(): readonly TextNodeChild[];
+  /**
+   * Replace all children with a new array of strings and/or nodes.
+   * The `children` setter: detaches old node children, adopts
+   * new ones, and marks the node dirty so the owner Text resyncs.
+   *
+   * Usage (dynamic update pattern):
+   * ```ts
+   * counterNode.children = [`\n\nCounter: ${n}`];
+   * ```
+   */
+  set children(newChildren: TextNodeChild[]);
+  /**
+   * Append a string, TextNode, or StyledText as a child.
+   * Returns the index at which the child was inserted.
+   */
+  add(child: TextNodeChild | StyledText, index?: number): number;
+  remove(child: TextNode): void;
+  /**
+   * Insert `child` before `anchor`. Throws if `anchor` is provided but not
+   * found — strict contract (helps catch anchor mismatches).
+   */
+  insertBefore(child: TextNodeChild | StyledText, anchor?: TextNode): void;
+  /**
+   * Remove all children and mark the node dirty.
+   * Unlike the old implementation there is NO separate `_text` field to miss.
+   */
+  clear(): void;
+  getChildren(): readonly TextNodeChild[];
+  /**
+   * Walk this node and all descendants, accumulating {@link TextChunk}s with
+   * inherited style applied. Called by `Text.onLifecyclePass` to
+   * build the flat chunk array that goes to the engine.
+   */
+  gatherWithInheritedStyle(inherited: {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes?: number;
+    link?: {
+      url: string;
+    } | undefined;
+  }): TextChunk[];
+  /** Serialise this node tree to an ANSI-escaped string. */
+  toString(): string;
+  /** Walk up the parent chain and mark all ancestors dirty. */
+  private _bubbleDirty;
+}
+/**
+ * RootTextNode — the root text node for a Text.
+ * When any descendant calls `_bubbleDirty()` and the dirty flag reaches this
+ * root, the `onDirty` callback is invoked so the owning `Text` can
+ * schedule a re-sync to the engine on the next lifecycle pass.
+ */
+declare class RootTextNode extends TextNode {
+  private readonly _onDirty;
+  constructor(options?: TextNodeOptions, onDirty?: () => void);
+  /**
+   * Overrides the private `_bubbleDirty` propagation: when this root is
+   * reached, fire the `onDirty` callback instead of (or in addition to)
+   * walking further up (there is no parent above the root).
+   */
+  markDirtyFromChild(): void;
+}
+//#endregion
+//#region src/renderables/Text.d.ts
+interface TextOptions extends BoxOptions {
+  content?: StyledText | string;
+  /** Foreground (text) color. */
+  fg?: ColorInput;
+  /** Background color (alias for backgroundColor). */
+  bg?: ColorInput;
+  /** Text wrap mode. */
+  wrapMode?: "none" | "char" | "word";
+  /** Truncate long lines with ellipsis. */
+  truncate?: boolean;
+  /** Text alignment. */
+  textAlign?: "left" | "center" | "right";
+  margin?: number;
+  /** Enable text selection. */
+  selectable?: boolean;
+  /** Selection background color. */
+  selectionBg?: ColorInput;
+  /** Selection foreground color. */
+  selectionFg?: ColorInput;
+}
+declare class Text extends Box {
+  private _fg;
+  private _bg;
+  private _textNodeId;
+  private _wrapMode;
+  private _truncate;
+  /**
+   * The root of the TextNode tree. All structured text attached via `add()`
+   * lives here. The lifecycle pass reads `isDirty` and, when true, gathers
+   * chunks from this tree and pushes them to the engine.
+   */
+  readonly rootTextNode: RootTextNode;
+  /**
+   * Bound lifecycle pass function, registered with the renderer so it is
+   * invoked once per frame. Kept as an arrow function so `unregister` works
+   * correctly on cleanup.
+   */
+  private readonly _lifecyclePassFn;
+  constructor(renderer: CliRenderer, options?: TextOptions);
+  /**
+   * Attach a TextNode to the root text node.
+   *
+   * This is the canonical BetterTUI API (`demoText.add(containerNode)`).
+   *
+   * NOTE: Named `addNode` rather than `add` because `Text` extends
+   * `Box` whose `add(Box)` has a different signature.
+   */
+  addNode(node: TextNode, index?: number): void;
+  /**
+   * Convenience: remove a previously added TextNode from the root.
+   */
+  removeNode(node: TextNode): void;
+  /**
+   * `content` setter — accepts a plain string or StyledText.
+   * Replaces all children of the root text node with a single string child.
+   * Kept for backward-compatibility with code that does `text.content = "..."`.
+   */
+  get content(): string;
+  set content(value: StyledText | string | string[]);
+  /** Clear all text content (clears the root node tree). */
+  clear(): void;
+  get wrapMode(): "none" | "char" | "word";
+  set wrapMode(value: "none" | "char" | "word");
+  get truncate(): boolean;
+  set truncate(value: boolean);
+  get fg(): RGBA | null;
+  set fg(color: ColorInput);
+  set bg(color: ColorInput);
+  set textColor(color: ColorInput);
+  /**
+   * Called once per frame by the CliRenderer lifecycle loop.
+   * Checks whether the root text node is dirty; if so, re-gathers all chunks
+   * from the node tree and pushes the new ANSI string to the engine.
+   *
+   * This is the mechanism behind BetterTUI's "mutate a node → auto-update"
+   * pattern.
+   */
+  onLifecyclePass(): void;
+  destroy(): void;
+  /** Push the current node-tree content to the engine as an ANSI string. */
+  private _syncToEngine;
+  private _applyTextStyle;
+}
+//#endregion
+//#region src/renderables/Stubs.d.ts
+type ASCIIFontKind = "tiny" | "block" | "shade" | "slick" | string;
+interface ASCIIFontOptions extends BoxOptions {
+  text?: string;
+  font?: ASCIIFontKind;
+  color?: ColorInput | ColorInput[];
+  backgroundColor?: ColorInput;
+  selectionBg?: ColorInput;
+  selectionFg?: ColorInput;
+}
+declare class ASCIIFont extends Box {
+  private _text;
+  private _font;
+  private _color;
+  private _contentNodeId;
+  private static readonly TINY_CHARS;
+  constructor(renderer: CliRenderer, options?: ASCIIFontOptions);
+  get text(): string;
+  set text(v: string);
+  get font(): ASCIIFontKind;
+  set font(v: ASCIIFontKind);
+  get color(): RGBA[];
+  set color(v: RGBA | RGBA[]);
+  getEstimatedHeight(): number;
+  private _render;
+  destroy(): void;
+  /** Returns whether this renderable has an active selection. */
+  hasSelection(): boolean;
+}
+interface FrameBufferOptions extends BoxOptions {
+  drawFn?: (buffer: FrameBufferLike, deltaTime: number, renderable: FrameBuffer) => void;
+}
+interface FrameBufferLike {
+  width: number;
+  height: number;
+  setCell(x: number, y: number, char: string, fg?: RGBA, bg?: RGBA): void;
+  drawText(text: string, x: number, y: number, fg?: RGBA, bg?: RGBA): void;
+  fillRect(x: number, y: number, w: number, h: number, color: RGBA): void;
+  clear(color?: RGBA): void;
+}
+declare class FrameBuffer extends Box {
+  private _drawFn;
+  private _buffer;
+  private _contentNodeId;
+  get frameBuffer(): FrameBufferLike;
+  constructor(renderer: CliRenderer, options?: FrameBufferOptions);
+  draw(deltaTime: number): void;
+  private _flush;
+  destroy(): void;
+}
+interface CodeOptions extends TextOptions {
+  language?: string;
+  filetype?: string;
+  showLineNumbers?: boolean;
+  code?: string;
+  selectionBg?: ColorInput;
+  selectionFg?: ColorInput;
+  syntaxStyle?: unknown;
+}
+declare class Code extends Text {
+  private _language;
+  private _showLineNumbers;
+  private _code;
+  filetype: string;
+  selectionBg: ColorInput;
+  selectionFg: ColorInput;
+  syntaxStyle: unknown;
+  virtualLineCount: number;
+  constructor(renderer: CliRenderer, options?: CodeOptions);
+  get code(): string;
+  set code(v: string);
+  get showLineNumbers(): boolean;
+  set showLineNumbers(v: boolean);
+  set language(v: string);
+  conceal(_ranges: unknown): void;
+  private _renderCode;
+}
+interface DiffOptions extends TextOptions {
+  oldText?: string;
+  newText?: string;
+  mode?: "unified" | "split";
+}
+declare class Diff extends Text {
+  constructor(renderer: CliRenderer, options?: DiffOptions);
+  setDiff(oldText: string, newText: string): void;
+  private _setDiff;
+}
+interface MarkdownOptions extends TextOptions {
+  content?: string | StyledText;
+}
+declare class Markdown extends Text {
+  constructor(renderer: CliRenderer, options?: MarkdownOptions);
+  set markdown(text: string);
+}
+interface TableColumn {
+  header: string;
+  key?: string;
+  width?: number;
+  align?: "left" | "center" | "right";
+}
+type TextTableColumnWidthMode = "content" | "full";
+type TextTableColumnFitter = "proportional" | "balanced";
+type TextTableContent = Array<Array<TextChunk[] | Array<TextChunk>>>;
+interface TextTableOptions extends BoxOptions {
+  columns?: TableColumn[];
+  rows?: Record<string, unknown>[][];
+  data?: string[][];
+  showBorder?: boolean;
+  headerColor?: ColorInput;
+  rowColor?: ColorInput;
+  alternateRowColor?: ColorInput;
+  wrapMode?: "none" | "word" | "char";
+  columnWidthMode?: TextTableColumnWidthMode;
+  columnFitter?: TextTableColumnFitter;
+  cellPadding?: number;
+  border?: boolean;
+  outerBorder?: boolean;
+  showBorders?: boolean;
+  borderStyle?: BorderStyleKind;
+  borderColor?: ColorInput;
+  fg?: ColorInput;
+  bg?: ColorInput;
+  content?: TextTableContent;
+}
+declare class TextTable extends Box {
+  private _columns;
+  private _data;
+  private _contentNodeId;
+  private _headerColor;
+  private _rowColor;
+  private _wrapMode;
+  private _columnWidthMode;
+  private _columnFitter;
+  private _cellPadding;
+  private _outerBorder;
+  private _showBorders;
+  private _content;
+  constructor(renderer: CliRenderer, options?: TextTableOptions);
+  get wrapMode(): "none" | "word" | "char";
+  set wrapMode(v: "none" | "word" | "char");
+  get columnWidthMode(): TextTableColumnWidthMode;
+  set columnWidthMode(v: TextTableColumnWidthMode);
+  get columnFitter(): TextTableColumnFitter;
+  set columnFitter(v: TextTableColumnFitter);
+  get cellPadding(): number;
+  set cellPadding(v: number);
+  get outerBorder(): boolean;
+  set outerBorder(v: boolean);
+  get showBorders(): boolean;
+  set showBorders(v: boolean);
+  get content(): TextTableContent | null;
+  set content(v: TextTableContent | null);
+  setData(columns: TableColumn[], data: string[][]): void;
+  addRow(row: string[]): void;
+  private _render;
+  destroy(): void;
+}
+interface LineNumberOptions extends BoxOptions {
+  lineCount?: number;
+  startLine?: number;
+  color?: ColorInput;
+  highlightColor?: ColorInput;
+  highlightLine?: number;
+  target?: unknown;
+}
+declare class LineNumber extends Box {
+  private _lineCount;
+  private _startLine;
+  private _color;
+  private _highlightColor;
+  private _highlightLine;
+  private _contentNodeId;
+  fg: ColorInput;
+  bg: ColorInput;
+  constructor(renderer: CliRenderer, options?: LineNumberOptions);
+  get lineCount(): number;
+  set lineCount(v: number);
+  get showLineNumbers(): boolean;
+  set highlightLine(v: number);
+  setLineColor(_line: number, _color: ColorInput): void;
+  clearAllLineColors(): void;
+  setLineSign(_line: number, _sign: string, _color?: ColorInput): void;
+  clearLineSign(_line: number): void;
+  getLineSigns(_line: number): string[];
+  private _render;
+  destroy(): void;
+}
+interface TimeToFirstDrawOptions extends TextOptions {
+  fg?: ColorInput;
+  color?: RGBA;
+}
+declare class TimeToFirstDraw extends Box {
+  private _fg;
+  private _color;
+  private _contentNodeId;
+  private _startTime;
+  constructor(renderer: CliRenderer, options?: TimeToFirstDrawOptions);
+  get fg(): RGBA;
+  set fg(color: ColorInput);
+  get color(): RGBA;
+  set color(v: RGBA);
+  private _render;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/TabSelect.d.ts
+interface TabOption {
+  name: string;
+  description?: string;
+  value?: unknown;
+}
+interface TabSelectOptions extends BoxOptions {
+  options?: TabOption[];
+  selectedIndex?: number;
+  /** Fixed width for each tab in characters. Set to 0 for auto-width based on content. */
+  tabWidth?: number;
+  /** Minimum width for auto-sized tabs. Ignored when tabWidth > 0. */
+  minTabWidth?: number;
+  /** Padding added to each side of tab text in auto mode. Default: 2. */
+  tabPadding?: number;
+  /** Gap between tabs in characters. Default: 1. */
+  tabGap?: number;
+  showDescription?: boolean;
+  showUnderline?: boolean;
+  showScrollArrows?: boolean;
+  scrollArrowLeft?: string;
+  scrollArrowRight?: string;
+  wrapSelection?: boolean;
+  backgroundColor?: ColorInput;
+  textColor?: ColorInput;
+  selectedTextColor?: ColorInput;
+  selectedBackgroundColor?: ColorInput;
+  activeUnderlineColor?: ColorInput;
+  inactiveUnderlineColor?: ColorInput;
+  descriptionColor?: ColorInput;
+}
+type TabSelectRenderableOptions = TabSelectOptions;
+declare class TabSelect extends Box {
+  private _tabOptions;
+  private _selectedIndex;
+  private _tabWidth;
+  private _minTabWidth;
+  private _tabPadding;
+  private _tabGap;
+  private _showDescription;
+  private _showUnderline;
+  private _showScrollArrows;
+  private _scrollArrowLeft;
+  private _scrollArrowRight;
+  private _wrapSelection;
+  private _textColor;
+  private _selectedTextColor;
+  private _selectedBgColor;
+  private _activeUnderlineColor;
+  private _inactiveUnderlineColor;
+  private _descriptionColor;
+  private _contentNodeId;
+  private readonly _keyHandler;
+  constructor(renderer: CliRenderer, options?: TabSelectOptions);
+  get options(): TabOption[];
+  set options(opts: TabOption[]);
+  get selectedIndex(): number;
+  set selectedIndex(idx: number);
+  get showDescription(): boolean;
+  set showDescription(v: boolean);
+  get showUnderline(): boolean;
+  set showUnderline(v: boolean);
+  get showScrollArrows(): boolean;
+  set showScrollArrows(v: boolean);
+  get scrollArrowLeft(): string;
+  set scrollArrowLeft(v: string);
+  get scrollArrowRight(): string;
+  set scrollArrowRight(v: string);
+  get wrapSelection(): boolean;
+  set wrapSelection(v: boolean);
+  getSelectedOption(): TabOption | undefined;
+  getSelectedIndex(): number;
+  selectCurrent(): void;
+  moveLeft(steps?: number): void;
+  moveRight(steps?: number): void;
+  focus(): void;
+  blur(): void;
+  private _handleKey;
+  private _render;
+  destroy(): void;
+}
+//#endregion
+//#region src/lib/vnode.d.ts
+/** A VNode (virtual node) — a lazy description of a renderable. */
+interface VNode {
+  _type: string | (new (renderer: CliRenderer, options: Record<string, unknown>) => Box);
+  _props: Record<string, unknown>;
+  _children: VNode[];
+}
+/**
+ * Create a VNode.
+ */
+declare function h(type: string | (new (renderer: CliRenderer, options: Record<string, unknown>) => Box), props?: Record<string, unknown> | null, ...children: (VNode | string | null | undefined)[]): VNode;
+/**
+ * Instantiate a VNode tree into real renderables.
+ */
+declare function instantiate(ctx: CliRenderer, vnode: VNode): Box;
+/**
+ * Redirect add/remove/focus calls to a named child renderable.
+ */
+declare function delegate(targets: string | string[], vnode: VNode): VNode;
+/** Maybe create a renderable from a VNode or return existing renderable. */
+declare function maybeMakeRenderable(ctx: CliRenderer, input: VNode | Box): Box;
+declare function BoxVNode(props?: BoxOptions, ...children: VNode[]): VNode;
+declare function TextVNode(props?: TextOptions, ...children: (VNode | string)[]): VNode;
+declare function InputVNode(props?: InputOptions, ...children: VNode[]): VNode;
+declare function SelectVNode(props?: SelectOptions, ...children: VNode[]): VNode;
+declare function TabSelectVNode(props?: TabSelectOptions, ...children: VNode[]): VNode;
+declare function CodeVNode(props?: CodeOptions, ...children: VNode[]): VNode;
+declare function GenericVNode(props?: BoxOptions & {
+  render?: (buffer: FrameBufferLike, dt: number, r: Box) => void;
+}, ...children: VNode[]): VNode;
+declare function ScrollBox$1(props?: BoxOptions, ...children: VNode[]): VNode;
+declare function ASCIIFont$1(props?: ASCIIFontOptions, ...children: VNode[]): VNode;
+declare const vstyles: {
+  bold: (text: string) => VNode;
+  italic: (text: string) => VNode;
+  underline: (text: string) => VNode;
+  dim: (text: string) => VNode;
+  color: (color: string, ...children: (string | VNode)[]) => VNode;
+  bgColor: (color: string, ...children: (string | VNode)[]) => VNode;
+  fg: (color: string) => (text: string) => VNode;
+  bg: (color: string) => (text: string) => VNode;
+  styled: (attrs: Record<string, unknown>, text: string) => VNode;
+  boldItalic: (text: string) => VNode;
+  boldUnderline: (text: string) => VNode;
+};
+//#endregion
+//#region src/platform/layoutSerializer.d.ts
+declare function layoutToEngineJson(layout: LayoutConstraints$1): Record<string, unknown>;
+//#endregion
+//#region src/testing/mockKeys.d.ts
+declare const KeyCodes: {
+  readonly RETURN: "\r";
+  readonly LINEFEED: "\n";
+  readonly TAB: "\t";
+  readonly BACKSPACE: "";
+  readonly DELETE: "[3~";
+  readonly HOME: "";
+  readonly END: "";
+  readonly ESCAPE: "";
+  readonly ARROW_UP: "";
+  readonly ARROW_DOWN: "";
+  readonly ARROW_RIGHT: "";
+  readonly ARROW_LEFT: "";
+  readonly F1: "OP";
+  readonly F2: "OQ";
+  readonly F3: "OR";
+  readonly F4: "OS";
+  readonly F5: "[15~";
+  readonly F6: "[17~";
+  readonly F7: "[18~";
+  readonly F8: "[19~";
+  readonly F9: "[20~";
+  readonly F10: "[21~";
+  readonly F11: "[23~";
+  readonly F12: "[24~";
+  readonly PAGE_UP: "[5~";
+  readonly PAGE_DOWN: "[6~";
+};
+type TestKeyInput = string | keyof typeof KeyCodes;
+interface MockKeysOptions {
+  kittyKeyboard?: boolean | undefined;
+}
+interface KeyModifiers {
+  shift?: boolean;
+  ctrl?: boolean;
+  alt?: boolean;
+  meta?: boolean;
+}
+declare function createMockKeys(_renderer: CliRenderer, _options?: MockKeysOptions): {
+  pressKey: (key: TestKeyInput, modifiers?: KeyModifiers) => void;
+  pressKeys: (keys: TestKeyInput[], delayMs?: number) => Promise<void>;
+  typeText: (text: string, delayMs?: number) => Promise<void>;
+  pressEnter: (modifiers?: KeyModifiers) => void;
+  pressEscape: (modifiers?: KeyModifiers) => void;
+  pressTab: (modifiers?: KeyModifiers) => void;
+  pressBackspace: (modifiers?: KeyModifiers) => void;
+  pressArrow: (direction: "up" | "down" | "left" | "right", modifiers?: KeyModifiers) => void;
+  pressCtrlC: () => void;
+  pressCtrlD: () => void;
+  pressPageUp: (modifiers?: KeyModifiers) => void;
+  pressPageDown: (modifiers?: KeyModifiers) => void;
+  pressHome: (modifiers?: KeyModifiers) => void;
+  pressEnd: (modifiers?: KeyModifiers) => void;
+  pressDelete: (modifiers?: KeyModifiers) => void;
+  getKeyHistory: () => string[];
+  clearHistory: () => void;
+};
+//#endregion
+//#region src/testing/mockMouse.d.ts
+declare const MouseButtons: {
+  readonly LEFT: 0;
+  readonly MIDDLE: 1;
+  readonly RIGHT: 2;
+  readonly WHEEL_UP: 64;
+  readonly WHEEL_DOWN: 65;
+  readonly WHEEL_LEFT: 66;
+  readonly WHEEL_RIGHT: 67;
+};
+type MouseButton$1 = (typeof MouseButtons)[keyof typeof MouseButtons];
+interface MousePosition {
+  x: number;
+  y: number;
+}
+interface MouseModifiers {
+  shift?: boolean;
+  alt?: boolean;
+  ctrl?: boolean;
+}
+type MouseEventType = "down" | "up" | "move" | "drag" | "scroll";
+interface MouseEventOptions {
+  button?: MouseButton$1;
+  modifiers?: MouseModifiers;
+  delayMs?: number;
+}
+declare function createMockMouse(): {
+  moveTo: (x: number, y: number, options?: MouseEventOptions) => Promise<void>;
+  click: (x: number, y: number, button?: MouseButton$1, options?: MouseEventOptions) => Promise<void>;
+  doubleClick: (x: number, y: number, button?: MouseButton$1, options?: MouseEventOptions) => Promise<void>;
+  pressDown: (x: number, y: number, button?: MouseButton$1, options?: MouseEventOptions) => Promise<void>;
+  release: (x: number, y: number, button?: MouseButton$1, options?: MouseEventOptions) => Promise<void>;
+  drag: (startX: number, startY: number, endX: number, endY: number, button?: MouseButton$1, options?: MouseEventOptions) => Promise<void>;
+  scroll: (x: number, y: number, direction: "up" | "down" | "left" | "right", options?: MouseEventOptions) => Promise<void>;
+  getCurrentPosition: () => MousePosition;
+  getPressedButtons: () => MouseButton$1[];
+  emitMouseEvent: (type: MouseEventType, x: number, y: number, button?: MouseButton$1, options?: Omit<MouseEventOptions, "button">) => Promise<void>;
+  getEventHistory: () => string[];
+  clearHistory: () => void;
+};
+//#endregion
+//#region src/testing/testStreams.d.ts
+declare class TestWriteStream extends Writable {
+  readonly isTTY = true;
+  columns: number;
+  rows: number;
+  buffer: Buffer;
+  constructor(columns?: number, rows?: number);
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  getColorDepth(): number;
+  getOutput(): string;
+  clear(): void;
+}
+type TestStdout = TestWriteStream & NodeJS.WriteStream;
+declare class TestReadStream extends Readable {
+  readonly isTTY = true;
+  constructor();
+  emitData(data: string | Buffer): void;
+}
+type TestStdin = TestReadStream & NodeJS.ReadStream;
+declare function createTestStdin(): TestStdin;
+declare function createTestStdout(columns?: number, rows?: number): TestStdout;
+//#endregion
+//#region src/testing/testRenderer.d.ts
+interface TestRendererOptions extends CliRendererOptions {
+  width?: number;
+  height?: number;
+  kittyKeyboard?: boolean;
+}
+type TestRenderer = CliRenderer;
+type MockInput = ReturnType<typeof createMockKeys>;
+type MockMouse = ReturnType<typeof createMockMouse>;
+interface TestRendererSetup {
+  renderer: TestRenderer;
+  mockInput: MockInput;
+  mockMouse: MockMouse;
+  stdin: TestStdin;
+  stdout: TestStdout;
+  renderOnce: () => void;
+  captureFrame: () => string;
+  resize: (width: number, height: number) => void;
+  cleanup: () => void;
+}
+declare function createTestRenderer(options?: TestRendererOptions): Promise<TestRendererSetup>;
+declare function createTestRendererSync(options?: TestRendererOptions): TestRendererSetup;
+//#endregion
+//#region src/testing/spy.d.ts
+interface Spy {
+  (...args: unknown[]): void;
+  calls: unknown[][];
+  callCount: () => number;
+  calledWith: (...expected: unknown[]) => boolean;
+  lastCall: () => unknown[] | undefined;
+  reset: () => void;
+}
+declare function createSpy(): Spy;
+//#endregion
+//#region src/testing/terminalCapabilities.d.ts
+interface TerminalCapabilitiesOptions {
+  trueColor?: boolean;
+  kittyKeyboard?: boolean;
+  csiU?: boolean;
+  bracketedPaste?: boolean;
+  focusEvents?: boolean;
+  mouse?: boolean;
+  osc52?: boolean;
+  osc8?: boolean;
+  sync?: boolean;
+  sgrPixel?: boolean;
+  underlineColor?: boolean;
+  strikethrough?: boolean;
+  cursorStyle?: boolean;
+  alternateScroll?: boolean;
+  inlineImages?: boolean;
+  sixel?: boolean;
+  columns?: number;
+  rows?: number;
+  brand?: string;
+}
+declare function createTerminalCapabilities(options?: TerminalCapabilitiesOptions): TerminalCapabilities$1;
+declare function createMinimalTerminalCapabilities(): TerminalCapabilities$1;
+declare function createFullTerminalCapabilities(): TerminalCapabilities$1;
+declare function createKittyTerminalCapabilities(): TerminalCapabilities$1;
+declare function createITerm2TerminalCapabilities(): TerminalCapabilities$1;
+//#endregion
+//#region src/testing/testing.d.ts
+interface TestBinding {
+  layer: string;
+  id: string;
+  keys: string;
+  command: string;
+  description: string | null;
+  priority: number;
+  enabled: boolean;
+}
+declare function createMockNativeKeymap(): NapiKeymap;
+declare function createTestKeymap(bindings?: Array<{
+  layer?: string;
+  id?: string;
+  keys: string;
+  command: string;
+  description?: string;
+  priority?: number;
+}>, options?: KeymapOptions): Keymap;
+//#endregion
+//#region src/animations.d.ts
+/**
+ * Animation utilities: easing functions, Tween, Spring, and interpolation helpers.
+ *
+ * @example
+ * ```ts
+ * import { easing, Tween, Spring, lerp } from "@bettertui/core"
+ *
+ * const tw = new Tween({ from: 0, to: 100, duration: 1, onUpdate: v => setX(v) })
+ * tw.play()
+ * tw.tick(deltaSeconds)
+ * ```
+ */
+/**
+ * Standard easing functions operating on [0, 1].
+ * Each function takes a normalised time `t` (0 = start, 1 = end) and returns
+ * the eased value.
+ */
+declare const easing: {
+  readonly linear: (t: number) => number;
+  readonly easeInQuad: (t: number) => number;
+  readonly easeOutQuad: (t: number) => number;
+  readonly easeInOutQuad: (t: number) => number;
+  readonly easeInCubic: (t: number) => number;
+  readonly easeOutCubic: (t: number) => number;
+  readonly easeInOutCubic: (t: number) => number;
+  readonly easeInQuart: (t: number) => number;
+  readonly easeOutQuart: (t: number) => number;
+  readonly easeInOutQuart: (t: number) => number;
+  readonly easeInSine: (t: number) => number;
+  readonly easeOutSine: (t: number) => number;
+  readonly easeInOutSine: (t: number) => number;
+  readonly easeInExpo: (t: number) => number;
+  readonly easeOutExpo: (t: number) => number;
+  readonly easeInOutExpo: (t: number) => number;
+  readonly easeInCirc: (t: number) => number;
+  readonly easeOutCirc: (t: number) => number;
+  readonly easeInOutCirc: (t: number) => number;
+  readonly easeInBack: (t: number, s?: number) => number;
+  readonly easeOutBack: (t: number, s?: number) => number;
+  readonly easeInElastic: (t: number) => number;
+  readonly easeOutElastic: (t: number) => number;
+  readonly easeOutBounce: (t: number) => number;
+  readonly easeInBounce: (t: number) => number;
+};
+type EasingName = keyof typeof easing;
+/** Linear interpolation between `a` and `b` by factor `t` (clamped to [0,1]). */
+declare function lerp(a: number, b: number, t: number): number;
+/** Inverse lerp: returns how far `value` is between `a` and `b` (0–1). */
+declare function inverseLerp(a: number, b: number, value: number): number;
+/** Smoothly interpolate between `a` and `b` using Hermite smoothstep. */
+declare function smoothstep(a: number, b: number, t: number): number;
+/** Clamp `value` to [min, max]. */
+declare function clamp(value: number, min: number, max: number): number;
+interface TweenOptions {
+  from: number;
+  to: number;
+  duration: number;
+  easing?: EasingName;
+  onUpdate?: (value: number) => void;
+  onComplete?: () => void;
+}
+/**
+ * A simple imperative tween driven manually with `tick(dt)`.
+ * Does NOT require a Timeline — useful for one-shot or procedural animations.
+ *
+ * @example
+ * ```ts
+ * const tw = new Tween({ from: 0, to: 255, duration: 1, onUpdate: v => setAlpha(v) })
+ * tw.play()
+ * tw.tick(deltaSeconds)
+ * ```
+ */
+declare class Tween {
+  private _time;
+  private _playing;
+  private readonly _options;
+  constructor(options: TweenOptions);
+  get value(): number;
+  get progress(): number;
+  get isComplete(): boolean;
+  play(): this;
+  pause(): this;
+  reset(): this;
+  tick(dt: number): void;
+}
+interface SpringOptions {
+  /** Natural frequency (stiffness). Higher = faster. Default: 10. */
+  frequency?: number;
+  /** Damping ratio. 1.0 = critically damped. Default: 0.8. */
+  damping?: number;
+  /** Initial position. Default: 0. */
+  initial?: number;
+  /** Target position. */
+  target: number;
+}
+/**
+ * Simple critically-damped spring for smooth follow animations.
+ *
+ * @example
+ * ```ts
+ * const spring = new Spring({ target: 100, frequency: 8, damping: 0.75 })
+ * spring.tick(dt)
+ * const x = spring.position
+ * ```
+ */
+declare class Spring {
+  private _pos;
+  private _vel;
+  private _target;
+  private readonly _frequency;
+  private readonly _damping;
+  constructor(options: SpringOptions);
+  get position(): number;
+  get velocity(): number;
+  set target(t: number);
+  /** Advance the spring simulation by `dt` seconds. */
+  tick(dt: number): void;
+  /** Instantly snap to the target. */
+  snap(): void;
+  /** Returns true when the spring has essentially settled. */
+  isSettled(tolerance?: number): boolean;
+}
+//#endregion
+//#region src/graphics.d.ts
+/**
+ * Terminal graphics utilities: pixel buffer, canvas, ANSI color helpers,
+ * and gradient generation.
+ *
+ * @example
+ * ```ts
+ * import { Canvas, parseHex } from "@bettertui/core"
+ *
+ * const canvas = new Canvas(40, 20)
+ * canvas.fill(parseHex("#1a1a2e"))
+ * canvas.drawRect(5, 2, 10, 6, { r: 255, g: 64, b: 0 })
+ * process.stdout.write(canvas.render())
+ * ```
+ */
+interface RGB {
+  r: number;
+  g: number;
+  b: number;
+}
+interface RGBA$1 extends RGB {
+  a: number;
+}
+/** Parse a CSS hex color string (`#rgb`, `#rrggbb`, `#rrggbbaa`) to RGBA. */
+declare function parseHex(hex: string): RGBA$1;
+/** Convert RGB to a 24-bit ANSI truecolor foreground escape sequence. */
+declare function rgbFg(color: RGB): string;
+/** Convert RGB to a 24-bit ANSI truecolor background escape sequence. */
+declare function rgbBg(color: RGB): string;
+/** ANSI reset sequence. */
+declare const RESET = "";
+/** A mutable RGBA pixel buffer. Each pixel is 4 bytes: R, G, B, A. */
+declare class PixelBuffer {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8ClampedArray;
+  constructor(width: number, height: number, fill?: RGBA$1);
+  private _offset;
+  getPixel(x: number, y: number): RGBA$1;
+  setPixel(x: number, y: number, color: RGB | RGBA$1): void;
+  fill(color: RGB | RGBA$1): void;
+  /** Convert this pixel buffer to a Node.js Buffer containing raw RGB bytes. */
+  toRgbBuffer(): Buffer;
+  /** Convert this pixel buffer to a Node.js Buffer containing raw RGBA bytes. */
+  toRgbaBuffer(): Buffer;
+}
+/**
+ * A terminal "canvas" that renders RGBA pixels as Unicode half-block
+ * characters (`▀`, `▄`), achieving 1×2 sub-cell pixel resolution.
+ * Each character cell covers one column × 2 rows of pixels.
+ *
+ * @example
+ * ```ts
+ * const canvas = new Canvas(40, 20)
+ * canvas.fill({ r: 0, g: 0, b: 0 })
+ * canvas.setPixel(10, 5, { r: 255, g: 64, b: 0 })
+ * process.stdout.write(canvas.render())
+ * ```
+ */
+declare class Canvas {
+  readonly pixelWidth: number;
+  readonly pixelHeight: number;
+  private _buffer;
+  /**
+   * @param pixelWidth  Width in pixels (each char column = 1 pixel wide).
+   * @param pixelHeight Height in pixels (each char row = 2 pixels tall).
+   */
+  constructor(pixelWidth: number, pixelHeight: number);
+  get buffer(): PixelBuffer;
+  setPixel(x: number, y: number, color: RGB | RGBA$1): void;
+  getPixel(x: number, y: number): RGBA$1;
+  fill(color: RGB | RGBA$1): void;
+  /**
+   * Render the canvas to a string using upper-half block `▀` characters.
+   * Each character encodes two pixel rows: foreground = top pixel, background = bottom pixel.
+   */
+  render(): string;
+  /** Draw a filled rectangle. */
+  drawRect(x: number, y: number, w: number, h: number, color: RGB | RGBA$1): void;
+  /** Draw a 1-pixel-wide rectangle outline. */
+  drawRectOutline(x: number, y: number, w: number, h: number, color: RGB | RGBA$1): void;
+  /** Draw a line using Bresenham's algorithm. */
+  drawLine(x0: number, y0: number, x1: number, y1: number, color: RGB | RGBA$1): void;
+  /** Draw a filled or outline circle using midpoint circle algorithm. */
+  drawCircle(cx: number, cy: number, radius: number, color: RGB | RGBA$1, filled?: boolean): void;
+  /** Build a PixelBuffer image suitable for passing to the Image widget. */
+  toPixelBuffer(): PixelBuffer;
+}
+/** Generate a horizontal gradient between two RGB colors across `steps` stops. */
+declare function gradientH(from: RGB, to: RGB, steps: number): RGB[];
+//#endregion
+//#region src/audio.d.ts
+type AudioGroup = number;
+type AudioStreamAction = "connect" | "read" | "decode" | "play" | "reconnect" | "stop" | "dispose";
+interface AudioStreamErrorContext {
+  action: AudioStreamAction;
+  status?: number;
+  errorCode?: number;
+  attempt?: number;
+}
+declare class AudioStreamError extends Error {
+  readonly context: AudioStreamErrorContext;
+  constructor(message: string, context: AudioStreamErrorContext, cause?: unknown);
+}
+type AudioStreamState = "initializing" | "buffering" | "playing" | "reconnecting" | "ended" | "errored" | "disposed" | "idle";
+interface AudioStreamStats {
+  state: AudioStreamState;
+  sampleRate: number;
+  channels: number;
+  bufferedFrames: number;
+  capacityFrames: number;
+  bufferedDurationMs: number;
+  bytesReceived: bigint;
+  framesDecoded: bigint;
+  framesPlayed: bigint;
+  underruns: number;
+  reconnectAttempts: number;
+}
+type AudioStreamMetadataFormat = "icy" | string;
+interface AudioStreamMetadata {
+  readonly format: AudioStreamMetadataFormat;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly fields: Readonly<Record<string, string>>;
+}
+interface AudioStreamReconnectEvent {
+  attempt: number;
+  delayMs: number;
+  error: AudioStreamError;
+}
+interface AudioStreamUrlOptions {
+  format?: "mp3" | "flac" | string;
+  signal?: AbortSignal;
+  volume?: number;
+  pan?: number;
+  groupId?: number;
+  buffer?: {
+    capacityMs?: number;
+    startupMs?: number;
+    resumeMs?: number;
+  };
+  reconnect?: {
+    maxRetries?: number;
+    retryOnEnd?: boolean;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    backoffFactor?: number;
+  };
+}
+declare class AudioStream<M = AudioStreamMetadata> extends EventEmitter {
+  private _state;
+  get state(): AudioStreamState;
+  getStats(): AudioStreamStats;
+  getMetadata(): M | null;
+  setVolume(_volume: number): boolean;
+  setPan(_pan: number): boolean;
+  setGroup(_groupId: number): boolean;
+  dispose(): void;
+}
+interface AudioPlaybackDevice {
+  name: string;
+  id: string;
+  isDefault: boolean;
+}
+interface AudioSound {
+  id: string;
+  duration: number;
+}
+interface AudioVoice {
+  id: string;
+  sound: AudioSound;
+}
+interface AudioSetupOptions {
+  autoStart?: boolean;
+  sampleRate?: number;
+  channels?: number;
+  bufferSize?: number;
+}
+interface AudioStartOptions {
+  deviceId?: string;
+}
+interface AudioPlayOptions {
+  volume?: number;
+  pan?: number;
+  loop?: boolean;
+  groupId?: number;
+}
+interface AudioStats {
+  lastPeak: number;
+  lastRms: number;
+  framesProcessed: bigint;
+}
+interface AudioTapResult {
+  framesRead: number;
+  frames: Float32Array;
+}
+declare class Audio extends EventEmitter {
+  readonly sampleRate: number;
+  private _started;
+  private _mixerStarted;
+  private _disposed;
+  private constructor();
+  /** Factory — creates a new Audio instance. */
+  static create(options?: AudioSetupOptions): Audio;
+  start(_options?: AudioStartOptions): boolean;
+  startMixer(): boolean;
+  stop(): boolean;
+  isStarted(): boolean;
+  isMixerStarted(): boolean;
+  /**
+   * Create an audio group.  Returns the group id (a small integer starting at 1).
+   */
+  private _groupCounter;
+  group(_name: string): AudioGroup;
+  createGroup(_name: string): AudioGroup;
+  setGroupVolume(_group: AudioGroup, _volume: number): boolean;
+  setMasterVolume(_volume: number): boolean;
+  enableTap(_bufferSize: number): void;
+  disableTap(): void;
+  readTapFrames(_frameCount: number, _channels: number): AudioTapResult | null;
+  mixFrames(_frameCount: number, _channels: number): void;
+  getStats(): AudioStats | null;
+  loadSound(_data: Uint8Array | ArrayBuffer): AudioSound | null;
+  loadSoundFile(_path: string): Promise<AudioSound | null>;
+  unloadSound(_sound: AudioSound): boolean;
+  play(_sound: AudioSound, _options?: AudioPlayOptions): AudioVoice | null;
+  stopVoice(_voice: AudioVoice): boolean;
+  setVoiceGroup(_voice: AudioVoice, _group: AudioGroup): boolean;
+  playStreamUrl(_url: string | URL, _options?: AudioStreamUrlOptions): Promise<AudioStream>;
+  dispose(): void;
+}
+//#endregion
+//#region src/renderables/ScrollBox.d.ts
+interface ScrollBarOptions extends BoxOptions {
+  orientation?: "vertical" | "horizontal";
+  showArrows?: boolean;
+  thumbColor?: ColorInput;
+  trackColor?: ColorInput;
+  trackOptions?: {
+    foregroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+  };
+}
+declare class ScrollBar extends Box {
+  private _orientation;
+  private _showArrows;
+  private _scrollPosition;
+  private _scrollSize;
+  private _viewSize;
+  private readonly _topSpacer;
+  private readonly _thumb;
+  private readonly _bottomSpacer;
+  constructor(renderer: CliRenderer, options?: ScrollBarOptions);
+  get showArrows(): boolean;
+  set showArrows(v: boolean);
+  get scrollPosition(): number;
+  set scrollPosition(v: number);
+  get scrollSize(): number;
+  set scrollSize(v: number);
+  get viewSize(): number;
+  set viewSize(v: number);
+  /**
+   * Update thumb position and size using proportional flex-grow weights.
+   *
+   * Total flex weight always equals `totalLines`, so the thumb proportion
+   * (viewLines / totalLines) is constant regardless of scroll position.
+   */
+  updateScrollBar(scrollTop: number, totalLines: number, viewLines: number): void;
+}
+interface ScrollBoxOptions extends BoxOptions {
+  rootOptions?: BoxOptions;
+  wrapperOptions?: BoxOptions;
+  viewportOptions?: BoxOptions;
+  contentOptions?: BoxOptions;
+  scrollbarOptions?: ScrollBarOptions;
+  verticalScrollbarOptions?: ScrollBarOptions;
+  horizontalScrollbarOptions?: ScrollBarOptions;
+  stickyScroll?: boolean;
+  stickyStart?: "bottom" | "top" | "left" | "right";
+  scrollX?: boolean;
+  scrollY?: boolean;
+  viewportCulling?: boolean;
+}
+declare class ScrollBox extends Box {
+  readonly content: Box;
+  readonly viewport: Box;
+  readonly verticalScrollBar: ScrollBar;
+  readonly horizontalScrollBar: ScrollBar;
+  private _scrollTop;
+  private _scrollLeft;
+  private _stickyScroll;
+  private _contentLines;
+  private _lastScrollTop;
+  private _lastContentLines;
+  private _lastViewLines;
+  private readonly _keyHandler;
+  private readonly _lifecyclePass;
+  constructor(renderer: CliRenderer, options?: ScrollBoxOptions);
+  get scrollTop(): number;
+  set scrollTop(v: number);
+  get scrollLeft(): number;
+  set scrollLeft(v: number);
+  get scrollHeight(): number;
+  get scrollWidth(): number;
+  get stickyScroll(): boolean;
+  set stickyScroll(v: boolean);
+  add(child: Box, index?: number): void;
+  remove(child: Box): void;
+  getRenderable(id: string): Box | undefined;
+  focus(): void;
+  blur(): void;
+  scrollBy(delta: number, axis?: "x" | "y"): void;
+  private _applyScroll;
+  private _estimateViewLines;
+  private _updateScrollbar;
+  private _handleKey;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/Textarea.d.ts
+/** Minimal extmarks controller stub for type compatibility. */
+interface ExtmarksController {
+  create(opts: {
+    start: number;
+    end: number;
+    virtual?: boolean;
+    styleId?: number;
+    data?: unknown;
+  }): number;
+  getAtOffset(offset: number): Array<{
+    start: number;
+    end: number;
+    styleId?: number;
+    data?: unknown;
+  }>;
+  getVirtual(): Array<{
+    start: number;
+    end: number;
+    styleId?: number;
+    data?: unknown;
+  }>;
+  destroy(): void;
+}
+declare class ExtmarksControllerStub implements ExtmarksController {
+  create(_opts: {
+    start: number;
+    end: number;
+    virtual?: boolean;
+    styleId?: number;
+    data?: unknown;
+  }): number;
+  getAtOffset(_offset: number): Array<{
+    start: number;
+    end: number;
+    styleId?: number;
+    data?: unknown;
+  }>;
+  getVirtual(): Array<{
+    start: number;
+    end: number;
+    styleId?: number;
+    data?: unknown;
+  }>;
+  destroy(): void;
+}
+interface TextareaOptions extends BoxOptions {
+  initialValue?: string;
+  placeholder?: string;
+  placeholderColor?: ColorInput;
+  textColor?: ColorInput;
+  focusedTextColor?: ColorInput;
+  cursorColor?: ColorInput;
+  backgroundColor?: ColorInput;
+  focusedBackgroundColor?: ColorInput;
+  wrapMode?: "none" | "char" | "word";
+  showCursor?: boolean;
+  readonly?: boolean;
+  selectionBg?: ColorInput;
+  selectionFg?: ColorInput;
+  syntaxStyle?: unknown;
+}
+declare class Textarea extends Box {
+  protected _text: string;
+  protected _cursorLine: number;
+  protected _cursorCol: number;
+  private _placeholder;
+  private _placeholderColor;
+  private _textColor;
+  private _focusedTextColor;
+  private _cursorColor;
+  private _focusedBgColor;
+  private _wrapMode;
+  private _showCursor;
+  private _readonly;
+  private _textNodeId;
+  private _scrollOffset;
+  private readonly _keyHandler;
+  /** Extmarks controller stub — override or replace in subclasses for full functionality. */
+  extmarks: ExtmarksControllerStub;
+  /** Logical cursor position (line/col). */
+  get logicalCursor(): {
+    row: number;
+    col: number;
+  };
+  constructor(renderer: CliRenderer, options?: TextareaOptions);
+  get plainText(): string;
+  set plainText(v: string);
+  get cursorOffset(): number;
+  setText(text: string): void;
+  insertText(text: string): void;
+  newLine(): boolean;
+  submit(): boolean;
+  focus(): void;
+  blur(): void;
+  protected _handleKey(key: KeyEvent): void;
+  protected _render(): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/Slider.d.ts
+interface SliderOptions extends BoxOptions {
+  orientation?: "horizontal" | "vertical";
+  min?: number;
+  max?: number;
+  value?: number;
+  step?: number;
+  viewPortSize?: number;
+  trackColor?: ColorInput;
+  thumbColor?: ColorInput;
+  activeTrackColor?: ColorInput;
+  onChange?: (value: number) => void;
+}
+type SliderRenderableOptions = SliderOptions;
+declare class Slider extends Box {
+  private _orientation;
+  private _min;
+  private _max;
+  private _value;
+  private _step;
+  private _viewPortSize;
+  private _trackColor;
+  private _thumbColor;
+  private _activeTrackColor;
+  private _onChange;
+  private _contentNodeId;
+  private readonly _keyHandler;
+  constructor(renderer: CliRenderer, options?: SliderOptions);
+  get value(): number;
+  set value(v: number);
+  get min(): number;
+  set min(v: number);
+  get max(): number;
+  set max(v: number);
+  get step(): number;
+  set step(v: number);
+  get orientation(): "horizontal" | "vertical";
+  focus(): void;
+  blur(): void;
+  private _handleKey;
+  private _render;
+  destroy(): void;
+}
+//#endregion
+//#region src/renderables/Canvas.d.ts
+interface CanvasHeaderOptions {
+  id?: string;
+  height?: number;
+  backgroundColor?: ColorInput;
+  border?: boolean | BorderSide[];
+  borderStyle?: BorderStyleKind;
+  borderColor?: ColorInput;
+  title?: string;
+  titleAlignment?: "left" | "center" | "right";
+  alignItems?: BoxOptions["alignItems"];
+  justifyContent?: BoxOptions["justifyContent"];
+  padding?: number;
+  paddingX?: number;
+  paddingY?: number;
+  paddingLeft?: number;
+  paddingRight?: number;
+}
+type CanvasFooterOptions = CanvasHeaderOptions;
+interface CanvasBodyOptions {
+  id?: string;
+  backgroundColor?: ColorInput;
+  flexDirection?: "row" | "column";
+  alignItems?: BoxOptions["alignItems"];
+  justifyContent?: BoxOptions["justifyContent"];
+  overflow?: BoxOptions["overflow"];
+  gap?: number;
+  padding?: number;
+  paddingX?: number;
+  paddingY?: number;
+}
+interface CanvasOptions {
+  id?: string;
+  backgroundColor?: ColorInput;
+  header?: CanvasHeaderOptions;
+  body?: CanvasBodyOptions;
+  footer?: CanvasFooterOptions;
+}
+interface ScreenResizeEvent {
+  width: number;
+  height: number;
+}
+declare const ScreenEvents: {
+  readonly RESIZE: "resize";
+};
+declare class Screen extends EventEmitter {
+  readonly container: Box;
+  readonly header: Box | null;
+  readonly body: Box;
+  readonly footer: Box | null;
+  private readonly _renderer;
+  private readonly _resizeHandler;
+  constructor(renderer: CliRenderer, options?: CanvasOptions);
+  get terminalWidth(): number;
+  get terminalHeight(): number;
+  /** Re-apply body layout atomically. Always sets flexGrow: 1, flexShrink: 1. */
+  setBodyLayout(opts: CanvasBodyOptions): void;
+  /** Re-apply header visual options (background / border color) after a theme change. */
+  applyHeaderOptions(opts: Pick<CanvasHeaderOptions, "backgroundColor" | "borderColor">): void;
+  /** Re-apply footer visual options (background / border color) after a theme change. */
+  applyFooterOptions(opts: Pick<CanvasFooterOptions, "backgroundColor" | "borderColor">): void;
+  onResize(cb: (e: ScreenResizeEvent) => void): this;
+  offResize(cb: (e: ScreenResizeEvent) => void): this;
+  destroy(): void;
+}
+//#endregion
+//#region src/index.d.ts
+/** Measure the display width and height of text. */
+declare function measureText(opts: {
+  text: string;
+  font?: string;
+}): {
+  width: number;
+  height: number;
+};
+declare function decodePasteBytes(bytes: Uint8Array): string;
+declare function resolveRenderLib(): {
+  getArenaAllocatedBytes: () => number;
+};
+/** Strip ANSI escape sequences from a string. */
+declare function stripAnsiSequences(str: string): string;
+type Selection = {
+  start: {
+    line: number;
+    col: number;
+  };
+  end: {
+    line: number;
+    col: number;
+  };
+  text: string;
+  getSelectedText(): string;
+  isDragging: boolean;
+};
+/** HAST (Hypertext Abstract Syntax Tree) element type. */
+type HASTElement = {
+  type: string;
+  tagName?: string;
+  value?: string;
+  properties?: Record<string, unknown>;
+  children?: HASTElement[];
+};
+declare class SyntaxStyle {
+  fg?: string;
+  bg?: string;
+  bold?: boolean;
+  italic?: boolean;
+  private _styles;
+  private _cache;
+  constructor(opts?: {
+    fg?: string;
+    bg?: string;
+    bold?: boolean;
+    italic?: boolean;
+  });
+  /** Create a new SyntaxStyle instance. */
+  static create(): SyntaxStyle;
+  /** Create a SyntaxStyle from a record of style definitions. */
+  static fromStyles(styles: Record<string, {
+    fg?: unknown;
+    bg?: unknown;
+    bold?: boolean;
+    italic?: boolean;
+  }>): SyntaxStyle;
+  /** Register a named style and return its numeric ID. */
+  registerStyle(name: string, style: Record<string, unknown>): number;
+  /** Get the number of cached entries. */
+  getCacheSize(): number;
+  /** Clear the style cache. */
+  clearCache(): void;
+  destroy(): void;
+}
+/** Convert a HAST tree to a StyledText string using the given SyntaxStyle. */
+declare function hastToStyledText(node: HASTElement, _style: SyntaxStyle): string;
+type RenderContext = {
+  width: number;
+  height: number;
+  requestRender(): void;
+};
+type OptimizedBuffer = {
+  width: number;
+  height: number;
+  buffers: {
+    bg: Uint16Array;
+    fg: Uint16Array;
+    char: Uint32Array;
+    attributes: Uint32Array;
+  };
+  setCell(x: number, y: number, char: string, fg?: unknown, bg?: unknown): void;
+  drawText(text: string, x: number, y: number, fg?: unknown, bg?: unknown, attributes?: number): void;
+  fillRect(x: number, y: number, w: number, h: number, color: unknown): void;
+};
+//#endregion
+export { ASCIIFont, type ASCIIFontKind, type ASCIIFontOptions, type ActiveKeyInfo, type AlignItems, type AlignSelf, Audio, type AudioGroup, type AudioPlayOptions, type AudioPlaybackDevice, type AudioSetupOptions, type AudioSound, type AudioStartOptions, type AudioStats, AudioStream, type AudioStreamAction, AudioStreamError, type AudioStreamErrorContext, type AudioStreamMetadata, type AudioStreamMetadataFormat, type AudioStreamReconnectEvent, type AudioStreamState, type AudioStreamStats, type AudioStreamUrlOptions, type AudioTapResult, type AudioVoice, type BindingInfo, type BorderSide, type BorderStyle, type BorderStyleKind, Box, type BoxOptions, type CallerInfo, Canvas, type CanvasBodyOptions, type CanvasFooterOptions, type CanvasHeaderOptions, type CanvasOptions, CapabilityInspector, type CapabilityInspectorOptions, CliRenderEvents, CliRenderer, type CliRendererOptions, type Clock, Code, type CodeOptions, type ColorInput, type ColorValue, type Command, CommandBuffer, type CommandBufferConsumer, type CommandContext, type CommandEntry, type CommandHandler, CommandInspector, type CommandInspectorOptions, type CommandResult, CommandRuntime, type CommandRuntimeOptions, type CommandType, type ConsoleLogEntry, ConsoleLogLevel, CreateDevToolsOptions, DebugConsole, DebugPanel, DevTools, type LogLevel as DevToolsLogLevel, Logger as DevToolsLogger, type DevToolsNode, DevToolsOptions, type TerminalCapabilities as DevToolsTerminalCapabilities, DevToolsTimeline, type DevToolsTimelineOptions, type DiagnosticExport, DiagnosticSnapshot, Diff, type DiffOptions, EasingName, type EnvVarConfig, type EventCategory, EventInspector, type EventInspectorOptions, type ExportData, type ExportOptions, type ExternalOutputMode, type ExtmarksController, ExtmarksControllerStub, type FlexDirection, FocusInspector, type FocusInspectorOptions, type FocusSnapshot, FrameBuffer, type FrameBufferLike, type FrameBufferOptions, type FrameMetrics, type Gap, GenericVNode as Generic, type GraphicsFormat, HASTElement, type HighlightSegment, type HighlightedLine, type HostConfig, type HostContext, type ImperativeContext, Input, InputEvents, type InputOptions, type InputRenderableOptions, type Inset, type Instance, type InterceptContext, type InterceptHandler, InternalKeyHandler, type JustifyContent, type KeyAliasMap, type KeyBinding, type KeyBindingLike, type KeyBindingLookup, KeyCodes, KeyEvent, KeyEvent as KeyboardEvent, type KeyEventSource, type KeyEventType, KeyHandler, type KeyHandlerEventMap, KeyInput, type KeyListener, type KeyModifiers, Keymap, type KeymapEvent, type KeymapOptions, type LayoutConstraints, LayoutEvents, LineNumber, type LineNumberOptions, type LogEntry, LogLevel$1 as LogLevel, Logger$1 as Logger, LoggerConfig, type LoggerOptions, type Margin, Markdown, type MarkdownOptions, MemoryStats, type MockInput, type MockKeysOptions, type MockMouse, type MouseButton, MouseButtons, type MouseEvent, type MouseEventOptions, type MouseEventType, type MouseModifiers, MouseParser, type MousePosition, type NapiDiagnosticSnapshot, type NapiEngine, type NapiEventBus, type NapiFocusManager, NapiHitGrid, type NapiKeymap, type NapiLoggerConfig, NapiPluginHost, type NapiScheduler, NapiSpanFeed, type NapiSpanFeedStats, type NapiTextEngine, type NapiTheme, type NapiThemeBorders, type NapiThemeColors, type NapiThemeSpacing, NapiTimeline, type NapiWidgetHost, type NativeSpanFeedOptions, OptimizedBuffer, type Overflow, type OverlayCorner, OverlayHost, type OverlayHostOptions, type Padding, type Panel, type PanelContext, type ParseKeypressOptions, type ParsedKey, PasteEvent, type PasteMetadata, type PerformanceSnapshot, PerformanceTracker, type PerformanceTrackerOptions, PixelBuffer, type PluginStateName, type Point, type Position, RESET, type RGB, RGBA, type RawKeyEvent, type RawMouseEvent, type RecordedCommand, type RecordedEvent, type Rect, RenderContext, type RenderResult, Renderable, RenderableEvents, Root, RootTextNode, SchedulerInspector, type SchedulerInspectorOptions, type SchedulerSnapshot, Screen, ScreenEvents, type ScreenMode, type ScreenResizeEvent, ScrollBar, type ScrollBarOptions, ScrollBox, type ScrollBoxOptions, type ScrollInfo, Select, SelectEvents, type SelectOption, type SelectOptions, type SelectRenderableOptions, Selection, type Size, type Sizing, Slider, SliderEvents, type SliderOptions, type SliderRenderableOptions, type SlotMode, type SnapshotDiff, SnapshotManager, type SnapshotOptions, Spring, SpringOptions, type Spy, type StdinEvent, StdinParser, type StdinParserOptions, type StdinParserProtocolContext, type StdinResponseProtocol, type StylableInput, type Style, StyledText, SyntaxStyle, SystemClock, type TabOption, TabSelect, TabSelectEvents, type TabSelectOptions, type TabSelectRenderableOptions, type TableColumn, type TerminalCapabilities$1 as TerminalCapabilities, type TerminalCapabilitiesOptions, TerminalConsole, TerminalConsoleCache, type TestBinding, type TestKeyInput, TestReadStream, type TestRenderer, type TestRendererOptions, type TestRendererSetup, type TestStdin, type TestStdout, TestWriteStream, Text, TextAttributes, type TextChunk, type TextInstance, TextNode, type TextNodeOptions, type TextOptions, TextTable, type TextTableColumnFitter, type TextTableColumnWidthMode, type TextTableContent, type TextTableOptions, Textarea, type TextareaOptions, type Theme, type ThemeColors, type ThemeMode, type ThemeSpacing, TimeToFirstDraw, type TimeToFirstDrawOptions, Timeline, type TimelineEntry, type TimelineOptions, type TimerHandle, TreeInspector, type TreeInspectorOptions, type TreeSnapshot, Tween, type TweenConfig, TweenOptions, type VNode, ASCIIFont$1 as VNodeASCIIFont, BoxVNode as VNodeBox, CodeVNode as VNodeCode, InputVNode as VNodeInput, ScrollBox$1 as VNodeScrollBox, SelectVNode as VNodeSelect, TabSelectVNode as VNodeTabSelect, TextVNode as VNodeText, type ValidationError, type ValidationResult, type WidgetContext, type WidgetLifecycle, ansiUtils_d_exports as ansi, appendChild, bg, bgBlack, bgBlue, bgCyan, bgGreen, bgMagenta, bgRed, bgWhite, bgYellow, black, blink, blue, bold, brightBlack, brightBlue, brightCyan, brightGreen, brightMagenta, brightRed, brightWhite, brightYellow, buildKeyBindingsMap, cacheHitRatio, capture, clamp, clearEnvCache, clipboardDecode, clipboardQuerySequence, clipboardSetSequence, commitTextUpdate, commitUpdate, createCliRenderer, createDarkTheme, createDevTools, createEngine, createEventBus, createExport, createFocusManager, createFullTerminalCapabilities, createHitGrid, createITerm2TerminalCapabilities, createInstance, createKeymap, createKittyTerminalCapabilities, createLightTheme, createMinimalTerminalCapabilities, createMockKeys, createMockMouse, createMockNativeKeymap, createTimeline as createNativeTimeline, createPluginHost, createReconciler, createScheduler, createSpanFeed, createSpy, createSummary, createTerminalCapabilities, createTestKeymap, createTestRenderer, createTestRendererSync, createTestStdin, createTestStdout, createTextEngine, createTextInstance, createTimeline$1 as createTimeline, createWidgetHost, cyan, decodePasteBytes, defaultKeyAliases, delegate, destroySingleton, detectCapabilities, dim, easing, env, exportToJson, fg, finalizeInitialChildren, generateEnvColored, generateEnvMarkdown, generateId, getAllEnvVarConfigs, getEnvVarConfig, getKeyBindingAction, getKeyBindingKey, getKeyBindingKeys, getNativePackageName, getSingleton, getVersion, gradientH, graphicsItermWrite, graphicsKittyDelete, graphicsKittyDeleteAll, graphicsKittyWrite, graphicsQuery, graphicsSixelWrite, green, h, hasSingleton, hastToStyledText, highlightCode, insertBefore, instantiate, inverseLerp, isStyledText, isValidColor, italic, keyBindingToString, kittyNamedSingleStrokeKeys, layoutToEngineJson, lerp, link, loggerFlush, loggerGetDiagnostics, loggerGetLevel, loggerInit, loggerSetLevel, loggerSetModuleFilter, magenta, matchesKeyBinding, maybeMakeRenderable, measureText, mergeKeyAliases, mergeKeyBindings, nonAlphanumericKeys, parseColor, parseHex, parseKeypress, parseKittyKeyboard, prepareUpdate, red, registerEnvVar, removeChild, resetAfterCommit, resolveRenderLib, reverse, rgbBg, rgbFg, rgbaToEngineColor, singleton, smoothstep, strikethrough, stringToStyledText, stripAnsiSequences, styledTextToAnsi, t, terminalConsoleCache, terminalNamedSingleStrokeKeys, underline, validate, validateLayoutConstraints, validateStyle, visibleWidth, vstyles, warnIfInvalid, white, yellow };
+//# sourceMappingURL=index.d.mts.map