@zaly/tui 0.0.4

package/dist/queries-DH3bj74K.d.mts

@@ -0,0 +1,1963 @@
+import { c as Color, f as Style, t as Theme } from "./types-B9Eh7k2v.mjs";
+import { a as StyleBuilder, t as InspectOpts } from "./inspect-D6FW_QUo.mjs";
+import { Emitter, MaybePromise } from "@zaly/shared";
+import { LogEntry, LogLevel, LogReporter, Logger, TryResult } from "@zaly/shared/logger";
+import { ArgsOpts, ArgsResult } from "@zaly/shared/args";
+//#region src/input/keys.d.ts
+/**
+ * Keyboard event shape + pattern-based matcher.
+ *
+ * `KeyEvent.name` is a canonical name:
+ *   - Single characters for printable keys: `"a"`, `"A"`, `" "`, `"!"`. The
+ *     `name` reflects the raw character the decoder produced — so `Shift+A`
+ *     arrives as `{ name: "A", shift: true }` (terminals already fold
+ *     shift into the uppercase byte for letters).
+ *   - Named constants for non-printing keys: `"enter"`, `"tab"`, `"esc"`,
+ *     `"backspace"`, `"delete"`, `"space"`, arrows `"up"/"down"/"left"/
+ *     "right"`, navigation `"home"/"end"/"pageup"/"pagedown"/"insert"`,
+ *     function keys `"f1"` .. `"f12"`.
+ *
+ * Patterns for `keyMatches` are dash-separated modifier prefixes plus the
+ * name: `"a"`, `"ctrl-c"`, `"shift-tab"`, `"ctrl-shift-x"`. Unknown
+ * prefixes are treated as literal characters in the name, so
+ * `"something-foo"` is interpreted as the name `"something-foo"` rather
+ * than a missing-modifier error.
+ *
+ * Modifier prefixes (order-independent):
+ *   - `ctrl-`
+ *   - `alt-`
+ *   - `shift-`
+ *   - `meta-`  (a.k.a. super / cmd)
+ */
+interface KeyEvent {
+  /** Canonical key name — raw character or one of the named constants above. */
+  name: string;
+  /**
+   * The literal text the keystroke would insert, when that makes sense.
+   * For printable chars this is the char itself; for Enter, Tab, etc. it's
+   * undefined. Widgets use this to decide whether to insert content vs.
+   * treat the key as a command.
+   */
+  text?: string;
+  ctrl: boolean;
+  alt: boolean;
+  shift: boolean;
+  meta: boolean;
+}
+/** Canonical modifier names used in `KeyPattern`. */
+type KeyModifier = "ctrl" | "alt" | "shift" | "meta";
+/**
+ * Named keys the decoder emits for non-printable keystrokes. Bindings
+ * reference these directly (`"enter"`, `"f5"`, `"pageup"`, …).
+ */
+type SpecialKeyName = (typeof specialKeys)[number];
+declare const KeyPatternBrand: unique symbol;
+/** A validated, canonical key binding string. */
+type KeyPattern = string & {
+  readonly [KeyPatternBrand]: true;
+};
+declare const specialKeys: readonly ["enter", "tab", "backspace", "delete", "space", "esc", "up", "down", "left", "right", "home", "end", "pageup", "pagedown", "insert", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12"];
+declare class KeyPatternError extends Error {
+  constructor(pattern: string, reason: string);
+}
+declare function isKeyPattern(s: string): s is KeyPattern;
+/**
+ * Canonical string form of a pattern or event — modifiers in a fixed
+ * alphabetical order, then the key name, joined by `-`. Used by the
+ * router to build a pattern index whose keys match regardless of how
+ * the user spelled the modifier order (`"ctrl-shift-a"` and
+ * `"shift-ctrl-a"` both canonicalize to `"ctrl-shift-a"`).
+ */
+declare function canonical(patternOrEvent: string | KeyEvent): KeyPattern;
+/**
+ * Test whether an event matches a pattern (or any of a list of patterns).
+ * Unspecified modifiers in the pattern must be *absent* on the event —
+ * matching is strict, not inclusive, so `"a"` only matches a bare `a`
+ * (no ctrl/alt/etc.).
+ */
+declare function keyMatches(ev: KeyEvent, pattern: string | readonly string[]): boolean;
+//#endregion
+//#region src/input/decoder.d.ts
+/**
+ * Decoder — bytes (as a string, after the caller UTF-8 decodes them) in,
+ * structured `InputEvent`s out. Holds partial state across `feed()` calls
+ * so split-chunk CSI / SS3 / paste sequences work transparently.
+ *
+ * ESC handling: a lone ESC byte is held as pending (because `ESC + <byte>`
+ * might be Alt+<key> or the start of a CSI sequence). Call `flush()` from
+ * an idle-timer tick to emit a bare `esc` event when no follow-up arrives.
+ */
+type MouseButton = "left" | "middle" | "right";
+type MouseEvent = {
+  type: "mouse";
+  x: number;
+  y: number;
+  alt: boolean;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+} & ({
+  kind: "scroll";
+  deltaY: number;
+} | {
+  kind: "down" | "drag" | "up";
+  button: MouseButton;
+  click?: 1 | 2 | 3;
+});
+type TerminalResponseEvent = {
+  type: "term-response";
+  kind: "csi";
+  sequence: string;
+  params: string;
+  final: string;
+} | {
+  type: "term-response";
+  kind: "osc" | "dcs" | "apc";
+  sequence: string;
+  payload: string;
+};
+type InputEvent = {
+  type: "key";
+  event: KeyEvent;
+} | {
+  type: "paste";
+  text: string;
+} | {
+  type: "focus";
+  gained: boolean;
+} | TerminalResponseEvent | MouseEvent;
+//#endregion
+//#region src/input/actions.d.ts
+/**
+ * Context handed to every action handler. Whether the action was
+ * fired by a key, programmatic dispatch, command palette, or a plugin,
+ * handlers see a uniform payload.
+ */
+type ActionCtx<T extends ArgsOpts = ArgsOpts, N = void> = {
+  /** The action id being dispatched. */
+  readonly id: string;
+  readonly node?: Node;
+  /** The node dispatch started from — typically the focused node for
+   *  key- or palette-triggered actions. `undefined` for purely
+   *  programmatic dispatch with no anchor. */
+  readonly target?: Node;
+  /** What triggered the dispatch. Open string for extensibility. */
+  readonly source: "key" | "programmatic" | (string & {});
+  /** When `source === "key"`, the originating routed key event. */
+  readonly key?: RoutedKey;
+  args?: ArgsResult<T>;
+} & (N extends Node ? {
+  /** The node whose `actions[id]` handler matched, or `undefined` when
+   *  the action was handled by a catalog-level `fn` (not tied to a
+   *  specific node). */
+  readonly node: N;
+} : {});
+type ActionFn<T extends ArgsOpts = ArgsOpts, N = void> = (ctx: ActionCtx<T, N>) => MaybePromise<unknown>;
+type KeyBinding = Omit<ActionDef, "fn" | "keys"> & {
+  id: string;
+  fn: ActionFn;
+  keys: string | readonly string[];
+};
+/**
+ * Metadata + default bindings for a single action. Used as catalog
+ * entries inside the `Actions` registry.
+ *
+ * - `desc` / `name`: human-facing copy for help screens, command palette.
+ * - `keys`: default key pattern(s). The registry builds the router's
+ *   keymap from these so apps don't have to wire bindings themselves.
+ * - `hidden`: omit from command palette enumeration.
+ * - `fn`: optional handler. When present, `dispatch(id)` calls it
+ *   directly (used for global/app actions that aren't anchored to a
+ *   widget instance). When absent, dispatch walks the focus chain
+ *   looking for a node with `actions[id]`.
+ */
+interface ActionDef<T extends ArgsOpts = ArgsOpts, N = void> {
+  cmd?: string;
+  desc?: string;
+  keys?: readonly string[];
+  hidden?: boolean;
+  args?: T;
+  source?: string;
+  fn?: ActionFn<T, N>;
+  /** Optional numeric priority for ordering in the command palette.
+   * Higher number is higher priority. Defaults to 0 */
+  priority?: number;
+}
+type Action<T extends ArgsOpts = ArgsOpts, N = void> = ActionDef<T, N> & {
+  id: string;
+};
+type ActionMap = Record<string, ActionDef>;
+type ActionFilter = {
+  cmd?: string;
+  id?: string | RegExp;
+  hidden?: boolean;
+  source?: string;
+  filter?: (info: Action) => boolean;
+};
+/** A single entry in a Node's `actions` dict.
+ *
+ *  Either a bare handler — the historical form, ideal for built-in
+ *  widgets whose metadata lives in `defaultActions` — or the full
+ *  `ActionInfo` shape (with a *required* `fn`). The object form lets
+ *  widget / plugin authors colocate desc + keys + impl in one place;
+ *  on mount, the metadata (everything except `fn`) is auto-registered
+ *  into `ctx.actions` with `extend: false`, so it contributes defaults
+ *  without clobbering anything the user already configured. */
+type NodeAction<T extends Node = Node> = ActionFn<ArgsOpts, T> | (ActionDef<ArgsOpts, T> & {
+  fn: ActionFn<ArgsOpts, T>;
+});
+/** Shape of a Node's `actions` dict — full action ids as keys. */
+type NodeActionMap<T extends Node = Node> = Record<string, NodeAction<T>>;
+type ActionEvents = {
+  change: {};
+};
+/**
+ * Runtime registry of action metadata + impls.
+ *
+ * `register(entries)` merges new `ActionInfo` objects into the catalog
+ * by id — passing `{ "x": { keys: [...] } }` updates only the `keys`
+ * field of `x`, preserving existing `fn`/`desc`. That lets docs,
+ * bindings, and impls be registered in separate calls / from different
+ * layers (bundled defaults, app-level overrides, plugin contributions).
+ *
+ * `dispatch(id, ctx)` runs the action:
+ *   - If the catalog entry has `fn`, it's called directly (global
+ *     actions).
+ *   - Otherwise, the focus chain is walked from `ctx.target` (default:
+ *     the router's focused node) up to the root, and the first node
+ *     with `actions[id]` handles it.
+ *
+ * `list()` returns the catalog for command palette / help enumeration.
+ */
+declare class Actions extends Emitter<ActionEvents> {
+  #private;
+  constructor(logger?: Logger);
+  /** Internal — the Renderer wires this after construction. */
+  setTargetResolver(fn: () => Node | undefined): void;
+  bind(binding: KeyBinding): () => void;
+  /**
+   * Register or merge catalog entries. Values are shallow-merged into
+   * existing entries by id.
+   *
+   * When `opts.default` is `true`, the new entry is merged *before* the
+   * existing one, so it provides defaults.
+   *
+   * When `opts.default` is `false` (the default), the new entry is merged
+   * *after* the existing one, so it overrides prior values.
+   *
+   * Returns an unregister function that rolls this call back.
+   */
+  register(actions: ActionMap | Action[], opts?: {
+    default?: boolean;
+  }): () => void;
+  /** Remove entries by id. */
+  delete(filter: string[] | ActionFilter): void;
+  get(id: string): Action | undefined;
+  list(opts?: ActionFilter): Action[];
+  find(opts?: ActionFilter): Action | undefined;
+  /**
+   * Fire the action `id`. Returns `true` if anything handled it.
+   *
+   * Order:
+   *   1. If the catalog entry has `fn`, call it with the full ctx.
+   *   2. Otherwise walk `target` → root and fire the first node's
+   *      `actions[id]`.
+   *   3. Return `false` if nothing consumed.
+   */
+  dispatch(id: string, ctx?: Partial<ActionCtx>): boolean;
+  dispatch(action: Action, ctx?: Partial<ActionCtx>): boolean;
+  dispatchKey(routed: RoutedKey, opts?: {
+    node?: boolean;
+    global?: boolean;
+  }): boolean;
+  whichKey(node: Node, opts?: {
+    filter?: ActionFilter;
+  }): (Action & {
+    keys: string[];
+  })[];
+}
+//#endregion
+//#region src/layout/size.d.ts
+/** Percentage string like `'50%'`, resolved against the parent's content axis. */
+type Pct = `${number}%`;
+/**
+ * Size along one axis.
+ *  - `number` — absolute cells
+ *  - `Pct` — percentage of the parent's content axis
+ *  - `'fill'` — take all of the remaining space in the flex allocation
+ *  - `'fit'`  — shrink to the content's natural size, capped at the
+ *               available axis. Mirrors CSS `fit-content`. Pairs nicely
+ *               with `'fill'` — `fill` grows, `fit` shrinks.
+ */
+type Size = number | Pct | "fill" | "fit";
+//#endregion
+//#region src/core/reactive.d.ts
+/** Run `fn` outside any tracking scope. Signal reads inside don't
+ *  subscribe the surrounding render, and async work started inside
+ *  (timers, promises, intervals) doesn't capture the current ctx —
+ *  callbacks fire with `getStore() === undefined`.
+ *
+ *  Use this when starting persistent async work from inside a render
+ *  pass: a `setInterval` set up during `_render` would otherwise
+ *  inherit the render's ALS context, and every timer tick would look
+ *  like it's "inside" that render — its invalidates would be silently
+ *  suppressed.
+ *
+ *  ```ts
+ *  // inside _render() or a render-driven reconcile():
+ *  untracked(() => {
+ *    this.#timer = setInterval(() => this.invalidate(), speed)
+ *  })
+ *  ```
+ *
+ *  Equivalent to Solid's `untrack`. */
+declare function untrack<T>(fn: () => T): T;
+/** Resolve a `Reactive<T>` to its current `T` without subscribing to
+ * any tracking context. */
+declare function peek<T>(s: Reactive<T>): T;
+/**
+ * Solid-style context for sharing values down the owner chain without
+ * prop-drilling. Widgets publish values via `provideContext` (in setup
+ * or `_render`); descendants read via `useContext`.
+ *
+ * ```ts
+ * const ThemeOverride = createContext<Theme | undefined>(undefined)
+ *
+ * // provider (in a widget body / setup / _render):
+ * provideContext(ThemeOverride, customTheme)
+ *
+ * // consumer (anywhere with an active node or owner chain):
+ * const theme = useContext(ThemeOverride) ?? defaultTheme
+ * ```
+ *
+ * Implementation: each `Node` carries an optional `#contexts` map keyed
+ * by context id. Lookups walk the *owner frame chain* (`OwnerFrame.owner`
+ * pointers), reading the live `#contexts` of each frame's node and
+ * falling back to the context's default if no ancestor provides it.
+ *
+ * The owner chain is the render-call ancestry captured at frame push
+ * (via `withActiveNode`) — independent of mount status. Effects/memos
+ * capture their creation frame and re-establish it on re-fire, so
+ * detached re-runs walk the same chain they would have at creation.
+ */
+interface Context<T> {
+  readonly id: symbol;
+  readonly defaultValue: T;
+}
+declare function createContext<T>(): Context<T | undefined>;
+declare function createContext<T>(defaultValue: T): Context<T>;
+/** Publish `value` for `ctx` on the active Owner. Persistent for the
+ *  Owner's lifetime. Descendants (in the render-call sense) that read
+ *  via `useContext` walk up the Owner chain and find it. */
+declare function provideContext<T>(ctx: Context<T>, value: T): void;
+/** Read the current value of `ctx`. Walks the Owner chain
+ *  (render-call ancestry, not mount tree). Returns the context's
+ *  default when no ancestor has provided a value. */
+declare function useContext<T>(ctx: Context<T>): T;
+/** Brand tag: every accessor / setter returned by `signal` / `memo`
+ *  carries this symbol so `unwrap` can tell a reactive source from a
+ *  plain function-valued prop (label formatter, text callback, etc.). */
+declare const REACTIVE: unique symbol;
+type Signal<T> = readonly [get: Accessor<T>, set: Setter<T>] & {
+  readonly get: Accessor<T>;
+  readonly set: Setter<T>;
+};
+/** A read-only reactive source. Branded so `isAccessor` can detect it
+ *  without false positives on arbitrary callables. */
+type Accessor<T> = (() => T) & {
+  readonly [REACTIVE]: "get";
+};
+/** A signal setter. Same branding as `Accessor` (different tag) so a
+ *  setter isn't mistaken for an accessor by `unwrap`. */
+type Setter<T> = ((next: T | ((prev: T) => T)) => void) & {
+  readonly [REACTIVE]: "set";
+};
+/** A widget prop that's either a literal value or a reactive accessor. */
+type Reactive<T> = T | Accessor<T>;
+/** Runtime check: `true` when `v` was produced by `signal` / `memo`.
+ *  False for plain callables (text-content functions, label formatters).
+ *
+ *  @internal */
+declare function isAccessor<T>(v: unknown): v is Accessor<T>;
+/** Resolve a `Reactive<T>` to its current `T`. Call inside `_render`
+ *  so accessor reads subscribe the rendering node. Only brand-tagged
+ *  accessors are invoked — other function values pass through
+ *  untouched, so widgets whose `T` is itself a function type (label
+ *  formatters etc.) don't need a hand-rolled guard. */
+declare function unwrap<T>(v: Reactive<T>): T;
+/**
+ * Reactive ownership scope — bundles cleanups + provided contexts
+ * scoped to a single widget body (or a `createRoot` headless scope).
+ *
+ * Owners form a chain via `parent` mirroring the call-time widget
+ * nesting: when `widget()` is invoked inside another widget's body,
+ * `createNode` creates the inner Owner with `parent =
+ * activeOwnerStore.getStore()` (the outer widget's Owner). That chain
+ * is what `useContext` walks.
+ *
+ * Owners are **not** bound to Nodes anymore — a widget's `createNode`
+ * pairs the Owner with the constructed Node only through
+ * `Node.once("unmount", () => owner.dispose())`. Primitive Nodes
+ * (`text`, `box`, …) don't get their own Owner; they share whatever
+ * Owner created them.
+ *
+ * Use `onCleanup(cb)` to register cleanups against the active Owner.
+ * Disposing the Owner runs them in reverse-registration order.
+ *
+ * @internal
+ */
+declare class Owner {
+  #private;
+  parent?: Owner;
+  constructor(parent?: Owner);
+  get disposed(): boolean;
+  /** Live view of this Owner's provided contexts. Populated by
+   *  `provideContext`. Walked upward via `parent` by `useContext`. */
+  get contexts(): ReadonlyMap<symbol, unknown> | undefined;
+  setContext(id: symbol, value: unknown): void;
+  /** Register a cleanup. Runs on `dispose()`. */
+  addCleanup(fn: () => void): void;
+  /** Fire cleanups in reverse-registration order. Idempotent. */
+  dispose(): void;
+}
+/** Run `fn` as the `node`'s render pass. Signal reads inside subscribe
+ *  the node's tracking ctx; the ctx's `notify` is `node.invalidate`,
+ *  so any signal write that this render depended on invalidates the
+ *  node and clears its cache. Cleanups are registered against the
+ *  Node's `unmount` event.
+ *
+ *  Does **not** push an Owner — primitive Nodes share whatever Owner
+ *  was active in their caller. Widget bodies install their own Owner
+ *  via `createNode` at construction time, which is when `useContext`
+ *  / `provideContext` / `effect` / `memo` care about the active scope.
+ *
+ *  @internal */
+declare function withActiveNode<T>(node: Node, fn: () => T): T;
+/** Run `fn` with a pre-existing Owner restored. Used by `effect` /
+ *  `memo` to re-establish their creation-time owner chain on re-fire,
+ *  so `useContext` walks the same ancestry regardless of whether the
+ *  re-fire was triggered from inside or outside a render.
+ *
+ *  @internal */
+declare function withOwner<T>(owner: Owner, fn: () => T): T;
+/** Create a fresh Owner scope and run `fn` inside it. Returns
+ *  whatever `fn` returns. The Owner's parent is whatever was active at
+ *  the call site (or `undefined` at module top).
+ *
+ *  The Owner is *not* auto-disposed — callers manage its lifetime via
+ *  the Owner returned alongside the result, or (more commonly) by
+ *  binding the Owner to a Node and disposing it on that Node's
+ *  unmount.
+ *
+ *  Typical use is via a surface's function-shape `add(fn)` API which
+ *  wraps this internally:
+ *
+ *  ```ts
+ *  ui.add(() => {
+ *    const [count, setCount] = signal(0)
+ *    onCleanup(() => console.log("gone"))
+ *    return text(() => `count: ${count()}`)
+ *  })
+ *  ```
+ *
+ *  For headless reactive scopes (tests, programmatic effects), call
+ *  `createRoot` directly:
+ *
+ *  ```ts
+ *  const { result, owner } = createRoot(() => signal(0))
+ *  // ... use result ...
+ *  owner.dispose()
+ *  ```
+ */
+declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+/** Run `fn` inside a fresh Owner scope and bind the returned Node to
+ *  that scope — when the Node unmounts, the Owner disposes (firing
+ *  every `onCleanup`, tearing down every `effect` / `memo` /
+ *  `createAsync` registered in the body).
+ *
+ *  This is what `widget()` calls under the hood: it's the per-instance
+ *  scope boundary. Surfaces also call it directly at their `add` /
+ *  `append` entry points so each appended subtree gets its own root.
+ *
+ *  ```ts
+ *  ui.add(() => {
+ *    const [c, setC] = signal(0)
+ *    onCleanup(() => clearInterval(timer))
+ *    const timer = setInterval(() => setC(x => x + 1), 1000)
+ *    return text(() => `count: ${c()}`)
+ *  })
+ *  ```
+ */
+declare function createNode<T extends Node>(fn: () => T): T;
+/** Register a cleanup against the active Owner. Fires when the Owner
+ *  disposes — i.e. when the widget body's `createNode` Node unmounts,
+ *  or when the surrounding `createRoot` is disposed.
+ *
+ *  ```ts
+ *  function widgetBody() {
+ *    const id = setInterval(() => tick(), 1000)
+ *    onCleanup(() => clearInterval(id))
+ *    return box(…)
+ *  }
+ *  ```
+ *
+ *  Throws if called outside any active Owner — the cleanup would
+ *  never fire and the caller is almost certainly mistaken. */
+declare function onCleanup(fn: () => void): void;
+/** Current Owner, or `undefined` outside any render. Captured by
+ *  effects/memos at creation time and restored on re-fire.
+ *
+ *  @internal */
+declare function useActiveOwner(): Owner | undefined;
+/** Whether we're currently executing inside `node`'s own render call
+ *  stack — i.e. this code path was reached synchronously (or via an
+ *  await preserved by `AsyncLocalStorage`) from `node`'s `withActiveNode`.
+ *
+ *  Used by `invalidate()` to suppress *internal* cascades — e.g.
+ *  Markdown mutating its child Text inside its own `_render`. External
+ *  mutations (network callbacks, event handlers) run outside any
+ *  render's ALS scope, so this returns `false` for them and they emit
+ *  normally even when a render is in flight.
+ *
+ *  @internal */
+declare function inRenderContextOf(node: Node): boolean;
+/**
+ * Reactive value. Returns a `[get, set]` tuple that's also accessible
+ * as `.get` / `.set` for destructure-skipping callers. Reads inside a
+ * tracking context (node render, effect, memo) auto-subscribe; writes
+ * notify every subscriber synchronously.
+ *
+ * ```ts
+ * const [count, setCount] = signal(0)
+ * setCount(1)               // value form
+ * setCount((prev) => prev + 1)  // updater form
+ * ```
+ *
+ * **Storing a function as a value — gotcha**: `set` interprets any
+ * function argument as the *updater* form `(prev) => next`, calls it
+ * with the current value, and stores the result. To store a function
+ * value (e.g. a callable `StyleBuilder` or a handler ref), wrap with
+ * the updater form so the call resolves to the function you wanted:
+ *
+ * ```ts
+ * const [style, setStyle] = signal<StyleBuilder | undefined>(undefined)
+ * setStyle(ctx.style)         // ✗ stored as `ctx.style(undefined)` — a string
+ * setStyle(() => ctx.style)   // ✓ stored as the StyleBuilder itself
+ * ```
+ *
+ * Same trap exists in Solid and React's `useState`. If you find
+ * yourself reaching for it, also consider whether storing a *plain*
+ * value (the underlying data, not the chain/builder) and recomputing
+ * the function-y derivative inside a `memo` is cleaner — usually it
+ * is.
+ *
+ * Equality is reference-based: `set(v)` where `v === current` skips
+ * the notify. Wrap mutable values you want to "publish" in a fresh
+ * object/array, or use a counter signal to force fan-out.
+ */
+declare function signal<T>(initial: T, opts?: {
+  equals?: false | ((prev: T, next: T) => boolean);
+}): Signal<T>;
+/**
+ * Lift a plain value to an `Accessor<T>`. The returned function always
+ * returns `value`, never tracks, never notifies — useful at the boundary
+ * where a static value enters a tree that otherwise expects `Accessor<T>`.
+ *
+ * Branded so `isAccessor` reports `true` and downstream `unwrap` calls
+ * resolve to a stable function call rather than treating the value as
+ * a ctx-aware thunk.
+ *
+ * ```ts
+ * // Component expects `Accessor<Theme>` deep in the tree:
+ * <CodeBlock theme={toAccessor(myStaticTheme)} />
+ * ```
+ */
+declare function toAccessor<T>(fn: () => T): Accessor<T>;
+/**
+ * Run `fn` immediately, then re-run whenever a signal it read writes.
+ * Returns a disposer that stops the effect and drops all tracked
+ * subscriptions. Unlike node render, effect dependencies are re-tracked
+ * from scratch on every run — reads that disappear from `fn` stop
+ * triggering re-runs.
+ *
+ * ```ts
+ * const dispose = effect(() => {
+ *   console.log("status is", status())
+ * })
+ * // ...
+ * dispose()
+ * ```
+ *
+ * **Footgun**: don't write a signal from inside an effect that reads
+ * the same signal — you'll loop. Writing unrelated signals is fine.
+ */
+declare function effect(fn: () => void | (() => void)): () => void;
+/**
+ * Derived, cached signal. `fn` runs once eagerly; the cached value is
+ * returned from the accessor. When any signal `fn` reads writes, the
+ * memo recomputes and notifies its own subscribers — but only if the
+ * new value differs from the cached one (reference equality).
+ *
+ * ```ts
+ * const [value, setValue] = signal(0)
+ * const pct = memo(() => Math.round(value() * 100))
+ * text(({ style }) => `${pct()}%`)   // subscribes to pct, not value
+ * ```
+ *
+ * Returns an `Accessor<T>`, not a `[read, write]` tuple — memos are
+ * read-only by construction.
+ */
+declare function memo<T>(fn: () => T): Accessor<T>;
+/**
+ * Reactive struct with fine-grained, lazy per-field tracking.
+ *
+ * Reads:
+ *   - `store.foo` — tracked when called inside a tracking ctx; allocates
+ *     a signal for `foo` on first read.
+ *
+ * Writes:
+ *   - `store.foo = x` — direct assignment.
+ *   - `store({ foo: x, bar: y })` — partial patch (merge).
+ *   - `store(current => ({ foo: current.foo + 1 }))` — updater form;
+ *     the function receives the current plain state (untracked) and
+ *     returns a partial patch which is then merged.
+ *
+ * All writes are value-equality (`===`) gated; setting a field to its
+ * current value is a no-op. The function-form updater receives the
+ * underlying state object directly so reads inside it are NOT tracked
+ * — exactly what an updater wants ("compute next from current").
+ *
+ * Spread (`{ ...store }`) yields the current values of every field via
+ * the proxy's `ownKeys` + `getOwnPropertyDescriptor` traps. Be aware:
+ * spreading inside a tracking ctx subscribes that ctx to every field
+ * (one signal allocation per field). Outside a tracking ctx, spread is
+ * cheap (no signal allocation).
+ *
+ * Implementation: an inner `state` object is the source of truth for
+ * plain reads / spreads / the updater's `current`. A `sigs` map is a
+ * lazy tracking layer; a key only gets a signal once it's read inside
+ * a tracking ctx. Writes update `state` and notify the signal *if it
+ * exists* — fields nobody subscribed to never allocate.
+ */
+type SignalStore<T extends object> = T & {
+  /** Apply a partial patch (merge), or call with an updater that
+   *  receives the current plain state (untracked) and returns a
+   *  partial to merge. Each field's signal short-circuits on value-
+   *  equality, so unchanged fields don't notify subscribers. */
+  set: (patch: Partial<T> | ((current: T) => Partial<T>)) => void;
+};
+declare function createStore<T extends object>(initial: T): SignalStore<T>;
+/**
+ * Suspense boundary handle — the value of `SuspenseContext`. Consumers
+ * (`createAsync`) call `increment` / `decrement` around in-flight work
+ * so providers (Stream's append, a `suspense()` widget) can observe
+ * "is anything pending below me".
+ *
+ * Boundaries chain: when a `suspense()` body installs its own boundary,
+ * its `parent` is the nearest ancestor boundary. Count flips at the
+ * 0→1 and 1→0 transitions propagate to the parent, so the outermost
+ * boundary's count is `> 0` iff *any* descendant has pending work —
+ * a single integer, no walks.
+ *
+ * `whenIdle` resolves when count returns to 0. Used by Stream to gate
+ * paint on resolved async; could be used by any other "wait for
+ * subtree to settle" caller.
+ */
+type SuspenseBoundary = {
+  increment: () => void;
+  decrement: () => void;
+  active: () => boolean;
+  whenIdle: () => Promise<void>;
+};
+/** Nearest Suspense provider in the Owner chain. `undefined` when no
+ *  boundary is installed — `createAsync` runs fire-and-forget in that
+ *  case (signal resolves later, normal invalidation re-renders). */
+declare const SuspenseContext: Context<SuspenseBoundary | undefined>;
+/**
+ * Build a boundary whose count flips propagate to `parent` on the 0→1
+ * and 1→0 transitions. Used by Stream's `append` and the `suspense()`
+ * widget. Internal-ish — most callers shouldn't construct boundaries
+ * directly.
+ *
+ * @internal
+ */
+declare function createSuspenseBoundary(parent?: SuspenseBoundary): SuspenseBoundary;
+/**
+ * Resource-style async accessor. `fn` reads signals (tracked); the
+ * effect re-fires when any of them change. Each run notifies the
+ * nearest `SuspenseContext` so a surrounding boundary (Stream's
+ * append, a `suspense()` widget) can observe pending work.
+ *
+ * ```ts
+ * const highlighted = createAsync(
+ *   async (prev) => highlight(unwrap(props.code)),
+ *   { initialValue: unwrap(props.code) },
+ * )
+ * text(highlighted)
+ * ```
+ *
+ * **Stale-write protection**: each run bumps a generation counter;
+ * late `.then` callbacks check it and skip `setValue` if a newer run
+ * has already fired. The boundary is decremented exactly once per
+ * increment (in the settle callback, regardless of staleness).
+ *
+ * **`prev`** is the previously resolved value (or `initialValue`) —
+ * useful for diff-based fetches. Reading it does *not* track, so
+ * resolving the new value won't re-fire the effect.
+ *
+ * **No active boundary** → increment/decrement no-op, work is
+ * fire-and-forget. Right for UI surface widgets that re-render
+ * cheaply on signal change. The Stream surface installs a boundary
+ * per appended subtree so committed-to-scrollback rows always reflect
+ * resolved values.
+ */
+declare function createAsync<T>(fn: (prev: T | undefined) => Promise<T>, opts: {
+  initialValue: T;
+}): Accessor<T>;
+declare function createAsync<T>(fn: (prev: T | undefined) => Promise<T>, opts?: {
+  initialValue?: T;
+}): Accessor<T | undefined>;
+type Progressive<T> = Accessor<T> & {
+  readonly loading: Accessor<boolean>;
+  whenIdle: () => Promise<void>;
+};
+declare function createProgressive<T>(fn: (ctx: {
+  signal: AbortSignal;
+  set: (value: T) => void;
+}) => MaybePromise<T>, opts: {
+  throttle?: number;
+  initialValue: T;
+}): Progressive<T>;
+declare function createProgressive<T>(fn: (ctx: {
+  signal: AbortSignal;
+  set: (value: T) => void;
+}) => MaybePromise<T>, opts: {
+  throttle?: number;
+  initialValue?: T;
+}): Progressive<T | undefined>;
+declare function createIterable<T>(fn: (ctx: {
+  signal: AbortSignal;
+}) => AsyncIterable<T | readonly T[]>, opts?: {
+  throttle?: number;
+  initialValue?: readonly T[];
+}): Progressive<readonly T[]>;
+interface Ref<T> {
+  (): T;
+  get value(): T | undefined;
+  set value(value: T);
+}
+declare function createRef<T>(value?: T, opts?: {
+  onSet?: (value: T, prev: T | undefined) => void | (() => void);
+}): Ref<T>;
+//#endregion
+//#region src/core/state.d.ts
+/**
+ * Fields every Node reads off its state. Widget state types should
+ * extend this (directly or transitively via `Style`, which extends
+ * `BaseState`) so the base behaviour wires up automatically.
+ *
+ *   - `visible: false` suppresses rendering with zero layout footprint.
+ *     Accepts a `Reactive<boolean>` — pass a signal accessor to toggle
+ *     visibility from shared state. `Node.render` unwraps it at render
+ *     time so the subscription goes through the usual tracking ctx.
+ */
+interface BaseState extends FlexState, LayoutState {
+  /** Sticky nodes stay at the bottom of the stream and don't scroll up with the rest of the content. */
+  sticky?: boolean;
+}
+type State<T extends object = object> = T & BaseState;
+/** Widget state mixin: `Style` (fg/bg/attrs) plus `BaseState`
+ *  (visibility + any future framework-level state fields). Widget state
+ *  interfaces extend this so base-state concerns and pure styling stay
+ *  cleanly separated at the type level without each widget having to
+ *  compose the two manually. */
+type StyleState = Style;
+interface LayoutState {
+  visible?: Reactive<boolean>;
+}
+/**
+ * Fields a flex-row child contributes to the allocator. Widget state
+ * types that want to participate in `flexDirection: "row"` layout
+ * (Box, Text, and anything else where per-child sizing makes sense)
+ * extend this interface.
+ *
+ * `allocateRow` reads these fields off each child's `state` — having
+ * them in one shared shape means widgets opt in explicitly without
+ * Box's row code needing per-widget casts.
+ */
+interface FlexState {
+  /** Requested width. `"fill"` requests whatever remains after fixed
+   *  children; a number requests exactly that many columns. */
+  width?: Size;
+  /** Floor for allocated width. Combined with the node's intrinsic
+   *  `Layout.minWidth` — the larger of the two wins. */
+  minWidth?: Size;
+  /** Ceiling for allocated width. */
+  maxWidth?: Size;
+  /** Weight used to distribute remaining space. Higher weight = more
+   *  growth. Unset children default to weight 1 if requested `"fill"`. */
+  flexGrow?: number;
+  /** Weight used to distribute the deficit when sibling bases exceed
+   *  available width. Higher weight shrinks more aggressively. Defaults
+   *  to `1` (CSS `flex-shrink`). Set to `0` to opt out of shrinking. */
+  flexShrink?: number;
+}
+interface Layout {
+  width: number;
+  minWidth: number;
+}
+//#endregion
+//#region src/layout/border.d.ts
+/**
+ * Border-character glyphs for drawing a box outline. Any single-cell string
+ * is allowed (including multi-byte glyphs like rounded corners).
+ */
+interface BorderChars {
+  h: string;
+  v: string;
+  tl: string;
+  tr: string;
+  bl: string;
+  br: string;
+}
+type BorderSpec = boolean | "single" | "double" | "rounded" | BorderChars;
+type TitleAlign = "left" | "center" | "right";
+//#endregion
+//#region src/widgets/text.d.ts
+/**
+ * Text content — three forms, resolved at render time:
+ *
+ *   1. Plain string — static content.
+ *   2. Reactive accessor (`signal()` / `memo()`) — re-reads on each
+ *      render and subscribes the node so signal writes invalidate.
+ *   3. `(ctx) => string` — computed from the render context. Use this
+ *      for inline-styled spans via `ctx.style`.
+ *
+ * Branded accessors are picked up via `isAccessor`; any other function
+ * is treated as the ctx-aware form. Plain strings pass through.
+ *
+ * ```ts
+ * text("hello")
+ * text(name)                                  // signal accessor
+ * text(({ style }) => style.ok(`✓ ${count}`)) // ctx-aware
+ * ```
+ */
+type TextContent = Reactive<string> | ((ctx: RenderCtx) => MaybePromise<Reactive<string>>);
+interface TextStyle extends Style {
+  content: TextContent;
+  wrap?: "word" | "char" | "none";
+}
+declare class Text extends Node<TextStyle> {
+  protected _render(ctx: RenderCtx): Promise<string[]>;
+  layout(ctx: RenderCtx): Promise<Layout>;
+}
+declare function textContent(content: TextContent, ctx: RenderCtx): Promise<string>;
+declare function textContent(content: TextContent | undefined, ctx: RenderCtx): Promise<undefined>;
+/**
+ * Factory for `Text`. Content can be a plain string or a `(ctx) => string`
+ * function that's called at render time — use the function form when you
+ * want inline-styled spans via `ctx.style`.
+ *
+ * ```ts
+ * text("hello")
+ * text("hello", { fg: "primary", bold: true })
+ * text({ content: "hello", fg: "primary" })
+ * text(({ style }) => `ok: ${style.ok("yes")}`)
+ * ```
+ */
+declare function text(content: TextContent, style?: Omit<State<TextStyle>, "content">): Text;
+declare function text(style: State<TextStyle>): Text;
+//#endregion
+//#region src/widgets/box.d.ts
+type Padding = number | readonly [v: number, h: number] | readonly [t: number, r: number, b: number, l: number];
+interface BoxStyle extends Style {
+  flexDirection?: "row" | "column";
+  gap?: number;
+  /** Fixed outer height in rows. When unset, the box's height emerges
+   *  naturally from its content + padding + border. When set, the
+   *  content area is truncated or padded with blank rows to land at
+   *  exactly this many rows of *outer* height. Pair with
+   *  `verticalAlign` to control which edge is anchored. */
+  height?: number;
+  /** Anchor for the content when `height` truncates or extends.
+   *  `"top"` (default) keeps the top edge: extra rows added at the
+   *  bottom, overflow truncated from the bottom. `"bottom"` keeps the
+   *  bottom edge: extra rows prepended, overflow truncated from the
+   *  top. Other CSS-like values (`middle`) are not implemented. */
+  verticalAlign?: "top" | "bottom";
+  padding?: Padding;
+  border?: BorderSpec;
+  borderTitle?: TextContent;
+  /** Placement of `borderTitle` along the top border. Defaults to `"left"`. */
+  borderTitleAlign?: TitleAlign;
+  /**
+   * Style applied to the border glyphs. Either a theme slot name (resolved
+   * via the active theme) or an inline `Style`. Defaults to the `"border"`
+   * theme slot when a border is drawn.
+   */
+  borderStyle?: string | Style;
+  /**
+   * Style applied to the border title. Defaults to the `"borderTitle"` theme
+   * slot when a title is set.
+   */
+  borderTitleStyle?: string | Style;
+}
+declare class Box<T extends object = {}> extends Node<BoxStyle & T> {
+  #private;
+  protected _render(ctx: RenderCtx): Promise<string[]>;
+  /**
+   * Intrinsic content width derived from children (or the explicit
+   * `width` when fixed). Lets parent flex containers size this Box
+   * without falling back to a measure-render — important for
+   * side-effecting children like `Image` whose first render allocates
+   * a KGP placement: rendering twice would emit two placements and the
+   * second render's `transmitOnce` returns no bytes, so the bytes from
+   * the discarded measure pass would be lost.
+   *
+   * Row direction → bases sum (plus gaps). Column direction → bases
+   * max. Both add chrome (padding + border) at the end.
+   *
+   * Children without `layout()` contribute 0 — the row allocator's
+   * render-measure fallback still kicks in for them at allocation
+   * time, but their absence here just means this Box reports a
+   * smaller intrinsic. That's the safe direction: under-report and
+   * let shrink/grow handle slack, never over-report.
+   */
+  layout(ctx: RenderCtx): Promise<{
+    minWidth: number;
+    width: number;
+  }>;
+}
+type Child = Node | false | null | undefined;
+/**
+ * Factory for `Box`. The style object is required (use `{}` if you don't
+ * need any styling) — the previous style-less overload caused TS to fail
+ * to discriminate between a Node child and an inferred-empty-state node
+ * like `WidgetNode`. Pass `box({}, child1, child2)` for un-styled boxes.
+ *
+ * Falsy children (`false`, `null`, `undefined`) are filtered out, enabling
+ * conditional JSX-like composition: `box({}, cond && child)`.
+ */
+declare function box(style: State<BoxStyle>, ...children: Child[]): Box;
+//#endregion
+//#region src/widgets/overlay.d.ts
+interface OverlayState {
+  /** Absolute column (1-based) of the overlay's left edge. */
+  x: number;
+  /** Absolute row (1-based) of the overlay's top edge. */
+  y: number;
+  /** Higher zIndex paints on top. Default: 0. */
+  zIndex?: number;
+  verticalAnchor?: "top" | "center" | "bottom";
+  horizontalAnchor?: "left" | "center" | "right";
+  relative?: "screen" | "ui" | "stream";
+  /** If true, the overlay will be automatically removed from the renderer when closed.
+   * When false, the overlay will remain in the renderer but will be hidden.
+   * Default: true. */
+  removeOnClose?: boolean;
+}
+type OverlayEvents = {
+  close: {};
+};
+type Overlay<T extends Node[] = Node[]> = Box<OverlayState> & {
+  children: T;
+} & Emitter<OverlayEvents>;
+declare function overlay<T extends Node[] = Node[]>(state: State<OverlayState & BoxStyle>, ...children: T): Overlay<T>;
+//#endregion
+//#region src/core/ctx.d.ts
+/**
+ * Passed to every `render(ctx)` call. Width flows in; height emerges from
+ * the returned row count. Theme is ambient — children share the parent's.
+ *
+ * `style` is a theme-bound chainable builder made available to components so
+ * they can produce inline-styled strings without re-binding the theme.
+ *
+ * `version` is a monotonic cache-key bumped by the `Renderer` whenever any
+ * identity-relevant ctx field changes (resize, theme swap). Node caches
+ * compare this integer — no hashing, no string keys.
+ */
+interface RenderCtx {
+  width: number;
+  style: StyleBuilder;
+  version: number;
+  /** Queue a side-channel ANSI payload (e.g. KGP image transmit) for
+   *  the renderer to flush before the next paint. Use this to keep
+   *  side-effecting bytes out of cached row strings — what `_render`
+   *  returns should be safe to reuse across paints, and transmit
+   *  bytes shouldn't be. */
+  readonly transmit: (seq: string) => void;
+}
+/**
+ * Context handed to a node when it mounts onto a surface. Gives widget
+ * authors a scoped handle to the services they legitimately need —
+ * focus, overlays, tree lookups, out-of-band repaints — without
+ * exposing the full Renderer.
+ *
+ * MountCtx is *per-lifetime*: set once when `mount()` is called and
+ * cleared on `unmount()`. Distinct from `RenderCtx` (per-tick, carries
+ * width/theme/version). If a node moves between surfaces, it receives
+ * a fresh MountCtx via the subsequent `mount()` call.
+ */
+interface MountCtx {
+  /** Which surface owns this subtree. */
+  readonly surface: SurfaceType;
+  /** Overlay capabilities — open/close an Overlay node from inside a
+   *  widget (e.g. a confirm dialog, autocomplete popover, tooltip). */
+  readonly overlay: {
+    readonly add: (o: () => Overlay) => void;
+    readonly remove: (o: Overlay) => void;
+  };
+  /** Input capabilities — a narrow slice of the router. We deliberately
+   *  don't expose the full `InputRouter`: `setKeymap` / `dispatch` are
+   *  app-level concerns. Widgets legitimately need to install direct
+   *  global key bindings (autocomplete) and move focus. */
+  readonly input: {
+    readonly terminalFocus: boolean;
+    readonly events: Emitter<InputRouterEvents>;
+    readonly bind: Actions["bind"];
+    /** Move focus to `node`. Mirrors `router.focus(node)`. */
+    readonly focus: (node: Node) => void;
+    /** Clear focus. */
+    readonly blur: (node: Node) => void;
+    readonly queries: TerminalQueries;
+  };
+  /** Action registry — widgets and plugins can `register` catalog
+   *  entries (with desc + default keys + optional `fn`) and `dispatch`
+   *  actions by id. The Router feeds key-triggered dispatches through
+   *  here; programmatic callers do the same. */
+  readonly actions: Actions;
+  /** Look up a node anywhere in the tree by its `id`. First match
+   *  wins; `undefined` when nothing matches. Same semantics as
+   *  `Renderer.getNode`. */
+  readonly getNode: (id: string) => Node | undefined;
+  /** Find every node matching a predicate. Strings match `node.type`;
+   *  pass a function for richer predicates. Same semantics as
+   *  `Renderer.findNode`. */
+  readonly findNode: (match: string | ((n: Node) => boolean)) => Node[];
+  logger: Logger;
+}
+//#endregion
+//#region src/widgets/log.d.ts
+type LogStyle = "badge" | "icon" | "prompt" | "title" | "text" | "notif";
+interface LogState {
+  level: LogLevel;
+  content: TextContent;
+  title?: string;
+  /** Rendering of the per-level prefix chunk. Defaults by level. */
+  style?: LogStyle;
+  /** Single-glyph icon for `icon` / `prompt` styles. */
+  icon?: string;
+  /** Theme slot or color name used to tint the prefix. */
+  color?: Color;
+  /** Extra plain text prepended to the auto prefix (unstyled). */
+  prefix?: string;
+  /** Theme slot or color name for the body text. Defaults by level, except */
+  textColor?: Color;
+  markdown?: boolean;
+}
+/**
+ * A single log entry — level-styled prefix (icon / badge / prompt / title /
+ * plain text) followed by the body content. The body can be any Node, so
+ * callers can stack markdown, code, images, etc. inside a log line.
+ *
+ * ```ts
+ * log({ level: "info", content: "hello" })
+ * log({ level: "error", content: markdown("**boom**") })
+ * ```
+ */
+declare const log: (state: State<LogState>, ...children: Node[]) => Box<{}>;
+//#endregion
+//#region src/services/logger.d.ts
+/** Minimal stream surface the logger needs. Stream satisfies this. */
+interface LoggerStream {
+  append: (node: () => Node) => unknown;
+}
+type LogEntryFactory = (level: LogLevel, msg: unknown[]) => Node;
+type LogStyleOverride = Omit<LogState, "level" | "content">;
+interface TuiReporterOpts extends InspectOpts {
+  /** Render string messages as markdown when they look like it.
+   *  Default: `true`. */
+  markdown?: boolean;
+  /** Per-level overrides for the default `log()` widget style fields. */
+  styles?: Partial<Record<LogLevel, LogStyleOverride>>;
+  /** Override the node produced per entry. Default uses `log()`. */
+  factory?: LogEntryFactory;
+  wrap?: (node: Node) => Node;
+  /** Fallback writer for when no stream is attached. Defaults to
+   *  `process.stdout/stderr`. Injectable for tests. */
+  write?: (text: string, kind: "stdout" | "stderr") => void;
+}
+declare class TuiReporter implements LogReporter {
+  #private;
+  constructor(opts?: TuiReporterOpts);
+  attach(stream: LoggerStream): this;
+  detach(): this;
+  $log({ level, msg }: LogEntry): void;
+}
+//#endregion
+//#region src/renderer/terminal.d.ts
+/**
+ * Terminal primitive — owns stdin raw mode, stdout writes, and the
+ * standard set of control modes we flip for a direct-mode renderer:
+ * hide cursor, DECAWM off, DECSTBM scroll region, synchronized output.
+ *
+ * No rendering logic lives here; upstream surfaces (stream, ui) push
+ * escape sequences through the helpers exposed below.
+ */
+interface TerminalWriter {
+  readonly columns: number;
+  readonly rows: number;
+  readonly isTTY?: boolean;
+  write: (s: string) => boolean | void;
+}
+interface TerminalReader {
+  readonly isTTY?: boolean;
+  setRawMode?: (mode: boolean) => void;
+  ref?: () => void;
+  unref?: () => void;
+  on: (event: string, listener: (...args: unknown[]) => void) => void;
+  off: (event: string, listener: (...args: unknown[]) => void) => void;
+  resume?: () => void;
+  pause?: () => void;
+}
+interface TerminalOpts {
+  stdin?: TerminalReader;
+  stdout?: TerminalWriter;
+  /** Rows reserved at the bottom for a sticky footer (UI surface). */
+  reserveBottom?: number;
+  /** Register SIGINT/SIGTERM/process.exit handlers. Disable for tests. */
+  hookSignals?: boolean;
+  /** Enable alternate screen buffer. */
+  altScreen?: boolean;
+  /** Enable SGR mouse reporting. */
+  mouse?: boolean;
+}
+type ResizeListener = (cols: number, rows: number) => void;
+/** @internal */
+declare class Terminal {
+  #private;
+  constructor(opts?: TerminalOpts);
+  /** Current terminal columns (number of cells wide). */
+  get cols(): number;
+  /** Current terminal rows (number of cells tall). */
+  get rows(): number;
+  /** Rows reserved at the bottom for the footer. */
+  get reserveBottom(): number;
+  /** Bottom row of the scroll region (1-based, inclusive). */
+  get scrollBottom(): number;
+  /** Top row of the footer (1-based, inclusive). 0 when no footer. */
+  get footerTop(): number;
+  get altScreen(): boolean;
+  get mouse(): boolean;
+  set mouse(mouse: boolean);
+  /**
+   * Install control-mode state: hide cursor, DECAWM off, DECSTBM scroll
+   * region, stdin raw mode, SIGWINCH + SIGINT/SIGTERM hooks.
+   */
+  start(): void;
+  deleteImages(opts?: {
+    data?: boolean;
+  }): void;
+  /** Restore terminal modes, detach listeners. Idempotent. */
+  stop(): void;
+  /** Set terminal/window progress when supported (OSC 9;4).
+   *
+   * - omitted / `"inactive"`: clear progress
+   * - `"loading"`: indeterminate progress
+   * - `"progress"`: determinate progress percentage, clamped to `0..100`
+   * - `"error"` / `"paused"`: terminal-specific error/paused states with optional percentage
+   */
+  setProgress(state: "progress", value: number): void;
+  setProgress(state: "error" | "paused", value?: number): void;
+  setProgress(state?: "inactive" | "loading"): void;
+  /** Change the bottom reservation and re-apply the scroll region. */
+  setReserveBottom(rows: number): void;
+  /** Low-level write. Use escape helpers + this to emit sequences. */
+  write(s: string): void;
+  /** Queue a side-channel ANSI payload (KGP transmit, etc.) for the
+   *  next `flushTransmits()`. No-op for empty strings. */
+  enqueueTransmit(seq: string): void;
+  /** Drain the transmit queue. Called by the renderer at the start of
+   *  each paint, before frame composition. Idempotent when empty. */
+  flushTransmits(): void;
+  /** Absolute cursor move (1-based). */
+  moveTo(row: number, col?: number): string;
+  /** Erase the entire line the cursor is on. */
+  clearLine(): string;
+  /** Clear from cursor to end of screen. */
+  clearBelow(): string;
+  /** Scroll the scroll region up by `n` rows (SU). Top rows enter scrollback. */
+  scrollUp(n: number): string;
+  /**
+   * Scroll the scroll region down by `n` rows (SD). Top `n` rows become
+   * blank, existing content shifts down, bottom `n` rows fall off the
+   * region (they don't move to scrollback — scrollback is a top-side
+   * concept; SD's displaced rows are simply lost).
+   */
+  scrollDown(n: number): string;
+  /** Delete `n` lines at the cursor, pulling content below upward (DL). */
+  deleteLines(n: number): string;
+  /** Set the scroll region (DECSTBM), 1-based inclusive. */
+  setScrollRegion(top: number, bottom: number): void;
+  /** Reset to the full-viewport scroll region. */
+  clearScrollRegion(): void;
+  /**
+   * Wrap a block of writes in begin/end-synchronized-update. Supporting
+   * terminals buffer the enclosed bytes and paint atomically — eliminates
+   * flicker on multi-row diff rewrites. Unsupported terminals ignore
+   * both escapes, so there's no downside.
+   */
+  sync(fn: () => void): void;
+  onResize(fn: ResizeListener): () => void;
+}
+//#endregion
+//#region src/renderer/frame.d.ts
+type FrameOp = (terminal: Terminal) => void;
+type LineSlice = {
+  from: number;
+  line: string;
+  to?: number;
+};
+declare class Frame {
+  #private;
+  readonly terminal: Terminal;
+  constructor(terminal: Terminal);
+  reset(rows?: number): void;
+  begin(): RenderFrame;
+  slice(row: number, from: number | undefined, to: number | undefined, width?: number): LineSlice | undefined;
+}
+declare class RenderFrame {
+  #private;
+  readonly terminal: Terminal;
+  readonly current: (string | undefined)[];
+  readonly base: (string | undefined)[];
+  constructor(terminal: Terminal, current: (string | undefined)[], base: (string | undefined)[]);
+  get(row: number): string;
+  set(row: number, content: string): void;
+  clear(row: number): void;
+  overlay(row: number, col: number, content: string): void;
+  slice(row: number, from: number | undefined, to: number | undefined, width?: number): LineSlice | undefined;
+  highlight(row: number, from: number | undefined, to: number | undefined, ctx: RenderCtx): LineSlice | undefined;
+  queue(op: FrameOp): void;
+  commitBase(): void;
+  flush(): void;
+  scrollUp(top: number, bottom: number, lines: number, op: FrameOp): void;
+  scrollDown(top: number, bottom: number, lines: number, op: FrameOp): void;
+  paint(): {
+    rows: number;
+    ops: number;
+  };
+}
+//#endregion
+//#region src/renderer/surface.d.ts
+/**
+ * Base event map for renderer surfaces. Surfaces usually schedule work
+ * through their owning `Renderer`; subclasses may extend this with their
+ * own surface-specific events.
+ *
+ * @internal
+ */
+type SurfaceEvents = {};
+type Point = {
+  row: number;
+  col: number;
+};
+/**
+ * Shared base for the three renderer surfaces (`Stream`, `UI`,
+ * `OverlaySurface`). Owns the common lifecycle and paint bookkeeping:
+ *
+ *   - `#running` flag and `#mountCtx` reference, driven by the Renderer
+ *     `start` / `stop` events. Subclasses read `mountCtx` to mount nodes
+ *     appended while the renderer is running.
+ *   - `#dirty`, set by `invalidate()`, means this surface has content or
+ *     state changes and schedules a frame.
+ * Concrete surfaces override `mountAll` / `unmountAll` to walk whichever
+ * node set they track, and `_render()` to compute rows and enqueue a paint
+ * closure into the renderer's atomic terminal sync.
+ *
+ * @internal
+ */
+declare abstract class Surface<E extends {} = never> extends Emitter<SurfaceEvents, E> {
+  #private;
+  abstract readonly type: SurfaceType;
+  $r: Renderer;
+  /** 1-based inclusive row bounds of this surface's content */
+  abstract bounds: {
+    top: number;
+    bottom: number;
+  };
+  constructor(renderer: Renderer);
+  /** Check if this surface contains the given screen position */
+  contains(point: Point): boolean;
+  get dirty(): boolean;
+  track(ev: string, inc?: number): void;
+  /** Mark this surface as changed and schedule a renderer frame. */
+  invalidate: () => void;
+  /** `true` between `onStart()` and `onStop()`. Subclasses read this
+   *  to decide whether an append should mount immediately or wait. */
+  protected get running(): boolean;
+  /** The MountCtx handed in by the Renderer on `start()`. Undefined
+   *  when the surface isn't running. Subclasses read this to mount
+   *  nodes appended while the renderer is up. */
+  protected get mountCtx(): MountCtx | undefined;
+  /** Mount every node this surface currently tracks under `ctx`.
+   *  Called by `onStart` after `#running` flips on. */
+  protected abstract mountAll(ctx: MountCtx): void;
+  /** Unmount every node this surface currently tracks. Called by
+   *  `onStop` before `#mountCtx` is cleared. */
+  protected abstract unmountAll(): void;
+  /** Every node this surface currently tracks, for renderer traversals. */
+  abstract get nodes(): readonly Node[];
+  /** Paint the surface into the renderer frame. Direct callers (tests) may
+   *  omit a frame; in that case a one-off frame is created and flushed. */
+  abstract _render(frame: RenderFrame): Promise<void>;
+  render(frame?: RenderFrame): Promise<void>;
+}
+//#endregion
+//#region src/renderer/overlay.d.ts
+type OverlayRenderState = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  zIndex: number;
+  node: Overlay;
+};
+type OverlaySurfaceEvents = {
+  "render-node": OverlayRenderState;
+};
+/**
+ * Overlay surface — paints absolute-positioned `Overlay` nodes on top
+ * of the stream and UI surfaces after each tick.
+ *
+ * Open/close is explicit. While an overlay is open, mutations on its
+ * state (or its subtree) bubble through `invalidate` → this surface's
+ * `dirty` → Renderer's scheduler, same as the other surfaces. On
+ * close, the covered area is overdrawn by asking the stream and UI
+ * to invalidate so the next flush repaints them in full.
+ *
+ * v1 is intentionally minimal:
+ *   - Overlays are painted top-to-bottom in z-order on every flush; we
+ *     don't track per-overlay dirty flags, just paint all active ones.
+ *   - No clipping against the viewport — callers are responsible for
+ *     sizing / positioning sensibly. The stream lives inside DECSTBM,
+ *     so overlays that touch row 0 can disrupt scrollback.
+ */
+declare class OverlaySurface extends Surface<OverlaySurfaceEvents> {
+  #private;
+  readonly type = "overlay";
+  get state(): readonly OverlayRenderState[];
+  get bounds(): {
+    top: number;
+    bottom: number;
+  };
+  get dirty(): boolean;
+  /** Active overlays in paint order (low → high z-index). */
+  get active(): readonly Overlay[];
+  /** Return the topmost overlay at the given `(row, col)`, if any. */
+  at({ row, col }: Point): OverlayRenderState | undefined;
+  contains(point: Point): boolean;
+  /** Register an overlay with the surface. Function form runs `fn`
+   *  inside a fresh Owner scope and adopts the returned Overlay. */
+  add<O extends Overlay>(overlay: () => O): O;
+  remove(overlay: Overlay): this;
+  open<T extends Overlay = Overlay>(overlay: () => T): T;
+  close(overlay: Overlay): this;
+  /** Every currently-open overlay node, for renderer traversals. */
+  get nodes(): readonly Node[];
+  protected mountAll(ctx: MountCtx): void;
+  protected unmountAll(): void;
+  /**
+   * Render pass: compute rows for each active overlay, then paint them
+   * at their absolute `(y, x)` inside the outer sync block. Matches the
+   * `render(sync?)` shape used by Stream and UI so the Renderer can
+   * capture all three paints and emit them in one atomic frame.
+   */
+  _render(frame: RenderFrame): Promise<void>;
+}
+//#endregion
+//#region src/renderer/selection.d.ts
+type SelectionSurface = "stream" | "screen";
+type Selection = {
+  dragging: boolean;
+  from: Point;
+  surface: SelectionSurface;
+  to: Point;
+};
+type SelectionEvents = {
+  change: {
+    selection?: Selection;
+    prev?: Selection;
+  };
+  selection: {
+    text: string;
+    selection: Selection;
+  };
+};
+declare class SelectionLayer extends Emitter<SelectionEvents> {
+  #private;
+  $r: Renderer;
+  constructor(renderer: Renderer);
+  get selection(): Selection | undefined;
+  set selection(value: Selection | undefined);
+  get text(): string | undefined;
+  set text(value: string);
+  invalidate(): void;
+  mouse(event: MouseEvent): boolean;
+  clear(): void;
+  select(screen: Point, what: "line" | "word"): void;
+  renderStream(frame: RenderFrame, ctx: RenderCtx): void;
+  renderScreen(frame: RenderFrame, ctx: RenderCtx): void;
+  render(frame: RenderFrame, ctx: RenderCtx): void;
+}
+//#endregion
+//#region src/renderer/stream.d.ts
+type StreamEvents = {
+  idle: void;
+  scroll: {
+    offset: number;
+    total: number;
+    below: number;
+  };
+};
+type StreamOptions = {
+  maxLive: number;
+  /** Baseline ("steady state") footer height in rows. The commit-to-
+   *  scrollback threshold uses `terminal.rows - fixedFooterHeight`
+   *  instead of `terminal.rows`. With this set to the natural footer
+   *  size (e.g. 2 for an input bar), scrollback is exactly contiguous
+   *  with the visible region in steady state — no rows hidden behind
+   *  the footer. Footer growth past this size (autocomplete) still
+   *  hides rows temporarily; they reappear when the footer returns
+   *  to baseline.
+   *
+   *  Default `0`: commit at full `terminal.rows` (old behavior).
+   */
+  fixedFooterHeight: number;
+};
+declare class Stream extends Surface<StreamEvents> {
+  #private;
+  readonly type = "stream";
+  constructor(renderer: Renderer, opts?: Partial<StreamOptions>);
+  get bounds(): {
+    top: number;
+    bottom: number;
+  };
+  get terminal(): Terminal;
+  /**
+   * Append `node` as the new live tail. The previous tail is frozen —
+   * it stops receiving re-renders even if its state mutates.
+   *
+   * Function form: `append(() => node)` runs the function inside a
+   * fresh Owner scope (so `signal` / `effect` / `onCleanup` /
+   * `provideContext` inside `fn` attach to that scope) and appends the
+   * returned Node. The Owner disposes when the Node unmounts.
+   */
+  append<N extends Node>(node: () => N): N;
+  /** How many rows the live region may occupy. */
+  get liveHeight(): number;
+  /** Tracked nodes (oldest first). Used by renderer traversals. */
+  get nodes(): readonly Node[];
+  waitIdle(): Promise<void>;
+  /**
+   * Rows currently painted in the live region, top-to-bottom. Bottom
+   * of the returned array aligns with `terminal.scrollBottom`. Exposed
+   * so the overlay surface can restore what it drew over.
+   */
+  get rows(): readonly string[];
+  getRow(row: number): string | undefined;
+  fromScreen(point: Point): Point | undefined;
+  toScreen(point: Point): Point | undefined;
+  emitScroll(): void;
+  scroll(lines?: number): Promise<void>;
+  scrollBottom(): Promise<void>;
+  scrollTop(): Promise<void>;
+  scrollUp(lines?: number): Promise<void>;
+  scrollDown(lines?: number): Promise<void>;
+  _render(frame: RenderFrame): Promise<void>;
+  get pending(): boolean;
+  get active(): boolean;
+  /**
+   * Terminal was resized. Forget only the paint mirror that mapped stream
+   * rows onto the old screen geometry. App scrollback and per-state commit
+   * boundaries are preserved; retained nodes re-render at the new width
+   * through Node.render()'s cache key.
+   *
+   * Paired with a screen-clear in the Renderer's resize handler — this
+   * method only resets our mirror of what's on screen; the actual wipe
+   * and re-establishment of DECSTBM lives in the terminal-level handler.
+   */
+  onResize(): void;
+  resetPaint(): void;
+  reset(opts?: {
+    keepNodes?: boolean;
+  }): void;
+  protected mountAll(ctx: MountCtx): void;
+  protected unmountAll(): void;
+}
+//#endregion
+//#region src/renderer/ui.d.ts
+/**
+ * UI surface — the sticky footer. Renders a single Box tree at the
+ * bottom of the terminal, inside the rows reserved by `Terminal`'s
+ * scroll region. Row-diff redraws: only changed rows are rewritten on
+ * each flush, so an input widget re-rendering every keystroke doesn't
+ * repaint the entire footer.
+ *
+ * Height is determined by the root's rendered row count, capped to a
+ * sensible upper bound so a runaway render can't take over the screen.
+ * When the height changes the terminal's reserved bottom gets updated,
+ * which rewrites `DECSTBM`; the stream surface then has less/more room
+ * and its next flush naturally fills the new geometry.
+ */
+declare class UI extends Surface {
+  #private;
+  readonly type = "ui";
+  constructor(renderer: Renderer);
+  /** The footer's root Box. Add children via `ui.root.add(child)`. */
+  get root(): Box;
+  get terminal(): Terminal;
+  /** Shortcut: add a child to the footer root. Same semantics as
+   *  `ui.root.add(child)`; returns `this` for chaining.
+   *
+   *  Function form: `add(() => box(…))` runs the function inside a
+   *  fresh Owner scope (so `signal` / `effect` / `onCleanup` /
+   *  `provideContext` inside `fn` attach to that scope) and adds the
+   *  returned Node. The Owner disposes when the Node unmounts. */
+  add<N extends Node>(child: () => N): N;
+  /** Current rendered height (rows). */
+  get height(): number;
+  /**
+   * The rows currently painted into the footer region, in order from the
+   * top of the reserved area downward. Exposed so the overlay surface
+   * can re-emit this content after it tears down, without re-rendering
+   * the tree.
+   */
+  get rows(): readonly string[];
+  /**
+   * Render the footer tree and paint the diff against the last paint.
+   * Updates the terminal's reservation whenever the height changes so
+   * the scroll region stays correctly sized.
+   *
+   * When called from `Renderer.render()`, a capture-style `sync` is
+   * provided so all surfaces paint inside one atomic sync frame. Direct
+   * callers (tests) omit it and get an immediate `terminal.sync`.
+   */
+  _render(frame: RenderFrame): Promise<void>;
+  /**
+   * Terminal was resized. Drop the painted-rows mirror so the next
+   * render's grow/shrink math treats the footer as if it's just
+   * appearing — correct after a screen clear, when the terminal no
+   * longer holds any footer bytes. The scroll region gets re-established
+   * through the normal `setReserveBottom` path inside `render()`.
+   */
+  onResize(): void;
+  /** UI's tracked node set is just the footer root. */
+  get nodes(): readonly Node[];
+  protected mountAll(ctx: MountCtx): void;
+  protected unmountAll(): void;
+  get bounds(): {
+    top: number;
+    bottom: number;
+  };
+}
+//#endregion
+//#region src/renderer/renderer.d.ts
+interface RendererOptions {
+  stdin?: TerminalReader;
+  stdout?: TerminalWriter;
+  images?: Reactive<boolean>;
+  theme?: Theme;
+  /** Baseline footer height in rows — the size the footer occupies in
+   *  "steady state" (no autocomplete, no transient widget growth).
+   *  Stream uses `terminal.rows - fixedFooterHeight` as its commit
+   *  threshold, so scrollback ends exactly at the visible region's top
+   *  edge whenever the footer is at this size. Default `0` (commit at
+   *  the full terminal — preserves pre-existing behavior). Set to
+   *  match your app's persistent footer (e.g. 2 for a single-line
+   *  input with a one-line border). */
+  fixedFooterHeight?: number;
+  /** Enable alternate screen buffer. Useful to test whether native
+   *  scrollback is competing with app-level scrolling. */
+  altScreen?: boolean;
+  /** Register SIGINT/SIGTERM cleanup (default: true). Disable in tests. */
+  hookSignals?: boolean;
+  logger?: Logger;
+  /** Enable terminal mouse reporting. Scroll events scroll the stream. */
+  mouse?: boolean;
+  reporter?: TuiReporterOpts;
+}
+type RenderEvents = {
+  start: {};
+  stop: {};
+  dirty: {};
+};
+type SurfaceType = "stream" | "ui" | "overlay";
+/** Visitor signature for `Renderer.walk`. Return `"stop"` to halt. */
+type NodeVisitor = (node: Node) => void | "stop";
+declare class RenderStats {
+  #private;
+  /** Increment a stat by `delta` (default: `1`). */
+  inc(stat: string, delta?: number): void;
+  set(stat: string, value: number): void;
+  get(): Record<string, number>;
+}
+/**
+ * Wires a `Terminal` primitive with the `Stream` and `UI` surfaces.
+ * Doesn't render anything until you either append to `renderer.stream`
+ * or add children to `renderer.ui.root`.
+ *
+ * ```ts
+ * const renderer = new Renderer()
+ * renderer.start()
+ * renderer.stream.append(text("hello"))
+ * renderer.ui.root.add(input({ placeholder: "> " }))
+ * // ... later
+ * renderer.stop()
+ * ```
+ */
+declare class Renderer extends Emitter<RenderEvents> {
+  #private;
+  readonly stream: Stream;
+  readonly ui: UI;
+  readonly overlay: OverlaySurface;
+  readonly selection: SelectionLayer;
+  readonly terminal: Terminal;
+  readonly input: InputRouter;
+  readonly frame: Frame;
+  /** Always-on logger, auto-attached to `this.stream`. Calling
+   *  `renderer.log("msg")` logs at `"log"` level; level methods
+   *  (`renderer.log.error(...)` etc.) are also available. */
+  readonly logger: Logger;
+  queries: TerminalQueries;
+  /** Runtime action registry (catalog + dispatcher). Populated with
+   *  `defaultActions` + `globalActions` at construction; apps extend
+   *  via `renderer.actions.register({ "app.foo": { ... } })`. */
+  readonly actions: Actions;
+  stats: RenderStats;
+  /** Global action impls. Merged into the `actions` catalog on
+   *  construction so the ids declared here gain their keys and desc
+   *  from `defaultActions`. Using `satisfies` (rather than an explicit
+   *  type annotation) keeps the literal keys so `BuiltinAction` can
+   *  pull them out. */
+  globalActions: {
+    "global.quit": {
+      fn: () => void;
+    };
+  };
+  constructor(opts?: RendererOptions);
+  /**
+   * Shared `RenderCtx` for the current tick. Built on demand and
+   * reused across every `Node.render(ctx)` call until the version
+   * bumps (resize, theme swap). Nodes compare `ctx.version` against
+   * their cached row's version — simple integer check, no hashing.
+   */
+  get ctx(): RenderCtx;
+  get rootOwner(): Owner;
+  get mouse(): boolean;
+  set mouse(mouse: boolean);
+  get debug(): boolean;
+  set debug(debug: boolean);
+  /** Whether the renderer is currently running. Surfaces use this to
+   *  decide whether a fresh append/open should immediately mount the
+   *  node or just queue it for the next `start()`. */
+  get running(): boolean;
+  /** Shortcut for `renderer.input.bind(pattern, handler)`. Returns an
+   *  unsubscribe function. Use for one-off app-level bindings where a
+   *  named action would be overkill. */
+  bind: Actions["bind"];
+  /** Swap the ambient theme. Widgets that read `theme()` / `style()`
+   *  from `useContext(RenderContext)` re-fire automatically; primitive
+   *  Nodes that compare cache against `ctx.version` need the version
+   *  bump that already happens elsewhere on theme-driven invalidation. */
+  set theme(theme: Theme);
+  /** Get the current theme. (tracked) */
+  get theme(): Theme;
+  start(): void;
+  stop(): void;
+  /** Look up a node by its `id`. Returns `undefined` if nothing matches. */
+  getNode(id: string): Node | undefined;
+  /**
+   * Find every node matching a predicate. When passed a string, it's
+   * interpreted as `node.type === string` — the common "find all
+   * Inputs" case. For anything richer, pass a function.
+   */
+  findNode(match: string | ((node: Node) => boolean)): Node[];
+  /**
+   * Walk every node in the combined stream + UI tree, depth-first,
+   * parents before children. Return `"stop"` from the visitor to halt.
+   */
+  walk(visit: NodeVisitor): void;
+  /** Build a MountCtx for a given surface. Each call creates a fresh
+   *  object but closes over the same underlying services, so nodes
+   *  across surfaces share a single overlay surface, router, etc. */
+  mountCtx(surface: SurfaceType): MountCtx;
+  /** Force a paint if dirty, and wait until the loop is idle. Useful
+   *  for tests and external "redraw and tell me when done" flows.
+   *  Concurrent callers share the same in-flight promise — no extra
+   *  paints are queued. */
+  render(): Promise<void>;
+}
+//#endregion
+//#region src/core/node.d.ts
+/** Minimum event map every node carries. Custom event maps intersect
+ *  this with their own events via `&`. */
+type BaseEvents = {
+  invalidate: {};
+  mount: {};
+  unmount: {};
+  focus: {};
+  blur: {};
+  show: {};
+  hide: {};
+  key: {
+    key: RoutedKey;
+  };
+  paste: {
+    paste: RoutedPaste;
+  };
+  childadded: {
+    child: Node;
+  };
+  childremoved: {
+    child: Node;
+  };
+};
+/**
+ * Public Node handle. Calling `render(ctx)` returns the node's rows from the
+ * per-node cache, recomputing only if state read inside `_render` has changed
+ * since the last call.
+ *
+ * Concrete subclasses implement the protected `_render(ctx)` hook; the public
+ * `render` is the caching wrapper around it.
+ *
+ * State is a `createStore` proxy: reads inside `_render` track per-field;
+ * mutating a read field invalidates this node. Three write forms:
+ *
+ *   - `n.state.field = value`               (direct assignment)
+ *   - `n.state.set({ field: value, ... })`  (patch — partial merge)
+ *   - `n.state.set(current => ({ ... }))`   (updater — receives untracked current)
+ *
+ * Writes through nested objects/arrays (`n.state.padding[0] = 1`) do NOT —
+ * reassign the whole field instead.
+ */
+declare abstract class Node<T extends object = object, E extends {} = {}> extends Emitter<BaseEvents, E> {
+  #private;
+  actions?: NodeActionMap;
+  type?: string;
+  protected layout?(ctx: RenderCtx): MaybePromise<Layout | undefined>;
+  constructor(state: State<T>, ...children: Node[]);
+  withEvents<Events extends {}>(): this & Emitter<Events>;
+  withActions<A extends NodeActionMap>(actions: A): this & {
+    actions: A;
+  };
+  action(id: keyof NonNullable<this["actions"]> & string, opts?: Partial<ActionCtx>): boolean;
+  get mountSignal(): AbortSignal;
+  get state(): SignalStore<T> & State<T>;
+  get children(): readonly Node[];
+  protected get logger(): import("@zaly/shared/logger").Logger<{
+    name: string;
+  } & Partial<{}> & {
+    id: string | undefined;
+    name: string;
+    node: string;
+  }> | undefined;
+  protected try<R>(fn: () => R): TryResult<R>;
+  /** Fragment protocol — opt-in. When defined, layout containers
+   *  (Box's row/column allocator) treat this node as a transparent
+   *  fragment and substitute the returned children for `this` during
+   *  flex allocation and rendering. The fragment Node still exists in
+   *  the tree (it's mounted; it bubbles invalidates from its
+   *  descendants), but layout sees through it.
+   *
+   *  Used by `show`, `errorBoundary`, `suspense`: their children carry
+   *  their own flex props through to the parent box, can share its
+   *  `gap`, and a row containing a `show` with multiple flex children
+   *  allocates per-leaf-slot rather than collapsing into one. */
+  protected layoutChildren?(): readonly Node[];
+  get parent(): Node | undefined;
+  /** Mount context when this node is attached to a surface — surface
+   *  identifier plus scoped handles to router / overlay / tree lookups.
+   *  `undefined` before mount and after unmount. Exposed so widget
+   *  authors can reach renderer services without closing over a ref. */
+  get ctx(): MountCtx | undefined;
+  get surface(): SurfaceType | undefined;
+  get mounted(): boolean;
+  /**
+   * Read or set the node's `id`. Called without args, returns the
+   * current id. Called with a string, sets it and returns `this` for
+   * chaining — useful when building trees inline:
+   *
+   * ```ts
+   * input({...}).id("chat-input").focus().on("submit", ...)
+   * ```
+   *
+   * The id is used by `ctx.getNode(id)` / `Renderer.getNode(id)` for
+   * tree lookups, and by the input router as a per-instance scope for
+   * keymap bindings (alongside the class-level `type`).
+   */
+  id(): string | undefined;
+  id(value: string): this;
+  getLayout(ctx: RenderCtx): Promise<Layout | undefined>;
+  get layoutNodes(): readonly Node[];
+  addActionTarget(node: Node): this;
+  removeActionTarget(node: Node): this;
+  get actionTargets(): Iterable<Node>;
+  invalidate(): this;
+  with<R>(fn: () => R): R;
+  render(ctx: RenderCtx): Promise<string[]>;
+  protected abstract _render(ctx: RenderCtx): Promise<string[]> | string[];
+  add(child: Node): this;
+  remove(child: Node): this;
+  splice(start: number, deleteCount: number, ...items: Node[]): this;
+  clear(): this;
+  mount(ctx: MountCtx): this;
+  unmount(): this;
+  /** Become the focused node. Routes through the MountCtx, which emits
+   *  `blur` on the previous focus and `focus` on this node.
+   *
+   *  When called before the node is mounted (the common case for
+   *  `input({ focus: true }).on(...)` style setup), the focus is
+   *  deferred until the next `mount` event. That keeps the API
+   *  synchronous and side-effect-free at build time — callers don't
+   *  have to think about ordering. */
+  focus(): this;
+  /** Release focus. No-op when not mounted. */
+  blur(): this;
+  get visible(): boolean;
+  show(): this;
+  hide(): this;
+  toggle(): this;
+  ref<N extends Node>(ref?: Ref<this extends N ? N : never>): this;
+  isVisible(): boolean;
+}
+/** Runtime type guard for Node.
+ *
+ * @internal*/
+declare function isNode(x: unknown): x is Node;
+//#endregion
+//#region src/input/router.d.ts
+type KeyPatterns = KeyPattern | readonly KeyPattern[];
+type KeyHandler = (ev: KeyEvent) => boolean | void;
+/** A keymap entry is either an action id (string) or a direct key
+ *  handler — the Router treats them as alternate branches on match.
+ *  Multiple entries can share the same key; dispatch tries each in
+ *  order until one consumes. */
+type KeymapEntry = string | KeyHandler;
+/**
+ * A routed keyboard event — the raw `KeyEvent` data plus a propagation
+ * control and a precomputed canonical `pattern`. Listeners call
+ * `.stop()` to consume the event; the router checks `.stopped` between
+ * parent-chain hops and halts bubbling.
+ */
+interface RoutedKey {
+  name: string;
+  text?: string;
+  ctrl: boolean;
+  alt: boolean;
+  shift: boolean;
+  meta: boolean;
+  /** Canonical pattern form (e.g. `"ctrl-a"`, `"shift-enter"`). Handy
+   *  for `switch(ev.pattern)` matching without calling `keyMatches`. */
+  pattern: string;
+  stopped: boolean;
+  stop: () => void;
+}
+/** A routed paste event — the pasted text + the same propagation control. */
+interface RoutedPaste {
+  text: string;
+  stopped: boolean;
+  stop: () => void;
+}
+type InputRouterEvents = {
+  "terminal-focus": {
+    gained: boolean;
+  };
+  key: {
+    event: KeyEvent;
+  };
+  mouse: {
+    event: MouseEvent;
+  };
+  "term-response": {
+    event: TerminalResponseEvent;
+  };
+  focus: {
+    node: Node;
+  };
+  blur: {
+    node: Node;
+  };
+};
+/**
+ * Routes decoder events to the right node and/or action.
+ *
+ * Dispatch priority for a key event (most-specific-first):
+ *
+ *   1. **Per-node `"key"` bubble** — focused node up to root. Each
+ *      node's `on("key")` / `bind()` handlers fire. Calling `.stop()`
+ *      ends dispatch. This is where local overrides live.
+ *   2. **Keymap lookup** — a single table built by the `Actions`
+ *      registry (`canonical pattern → action id | direct handler`).
+ *      Action ids are dispatched through `Actions.dispatch(id)`,
+ *      which walks the focus chain for `node.actions[id]` — or
+ *      calls a catalog-level `fn` if the action has one.
+ *   3. **Global `bind()` handlers** — a last-resort fallback for
+ *      ad-hoc app-level bindings registered via `router.bind(...)`.
+ *
+ * Paste events follow a simple emit-and-bubble path — no keymap.
+ */
+declare class InputRouter extends Emitter<InputRouterEvents> {
+  #private;
+  constructor(logger?: Logger);
+  /** Internal — wired by the Renderer at construction. */
+  setActions(actions: Actions): void;
+  /** Currently-focused node, or `undefined` when none. */
+  get focused(): Node | undefined;
+  /**
+   * Move focus to `node`. Emits `blur`
+   * on the previously-focused node and `focus` on the new one.
+   * Focusing the already-focused node is a no-op.
+   */
+  focus(node: Node): void;
+  /** Clear focus from `node`. Emits `blur` on the node and `focus`
+   * on the next-most-recently-focused node, if any. */
+  blur(node: Node): void;
+  get terminalFocus(): boolean;
+  /**
+   * Dispatch a decoder event. Returns `true` if consumed.
+   */
+  dispatch(ev: InputEvent): boolean;
+}
+//#endregion
+//#region src/input/queries.d.ts
+type TerminalQuery<T = TerminalResponseEvent> = TerminalQueryOpts & {
+  request: string;
+  match: (event: TerminalResponseEvent) => T | undefined;
+};
+type TerminalQueryOpts = {
+  timeout?: number;
+  wrap?: (seq: string) => string;
+};
+type TerminalQueryWriter = {
+  write: (seq: string) => void;
+};
+declare class TerminalQueries {
+  #private;
+  constructor(router: InputRouter, terminal: TerminalQueryWriter);
+  query<T>(query: TerminalQuery<T>): Promise<T | undefined>;
+  primaryDeviceAttributes(opts?: TerminalQueryOpts): Promise<(TerminalResponseEvent & {
+    attrs: number[];
+  }) | undefined>;
+  secondaryDeviceAttributes(opts?: TerminalQueryOpts): Promise<(TerminalResponseEvent & {
+    attrs: number[];
+  }) | undefined>;
+  xtVersion(opts?: TerminalQueryOpts): Promise<(TerminalResponseEvent & {
+    name: string;
+    version?: string;
+  }) | undefined>;
+}
+declare function parseAttrs(params: string): number[];
+//#endregion
+export { Context as $, LogState as A, useContext as At, Padding as B, Actions as Bt, OverlaySurface as C, peek as Ct, LoggerStream as D, untrack as Dt, LogStyleOverride as E, toAccessor as Et, Overlay as F, ActionCtx as Ft, text as G, KeyModifier as Gt, Text as H, NodeAction as Ht, OverlayState as I, ActionDef as It, Layout as J, SpecialKeyName as Jt, textContent as K, KeyPattern as Kt, overlay as L, ActionFilter as Lt, log as M, withOwner as Mt, MountCtx as N, Size as Nt, TuiReporter as O, unwrap as Ot, RenderCtx as P, Action as Pt, Accessor as Q, Box as R, ActionFn as Rt, Stream as S, onCleanup as St, LogEntryFactory as T, signal as Tt, TextContent as U, NodeActionMap as Ut, box as V, KeyBinding as Vt, TextStyle as W, KeyEvent as Wt, State as X, isKeyPattern as Xt, LayoutState as Y, canonical as Yt, StyleState as Z, keyMatches as Zt, RenderStats as _, createSuspenseBoundary as _t, InputRouter as a, Signal as at, SurfaceType as b, isAccessor as bt, KeyPatterns as c, SuspenseContext as ct, RoutedPaste as d, createIterable as dt, Owner as et, BaseEvents as f, createNode as ft, RenderEvents as g, createStore as gt, NodeVisitor as h, createRoot as ht, parseAttrs as i, Setter as it, LogStyle as j, withActiveNode as jt, TuiReporterOpts as k, useActiveOwner as kt, KeymapEntry as l, createAsync as lt, isNode as m, createRef as mt, TerminalQuery as n, Reactive as nt, InputRouterEvents as o, SignalStore as ot, Node as p, createProgressive as pt, FlexState as q, KeyPatternError as qt, TerminalQueryOpts as r, Ref as rt, KeyHandler as s, SuspenseBoundary as st, TerminalQueries as t, Progressive as tt, RoutedKey as u, createContext as ut, Renderer as v, effect as vt, Terminal as w, provideContext as wt, UI as x, memo as xt, RendererOptions as y, inRenderContextOf as yt, BoxStyle as z, ActionMap as zt };
+//# sourceMappingURL=queries-DH3bj74K.d.mts.map