@vertz/tui 0.2.3

package/dist/index.js

@@ -0,0 +1,2374 @@
+import {
+  BORDER_CHARS,
+  defaultLayoutProps
+} from "./shared/chunk-5x9fb9b2.js";
+import {
+  TerminalBuffer,
+  TestAdapter
+} from "./shared/chunk-6y95cgnx.js";
+
+// src/index.ts
+import {
+  batch,
+  computed,
+  createContext as createContext2,
+  onMount,
+  signal as signal10,
+  useContext as useContext2
+} from "@vertz/ui";
+
+// src/app.ts
+import { lifecycleEffect, popScope as popScope2, pushScope as pushScope2, runCleanups as runCleanups2 } from "@vertz/ui/internals";
+
+// src/input/key-parser.ts
+function parseKey(data) {
+  const str = data.toString("utf8");
+  const code = str.charCodeAt(0);
+  if (str.startsWith("\x1B")) {
+    return parseEscapeSequence(str);
+  }
+  if (str === "\r" || str === `
+`) {
+    return { name: "return", char: "", ctrl: false, shift: false, meta: false };
+  }
+  if (str === "\t") {
+    return { name: "tab", char: "", ctrl: false, shift: false, meta: false };
+  }
+  if (code === 127 || code === 8) {
+    return { name: "backspace", char: "", ctrl: false, shift: false, meta: false };
+  }
+  if (str === " ") {
+    return { name: "space", char: " ", ctrl: false, shift: false, meta: false };
+  }
+  if (str.length === 1 && code >= 1 && code <= 26) {
+    const letter = String.fromCharCode(code + 96);
+    return { name: letter, char: "", ctrl: true, shift: false, meta: false };
+  }
+  if (str.length === 1) {
+    return { name: str, char: str, ctrl: false, shift: false, meta: false };
+  }
+  return { name: str, char: str, ctrl: false, shift: false, meta: false };
+}
+function parseEscapeSequence(str) {
+  if (str === "\x1B") {
+    return { name: "escape", char: "", ctrl: false, shift: false, meta: false };
+  }
+  if (str.startsWith("\x1B[")) {
+    const seq = str.slice(2);
+    switch (seq) {
+      case "A":
+        return { name: "up", char: "", ctrl: false, shift: false, meta: false };
+      case "B":
+        return { name: "down", char: "", ctrl: false, shift: false, meta: false };
+      case "C":
+        return { name: "right", char: "", ctrl: false, shift: false, meta: false };
+      case "D":
+        return { name: "left", char: "", ctrl: false, shift: false, meta: false };
+      case "H":
+        return { name: "home", char: "", ctrl: false, shift: false, meta: false };
+      case "F":
+        return { name: "end", char: "", ctrl: false, shift: false, meta: false };
+      case "3~":
+        return { name: "delete", char: "", ctrl: false, shift: false, meta: false };
+      case "5~":
+        return { name: "pageup", char: "", ctrl: false, shift: false, meta: false };
+      case "6~":
+        return { name: "pagedown", char: "", ctrl: false, shift: false, meta: false };
+      case "Z":
+        return { name: "tab", char: "", ctrl: false, shift: true, meta: false };
+      case "1;5A":
+        return { name: "up", char: "", ctrl: true, shift: false, meta: false };
+      case "1;5B":
+        return { name: "down", char: "", ctrl: true, shift: false, meta: false };
+      case "1;5C":
+        return { name: "right", char: "", ctrl: true, shift: false, meta: false };
+      case "1;5D":
+        return { name: "left", char: "", ctrl: true, shift: false, meta: false };
+    }
+  }
+  if (str.length === 2 && str[1]) {
+    return { name: str[1], char: str[1], ctrl: false, shift: false, meta: true };
+  }
+  return { name: str, char: "", ctrl: false, shift: false, meta: false };
+}
+
+// src/input/stdin-reader.ts
+class StdinReader {
+  _stdin;
+  _listeners = [];
+  _onData = null;
+  _wasRaw;
+  constructor(stdin) {
+    this._stdin = stdin ?? process.stdin;
+    this._wasRaw = this._stdin.isRaw ?? false;
+  }
+  start() {
+    if (this._onData)
+      return;
+    if (typeof this._stdin.setRawMode === "function") {
+      this._stdin.setRawMode(true);
+    }
+    this._stdin.resume();
+    this._onData = (data) => {
+      const key = parseKey(data);
+      for (const listener of this._listeners) {
+        listener(key);
+      }
+      if (key.ctrl && key.name === "c") {
+        process.exit(130);
+      }
+    };
+    this._stdin.on("data", this._onData);
+  }
+  stop() {
+    if (this._onData) {
+      this._stdin.off("data", this._onData);
+      this._onData = null;
+    }
+    if (typeof this._stdin.setRawMode === "function") {
+      this._stdin.setRawMode(this._wasRaw);
+    }
+    this._stdin.pause();
+  }
+  onKey(listener) {
+    this._listeners.push(listener);
+    return () => {
+      const idx = this._listeners.indexOf(listener);
+      if (idx !== -1)
+        this._listeners.splice(idx, 1);
+    };
+  }
+  dispose() {
+    this.stop();
+    this._listeners = [];
+  }
+}
+
+// src/internals.ts
+import { _tryOnCleanup, domEffect, popScope, pushScope, runCleanups } from "@vertz/ui/internals";
+
+// src/tui-element.ts
+function isTuiElement(value) {
+  return typeof value === "object" && value !== null && "_tuiElement" in value;
+}
+function isTuiTextNode(value) {
+  return typeof value === "object" && value !== null && "_tuiText" in value;
+}
+function isTuiConditionalNode(value) {
+  return typeof value === "object" && value !== null && "_tuiConditional" in value;
+}
+function isTuiListNode(value) {
+  return typeof value === "object" && value !== null && "_tuiList" in value;
+}
+
+// src/internals.ts
+var renderCallback = null;
+var renderScheduled = false;
+var syncRender = false;
+function setRenderCallback(cb) {
+  renderCallback = cb;
+}
+function setSyncRender(sync) {
+  syncRender = sync;
+}
+function scheduleRender() {
+  if (!renderCallback)
+    return;
+  if (syncRender) {
+    renderCallback();
+    return;
+  }
+  if (renderScheduled)
+    return;
+  renderScheduled = true;
+  queueMicrotask(() => {
+    renderScheduled = false;
+    renderCallback?.();
+  });
+}
+function applyProp(el, key, value) {
+  el.props[key] = value;
+  switch (key) {
+    case "direction":
+      if (value === "row" || value === "column")
+        el.layoutProps.direction = value;
+      break;
+    case "padding":
+      if (typeof value === "number")
+        el.layoutProps.padding = value;
+      break;
+    case "paddingX":
+      if (typeof value === "number")
+        el.layoutProps.paddingX = value;
+      break;
+    case "paddingY":
+      if (typeof value === "number")
+        el.layoutProps.paddingY = value;
+      break;
+    case "gap":
+      if (typeof value === "number")
+        el.layoutProps.gap = value;
+      break;
+    case "width":
+      if (typeof value === "number" || value === "full")
+        el.layoutProps.width = value;
+      break;
+    case "height":
+      if (typeof value === "number")
+        el.layoutProps.height = value;
+      break;
+    case "grow":
+      if (typeof value === "number")
+        el.layoutProps.grow = value;
+      break;
+    case "align":
+      if (value === "start" || value === "center" || value === "end")
+        el.layoutProps.align = value;
+      break;
+    case "justify":
+      if (value === "start" || value === "center" || value === "end" || value === "between") {
+        el.layoutProps.justify = value;
+      }
+      break;
+    case "border":
+      if (value === "single" || value === "double" || value === "round" || value === "bold" || value === "none") {
+        el.layoutProps.border = value;
+      }
+      break;
+    case "color":
+      if (typeof value === "string")
+        el.style.color = value;
+      break;
+    case "bgColor":
+    case "borderColor":
+      if (typeof value === "string")
+        el.style.bgColor = value;
+      break;
+    case "bold":
+      el.style.bold = value === true ? true : undefined;
+      break;
+    case "dim":
+      el.style.dim = value === true ? true : undefined;
+      break;
+    case "italic":
+      el.style.italic = value === true ? true : undefined;
+      break;
+    case "underline":
+      el.style.underline = value === true ? true : undefined;
+      break;
+    case "strikethrough":
+      el.style.strikethrough = value === true ? true : undefined;
+      break;
+  }
+}
+function __element(tag, ...staticAttrs) {
+  const el = {
+    _tuiElement: true,
+    tag,
+    props: {},
+    style: {},
+    layoutProps: defaultLayoutProps(),
+    children: [],
+    parent: null,
+    dirty: false,
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+  for (let i = 0;i < staticAttrs.length; i += 2) {
+    const key = staticAttrs[i];
+    const value = staticAttrs[i + 1];
+    applyProp(el, key, value);
+  }
+  return el;
+}
+function __staticText(text) {
+  return {
+    _tuiText: true,
+    text,
+    style: {},
+    dirty: false,
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function __child(fn) {
+  const node = {
+    _tuiText: true,
+    text: "",
+    style: {},
+    dirty: false,
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+  domEffect(() => {
+    const value = fn();
+    if (value == null || typeof value === "boolean") {
+      node.text = "";
+    } else {
+      node.text = String(value);
+    }
+    node.dirty = true;
+    scheduleRender();
+  });
+  return node;
+}
+function __append(parent, child) {
+  parent.children.push(child);
+  if (isTuiElement(child)) {
+    child.parent = parent;
+  }
+}
+
+// src/renderer/ansi.ts
+var FG_COLORS = {
+  black: "30",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  magenta: "35",
+  cyan: "36",
+  white: "37",
+  gray: "90",
+  redBright: "91",
+  greenBright: "92",
+  yellowBright: "93",
+  blueBright: "94",
+  magentaBright: "95",
+  cyanBright: "96",
+  whiteBright: "97"
+};
+var BG_COLORS = {
+  black: "40",
+  red: "41",
+  green: "42",
+  yellow: "43",
+  blue: "44",
+  magenta: "45",
+  cyan: "46",
+  white: "47",
+  gray: "100",
+  redBright: "101",
+  greenBright: "102",
+  yellowBright: "103",
+  blueBright: "104",
+  magentaBright: "105",
+  cyanBright: "106",
+  whiteBright: "107"
+};
+function hexToAnsi(hex, isBg) {
+  const clean = hex.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(clean))
+    return "";
+  const r = Number.parseInt(clean.slice(0, 2), 16);
+  const g = Number.parseInt(clean.slice(2, 4), 16);
+  const b = Number.parseInt(clean.slice(4, 6), 16);
+  return `${isBg ? "48" : "38"};2;${r};${g};${b}`;
+}
+function styleToSGR(style) {
+  const codes = [];
+  if (style.bold)
+    codes.push("1");
+  if (style.dim)
+    codes.push("2");
+  if (style.italic)
+    codes.push("3");
+  if (style.underline)
+    codes.push("4");
+  if (style.strikethrough)
+    codes.push("9");
+  if (style.color) {
+    if (style.color.startsWith("#")) {
+      const hex = hexToAnsi(style.color, false);
+      if (hex)
+        codes.push(hex);
+    } else {
+      const code = FG_COLORS[style.color];
+      if (code)
+        codes.push(code);
+    }
+  }
+  if (style.bgColor) {
+    if (style.bgColor.startsWith("#")) {
+      const hex = hexToAnsi(style.bgColor, true);
+      if (hex)
+        codes.push(hex);
+    } else {
+      const code = BG_COLORS[style.bgColor];
+      if (code)
+        codes.push(code);
+    }
+  }
+  if (codes.length === 0)
+    return "";
+  return `\x1B[${codes.join(";")}m`;
+}
+function cursorTo(row, col) {
+  return `\x1B[${row + 1};${col + 1}H`;
+}
+var RESET = "\x1B[0m";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR_SCREEN = "\x1B[2J";
+var ALT_BUFFER_ON = "\x1B[?1049h";
+var ALT_BUFFER_OFF = "\x1B[?1049l";
+var CURSOR_HOME = "\x1B[H";
+function renderCell(cell) {
+  const sgr = styleToSGR(cell.style);
+  if (sgr) {
+    return `${sgr}${cell.char}${RESET}`;
+  }
+  return cell.char;
+}
+function renderRegions(regions) {
+  let output = "";
+  for (const region of regions) {
+    output += cursorTo(region.row, region.col);
+    for (const cell of region.cells) {
+      output += renderCell(cell);
+    }
+  }
+  return output;
+}
+
+// src/renderer/output-adapter.ts
+class StdoutAdapter {
+  _stdout;
+  constructor(stdout) {
+    this._stdout = stdout ?? process.stdout;
+  }
+  write(data) {
+    this._stdout.write(data);
+  }
+  get columns() {
+    return this._stdout.columns ?? 80;
+  }
+  get rows() {
+    return this._stdout.rows ?? 24;
+  }
+}
+
+// src/layout/measure.ts
+function measureTextWidth(text) {
+  const stripped = stripAnsi(text);
+  let width = 0;
+  for (const char of stripped) {
+    width += charWidth(char);
+  }
+  return width;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function charWidth(char) {
+  const code = char.codePointAt(0);
+  if (code === undefined)
+    return 0;
+  if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 43360 && code <= 43391 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 131072 && code <= 196605 || code >= 196608 && code <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function splitTextLines(text, maxWidth) {
+  if (maxWidth <= 0)
+    return [""];
+  const lines = text.split(`
+`);
+  const result = [];
+  for (const line of lines) {
+    if (measureTextWidth(line) <= maxWidth) {
+      result.push(line);
+    } else {
+      let current = "";
+      let currentWidth = 0;
+      for (const char of line) {
+        const w = charWidth(char);
+        if (currentWidth + w > maxWidth)
+          break;
+        current += char;
+        currentWidth += w;
+      }
+      result.push(current);
+    }
+  }
+  return result;
+}
+
+// src/layout/compute.ts
+function computeLayout(root, constraints) {
+  computeSize(root, constraints);
+  assignPosition(root, 0, 0);
+}
+function computeSize(node, constraints) {
+  const { props } = node;
+  const hasBorder = props.border !== "none";
+  const borderInset = hasBorder ? 2 : 0;
+  const padX = (props.paddingX || props.padding) * 2;
+  const padY = (props.paddingY || props.padding) * 2;
+  let resolvedWidth;
+  if (props.width === "full") {
+    resolvedWidth = constraints.maxWidth;
+  } else if (typeof props.width === "number") {
+    resolvedWidth = Math.min(props.width, constraints.maxWidth);
+  } else {
+    resolvedWidth = constraints.maxWidth;
+  }
+  const innerMaxWidth = Math.max(0, resolvedWidth - padX - borderInset);
+  const innerMaxHeight = Math.max(0, constraints.maxHeight - padY - borderInset);
+  if (node.type === "text") {
+    const text = node.text ?? "";
+    const lines = splitTextLines(text, innerMaxWidth);
+    const textWidth = lines.reduce((max, line) => Math.max(max, measureTextWidth(line)), 0);
+    const textHeight = lines.length;
+    if (props.width === "full" || typeof props.width === "number") {
+      node.box.width = resolvedWidth;
+    } else {
+      node.box.width = Math.min(textWidth + padX + borderInset, constraints.maxWidth);
+    }
+    node.box.height = Math.min(typeof props.height === "number" ? props.height : textHeight + padY + borderInset, constraints.maxHeight);
+    return;
+  }
+  const childConstraints = {
+    maxWidth: innerMaxWidth,
+    maxHeight: innerMaxHeight
+  };
+  for (const child of node.children) {
+    computeSize(child, childConstraints);
+  }
+  let contentWidth = 0;
+  let contentHeight = 0;
+  const visibleChildren = node.children.filter((c) => c.box.width > 0 || c.box.height > 0);
+  const gapTotal = Math.max(0, visibleChildren.length - 1) * props.gap;
+  if (props.direction === "row") {
+    for (const child of visibleChildren) {
+      contentWidth += child.box.width;
+      contentHeight = Math.max(contentHeight, child.box.height);
+    }
+    contentWidth += gapTotal;
+  } else {
+    for (const child of visibleChildren) {
+      contentWidth = Math.max(contentWidth, child.box.width);
+      contentHeight += child.box.height;
+    }
+    contentHeight += gapTotal;
+  }
+  const growChildren = visibleChildren.filter((c) => c.props.grow > 0);
+  if (growChildren.length > 0) {
+    if (props.direction === "row") {
+      const nonGrowWidth = visibleChildren.filter((c) => c.props.grow === 0).reduce((sum, c) => sum + c.box.width, 0);
+      const remaining = Math.max(0, innerMaxWidth - nonGrowWidth - gapTotal);
+      const totalGrow = growChildren.reduce((sum, c) => sum + c.props.grow, 0);
+      for (const child of growChildren) {
+        child.box.width = Math.floor(remaining * child.props.grow / totalGrow);
+      }
+      contentWidth = innerMaxWidth;
+    } else {
+      const nonGrowHeight = visibleChildren.filter((c) => c.props.grow === 0).reduce((sum, c) => sum + c.box.height, 0);
+      const remaining = Math.max(0, innerMaxHeight - nonGrowHeight - gapTotal);
+      const totalGrow = growChildren.reduce((sum, c) => sum + c.props.grow, 0);
+      for (const child of growChildren) {
+        child.box.height = Math.floor(remaining * child.props.grow / totalGrow);
+      }
+      contentHeight = innerMaxHeight;
+    }
+  }
+  if (props.width === "full") {
+    node.box.width = constraints.maxWidth;
+  } else if (typeof props.width === "number") {
+    node.box.width = Math.min(props.width, constraints.maxWidth);
+  } else {
+    node.box.width = Math.min(contentWidth + padX + borderInset, constraints.maxWidth);
+  }
+  node.box.height = Math.min(typeof props.height === "number" ? props.height : contentHeight + padY + borderInset, constraints.maxHeight);
+}
+function assignPosition(node, x, y) {
+  node.box.x = x;
+  node.box.y = y;
+  if (node.type === "text" || node.children.length === 0)
+    return;
+  const { props } = node;
+  const hasBorder = props.border !== "none";
+  const borderOffset = hasBorder ? 1 : 0;
+  const padLeft = (props.paddingX || props.padding) + borderOffset;
+  const padTop = (props.paddingY || props.padding) + borderOffset;
+  const padX = (props.paddingX || props.padding) * 2 + borderOffset * 2;
+  const padY = (props.paddingY || props.padding) * 2 + borderOffset * 2;
+  const innerWidth = Math.max(0, node.box.width - padX);
+  const innerHeight = Math.max(0, node.box.height - padY);
+  const visibleChildren = node.children.filter((c) => c.box.width > 0 || c.box.height > 0);
+  const gapTotal = Math.max(0, visibleChildren.length - 1) * props.gap;
+  if (props.direction === "row") {
+    const totalChildWidth = visibleChildren.reduce((sum, c) => sum + c.box.width, 0) + gapTotal;
+    let offsetX = computeJustifyOffset(props.justify, innerWidth, totalChildWidth, visibleChildren.length);
+    for (const child of visibleChildren) {
+      const offsetY = computeAlignOffset(props.align, innerHeight, child.box.height);
+      assignPosition(child, x + padLeft + offsetX, y + padTop + offsetY);
+      offsetX += child.box.width + props.gap;
+    }
+  } else {
+    const totalChildHeight = visibleChildren.reduce((sum, c) => sum + c.box.height, 0) + gapTotal;
+    let offsetY = computeJustifyOffset(props.justify, innerHeight, totalChildHeight, visibleChildren.length);
+    for (const child of visibleChildren) {
+      const offsetX = computeAlignOffset(props.align, innerWidth, child.box.width);
+      assignPosition(child, x + padLeft + offsetX, y + padTop + offsetY);
+      offsetY += child.box.height + props.gap;
+    }
+  }
+}
+function computeJustifyOffset(justify, totalSpace, contentSize, _childCount) {
+  switch (justify) {
+    case "start":
+      return 0;
+    case "center":
+      return Math.max(0, Math.floor((totalSpace - contentSize) / 2));
+    case "end":
+      return Math.max(0, totalSpace - contentSize);
+    case "between":
+      return 0;
+  }
+}
+function computeAlignOffset(align, totalSpace, childSize) {
+  switch (align) {
+    case "start":
+      return 0;
+    case "center":
+      return Math.max(0, Math.floor((totalSpace - childSize) / 2));
+    case "end":
+      return Math.max(0, totalSpace - childSize);
+  }
+}
+
+// src/nodes/types.ts
+function isTuiElement2(value) {
+  return typeof value === "object" && value !== null && "_tuiElement" in value;
+}
+function isTuiTextNode2(value) {
+  return typeof value === "object" && value !== null && "_tuiText" in value;
+}
+
+// src/renderer/paint.ts
+function toLayoutTree(node) {
+  if (node == null || node === false) {
+    return emptyLayoutNode();
+  }
+  if (Array.isArray(node)) {
+    return {
+      type: "box",
+      props: defaultLayoutProps(),
+      children: node.map((n) => toLayoutTree(n)),
+      box: { x: 0, y: 0, width: 0, height: 0 }
+    };
+  }
+  if (isTuiTextNode2(node)) {
+    return textToLayout(node);
+  }
+  if (isTuiConditionalNode(node)) {
+    if (node.current) {
+      return toLayoutTree(node.current);
+    }
+    return emptyLayoutNode();
+  }
+  if (isTuiListNode(node)) {
+    return {
+      type: "box",
+      props: defaultLayoutProps(),
+      children: node.items.map((item) => toLayoutTree(item)),
+      box: { x: 0, y: 0, width: 0, height: 0 }
+    };
+  }
+  if (isTuiElement2(node)) {
+    return elementToLayout(node);
+  }
+  return {
+    type: "text",
+    props: defaultLayoutProps(),
+    text: String(node),
+    children: [],
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function textToLayout(node) {
+  return {
+    type: "text",
+    props: defaultLayoutProps(),
+    text: node.text,
+    children: [],
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function elementToLayout(node) {
+  const { tag } = node;
+  if (tag === "Spacer") {
+    return {
+      type: "text",
+      props: { ...defaultLayoutProps(), grow: 1 },
+      text: "",
+      children: [],
+      box: { x: 0, y: 0, width: 0, height: 0 }
+    };
+  }
+  if (tag === "Text") {
+    const text = collectText(node.children);
+    return {
+      type: "text",
+      props: { ...defaultLayoutProps(), ...node.layoutProps },
+      style: node.style,
+      text,
+      children: [],
+      box: { x: 0, y: 0, width: 0, height: 0 }
+    };
+  }
+  const layoutChildren = node.children.map((child) => toLayoutTree(child));
+  return {
+    type: "box",
+    props: { ...defaultLayoutProps(), ...node.layoutProps },
+    children: layoutChildren,
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function collectText(children) {
+  let text = "";
+  for (const child of children) {
+    if (child == null || child === false)
+      continue;
+    if (Array.isArray(child)) {
+      text += collectText(child);
+    } else if (isTuiTextNode2(child) || isTuiTextNode(child)) {
+      text += child.text;
+    } else if (isTuiConditionalNode(child)) {
+      if (child.current) {
+        text += collectText([child.current]);
+      }
+    } else if (isTuiListNode(child)) {
+      text += collectText(child.items);
+    } else if (isTuiElement2(child)) {
+      text += collectText(child.children);
+    } else {
+      text += String(child);
+    }
+  }
+  return text;
+}
+function emptyLayoutNode() {
+  return {
+    type: "text",
+    props: defaultLayoutProps(),
+    text: "",
+    children: [],
+    box: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function paintTree(buffer, node, inheritedStyle, maxRows) {
+  if (node.type === "text") {
+    paintText(buffer, node, node.style ?? inheritedStyle, maxRows);
+    return;
+  }
+  if (node.props.border !== "none") {
+    paintBorder(buffer, node);
+  }
+  for (const child of node.children) {
+    paintTree(buffer, child, inheritedStyle, maxRows);
+  }
+}
+function paintText(buffer, node, style, maxRows) {
+  const text = node.text ?? "";
+  if (!text)
+    return;
+  const lines = splitTextLines(text, node.box.width);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined)
+      continue;
+    const row = node.box.y + i;
+    if (row >= maxRows)
+      break;
+    buffer.writeString(row, node.box.x, line, style);
+  }
+}
+function paintBorder(buffer, node) {
+  const borderStyle = node.props.border;
+  if (borderStyle === "none")
+    return;
+  const chars = BORDER_CHARS[borderStyle];
+  if (!chars)
+    return;
+  const { x, y, width, height } = node.box;
+  const style = {};
+  buffer.set(y, x, chars.topLeft, style);
+  for (let c = 1;c < width - 1; c++) {
+    buffer.set(y, x + c, chars.horizontal, style);
+  }
+  if (width > 1)
+    buffer.set(y, x + width - 1, chars.topRight, style);
+  if (height > 1) {
+    buffer.set(y + height - 1, x, chars.bottomLeft, style);
+    for (let c = 1;c < width - 1; c++) {
+      buffer.set(y + height - 1, x + c, chars.horizontal, style);
+    }
+    if (width > 1) {
+      buffer.set(y + height - 1, x + width - 1, chars.bottomRight, style);
+    }
+  }
+  for (let r = 1;r < height - 1; r++) {
+    buffer.set(y + r, x, chars.vertical, style);
+    if (width > 1)
+      buffer.set(y + r, x + width - 1, chars.vertical, style);
+  }
+}
+
+// src/renderer/renderer.ts
+class TuiRenderer {
+  _adapter;
+  _current;
+  _previous;
+  constructor(adapter) {
+    this._adapter = adapter;
+    this._current = new TerminalBuffer(adapter.columns, adapter.rows);
+    this._previous = new TerminalBuffer(adapter.columns, adapter.rows);
+  }
+  render(rootNode) {
+    this._current.clear();
+    const layoutRoot = toLayoutTree(rootNode);
+    computeLayout(layoutRoot, {
+      maxWidth: this._adapter.columns,
+      maxHeight: this._adapter.rows
+    });
+    paintTree(this._current, layoutRoot, {}, this._adapter.rows);
+    const regions = this._current.diff(this._previous);
+    if (regions.length > 0) {
+      const ansi = renderRegions(regions);
+      this._adapter.write(ansi);
+    }
+    this._previous = this._current.clone();
+  }
+  getBuffer() {
+    return this._current;
+  }
+}
+
+// src/app.ts
+var currentApp = null;
+function mount(app, options = {}) {
+  const mode = options.mode ?? "inline";
+  let adapter;
+  if (options.adapter) {
+    adapter = options.adapter;
+  } else {
+    adapter = new StdoutAdapter(options.stdout);
+  }
+  const renderer = new TuiRenderer(adapter);
+  if (mode === "fullscreen") {
+    adapter.write(HIDE_CURSOR + CLEAR_SCREEN + CURSOR_HOME);
+  } else if (mode === "alternate") {
+    adapter.write(ALT_BUFFER_ON + HIDE_CURSOR);
+  }
+  let exitResolve = null;
+  const exitPromise = new Promise((resolve) => {
+    exitResolve = resolve;
+  });
+  const ctx = {
+    renderer,
+    adapter,
+    mode,
+    disposed: false,
+    exitResolve,
+    testStdin: options.testStdin ?? null,
+    stdinReader: null,
+    stdinOptions: options.stdin,
+    scope: null,
+    effectCleanup: null,
+    rerenderFn: null,
+    componentStates: new Map,
+    stateIndex: 0
+  };
+  currentApp = ctx;
+  const isTestMode = adapter instanceof TestAdapter;
+  if (!options.testStdin) {
+    const stdinStream = options.stdin ?? (isTestMode ? undefined : process.stdin);
+    if (stdinStream) {
+      const reader = new StdinReader(stdinStream);
+      reader.start();
+      ctx.stdinReader = reader;
+    }
+  }
+  setSyncRender(isTestMode);
+  let rendering = false;
+  let dirty = false;
+  let lastTree = null;
+  const doRender = () => {
+    if (ctx.disposed)
+      return;
+    if (rendering) {
+      dirty = true;
+      return;
+    }
+    rendering = true;
+    try {
+      do {
+        dirty = false;
+        ctx.stateIndex = 0;
+        lastTree = app();
+        renderer.render(lastTree);
+        if (adapter instanceof TestAdapter) {
+          adapter.buffer = renderer.getBuffer();
+        }
+      } while (dirty);
+    } finally {
+      rendering = false;
+    }
+  };
+  ctx.rerenderFn = doRender;
+  const scope = pushScope2();
+  ctx.effectCleanup = lifecycleEffect(doRender);
+  popScope2();
+  ctx.scope = scope;
+  setRenderCallback(() => {
+    if (ctx.disposed)
+      return;
+    if (lastTree) {
+      renderer.render(lastTree);
+      if (adapter instanceof TestAdapter) {
+        adapter.buffer = renderer.getBuffer();
+      }
+    }
+  });
+  const handle = {
+    unmount() {
+      cleanup(ctx);
+    },
+    async waitUntilExit() {
+      await exitPromise;
+    },
+    output: adapter
+  };
+  return handle;
+}
+function cleanup(ctx) {
+  if (ctx.disposed)
+    return;
+  ctx.disposed = true;
+  setRenderCallback(null);
+  if (ctx.scope) {
+    runCleanups2(ctx.scope);
+    ctx.scope = null;
+  }
+  if (ctx.effectCleanup) {
+    ctx.effectCleanup();
+    ctx.effectCleanup = null;
+  }
+  if (ctx.stdinReader) {
+    ctx.stdinReader.dispose();
+    ctx.stdinReader = null;
+  }
+  if (ctx.mode === "fullscreen") {
+    ctx.adapter.write(SHOW_CURSOR);
+  } else if (ctx.mode === "alternate") {
+    ctx.adapter.write(ALT_BUFFER_OFF + SHOW_CURSOR);
+  }
+  if (ctx.exitResolve) {
+    ctx.exitResolve();
+    ctx.exitResolve = null;
+  }
+  if (currentApp === ctx) {
+    currentApp = null;
+  }
+}
+function exit() {
+  if (currentApp) {
+    cleanup(currentApp);
+  }
+}
+function getCurrentApp() {
+  return currentApp;
+}
+var tui = {
+  mount,
+  exit
+};
+// src/auth/device-code-auth.ts
+import { execFile } from "node:child_process";
+import { signal as signal2 } from "@vertz/ui";
+import { _tryOnCleanup as _tryOnCleanup4 } from "@vertz/ui/internals";
+
+// src/interactive.ts
+var CI_ENV_VARS = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "GITLAB_CI",
+  "CIRCLECI",
+  "TRAVIS",
+  "JENKINS_URL",
+  "BUILD_NUMBER",
+  "BUILDKITE",
+  "CODEBUILD_BUILD_ID",
+  "TF_BUILD"
+];
+function isInteractive() {
+  for (const envVar of CI_ENV_VARS) {
+    if (process.env[envVar])
+      return false;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY)
+    return false;
+  return true;
+}
+
+class NonInteractiveError extends Error {
+  constructor(promptType) {
+    super(`Cannot run interactive ${promptType} prompt in non-interactive environment. ` + "Provide a default value or run in an interactive terminal.");
+    this.name = "NonInteractiveError";
+  }
+}
+
+// src/theme.ts
+var symbols = Object.freeze({
+  success: "✓",
+  error: "✗",
+  warning: "⚠",
+  info: "ℹ",
+  arrow: "➜",
+  pointer: "❯",
+  bullet: "●",
+  dash: "─"
+});
+var colors = Object.freeze({
+  success: "greenBright",
+  error: "redBright",
+  warning: "yellowBright",
+  info: "cyanBright",
+  dim: "gray",
+  method: Object.freeze({
+    GET: "greenBright",
+    POST: "blueBright",
+    PUT: "yellowBright",
+    PATCH: "cyanBright",
+    DELETE: "redBright"
+  })
+});
+
+// src/components/Spinner.ts
+import { signal } from "@vertz/ui";
+import { _tryOnCleanup as _tryOnCleanup2 } from "@vertz/ui/internals";
+var SPINNER_FRAMES = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏"
+];
+function Spinner(props) {
+  const frameIndex = signal(0);
+  const timer = setInterval(() => {
+    frameIndex.value = (frameIndex.value + 1) % SPINNER_FRAMES.length;
+  }, 80);
+  _tryOnCleanup2(() => clearInterval(timer));
+  if (props.label) {
+    const box = __element("Box", "direction", "row", "gap", 1);
+    const spinnerText = __element("Text", "color", "cyan");
+    __append(spinnerText, __child(() => SPINNER_FRAMES[frameIndex.value]));
+    const labelText = __element("Text");
+    __append(labelText, __staticText(props.label));
+    __append(box, spinnerText);
+    __append(box, labelText);
+    return box;
+  }
+  const el = __element("Text", "color", "cyan");
+  __append(el, __child(() => SPINNER_FRAMES[frameIndex.value]));
+  return el;
+}
+
+// src/input/hooks.ts
+import { _tryOnCleanup as _tryOnCleanup3 } from "@vertz/ui/internals";
+var registeredCallbacks = new WeakSet;
+function useKeyboard(callback) {
+  if (registeredCallbacks.has(callback))
+    return;
+  registeredCallbacks.add(callback);
+  const app = getCurrentApp();
+  if (!app)
+    return;
+  let removeListener;
+  if (app.testStdin) {
+    removeListener = app.testStdin.onKey(callback);
+  } else if (app.stdinReader) {
+    removeListener = app.stdinReader.onKey(callback);
+  }
+  _tryOnCleanup3(() => {
+    registeredCallbacks.delete(callback);
+    removeListener?.();
+  });
+}
+
+// src/auth/device-code-display.ts
+function formatCountdown(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  if (m > 0)
+    return `${m}m ${s}s`;
+  return `${s}s`;
+}
+function DeviceCodeDisplay({
+  title = "Authenticate",
+  userCode,
+  verificationUri,
+  secondsRemaining,
+  status,
+  onCancel,
+  onOpenBrowser
+}) {
+  useKeyboard((key) => {
+    if (key.name === "escape" && onCancel) {
+      onCancel();
+    } else if (key.name === "return" && onOpenBrowser) {
+      onOpenBrowser();
+    }
+  });
+  const outer = __element("Box", "border", "round", "paddingX", 2, "paddingY", 1, "direction", "column");
+  const titleEl = __element("Text", "bold", true);
+  __append(titleEl, __staticText(title));
+  __append(outer, titleEl);
+  const spacer1 = __element("Text");
+  __append(spacer1, __staticText(""));
+  __append(outer, spacer1);
+  const urlRow = __element("Box", "direction", "row", "gap", 1);
+  const urlLabel = __element("Text", "dim", true);
+  __append(urlLabel, __staticText("Visit:"));
+  const urlValue = __element("Text");
+  __append(urlValue, __child(() => verificationUri.value));
+  __append(urlRow, urlLabel);
+  __append(urlRow, urlValue);
+  __append(outer, urlRow);
+  const codeRow = __element("Box", "direction", "row", "gap", 1);
+  const codeLabel = __element("Text", "dim", true);
+  __append(codeLabel, __staticText("Code:"));
+  const codeValue = __element("Text", "bold", true);
+  __append(codeValue, __child(() => userCode.value));
+  __append(codeRow, codeLabel);
+  __append(codeRow, codeValue);
+  __append(outer, codeRow);
+  const spacer2 = __element("Text");
+  __append(spacer2, __staticText(""));
+  __append(outer, spacer2);
+  const statusText = __element("Text");
+  __append(statusText, __child(() => {
+    const s = status.value;
+    const remaining = formatCountdown(secondsRemaining.value);
+    switch (s) {
+      case "awaiting-approval":
+      case "polling":
+        return `Waiting for approval... (${remaining})`;
+      case "success":
+        return `${symbols.success} Authenticated!`;
+      case "expired":
+        return `${symbols.warning} Code expired`;
+      case "denied":
+        return `${symbols.error} Authorization denied`;
+      case "error":
+        return `${symbols.error} Authentication failed`;
+      default:
+        return "";
+    }
+  }));
+  const spinnerContainer = __element("Box", "direction", "row", "gap", 1);
+  const spinnerEl = Spinner({});
+  __append(spinnerContainer, spinnerEl);
+  __append(spinnerContainer, statusText);
+  __append(outer, spinnerContainer);
+  const spacer3 = __element("Text");
+  __append(spacer3, __staticText(""));
+  __append(outer, spacer3);
+  const hint1 = __element("Text", "dim", true);
+  __append(hint1, __staticText("Press Enter to open browser"));
+  __append(outer, hint1);
+  const hint2 = __element("Text", "dim", true);
+  __append(hint2, __staticText("Press Esc to cancel"));
+  __append(outer, hint2);
+  return outer;
+}
+
+// src/auth/types.ts
+class AuthDeniedError extends Error {
+  constructor() {
+    super("Authorization request was denied by the user.");
+    this.name = "AuthDeniedError";
+  }
+}
+
+class AuthExpiredError extends Error {
+  constructor() {
+    super("Device code expired before authorization was completed.");
+    this.name = "AuthExpiredError";
+  }
+}
+
+class AuthCancelledError extends Error {
+  constructor() {
+    super("Authentication was cancelled.");
+    this.name = "AuthCancelledError";
+  }
+}
+
+// src/auth/device-code-flow.ts
+async function requestDeviceCode(config) {
+  const fetcher = config.fetcher ?? globalThis.fetch;
+  const body = { client_id: config.clientId };
+  if (config.scopes?.length) {
+    body.scope = config.scopes.join(" ");
+  }
+  const response = await fetcher(config.deviceCodeUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(body),
+    signal: AbortSignal.timeout(30000)
+  });
+  if (!response.ok) {
+    throw new Error(`Device code request failed: ${response.status}`);
+  }
+  return response.json();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollTokenUntilComplete(config, deviceCode, signal2) {
+  const fetcher = config.fetcher ?? globalThis.fetch;
+  let interval = deviceCode.interval * 1000;
+  const deadline = Date.now() + deviceCode.expires_in * 1000;
+  while (Date.now() < deadline) {
+    if (signal2?.aborted) {
+      throw new AuthExpiredError;
+    }
+    await sleep(interval);
+    if (signal2?.aborted) {
+      throw new AuthExpiredError;
+    }
+    const response = await fetcher(config.tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode.device_code,
+        client_id: config.clientId
+      }),
+      signal: signal2 ? AbortSignal.any([signal2, AbortSignal.timeout(30000)]) : AbortSignal.timeout(30000)
+    });
+    if (response.ok) {
+      const tokenData = await response.json();
+      const tokens = {
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+        expiresIn: tokenData.expires_in
+      };
+      if (config.onTokens) {
+        await config.onTokens(tokens);
+      }
+      return tokens;
+    }
+    const errorBody = await response.json();
+    switch (errorBody.error) {
+      case "authorization_pending":
+        break;
+      case "slow_down":
+        interval += 5000;
+        break;
+      case "access_denied":
+        throw new AuthDeniedError;
+      case "expired_token":
+        throw new AuthExpiredError;
+      default:
+        throw new Error(`Token request failed: ${errorBody.error}${errorBody.error_description ? ` — ${errorBody.error_description}` : ""}`);
+    }
+  }
+  throw new AuthExpiredError;
+}
+
+// src/auth/device-code-auth.ts
+function write(text) {
+  process.stdout.write(`${text}
+`);
+}
+async function DeviceCodeAuth(config) {
+  if (!config._mountOptions && !isInteractive()) {
+    return runNonInteractive(config);
+  }
+  return runInteractive(config);
+}
+async function runNonInteractive(config) {
+  write(`${symbols.info} Starting device code authentication...`);
+  const deviceCode = await requestDeviceCode(config);
+  write(`${symbols.arrow} Visit: ${deviceCode.verification_uri}`);
+  write(`${symbols.arrow} Code:  ${deviceCode.user_code}`);
+  write(`${symbols.info} Waiting for approval...`);
+  const tokens = await pollTokenUntilComplete(config, deviceCode);
+  write(`${symbols.success} Authenticated successfully.`);
+  return tokens;
+}
+async function runInteractive(config) {
+  return new Promise((resolve, reject) => {
+    let handle = null;
+    let abortController = null;
+    function App() {
+      const userCode = signal2("");
+      const verificationUri = signal2("");
+      const secondsRemaining = signal2(0);
+      const status = signal2("requesting-code");
+      abortController = new AbortController;
+      requestDeviceCode(config).then((deviceCode) => {
+        userCode.value = deviceCode.user_code;
+        verificationUri.value = deviceCode.verification_uri;
+        secondsRemaining.value = deviceCode.expires_in;
+        status.value = "awaiting-approval";
+        const countdownTimer = setInterval(() => {
+          if (secondsRemaining.value > 0) {
+            secondsRemaining.value--;
+          }
+        }, 1000);
+        _tryOnCleanup4(() => clearInterval(countdownTimer));
+        return pollTokenUntilComplete(config, deviceCode, abortController?.signal);
+      }).then((tokens) => {
+        status.value = "success";
+        handle?.unmount();
+        resolve(tokens);
+      }).catch((err) => {
+        if (err instanceof AuthCancelledError) {
+          status.value = "cancelled";
+        } else {
+          status.value = "error";
+        }
+        handle?.unmount();
+        reject(err);
+      });
+      return DeviceCodeDisplay({
+        title: config.title,
+        userCode,
+        verificationUri,
+        secondsRemaining,
+        status,
+        onCancel: () => {
+          abortController?.abort();
+          handle?.unmount();
+          reject(new AuthCancelledError);
+        },
+        onOpenBrowser: () => {
+          const uri = verificationUri.value;
+          if (uri) {
+            try {
+              const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+              execFile(cmd, [uri]);
+            } catch {}
+          }
+        }
+      });
+    }
+    handle = tui.mount(App, config._mountOptions);
+  });
+}
+// src/components/Banner.ts
+function Banner({
+  title,
+  subtitle,
+  border = "round",
+  titleColor = "cyanBright"
+}) {
+  const box = __element("Box", "border", border, "paddingX", 2, "paddingY", 1, "direction", "column");
+  const titleEl = __element("Text", "bold", true, "color", titleColor);
+  __append(titleEl, __staticText(title));
+  __append(box, titleEl);
+  if (subtitle) {
+    const subtitleEl = __element("Text", "dim", true);
+    __append(subtitleEl, __staticText(subtitle));
+    __append(box, subtitleEl);
+  }
+  return box;
+}
+// src/components/Box.ts
+function Box(_props) {
+  return null;
+}
+// src/components/Confirm.ts
+import { signal as signal3 } from "@vertz/ui";
+function Confirm(props) {
+  const value = signal3(true);
+  useKeyboard((key) => {
+    if (key.name === "left" || key.name === "right") {
+      value.value = !value.value;
+    } else if (key.name === "y") {
+      value.value = true;
+    } else if (key.name === "n") {
+      value.value = false;
+    } else if (key.name === "return") {
+      if (props.onSubmit)
+        props.onSubmit(value.value);
+    }
+  });
+  const box = __element("Box", "direction", "row", "gap", 1);
+  const msgEl = __element("Text", "bold", true);
+  __append(msgEl, __staticText(props.message));
+  __append(box, msgEl);
+  const yesEl = __element("Text");
+  __append(yesEl, __child(() => value.value ? "[Yes]" : " Yes "));
+  __append(box, yesEl);
+  const slashEl = __element("Text");
+  __append(slashEl, __staticText("/"));
+  __append(box, slashEl);
+  const noEl = __element("Text");
+  __append(noEl, __child(() => value.value ? " No " : "[No]"));
+  __append(box, noEl);
+  return box;
+}
+// src/components/Dashboard.ts
+function Dashboard({ header, footer, children }) {
+  const outer = __element("Box", "direction", "column", "width", "full");
+  if (header) {
+    __append(outer, header);
+  }
+  const contentBox = __element("Box", "direction", "column", "grow", 1);
+  if (children) {
+    __append(contentBox, children);
+  }
+  __append(outer, contentBox);
+  if (footer) {
+    __append(outer, footer);
+  }
+  return outer;
+}
+// src/components/DiagnosticView.ts
+function DiagnosticView({
+  diagnostics,
+  showSource = true,
+  showSuggestions = true
+}) {
+  const box = __element("Box", "direction", "column", "gap", 1);
+  for (const diag of diagnostics) {
+    const section = __element("Box", "direction", "column");
+    const isError = diag.severity === "error";
+    const isWarning = diag.severity === "warning";
+    const icon = isError ? symbols.error : isWarning ? symbols.warning : symbols.info;
+    const color = isError ? colors.error : isWarning ? colors.warning : colors.info;
+    const headerEl = __element("Text", "color", color);
+    __append(headerEl, __staticText(`${icon} ${diag.code}`));
+    __append(section, headerEl);
+    const messageEl = __element("Text");
+    __append(messageEl, __staticText(`  ${diag.message}`));
+    __append(section, messageEl);
+    if (diag.file) {
+      const location = `${diag.file}:${diag.line ?? 0}:${diag.column ?? 0}`;
+      const locEl = __element("Text", "dim", true);
+      __append(locEl, __staticText(`  at ${location}`));
+      __append(section, locEl);
+    }
+    if (showSource && diag.sourceLines && diag.sourceLines.length > 0) {
+      const maxLineNum = Math.max(...diag.sourceLines.map((l) => l.number));
+      const gutterWidth = String(maxLineNum).length;
+      for (const line of diag.sourceLines) {
+        const lineNum = String(line.number).padStart(gutterWidth);
+        const srcEl = __element("Text");
+        __append(srcEl, __staticText(`  ${lineNum} ${line.text}`));
+        __append(section, srcEl);
+      }
+      if (diag.highlightStart !== undefined && diag.highlightLength !== undefined && diag.highlightLength > 0) {
+        const padding = " ".repeat(diag.highlightStart + gutterWidth + 3);
+        const underline = "^".repeat(diag.highlightLength);
+        const underlineEl = __element("Text", "color", color);
+        __append(underlineEl, __staticText(padding + underline));
+        __append(section, underlineEl);
+      }
+    }
+    if (showSuggestions && diag.suggestion) {
+      const sugEl = __element("Text", "color", colors.info);
+      __append(sugEl, __staticText(`  ${symbols.info} ${diag.suggestion}`));
+      __append(section, sugEl);
+    }
+    __append(box, section);
+  }
+  return box;
+}
+// src/components/Divider.ts
+function Divider({
+  label,
+  char = symbols.dash,
+  width = 80,
+  color
+}) {
+  let text;
+  if (label) {
+    const labelText = ` ${label} `;
+    const remaining = Math.max(0, width - labelText.length);
+    const left = Math.floor(remaining / 2);
+    const right = remaining - left;
+    text = char.repeat(left) + labelText + char.repeat(right);
+  } else {
+    text = char.repeat(width);
+  }
+  const attrs = [];
+  if (color) {
+    attrs.push("color", color);
+  } else {
+    attrs.push("dim", true);
+  }
+  const el = __element("Text", ...attrs);
+  __append(el, __staticText(text));
+  return el;
+}
+// src/components/KeyValue.ts
+function KeyValue({ entries, separator = ": ", keyBold = true }) {
+  const maxKeyLen = entries.reduce((max, e) => Math.max(max, e.key.length), 0);
+  const box = __element("Box", "direction", "column");
+  for (const entry of entries) {
+    const paddedKey = entry.key.padStart(maxKeyLen);
+    const row = __element("Box", "direction", "row");
+    const keyAttrs = [];
+    if (keyBold)
+      keyAttrs.push("bold", true);
+    const keyEl = __element("Text", ...keyAttrs);
+    __append(keyEl, __staticText(paddedKey));
+    const sepEl = __element("Text", "dim", true);
+    __append(sepEl, __staticText(separator));
+    const valEl = __element("Text");
+    __append(valEl, __staticText(entry.value));
+    __append(row, keyEl);
+    __append(row, sepEl);
+    __append(row, valEl);
+    __append(box, row);
+  }
+  return box;
+}
+// src/components/Log.ts
+function Log(props) {
+  const { items, children: renderItem } = props;
+  const box = __element("Box", "direction", "column");
+  for (const item of items) {
+    __append(box, renderItem(item));
+  }
+  return box;
+}
+// src/components/LogStream.ts
+function LogStream({
+  entries,
+  children: renderEntry,
+  maxLines
+}) {
+  const box = __element("Box", "direction", "column");
+  const visible = maxLines ? entries.slice(-maxLines) : entries;
+  for (const entry of visible) {
+    __append(box, renderEntry(entry));
+  }
+  return box;
+}
+// src/components/MultiSelect.ts
+import { signal as signal4 } from "@vertz/ui";
+function MultiSelect(props) {
+  const box = __element("Box", "direction", "column");
+  const header = __element("Text", "bold", true);
+  __append(header, __staticText(props.message));
+  __append(box, header);
+  if (props.options.length === 0)
+    return box;
+  if (props.defaultValue) {
+    const optionValues = new Set(props.options.map((o) => o.value));
+    for (const val of props.defaultValue) {
+      if (!optionValues.has(val)) {
+        console.warn(`MultiSelect: defaultValue "${String(val)}" not found in options`);
+      }
+    }
+  }
+  const initialChecked = new Set(props.defaultValue ? props.options.map((o, i) => props.defaultValue?.includes(o.value) ? i : -1).filter((i) => i !== -1) : []);
+  const selectedIndex = signal4(0);
+  const checked = signal4(initialChecked);
+  useKeyboard((key) => {
+    if (key.name === "up") {
+      selectedIndex.value = Math.max(0, selectedIndex.value - 1);
+    } else if (key.name === "down") {
+      selectedIndex.value = Math.min(props.options.length - 1, selectedIndex.value + 1);
+    } else if (key.name === "space") {
+      const newChecked = new Set(checked.value);
+      if (newChecked.has(selectedIndex.value)) {
+        newChecked.delete(selectedIndex.value);
+      } else {
+        newChecked.add(selectedIndex.value);
+      }
+      checked.value = newChecked;
+    } else if (key.name === "return") {
+      if (props.onSubmit) {
+        const selected = props.options.filter((_, i) => checked.value.has(i)).map((o) => o.value);
+        props.onSubmit(selected);
+      }
+    }
+  });
+  for (let i = 0;i < props.options.length; i++) {
+    const option = props.options[i];
+    if (!option)
+      continue;
+    const idx = i;
+    const optionEl = __element("Text");
+    __append(optionEl, __child(() => {
+      const isSelected = idx === selectedIndex.value;
+      const isChecked = checked.value.has(idx);
+      const checkbox = isChecked ? symbols.success : symbols.bullet;
+      const prefix = isSelected ? symbols.pointer : " ";
+      return `${prefix} ${checkbox} ${option.label}`;
+    }));
+    __append(box, optionEl);
+  }
+  return box;
+}
+// src/components/PasswordInput.ts
+import { signal as signal5 } from "@vertz/ui";
+function PasswordInput(props) {
+  const text = signal5(props.value ?? "");
+  useKeyboard((key) => {
+    if (key.name === "return") {
+      if (props.onSubmit)
+        props.onSubmit(text.value);
+    } else if (key.name === "backspace") {
+      text.value = text.value.slice(0, -1);
+      if (props.onChange)
+        props.onChange(text.value);
+    } else if (key.char && key.char.length === 1 && key.name !== "space") {
+      text.value += key.char;
+      if (props.onChange)
+        props.onChange(text.value);
+    } else if (key.name === "space") {
+      text.value += " ";
+      if (props.onChange)
+        props.onChange(text.value);
+    }
+  });
+  const el = __element("Text");
+  __append(el, __child(() => {
+    const showPlaceholder = !text.value && props.placeholder;
+    if (showPlaceholder)
+      return props.placeholder ?? "";
+    return text.value ? "•".repeat(text.value.length) : "";
+  }));
+  return el;
+}
+// src/components/ProgressBar.ts
+var FILLED = "█";
+var EMPTY = "░";
+function ProgressBar(props) {
+  const { value, max, label, width = 20 } = props;
+  const ratio = max > 0 ? Math.min(1, Math.max(0, value / max)) : 0;
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  const percent = Math.round(ratio * 100);
+  const bar = FILLED.repeat(filled) + EMPTY.repeat(empty);
+  const text = label ? `${label} ${bar} ${percent}%` : `${bar} ${percent}%`;
+  const el = __element("Text");
+  __append(el, __staticText(text));
+  return el;
+}
+// src/components/Select.ts
+import { signal as signal6 } from "@vertz/ui";
+function Select(props) {
+  const box = __element("Box", "direction", "column");
+  const header = __element("Text", "bold", true);
+  __append(header, __staticText(props.message));
+  __append(box, header);
+  if (props.options.length === 0)
+    return box;
+  const selectedIndex = signal6(0);
+  useKeyboard((key) => {
+    if (key.name === "up") {
+      const next = Math.max(0, selectedIndex.value - 1);
+      if (next !== selectedIndex.value)
+        selectedIndex.value = next;
+    } else if (key.name === "down") {
+      const next = Math.min(props.options.length - 1, selectedIndex.value + 1);
+      if (next !== selectedIndex.value)
+        selectedIndex.value = next;
+    } else if (key.name === "return") {
+      const option = props.options[selectedIndex.value];
+      if (option && props.onSubmit) {
+        props.onSubmit(option.value);
+      }
+    }
+  });
+  for (let i = 0;i < props.options.length; i++) {
+    const option = props.options[i];
+    if (!option)
+      continue;
+    const idx = i;
+    const optionEl = __element("Text");
+    __append(optionEl, __child(() => {
+      const isSelected = idx === selectedIndex.value;
+      const prefix = isSelected ? symbols.pointer : " ";
+      const hint = option.hint ? ` (${option.hint})` : "";
+      return `${prefix} ${option.label}${hint}`;
+    }));
+    __append(box, optionEl);
+  }
+  return box;
+}
+// src/components/Spacer.ts
+function Spacer(_props) {
+  return null;
+}
+// src/components/Table.ts
+function padCell(text, width, align = "left") {
+  if (text.length >= width)
+    return text.slice(0, width);
+  const padding = width - text.length;
+  if (align === "right")
+    return " ".repeat(padding) + text;
+  if (align === "center") {
+    const left = Math.floor(padding / 2);
+    return " ".repeat(left) + text + " ".repeat(padding - left);
+  }
+  return text + " ".repeat(padding);
+}
+function Table(props) {
+  const { data, columns } = props;
+  const widths = columns.map((col) => {
+    if (col.width)
+      return col.width;
+    let max = col.header.length;
+    for (const row of data) {
+      const val = String(row[col.key] ?? "");
+      if (val.length > max)
+        max = val.length;
+    }
+    return max;
+  });
+  const box = __element("Box", "direction", "column");
+  const headerCells = columns.map((col, i) => padCell(col.header, widths[i] ?? col.header.length, col.align));
+  const headerEl = __element("Text", "bold", true);
+  __append(headerEl, __staticText(headerCells.join("  ")));
+  __append(box, headerEl);
+  const separator = widths.map((w) => "─".repeat(w)).join("──");
+  const sepEl = __element("Text", "dim", true);
+  __append(sepEl, __staticText(separator));
+  __append(box, sepEl);
+  for (const row of data) {
+    const cells = columns.map((col, i) => {
+      const val = String(row[col.key] ?? "");
+      return padCell(val, widths[i] ?? val.length, col.align);
+    });
+    const rowEl = __element("Text");
+    __append(rowEl, __staticText(cells.join("  ")));
+    __append(box, rowEl);
+  }
+  return box;
+}
+// src/components/TaskRunner.ts
+import { signal as signal7 } from "@vertz/ui";
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function write2(text) {
+  process.stdout.write(`${text}
+`);
+}
+function TaskRunner(config) {
+  const taskStates = config.tasks.map(() => signal7({
+    status: "pending",
+    duration: 0
+  }));
+  async function run() {
+    const results = [];
+    const ci = !isInteractive();
+    let failed = false;
+    for (const [i, task] of config.tasks.entries()) {
+      const state = taskStates[i];
+      if (!state)
+        continue;
+      if (failed) {
+        state.value = { status: "skipped", duration: 0 };
+        results.push({ label: task.label, status: "skipped", duration: 0 });
+        if (ci)
+          write2(`${symbols.dash} ${task.label} (skipped)`);
+        continue;
+      }
+      state.value = { status: "running", duration: 0 };
+      if (ci)
+        write2(`${symbols.pointer} ${task.label}...`);
+      const start = performance.now();
+      try {
+        const value = await task.run();
+        const duration = performance.now() - start;
+        state.value = { status: "success", duration };
+        results.push({ label: task.label, status: "success", value, duration });
+        if (ci)
+          write2(`${symbols.success} ${task.label} (${formatDuration(duration)})`);
+      } catch (err) {
+        const duration = performance.now() - start;
+        const error = err instanceof Error ? err : new Error(String(err));
+        state.value = { status: "error", duration, error };
+        results.push({ label: task.label, status: "error", error, duration });
+        if (ci)
+          write2(`${symbols.error} ${task.label} — failed`);
+        failed = true;
+      }
+    }
+    return results;
+  }
+  function component() {
+    const box = __element("Box", "direction", "column");
+    for (const [i, task] of config.tasks.entries()) {
+      const state = taskStates[i];
+      if (!state)
+        continue;
+      const row = __element("Box", "direction", "row", "gap", 1);
+      const statusEl = __element("Text");
+      __append(statusEl, __child(() => {
+        const s = state.value;
+        switch (s.status) {
+          case "pending":
+            return symbols.dash;
+          case "success":
+            return symbols.success;
+          case "error":
+            return symbols.error;
+          case "skipped":
+            return symbols.dash;
+          default:
+            return "";
+        }
+      }));
+      const labelEl = __element("Text");
+      __append(labelEl, __staticText(task.label));
+      const durationEl = __element("Text", "color", "gray");
+      __append(durationEl, __child(() => {
+        const s = state.value;
+        if (s.status === "success")
+          return formatDuration(s.duration);
+        if (s.status === "error")
+          return s.error?.message ?? "failed";
+        return "";
+      }));
+      __append(row, statusEl);
+      __append(row, labelEl);
+      __append(row, durationEl);
+      __append(box, row);
+    }
+    return box;
+  }
+  return { run, component };
+}
+// src/components/Text.ts
+function Text(_props) {
+  return null;
+}
+// src/components/TextInput.ts
+import { signal as signal8 } from "@vertz/ui";
+function TextInput(props) {
+  const text = signal8(props.value ?? "");
+  useKeyboard((key) => {
+    if (key.name === "return") {
+      if (props.onSubmit)
+        props.onSubmit(text.value);
+    } else if (key.name === "backspace") {
+      text.value = text.value.slice(0, -1);
+      if (props.onChange)
+        props.onChange(text.value);
+    } else if (key.char && key.char.length === 1 && key.name !== "space") {
+      text.value += key.char;
+      if (props.onChange)
+        props.onChange(text.value);
+    } else if (key.name === "space") {
+      text.value += " ";
+      if (props.onChange)
+        props.onChange(text.value);
+    }
+  });
+  const el = __element("Text");
+  __append(el, __child(() => {
+    const showPlaceholder = !text.value && props.placeholder;
+    return showPlaceholder ? props.placeholder ?? "" : text.value;
+  }));
+  return el;
+}
+// src/focus/focus-manager.ts
+import { createContext, useContext } from "@vertz/ui";
+var FocusContext = createContext();
+function useFocus() {
+  const ctx = useContext(FocusContext);
+  return ctx ?? { focused: false };
+}
+// src/input/match.ts
+function parsePattern(pattern) {
+  const parts = pattern.split("+");
+  const name = parts[parts.length - 1] ?? pattern;
+  let ctrl = false;
+  let shift = false;
+  let meta = false;
+  for (let i = 0;i < parts.length - 1; i++) {
+    const modifier = parts[i];
+    if (modifier === undefined)
+      continue;
+    const lower = modifier.toLowerCase();
+    if (lower === "ctrl")
+      ctrl = true;
+    else if (lower === "shift")
+      shift = true;
+    else if (lower === "meta")
+      meta = true;
+  }
+  return { name, ctrl, shift, meta };
+}
+function match(keyMap) {
+  const entries = [];
+  for (const pattern in keyMap) {
+    const handler = keyMap[pattern];
+    if (handler) {
+      entries.push({ parsed: parsePattern(pattern), handler });
+    }
+  }
+  return (key) => {
+    for (const { parsed, handler } of entries) {
+      if (key.name === parsed.name && key.ctrl === parsed.ctrl && key.shift === parsed.shift && key.meta === parsed.meta) {
+        handler(key);
+        return;
+      }
+    }
+  };
+}
+// src/legacy.ts
+var colorCodes = {
+  green: (t) => `\x1B[32m${t}\x1B[0m`,
+  red: (t) => `\x1B[31m${t}\x1B[0m`,
+  yellow: (t) => `\x1B[33m${t}\x1B[0m`,
+  cyan: (t) => `\x1B[36m${t}\x1B[0m`,
+  gray: (t) => `\x1B[90m${t}\x1B[0m`
+};
+function applyColor(text, color) {
+  const fn = colorCodes[color];
+  return fn ? fn(text) : text;
+}
+var symbolMap = {
+  info: symbols.info,
+  error: symbols.error,
+  warning: symbols.warning,
+  success: symbols.success
+};
+var colorMap = {
+  info: colors.info,
+  error: colors.error,
+  warning: colors.warning,
+  success: colors.success
+};
+function Message({ type, children }) {
+  return {
+    render() {
+      const symbol = symbolMap[type];
+      const content = typeof children === "function" ? children() : String(children);
+      return applyColor(`${symbol} ${content}`, colorMap[type]);
+    }
+  };
+}
+function SelectList({ title, choices, selectedIndex }) {
+  return {
+    render() {
+      const titleText = typeof title === "function" ? title() : title;
+      const choicesList = typeof choices === "function" ? choices() : choices;
+      const selected = selectedIndex.value;
+      const lines = [titleText];
+      for (let i = 0;i < choicesList.length; i++) {
+        const choice = choicesList[i];
+        if (!choice)
+          continue;
+        const prefix = i === selected ? symbols.pointer : " ";
+        lines.push(`${prefix} ${choice.label}`);
+      }
+      return lines.join(`
+`);
+    }
+  };
+}
+var iconMap = {
+  pending: symbols.dash,
+  running: symbols.pointer,
+  done: symbols.success,
+  error: symbols.error
+};
+function Task({ name, status, detail }) {
+  return {
+    render() {
+      const nameText = typeof name === "function" ? name() : name;
+      const currentStatus = status.value;
+      const icon = iconMap[currentStatus];
+      const detailText = detail?.value;
+      let text = `${icon} ${nameText}`;
+      if (detailText) {
+        text += ` ${detailText}`;
+      }
+      if (currentStatus === "done") {
+        return applyColor(text, colors.success);
+      } else if (currentStatus === "error") {
+        return applyColor(text, colors.error);
+      } else if (currentStatus === "running") {
+        return applyColor(text, colors.info);
+      }
+      return text;
+    }
+  };
+}
+function TaskList({ title, tasks }) {
+  return {
+    render() {
+      const titleText = typeof title === "function" ? title() : title;
+      const taskList = tasks.value;
+      const lines = [`\x1B[1m${titleText}\x1B[0m`];
+      for (const task of taskList) {
+        const taskStatus = task.status;
+        const icon = iconMap[taskStatus];
+        let line = `${icon} ${task.name}`;
+        if (task.detail) {
+          line += ` ${task.detail}`;
+        }
+        if (taskStatus === "done") {
+          line = applyColor(line, colors.success);
+        } else if (taskStatus === "error") {
+          line = applyColor(line, colors.error);
+        } else if (taskStatus === "running") {
+          line = applyColor(line, colors.info);
+        }
+        lines.push(line);
+      }
+      return lines.join(`
+`);
+    }
+  };
+}
+function createTaskRunner() {
+  const messages = [];
+  return {
+    group(_name) {
+      return {
+        async task(_name2, fn) {
+          const handle = {
+            update() {},
+            succeed() {},
+            fail() {}
+          };
+          await fn(handle);
+        },
+        dismiss() {}
+      };
+    },
+    info(message) {
+      messages.push({ type: "info", message });
+    },
+    warn(message) {
+      messages.push({ type: "warning", message });
+    },
+    error(message) {
+      messages.push({ type: "error", message });
+    },
+    success(message) {
+      messages.push({ type: "success", message });
+    },
+    cleanup() {}
+  };
+}
+// src/prompt.ts
+import { signal as signal9 } from "@vertz/ui";
+function write3(text) {
+  process.stdout.write(`${text}
+`);
+}
+var prompt = {
+  text(config) {
+    if (!config._mountOptions && !isInteractive()) {
+      if (config.default !== undefined)
+        return Promise.resolve(config.default);
+      return Promise.reject(new NonInteractiveError("text"));
+    }
+    return new Promise((resolve) => {
+      let handle = null;
+      const errorMsg = signal9("");
+      function App() {
+        const box = __element("Box", "direction", "column");
+        const header = __element("Text", "bold", true);
+        __append(header, __staticText(config.message));
+        __append(box, header);
+        __append(box, TextInput({
+          placeholder: config.placeholder,
+          onSubmit: (value) => {
+            if (config.validate) {
+              const error = config.validate(value);
+              if (error) {
+                errorMsg.value = error;
+                return;
+              }
+            }
+            handle?.unmount();
+            resolve(value);
+          }
+        }));
+        const errorEl = __element("Text", "color", "red");
+        __append(errorEl, __child(() => errorMsg.value));
+        __append(box, errorEl);
+        return box;
+      }
+      handle = tui.mount(App, config._mountOptions);
+    });
+  },
+  select(config) {
+    if (!isInteractive()) {
+      if (config.default !== undefined)
+        return Promise.resolve(config.default);
+      return Promise.reject(new NonInteractiveError("select"));
+    }
+    return new Promise((resolve) => {
+      let handle = null;
+      function App() {
+        return Select({
+          message: config.message,
+          options: config.options,
+          onSubmit: (value) => {
+            handle?.unmount();
+            resolve(value);
+          }
+        });
+      }
+      handle = tui.mount(App);
+    });
+  },
+  multiSelect(config) {
+    if (!isInteractive()) {
+      if (config.defaultValue !== undefined)
+        return Promise.resolve(config.defaultValue);
+      return Promise.reject(new NonInteractiveError("multiSelect"));
+    }
+    return new Promise((resolve) => {
+      let handle = null;
+      function App() {
+        return MultiSelect({
+          message: config.message,
+          options: config.options,
+          defaultValue: config.defaultValue,
+          onSubmit: (values) => {
+            handle?.unmount();
+            resolve(values);
+          }
+        });
+      }
+      handle = tui.mount(App);
+    });
+  },
+  confirm(config) {
+    if (!isInteractive()) {
+      if (config.default !== undefined)
+        return Promise.resolve(config.default);
+      return Promise.reject(new NonInteractiveError("confirm"));
+    }
+    return new Promise((resolve) => {
+      let handle = null;
+      function App() {
+        return Confirm({
+          message: config.message,
+          onSubmit: (value) => {
+            handle?.unmount();
+            resolve(value);
+          }
+        });
+      }
+      handle = tui.mount(App);
+    });
+  },
+  password(config) {
+    if (!isInteractive()) {
+      if (config.default !== undefined)
+        return Promise.resolve(config.default);
+      return Promise.reject(new NonInteractiveError("password"));
+    }
+    return new Promise((resolve) => {
+      let handle = null;
+      function App() {
+        const box = __element("Box", "direction", "column");
+        const header = __element("Text", "bold", true);
+        __append(header, __staticText(config.message));
+        __append(box, header);
+        __append(box, PasswordInput({
+          placeholder: config.placeholder,
+          onSubmit: (value) => {
+            handle?.unmount();
+            resolve(value);
+          }
+        }));
+        return box;
+      }
+      handle = tui.mount(App);
+    });
+  },
+  spinner() {
+    if (!isInteractive()) {
+      return {
+        start(message) {
+          write3(`${symbols.info} ${message}`);
+        },
+        stop(message) {
+          write3(`${symbols.success} ${message}`);
+        }
+      };
+    }
+    let handle = null;
+    return {
+      start(message) {
+        function App() {
+          return Spinner({ label: message });
+        }
+        handle = tui.mount(App);
+      },
+      stop(message) {
+        handle?.unmount();
+        handle = null;
+        write3(message);
+      }
+    };
+  },
+  intro(title) {
+    write3("");
+    write3(`  ${title}`);
+    write3("");
+  },
+  outro(message) {
+    write3("");
+    write3(`  ${message}`);
+    write3("");
+  },
+  log: {
+    info(message) {
+      write3(`${symbols.info} ${message}`);
+    },
+    warn(message) {
+      write3(`${symbols.warning} ${message}`);
+    },
+    error(message) {
+      write3(`${symbols.error} ${message}`);
+    },
+    success(message) {
+      write3(`${symbols.success} ${message}`);
+    }
+  }
+};
+// src/render-to-string.ts
+function renderToString(node, options = {}) {
+  const width = options.width ?? 80;
+  const height = options.height ?? 24;
+  const layoutRoot = toLayoutTree(node);
+  computeLayout(layoutRoot, { maxWidth: width, maxHeight: height });
+  const buffer = new TerminalBuffer(width, height);
+  paintTree(buffer, layoutRoot, {}, height);
+  return bufferToString(buffer);
+}
+function bufferToString(buffer) {
+  const lines = [];
+  let lastNonEmptyRow = -1;
+  for (let r = 0;r < buffer.height; r++) {
+    const rowText = buffer.getRowText(r);
+    if (rowText.trim()) {
+      lastNonEmptyRow = r;
+    }
+  }
+  for (let r = 0;r <= lastNonEmptyRow; r++) {
+    lines.push(renderRow(buffer, r));
+  }
+  return lines.join(`
+`);
+}
+function renderRow(buffer, row) {
+  let output = "";
+  let lastNonSpace = -1;
+  for (let c = buffer.width - 1;c >= 0; c--) {
+    const cell = buffer.get(row, c);
+    if (cell && cell.char !== " ") {
+      lastNonSpace = c;
+      break;
+    }
+    if (cell && hasStyle(cell.style)) {
+      lastNonSpace = c;
+      break;
+    }
+  }
+  for (let c = 0;c <= lastNonSpace; c++) {
+    const cell = buffer.get(row, c);
+    if (!cell)
+      continue;
+    const sgr = styleToSGR(cell.style);
+    if (sgr) {
+      output += `${sgr}${cell.char}${RESET}`;
+    } else {
+      output += cell.char;
+    }
+  }
+  return output;
+}
+function hasStyle(style) {
+  return !!(style.color || style.bgColor || style.bold || style.dim || style.italic || style.underline || style.strikethrough);
+}
+// src/wizard.ts
+async function wizard(config) {
+  const { steps, onStep } = config;
+  const answers = {};
+  const total = steps.length;
+  for (let i = 0;i < steps.length; i++) {
+    const step = steps[i];
+    if (!step)
+      continue;
+    const current = i + 1;
+    if (onStep) {
+      onStep({ current, total, id: step.id });
+    } else {
+      prompt.log.info(`Step ${current}/${total} ${symbols.dash} ${step.id}`);
+    }
+    const ctx = { answers: { ...answers } };
+    const value = await step.prompt(ctx);
+    answers[step.id] = value;
+  }
+  return answers;
+}
+export {
+  wizard,
+  useKeyboard,
+  useFocus,
+  useContext2 as useContext,
+  tui,
+  symbols,
+  signal10 as signal,
+  requestDeviceCode,
+  renderToString,
+  prompt,
+  pollTokenUntilComplete,
+  onMount,
+  match,
+  isInteractive,
+  createTaskRunner,
+  createContext2 as createContext,
+  computed,
+  colors,
+  batch,
+  TextInput,
+  Text,
+  TaskRunner,
+  TaskList,
+  Task,
+  Table,
+  Spinner,
+  Spacer,
+  SelectList,
+  Select,
+  ProgressBar,
+  PasswordInput,
+  NonInteractiveError,
+  MultiSelect,
+  Message,
+  LogStream,
+  Log,
+  KeyValue,
+  FocusContext,
+  Divider,
+  DiagnosticView,
+  DeviceCodeAuth,
+  Dashboard,
+  Confirm,
+  Box,
+  Banner,
+  AuthExpiredError,
+  AuthDeniedError,
+  AuthCancelledError
+};