@textui/core 0.1.0

package/src/types/animation.ts

@@ -0,0 +1,34 @@
+import type { Disposable } from './disposable.js';
+
+export type Easing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | ((t: number) => number);
+
+export interface TweenOptions {
+  from: number;
+  to: number;
+  durationMs: number;
+  easing?: Easing;
+  onUpdate(value: number): void;
+  onComplete?(): void;
+}
+
+export interface TickerOptions {
+  /** Frames per second. Clamped by the driver's global cap. */
+  fps?: number;
+  onTick(frame: number, elapsedMs: number): void;
+}
+
+/**
+ * One driver for every moving thing, so a global disable is one flag and a
+ * slow ssh link can drop the frame rate for all of it at once.
+ */
+export interface AnimationDriver extends Disposable {
+  enabled: boolean;
+  /** Global ceiling; individual tickers may ask for less. */
+  maxFps: number;
+  ticker(options: TickerOptions): Disposable;
+  tween(options: TweenOptions): Disposable;
+  /** Advance manually. The testing harness drives time with this. */
+  advance(ms: number): void;
+  /** True when animations are off - components render their final state. */
+  readonly disabled: boolean;
+}

package/src/types/app.ts

@@ -0,0 +1,149 @@
+import type { Disposable } from './disposable.js';
+import type { Size } from './geometry.js';
+import type { ReactiveStore, EventBus, ScopeName } from './store.js';
+import type { ComponentRegistry } from './component-registry.js';
+import type { CommandRegistry } from './command.js';
+import type { KeybindingRegistry } from './keybinding.js';
+import type { ThemeRegistry, ResolvedTheme, ThemeDefinition } from './theme.js';
+import type { ShellRegistry } from './shell.js';
+import type { LayoutRegistry, SurfaceRegistry, SurfaceName } from './surface.js';
+import type { ResourceRegistry } from './resource.js';
+import type { SyntaxRegistry } from './syntax.js';
+import type { ResourceAdapter } from './adapter.js';
+import type { Navigator } from './navigation.js';
+import type { LayerManager } from './layer.js';
+import type { FocusManager } from './focus.js';
+import type { WhenEngine } from './when.js';
+import type { I18n } from './i18n.js';
+import type { ServiceContainer } from './services.js';
+import type { AnimationDriver } from './animation.js';
+import type { ManifestAPI } from './manifest.js';
+import type { TerminalAdapter, TerminalSessionOptions } from './terminal.js';
+import type { TerminalCapabilities, CapabilityOverrides } from './capabilities.js';
+import type { ComponentNode } from './graph.js';
+import type { CellBuffer } from './cells.js';
+
+/**
+ * The application. Every registry hangs off it, and every registry is late
+ * binding, which is what lets a screen be data and a shell be swappable at
+ * runtime.
+ */
+export interface TextUIApp extends Disposable {
+  readonly components: ComponentRegistry;
+  readonly commands: CommandRegistry;
+  readonly keybindings: KeybindingRegistry;
+  readonly themes: ThemeRegistry;
+  readonly shells: ShellRegistry;
+  readonly layouts: LayoutRegistry;
+  readonly surfaces: SurfaceRegistry;
+  readonly resources: ResourceRegistry;
+  readonly syntax: SyntaxRegistry;
+  readonly screens: Navigator;
+  readonly layers: LayerManager;
+  readonly focus: FocusManager;
+  readonly store: ReactiveStore;
+  readonly events: EventBus;
+  readonly when: WhenEngine;
+  readonly i18n: I18n;
+  readonly services: ServiceContainer;
+  readonly animation: AnimationDriver;
+  readonly manifest: ManifestAPI;
+  readonly terminal: TerminalAdapter;
+
+  readonly capabilities: TerminalCapabilities;
+  readonly theme: ResolvedTheme;
+  readonly size: Size;
+  readonly running: boolean;
+
+  setTheme(id: string): void;
+  setShell(id: string): void;
+  activeShell(): string;
+  setCapabilityOverrides(overrides: CapabilityOverrides): void;
+
+  /** Acquire the terminal and start the render loop. */
+  /** Swap the root node for another one, and redraw. */
+  setRoot(node: ComponentNode): void;
+
+  start(): Promise<void>;
+  /** Release exactly what was acquired, then stop. */
+  stop(): Promise<void>;
+  /** Force a frame now, outside the scheduler. Tests and screenshots use it. */
+  flush(): void;
+  /** The last painted frame. */
+  buffer(): CellBuffer;
+
+  /**
+   * Register a resource type whole: kinds, provider, viewers, highlighter,
+   * actions, commands. Disposing removes exactly what was added.
+   */
+  registerAdapter(adapter: ResourceAdapter): Disposable;
+
+  open: SurfaceRegistry['open'];
+  openResource: SurfaceRegistry['openResource'];
+  execute: CommandRegistry['execute'];
+
+  /** Every mounted node's tree, for the inspector and the test harness. */
+  inspect(): InspectorNode | null;
+
+  /**
+   * Frame statistics. `runs` is how many terminal writes the last frame cost,
+   * which is the number that tells you whether the diff is doing its job.
+   */
+  stats(): { renders: number; runs: number; instances: number };
+}
+
+export interface InspectorNode {
+  id: string;
+  component: string;
+  key?: string | number;
+  rect?: { x: number; y: number; width: number; height: number };
+  props: Record<string, unknown>;
+  role?: string;
+  label?: string;
+  text?: string;
+  focusable?: boolean;
+  focused?: boolean;
+  /** Why the last render happened, when diagnostics are on. */
+  renderReason?: string;
+  bindings?: string[];
+  children: InspectorNode[];
+}
+
+export interface CreateAppOptions {
+  terminal?: TerminalAdapter;
+  session?: TerminalSessionOptions;
+  theme?: string;
+  themes?: ThemeDefinition[];
+  shell?: string;
+  /**
+   * The root node, when the app is not using screens.
+   *
+   * It is mounted into the `main` surface at boot, so the shell still frames
+   * it: the canvas is painted, the status surface and toast host exist, and
+   * `setShell` means something. It is an alternative to screens, not to the
+   * shell.
+   */
+  root?: ComponentNode;
+  capabilityOverrides?: CapabilityOverrides;
+  locale?: string;
+  /**
+   * Register everything the app needs. Runs once at boot, before the first
+   * render.
+   *
+   * A `Disposable` may be returned and the app disposes it on `stop()`, which
+   * is what makes `onBoot: registerBuiltins` the whole call rather than
+   * `onBoot: (app) => void registerBuiltins(app)`. Everything that registers
+   * hands back a disposable already; requiring `void` meant the shortest
+   * correct form was a cast of one away.
+   */
+  onBoot?(app: TextUIApp): void | Disposable | Promise<void | Disposable>;
+  /** Off disables every animation globally. */
+  animations?: boolean;
+  maxFps?: number;
+  /** Scopes cleared when `stop()` runs. */
+  clearOnStop?: ScopeName[];
+  /** Surfaces this app uses; others never mount. */
+  surfaces?: SurfaceName[];
+  /** Render diagnostics into `$/modus/diagnostics/*`. */
+  diagnostics?: boolean;
+}

package/src/types/async.ts

@@ -0,0 +1,35 @@
+import type { Disposable } from './disposable.js';
+
+export type TaskStatus = 'idle' | 'running' | 'success' | 'error' | 'cancelled';
+
+export interface TaskState<T = unknown> {
+  status: TaskStatus;
+  data?: T;
+  error?: unknown;
+  /** 0..1 when the task reports it, undefined when indeterminate. */
+  progress?: number;
+  /** Free-text step description, for a progress line. */
+  step?: string;
+  startedAt?: number;
+  finishedAt?: number;
+}
+
+export interface TaskController<T = unknown> {
+  readonly state: TaskState<T>;
+  run(...args: unknown[]): Promise<T | undefined>;
+  cancel(): void;
+  reset(): void;
+  subscribe(fn: (state: TaskState<T>) => void): Disposable;
+}
+
+export interface TaskRunContext {
+  signal: AbortSignal;
+  progress(value: number, step?: string): void;
+}
+
+export type TaskFn<T> = (ctx: TaskRunContext, ...args: any[]) => Promise<T> | T;
+
+export interface ResourceState<T = unknown> extends TaskState<T> {
+  /** Refetching while previous data is still shown. */
+  refreshing: boolean;
+}

package/src/types/capabilities.ts

@@ -0,0 +1,79 @@
+/**
+ * What this terminal can actually do. Detected where possible, overridable by
+ * the adapter, and readable from the store at `$/modus/capabilities/*` so a
+ * `when` clause and a layout can both branch on it.
+ *
+ * Components degrade against this; they never feature-detect on their own.
+ */
+export type ColorDepth = 0 | 4 | 8 | 24;
+
+/** How much of the box-drawing / symbol repertoire is safe to emit. */
+export type UnicodeLevel = 'ascii' | 'bmp' | 'full';
+
+export interface TerminalCapabilities {
+  /** 0 = monochrome, 4 = 16 colors, 8 = 256, 24 = truecolor. */
+  colorDepth: ColorDepth;
+  unicode: UnicodeLevel;
+  /** True when the terminal reports (or is assumed to have) emoji/wide support. */
+  wideChars: boolean;
+  mouse: boolean;
+  wheel: boolean;
+  /** Terminal reports focus in/out (CSI ?1004h). */
+  focusEvents: boolean;
+  /** Bracketed paste (CSI ?2004h). */
+  paste: boolean;
+  /** OSC 8 hyperlinks. */
+  hyperlinks: boolean;
+  /** OSC 52 clipboard write. */
+  clipboard: boolean;
+  /** Alternate screen buffer (CSI ?1049h). */
+  altScreen: boolean;
+  /** Cursor show/hide/position. */
+  cursor: boolean;
+  /** Synchronized output (DEC 2026) - tear-free frames. */
+  synchronizedOutput: boolean;
+  /** Terminal supports setting the window/tab title (OSC 0/2). */
+  title: boolean;
+  /** Keyboard disambiguation (Kitty keyboard protocol). */
+  kittyKeyboard: boolean;
+}
+
+export type CapabilityName = keyof TerminalCapabilities;
+
+/** Partial override applied on top of detection. */
+export type CapabilityOverrides = Partial<TerminalCapabilities>;
+
+/** The most conservative terminal we still render correctly on. */
+export const MINIMAL_CAPABILITIES: TerminalCapabilities = {
+  colorDepth: 0,
+  unicode: 'ascii',
+  wideChars: false,
+  mouse: false,
+  wheel: false,
+  focusEvents: false,
+  paste: false,
+  hyperlinks: false,
+  clipboard: false,
+  altScreen: false,
+  cursor: true,
+  synchronizedOutput: false,
+  title: false,
+  kittyKeyboard: false,
+};
+
+export const FULL_CAPABILITIES: TerminalCapabilities = {
+  colorDepth: 24,
+  unicode: 'full',
+  wideChars: true,
+  mouse: true,
+  wheel: true,
+  focusEvents: true,
+  paste: true,
+  hyperlinks: true,
+  clipboard: true,
+  altScreen: true,
+  cursor: true,
+  synchronizedOutput: true,
+  title: true,
+  kittyKeyboard: true,
+};

package/src/types/cells.ts

@@ -0,0 +1,79 @@
+import type { Rect } from './geometry.js';
+
+/**
+ * A color is either a token name resolved through the theme, a 24-bit RGB
+ * value, a 256-palette index, or one of the 16 ANSI names. The renderer
+ * downsamples to whatever `colorDepth` allows - a component never picks a
+ * fallback itself.
+ */
+export type AnsiColorName =
+  | 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white'
+  | 'brightBlack' | 'brightRed' | 'brightGreen' | 'brightYellow'
+  | 'brightBlue' | 'brightMagenta' | 'brightCyan' | 'brightWhite';
+
+export type Color =
+  | AnsiColorName
+  | `#${string}`
+  | { rgb: [number, number, number] }
+  | { palette: number }
+  | 'default';
+
+/** Text attributes as a bitfield - one number per cell, cheap to diff. */
+export const ATTR_NONE = 0;
+export const ATTR_BOLD = 1 << 0;
+export const ATTR_DIM = 1 << 1;
+export const ATTR_ITALIC = 1 << 2;
+export const ATTR_UNDERLINE = 1 << 3;
+export const ATTR_BLINK = 1 << 4;
+export const ATTR_INVERSE = 1 << 5;
+export const ATTR_HIDDEN = 1 << 6;
+export const ATTR_STRIKE = 1 << 7;
+
+export type Attrs = number;
+
+/**
+ * One terminal cell. `char` is a full grapheme cluster (may be several code
+ * points). A wide grapheme occupies this cell and marks the next one
+ * `continuation`, which the writer skips.
+ */
+export interface Cell {
+  char: string;
+  fg: Color;
+  bg: Color;
+  attrs: Attrs;
+  /** OSC 8 target, when the terminal supports hyperlinks. */
+  link?: string;
+  /** True for the right half of a double-width grapheme. */
+  continuation?: boolean;
+}
+
+export interface CellBuffer {
+  readonly width: number;
+  readonly height: number;
+  get(x: number, y: number): Cell | undefined;
+  set(x: number, y: number, cell: Cell): void;
+  /** Rows that changed since `commit()`. Empty when nothing moved. */
+  dirtyRows(): number[];
+  commit(): void;
+  clear(rect?: Rect): void;
+  resize(width: number, height: number): void;
+  /** Plain text, no attributes. The testing harness reads this. */
+  toText(rect?: Rect): string;
+}
+
+/** One contiguous run of identical-style cells - what the ANSI writer emits. */
+export interface CellRun {
+  x: number;
+  y: number;
+  text: string;
+  fg: Color;
+  bg: Color;
+  attrs: Attrs;
+  link?: string;
+}
+
+export interface FrameDiff {
+  runs: CellRun[];
+  /** Where the hardware cursor should end up, or null to keep it hidden. */
+  cursor: { x: number; y: number; visible: boolean } | null;
+}

package/src/types/command.ts

@@ -0,0 +1,139 @@
+import type { Disposable } from './disposable.js';
+import type { WhenClause } from './when.js';
+import type { ReactiveStore } from './store.js';
+import type { TextUIApp } from './app.js';
+
+/**
+ * Command scope. A command resolves from the most specific scope outward:
+ *   component -> region -> screen -> app
+ * The same id may be registered at several scopes; the innermost active one
+ * wins, which is how `table.search` means the focused table.
+ */
+export type CommandScope = 'app' | 'screen' | 'region' | 'component';
+
+/**
+ * One thing an argument may be answered with.
+ *
+ * A bare string is the short form and stays the common one - the value is the
+ * label and there is nothing else to say. The long form is for a choice that
+ * has to be *explained*: an agent's approval modes are five words that all
+ * sound alike ("Auto Mode", "Plan Mode") and the sentence under each one is
+ * what tells them apart, which is the difference between picking and guessing.
+ *
+ * The command is handed `value`, never the label. A host's ids are opaque and
+ * its labels are prose, and resolving one back to the other at the far end is
+ * a lookup that can be wrong.
+ */
+export interface ArgChoice {
+  value: string;
+  /** What a person reads. The value, when there is nothing better. */
+  label?: string;
+  icon?: string;
+  /** A line under it: what choosing this would mean. */
+  description?: string;
+}
+
+export type ArgChoices = (string | ArgChoice)[];
+
+export interface ArgSpec {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'unknown';
+  required?: boolean;
+  description?: string;
+  /** Fixed choices, or a resolver for a picker. */
+  choices?: ArgChoices | (() => Promise<ArgChoices> | ArgChoices);
+  default?: unknown;
+
+  /**
+   * Show what a choice would do, before it is chosen.
+   *
+   * Called as the highlight moves, and with `null` when the asking is
+   * abandoned - so a theme can be applied while you look at it and put back if
+   * you press escape. The command owns whatever it needs to remember to undo
+   * itself; the palette only reports what is happening.
+   */
+  preview?(value: string | null): void;
+}
+
+export type ArgsSchema = ArgSpec[];
+
+export interface CommandContext {
+  app: TextUIApp;
+  store: ReactiveStore;
+  /** The scope instance the command resolved from (a region id, a node id). */
+  scopeId: string | null;
+  /** How it was invoked, for commands that care. */
+  source: 'keybinding' | 'palette' | 'menu' | 'api' | 'mouse' | 'cli';
+}
+
+export type CommandHandler = (
+  args: Record<string, unknown>,
+  ctx: CommandContext,
+) => unknown | Promise<unknown>;
+
+export interface CommandDefinition {
+  id: string;
+  title: string;
+  description?: string;
+  category?: string;
+  icon?: string;
+  /**
+   * Leave the surface that ran this open.
+   *
+   * For a command whose whole effect is to flip something: closing the palette
+   * after each one means reopening it to reach the next, and a list of
+   * switches is meant to be walked.
+   */
+  keepOpen?: boolean;
+  /**
+   * A short state word shown beside the row, in place of the category.
+   *
+   * The icon is the row's identity and should not move under the reader as
+   * state changes; this is where the state goes instead.
+   */
+  badge?: string;
+  /**
+   * A key hint, when it is not this command's own keybinding.
+   *
+   * A row built for one list may stand for a command registered under another
+   * id; the binding a person would actually press belongs to that one.
+   */
+  shortcut?: string;
+  keywords?: string[];
+  scope?: CommandScope;
+  /** The instance this registration belongs to, for non-app scopes. */
+  scopeId?: string;
+  when?: WhenClause;
+  /**
+   * The state of a command that is a switch, as a clause over the store.
+   *
+   * A toggle's row has to say what it is toggling *to*, and the definition is
+   * registered once while the state changes under it - so this is a clause
+   * evaluated per read, the same way `when` is, rather than a boolean nobody
+   * would remember to update. Absent means the command is not a switch, which
+   * a menu needs to tell apart from a switch that is off.
+   */
+  checked?: WhenClause;
+  args?: ArgsSchema;
+  /** Slots this command publishes itself into: 'palette', 'menu:tab', ... */
+  slots?: string[];
+  run: CommandHandler;
+}
+
+export interface CommandRegistry {
+  register(def: CommandDefinition): Disposable;
+  unregister(id: string, scopeId?: string): void;
+  get(id: string): CommandDefinition | undefined;
+  list(options?: { scope?: CommandScope; slot?: string; enabledOnly?: boolean }): CommandDefinition[];
+  /** Resolve through the active scope chain, innermost first. */
+  resolve(id: string): CommandDefinition | undefined;
+  execute(
+    id: string,
+    args?: Record<string, unknown>,
+    source?: CommandContext['source'],
+  ): Promise<unknown>;
+  /** True when the command exists and its `when` clause passes. */
+  enabled(id: string): boolean;
+  /** A switch's state, or undefined when the command is not a switch. */
+  isChecked(id: string): boolean | undefined;
+}

package/src/types/component-registry.ts

@@ -0,0 +1,82 @@
+import type { Disposable } from './disposable.js';
+import type { ComponentNode, ErrorFallback } from './graph.js';
+import type { WhenClause } from './when.js';
+import type { CapabilityName } from './capabilities.js';
+import type { FunctionComponent, HostComponent } from './render.js';
+import type { Style } from './style.js';
+
+export type ComponentCategory =
+  | 'layout' | 'display' | 'control' | 'form' | 'data' | 'navigation'
+  | 'overlay' | 'feedback' | 'chart' | 'chrome' | 'resource' | 'template';
+
+/** Late binding: a name, a category, and something that renders. */
+export type ComponentRenderer =
+  | { kind: 'function'; render: FunctionComponent }
+  | { kind: 'host'; host: HostComponent }
+  /** A component defined as data - the graph all the way down. */
+  | { kind: 'template'; template: ComponentNode }
+  /** Loaded on first mount. The catalog costs a name until something uses it. */
+  | { kind: 'lazy'; load: () => Promise<{ default: FunctionComponent } | FunctionComponent> };
+
+export type PropsSchema = Record<string, string | readonly string[]>;
+
+/**
+ * Declares that this component can render a resource kind. `findOpeners`
+ * drives "Open with...", double-click in an explorer, and the resource picker.
+ */
+export interface ComponentOpensSpec {
+  resourceKinds?: string[];
+  selector?: WhenClause;
+  title?: string;
+  icon?: string;
+  priority?: number;
+  /** 'view' is read-only, 'edit' can write back. */
+  mode?: 'view' | 'edit';
+}
+
+export interface ComponentDefinition {
+  component: string;
+  renderer: ComponentRenderer;
+  category?: ComponentCategory;
+  description?: string;
+  propsSchema?: PropsSchema;
+  /** Variants this component understands, for the theme and the CLI. */
+  variants?: string[];
+  /** Rendered instead when this subtree throws. */
+  fallback?: ErrorFallback;
+  /** Degrades or refuses to mount without these. */
+  requires?: CapabilityName[];
+  /** Uses these when present, works without them. */
+  enhancedBy?: CapabilityName[];
+  opens?: ComponentOpensSpec;
+  /** Default style, merged under the theme's entry for this component. */
+  defaultStyle?: Style;
+  /** Semantic role, for the testing harness and future a11y integrations. */
+  role?: SemanticRole;
+}
+
+export type SemanticRole =
+  | 'button' | 'textbox' | 'checkbox' | 'radio' | 'slider' | 'switch'
+  | 'dialog' | 'alertdialog' | 'menu' | 'menuitem' | 'list' | 'listitem'
+  | 'tree' | 'treeitem' | 'table' | 'row' | 'cell' | 'columnheader'
+  | 'tab' | 'tablist' | 'tabpanel' | 'link' | 'heading' | 'label'
+  | 'progressbar' | 'status' | 'alert' | 'region' | 'group' | 'separator'
+  | 'toolbar' | 'searchbox' | 'combobox' | 'option' | 'presentation'
+  | 'log' | 'timer' | 'marquee' | 'tooltip' | 'banner' | 'main' | 'navigation'
+  | 'document'
+  | 'complementary' | 'contentinfo' | 'form' | 'grid' | 'gridcell' | 'meter';
+
+export interface ComponentRegistry {
+  register(def: ComponentDefinition): Disposable;
+  registerMany(defs: ComponentDefinition[]): Disposable;
+  unregister(component: string): void;
+  get(component: string): ComponentDefinition | undefined;
+  has(component: string): boolean;
+  list(category?: ComponentCategory): ComponentDefinition[];
+  /** Resolve a lazy renderer. Idempotent, cached. */
+  resolve(component: string): Promise<ComponentDefinition>;
+  /** Names registered but not yet resolved. */
+  pending(): string[];
+  /** Components whose `opens` accepts this kind, best first. */
+  findOpeners(resourceKind: string): ComponentDefinition[];
+}

package/src/types/disposable.ts

@@ -0,0 +1,8 @@
+export interface Disposable {
+  dispose(): void;
+}
+
+/** A disposable that owns other disposables. Dispose once, dispose all. */
+export interface DisposableBag extends Disposable {
+  add<T extends Disposable>(d: T): T;
+}

package/src/types/focus.ts

@@ -0,0 +1,77 @@
+import type { Disposable } from './disposable.js';
+import type { Rect } from './geometry.js';
+import type { KeyEvent } from './input.js';
+
+export type FocusDirection = 'next' | 'previous' | 'up' | 'down' | 'left' | 'right';
+
+/**
+ * A focus scope is a container that focus can be trapped inside or restored
+ * to. Modals trap; a sidebar does not. Scopes nest, and the innermost active
+ * scope answers navigation first.
+ */
+export interface FocusScopeOptions {
+  id: string;
+  /** Tab cannot leave this scope while it is active. Modals want this. */
+  trap?: boolean;
+  /** Restore focus to whatever was focused before, on deactivate. */
+  restore?: boolean;
+  /** Focus this scope's first focusable as soon as it activates. */
+  autoFocus?: boolean;
+  /** Higher wins when two scopes are active. */
+  priority?: number;
+}
+
+export interface FocusableOptions {
+  id: string;
+  /** Explicit order within the scope. Unset = document order. */
+  order?: number;
+  disabled?: boolean;
+  /** Skipped by tab, still reachable by directional navigation and click. */
+  skipTab?: boolean;
+  /**
+   * Reads keys whether or not it is focused.
+   *
+   * For handlers that are not about one control - a screen's shortcuts, a
+   * layer that must see escape. A focusable without this only reads keys while
+   * it holds focus, which is what focus means.
+   */
+  global?: boolean;
+  /** Current bounds, for directional navigation and mouse hit-testing. */
+  rect?: Rect;
+  scopeId?: string;
+  onFocus?(): void;
+  onBlur?(): void;
+  /** Return true to consume. Runs before the scope's and the app's handlers. */
+  onKey?(event: KeyEvent): boolean | void;
+}
+
+export interface FocusManager {
+  registerScope(options: FocusScopeOptions): Disposable;
+  activateScope(id: string): void;
+  deactivateScope(id: string): void;
+  activeScope(): string | null;
+
+  register(options: FocusableOptions): Disposable;
+  update(id: string, patch: Partial<FocusableOptions>): void;
+
+  /** True when a focusable with this id is registered. */
+  has(id: string): boolean;
+  /** Which scope a focusable belongs to. */
+  scopeOf(id: string): string;
+  focus(id: string): boolean;
+  blur(): void;
+  focused(): string | null;
+  /** Move focus; returns the id that took it. */
+  move(direction: FocusDirection): string | null;
+  /** The focused id and every ancestor scope, innermost first. */
+  chain(): string[];
+  /** Ids in tab order within a scope (or the active scope). */
+  order(scopeId?: string): string[];
+  /** Hit-test a cell; used for click-to-focus. */
+  at(x: number, y: number): string | null;
+  /**
+   * Feed a key to the focused node, then outward through its scopes, then to
+   * global handlers. Returns true when something consumed it.
+   */
+  dispatch(event: KeyEvent): boolean;
+}