reasonix 0.23.1 → 0.24.0

package/dist/cli/chunk-JHXQDL7B.js

@@ -0,0 +1,2056 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-2H7UOFLK.js";
+
+// src/renderer/react/components.ts
+import React from "react";
+var HOST_BOX = "rsx-box";
+var HOST_TEXT = "rsx-text";
+function Box(props) {
+  return React.createElement(HOST_BOX, props);
+}
+function Text(props) {
+  return React.createElement(HOST_TEXT, props);
+}
+
+// src/renderer/input/use-keystroke.ts
+import { createContext, useContext, useEffect } from "react";
+var KeystrokeContext = createContext(null);
+function useKeystroke(handler, enabled = true) {
+  const reader = useContext(KeystrokeContext);
+  useEffect(() => {
+    if (!enabled || !reader) return;
+    const wrapped = (key) => handler(key);
+    return reader.subscribe(wrapped);
+  }, [reader, handler, enabled]);
+}
+
+// src/renderer/input/keystroke.ts
+function emptyKeystroke() {
+  return {
+    input: "",
+    raw: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    home: false,
+    end: false,
+    pageUp: false,
+    pageDown: false,
+    delete: false,
+    backspace: false,
+    return: false,
+    escape: false,
+    tab: false,
+    wheelUp: false,
+    wheelDown: false
+  };
+}
+var CSI_FINAL = {
+  A: { upArrow: true },
+  B: { downArrow: true },
+  C: { rightArrow: true },
+  D: { leftArrow: true },
+  H: { home: true },
+  F: { end: true }
+};
+var CSI_TILDE = {
+  "1": { home: true },
+  "3": { delete: true },
+  "4": { end: true },
+  "5": { pageUp: true },
+  "6": { pageDown: true },
+  "7": { home: true },
+  "8": { end: true }
+};
+function parseKeystrokes(chunk) {
+  const out = [];
+  let i = 0;
+  while (i < chunk.length) {
+    const consumed = parseOne(chunk, i);
+    if (consumed.length === 0) {
+      i++;
+      continue;
+    }
+    out.push(consumed.key);
+    i += consumed.length;
+  }
+  return out;
+}
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+function parseOne(s, start) {
+  const ch = s[start];
+  if (ch === "\x1B" && s.startsWith(PASTE_START, start)) {
+    const bodyStart = start + PASTE_START.length;
+    const endIdx = s.indexOf(PASTE_END, bodyStart);
+    if (endIdx >= 0) {
+      const content = s.slice(bodyStart, endIdx);
+      return {
+        key: {
+          ...emptyKeystroke(),
+          raw: s.slice(start, endIdx + PASTE_END.length),
+          input: content
+        },
+        length: endIdx + PASTE_END.length - start
+      };
+    }
+  }
+  if (ch === "\x1B") {
+    return parseEscape(s, start);
+  }
+  if (ch === "\r" || ch === "\n") {
+    return { key: { ...emptyKeystroke(), raw: ch, return: true }, length: 1 };
+  }
+  if (ch === "	") {
+    return { key: { ...emptyKeystroke(), raw: ch, tab: true }, length: 1 };
+  }
+  if (ch === "\x7F" || ch === "\b") {
+    return { key: { ...emptyKeystroke(), raw: ch, backspace: true }, length: 1 };
+  }
+  const code = ch.charCodeAt(0);
+  if (code >= 1 && code <= 26 && ch !== "	" && ch !== "\r" && ch !== "\n") {
+    const letter = String.fromCharCode(code + 96);
+    return {
+      key: { ...emptyKeystroke(), raw: ch, ctrl: true, input: letter },
+      length: 1
+    };
+  }
+  return { key: { ...emptyKeystroke(), raw: ch, input: ch }, length: 1 };
+}
+function parseEscape(s, start) {
+  if (start + 1 >= s.length) {
+    return { key: { ...emptyKeystroke(), raw: "\x1B", escape: true }, length: 1 };
+  }
+  const next = s[start + 1];
+  if (next === "[" || next === "O") {
+    return parseCsi(s, start);
+  }
+  if (next === "\r" || next === "\n") {
+    return {
+      key: { ...emptyKeystroke(), raw: `\x1B${next}`, meta: true, return: true },
+      length: 2
+    };
+  }
+  if (isPrintable(next)) {
+    return {
+      key: { ...emptyKeystroke(), raw: `\x1B${next}`, meta: true, input: next },
+      length: 2
+    };
+  }
+  return { key: { ...emptyKeystroke(), raw: "\x1B", escape: true }, length: 1 };
+}
+function parseCsi(s, start) {
+  let i = start + 2;
+  let params = "";
+  while (i < s.length) {
+    const c = s[i];
+    if (isCsiFinal(c)) {
+      const raw = s.slice(start, i + 1);
+      const key = decodeCsi(params, c, raw);
+      return { key, length: i - start + 1 };
+    }
+    params += c;
+    i++;
+  }
+  return {
+    key: { ...emptyKeystroke(), raw: s.slice(start), escape: true },
+    length: s.length - start
+  };
+}
+function decodeCsi(params, final, raw) {
+  const base = { ...emptyKeystroke(), raw };
+  if (params.startsWith("<") && (final === "M" || final === "m")) {
+    const mouse = params.slice(1).split(";");
+    const button = Number.parseInt(mouse[0] ?? "", 10);
+    if (button === 64) return { ...base, wheelUp: true };
+    if (button === 65) return { ...base, wheelDown: true };
+    return base;
+  }
+  const segments = params.split(";");
+  const modCode = segments[1] ? Number.parseInt(segments[1], 10) : 1;
+  const mods = decodeModifiers(modCode);
+  if (final === "~" && segments[0]) {
+    const part2 = CSI_TILDE[segments[0]];
+    if (part2) return { ...base, ...part2, ...mods };
+  }
+  const part = CSI_FINAL[final];
+  if (part) return { ...base, ...part, ...mods };
+  return { ...base, escape: true };
+}
+function decodeModifiers(code) {
+  const m = code - 1;
+  return {
+    shift: (m & 1) !== 0,
+    meta: (m & 2) !== 0,
+    ctrl: (m & 4) !== 0
+  };
+}
+function isCsiFinal(ch) {
+  const code = ch.charCodeAt(0);
+  return code >= 64 && code <= 126 && ch !== "[";
+}
+function isPrintable(ch) {
+  const code = ch.charCodeAt(0);
+  return code >= 32 && code <= 126;
+}
+
+// src/renderer/input/reader.ts
+var KeystrokeReader = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.onData = (chunk) => this.handle(chunk);
+    if (opts.rawMode !== false) {
+      opts.source.setRawMode?.(true);
+    }
+    opts.source.resume?.();
+    opts.source.on("data", this.onData);
+  }
+  opts;
+  listeners = [];
+  onData;
+  destroyed = false;
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const i = this.listeners.indexOf(listener);
+      if (i >= 0) this.listeners.splice(i, 1);
+    };
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.opts.source.off("data", this.onData);
+    if (this.opts.rawMode !== false) {
+      this.opts.source.setRawMode?.(false);
+    }
+    this.listeners.length = 0;
+  }
+  handle(chunk) {
+    if (this.destroyed) return;
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    const keys = parseKeystrokes(text);
+    for (const key of keys) {
+      for (const cb of this.listeners) cb(key);
+    }
+  }
+};
+
+// src/renderer/pools/char-pool.ts
+var ASCII_TABLE_SIZE = 128;
+var SPACE_ID = 0;
+var EMPTY_ID = 1;
+var CharPool = class {
+  strings;
+  map;
+  ascii;
+  constructor() {
+    this.strings = [" ", ""];
+    this.map = /* @__PURE__ */ new Map([
+      [" ", SPACE_ID],
+      ["", EMPTY_ID]
+    ]);
+    this.ascii = new Int32Array(ASCII_TABLE_SIZE).fill(-1);
+    this.ascii[" ".charCodeAt(0)] = SPACE_ID;
+  }
+  intern(s) {
+    if (s.length === 1) {
+      const code = s.charCodeAt(0);
+      if (code < ASCII_TABLE_SIZE) {
+        const cached = this.ascii[code];
+        if (cached !== -1) return cached;
+        const id2 = this.strings.length;
+        this.strings.push(s);
+        this.ascii[code] = id2;
+        this.map.set(s, id2);
+        return id2;
+      }
+    }
+    const existing = this.map.get(s);
+    if (existing !== void 0) return existing;
+    const id = this.strings.length;
+    this.strings.push(s);
+    this.map.set(s, id);
+    return id;
+  }
+  get(id) {
+    return this.strings[id] ?? " ";
+  }
+  get size() {
+    return this.strings.length;
+  }
+};
+
+// src/renderer/pools/hyperlink-pool.ts
+var NO_HYPERLINK = 0;
+var HyperlinkPool = class {
+  strings = [""];
+  map = /* @__PURE__ */ new Map();
+  intern(uri) {
+    if (!uri) return NO_HYPERLINK;
+    const existing = this.map.get(uri);
+    if (existing !== void 0) return existing;
+    const id = this.strings.length;
+    this.strings.push(uri);
+    this.map.set(uri, id);
+    return id;
+  }
+  get(id) {
+    if (id === NO_HYPERLINK) return void 0;
+    return this.strings[id];
+  }
+  get size() {
+    return this.strings.length;
+  }
+};
+
+// src/renderer/pools/style-pool.ts
+var EMPTY_KEY = "";
+var StylePool = class {
+  stacks = [[]];
+  idsByKey = /* @__PURE__ */ new Map([[EMPTY_KEY, 0]]);
+  transitionCache = /* @__PURE__ */ new Map();
+  none = 0;
+  intern(codes) {
+    const key = stackKey(codes);
+    const existing = this.idsByKey.get(key);
+    if (existing !== void 0) return existing;
+    const id = this.stacks.length;
+    this.stacks.push(codes);
+    this.idsByKey.set(key, id);
+    return id;
+  }
+  transition(fromId, toId) {
+    if (fromId === toId) return "";
+    const cacheKey = fromId << 16 | toId;
+    const cached = this.transitionCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    const from = this.stacks[fromId] ?? [];
+    const to = this.stacks[toId] ?? [];
+    const fromApplies = new Set(from.map((c) => c.apply));
+    const toApplies = new Set(to.map((c) => c.apply));
+    let out = "";
+    for (const c of from) {
+      if (!toApplies.has(c.apply)) out += c.revert;
+    }
+    for (const c of to) {
+      if (!fromApplies.has(c.apply)) out += c.apply;
+    }
+    this.transitionCache.set(cacheKey, out);
+    return out;
+  }
+  get size() {
+    return this.stacks.length;
+  }
+};
+function stackKey(codes) {
+  if (codes.length === 0) return EMPTY_KEY;
+  const applies = codes.map((c) => c.apply);
+  applies.sort();
+  return applies.join("\0");
+}
+
+// src/renderer/reconciler/mount.ts
+import { createElement as createElement3 } from "react";
+
+// src/renderer/screen/cell.ts
+var CellWidth = {
+  Single: 1,
+  Wide: 2,
+  /** Occupies the column following a Wide glyph; renderer must skip it. */
+  SpacerTail: 3
+};
+var EMPTY_CELL = Object.freeze({
+  charId: 0,
+  styleId: 0,
+  hyperlinkId: 0,
+  width: CellWidth.Single
+});
+function cellsEqual(a, b) {
+  return a.charId === b.charId && a.styleId === b.styleId && a.hyperlinkId === b.hyperlinkId && a.width === b.width;
+}
+
+// src/renderer/screen/diff.ts
+function diffEach(prev, next, cb) {
+  const w = Math.max(prev.width, next.width);
+  const h = Math.max(prev.height, next.height);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const a = prev.cellAt(x, y);
+      const b = next.cellAt(x, y);
+      if (a === b) continue;
+      if (a !== void 0 && b !== void 0 && cellsEqual(a, b)) continue;
+      if (cb(x, y, a, b) === true) return true;
+    }
+  }
+  return false;
+}
+
+// src/renderer/diff/diff-frames.ts
+function diffFrames(prev, next, pools) {
+  if (prev.viewportWidth !== next.viewportWidth || prev.viewportHeight !== next.viewportHeight) {
+    return fullReset(next, pools);
+  }
+  const out = [];
+  const cursor = {
+    x: prev.cursor.x,
+    y: prev.cursor.y,
+    styleId: pools.style.none,
+    hyperlinkId: 0
+  };
+  diffEach(prev.screen, next.screen, (x, y, _prevCell, nextCell) => {
+    moveTo(out, cursor, x, y, next.viewportWidth);
+    writeCell(out, cursor, nextCell, pools);
+    return void 0;
+  });
+  if (next.cursor.x !== cursor.x || next.cursor.y !== cursor.y) {
+    moveTo(out, cursor, next.cursor.x, next.cursor.y, next.viewportWidth);
+  }
+  if (prev.cursor.visible !== next.cursor.visible) {
+    out.push({ type: "cursorVisible", visible: next.cursor.visible });
+  }
+  resetTrailingState(out, cursor, pools);
+  return out;
+}
+function fullReset(next, pools) {
+  const out = [{ type: "clearTerminal" }];
+  const cursor = { x: 0, y: 0, styleId: pools.style.none, hyperlinkId: 0 };
+  for (let y = 0; y < next.screen.height; y++) {
+    for (let x = 0; x < next.screen.width; x++) {
+      const cell = next.screen.cellAt(x, y);
+      if (!cell) continue;
+      if (cell.width === CellWidth.SpacerTail) continue;
+      moveTo(out, cursor, x, y, next.viewportWidth);
+      writeCell(out, cursor, cell, pools);
+    }
+  }
+  resetTrailingState(out, cursor, pools);
+  return out;
+}
+function moveTo(out, cursor, targetX, targetY, viewportWidth) {
+  if (cursor.x === targetX && cursor.y === targetY) return;
+  if (cursor.x >= viewportWidth) {
+    out.push({ type: "carriageReturn" });
+    cursor.x = 0;
+  }
+  if (cursor.y !== targetY) {
+    const dy = targetY - cursor.y;
+    out.push({ type: "carriageReturn" });
+    out.push({ type: "cursorMove", dx: 0, dy });
+    cursor.x = 0;
+    cursor.y = targetY;
+  }
+  if (cursor.x !== targetX) {
+    out.push({ type: "cursorMove", dx: targetX - cursor.x, dy: 0 });
+    cursor.x = targetX;
+  }
+}
+function writeCell(out, cursor, cell, pools) {
+  if (!cell) {
+    transitionStyle(out, cursor, pools.style.none, pools);
+    transitionHyperlink(out, cursor, 0, pools);
+    out.push({ type: "stdout", content: " " });
+    cursor.x++;
+    return;
+  }
+  if (cell.width === CellWidth.SpacerTail) return;
+  transitionStyle(out, cursor, cell.styleId, pools);
+  transitionHyperlink(out, cursor, cell.hyperlinkId, pools);
+  const isWide = cell.width === CellWidth.Wide;
+  const charStr = pools.char.get(cell.charId);
+  if (isWide) {
+    out.push({ type: "cursorTo", col: cursor.x + 1 });
+    out.push({ type: "stdout", content: " " });
+    out.push({ type: "cursorTo", col: cursor.x });
+    out.push({ type: "stdout", content: charStr });
+    cursor.x += 2;
+    out.push({ type: "cursorTo", col: cursor.x });
+  } else {
+    out.push({ type: "stdout", content: charStr });
+    cursor.x += 1;
+  }
+}
+function transitionStyle(out, cursor, targetStyleId, pools) {
+  if (cursor.styleId === targetStyleId) return;
+  const str = pools.style.transition(cursor.styleId, targetStyleId);
+  if (str.length > 0) out.push({ type: "styleStr", str });
+  cursor.styleId = targetStyleId;
+}
+function transitionHyperlink(out, cursor, targetId, pools) {
+  if (cursor.hyperlinkId === targetId) return;
+  out.push({ type: "hyperlink", uri: pools.hyperlink.get(targetId) ?? "" });
+  cursor.hyperlinkId = targetId;
+}
+function resetTrailingState(out, cursor, pools) {
+  transitionStyle(out, cursor, pools.style.none, pools);
+  transitionHyperlink(out, cursor, 0, pools);
+}
+
+// src/renderer/screen/screen.ts
+var Screen = class {
+  width;
+  height;
+  cells;
+  _damage;
+  constructor(width, height) {
+    this.width = Math.max(0, width | 0);
+    this.height = Math.max(0, height | 0);
+    this.cells = new Array(this.width * this.height);
+    for (let i = 0; i < this.cells.length; i++) this.cells[i] = EMPTY_CELL;
+    this._damage = void 0;
+  }
+  get damage() {
+    return this._damage;
+  }
+  resetDamage() {
+    this._damage = void 0;
+  }
+  cellAt(x, y) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return void 0;
+    return this.cells[y * this.width + x];
+  }
+  writeCell(x, y, cell) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return;
+    this.cells[y * this.width + x] = cell;
+    this.markDamage(x, y, 1, 1);
+  }
+  markDamage(x, y, w, h) {
+    if (w <= 0 || h <= 0) return;
+    if (this._damage === void 0) {
+      this._damage = { x, y, width: w, height: h };
+      return;
+    }
+    const d = this._damage;
+    const x1 = Math.min(d.x, x);
+    const y1 = Math.min(d.y, y);
+    const x2 = Math.max(d.x + d.width, x + w);
+    const y2 = Math.max(d.y + d.height, y + h);
+    d.x = x1;
+    d.y = y1;
+    d.width = x2 - x1;
+    d.height = y2 - y1;
+  }
+};
+
+// src/renderer/diff/frame.ts
+function emptyFrame(viewportWidth, viewportHeight) {
+  return {
+    screen: new Screen(0, 0),
+    viewportWidth,
+    viewportHeight,
+    cursor: { x: 0, y: 0, visible: true }
+  };
+}
+
+// src/renderer/diff/serialize.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var ST = `${ESC}\\`;
+function serializePatches(patches) {
+  let out = "";
+  for (const patch of patches) {
+    out += serializeOne(patch);
+  }
+  return out;
+}
+function serializeOne(patch) {
+  switch (patch.type) {
+    case "stdout":
+      return patch.content;
+    case "cursorMove":
+      return cursorMove(patch.dx, patch.dy);
+    case "cursorTo":
+      return `${CSI}${patch.col + 1}G`;
+    case "cursorVisible":
+      return patch.visible ? `${CSI}?25h` : `${CSI}?25l`;
+    case "carriageReturn":
+      return "\r";
+    case "styleStr":
+      return patch.str;
+    case "hyperlink":
+      return `${ESC}]8;;${patch.uri}${ST}`;
+    case "clear":
+      return clearLines(patch.count);
+    case "clearTerminal":
+      return `${CSI}2J${CSI}H`;
+  }
+}
+function cursorMove(dx, dy) {
+  let out = "";
+  if (dy > 0) out += `${CSI}${dy}B`;
+  else if (dy < 0) out += `${CSI}${-dy}A`;
+  if (dx > 0) out += `${CSI}${dx}C`;
+  else if (dx < 0) out += `${CSI}${-dx}D`;
+  return out;
+}
+function clearLines(count) {
+  if (count <= 0) return `\r${CSI}J`;
+  return `\r${CSI}${count}A${CSI}J`;
+}
+
+// src/renderer/ink-compat/renderer-bridge.ts
+import { createContext as createContext2 } from "react";
+var RendererBridgeContext = createContext2(null);
+
+// src/renderer/ink-compat/use-app.ts
+import { createContext as createContext3, useContext as useContext2 } from "react";
+var AppContext = createContext3({ exit: () => {
+} });
+function useApp() {
+  return useContext2(AppContext);
+}
+
+// src/renderer/ink-compat/viewport.ts
+import { createContext as createContext4, createElement, useContext as useContext3, useMemo } from "react";
+var ViewportContext = createContext4({ columns: 80, rows: 24 });
+var StdoutContext = createContext4(
+  typeof process !== "undefined" ? process.stdout ?? null : null
+);
+function StdoutProvider({
+  stdout,
+  children
+}) {
+  return createElement(StdoutContext.Provider, { value: stdout }, children);
+}
+function useStdout() {
+  const viewport = useContext3(ViewportContext);
+  const real = useContext3(StdoutContext);
+  return useMemo(() => {
+    const stdout = {
+      columns: viewport.columns,
+      rows: viewport.rows,
+      isTTY: real ? real.isTTY : void 0,
+      write: real ? (data) => real.write(data) : () => true,
+      on: real ? (event, listener) => real.on(event, listener) : () => void 0,
+      off: real ? (event, listener) => real.off(event, listener) : () => void 0
+    };
+    return { stdout, write: stdout.write };
+  }, [viewport.columns, viewport.rows, real]);
+}
+
+// src/renderer/layout/layout.ts
+import stringWidthRaw from "string-width";
+
+// src/renderer/layout/yoga-layout.ts
+import Yoga, {
+  Align,
+  BoxSizing,
+  Direction,
+  Display,
+  Edge,
+  FlexDirection,
+  Gutter,
+  Justify,
+  MeasureMode,
+  Wrap
+} from "yoga-layout";
+
+// src/renderer/layout/borders.ts
+var BORDER_PRESETS = {
+  single: {
+    topLeft: "\u250C",
+    top: "\u2500",
+    topRight: "\u2510",
+    left: "\u2502",
+    right: "\u2502",
+    bottomLeft: "\u2514",
+    bottom: "\u2500",
+    bottomRight: "\u2518"
+  },
+  double: {
+    topLeft: "\u2554",
+    top: "\u2550",
+    topRight: "\u2557",
+    left: "\u2551",
+    right: "\u2551",
+    bottomLeft: "\u255A",
+    bottom: "\u2550",
+    bottomRight: "\u255D"
+  },
+  round: {
+    topLeft: "\u256D",
+    top: "\u2500",
+    topRight: "\u256E",
+    left: "\u2502",
+    right: "\u2502",
+    bottomLeft: "\u2570",
+    bottom: "\u2500",
+    bottomRight: "\u256F"
+  },
+  bold: {
+    topLeft: "\u250F",
+    top: "\u2501",
+    topRight: "\u2513",
+    left: "\u2503",
+    right: "\u2503",
+    bottomLeft: "\u2517",
+    bottom: "\u2501",
+    bottomRight: "\u251B"
+  },
+  ascii: {
+    topLeft: "+",
+    top: "-",
+    topRight: "+",
+    left: "|",
+    right: "|",
+    bottomLeft: "+",
+    bottom: "-",
+    bottomRight: "+"
+  }
+};
+function resolveBorderStyle(style) {
+  if (style === void 0) return void 0;
+  if (typeof style === "string") return BORDER_PRESETS[style];
+  return style;
+}
+
+// src/renderer/layout/yoga-layout.ts
+var ALIGN_MAP = {
+  "flex-start": Align.FlexStart,
+  "flex-end": Align.FlexEnd,
+  center: Align.Center,
+  stretch: Align.Stretch,
+  baseline: Align.Baseline
+};
+var JUSTIFY_MAP = {
+  "flex-start": Justify.FlexStart,
+  "flex-end": Justify.FlexEnd,
+  center: Justify.Center,
+  "space-between": Justify.SpaceBetween,
+  "space-around": Justify.SpaceAround,
+  "space-evenly": Justify.SpaceEvenly
+};
+function buildYogaTree(node, pools, measureText2) {
+  const meta = /* @__PURE__ */ new WeakMap();
+  const children = /* @__PURE__ */ new Map();
+  const root = build(node, pools, measureText2, meta, children);
+  return { root, meta, children };
+}
+function build(node, pools, measureText2, meta, children) {
+  if (node.kind === "text") {
+    return buildText(node, pools, measureText2, meta);
+  }
+  return buildBox(node, pools, measureText2, meta, children);
+}
+function buildText(node, pools, measureText2, meta) {
+  const yoga = Yoga.Node.create();
+  yoga.setBoxSizing(BoxSizing.BorderBox);
+  yoga.setFlexShrink(1);
+  const measure = (width, widthMode) => measureText2(node.content, width, widthMode);
+  yoga.setMeasureFunc(measure);
+  const styleId = node.style ? pools.style.intern(node.style) : pools.style.none;
+  const hyperlinkId = pools.hyperlink.intern(node.hyperlink);
+  meta.set(yoga, {
+    node,
+    useTop: false,
+    useBottom: false,
+    useLeft: false,
+    useRight: false,
+    styleId,
+    hyperlinkId
+  });
+  return yoga;
+}
+function buildBox(node, pools, measureText2, meta, children) {
+  const yoga = Yoga.Node.create();
+  yoga.setBoxSizing(BoxSizing.BorderBox);
+  yoga.setFlexShrink(1);
+  applyBoxStyle(yoga, node);
+  const border = resolveBorderStyle(node.borderStyle);
+  const useTop = border !== void 0 && node.borderTop !== false;
+  const useBottom = border !== void 0 && node.borderBottom !== false;
+  const useLeft = border !== void 0 && node.borderLeft !== false;
+  const useRight = border !== void 0 && node.borderRight !== false;
+  if (useTop) yoga.setBorder(Edge.Top, 1);
+  if (useBottom) yoga.setBorder(Edge.Bottom, 1);
+  if (useLeft) yoga.setBorder(Edge.Left, 1);
+  if (useRight) yoga.setBorder(Edge.Right, 1);
+  meta.set(yoga, {
+    node,
+    border,
+    useTop,
+    useBottom,
+    useLeft,
+    useRight,
+    styleId: 0,
+    hyperlinkId: 0
+  });
+  const childList = [];
+  for (let i = 0; i < node.children.length; i++) {
+    const childYoga = build(node.children[i], pools, measureText2, meta, children);
+    yoga.insertChild(childYoga, i);
+    childList.push(childYoga);
+  }
+  children.set(yoga, childList);
+  return yoga;
+}
+function applyBoxStyle(yoga, node) {
+  if (node.flexDirection === "row") yoga.setFlexDirection(FlexDirection.Row);
+  else if (node.flexDirection === "row-reverse") yoga.setFlexDirection(FlexDirection.RowReverse);
+  else if (node.flexDirection === "column-reverse")
+    yoga.setFlexDirection(FlexDirection.ColumnReverse);
+  else yoga.setFlexDirection(FlexDirection.Column);
+  if (node.flexGrow !== void 0) yoga.setFlexGrow(node.flexGrow);
+  if (node.flexShrink !== void 0) yoga.setFlexShrink(node.flexShrink);
+  if (node.flexBasis !== void 0) yoga.setFlexBasis(node.flexBasis);
+  if (node.flexWrap === "wrap") yoga.setFlexWrap(Wrap.Wrap);
+  else if (node.flexWrap === "wrap-reverse") yoga.setFlexWrap(Wrap.WrapReverse);
+  if (node.justifyContent) yoga.setJustifyContent(JUSTIFY_MAP[node.justifyContent]);
+  if (node.alignItems) yoga.setAlignItems(ALIGN_MAP[node.alignItems]);
+  if (node.alignSelf) yoga.setAlignSelf(ALIGN_MAP[node.alignSelf]);
+  if (node.alignContent) {
+    if (node.alignContent === "space-between") yoga.setAlignContent(Align.SpaceBetween);
+    else if (node.alignContent === "space-around") yoga.setAlignContent(Align.SpaceAround);
+    else yoga.setAlignContent(ALIGN_MAP[node.alignContent]);
+  }
+  if (node.width !== void 0) yoga.setWidth(node.width);
+  if (node.height !== void 0) yoga.setHeight(node.height);
+  if (node.minWidth !== void 0) yoga.setMinWidth(node.minWidth);
+  if (node.minHeight !== void 0) yoga.setMinHeight(node.minHeight);
+  if (node.maxWidth !== void 0) yoga.setMaxWidth(node.maxWidth);
+  if (node.maxHeight !== void 0) yoga.setMaxHeight(node.maxHeight);
+  if (node.gap !== void 0) yoga.setGap(Gutter.All, node.gap);
+  if (node.rowGap !== void 0) yoga.setGap(Gutter.Row, node.rowGap);
+  if (node.columnGap !== void 0) yoga.setGap(Gutter.Column, node.columnGap);
+  if (node.paddingTop !== void 0) yoga.setPadding(Edge.Top, node.paddingTop);
+  if (node.paddingBottom !== void 0) yoga.setPadding(Edge.Bottom, node.paddingBottom);
+  if (node.paddingLeft !== void 0) yoga.setPadding(Edge.Left, node.paddingLeft);
+  if (node.paddingRight !== void 0) yoga.setPadding(Edge.Right, node.paddingRight);
+  if (node.marginTop !== void 0) yoga.setMargin(Edge.Top, node.marginTop);
+  if (node.marginBottom !== void 0) yoga.setMargin(Edge.Bottom, node.marginBottom);
+  if (node.marginLeft !== void 0) yoga.setMargin(Edge.Left, node.marginLeft);
+  if (node.marginRight !== void 0) yoga.setMargin(Edge.Right, node.marginRight);
+  if (node.display === "none") yoga.setDisplay(Display.None);
+}
+
+// src/renderer/layout/layout.ts
+function stringWidth(s) {
+  if (s.length === 0) return 0;
+  if (s.length === 1) {
+    const code = s.charCodeAt(0);
+    if (code >= 9472 && code <= 9631) return 1;
+  }
+  return stringWidthRaw(s, { ambiguousIsNarrow: false });
+}
+function renderToScreen(node, width, pools, maxHeight) {
+  const w = Math.max(0, width | 0);
+  if (w === 0) return new Screen(0, 0);
+  const laid = layout(node, w, pools);
+  const cap = maxHeight !== void 0 ? Math.max(0, Math.floor(maxHeight)) : laid.rows.length;
+  const skip = Math.max(0, laid.rows.length - cap);
+  return blitRowSlice(laid.rows, skip, laid.rows.length, w, pools);
+}
+function renderViewport(node, width, pools, maxHeight) {
+  const w = Math.max(0, width | 0);
+  if (w === 0) {
+    return {
+      screen: new Screen(0, 0),
+      skipped: 0,
+      totalRows: 0,
+      serializePromoted: () => ""
+    };
+  }
+  const laid = layout(node, w, pools);
+  const cap = Math.max(0, Math.floor(maxHeight));
+  const skipped = Math.max(0, laid.rows.length - cap);
+  const screen = blitRowSlice(laid.rows, skipped, laid.rows.length, w, pools);
+  return {
+    screen,
+    skipped,
+    totalRows: laid.rows.length,
+    serializePromoted: (fromRow, toRow) => serializeRowSlice(
+      laid.rows,
+      Math.max(0, fromRow),
+      Math.min(toRow, laid.rows.length),
+      w,
+      pools
+    )
+  };
+}
+function blitRowSlice(rows, fromRow, toRow, width, pools) {
+  const h = Math.max(0, toRow - fromRow);
+  const screen = new Screen(width, h);
+  for (let y = 0; y < h; y++) {
+    for (const frag of rows[y + fromRow]) blitFragment(screen, frag, y, pools);
+  }
+  screen.resetDamage();
+  return screen;
+}
+function renderVirtual(node, width, pools) {
+  const w = Math.max(0, width | 0);
+  if (w === 0) {
+    return {
+      totalRows: 0,
+      windowAt: () => new Screen(0, 0)
+    };
+  }
+  const laid = layout(node, w, pools);
+  return {
+    totalRows: laid.rows.length,
+    windowAt(scrollOffset, windowHeight) {
+      const start = Math.max(0, Math.min(laid.rows.length, Math.floor(scrollOffset)));
+      const end = Math.max(start, Math.min(laid.rows.length, start + Math.floor(windowHeight)));
+      return blitRowSlice(laid.rows, start, end, w, pools);
+    }
+  };
+}
+function serializeRowSlice(rows, fromRow, toRow, width, pools) {
+  if (toRow <= fromRow) return "";
+  const screen = blitRowSlice(rows, fromRow, toRow, width, pools);
+  let out = "";
+  let curStyle = pools.style.none;
+  let curLink = 0;
+  for (let y = 0; y < screen.height; y++) {
+    if (y > 0) {
+      out += pools.style.transition(curStyle, pools.style.none);
+      curStyle = pools.style.none;
+      if (curLink !== 0) {
+        out += "\x1B]8;;\x1B\\";
+        curLink = 0;
+      }
+      out += "\r\n";
+    }
+    for (let x = 0; x < screen.width; x++) {
+      const cell = screen.cellAt(x, y);
+      if (!cell) continue;
+      if (cell.width === CellWidth.SpacerTail) continue;
+      if (cell.styleId !== curStyle) {
+        out += pools.style.transition(curStyle, cell.styleId);
+        curStyle = cell.styleId;
+      }
+      if (cell.hyperlinkId !== curLink) {
+        const uri = pools.hyperlink.get(cell.hyperlinkId) ?? "";
+        out += `\x1B]8;;${uri}\x1B\\`;
+        curLink = cell.hyperlinkId;
+      }
+      out += pools.char.get(cell.charId);
+    }
+  }
+  out += pools.style.transition(curStyle, pools.style.none);
+  if (curLink !== 0) out += "\x1B]8;;\x1B\\";
+  out += "\r\n";
+  return out;
+}
+function layout(node, availableWidth, pools) {
+  if (availableWidth <= 0) return { rows: [], width: 0 };
+  const built = buildYogaTree(node, pools, measureText);
+  built.root.calculateLayout(availableWidth, "auto", Direction.LTR);
+  const rootTop = Math.max(0, Math.round(built.root.getComputedTop()));
+  const rootLeft = Math.max(0, Math.round(built.root.getComputedLeft()));
+  const innerHeight = Math.max(0, Math.ceil(built.root.getComputedHeight()));
+  const innerWidth = Math.max(0, Math.ceil(built.root.getComputedWidth()));
+  const bottomMargin = node.kind === "box" ? Math.max(0, node.marginBottom ?? 0) : 0;
+  const rightMargin = node.kind === "box" ? Math.max(0, node.marginRight ?? 0) : 0;
+  const totalHeight = rootTop + innerHeight + bottomMargin;
+  const totalWidth = rootLeft + innerWidth + rightMargin;
+  const rows = [];
+  for (let i = 0; i < totalHeight; i++) rows.push([]);
+  rasterize(built.root, built, 0, 0, rows, pools);
+  built.root.freeRecursive();
+  return { rows, width: totalWidth };
+}
+function rasterize(yoga, built, parentX, parentY, rows, pools) {
+  const meta = built.meta.get(yoga);
+  if (!meta) return;
+  const left = parentX + Math.round(yoga.getComputedLeft());
+  const top = parentY + Math.round(yoga.getComputedTop());
+  const width = Math.max(0, Math.round(yoga.getComputedWidth()));
+  const height = Math.max(0, Math.round(yoga.getComputedHeight()));
+  if (meta.node.kind === "text") {
+    rasterizeText(meta.node, left, top, width, height, meta.styleId, meta.hyperlinkId, rows);
+    return;
+  }
+  const box = meta.node;
+  if (meta.border) {
+    paintBorder(meta, box, left, top, width, height, rows, pools);
+  }
+  const childList = built.children.get(yoga) ?? [];
+  for (const child of childList) {
+    rasterize(child, built, left, top, rows, pools);
+  }
+}
+function rasterizeText(text, x, y, width, height, styleId, hyperlinkId, rows) {
+  if (width <= 0 || height <= 0 || y < 0) return;
+  const segmenter = getSegmenter();
+  let lineIdx = 0;
+  for (const rawLine of text.content.split("\n")) {
+    if (lineIdx >= height) break;
+    const wrapped = wrapLine(rawLine, width, segmenter);
+    if (wrapped.length === 0) {
+      pushFragment(rows, y + lineIdx, { graphemes: [], styleId, hyperlinkId, leftPad: x });
+      lineIdx++;
+      continue;
+    }
+    for (const row of wrapped) {
+      if (lineIdx >= height) break;
+      pushFragment(rows, y + lineIdx, { graphemes: row, styleId, hyperlinkId, leftPad: x });
+      lineIdx++;
+    }
+  }
+}
+function paintBorder(meta, box, left, top, width, height, rows, pools) {
+  if (!meta.border || width <= 0 || height <= 0) return;
+  const border = meta.border;
+  const topColor = pickStyleId(box.borderTopColor ?? box.borderColor, pools);
+  const bottomColor = pickStyleId(box.borderBottomColor ?? box.borderColor, pools);
+  const leftColor = pickStyleId(box.borderLeftColor ?? box.borderColor, pools);
+  const rightColor = pickStyleId(box.borderRightColor ?? box.borderColor, pools);
+  if (meta.useTop) {
+    paintHorizontalEdge(
+      rows,
+      top,
+      left,
+      width,
+      border,
+      "top",
+      meta.useLeft,
+      meta.useRight,
+      topColor
+    );
+  }
+  if (meta.useBottom && height > 1) {
+    paintHorizontalEdge(
+      rows,
+      top + height - 1,
+      left,
+      width,
+      border,
+      "bottom",
+      meta.useLeft,
+      meta.useRight,
+      bottomColor
+    );
+  }
+  const innerTop = top + (meta.useTop ? 1 : 0);
+  const innerBottom = top + height - (meta.useBottom ? 2 : 1);
+  for (let r = innerTop; r <= innerBottom; r++) {
+    if (meta.useLeft) {
+      pushFragment(rows, r, {
+        graphemes: [{ glyph: border.left, width: Math.max(1, stringWidth(border.left)) }],
+        styleId: leftColor,
+        hyperlinkId: 0,
+        leftPad: left
+      });
+    }
+    if (meta.useRight && width > 1) {
+      pushFragment(rows, r, {
+        graphemes: [{ glyph: border.right, width: Math.max(1, stringWidth(border.right)) }],
+        styleId: rightColor,
+        hyperlinkId: 0,
+        leftPad: left + width - 1
+      });
+    }
+  }
+}
+function paintHorizontalEdge(rows, y, x, width, style, side, useLeft, useRight, styleId) {
+  if (width <= 0 || y < 0) return;
+  const corners = side === "top" ? [style.topLeft, style.topRight] : [style.bottomLeft, style.bottomRight];
+  const edge = side === "top" ? style.top : style.bottom;
+  const graphemes = [];
+  for (let i = 0; i < width; i++) {
+    let glyph;
+    if (i === 0 && useLeft) glyph = corners[0];
+    else if (i === width - 1 && useRight) glyph = corners[1];
+    else glyph = edge;
+    graphemes.push({ glyph, width: Math.max(1, stringWidth(glyph)) });
+  }
+  pushFragment(rows, y, { graphemes, styleId, hyperlinkId: 0, leftPad: x });
+}
+function pushFragment(rows, y, frag) {
+  if (y < 0) return;
+  while (rows.length <= y) rows.push([]);
+  rows[y].push(frag);
+}
+function pickStyleId(color, pools) {
+  return color ? pools.style.intern(color) : pools.style.none;
+}
+function measureText(content, width, widthMode) {
+  const segmenter = getSegmenter();
+  if (widthMode === MeasureMode.Undefined || width < 0) {
+    let maxW2 = 0;
+    let lines = 0;
+    for (const line of content.split("\n")) {
+      lines += 1;
+      const w = stringWidth(line);
+      if (w > maxW2) maxW2 = w;
+    }
+    return { width: maxW2, height: Math.max(1, lines) };
+  }
+  let maxW = 0;
+  let totalLines = 0;
+  for (const rawLine of content.split("\n")) {
+    const wrapped = wrapLine(rawLine, Math.floor(width), segmenter);
+    if (wrapped.length === 0) {
+      totalLines += 1;
+      continue;
+    }
+    totalLines += wrapped.length;
+    for (const row of wrapped) {
+      let w = 0;
+      for (const g of row) w += g.width;
+      if (w > maxW) maxW = w;
+    }
+  }
+  return { width: maxW, height: Math.max(1, totalLines) };
+}
+function wrapLine(line, width, segmenter) {
+  if (width <= 0) return [];
+  const rows = [];
+  let current = [];
+  let used = 0;
+  for (const seg of segmenter.segment(line)) {
+    const glyph = seg.segment;
+    const gw = Math.max(0, stringWidth(glyph));
+    if (gw === 0) continue;
+    if (used + gw > width) {
+      if (current.length > 0) rows.push(current);
+      current = [];
+      used = 0;
+      if (gw > width) continue;
+    }
+    current.push({ glyph, width: gw });
+    used += gw;
+  }
+  if (current.length > 0) rows.push(current);
+  return rows;
+}
+function blitFragment(screen, frag, y, pools) {
+  let x = frag.leftPad;
+  for (const { glyph, width } of frag.graphemes) {
+    if (x >= screen.width) break;
+    const charId = pools.char.intern(glyph);
+    const cell = {
+      charId,
+      styleId: frag.styleId,
+      hyperlinkId: frag.hyperlinkId,
+      width: width === 2 ? CellWidth.Wide : CellWidth.Single
+    };
+    screen.writeCell(x, y, cell);
+    if (width === 2 && x + 1 < screen.width) {
+      screen.writeCell(x + 1, y, {
+        charId: 1,
+        styleId: frag.styleId,
+        hyperlinkId: frag.hyperlinkId,
+        width: CellWidth.SpacerTail
+      });
+    }
+    x += width;
+  }
+}
+var _segmenter;
+function getSegmenter() {
+  if (_segmenter) return _segmenter;
+  _segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  return _segmenter;
+}
+
+// src/renderer/runtime/render-to-bytes.ts
+import { createElement as createElement2 } from "react";
+
+// src/renderer/reconciler/host-config.ts
+import ReactReconciler from "react-reconciler";
+
+// src/renderer/reconciler/host-node.ts
+function makeHostBox(props) {
+  return { type: "box", props, children: [], parent: null };
+}
+function makeHostText(props) {
+  return { type: "text", props, children: [], parent: null };
+}
+function makeHostRawText(text) {
+  return { type: "raw-text", text, parent: null };
+}
+function hostToLayoutNode(node) {
+  if (node.type === "raw-text") {
+    return { kind: "text", content: node.text };
+  }
+  if (node.type === "text") {
+    return {
+      kind: "text",
+      content: collectText(node.children),
+      ...node.props.style ? { style: node.props.style } : {},
+      ...node.props.hyperlink ? { hyperlink: node.props.hyperlink } : {}
+    };
+  }
+  const layoutChildren = [];
+  for (const c of node.children) {
+    const child = hostToLayoutNode(c);
+    if (child) layoutChildren.push(child);
+  }
+  const p = node.props;
+  const out = { kind: "box", children: layoutChildren };
+  return assignBoxProps(out, p);
+}
+function collectText(children) {
+  let out = "";
+  for (const child of children) {
+    if (child.type === "raw-text") out += child.text;
+    else if (child.type === "text") out += collectText(child.children);
+  }
+  return out;
+}
+function assignBoxProps(node, props) {
+  const result = { ...node };
+  const padAll = props.padding;
+  const padX = props.paddingX ?? padAll;
+  const padY = props.paddingY ?? padAll;
+  const padTop = props.paddingTop ?? padY;
+  const padBottom = props.paddingBottom ?? padY;
+  const padLeft = props.paddingLeft ?? padX;
+  const padRight = props.paddingRight ?? padX;
+  if (padTop !== void 0) result.paddingTop = padTop;
+  if (padBottom !== void 0) result.paddingBottom = padBottom;
+  if (padLeft !== void 0) result.paddingLeft = padLeft;
+  if (padRight !== void 0) result.paddingRight = padRight;
+  const marginAll = props.margin;
+  const marginX = props.marginX ?? marginAll;
+  const marginY = props.marginY ?? marginAll;
+  const marginTop = props.marginTop ?? marginY;
+  const marginBottom = props.marginBottom ?? marginY;
+  const marginLeft = props.marginLeft ?? marginX;
+  const marginRight = props.marginRight ?? marginX;
+  if (marginTop !== void 0) result.marginTop = marginTop;
+  if (marginBottom !== void 0) result.marginBottom = marginBottom;
+  if (marginLeft !== void 0) result.marginLeft = marginLeft;
+  if (marginRight !== void 0) result.marginRight = marginRight;
+  if (props.flexDirection !== void 0) result.flexDirection = props.flexDirection;
+  if (props.flexGrow !== void 0) result.flexGrow = props.flexGrow;
+  if (props.flexShrink !== void 0) result.flexShrink = props.flexShrink;
+  if (props.flexBasis !== void 0) result.flexBasis = props.flexBasis;
+  if (props.flexWrap !== void 0) result.flexWrap = props.flexWrap;
+  if (props.justifyContent !== void 0) result.justifyContent = props.justifyContent;
+  if (props.alignItems !== void 0) result.alignItems = props.alignItems;
+  if (props.alignSelf !== void 0) result.alignSelf = props.alignSelf;
+  if (props.alignContent !== void 0) result.alignContent = props.alignContent;
+  if (props.width !== void 0) result.width = props.width;
+  if (props.height !== void 0) result.height = props.height;
+  if (props.minWidth !== void 0) result.minWidth = props.minWidth;
+  if (props.minHeight !== void 0) result.minHeight = props.minHeight;
+  if (props.maxWidth !== void 0) result.maxWidth = props.maxWidth;
+  if (props.maxHeight !== void 0) result.maxHeight = props.maxHeight;
+  if (props.gap !== void 0) result.gap = props.gap;
+  if (props.columnGap !== void 0) result.columnGap = props.columnGap;
+  if (props.rowGap !== void 0) result.rowGap = props.rowGap;
+  if (props.display !== void 0) result.display = props.display;
+  if (props.borderStyle !== void 0) result.borderStyle = props.borderStyle;
+  if (props.borderTop !== void 0) result.borderTop = props.borderTop;
+  if (props.borderBottom !== void 0) result.borderBottom = props.borderBottom;
+  if (props.borderLeft !== void 0) result.borderLeft = props.borderLeft;
+  if (props.borderRight !== void 0) result.borderRight = props.borderRight;
+  if (props.borderColor !== void 0) result.borderColor = props.borderColor;
+  if (props.borderTopColor !== void 0) result.borderTopColor = props.borderTopColor;
+  if (props.borderBottomColor !== void 0) result.borderBottomColor = props.borderBottomColor;
+  if (props.borderLeftColor !== void 0) result.borderLeftColor = props.borderLeftColor;
+  if (props.borderRightColor !== void 0) result.borderRightColor = props.borderRightColor;
+  return result;
+}
+
+// src/renderer/reconciler/host-config.ts
+var hostConfig = {
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  // We're the only React renderer in this process. `false` would put us on
+  // React's shared non-primary context-stack — re-entrant updateContainer
+  // (the Static / emitStatic path) crashed against that. `true` gives us our
+  // own context state, no shared-stack collisions.
+  isPrimaryRenderer: true,
+  noTimeout: -1,
+  createInstance(type, props) {
+    if (type === HOST_BOX) return makeHostBox(props);
+    if (type === HOST_TEXT) return makeHostText(props);
+    throw new Error(`Reasonix renderer: unsupported element type: ${String(type)}`);
+  },
+  createTextInstance(text) {
+    return makeHostRawText(text);
+  },
+  appendInitialChild(parent, child) {
+    parent.children.push(child);
+    child.parent = parent;
+  },
+  appendChild(parent, child) {
+    parent.children.push(child);
+    child.parent = parent;
+  },
+  appendChildToContainer(container, child) {
+    container.children.push(child);
+    child.parent = null;
+  },
+  insertBefore(parent, child, beforeChild) {
+    const idx = parent.children.indexOf(beforeChild);
+    if (idx < 0) parent.children.push(child);
+    else parent.children.splice(idx, 0, child);
+    child.parent = parent;
+  },
+  insertInContainerBefore(container, child, beforeChild) {
+    const idx = container.children.indexOf(beforeChild);
+    if (idx < 0) container.children.push(child);
+    else container.children.splice(idx, 0, child);
+    child.parent = null;
+  },
+  removeChild(parent, child) {
+    const idx = parent.children.indexOf(child);
+    if (idx >= 0) parent.children.splice(idx, 1);
+    child.parent = null;
+  },
+  removeChildFromContainer(container, child) {
+    const idx = container.children.indexOf(child);
+    if (idx >= 0) container.children.splice(idx, 1);
+  },
+  finalizeInitialChildren() {
+    return false;
+  },
+  prepareUpdate(_instance, _type, _oldProps, newProps) {
+    return newProps;
+  },
+  commitUpdate(instance, payload) {
+    instance.props = payload;
+  },
+  commitTextUpdate(textInstance, _oldText, newText) {
+    textInstance.text = newText;
+  },
+  resetTextContent() {
+  },
+  shouldSetTextContent() {
+    return false;
+  },
+  getRootHostContext() {
+    return {};
+  },
+  getChildHostContext() {
+    return {};
+  },
+  getPublicInstance(instance) {
+    return instance;
+  },
+  prepareForCommit() {
+    return null;
+  },
+  resetAfterCommit(container) {
+    container.onCommit();
+  },
+  preparePortalMount() {
+  },
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  getCurrentEventPriority() {
+    return DefaultEventPriority;
+  },
+  getInstanceFromNode() {
+    return null;
+  },
+  beforeActiveInstanceBlur() {
+  },
+  afterActiveInstanceBlur() {
+  },
+  prepareScopeUpdate() {
+  },
+  getInstanceFromScope() {
+    return null;
+  },
+  detachDeletedInstance() {
+  },
+  clearContainer(container) {
+    container.children.length = 0;
+  }
+};
+var DefaultEventPriority = 16;
+var reconciler = ReactReconciler(hostConfig);
+
+// src/renderer/runtime/render-to-bytes.ts
+var ESC2 = "\x1B";
+var ST2 = `${ESC2}\\`;
+function renderToBytes(element, width, pools) {
+  const layout2 = renderTreeToLayout(element, width);
+  const screen = renderToScreen(layout2, width, pools);
+  if (screen.height === 0) return "";
+  let out = "";
+  let curStyle = pools.style.none;
+  let curLink = 0;
+  for (let y = 0; y < screen.height; y++) {
+    if (y > 0) {
+      out += pools.style.transition(curStyle, pools.style.none);
+      curStyle = pools.style.none;
+      if (curLink !== 0) {
+        out += `${ESC2}]8;;${ST2}`;
+        curLink = 0;
+      }
+      out += "\r\n";
+    }
+    for (let x = 0; x < screen.width; x++) {
+      const cell = screen.cellAt(x, y);
+      if (!cell) continue;
+      if (cell.width === CellWidth.SpacerTail) continue;
+      if (cell.styleId !== curStyle) {
+        out += pools.style.transition(curStyle, cell.styleId);
+        curStyle = cell.styleId;
+      }
+      if (cell.hyperlinkId !== curLink) {
+        const uri = pools.hyperlink.get(cell.hyperlinkId) ?? "";
+        out += `${ESC2}]8;;${uri}${ST2}`;
+        curLink = cell.hyperlinkId;
+      }
+      out += pools.char.get(cell.charId);
+    }
+  }
+  out += pools.style.transition(curStyle, pools.style.none);
+  if (curLink !== 0) out += `${ESC2}]8;;${ST2}`;
+  out += "\r\n";
+  return out;
+}
+function renderTreeToLayout(element, width) {
+  const root = {
+    children: [],
+    onCommit: () => {
+    }
+  };
+  const container = reconciler.createContainer(
+    root,
+    0,
+    // LegacyMode — sync
+    null,
+    false,
+    null,
+    "rsx-static",
+    () => {
+    },
+    null
+  );
+  const wrapped = createElement2(
+    ViewportContext.Provider,
+    { value: { columns: width, rows: 24 } },
+    element
+  );
+  reconciler.updateContainer(wrapped, container, null, () => {
+  });
+  const layoutChildren = [];
+  for (const c of root.children) {
+    const child = hostToLayoutNode(c);
+    if (child) layoutChildren.push(child);
+  }
+  const layout2 = layoutChildren.length === 1 ? layoutChildren[0] : { kind: "box", children: layoutChildren };
+  reconciler.updateContainer(null, container, null, () => {
+  });
+  return layout2;
+}
+
+// src/renderer/reconciler/cursor.ts
+import { createContext as createContext5, useContext as useContext4, useEffect as useEffect2 } from "react";
+var CursorContext = createContext5(null);
+function useCursor(target) {
+  const setter = useContext4(CursorContext);
+  const isSet = target !== null;
+  const col = target?.col ?? 0;
+  const rowFromBottom = target?.rowFromBottom ?? 0;
+  const visible = target?.visible !== false;
+  useEffect2(() => {
+    if (!setter) return;
+    if (!isSet) {
+      setter(null);
+      return;
+    }
+    setter({ col, rowFromBottom, visible });
+    return () => setter(null);
+  }, [setter, isSet, col, rowFromBottom, visible]);
+}
+
+// src/renderer/reconciler/mount.ts
+var RESET_SGR = "\x1B[0m";
+var CLOSE_HYPERLINK = "\x1B]8;;\x1B\\";
+var ENTER_VIRTUAL = "\x1B[?1049h\x1B[2J\x1B[H\x1B[?1002h\x1B[?1006h";
+var LEAVE_VIRTUAL = "\x1B[?1006l\x1B[?1002l\x1B[?1000l\x1B[?1049l";
+function mount(element, opts) {
+  const scrollMode = opts.scroll ?? "scrollback";
+  let viewportWidth = opts.viewportWidth;
+  let viewportHeight = opts.viewportHeight;
+  let frame = emptyFrame(viewportWidth, viewportHeight);
+  let reservedRows = 0;
+  let promotedRows = 0;
+  let scrollOffset = 0;
+  let stickyBottom = true;
+  let lastTotalRows = 0;
+  let destroyed = false;
+  let lastElement = element;
+  const reader = opts.stdin ? new KeystrokeReader({ source: opts.stdin }) : null;
+  let cursorTarget = null;
+  const setCursorTarget = (next) => {
+    cursorTarget = next;
+    if (!destroyed && root.children.length > 0) root.onCommit();
+  };
+  const computeCursor = (screenHeight) => {
+    if (cursorTarget) {
+      const rowFromBottom = Math.max(0, cursorTarget.rowFromBottom ?? 0);
+      const y = Math.max(0, screenHeight - 1 - rowFromBottom);
+      return {
+        x: Math.max(0, cursorTarget.col),
+        y,
+        visible: cursorTarget.visible !== false
+      };
+    }
+    if (opts.cursor) return opts.cursor();
+    return { x: 0, y: screenHeight, visible: true };
+  };
+  const scrollBy = (delta) => {
+    if (scrollMode !== "virtual") return;
+    const window = Math.max(1, viewportHeight - 1);
+    const maxOffset = Math.max(0, lastTotalRows - window);
+    const next = Math.max(0, Math.min(maxOffset, scrollOffset + delta));
+    if (next === scrollOffset) return;
+    scrollOffset = next;
+    stickyBottom = next === maxOffset;
+    if (root.children.length > 0) {
+      root.onCommit();
+    }
+  };
+  let exitCleanup = null;
+  let signalCleanup = null;
+  if (scrollMode === "virtual") {
+    opts.write(ENTER_VIRTUAL);
+    if (reader) {
+      reader.subscribe((k) => {
+        const window = Math.max(1, viewportHeight - 1);
+        if (k.pageUp) scrollBy(-window);
+        else if (k.pageDown) scrollBy(window);
+        else if (k.home) scrollBy(-Number.MAX_SAFE_INTEGER);
+        else if (k.end) scrollBy(Number.MAX_SAFE_INTEGER);
+        else if (k.wheelUp) scrollBy(-3);
+        else if (k.wheelDown) scrollBy(3);
+      });
+    }
+    if (typeof process !== "undefined" && process.on) {
+      exitCleanup = () => {
+        try {
+          opts.write(LEAVE_VIRTUAL);
+        } catch {
+        }
+      };
+      signalCleanup = () => process.exit(130);
+      process.on("exit", exitCleanup);
+      process.on("SIGINT", signalCleanup);
+      process.on("SIGTERM", signalCleanup);
+    }
+  }
+  const commitScrollback = (layout2) => {
+    const maxHeight = Math.max(1, viewportHeight - 1);
+    const split = renderViewport(layout2, viewportWidth, opts.pools, maxHeight);
+    const newPromote = Math.max(0, split.skipped - promotedRows);
+    let out = "";
+    if (newPromote > 0) {
+      if (frame.screen.height > 0) {
+        out += `\r\x1B[${frame.screen.height}A\x1B[J`;
+      } else if (reservedRows === 0) {
+        out += "\r\x1B[J";
+      }
+      out += split.serializePromoted(promotedRows, split.skipped);
+      promotedRows = split.skipped;
+      frame = emptyFrame(viewportWidth, viewportHeight);
+      reservedRows = 0;
+    }
+    const screen = split.screen;
+    const targetReserve = Math.min(screen.height, Math.max(0, viewportHeight - 1));
+    if (targetReserve > reservedRows) {
+      const delta = targetReserve - reservedRows;
+      if (reservedRows === 0) out += "\r";
+      out += `${"\n".repeat(delta)}\x1B[${delta}A`;
+      reservedRows = targetReserve;
+    }
+    const next = {
+      screen,
+      viewportWidth,
+      viewportHeight,
+      cursor: computeCursor(screen.height)
+    };
+    const patches = diffFrames(frame, next, opts.pools);
+    if (patches.length > 0) out += serializePatches(patches);
+    if (out.length > 0) opts.write(out);
+    frame = next;
+  };
+  const commitVirtual = (layout2) => {
+    const window = Math.max(1, viewportHeight - 1);
+    const virt = renderVirtual(layout2, viewportWidth, opts.pools);
+    const maxOffset = Math.max(0, virt.totalRows - window);
+    if (stickyBottom || virt.totalRows < lastTotalRows) {
+      scrollOffset = maxOffset;
+    } else {
+      scrollOffset = Math.min(scrollOffset, maxOffset);
+    }
+    lastTotalRows = virt.totalRows;
+    const screen = virt.windowAt(scrollOffset, window);
+    const targetReserve = Math.min(window, Math.max(0, viewportHeight - 1));
+    let out = "";
+    if (targetReserve > reservedRows) {
+      const delta = targetReserve - reservedRows;
+      if (reservedRows === 0) out += "\r";
+      out += `${"\n".repeat(delta)}\x1B[${delta}A`;
+      reservedRows = targetReserve;
+    }
+    const next = {
+      screen,
+      viewportWidth,
+      viewportHeight,
+      cursor: computeCursor(screen.height)
+    };
+    const patches = diffFrames(frame, next, opts.pools);
+    if (patches.length > 0) out += serializePatches(patches);
+    if (out.length > 0) opts.write(out);
+    frame = next;
+  };
+  const root = {
+    children: [],
+    onCommit: () => {
+      if (destroyed) return;
+      const layout2 = collectRootLayout(root.children);
+      if (scrollMode === "virtual") {
+        commitVirtual(layout2);
+      } else {
+        commitScrollback(layout2);
+      }
+    }
+  };
+  const container = reconciler.createContainer(
+    root,
+    0,
+    null,
+    false,
+    null,
+    "rsx",
+    () => {
+    },
+    null
+  );
+  const emitStatic = (node) => {
+    if (destroyed) return;
+    queueMicrotask(() => {
+      if (destroyed) return;
+      const bytes = renderToBytes(node, viewportWidth, opts.pools);
+      if (bytes.length === 0) return;
+      let out = "";
+      if (frame.screen.height > 0) {
+        out += `\r\x1B[${frame.screen.height}A\x1B[J`;
+      } else {
+        out += "\r\x1B[J";
+      }
+      out += bytes;
+      opts.write(out);
+      frame = emptyFrame(viewportWidth, viewportHeight);
+      reservedRows = 0;
+      root.onCommit();
+    });
+  };
+  const bridge = { emitStatic };
+  const appApi = {
+    exit: (error) => {
+      if (destroyed) return;
+      queueMicrotask(() => opts.onExit?.(error));
+    }
+  };
+  const wrap = (node) => {
+    const withApp = createElement3(AppContext.Provider, { value: appApi }, node);
+    const withBridge = createElement3(
+      RendererBridgeContext.Provider,
+      { value: bridge },
+      withApp
+    );
+    const withViewport = createElement3(
+      ViewportContext.Provider,
+      { value: { columns: viewportWidth, rows: viewportHeight } },
+      withBridge
+    );
+    const stdoutForCtx = opts.stdout ?? (typeof process !== "undefined" ? process.stdout : void 0);
+    const withStdout = stdoutForCtx ? createElement3(StdoutContext.Provider, { value: stdoutForCtx }, withViewport) : withViewport;
+    const withCursor = createElement3(
+      CursorContext.Provider,
+      { value: setCursorTarget },
+      withStdout
+    );
+    return reader ? createElement3(KeystrokeContext.Provider, { value: reader }, withCursor) : withCursor;
+  };
+  reconciler.updateContainer(wrap(element), container, null, () => {
+  });
+  return {
+    update(nextElement) {
+      if (destroyed) return;
+      lastElement = nextElement;
+      reconciler.updateContainer(wrap(nextElement), container, null, () => {
+      });
+    },
+    resize(width, height) {
+      if (destroyed) return;
+      viewportWidth = width;
+      viewportHeight = height;
+      frame = emptyFrame(width, height);
+      reservedRows = 0;
+      promotedRows = 0;
+      scrollOffset = 0;
+      stickyBottom = true;
+      lastTotalRows = 0;
+      opts.write("\x1B[2J\x1B[H");
+      reconciler.updateContainer(wrap(lastElement), container, null, () => {
+      });
+    },
+    emitStatic,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      reader?.destroy();
+      reconciler.updateContainer(null, container, null, () => {
+      });
+      const teardown = scrollMode === "virtual" ? LEAVE_VIRTUAL : "";
+      opts.write(`${teardown}${RESET_SGR}${CLOSE_HYPERLINK}`);
+      if (exitCleanup && typeof process !== "undefined" && process.off) {
+        process.off("exit", exitCleanup);
+        exitCleanup = null;
+      }
+      if (signalCleanup && typeof process !== "undefined" && process.off) {
+        process.off("SIGINT", signalCleanup);
+        process.off("SIGTERM", signalCleanup);
+        signalCleanup = null;
+      }
+    }
+  };
+}
+function collectRootLayout(children) {
+  const layoutChildren = [];
+  for (const c of children) {
+    const child = hostToLayoutNode(c);
+    if (child) layoutChildren.push(child);
+  }
+  if (layoutChildren.length === 1) return layoutChildren[0];
+  return { kind: "box", children: layoutChildren };
+}
+
+// src/renderer/ink-compat/index.ts
+var ink_compat_exports = {};
+__export(ink_compat_exports, {
+  AppContext: () => AppContext,
+  Box: () => Box2,
+  RendererBridgeContext: () => RendererBridgeContext,
+  Spacer: () => Spacer,
+  Static: () => Static,
+  StdoutContext: () => StdoutContext,
+  StdoutProvider: () => StdoutProvider,
+  Text: () => Text2,
+  ViewportContext: () => ViewportContext,
+  bgCode: () => bgCode,
+  fgCode: () => fgCode,
+  render: () => render,
+  useApp: () => useApp,
+  useInput: () => useInput,
+  useStdout: () => useStdout
+});
+
+// src/renderer/ink-compat/Box.tsx
+import React2 from "react";
+
+// src/renderer/ink-compat/colors.ts
+var FG_BASE = {
+  black: 30,
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34,
+  magenta: 35,
+  cyan: 36,
+  white: 37,
+  gray: 90,
+  grey: 90,
+  blackBright: 90,
+  redBright: 91,
+  greenBright: 92,
+  yellowBright: 93,
+  blueBright: 94,
+  magentaBright: 95,
+  cyanBright: 96,
+  whiteBright: 97
+};
+var FG_RESET = 39;
+var BG_RESET = 49;
+function fgCode(color) {
+  if (!color) return null;
+  if (color.startsWith("#")) {
+    const rgb = parseHex(color);
+    if (!rgb) return null;
+    return { apply: `\x1B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`, revert: `\x1B[${FG_RESET}m` };
+  }
+  const code = FG_BASE[color];
+  if (code === void 0) return null;
+  return { apply: `\x1B[${code}m`, revert: `\x1B[${FG_RESET}m` };
+}
+function bgCode(color) {
+  if (!color) return null;
+  if (color.startsWith("#")) {
+    const rgb = parseHex(color);
+    if (!rgb) return null;
+    return { apply: `\x1B[48;2;${rgb[0]};${rgb[1]};${rgb[2]}m`, revert: `\x1B[${BG_RESET}m` };
+  }
+  const base = FG_BASE[color];
+  if (base === void 0) return null;
+  const bg = base < 90 ? base + 10 : base + 10;
+  return { apply: `\x1B[${bg}m`, revert: `\x1B[${BG_RESET}m` };
+}
+function parseHex(hex) {
+  const s = hex.slice(1);
+  if (s.length === 3) {
+    const r = Number.parseInt(s[0] + s[0], 16);
+    const g = Number.parseInt(s[1] + s[1], 16);
+    const b = Number.parseInt(s[2] + s[2], 16);
+    return Number.isNaN(r) ? null : [r, g, b];
+  }
+  if (s.length === 6) {
+    const r = Number.parseInt(s.slice(0, 2), 16);
+    const g = Number.parseInt(s.slice(2, 4), 16);
+    const b = Number.parseInt(s.slice(4, 6), 16);
+    return Number.isNaN(r) ? null : [r, g, b];
+  }
+  return null;
+}
+
+// src/renderer/ink-compat/Box.tsx
+function Box2(props) {
+  const borderColor = fgCode(props.borderColor);
+  const borderTopColor = fgCode(props.borderTopColor);
+  const borderBottomColor = fgCode(props.borderBottomColor);
+  const borderLeftColor = fgCode(props.borderLeftColor);
+  const borderRightColor = fgCode(props.borderRightColor);
+  return /* @__PURE__ */ React2.createElement(
+    Box,
+    {
+      flexDirection: props.flexDirection ?? "row",
+      flexGrow: props.flexGrow,
+      flexShrink: props.flexShrink,
+      flexBasis: props.flexBasis,
+      flexWrap: props.flexWrap,
+      justifyContent: props.justifyContent,
+      alignItems: props.alignItems,
+      alignSelf: props.alignSelf,
+      alignContent: props.alignContent,
+      width: props.width,
+      height: props.height,
+      minWidth: props.minWidth,
+      minHeight: props.minHeight,
+      maxWidth: props.maxWidth,
+      maxHeight: props.maxHeight,
+      gap: props.gap,
+      columnGap: props.columnGap,
+      rowGap: props.rowGap,
+      display: props.display,
+      padding: props.padding,
+      paddingX: props.paddingX,
+      paddingY: props.paddingY,
+      paddingTop: props.paddingTop,
+      paddingBottom: props.paddingBottom,
+      paddingLeft: props.paddingLeft,
+      paddingRight: props.paddingRight,
+      margin: props.margin,
+      marginX: props.marginX,
+      marginY: props.marginY,
+      marginTop: props.marginTop,
+      marginBottom: props.marginBottom,
+      marginLeft: props.marginLeft,
+      marginRight: props.marginRight,
+      borderStyle: props.borderStyle,
+      borderColor: borderColor ? [borderColor] : void 0,
+      borderTopColor: borderTopColor ? [borderTopColor] : void 0,
+      borderBottomColor: borderBottomColor ? [borderBottomColor] : void 0,
+      borderLeftColor: borderLeftColor ? [borderLeftColor] : void 0,
+      borderRightColor: borderRightColor ? [borderRightColor] : void 0,
+      borderTop: props.borderTop,
+      borderBottom: props.borderBottom,
+      borderLeft: props.borderLeft,
+      borderRight: props.borderRight
+    },
+    props.children
+  );
+}
+
+// src/renderer/ink-compat/Text.tsx
+import React3 from "react";
+var SGR = {
+  bold: { apply: "\x1B[1m", revert: "\x1B[22m" },
+  dim: { apply: "\x1B[2m", revert: "\x1B[22m" },
+  italic: { apply: "\x1B[3m", revert: "\x1B[23m" },
+  underline: { apply: "\x1B[4m", revert: "\x1B[24m" },
+  inverse: { apply: "\x1B[7m", revert: "\x1B[27m" },
+  strikethrough: { apply: "\x1B[9m", revert: "\x1B[29m" }
+};
+function Text2(props) {
+  const codes = [];
+  const fg = fgCode(props.color);
+  if (fg) codes.push(fg);
+  const bg = bgCode(props.backgroundColor);
+  if (bg) codes.push(bg);
+  if (props.bold) codes.push(SGR.bold);
+  if (props.dimColor) codes.push(SGR.dim);
+  if (props.italic) codes.push(SGR.italic);
+  if (props.underline) codes.push(SGR.underline);
+  if (props.inverse) codes.push(SGR.inverse);
+  if (props.strikethrough) codes.push(SGR.strikethrough);
+  return /* @__PURE__ */ React3.createElement(Text, { style: codes.length > 0 ? codes : void 0 }, props.children);
+}
+
+// src/renderer/ink-compat/Spacer.tsx
+import React4 from "react";
+function Spacer() {
+  return /* @__PURE__ */ React4.createElement(Box, { flexGrow: 1 });
+}
+
+// src/renderer/ink-compat/Static.tsx
+import React5, { useContext as useContext5, useEffect as useEffect3, useRef } from "react";
+function Static(props) {
+  const bridge = useContext5(RendererBridgeContext);
+  const lastIndex = useRef(0);
+  useEffect3(() => {
+    if (!bridge) return;
+    if (props.items.length < lastIndex.current) {
+      lastIndex.current = props.items.length;
+      return;
+    }
+    if (props.items.length === lastIndex.current) return;
+    const fresh = props.items.slice(lastIndex.current);
+    const startIndex = lastIndex.current;
+    lastIndex.current = props.items.length;
+    bridge.emitStatic(
+      /* @__PURE__ */ React5.createElement(Box, { flexDirection: "column" }, fresh.map((item, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: Static items are positional and append-only
+        /* @__PURE__ */ React5.createElement(React5.Fragment, { key: `s-${startIndex + i}` }, props.children(item, startIndex + i))
+      )))
+    );
+  }, [bridge, props.items, props.children]);
+  if (bridge) return null;
+  return /* @__PURE__ */ React5.createElement(Box, { flexDirection: "column" }, props.items.map((item, i) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: fallback path with no bridge — positional keys are fine
+    /* @__PURE__ */ React5.createElement(React5.Fragment, { key: `s-${i}` }, props.children(item, i))
+  )));
+}
+
+// src/renderer/ink-compat/use-input.ts
+function useInput(handler, options = {}) {
+  const active = options.isActive !== false;
+  useKeystroke((k) => {
+    if (!active) return;
+    handler(k.input ?? "", toInkKey(k));
+  });
+}
+function toInkKey(k) {
+  return {
+    upArrow: k.upArrow,
+    downArrow: k.downArrow,
+    leftArrow: k.leftArrow,
+    rightArrow: k.rightArrow,
+    pageDown: k.pageDown,
+    pageUp: k.pageUp,
+    return: k.return,
+    escape: k.escape,
+    ctrl: k.ctrl,
+    shift: k.shift,
+    tab: k.tab,
+    backspace: k.backspace,
+    delete: k.delete,
+    meta: k.meta
+  };
+}
+
+// src/renderer/ink-compat/render.tsx
+function render(element, opts = {}) {
+  const stdout = opts.stdout ?? process.stdout;
+  const stdin = opts.stdin ?? process.stdin;
+  const exitOnCtrlC = opts.exitOnCtrlC !== false;
+  const pools = {
+    char: new CharPool(),
+    style: new StylePool(),
+    hyperlink: new HyperlinkPool()
+  };
+  let resolveExit = () => {
+  };
+  let exitError;
+  const exitPromise = new Promise((resolve, reject) => {
+    resolveExit = () => {
+      if (exitError) reject(exitError);
+      else resolve();
+    };
+  });
+  let destroyed = false;
+  let handle = null;
+  const onResize = () => {
+    if (destroyed || !handle) return;
+    handle.resize(stdout.columns ?? 80, stdout.rows ?? 24);
+  };
+  const onCtrlCData = (chunk) => {
+    if (destroyed || !exitOnCtrlC) return;
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (text.includes("")) instance.unmount();
+  };
+  handle = mount(element, {
+    viewportWidth: stdout.columns ?? 80,
+    viewportHeight: stdout.rows ?? 24,
+    pools,
+    write: (bytes) => stdout.write(bytes),
+    stdin,
+    stdout,
+    onExit: (err) => {
+      if (destroyed) return;
+      if (err) exitError = err;
+      instance.unmount();
+    }
+  });
+  stdout.on("resize", onResize);
+  stdin.on("data", onCtrlCData);
+  const sigintListener = () => {
+    if (!destroyed) instance.unmount();
+  };
+  if (exitOnCtrlC) process.on("SIGINT", sigintListener);
+  const instance = {
+    rerender(next) {
+      if (destroyed || !handle) return;
+      handle.update(next);
+    },
+    unmount() {
+      if (destroyed) return;
+      destroyed = true;
+      stdout.off("resize", onResize);
+      stdin.off("data", onCtrlCData);
+      if (exitOnCtrlC) process.off("SIGINT", sigintListener);
+      handle?.destroy();
+      handle = null;
+      resolveExit();
+    },
+    waitUntilExit() {
+      return exitPromise;
+    },
+    cleanup() {
+    },
+    clear() {
+      if (destroyed) return;
+      stdout.write("\x1B[2J\x1B[H");
+    }
+  };
+  return instance;
+}
+
+// src/renderer/react/render.ts
+import { Fragment, isValidElement } from "react";
+
+export {
+  Box,
+  Text,
+  Box2,
+  Text2,
+  Static,
+  useStdout,
+  useApp,
+  useKeystroke,
+  useInput,
+  CharPool,
+  HyperlinkPool,
+  StylePool,
+  useCursor,
+  mount,
+  render,
+  ink_compat_exports
+};
+//# sourceMappingURL=chunk-JHXQDL7B.js.map