@vui-rs/vue 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1763 @@
+import { Component, InjectionKey, PropType, VNode, computed, defineComponent, h, nextTick, onBeforeUnmount, onMounted, onUnmounted, reactive, ref, shallowReactive, shallowRef, toRef, toRefs, watch, watchEffect } from "@vue/runtime-core";
+import { AlignValue, Attr, Dim, EditBuffer, EditMotion, EditMotionCode, EditorView, InputEvent, InputEvent as InputEvent$1, JustifyValue, Key, KeyEvent, MouseEvent, MouseEvent as MouseEvent$1, Renderer, Sides, TextRun, TextWrapMode, TextWrapMode as TextWrapMode$1, VuiNode, VuiStyle, matchesKey, parseColor, rgba } from "@vui-rs/core";
+
+//#region src/host/link-registry.d.ts
+declare class LinkRegistry {
+  #private;
+  /** Stable id for `uri` (assigning one on first sight). 0 if the table is full. */
+  idFor(uri: string): number;
+  /** All `(id, uri)` entries, for staging the renderer's link table each frame. */
+  entries(): Array<[number, string]>;
+  get size(): number;
+}
+//#endregion
+//#region src/host/selection.d.ts
+interface SelPoint {
+  x: number;
+  y: number;
+}
+declare class HostSelection {
+  anchor: SelPoint | null;
+  focus: SelPoint | null;
+  /** Left/right screen columns (half-open) of the anchored text region. */
+  left: number;
+  right: number;
+  /** True once the drag covers more than the single anchor cell. */
+  get active(): boolean;
+  begin(x: number, y: number, left: number, right: number): void;
+  update(x: number, y: number): void;
+  clear(): void;
+  /** Anchor/focus ordered top-left-first, or null when no selection exists. */
+  ordered(): {
+    start: SelPoint;
+    end: SelPoint;
+  } | null;
+  /**
+   * The half-open `[x0, x1)` column span selected on row `y` (line-flow), clamped
+   * to the region bounds; null when the row is outside the selection.
+   */
+  rowRange(y: number): {
+    x0: number;
+    x1: number;
+  } | null;
+}
+//#endregion
+//#region src/host/focus.d.ts
+/** An input event as seen by handlers — augmented with bubble control. */
+type DispatchableEvent = InputEvent$1 & {
+  defaultPrevented: boolean;
+  preventDefault: () => void;
+};
+type DispatchableMouseEvent = MouseEvent$1 & {
+  defaultPrevented: boolean;
+  preventDefault: () => void;
+};
+interface HostFocusManager {
+  focus(node: Renderable): void;
+  blur(): void;
+  focusNext(): void;
+  focusPrev(): void;
+  current(): Renderable | null;
+  /** Drop a node from focus if it currently holds it (called when it unmounts). */
+  release(node: Renderable): void;
+  /** Route an input event to its target, then bubble to ancestors. */
+  dispatch(ev: InputEvent$1): void;
+  /**
+   * Capture the pointer to `node`: until released, all mouse move/drag/up events
+   * route to it regardless of what's under the cursor — so a drag that leaves the
+   * node (e.g. dragging a 1-cell scrollbar thumb sideways) keeps tracking.
+   */
+  setPointerCapture(node: Renderable): void;
+  releasePointerCapture(node?: Renderable): void;
+}
+declare function createHostFocusManager(ctx: HostContext): HostFocusManager;
+//#endregion
+//#region src/host/animation/easing.d.ts
+/** An easing curve: normalized time `[0,1]` → eased progress (may overshoot mid-way). */
+type EasingFn = (t: number) => number;
+declare function outBounce(t: number): number;
+/** The standard easing catalogue, keyed by name. */
+declare const easings: {
+  linear: (t: number) => number;
+  inQuad: (t: number) => number;
+  outQuad: (t: number) => number;
+  inOutQuad: (t: number) => number;
+  inCubic: (t: number) => number;
+  outCubic: (t: number) => number;
+  inOutCubic: (t: number) => number;
+  inQuart: (t: number) => number;
+  outQuart: (t: number) => number;
+  inOutQuart: (t: number) => number;
+  inSine: (t: number) => number;
+  outSine: (t: number) => number;
+  inOutSine: (t: number) => number;
+  inExpo: (t: number) => number;
+  outExpo: (t: number) => number;
+  inOutExpo: (t: number) => number;
+  inCirc: (t: number) => number;
+  outCirc: (t: number) => number;
+  inOutCirc: (t: number) => number;
+  inBack: (t: number) => number;
+  outBack: (t: number) => number;
+  inOutBack: (t: number) => number;
+  inElastic: (t: number) => number;
+  outElastic: (t: number) => number;
+  inOutElastic: (t: number) => number;
+  inBounce: (t: number) => number;
+  outBounce: typeof outBounce;
+  inOutBounce: (t: number) => number;
+};
+/** Name of a built-in easing curve. */
+type EasingName = keyof typeof easings;
+/** Resolve an easing name (or a custom function) to a callable curve; unknown → linear. */
+declare function resolveEasing(easing: EasingName | EasingFn | undefined): EasingFn;
+//#endregion
+//#region src/host/animation/timeline.d.ts
+/** Options for a single number tween. */
+interface AnimateOptions {
+  /** Start value. */
+  from: number;
+  /** End value. */
+  to: number;
+  /** Tween length in milliseconds (≤0 = apply `to` immediately). */
+  duration: number;
+  /** Easing curve (name or custom fn); default `linear`. */
+  easing?: EasingName | EasingFn;
+  /** Milliseconds to wait before the tween starts. */
+  delay?: number;
+  /** `true` = loop forever, a number = repeat that many times, else play once. */
+  loop?: boolean | number;
+  /** Ping-pong: reverse direction every loop so it goes `from→to→from→…`. */
+  alternate?: boolean;
+  /** Called with each tweened value (wire to a reactive ref). */
+  onUpdate: (value: number) => void;
+  /** Called once when the tween finishes naturally (not on `cancel`). */
+  onComplete?: () => void;
+}
+/** A running tween. The scheduler drives it via `tick`; components control it via pause/resume/cancel. */
+interface Animation {
+  /** Latest emitted value. */
+  readonly value: number;
+  /** True once finished or cancelled (the registry prunes it). */
+  readonly done: boolean;
+  /** True while paused (ticks are ignored). */
+  readonly paused: boolean;
+  /** Advance by `dt` ms; emits an updated value and fires completion/loop logic. */
+  tick(dt: number): void;
+  /** Suspend ticking (value frozen) until `resume`. */
+  pause(): void;
+  /** Resume ticking after `pause`. */
+  resume(): void;
+  /** Stop immediately without firing `onComplete`; marks `done` so the registry drops it. */
+  cancel(): void;
+  /** Rewind to the start (re-arms delay and loops) and un-pause. */
+  restart(): void;
+}
+declare function createAnimation(opts: AnimateOptions): Animation;
+/**
+ * Holds the active animations and drives them as a batch. `onActive(true|false)`
+ * fires on the empty↔non-empty edge so the scheduler starts/stops its frame loop
+ * (no loop while idle). The registry itself owns no timer — it is ticked from the
+ * outside with the frame delta.
+ */
+interface AnimationRegistry {
+  add(a: Animation): void;
+  remove(a: Animation): void;
+  readonly size: number;
+  /** Advance every animation by `dt` ms, then drop the ones that finished. */
+  tick(dt: number): void;
+  /** Drop all animations (used on dispose). */
+  clear(): void;
+}
+declare function createAnimationRegistry(onActive: (active: boolean) => void): AnimationRegistry;
+//#endregion
+//#region src/theme/loader.d.ts
+/** A literal color (`#rrggbb(aa)`, `rgb()/rgba()`, named) or a `defs`/token ref. */
+type ColorValue = string | number | {
+  dark: string | number;
+  light: string | number;
+};
+/** The on-disk theme shape. */
+interface ThemeJson {
+  $schema?: string;
+  /** Named color palette; token values may reference these by name. */
+  defs?: Record<string, string | number>;
+  /** Semantic tokens; keys are theme token names. */
+  theme: Record<string, ColorValue>;
+}
+/**
+ * Resolve a theme JSON into a fully packed `Theme` for the given mode. Every token
+ * falls back to a sensible related token when omitted (so partial/older theme
+ * files still load), and the legacy `fg`/`bg`/`muted` aliases mirror
+ * `text`/`background`/`textMuted` for backward compatibility.
+ */
+declare function resolveThemeJson(json: ThemeJson, mode?: 'dark' | 'light'): Theme;
+/** Read + parse a theme JSON file from disk (`~/.vui/themes/*.json`). */
+declare function loadThemeFile(path: string): Promise<ThemeJson>;
+//#endregion
+//#region src/theme/registry.d.ts
+/** Built-in themes, keyed by name. Each carries dark + light. */
+declare const BUILTIN_THEMES: Record<string, ThemeJson>;
+/** Register (or replace) a theme JSON under `name`, available to `resolveTheme()`. */
+declare function registerTheme(name: string, json: ThemeJson): void;
+/** All registered theme names (built-in + registered). */
+declare function listThemes(): string[];
+/** Resolve a registered theme name to a packed `Theme` for the given mode. */
+declare function resolveTheme(name: string, mode?: 'dark' | 'light'): Theme;
+/**
+ * Detect the terminal's light/dark preference without querying it. Honors an
+ * explicit `VUI_THEME_MODE`, then `COLORFGBG` (the background ANSI index: 0–6 is
+ * dark, 7–15 light — set by many terminals), then defaults to dark.
+ */
+declare function detectColorScheme(): 'dark' | 'light';
+/** The default dark theme (Catppuccin Mocha) — the app theme when none is set. */
+declare const darkTheme: Theme;
+/** The default light theme (Catppuccin Latte). */
+declare const lightTheme: Theme;
+/** What `setTheme()` accepts: a registered name, a theme JSON, a packed `Theme`, or a partial override. */
+type ThemeInput = string | ThemeJson | Theme | Partial<Theme>;
+//#endregion
+//#region src/theme.d.ts
+/**
+ * Semantic color tokens. Values are packed `0xRRGGBBAA` numbers.
+ * `fg`/`bg`/`muted` are legacy aliases of
+ * `text`/`background`/`textMuted`, kept for backward compatibility.
+ */
+interface Theme {
+  primary: number;
+  secondary: number;
+  /** The one highlight color (spinners, focused affordances, links); maps to `primary`. */
+  accent: number;
+  error: number;
+  warning: number;
+  success: number;
+  info: number;
+  text: number;
+  textMuted: number;
+  /** Foreground for a selected list item. */
+  selectedText: number;
+  background: number;
+  backgroundPanel: number;
+  backgroundElement: number;
+  backgroundMenu: number;
+  border: number;
+  borderActive: number;
+  borderSubtle: number;
+  diffAdded: number;
+  diffRemoved: number;
+  diffContext: number;
+  diffHunkHeader: number;
+  diffAddedBg: number;
+  diffRemovedBg: number;
+  diffContextBg: number;
+  markdownText: number;
+  markdownHeading: number;
+  markdownLink: number;
+  markdownLinkText: number;
+  markdownCode: number;
+  markdownBlockQuote: number;
+  markdownEmph: number;
+  markdownStrong: number;
+  markdownHorizontalRule: number;
+  markdownListItem: number;
+  markdownListEnumeration: number;
+  markdownImage: number;
+  markdownImageText: number;
+  markdownCodeBlock: number;
+  syntaxComment: number;
+  syntaxKeyword: number;
+  syntaxFunction: number;
+  syntaxVariable: number;
+  syntaxString: number;
+  syntaxNumber: number;
+  syntaxType: number;
+  syntaxOperator: number;
+  syntaxPunctuation: number;
+  /** Default foreground (alias of `text`). */
+  fg: number;
+  /** Canvas background (alias of `background`). */
+  bg: number;
+  /** De-emphasised text (alias of `textMuted`). */
+  muted: number;
+}
+/** Injection key for the active theme; `useTheme()` reads it, `provideTheme()` sets it. */
+declare const ThemeSymbol: InjectionKey<Theme>;
+//#endregion
+//#region src/host/renderable.d.ts
+type RenderableKind = 'box' | 'text' | 'edit' | 'textarea' | 'span' | 'raw-text' | 'comment';
+/** Run-style a `span` folds into its enclosing `<text>` (mirrors host-node RunStyle). */
+interface RunStyle {
+  fg?: number;
+  bg?: number;
+  attrs: number;
+  /** OSC 8 link target; resolved to a link id and ORed into the run's attrs. */
+  link?: string;
+}
+/**
+ * Opaque dim backdrop an overlay can paint under itself: each covered cell is
+ * read back and rewritten with its glyph kept but its fg/bg scaled toward black
+ * by `darken` (0..1). No real alpha — the terminal has none — just a darker
+ * opaque rewrite, enough to push the layer behind a modal into the background.
+ */
+interface Backdrop {
+  /** Brightness multiplier for the covered cells (0 = black, 1 = unchanged). */
+  darken: number;
+}
+/** Visual (non-layout) props a Renderable paints with. The JS twin of Rust PaintProps. */
+interface PaintProps$1 {
+  bg?: number;
+  fg?: number;
+  /** Combined attr bits (base | flags), recomputed on change. */
+  attrs: number;
+  /** Explicitly-set numeric `attrs`, OR-ed with the boolean attr flags. */
+  baseAttrs: number;
+  attrFlags: Record<string, number>;
+  border: 'none' | 'single' | 'double' | 'rounded';
+  borderColor?: number;
+  title: string;
+  titleAlign: 'left' | 'center' | 'right';
+  visible: boolean;
+  opacity: number;
+  wrap: TextWrapMode$1;
+  /**
+   * How children that exceed this node's content box are treated at paint time.
+   * `visible` (default) lets them spill — children are clipped only by the
+   * inherited ancestor clip, not this box's content box. `hidden`/`scroll` clip
+   * children to the content box (a viewport); `scroll` additionally pairs with a
+   * scroll offset + scrollbar. Paint-only — layout (taffy) is unaffected.
+   */
+  overflow: 'visible' | 'hidden' | 'scroll';
+  /** Paint order among siblings (and among overlays); higher draws later/on top. */
+  zIndex: number;
+  /** Opaque dim backdrop painted under an overlay's content; undefined = none. */
+  backdrop?: Backdrop;
+}
+/** Edge insets (padding/border) a laid-out node reports, in cells. */
+interface Edges {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+}
+/** A node's computed box from layout (Phase 03). Origin is parent-relative. */
+interface LayoutRect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  padding: Edges;
+  border: Edges;
+}
+/** Half-open clip rect `[x0,x1) × [y0,y1)` — the JS twin of paint.rs `Clip`. */
+interface Clip {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+}
+/** Absolute rounded half-open screen rect cached during the paint walk. */
+type ScreenRect = Clip;
+/**
+ * Paint surface a Renderable draws into — the native cell buffer, via the
+ * clip-aware prims. Every op takes the clip (already intersected with the
+ * buffer). `bgUnder` reads the current cell background so a transparent glyph
+ * keeps whatever it sits on (the JS twin of paint.rs `bg_under`).
+ */
+interface PaintBuffer {
+  fillRect(x: number, y: number, w: number, h: number, bg: number, clip: Clip): void;
+  setCell(x: number, y: number, ch: number, fg: number, bg: number, attrs: number, clip: Clip): void;
+  /** Draw a whole string on a row, clipped (one FFI op). Used by the canvas ctx. */
+  drawText(x: number, y: number, text: string, fg: number, bg: number, attrs: number, clip: Clip): void;
+  /** Draw a native editor view in one clipped FFI op. */
+  drawEditor(view: import('@vui-rs/core').EditorView, x: number, y: number, fg: number, bg: number, cursorBg: number, attrs: number, clip: Clip): void;
+  /** Draw a native text-buffer view in one clipped FFI op. */
+  drawTextBuffer(view: import('@vui-rs/core').TextBufferView, x: number, y: number, fg: number, bg: number | undefined, attrs: number, clip: Clip): void;
+  /** Composite an offscreen buffer into the back buffer at `(dstX,dstY)`, clipped. */
+  blit(src: import('@vui-rs/core').OffscreenBuffer, dstX: number, dstY: number, clip: Clip): void;
+  bgUnder(x: number, y: number): number;
+  /**
+   * The whole cell currently at `(x,y)` — glyph + colors + attrs — read back from
+   * the live buffer. Lets the overlay backdrop darken a cell in place while
+   * keeping its glyph (the JS-only twin of `bgUnder`, widened to all fields).
+   */
+  cellUnder(x: number, y: number): CellUnder;
+}
+/** A cell read back from the buffer: packed colors as `0xRRGGBBAA`. */
+interface CellUnder {
+  ch: number;
+  fg: number;
+  bg: number;
+  attrs: number;
+}
+/**
+ * Geometry a Renderable paints with, computed by the paint walk: the rounded
+ * absolute border box (`x0..y1`) + its clip, and the content box (`cx0..cy1`,
+ * inset by border+padding) + its clip. The JS twin of paint.rs `paint_node`'s
+ * locals, handed to `renderSelf`.
+ */
+interface PaintCtx {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+  clip: Clip;
+  cx0: number;
+  cy0: number;
+  cx1: number;
+  cy1: number;
+  contentClip: Clip;
+}
+/**
+ * Base host node. `box`/`text`/`edit` get dedicated subclasses (with a real
+ * `renderSelf` in Phase 04); `span`/`raw-text`/`comment` stay base instances —
+ * they own no rect and fold into the enclosing `<text>`'s runs.
+ */
+declare class Renderable {
+  ctx: HostContext;
+  kind: RenderableKind;
+  tag: string;
+  parent: Renderable | null;
+  children: Renderable[];
+  /**
+   * Layout-only native node for `box`/`text`/`edit` (taffy style + text-for-
+   * measure ONLY — no paint props; the Renderable paints itself in JS). `null`
+   * for virtual nodes (span/raw-text/comment). The L1 layout-via-FFI backing.
+   */
+  layoutNode: VuiNode | null;
+  /** Layout bucket (taffy style), flushed to the layout node (Phase 03). */
+  style: VuiStyle;
+  paint: PaintProps$1;
+  /** Run-style for `span` nodes. */
+  spanStyle: RunStyle;
+  /** Value for `raw-text`/`comment`; default-run text for a `<text>` set via setElementText. */
+  text: string;
+  directText: string | null;
+  events: Map<string, (...args: unknown[]) => void>;
+  focusable: boolean;
+  /** Unknown props, kept for debugging (parity with the FFI patch-prop). */
+  props: Record<string, unknown>;
+  /** Computed box from layout; null until the first layout pass. */
+  rect: LayoutRect | null;
+  /** Paint-time scroll offset applied to this node's children. */
+  scrollX: number;
+  scrollY: number;
+  /** Absolute rounded border box from the last paint walk; null until painted. */
+  screenRect: ScreenRect | null;
+  /**
+   * Overlay/portal root: laid out absolute on the terminal (its layout node is
+   * hoisted under the renderer root), skipped by the main paint walk, and drawn
+   * by the separate overlay pass on top of the tree. Set by `OverlayRenderable`.
+   */
+  isOverlay: boolean;
+  /**
+   * A focus-trapping overlay: while mounted, Tab/Shift-Tab focus is confined to
+   * this overlay's subtree (the active modal). Non-trapping overlays (toasts,
+   * popups) leave the underlying tab order intact. Set via the `trapFocus` prop.
+   */
+  trapFocus: boolean;
+  /** Dirty since the last paint walk (drives dirty-subtree skipping in Phase 06). */
+  dirty: boolean;
+  constructor(ctx: HostContext, kind: RenderableKind, tag: string);
+  /** Draw this node into the buffer with the walk-computed geometry. Overridden by subclasses. */
+  renderSelf(_buffer: PaintBuffer, _ctx: PaintCtx): void;
+  /** Mark this node (and request a render) as needing repaint. */
+  markDirty(): void;
+  /**
+   * Release any native resources this node owns (e.g. a canvas's offscreen
+   * buffer). Called for every node in a removed subtree. Base: nothing to free.
+   */
+  dispose(): void;
+}
+/**
+ * Per-app wiring for the JS host path. The native `Renderer` (cell buffer owner)
+ * is only known at mount. `paint`/`layout` hooks are filled by later phases; in
+ * Phase 01 they are null and `scheduleRender` just bumps the counter.
+ */
+interface HostContext {
+  renderer: import('@vui-rs/core').Renderer | null;
+  root: Renderable | null;
+  /**
+   * Overlay/portal roots, painted after the main tree (low zIndex first) on top
+   * of everything. Registered by node-ops when an `<overlay>` mounts.
+   */
+  overlays: Renderable[];
+  theme: Theme;
+  /** Renderables whose layout style changed since the last layout pass. */
+  dirtyLayout: Set<Renderable>;
+  /** Renderables whose text runs changed (re-flattened on paint). */
+  dirtyText: Set<Renderable>;
+  /** URI → stable OSC 8 link id, staged to the renderer each frame before flush. */
+  links: LinkRegistry;
+  /** Active drag-selection over static `<text>`/`<markdown>` (highlight + copy). */
+  selection: HostSelection;
+  /** Renderer size at the last layout pass; a change (resize) forces a relayout. */
+  layoutW: number;
+  layoutH: number;
+  scheduleRender: () => void;
+  flushNow: () => void;
+  dispose: () => void;
+  renderCount: number;
+  /**
+   * Callbacks run after the layout pass and before paint, while rects are fresh.
+   * Scroll viewports register here to clamp/stick their offset to the just-laid-
+   * out content size (stick-to-bottom) with no one-frame lag. Mutate paint state
+   * + `markDirty()` only — do NOT `scheduleRender()` (paint runs next this frame).
+   */
+  afterLayout: Set<() => void>;
+  /** Layout pass (Phase 03); null until wired. */
+  layout: ((ctx: HostContext) => void) | null;
+  /** Paint walk (Phase 04); null until wired. */
+  paint: ((ctx: HostContext) => void) | null;
+  /** Keyboard focus model; wired at mount (null in offscreen-only tests). */
+  focusManager: HostFocusManager | null;
+  /**
+   * Active animations (Phase: animation/timeline). The scheduler drives a frame
+   * loop only while this is non-empty; each tween's `onUpdate` sets a reactive
+   * ref → the existing coalesced render. Empty ⇒ zero-render-on-idle holds.
+   */
+  animations: AnimationRegistry;
+}
+/**
+ * Injection key for the per-app `HostContext`, provided at mount. Composables
+ * like `useTimeline()` inject it to reach the animation registry/scheduler
+ * without threading a host-element ref through the component.
+ */
+declare const HostContextSymbol: InjectionKey<HostContext>;
+//#endregion
+//#region src/host/create-host-app.d.ts
+interface HostMountOptions {
+  renderer?: Renderer;
+  width?: number;
+  height?: number;
+  altScreen?: boolean;
+  theme?: Theme;
+}
+interface VuiHostApp {
+  mount(options?: HostMountOptions): VuiHostApp;
+  unmount(): void;
+  /** Swap the active theme at runtime (by name, JSON, full theme, or partial) — no remount. */
+  setTheme(input: ThemeInput, mode?: 'dark' | 'light'): void;
+  readonly renderer: Renderer | null;
+  readonly context: HostContext;
+}
+declare function createHostApp(rootComponent: Component, rootProps?: Record<string, unknown>): VuiHostApp;
+//#endregion
+//#region src/create-app.d.ts
+/** Mount options (renderer/size/altScreen/theme). Alias of the host's options. */
+type MountOptions = HostMountOptions;
+/** A mounted app handle (mount/unmount/renderer/context). Alias of the host app. */
+type VuiApp = VuiHostApp;
+/** Create a vui-rs app from a root component. Mount it with `.mount()`. */
+declare function createApp(rootComponent: Component, rootProps?: Record<string, unknown>): VuiApp;
+//#endregion
+//#region src/host/catalogue.d.ts
+/** Build a Renderable for `tag` in `ctx`. Custom entries supply their own factory. */
+type RenderableFactory = (ctx: HostContext, tag: string) => Renderable;
+interface CatalogueEntry {
+  kind: Renderable['kind'];
+  /** For `span` kinds: attribute bits the tag contributes (bold/italic/…). */
+  spanAttrs: number;
+  /** Custom constructor (from `extend`); defaults to the built-in for `kind`. */
+  make?: RenderableFactory;
+}
+/** Register custom element kinds. Overrides existing tags. */
+declare function extend(map: Record<string, CatalogueEntry>): void;
+/**
+ * Is `tag` a vui *element* (vs. a Vue component) for the SFC compiler's
+ * `isCustomElement`? `box`/`text`/`canvas` and the inline `span`-kind tags are
+ * elements; `edit`-kind tags (`<input>`) are NOT — they resolve to the
+ * `VuiHostInput` component (registered at app create) so v-model round-trips
+ * through its editing logic. `textarea-host` is the internal element rendered by
+ * the public `<textarea>` component. Only knows built-in + `extend()`-ed tags in THIS
+ * process; the Vite build lists runtime tags in the plugin separately.
+ */
+declare function isVuiTag(tag: string): boolean;
+//#endregion
+//#region src/host/canvas-renderable.d.ts
+/** Optional per-cell style for the canvas draw ops. */
+interface CanvasStyle {
+  fg?: number;
+  bg?: number;
+  attrs?: number;
+}
+/** The laid-out rect handed to `onDraw` (absolute cells). Local draw coords are 0-based. */
+interface CanvasRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * The clamped drawing surface passed to a canvas's `onDraw`. Coordinates are
+ * LOCAL to the canvas content box (0,0 = its top-left); every op is clipped to
+ * the box so a canvas can never corrupt a sibling.
+ */
+interface CanvasContext {
+  readonly width: number;
+  readonly height: number;
+  clear(bg?: number): void;
+  fillRect(x: number, y: number, w: number, h: number, bg: number): void;
+  setCell(x: number, y: number, ch: string | number, style?: CanvasStyle): void;
+  drawText(x: number, y: number, text: string, style?: CanvasStyle): void;
+}
+type CanvasDraw = (ctx: CanvasContext, rect: CanvasRect) => void;
+declare class CanvasRenderable extends Renderable {
+  #private;
+  /** Number of `onDraw` invocations — instrumentation for the buffered-redraw test. */
+  drawCount: number;
+  constructor(ctx: HostContext, tag: string);
+  /** Buffered mode owns an offscreen framebuffer; toggled by the `buffered` prop. */
+  get buffered(): boolean;
+  /** Force a buffered canvas to re-run `onDraw` on the next paint. */
+  redraw(): void;
+  renderSelf(buffer: PaintBuffer, ctx: PaintCtx): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/host/box-renderable.d.ts
+declare class BoxRenderable extends Renderable {
+  constructor(ctx: HostContext, tag: string);
+  renderSelf(buffer: PaintBuffer, ctx: PaintCtx): void;
+}
+//#endregion
+//#region src/host/overlay.d.ts
+/**
+ * An `<overlay>` host node: a top-layer box laid out absolute over the whole
+ * terminal. Defaults to filling the screen (`position:absolute`, all insets 0) so
+ * a centered modal can flex-center within it and a backdrop covers everything;
+ * authors override the layout props as usual.
+ */
+declare class OverlayRenderable extends BoxRenderable {
+  constructor(ctx: HostContext, tag: string);
+}
+//#endregion
+//#region src/host/image-renderable.d.ts
+declare class ImageRenderable extends Renderable {
+  #private;
+  constructor(ctx: HostContext, tag: string);
+  get src(): string;
+  renderSelf(buffer: PaintBuffer, ctx: PaintCtx): void;
+}
+//#endregion
+//#region src/host/image-encode.d.ts
+type ImageEncoding = 'kitty' | 'iterm2' | 'halfblock';
+type Env = Record<string, string | undefined>;
+/**
+ * Choose an encoding from an explicit override or terminal detection. Auto-order:
+ * Kitty → iTerm2 → half-block (the universal fallback).
+ */
+declare function selectImageEncoding(env?: Env): ImageEncoding;
+//#endregion
+//#region src/host/edit-renderable.d.ts
+/** Editable state surfaced to paint (cursor is a grapheme index; column is derived). */
+interface EditState {
+  value: string;
+  placeholder: string;
+  cursor: number;
+  focused: boolean;
+  maxLength?: number;
+  cursorColor?: number;
+  placeholderColor?: number;
+}
+declare class EditRenderable extends Renderable {
+  #private;
+  edit: EditState;
+  constructor(ctx: HostContext, tag: string);
+  renderSelf(buffer: PaintBuffer, ctx: PaintCtx): void;
+  getValue(): string;
+  /** External value write (v-model): replace, cursor to end. No change emit. */
+  setValue(text: string): void;
+  insert(text: string): void;
+  backspace(): void;
+  delete(): void;
+  move(motion: number): void;
+}
+//#endregion
+//#region src/host/components/input.d.ts
+type ColorProp$3 = string | number;
+declare const VuiHostInput: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  value: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholder: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholderColor: {
+    type: PropType<ColorProp$3>;
+    default: undefined;
+  };
+  cursorColor: {
+    type: PropType<ColorProp$3>;
+    default: undefined;
+  };
+  maxLength: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("update:value" | "input" | "change" | "enter")[], "update:value" | "input" | "change" | "enter", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  value: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholder: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholderColor: {
+    type: PropType<ColorProp$3>;
+    default: undefined;
+  };
+  cursorColor: {
+    type: PropType<ColorProp$3>;
+    default: undefined;
+  };
+  maxLength: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>> & Readonly<{
+  "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+  onInput?: ((...args: any[]) => any) | undefined;
+  onChange?: ((...args: any[]) => any) | undefined;
+  onEnter?: ((...args: any[]) => any) | undefined;
+}>, {
+  value: string;
+  placeholder: string;
+  placeholderColor: ColorProp$3;
+  cursorColor: ColorProp$3;
+  maxLength: number;
+  focused: boolean;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/textarea-renderable.d.ts
+interface TextareaState {
+  placeholder: string;
+  focused: boolean;
+  cursorColor?: number;
+  placeholderColor?: number;
+  wrap: TextWrapMode$1;
+  autoWidth: boolean;
+  autoHeight: boolean;
+  tabBehavior: 'focus' | 'indent';
+  tabSize: number;
+}
+declare class TextareaRenderable extends Renderable {
+  #private;
+  edit: EditBuffer;
+  editor: EditorView;
+  textarea: TextareaState;
+  constructor(ctx: HostContext, tag: string);
+  renderSelf(buffer: PaintBuffer, ctx: PaintCtx): void;
+  getValue(): string;
+  setValue(value: string): void;
+  insert(text: string): void;
+  newline(): void;
+  backspace(): void;
+  delete(): void;
+  move(motion: EditMotionCode, selecting?: boolean): void;
+  syncAutoSizeStyle(): boolean;
+  selectAll(): void;
+  hasSelection(): boolean;
+  selectedText(): string;
+  deleteSelection(): boolean;
+  undo(): void;
+  redo(): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/host/components/textarea.d.ts
+type ColorProp$2 = string | number;
+declare const VuiHostTextarea: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  value: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholder: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholderColor: {
+    type: PropType<ColorProp$2>;
+    default: undefined;
+  };
+  cursorColor: {
+    type: PropType<ColorProp$2>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  wrap: {
+    type: PropType<"word" | "char" | "nowrap">;
+    default: string;
+  };
+  tabBehavior: {
+    type: PropType<"focus" | "indent">;
+    default: string;
+  };
+  tabSize: {
+    type: NumberConstructor;
+    default: number;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("update:value" | "input" | "change" | "enter")[], "update:value" | "input" | "change" | "enter", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  value: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholder: {
+    type: StringConstructor;
+    default: string;
+  };
+  placeholderColor: {
+    type: PropType<ColorProp$2>;
+    default: undefined;
+  };
+  cursorColor: {
+    type: PropType<ColorProp$2>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  wrap: {
+    type: PropType<"word" | "char" | "nowrap">;
+    default: string;
+  };
+  tabBehavior: {
+    type: PropType<"focus" | "indent">;
+    default: string;
+  };
+  tabSize: {
+    type: NumberConstructor;
+    default: number;
+  };
+}>> & Readonly<{
+  "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+  onInput?: ((...args: any[]) => any) | undefined;
+  onChange?: ((...args: any[]) => any) | undefined;
+  onEnter?: ((...args: any[]) => any) | undefined;
+}>, {
+  value: string;
+  placeholder: string;
+  placeholderColor: ColorProp$2;
+  cursorColor: ColorProp$2;
+  focused: boolean;
+  wrap: "nowrap" | "char" | "word";
+  tabBehavior: "focus" | "indent";
+  tabSize: number;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/components/scroll-box.d.ts
+declare const VuiScrollBox: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  modelValue: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  scrollY: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  step: {
+    type: NumberConstructor;
+    default: number;
+  };
+  pageStep: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Chat/transcript mode: keep the view pinned to the bottom as content grows,
+   * unless the user has scrolled up. Uncontrolled only — don't bind modelValue.
+   */
+  stickToBottom: {
+    type: BooleanConstructor;
+    default: boolean;
+  }; /** Render an integrated vertical scrollbar (indicator + drag) on the right edge. */
+  scrollbar: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("scroll" | "update:modelValue" | "update:scrollY")[], "scroll" | "update:modelValue" | "update:scrollY", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  modelValue: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  scrollY: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  step: {
+    type: NumberConstructor;
+    default: number;
+  };
+  pageStep: {
+    type: NumberConstructor;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Chat/transcript mode: keep the view pinned to the bottom as content grows,
+   * unless the user has scrolled up. Uncontrolled only — don't bind modelValue.
+   */
+  stickToBottom: {
+    type: BooleanConstructor;
+    default: boolean;
+  }; /** Render an integrated vertical scrollbar (indicator + drag) on the right edge. */
+  scrollbar: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>> & Readonly<{
+  onScroll?: ((...args: any[]) => any) | undefined;
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+  "onUpdate:scrollY"?: ((...args: any[]) => any) | undefined;
+}>, {
+  focused: boolean;
+  focusable: boolean;
+  modelValue: number;
+  scrollY: number;
+  step: number;
+  pageStep: number;
+  stickToBottom: boolean;
+  scrollbar: boolean;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/components/scroll-bar.d.ts
+declare const VuiScrollBar: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  scrollY: {
+    type: NumberConstructor;
+    default: number;
+  };
+  viewportHeight: {
+    type: NumberConstructor;
+    required: true;
+  };
+  contentHeight: {
+    type: NumberConstructor;
+    required: true;
+  };
+  thumbBg: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: string;
+  };
+  trackBg: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: undefined;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("scroll" | "update:scrollY")[], "scroll" | "update:scrollY", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  scrollY: {
+    type: NumberConstructor;
+    default: number;
+  };
+  viewportHeight: {
+    type: NumberConstructor;
+    required: true;
+  };
+  contentHeight: {
+    type: NumberConstructor;
+    required: true;
+  };
+  thumbBg: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: string;
+  };
+  trackBg: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: undefined;
+  };
+}>> & Readonly<{
+  onScroll?: ((...args: any[]) => any) | undefined;
+  "onUpdate:scrollY"?: ((...args: any[]) => any) | undefined;
+}>, {
+  scrollY: number;
+  thumbBg: string | number;
+  trackBg: string | number;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/components/select-list.d.ts
+type ColorProp$1 = string | number;
+type SelectItemValue = string | number;
+type SelectItem = SelectItemValue | {
+  label: string;
+  value: SelectItemValue;
+  disabled?: boolean;
+};
+declare const VuiSelectList: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  items: {
+    type: PropType<SelectItem[]>;
+    required: true;
+  };
+  modelValue: {
+    type: PropType<SelectItemValue | undefined>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeBg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  activeFg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  selectedBg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+  selectedFg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("select" | "update:modelValue" | "active")[], "select" | "update:modelValue" | "active", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  items: {
+    type: PropType<SelectItem[]>;
+    required: true;
+  };
+  modelValue: {
+    type: PropType<SelectItemValue | undefined>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeBg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  activeFg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  selectedBg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+  selectedFg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+}>> & Readonly<{
+  onSelect?: ((...args: any[]) => any) | undefined;
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+  onActive?: ((...args: any[]) => any) | undefined;
+}>, {
+  focused: boolean;
+  focusable: boolean;
+  modelValue: SelectItemValue | undefined;
+  activeBg: ColorProp$1;
+  activeFg: ColorProp$1;
+  selectedBg: ColorProp$1;
+  selectedFg: ColorProp$1;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+declare const VuiSelect: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  items: {
+    type: PropType<SelectItem[]>;
+    required: true;
+  };
+  modelValue: {
+    type: PropType<SelectItemValue | undefined>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeBg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  activeFg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  selectedBg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+  selectedFg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, ("select" | "update:modelValue" | "active")[], "select" | "update:modelValue" | "active", import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  items: {
+    type: PropType<SelectItem[]>;
+    required: true;
+  };
+  modelValue: {
+    type: PropType<SelectItemValue | undefined>;
+    default: undefined;
+  };
+  focused: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  focusable: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeBg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  activeFg: {
+    type: PropType<ColorProp$1>;
+    default: string;
+  };
+  selectedBg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+  selectedFg: {
+    type: PropType<ColorProp$1>;
+    default: undefined;
+  };
+}>> & Readonly<{
+  onSelect?: ((...args: any[]) => any) | undefined;
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+  onActive?: ((...args: any[]) => any) | undefined;
+}>, {
+  focused: boolean;
+  focusable: boolean;
+  modelValue: SelectItemValue | undefined;
+  activeBg: ColorProp$1;
+  activeFg: ColorProp$1;
+  selectedBg: ColorProp$1;
+  selectedFg: ColorProp$1;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/spinner.d.ts
+type ColorProp = string | number;
+/** Built-in spinner frame sets, selectable via the `preset` prop. */
+declare const SPINNER_PRESETS: {
+  readonly braille: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  readonly dots: readonly ["⢄", "⢂", "⢁", "⡁", "⡈", "⡐", "⡠"];
+  readonly line: readonly ["-", "\\", "|", "/"];
+  readonly bounce: readonly ["⠁", "⠂", "⠄", "⠂"];
+  readonly arc: readonly ["◜", "◠", "◝", "◞", "◡", "◟"];
+  readonly circle: readonly ["◐", "◓", "◑", "◒"];
+  readonly arrow: readonly ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"];
+  readonly toggle: readonly ["▰▱▱", "▱▰▱", "▱▱▰", "▱▰▱"];
+  readonly pulse: readonly ["·", "•", "●", "•"];
+};
+type SpinnerPreset = keyof typeof SPINNER_PRESETS;
+declare const VuiSpinner: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Animation frames, cycled in order. Overrides `preset` when set. */frames: {
+    type: PropType<string[]>;
+    default: undefined;
+  }; /** Named built-in frame set; ignored when `frames` is provided. */
+  preset: {
+    type: PropType<SpinnerPreset>;
+    default: string;
+  }; /** Milliseconds between frames. */
+  interval: {
+    type: NumberConstructor;
+    default: number;
+  }; /** Spinner color; defaults to the active theme's accent. */
+  color: {
+    type: PropType<ColorProp>;
+    default: undefined;
+  }; /** Optional label rendered after the spinner glyph. */
+  label: {
+    type: StringConstructor;
+    default: string;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Animation frames, cycled in order. Overrides `preset` when set. */frames: {
+    type: PropType<string[]>;
+    default: undefined;
+  }; /** Named built-in frame set; ignored when `frames` is provided. */
+  preset: {
+    type: PropType<SpinnerPreset>;
+    default: string;
+  }; /** Milliseconds between frames. */
+  interval: {
+    type: NumberConstructor;
+    default: number;
+  }; /** Spinner color; defaults to the active theme's accent. */
+  color: {
+    type: PropType<ColorProp>;
+    default: undefined;
+  }; /** Optional label rendered after the spinner glyph. */
+  label: {
+    type: StringConstructor;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  label: string;
+  frames: string[];
+  preset: "toggle" | "braille" | "dots" | "line" | "bounce" | "arc" | "circle" | "arrow" | "pulse";
+  interval: number;
+  color: ColorProp;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/animation/use-timeline.d.ts
+/** A timeline handle: spawn tweens that the component owns and that clean up on unmount. */
+interface Timeline {
+  /** Start a tween; it auto-registers with the scheduler and is cancelled on unmount. */
+  animate(opts: AnimateOptions): Animation;
+  /** Cancel every tween this timeline started (also run automatically on unmount). */
+  stop(): void;
+}
+/**
+ * Create a component-scoped timeline. Tweens started via the returned `animate`
+ * are driven by the shared frame loop and cancelled when the component unmounts.
+ */
+declare function useTimeline(): Timeline;
+/**
+ * Convenience wrapper for the common one-tween case: start a single animation and
+ * get its handle. Equivalent to `useTimeline().animate(opts)`.
+ */
+declare function useAnimation(opts: AnimateOptions): Animation;
+//#endregion
+//#region src/host/highlighter.d.ts
+/** One highlighted line: an ordered list of styled runs (alias of `TextRun[]`). */
+type StyledLine = TextRun[];
+/** A swappable syntax engine. Returns one `StyledLine` per source line. */
+interface Highlighter {
+  highlight(code: string, lang?: string): StyledLine[];
+}
+/**
+ * Color + attrs for a highlight scope. Keyed by highlight.js scope name (the part
+ * after `hljs-`). Values are author-friendly color strings OR packed `0xRRGGBBAA`
+ * numbers (e.g. from a `Theme`), resolved once via `parseColor`. Tuned for a dark
+ * theme (Catppuccin Mocha); override via `createDefaultHighlighter`.
+ */
+interface SyntaxPalette {
+  [scope: string]: string | number;
+}
+/**
+ * Build a syntax palette from a theme's `syntax*` tokens. Returned partial overrides
+ * the built-in defaults in `createDefaultHighlighter`, so `<code>`/`<markdown>`
+ * fences recolor with the active theme (and on a runtime `setTheme()`).
+ */
+declare function syntaxPaletteFromTheme(theme: Theme): SyntaxPalette;
+/**
+ * The built-in highlighter: highlight.js over a registered set of common
+ * languages (ts/js/rust/python/go/json/bash/html/css), adapted to styled runs.
+ * Unknown or omitted languages fall back to uncolored lines — never throws.
+ */
+declare function createDefaultHighlighter(palette?: SyntaxPalette): Highlighter;
+/** The shared default highlighter instance used by `<code>`/`<markdown>`. */
+declare const defaultHighlighter: Highlighter;
+//#endregion
+//#region src/host/components/markdown.d.ts
+declare const VuiMarkdown: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Markdown source. */content: {
+    type: StringConstructor;
+    default: string;
+  }; /** Highlighter for fenced code; defaults to the built-in highlight.js one. */
+  highlighter: {
+    type: PropType<Highlighter>;
+    default: undefined;
+  };
+}>, () => VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Markdown source. */content: {
+    type: StringConstructor;
+    default: string;
+  }; /** Highlighter for fenced code; defaults to the built-in highlight.js one. */
+  highlighter: {
+    type: PropType<Highlighter>;
+    default: undefined;
+  };
+}>> & Readonly<{}>, {
+  content: string;
+  highlighter: Highlighter;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/components/code.d.ts
+declare const VuiCode: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Source code to render. */text: {
+    type: StringConstructor;
+    default: string;
+  }; /** Language id/extension (ts, js, rust, python, go, …); omit for no color. */
+  lang: {
+    type: StringConstructor;
+    default: undefined;
+  }; /** Swappable engine; defaults to the built-in highlight.js highlighter. */
+  highlighter: {
+    type: PropType<Highlighter>;
+    default: undefined;
+  }; /** Render a left line-number gutter. */
+  lineNumbers: {
+    type: BooleanConstructor;
+    default: boolean;
+  }; /** Wrap mode for long lines; code defaults to `nowrap` (clip/scroll). */
+  wrap: {
+    type: PropType<TextWrapMode$1>;
+    default: string;
+  };
+}>, () => VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Source code to render. */text: {
+    type: StringConstructor;
+    default: string;
+  }; /** Language id/extension (ts, js, rust, python, go, …); omit for no color. */
+  lang: {
+    type: StringConstructor;
+    default: undefined;
+  }; /** Swappable engine; defaults to the built-in highlight.js highlighter. */
+  highlighter: {
+    type: PropType<Highlighter>;
+    default: undefined;
+  }; /** Render a left line-number gutter. */
+  lineNumbers: {
+    type: BooleanConstructor;
+    default: boolean;
+  }; /** Wrap mode for long lines; code defaults to `nowrap` (clip/scroll). */
+  wrap: {
+    type: PropType<TextWrapMode$1>;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  wrap: TextWrapMode$1;
+  text: string;
+  highlighter: Highlighter;
+  lang: string;
+  lineNumbers: boolean;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/components/diff.d.ts
+declare const VuiDiff: import("@vue/runtime-core").DefineComponent<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Unified-diff text (`git diff` output). */patch: {
+    type: StringConstructor;
+    default: string;
+  }; /** `unified` (default). `split` is accepted but renders unified for now. */
+  mode: {
+    type: PropType<"unified" | "split">;
+    default: string;
+  }; /** Render an old/new line-number gutter. */
+  lineNumbers: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>, () => import("@vue/runtime-core").VNode<import("@vue/runtime-core").RendererNode, import("@vue/runtime-core").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("@vue/runtime-core").ComponentOptionsMixin, import("@vue/runtime-core").ComponentOptionsMixin, {}, string, import("@vue/runtime-core").PublicProps, Readonly<import("@vue/runtime-core").ExtractPropTypes<{
+  /** Unified-diff text (`git diff` output). */patch: {
+    type: StringConstructor;
+    default: string;
+  }; /** `unified` (default). `split` is accepted but renders unified for now. */
+  mode: {
+    type: PropType<"unified" | "split">;
+    default: string;
+  }; /** Render an old/new line-number gutter. */
+  lineNumbers: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>> & Readonly<{}>, {
+  mode: "split" | "unified";
+  lineNumbers: boolean;
+  patch: string;
+}, {}, {}, {}, string, import("@vue/runtime-core").ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/host/markdown-parser.d.ts
+/** An inline run with the formatting flags a `<span>` can carry. */
+interface MdSpan {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  strike?: boolean;
+  /** Inline `code` span — rendered with the code accent + subtle background. */
+  code?: boolean;
+  /** Link target (text is the visible label); rendered underlined. */
+  href?: string;
+}
+interface MdHeading {
+  type: 'heading';
+  level: number;
+  spans: MdSpan[];
+}
+interface MdParagraph {
+  type: 'paragraph';
+  spans: MdSpan[];
+}
+interface MdCode {
+  type: 'code';
+  text: string;
+  lang?: string;
+}
+interface MdListItem {
+  spans: MdSpan[];
+  /** Nested sub-list, if any. */
+  children?: MdList;
+}
+interface MdList {
+  type: 'list';
+  ordered: boolean;
+  start: number;
+  items: MdListItem[];
+}
+interface MdBlockquote {
+  type: 'blockquote';
+  blocks: MdBlock[];
+}
+interface MdHr {
+  type: 'hr';
+}
+interface MdTable {
+  type: 'table';
+  header: MdSpan[][];
+  rows: MdSpan[][][];
+}
+type MdBlock = MdHeading | MdParagraph | MdCode | MdList | MdBlockquote | MdHr | MdTable;
+/** Parse markdown source into a flat list of renderable blocks. */
+declare function parseMarkdown(content: string): MdBlock[];
+//#endregion
+//#region src/host/diff-parser.d.ts
+type DiffLineKind = 'meta' | 'hunk' | 'add' | 'del' | 'context';
+interface DiffLine {
+  kind: DiffLineKind;
+  /** Line content without the leading +/-/space marker. */
+  text: string;
+  /** 1-based line number in the old file (del/context), else undefined. */
+  oldNo?: number;
+  /** 1-based line number in the new file (add/context), else undefined. */
+  newNo?: number;
+}
+/** Parse a unified-diff patch into classified, line-numbered rows. */
+declare function parseUnifiedDiff(patch: string): DiffLine[];
+//#endregion
+//#region src/vui-elements.d.ts
+/** A color: a CSS/hex/name string or a packed `0xRRGGBBAA` number (see `rgba`). */
+type Color = string | number;
+/** Layout props — folded into the node's taffy style (mirror of `VuiStyle`). */
+interface LayoutProps {
+  display?: 'flex' | 'none';
+  position?: 'relative' | 'absolute';
+  flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+  flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+  alignItems?: AlignValue;
+  alignSelf?: AlignValue;
+  justifyContent?: JustifyValue;
+  flexGrow?: number;
+  flexShrink?: number;
+  flexBasis?: Dim;
+  width?: Dim;
+  height?: Dim;
+  minWidth?: Dim;
+  minHeight?: Dim;
+  maxWidth?: Dim;
+  maxHeight?: Dim;
+  padding?: Sides;
+  margin?: Sides;
+  inset?: Sides;
+  /** Per-side `inset` shorthands (absolute positioning). */
+  top?: Dim;
+  right?: Dim;
+  bottom?: Dim;
+  left?: Dim;
+  gap?: number | {
+    width?: number;
+    height?: number;
+  };
+  /** Border thickness in layout cells; `border` (paint) sets this implicitly. */
+  borderWidth?: Dim;
+  /** A whole `VuiStyle` object, spread through `patchProp`. */
+  style?: VuiStyle;
+}
+/** Paint props — applied immediately to the Rust node (`set_*`). */
+interface PaintProps {
+  bg?: Color;
+  backgroundColor?: Color;
+  fg?: Color;
+  color?: Color;
+  /** Raw attribute bitmask (OR of `Attr.*`); the boolean flags below OR onto it. */
+  attrs?: number;
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+  border?: boolean | 'none' | 'single' | 'double' | 'rounded';
+  borderColor?: Color;
+  title?: string;
+  titleAlign?: 'left' | 'center' | 'right';
+  visible?: boolean;
+  opacity?: number;
+  wrap?: 'word' | 'char' | 'nowrap';
+  /**
+   * Clip children to this box's content box. `visible` (default) lets them
+   * spill; `hidden`/`scroll` make it a viewport (`scroll` pairs with scrollY).
+   */
+  overflow?: 'visible' | 'hidden' | 'scroll';
+  /** Paint order among siblings; higher draws on top (default 0). */
+  zIndex?: number;
+}
+/** Focus + keyboard event props (dispatched by the focus manager). */
+interface FocusProps {
+  /** Participate in Tab focus traversal. */
+  focusable?: boolean;
+  /** Controlled focus: focus this node on mount / when true. */
+  focused?: boolean;
+  onKeyDown?: (ev: DispatchableEvent) => void;
+  onPaste?: (ev: DispatchableEvent) => void;
+  onMouseDown?: (ev: DispatchableMouseEvent) => void;
+  onMouseUp?: (ev: DispatchableMouseEvent) => void;
+  onMouseMove?: (ev: DispatchableMouseEvent) => void;
+  onWheel?: (ev: DispatchableMouseEvent) => void;
+  onFocus?: () => void;
+  onBlur?: () => void;
+}
+/** `<box>` — a flex container; the only element that may hold boxes/text. */
+type BoxProps = LayoutProps & PaintProps & FocusProps;
+/** `<text>` — holds strings + inline run-style tags; sizes/colors its content. */
+type TextProps = LayoutProps & PaintProps & FocusProps;
+interface ScrollProps {
+  /** Paint-time child offset; layout still measures the full child tree. */
+  scrollX?: number;
+  scrollY?: number;
+}
+/**
+ * Inline run-style tags (`<span>`/`<b>`/`<i>`/`<u>`/`<em>`/`<strong>`) — virtual
+ * nodes that fold style into the enclosing `<text>`'s runs. They take only run
+ * style, not layout.
+ */
+interface SpanProps {
+  fg?: Color;
+  color?: Color;
+  bg?: Color;
+  backgroundColor?: Color;
+  attrs?: number;
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+}
+/**
+ * `<input>` — resolves to the `VuiInput` component (registered globally in
+ * create-app.ts). v-model uses `value` / `update:value`; both `v-model:value`
+ * and bare `v-model` type-check (the latter via the `modelValue` aliases here,
+ * which the build-time directive transform rewrites to `value`). Layout/paint
+ * props fall through to the underlying edit node.
+ */
+interface InputProps extends LayoutProps, PaintProps, FocusProps {
+  value?: string;
+  /** Alias so bare `v-model` type-checks; rewritten to `value` at build time. */
+  modelValue?: string;
+  placeholder?: string;
+  placeholderColor?: Color;
+  cursorColor?: Color;
+  maxLength?: number;
+  'onUpdate:value'?: (value: string) => void;
+  'onUpdate:modelValue'?: (value: string) => void;
+  onInput?: (value: string) => void;
+  onChange?: (value: string) => void;
+  onEnter?: (value: string) => void;
+}
+/** `<textarea>` — multi-line native-backed editor. */
+interface TextareaProps extends LayoutProps, PaintProps, FocusProps {
+  value?: string;
+  modelValue?: string;
+  placeholder?: string;
+  placeholderColor?: Color;
+  cursorColor?: Color;
+  wrap?: 'word' | 'char' | 'nowrap';
+  tabBehavior?: 'focus' | 'indent';
+  tabSize?: number;
+  'onUpdate:value'?: (value: string) => void;
+  'onUpdate:modelValue'?: (value: string) => void;
+  onInput?: (value: string) => void;
+  onChange?: (value: string) => void;
+  onEnter?: (value: string) => void;
+}
+/**
+ * `<canvas>` — first-class custom drawing (JS host). `@draw` receives a clamped,
+ * clipped `CanvasContext` (local 0-based coords) + the laid-out rect; `buffered`
+ * switches to an offscreen framebuffer that re-runs `@draw` only on change.
+ */
+interface CanvasProps extends LayoutProps, PaintProps, FocusProps {
+  buffered?: boolean;
+  onDraw?: (ctx: CanvasContext, rect: CanvasRect) => void;
+}
+interface ScrollBoxProps extends LayoutProps, PaintProps, FocusProps {
+  modelValue?: number;
+  scrollY?: number;
+  step?: number;
+  pageStep?: number;
+  /** Pin the view to the bottom as content grows (chat/transcript). */
+  stickToBottom?: boolean;
+  /** Render an integrated vertical scrollbar (indicator + drag) on the right edge. */
+  scrollbar?: boolean;
+  'onUpdate:modelValue'?: (value: number) => void;
+  'onUpdate:scrollY'?: (value: number) => void;
+  onScroll?: (value: number) => void;
+}
+interface ScrollBarProps extends LayoutProps, PaintProps, FocusProps {
+  scrollY?: number;
+  viewportHeight: number;
+  contentHeight: number;
+  thumbBg?: Color;
+  trackBg?: Color;
+  'onUpdate:scrollY'?: (value: number) => void;
+  onScroll?: (value: number) => void;
+}
+/**
+ * `<overlay>` — a top-layer box (modal/dialog/toast). Laid out absolute over the
+ * whole terminal by default and drawn on top of the tree, ignoring ancestor
+ * clips. `backdrop` dims everything behind it (opaque).
+ */
+interface OverlayProps extends LayoutProps, PaintProps, FocusProps {
+  /** Opaque dim layer behind the overlay: `true` (default dim), a `0..1`
+   * brightness multiplier, or `{ darken }`. Omit for no backdrop. */
+  backdrop?: boolean | number | {
+    darken?: number;
+  };
+  /** Confine Tab/Shift-Tab focus to this overlay's subtree while open (modal).
+   * Default `false`; non-trapping overlays (toasts/popups) keep the tab order. */
+  trapFocus?: boolean;
+}
+type SelectItemValue$1 = string | number;
+type SelectItem$1 = SelectItemValue$1 | {
+  label: string;
+  value: SelectItemValue$1;
+  disabled?: boolean;
+};
+interface SelectListProps extends LayoutProps, PaintProps, FocusProps {
+  items: SelectItem$1[];
+  modelValue?: SelectItemValue$1;
+  activeBg?: Color;
+  activeFg?: Color;
+  selectedBg?: Color;
+  selectedFg?: Color;
+  'onUpdate:modelValue'?: (value: SelectItemValue$1) => void;
+  onSelect?: (value: SelectItemValue$1, item: SelectItem$1, index: number) => void;
+  onActive?: (index: number) => void;
+}
+/**
+ * `<markdown>` — renders a markdown string into box/text/span. Inline emphasis
+ * folds into styled runs; fenced code is delegated to `<code>`. `highlighter`
+ * swaps the syntax engine used for fences.
+ */
+interface MarkdownProps extends LayoutProps, PaintProps {
+  content?: string;
+  highlighter?: Highlighter;
+}
+/** `<code>` — a syntax-highlighted code block (pluggable highlighter). */
+interface CodeProps extends LayoutProps, PaintProps {
+  text?: string;
+  lang?: string;
+  highlighter?: Highlighter;
+  lineNumbers?: boolean;
+  wrap?: 'word' | 'char' | 'nowrap';
+}
+/** `<diff>` — a unified-diff viewer (split mode deferred). */
+interface DiffProps extends LayoutProps, PaintProps {
+  patch?: string;
+  mode?: 'unified' | 'split';
+  lineNumbers?: boolean;
+}
+declare module '@vue/runtime-core' {
+  interface GlobalComponents {
+    box: DefineComponent<BoxProps & ScrollProps>;
+    text: DefineComponent<TextProps>;
+    span: DefineComponent<SpanProps>;
+    b: DefineComponent<SpanProps>;
+    i: DefineComponent<SpanProps>;
+    u: DefineComponent<SpanProps>;
+    em: DefineComponent<SpanProps>;
+    strong: DefineComponent<SpanProps>;
+    input: DefineComponent<InputProps>;
+    textarea: DefineComponent<TextareaProps>;
+    canvas: DefineComponent<CanvasProps>;
+    overlay: DefineComponent<OverlayProps & ScrollProps>;
+    'scroll-box': DefineComponent<ScrollBoxProps>;
+    'scroll-bar': DefineComponent<ScrollBarProps>;
+    'select-list': DefineComponent<SelectListProps>;
+    markdown: DefineComponent<MarkdownProps>;
+    code: DefineComponent<CodeProps>;
+    diff: DefineComponent<DiffProps>;
+  }
+}
+//#endregion
+//#region src/use-theme.d.ts
+/** The active theme for the current component (app theme, or a subtree override). */
+declare function useTheme(): Theme;
+/** Override the theme for this component's subtree; merges over the active theme. */
+declare function provideTheme(theme: Partial<Theme>): Theme;
+/**
+ * Returns a `setTheme(input, mode?)` that swaps the whole app theme at runtime —
+ * by registered name, theme JSON, full `Theme`, or partial override — with one
+ * coalesced re-render and no remount. `mode` defaults to the detected light/dark
+ * preference. Call inside a component (e.g. from a key handler).
+ */
+declare function useSetTheme(): (input: ThemeInput, mode?: 'dark' | 'light') => void;
+//#endregion
+//#region src/theme/contrast.d.ts
+/** Perceived luminance (0–1) of a packed color, ITU-R BT.601 weights. */
+declare function luminance(packed: number): number;
+/** Whether a background reads as "light" (luminance above the midpoint). */
+declare function isLight(packed: number): boolean;
+/**
+ * Choose a foreground color that contrasts with `bg`. On a light background returns
+ * `dark` (default black); on a dark background returns `light` (default white).
+ */
+declare function pickForeground(bg: number, opts?: {
+  light?: number;
+  dark?: number;
+}): number;
+//#endregion
+export { type AnimateOptions, type Animation, type AnimationRegistry, Attr, BUILTIN_THEMES, type Backdrop, type BoxProps, type CanvasContext, type CanvasDraw, type CanvasProps, type CanvasRect, CanvasRenderable, type CanvasStyle, type CatalogueEntry, type Color, type ColorValue, type DiffLine, type DiffLineKind, type DispatchableEvent, type DispatchableMouseEvent, type EasingFn, type EasingName, EditMotion, EditRenderable, type EditState, type HostFocusManager as FocusManager, type HostFocusManager, type Highlighter, type HostContext, HostContextSymbol, type HostMountOptions, type ImageEncoding, ImageRenderable, type InputEvent, type InputProps, Key, type KeyEvent, type MdBlock, type MdSpan, type MountOptions, type MouseEvent, type OverlayProps, OverlayRenderable, Renderable, type RenderableKind, SPINNER_PRESETS, type ScrollBarProps, type ScrollBoxProps, type SelectItem, type SelectItemValue, type SelectListProps, type SpanProps, type SpinnerPreset, type StyledLine, type SyntaxPalette, type TextProps, type TextWrapMode, type TextareaProps, TextareaRenderable, type TextareaState, type Theme, type ThemeInput, type ThemeJson, ThemeSymbol, type Timeline, type VuiApp, VuiCode, VuiDiff, type VuiHostApp, VuiHostInput, VuiHostInput as VuiInput, VuiHostTextarea, VuiHostTextarea as VuiTextarea, VuiMarkdown, VuiScrollBar, VuiScrollBox, VuiSelect, VuiSelectList, VuiSpinner, computed, createAnimation, createAnimationRegistry, createApp, createDefaultHighlighter, createHostFocusManager as createFocusManager, createHostFocusManager, createHostApp, darkTheme, defaultHighlighter, defineComponent, detectColorScheme, easings, extend, h, isLight, isVuiTag, lightTheme, listThemes, loadThemeFile, luminance, matchesKey, nextTick, onBeforeUnmount, onMounted, onUnmounted, parseColor, parseMarkdown, parseUnifiedDiff, pickForeground, provideTheme, reactive, ref, registerTheme, resolveEasing, resolveTheme, resolveThemeJson, rgba, selectImageEncoding, shallowReactive, shallowRef, syntaxPaletteFromTheme, toRef, toRefs, useAnimation, useSetTheme, useTheme, useTimeline, watch, watchEffect };