@opentui/core 0.1.23 → 0.1.25

package/{index-a6ydv6yb.js → index-6kvgbzah.js}

@@ -1,3 +1,4 @@
+// @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -26,102 +27,29 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 
-// src/lib/border.ts
-var BorderChars = {
-  single: {
-    topLeft: "\u250C",
-    topRight: "\u2510",
-    bottomLeft: "\u2514",
-    bottomRight: "\u2518",
-    horizontal: "\u2500",
-    vertical: "\u2502",
-    topT: "\u252C",
-    bottomT: "\u2534",
-    leftT: "\u251C",
-    rightT: "\u2524",
-    cross: "\u253C"
-  },
-  double: {
-    topLeft: "\u2554",
-    topRight: "\u2557",
-    bottomLeft: "\u255A",
-    bottomRight: "\u255D",
-    horizontal: "\u2550",
-    vertical: "\u2551",
-    topT: "\u2566",
-    bottomT: "\u2569",
-    leftT: "\u2560",
-    rightT: "\u2563",
-    cross: "\u256C"
-  },
-  rounded: {
-    topLeft: "\u256D",
-    topRight: "\u256E",
-    bottomLeft: "\u2570",
-    bottomRight: "\u256F",
-    horizontal: "\u2500",
-    vertical: "\u2502",
-    topT: "\u252C",
-    bottomT: "\u2534",
-    leftT: "\u251C",
-    rightT: "\u2524",
-    cross: "\u253C"
-  },
-  heavy: {
-    topLeft: "\u250F",
-    topRight: "\u2513",
-    bottomLeft: "\u2517",
-    bottomRight: "\u251B",
-    horizontal: "\u2501",
-    vertical: "\u2503",
-    topT: "\u2533",
-    bottomT: "\u253B",
-    leftT: "\u2523",
-    rightT: "\u252B",
-    cross: "\u254B"
-  }
-};
-function getBorderFromSides(sides) {
-  const result = [];
-  if (sides.top)
-    result.push("top");
-  if (sides.right)
-    result.push("right");
-  if (sides.bottom)
-    result.push("bottom");
-  if (sides.left)
-    result.push("left");
-  return result.length > 0 ? result : false;
-}
-function getBorderSides(border) {
-  return border === true ? { top: true, right: true, bottom: true, left: true } : Array.isArray(border) ? {
-    top: border.includes("top"),
-    right: border.includes("right"),
-    bottom: border.includes("bottom"),
-    left: border.includes("left")
-  } : { top: false, right: false, bottom: false, left: false };
-}
-function borderCharsToArray(chars) {
-  const array = new Uint32Array(11);
-  array[0] = chars.topLeft.codePointAt(0);
-  array[1] = chars.topRight.codePointAt(0);
-  array[2] = chars.bottomLeft.codePointAt(0);
-  array[3] = chars.bottomRight.codePointAt(0);
-  array[4] = chars.horizontal.codePointAt(0);
-  array[5] = chars.vertical.codePointAt(0);
-  array[6] = chars.topT.codePointAt(0);
-  array[7] = chars.bottomT.codePointAt(0);
-  array[8] = chars.leftT.codePointAt(0);
-  array[9] = chars.rightT.codePointAt(0);
-  array[10] = chars.cross.codePointAt(0);
-  return array;
-}
-var BorderCharArrays = {
-  single: borderCharsToArray(BorderChars.single),
-  double: borderCharsToArray(BorderChars.double),
-  rounded: borderCharsToArray(BorderChars.rounded),
-  heavy: borderCharsToArray(BorderChars.heavy)
-};
+// ../../node_modules/yoga-layout/dist/src/index.js
+var exports_src = {};
+__export(exports_src, {
+  default: () => src_default,
+  Wrap: () => Wrap,
+  Unit: () => Unit,
+  PositionType: () => PositionType,
+  Overflow: () => Overflow,
+  NodeType: () => NodeType,
+  MeasureMode: () => MeasureMode,
+  LogLevel: () => LogLevel,
+  Justify: () => Justify,
+  Gutter: () => Gutter,
+  FlexDirection: () => FlexDirection,
+  ExperimentalFeature: () => ExperimentalFeature,
+  Errata: () => Errata,
+  Edge: () => Edge,
+  Display: () => Display,
+  Direction: () => Direction,
+  Dimension: () => Dimension,
+  BoxSizing: () => BoxSizing,
+  Align: () => Align
+});
 
 // ../../node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
 var loadYoga = (() => {
@@ -1737,186 +1665,336 @@ function wrapAssembly(lib) {
 var Yoga = wrapAssembly(await yoga_wasm_base64_esm_default());
 var src_default = Yoga;
 
-// src/lib/TrackedNode.ts
-import { EventEmitter } from "events";
-
-class TrackedNode extends EventEmitter {
-  static idCounter = 0;
-  id;
-  yogaNode;
-  metadata;
-  parent;
-  children;
-  _destroyed = false;
-  _width = "auto";
-  _height = "auto";
-  constructor(yogaNode, metadata = {}) {
-    super();
-    this.id = TrackedNode.idCounter++;
-    this.yogaNode = yogaNode;
-    this.metadata = metadata;
-    this.parent = null;
-    this.children = [];
-  }
-  parseWidth(width) {
-    if (this._destroyed) {
-      throw new Error("Node is destroyed");
-    }
-    if (typeof width === "number" || width === "auto") {
-      return width;
-    }
-    if (!this.parent) {
-      return this.yogaNode.getComputedWidth();
-    }
-    if (this.parent._destroyed) {
-      throw new Error("Parent node is destroyed");
-    }
-    return Math.floor(this.parent.yogaNode.getComputedWidth() * parseInt(width) / 100);
+// src/lib/border.ts
+var BorderChars = {
+  single: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    topT: "\u252C",
+    bottomT: "\u2534",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    cross: "\u253C"
+  },
+  double: {
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    horizontal: "\u2550",
+    vertical: "\u2551",
+    topT: "\u2566",
+    bottomT: "\u2569",
+    leftT: "\u2560",
+    rightT: "\u2563",
+    cross: "\u256C"
+  },
+  rounded: {
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    topT: "\u252C",
+    bottomT: "\u2534",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    cross: "\u253C"
+  },
+  heavy: {
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B",
+    horizontal: "\u2501",
+    vertical: "\u2503",
+    topT: "\u2533",
+    bottomT: "\u253B",
+    leftT: "\u2523",
+    rightT: "\u252B",
+    cross: "\u254B"
   }
-  parseHeight(height) {
-    if (this._destroyed) {
-      throw new Error("Node is destroyed");
-    }
-    if (typeof height === "number" || height === "auto") {
-      return height;
-    }
-    if (!this.parent) {
-      return this.yogaNode.getComputedHeight();
-    }
-    if (this.parent._destroyed) {
-      throw new Error("Parent node is destroyed");
+};
+function getBorderFromSides(sides) {
+  const result = [];
+  if (sides.top)
+    result.push("top");
+  if (sides.right)
+    result.push("right");
+  if (sides.bottom)
+    result.push("bottom");
+  if (sides.left)
+    result.push("left");
+  return result.length > 0 ? result : false;
+}
+function getBorderSides(border) {
+  return border === true ? { top: true, right: true, bottom: true, left: true } : Array.isArray(border) ? {
+    top: border.includes("top"),
+    right: border.includes("right"),
+    bottom: border.includes("bottom"),
+    left: border.includes("left")
+  } : { top: false, right: false, bottom: false, left: false };
+}
+function borderCharsToArray(chars) {
+  const array = new Uint32Array(11);
+  array[0] = chars.topLeft.codePointAt(0);
+  array[1] = chars.topRight.codePointAt(0);
+  array[2] = chars.bottomLeft.codePointAt(0);
+  array[3] = chars.bottomRight.codePointAt(0);
+  array[4] = chars.horizontal.codePointAt(0);
+  array[5] = chars.vertical.codePointAt(0);
+  array[6] = chars.topT.codePointAt(0);
+  array[7] = chars.bottomT.codePointAt(0);
+  array[8] = chars.leftT.codePointAt(0);
+  array[9] = chars.rightT.codePointAt(0);
+  array[10] = chars.cross.codePointAt(0);
+  return array;
+}
+var BorderCharArrays = {
+  single: borderCharsToArray(BorderChars.single),
+  double: borderCharsToArray(BorderChars.double),
+  rounded: borderCharsToArray(BorderChars.rounded),
+  heavy: borderCharsToArray(BorderChars.heavy)
+};
+
+// src/lib/parse.keypress.ts
+import { Buffer } from "buffer";
+
+// src/lib/parse.keypress-kitty.ts
+var kittyKeyMap = {
+  27: "escape",
+  9: "tab",
+  13: "enter",
+  127: "backspace",
+  57344: "escape",
+  57345: "enter",
+  57346: "tab",
+  57347: "backspace",
+  57348: "insert",
+  57349: "delete",
+  57350: "left",
+  57351: "right",
+  57352: "up",
+  57353: "down",
+  57354: "pageup",
+  57355: "pagedown",
+  57356: "home",
+  57357: "end",
+  57364: "f1",
+  57365: "f2",
+  57366: "f3",
+  57367: "f4",
+  57368: "f5",
+  57369: "f6",
+  57370: "f7",
+  57371: "f8",
+  57372: "f9",
+  57373: "f10",
+  57374: "f11",
+  57375: "f12",
+  57376: "f13",
+  57377: "f14",
+  57378: "f15",
+  57379: "f16",
+  57380: "f17",
+  57381: "f18",
+  57382: "f19",
+  57383: "f20",
+  57384: "f21",
+  57385: "f22",
+  57386: "f23",
+  57387: "f24",
+  57388: "f25",
+  57389: "f26",
+  57390: "f27",
+  57391: "f28",
+  57392: "f29",
+  57393: "f30",
+  57394: "f31",
+  57395: "f32",
+  57396: "f33",
+  57397: "f34",
+  57398: "f35",
+  57400: "kp0",
+  57401: "kp1",
+  57402: "kp2",
+  57403: "kp3",
+  57404: "kp4",
+  57405: "kp5",
+  57406: "kp6",
+  57407: "kp7",
+  57408: "kp8",
+  57409: "kp9",
+  57410: "kpdecimal",
+  57411: "kpdivide",
+  57412: "kpmultiply",
+  57413: "kpminus",
+  57414: "kpplus",
+  57415: "kpenter",
+  57416: "kpequal",
+  57428: "mediaplay",
+  57429: "mediapause",
+  57430: "mediaplaypause",
+  57431: "mediareverse",
+  57432: "mediastop",
+  57433: "mediafastforward",
+  57434: "mediarewind",
+  57435: "medianext",
+  57436: "mediaprev",
+  57437: "mediarecord",
+  57438: "volumedown",
+  57439: "volumeup",
+  57440: "mute",
+  57441: "leftshift",
+  57442: "leftctrl",
+  57443: "leftalt",
+  57444: "leftsuper",
+  57445: "lefthyper",
+  57446: "leftmeta",
+  57447: "rightshift",
+  57448: "rightctrl",
+  57449: "rightalt",
+  57450: "rightsuper",
+  57451: "righthyper",
+  57452: "rightmeta",
+  57453: "iso_level3_shift",
+  57454: "iso_level5_shift"
+};
+function fromKittyMods(mod) {
+  return {
+    shift: !!(mod & 1),
+    alt: !!(mod & 2),
+    ctrl: !!(mod & 4),
+    super: !!(mod & 8),
+    hyper: !!(mod & 16),
+    meta: !!(mod & 32),
+    capsLock: !!(mod & 64),
+    numLock: !!(mod & 128)
+  };
+}
+function parseKittyKeyboard(sequence) {
+  const kittyRe = /^\x1b\[([^\x1b]+)u$/;
+  const match = kittyRe.exec(sequence);
+  if (!match)
+    return null;
+  const params = match[1];
+  const fields = params.split(";");
+  if (fields.length < 1)
+    return null;
+  const key = {
+    name: "",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    number: false,
+    sequence,
+    raw: sequence,
+    eventType: "press",
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false
+  };
+  let text = "";
+  const field1 = fields[0]?.split(":") || [];
+  const codepointStr = field1[0];
+  if (!codepointStr)
+    return null;
+  const codepoint = parseInt(codepointStr, 10);
+  if (isNaN(codepoint))
+    return null;
+  let shiftedCodepoint;
+  let baseCodepoint;
+  if (field1[1]) {
+    const shifted = parseInt(field1[1], 10);
+    if (!isNaN(shifted) && shifted > 0 && shifted <= 1114111) {
+      shiftedCodepoint = shifted;
     }
-    return Math.floor(this.parent.yogaNode.getComputedHeight() * parseInt(height) / 100);
   }
-  setWidth(width) {
-    this._width = width;
-    const parsedWidth = this.parseWidth(width);
-    if (parsedWidth === "auto") {
-      this.yogaNode.setWidthAuto();
-    } else {
-      this.yogaNode.setWidth(parsedWidth);
+  if (field1[2]) {
+    const base = parseInt(field1[2], 10);
+    if (!isNaN(base) && base > 0 && base <= 1114111) {
+      baseCodepoint = base;
     }
   }
-  setHeight(height) {
-    this._height = height;
-    const parsedHeight = this.parseHeight(height);
-    if (parsedHeight === "auto") {
-      this.yogaNode.setHeightAuto();
+  const knownKey = kittyKeyMap[codepoint];
+  if (knownKey) {
+    key.name = knownKey;
+    key.code = `[${codepoint}u`;
+  } else {
+    if (codepoint > 0 && codepoint <= 1114111) {
+      const char = String.fromCodePoint(codepoint);
+      key.name = char;
+      if (baseCodepoint) {
+        key.baseCode = baseCodepoint;
+      }
     } else {
-      this.yogaNode.setHeight(parsedHeight);
+      return null;
     }
   }
-  addChild(childNode) {
-    if (childNode.parent) {
-      childNode.parent.removeChild(childNode);
+  if (fields[1]) {
+    const field2 = fields[1].split(":");
+    const modifierStr = field2[0];
+    const eventTypeStr = field2[1];
+    if (modifierStr) {
+      const modifierMask = parseInt(modifierStr, 10);
+      if (!isNaN(modifierMask) && modifierMask > 1) {
+        const mods = fromKittyMods(modifierMask - 1);
+        key.shift = mods.shift;
+        key.ctrl = mods.ctrl;
+        key.meta = mods.alt || mods.meta;
+        key.option = mods.alt;
+        key.super = mods.super;
+        key.hyper = mods.hyper;
+        key.capsLock = mods.capsLock;
+        key.numLock = mods.numLock;
+      }
     }
-    childNode.parent = this;
-    const index = this.children.length;
-    this.children.push(childNode);
-    this.yogaNode.insertChild(childNode.yogaNode, index);
-    try {
-      childNode.yogaNode.setWidth(childNode.parseWidth(childNode._width));
-      childNode.yogaNode.setHeight(childNode.parseHeight(childNode._height));
-    } catch (e) {
-      console.error("Error setting width and height", e);
+    if (eventTypeStr === "1" || !eventTypeStr) {
+      key.eventType = "press";
+    } else if (eventTypeStr === "2") {
+      key.eventType = "repeat";
+    } else if (eventTypeStr === "3") {
+      key.eventType = "release";
+    } else {
+      key.eventType = "press";
     }
-    return index;
-  }
-  getChildIndex(childNode) {
-    return this.children.indexOf(childNode);
   }
-  removeChild(childNode) {
-    const index = this.children.indexOf(childNode);
-    if (index === -1) {
-      return false;
-    }
-    this.children.splice(index, 1);
-    this.yogaNode.removeChild(childNode.yogaNode);
-    childNode.parent = null;
-    return true;
-  }
-  removeChildAtIndex(index) {
-    if (index < 0 || index >= this.children.length) {
-      return null;
-    }
-    const childNode = this.children[index];
-    this.children.splice(index, 1);
-    this.yogaNode.removeChild(childNode.yogaNode);
-    childNode.parent = null;
-    return childNode;
-  }
-  moveChild(childNode, newIndex) {
-    const currentIndex = this.children.indexOf(childNode);
-    if (currentIndex === -1) {
-      throw new Error("Node is not a child of this parent");
-    }
-    const boundedNewIndex = Math.max(0, Math.min(newIndex, this.children.length - 1));
-    if (currentIndex === boundedNewIndex) {
-      return currentIndex;
-    }
-    this.children.splice(currentIndex, 1);
-    this.children.splice(boundedNewIndex, 0, childNode);
-    this.yogaNode.removeChild(childNode.yogaNode);
-    this.yogaNode.insertChild(childNode.yogaNode, boundedNewIndex);
-    return boundedNewIndex;
-  }
-  insertChild(childNode, index) {
-    if (childNode.parent) {
-      childNode.parent.removeChild(childNode);
-    }
-    childNode.parent = this;
-    const boundedIndex = Math.max(0, Math.min(index, this.children.length));
-    this.children.splice(boundedIndex, 0, childNode);
-    this.yogaNode.insertChild(childNode.yogaNode, boundedIndex);
-    try {
-      childNode.yogaNode.setWidth(childNode.parseWidth(childNode._width));
-      childNode.yogaNode.setHeight(childNode.parseHeight(childNode._height));
-    } catch (e) {
-      console.error("Error setting width and height", e);
+  if (fields[2]) {
+    const codepoints = fields[2].split(":");
+    for (const cpStr of codepoints) {
+      const cp = parseInt(cpStr, 10);
+      if (!isNaN(cp) && cp > 0 && cp <= 1114111) {
+        text += String.fromCodePoint(cp);
+      }
     }
-    return boundedIndex;
-  }
-  getChildCount() {
-    return this.children.length;
   }
-  getChildAtIndex(index) {
-    if (index < 0 || index >= this.children.length) {
-      return null;
+  if (text === "") {
+    const isPrintable = key.name.length > 0 && !kittyKeyMap[codepoint];
+    if (isPrintable) {
+      if (key.shift && shiftedCodepoint) {
+        text = String.fromCodePoint(shiftedCodepoint);
+      } else {
+        text = key.name;
+      }
     }
-    return this.children[index];
   }
-  setMetadata(key, value) {
-    this.metadata[key] = value;
+  if (key.name === " " && key.shift && !key.ctrl && !key.meta) {
+    text = " ";
   }
-  getMetadata(key) {
-    return this.metadata[key];
+  if (text) {
+    key.sequence = text;
   }
-  removeMetadata(key) {
-    delete this.metadata[key];
-  }
-  hasChild(childNode) {
-    return this.children.includes(childNode);
-  }
-  destroy() {
-    if (this._destroyed) {
-      return;
-    }
-    if (this.parent) {
-      this.parent.removeChild(this);
-    }
-    try {
-      this.yogaNode.free();
-    } catch (e) {}
-    this._destroyed = true;
-  }
-}
-function createTrackedNode(metadata = {}, yogaConfig) {
-  const yogaNode = src_default.Node.create(yogaConfig);
-  return new TrackedNode(yogaNode, metadata);
+  return key;
 }
 
 // src/lib/parse.keypress.ts
-import { Buffer } from "buffer";
 var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 var fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
 var keyName = {
@@ -2000,7 +2078,7 @@ var isShiftKey = (code) => {
 var isCtrlKey = (code) => {
   return ["Oa", "Ob", "Oc", "Od", "Oe", "[2^", "[3^", "[5^", "[6^", "[7^", "[8^"].includes(code);
 };
-var parseKeypress = (s = "") => {
+var parseKeypress = (s = "", options = {}) => {
   let parts;
   if (Buffer.isBuffer(s)) {
     if (s[0] > 127 && s[1] === undefined) {
@@ -2022,9 +2100,16 @@ var parseKeypress = (s = "") => {
     option: false,
     number: false,
     sequence: s,
-    raw: s
+    raw: s,
+    eventType: "press"
   };
   key.sequence = key.sequence || s || key.name;
+  if (options.useKittyKeyboard && /^\x1b\[.*u$/.test(s)) {
+    const kittyResult = parseKittyKeyboard(s);
+    if (kittyResult) {
+      return kittyResult;
+    }
+  }
   if (s === "\r") {
     key.name = "return";
   } else if (s === `
@@ -2064,15 +2149,21 @@ var parseKeypress = (s = "") => {
       key.option = true;
     }
     const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
-    const modifier = (parts[3] || parts[5] || 1) - 1;
+    const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1;
     key.ctrl = !!(modifier & 4);
     key.meta = !!(modifier & 10);
     key.shift = !!(modifier & 1);
     key.option = !!(modifier & 2);
     key.code = code;
-    key.name = keyName[code];
-    key.shift = isShiftKey(code) || key.shift;
-    key.ctrl = isCtrlKey(code) || key.ctrl;
+    const keyNameResult = keyName[code];
+    if (keyNameResult) {
+      key.name = keyNameResult;
+      key.shift = isShiftKey(code) || key.shift;
+      key.ctrl = isCtrlKey(code) || key.ctrl;
+    } else {
+      key.name = "";
+      key.code = undefined;
+    }
   } else if (s === "\x1B[3~") {
     key.name = "delete";
     key.meta = false;
@@ -2082,42 +2173,69 @@ var parseKeypress = (s = "") => {
 };
 
 // src/lib/KeyHandler.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter } from "events";
 
-// src/singleton.ts
-var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
-function singleton(key, factory) {
-  const bag = globalThis[singletonCacheSymbol] ??= {};
-  if (!(key in bag)) {
-    bag[key] = factory();
-  }
-  return bag[key];
-}
+// src/ansi.ts
+var ANSI = {
+  switchToAlternateScreen: "\x1B[?1049h",
+  switchToMainScreen: "\x1B[?1049l",
+  reset: "\x1B[0m",
+  scrollDown: (lines) => `\x1B[${lines}T`,
+  scrollUp: (lines) => `\x1B[${lines}S`,
+  moveCursor: (row, col) => `\x1B[${row};${col}H`,
+  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
+  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
+  resetBackground: "\x1B[49m",
+  bracketedPasteStart: "\x1B[200~",
+  bracketedPasteEnd: "\x1B[201~"
+};
 
 // src/lib/KeyHandler.ts
-class KeyHandler extends EventEmitter2 {
-  constructor() {
+class KeyHandler extends EventEmitter {
+  stdin;
+  useKittyKeyboard;
+  listener;
+  pasteMode = false;
+  pasteBuffer = [];
+  constructor(stdin, useKittyKeyboard = false) {
     super();
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (key) => {
-      const parsedKey = parseKeypress(key);
-      this.emit("keypress", parsedKey);
-    });
+    this.stdin = stdin || process.stdin;
+    this.useKittyKeyboard = useKittyKeyboard;
+    this.listener = (key) => {
+      let data = key.toString();
+      if (data.startsWith(ANSI.bracketedPasteStart)) {
+        this.pasteMode = true;
+      }
+      if (this.pasteMode) {
+        this.pasteBuffer.push(Bun.stripANSI(data));
+        if (data.endsWith(ANSI.bracketedPasteEnd)) {
+          this.pasteMode = false;
+          this.emit("paste", this.pasteBuffer.join(""));
+          this.pasteBuffer = [];
+        }
+        return;
+      }
+      const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
+      switch (parsedKey.eventType) {
+        case "press":
+          this.emit("keypress", parsedKey);
+          break;
+        case "repeat":
+          this.emit("keyrepeat", parsedKey);
+          break;
+        case "release":
+          this.emit("keyrelease", parsedKey);
+          break;
+        default:
+          this.emit("keypress", parsedKey);
+          break;
+      }
+    };
+    this.stdin.on("data", this.listener);
   }
   destroy() {
-    process.stdin.removeAllListeners("data");
-  }
-}
-var keyHandler = null;
-function getKeyHandler() {
-  if (!keyHandler) {
-    keyHandler = singleton("KeyHandler", () => new KeyHandler);
+    this.stdin.removeListener("data", this.listener);
   }
-  return keyHandler;
 }
 
 // src/lib/RGBA.ts
@@ -3936,6 +4054,31 @@ function createTextAttributes({
     attributes |= TextAttributes.STRIKETHROUGH;
   return attributes;
 }
+function visualizeRenderableTree(renderable, maxDepth = 10) {
+  function buildTreeLines(node, prefix = "", parentPrefix = "", isLastChild = true, depth = 0) {
+    if (depth >= maxDepth) {
+      return [`${prefix}${node.id} ... (max depth reached)`];
+    }
+    const lines = [];
+    const children = node.getChildren();
+    lines.push(`${prefix}${node.id}`);
+    if (children.length > 0) {
+      const lastChildIndex = children.length - 1;
+      children.forEach((child, index) => {
+        const childIsLast = index === lastChildIndex;
+        const connector = childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const childPrefix = parentPrefix + (isLastChild ? "    " : "\u2502   ");
+        const childLines = buildTreeLines(child, childPrefix + connector, childPrefix, childIsLast, depth + 1);
+        lines.push(...childLines);
+      });
+    }
+    return lines;
+  }
+  const treeLines = buildTreeLines(renderable);
+  console.log(`Renderable Tree:
+` + treeLines.join(`
+`));
+}
 
 // src/lib/styled-text.ts
 var BrandedStyledText = Symbol.for("@opentui/core/StyledText");
@@ -4671,6 +4814,166 @@ class ASCIIFontSelectionHelper {
     return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
 }
+
+// src/lib/singleton.ts
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
+function singleton(key, factory) {
+  const bag = globalThis[singletonCacheSymbol] ??= {};
+  if (!(key in bag)) {
+    bag[key] = factory();
+  }
+  return bag[key];
+}
+
+// src/lib/env.ts
+var envRegistry = {};
+function registerEnvVar(config) {
+  const existing = envRegistry[config.name];
+  if (existing) {
+    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
+      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+    }
+    return;
+  }
+  envRegistry[config.name] = config;
+}
+function normalizeBoolean(value) {
+  const lowerValue = value.toLowerCase();
+  return ["true", "1", "on", "yes"].includes(lowerValue);
+}
+function parseEnvValue(config) {
+  const envValue = process.env[config.name];
+  if (envValue === undefined && config.default !== undefined) {
+    return config.default;
+  }
+  if (envValue === undefined) {
+    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  }
+  switch (config.type) {
+    case "boolean":
+      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
+    case "number":
+      const numValue = Number(envValue);
+      if (isNaN(numValue)) {
+        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+      }
+      return numValue;
+    case "string":
+    default:
+      return envValue;
+  }
+}
+
+class EnvStore {
+  parsedValues = new Map;
+  get(key) {
+    if (this.parsedValues.has(key)) {
+      return this.parsedValues.get(key);
+    }
+    if (!(key in envRegistry)) {
+      throw new Error(`Environment variable ${key} is not registered.`);
+    }
+    try {
+      const value = parseEnvValue(envRegistry[key]);
+      this.parsedValues.set(key, value);
+      return value;
+    } catch (error) {
+      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  has(key) {
+    return key in envRegistry;
+  }
+}
+var envStore = singleton("env-store", () => new EnvStore);
+function generateEnvMarkdown() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `# Environment Variables
+
+No environment variables registered.
+`;
+  }
+  let markdown = `# Environment Variables
+
+`;
+  for (const config of configs) {
+    markdown += `## ${config.name}
+
+`;
+    markdown += `${config.description}
+
+`;
+    markdown += `**Type:** \`${config.type || "string"}\`  
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      markdown += `**Default:** \`${defaultValue}\`  
+`;
+    } else {
+      markdown += `**Default:** *Required*  
+`;
+    }
+    markdown += `
+`;
+  }
+  return markdown;
+}
+function generateEnvColored() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `\x1B[1;36mEnvironment Variables\x1B[0m
+
+No environment variables registered.
+`;
+  }
+  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
+
+`;
+  for (const config of configs) {
+    output += `\x1B[1;33m${config.name}\x1B[0m
+`;
+    output += `${config.description}
+`;
+    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
+`;
+    } else {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+var env = new Proxy({}, {
+  get(target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return envStore.get(prop);
+  },
+  has(target, prop) {
+    return envStore.has(prop);
+  },
+  ownKeys() {
+    return Object.keys(envRegistry);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    if (envStore.has(prop)) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => envStore.get(prop)
+      };
+    }
+    return;
+  }
+});
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
 import { existsSync } from "fs";
@@ -4713,10 +5016,16 @@ class OptimizedBuffer {
   _height;
   respectAlpha = false;
   _rawBuffers = null;
+  _destroyed = false;
   get ptr() {
     return this.bufferPtr;
   }
+  guard() {
+    if (this._destroyed)
+      throw new Error(`Buffer ${this.id} is destroyed`);
+  }
   get buffers() {
+    this.guard();
     if (this._rawBuffers === null) {
       const size = this._width * this._height;
       const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
@@ -4746,9 +5055,6 @@ class OptimizedBuffer {
     const id = options.id && options.id.trim() !== "" ? options.id : "unnamed buffer";
     return lib.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
   }
-  coordsToIndex(x, y) {
-    return y * this._width + x;
-  }
   get width() {
     return this._width;
   }
@@ -4756,22 +5062,35 @@ class OptimizedBuffer {
     return this._height;
   }
   setRespectAlpha(respectAlpha) {
+    this.guard();
     this.lib.bufferSetRespectAlpha(this.bufferPtr, respectAlpha);
     this.respectAlpha = respectAlpha;
   }
   getNativeId() {
+    this.guard();
     return this.lib.bufferGetId(this.bufferPtr);
   }
+  getRealCharBytes(addLineBreaks = false) {
+    this.guard();
+    const realSize = this.lib.bufferGetRealCharSize(this.bufferPtr);
+    const outputBuffer = new Uint8Array(realSize);
+    const bytesWritten = this.lib.bufferWriteResolvedChars(this.bufferPtr, outputBuffer, addLineBreaks);
+    return outputBuffer.slice(0, bytesWritten);
+  }
   clear(bg2 = RGBA.fromValues(0, 0, 0, 1)) {
+    this.guard();
     this.lib.bufferClear(this.bufferPtr, bg2);
   }
   setCell(x, y, char, fg2, bg2, attributes = 0) {
+    this.guard();
     this.lib.bufferSetCell(this.bufferPtr, x, y, char, fg2, bg2, attributes);
   }
   setCellWithAlphaBlending(x, y, char, fg2, bg2, attributes = 0) {
+    this.guard();
     this.lib.bufferSetCellWithAlphaBlending(this.bufferPtr, x, y, char, fg2, bg2, attributes);
   }
   drawText(text, x, y, fg2, bg2, attributes = 0, selection2) {
+    this.guard();
     if (!selection2) {
       this.lib.bufferDrawText(this.bufferPtr, text, x, y, fg2, bg2, attributes);
       return;
@@ -4804,21 +5123,29 @@ class OptimizedBuffer {
     this.lib.bufferFillRect(this.bufferPtr, x, y, width, height, bg2);
   }
   drawFrameBuffer(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
+    this.guard();
     this.lib.drawFrameBuffer(this.bufferPtr, destX, destY, frameBuffer.ptr, sourceX, sourceY, sourceWidth, sourceHeight);
   }
   destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
     this.lib.destroyOptimizedBuffer(this.bufferPtr);
   }
   drawTextBuffer(textBuffer, x, y, clipRect) {
+    this.guard();
     this.lib.bufferDrawTextBuffer(this.bufferPtr, textBuffer.ptr, x, y, clipRect);
   }
   drawSuperSampleBuffer(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
+    this.guard();
     this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow);
   }
   drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
+    this.guard();
     this.lib.bufferDrawPackedBuffer(this.bufferPtr, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
   resize(width, height) {
+    this.guard();
     if (this._width === width && this._height === height)
       return;
     this._width = width;
@@ -4827,18 +5154,22 @@ class OptimizedBuffer {
     this.lib.bufferResize(this.bufferPtr, width, height);
   }
   drawBox(options) {
+    this.guard();
     const style = options.borderStyle || "single";
     const borderChars = options.customBorderChars ?? BorderCharArrays[style];
     const packedOptions = packDrawOptions(options.border, options.shouldFill ?? false, options.titleAlignment || "left");
     this.lib.bufferDrawBox(this.bufferPtr, options.x, options.y, options.width, options.height, borderChars, packedOptions, options.borderColor, options.backgroundColor, options.title ?? null);
   }
   pushScissorRect(x, y, width, height) {
+    this.guard();
     this.lib.bufferPushScissorRect(this.bufferPtr, x, y, width, height);
   }
   popScissorRect() {
+    this.guard();
     this.lib.bufferPopScissorRect(this.bufferPtr);
   }
   clearScissorRects() {
+    this.guard();
     this.lib.bufferClearScissorRects(this.bufferPtr);
   }
 }
@@ -4849,19 +5180,31 @@ var targetLibPath = module.default;
 if (!existsSync(targetLibPath)) {
   throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
 }
+registerEnvVar({
+  name: "OTUI_DEBUG_FFI",
+  description: "Enable debug logging for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_TRACE_FFI",
+  description: "Enable tracing for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
-  return dlopen(resolvedLibPath, {
+  const rawSymbols = dlopen(resolvedLibPath, {
     setLogCallback: {
       args: ["ptr"],
       returns: "void"
     },
     createRenderer: {
-      args: ["u32", "u32"],
+      args: ["u32", "u32", "bool"],
       returns: "ptr"
     },
     destroyRenderer: {
-      args: ["ptr", "bool", "u32"],
+      args: ["ptr"],
       returns: "void"
     },
     setUseThread: {
@@ -4896,6 +5239,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
+    queryPixelResolution: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createOptimizedBuffer: {
       args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
       returns: "ptr"
@@ -4948,6 +5295,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
+    bufferGetRealCharSize: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferWriteResolvedChars: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "u32"
+    },
     bufferDrawText: {
       args: ["ptr", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
       returns: "void"
@@ -5061,25 +5416,17 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     createTextBuffer: {
-      args: ["u32", "u8"],
+      args: ["u8"],
       returns: "ptr"
     },
     destroyTextBuffer: {
       args: ["ptr"],
       returns: "void"
     },
-    textBufferGetCharPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
     textBufferGetLength: {
       args: ["ptr"],
       returns: "u32"
     },
-    textBufferResize: {
-      args: ["ptr", "u32"],
-      returns: "void"
-    },
     textBufferReset: {
       args: ["ptr"],
       returns: "void"
@@ -5112,10 +5459,6 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr", "u32", "ptr", "ptr", "ptr"],
       returns: "u32"
     },
-    textBufferGetCapacity: {
-      args: ["ptr"],
-      returns: "u32"
-    },
     textBufferFinalizeLineInfo: {
       args: ["ptr"],
       returns: "void"
@@ -5126,7 +5469,7 @@ function getOpenTUILib(libPath) {
     },
     textBufferGetLineInfoDirect: {
       args: ["ptr", "ptr", "ptr"],
-      returns: "void"
+      returns: "u32"
     },
     textBufferGetSelectionInfo: {
       args: ["ptr"],
@@ -5164,6 +5507,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "usize"
     },
+    textBufferSetWrapWidth: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferSetWrapMode: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
     getArenaAllocatedBytes: {
       args: [],
       returns: "usize"
@@ -5181,6 +5532,115 @@ function getOpenTUILib(libPath) {
       returns: "void"
     }
   });
+  if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
+    return {
+      symbols: convertToDebugSymbols(rawSymbols.symbols)
+    };
+  }
+  return rawSymbols;
+}
+function convertToDebugSymbols(symbols) {
+  const debugSymbols = {};
+  const traceSymbols = {};
+  let hasTracing = false;
+  Object.entries(symbols).forEach(([key, value]) => {
+    debugSymbols[key] = value;
+  });
+  if (env.OTUI_DEBUG_FFI) {
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        debugSymbols[key] = (...args) => {
+          console.log(`${key}(${args.map((arg) => String(arg)).join(", ")})`);
+          const result = value(...args);
+          console.log(`${key} returned:`, String(result));
+          return result;
+        };
+      }
+    });
+  }
+  if (env.OTUI_TRACE_FFI) {
+    hasTracing = true;
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        traceSymbols[key] = [];
+        const originalFunc = debugSymbols[key];
+        debugSymbols[key] = (...args) => {
+          const start = performance.now();
+          const result = originalFunc(...args);
+          const end = performance.now();
+          traceSymbols[key].push(end - start);
+          return result;
+        };
+      }
+    });
+  }
+  if (hasTracing) {
+    process.on("exit", () => {
+      const allStats = [];
+      for (const [key, timings] of Object.entries(traceSymbols)) {
+        if (!Array.isArray(timings) || timings.length === 0) {
+          continue;
+        }
+        const sortedTimings = [...timings].sort((a, b) => a - b);
+        const count = sortedTimings.length;
+        const total = sortedTimings.reduce((acc, t2) => acc + t2, 0);
+        const average = total / count;
+        const min = sortedTimings[0];
+        const max = sortedTimings[count - 1];
+        const medianIndex = Math.floor(count / 2);
+        const p90Index = Math.floor(count * 0.9);
+        const p99Index = Math.floor(count * 0.99);
+        const median = sortedTimings[medianIndex];
+        const p90 = sortedTimings[Math.min(p90Index, count - 1)];
+        const p99 = sortedTimings[Math.min(p99Index, count - 1)];
+        allStats.push({
+          name: key,
+          count,
+          total,
+          average,
+          min,
+          max,
+          median,
+          p90,
+          p99
+        });
+      }
+      allStats.sort((a, b) => b.total - a.total);
+      console.log(`
+--- OpenTUI FFI Call Performance ---`);
+      console.log("Sorted by total time spent (descending)");
+      console.log("-------------------------------------------------------------------------------------------------------------------------");
+      if (allStats.length === 0) {
+        console.log("No trace data collected or all symbols had zero calls.");
+      } else {
+        const nameHeader = "Symbol";
+        const callsHeader = "Calls";
+        const totalHeader = "Total (ms)";
+        const avgHeader = "Avg (ms)";
+        const minHeader = "Min (ms)";
+        const maxHeader = "Max (ms)";
+        const medHeader = "Med (ms)";
+        const p90Header = "P90 (ms)";
+        const p99Header = "P99 (ms)";
+        const nameWidth = Math.max(nameHeader.length, ...allStats.map((s) => s.name.length));
+        const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
+        const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
+        const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
+        const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
+        const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
+        const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
+        const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
+        const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
+        console.log(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
+        console.log(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
+        allStats.forEach((stat) => {
+          console.log(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
+        });
+      }
+      console.log("-------------------------------------------------------------------------------------------------------------------------");
+    });
+  }
+  return debugSymbols;
 }
 var LogLevel2;
 ((LogLevel3) => {
@@ -5244,11 +5704,11 @@ class FFIRenderLib {
   setLogCallback(callbackPtr) {
     this.opentui.symbols.setLogCallback(callbackPtr);
   }
-  createRenderer(width, height) {
-    return this.opentui.symbols.createRenderer(width, height);
+  createRenderer(width, height, options = { testing: false }) {
+    return this.opentui.symbols.createRenderer(width, height, options.testing);
   }
-  destroyRenderer(renderer, useAlternateScreen, splitHeight) {
-    this.opentui.symbols.destroyRenderer(renderer, useAlternateScreen, splitHeight);
+  destroyRenderer(renderer) {
+    this.opentui.symbols.destroyRenderer(renderer);
   }
   setUseThread(renderer, useThread) {
     this.opentui.symbols.setUseThread(renderer, useThread);
@@ -5324,6 +5784,13 @@ class FFIRenderLib {
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     return this.decoder.decode(outBuffer.slice(0, len));
   }
+  bufferGetRealCharSize(buffer) {
+    return this.opentui.symbols.bufferGetRealCharSize(buffer);
+  }
+  bufferWriteResolvedChars(buffer, outputBuffer, addLineBreaks) {
+    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(buffer, outputBuffer, outputBuffer.length, addLineBreaks);
+    return typeof bytesWritten === "bigint" ? Number(bytesWritten) : bytesWritten;
+  }
   getBufferWidth(buffer) {
     return this.opentui.symbols.getBufferWidth(buffer);
   }
@@ -5453,30 +5920,23 @@ class FFIRenderLib {
   setupTerminal(renderer, useAlternateScreen) {
     this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
   }
-  createTextBuffer(capacity, widthMethod) {
+  queryPixelResolution(renderer) {
+    this.opentui.symbols.queryPixelResolution(renderer);
+  }
+  createTextBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
-    const bufferPtr = this.opentui.symbols.createTextBuffer(capacity, widthMethodCode);
+    const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
     if (!bufferPtr) {
-      throw new Error(`Failed to create TextBuffer with capacity ${capacity}`);
+      throw new Error(`Failed to create TextBuffer`);
     }
-    return new TextBuffer(this, bufferPtr, capacity);
+    return new TextBuffer(this, bufferPtr);
   }
   destroyTextBuffer(buffer) {
     this.opentui.symbols.destroyTextBuffer(buffer);
   }
-  textBufferGetCharPtr(buffer) {
-    const ptr2 = this.opentui.symbols.textBufferGetCharPtr(buffer);
-    if (!ptr2) {
-      throw new Error("Failed to get TextBuffer char pointer");
-    }
-    return ptr2;
-  }
   textBufferGetLength(buffer) {
     return this.opentui.symbols.textBufferGetLength(buffer);
   }
-  textBufferResize(buffer, newLength) {
-    this.opentui.symbols.textBufferResize(buffer, newLength);
-  }
   textBufferReset(buffer) {
     this.opentui.symbols.textBufferReset(buffer);
   }
@@ -5507,9 +5967,6 @@ class FFIRenderLib {
     const attrValue = attributes === null ? null : new Uint8Array([attributes]);
     return this.opentui.symbols.textBufferWriteChunk(buffer, textBytes, textBytes.length, fg2 ? fg2.buffer : null, bg2 ? bg2.buffer : null, attrValue);
   }
-  textBufferGetCapacity(buffer) {
-    return this.opentui.symbols.textBufferGetCapacity(buffer);
-  }
   textBufferFinalizeLineInfo(buffer) {
     this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
   }
@@ -5517,7 +5974,7 @@ class FFIRenderLib {
     return this.opentui.symbols.textBufferGetLineCount(buffer);
   }
   textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr) {
-    this.opentui.symbols.textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr);
+    return this.opentui.symbols.textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr);
   }
   textBufferGetSelection(buffer) {
     const packedInfo = this.textBufferGetSelectionInfo(buffer);
@@ -5582,6 +6039,13 @@ class FFIRenderLib {
     const result = this.opentui.symbols.textBufferGetChunkGroupCount(buffer);
     return typeof result === "bigint" ? Number(result) : result;
   }
+  textBufferSetWrapWidth(buffer, width) {
+    this.opentui.symbols.textBufferSetWrapWidth(buffer, width);
+  }
+  textBufferSetWrapMode(buffer, mode) {
+    const modeValue = mode === "char" ? 0 : 1;
+    this.opentui.symbols.textBufferSetWrapMode(buffer, modeValue);
+  }
   getArenaAllocatedBytes() {
     const result = this.opentui.symbols.getArenaAllocatedBytes();
     return typeof result === "bigint" ? Number(result) : result;
@@ -5589,12 +6053,13 @@ class FFIRenderLib {
   textBufferGetLineInfo(buffer) {
     const lineCount = this.textBufferGetLineCount(buffer);
     if (lineCount === 0) {
-      return { lineStarts: [], lineWidths: [] };
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
     }
     const lineStarts = new Uint32Array(lineCount);
     const lineWidths = new Uint32Array(lineCount);
-    this.textBufferGetLineInfoDirect(buffer, ptr(lineStarts), ptr(lineWidths));
+    const maxLineWidth = this.textBufferGetLineInfoDirect(buffer, ptr(lineStarts), ptr(lineWidths));
     return {
+      maxLineWidth,
       lineStarts: Array.from(lineStarts),
       lineWidths: Array.from(lineWidths)
     };
@@ -5669,53 +6134,58 @@ class TextBuffer {
   lib;
   bufferPtr;
   _length = 0;
-  _capacity;
   _lineInfo;
-  constructor(lib, ptr2, capacity) {
+  _destroyed = false;
+  constructor(lib, ptr2) {
     this.lib = lib;
     this.bufferPtr = ptr2;
-    this._capacity = capacity;
   }
-  static create(capacity = 256, widthMethod) {
+  static create(widthMethod) {
     const lib = resolveRenderLib();
-    return lib.createTextBuffer(capacity, widthMethod);
+    return lib.createTextBuffer(widthMethod);
+  }
+  guard() {
+    if (this._destroyed)
+      throw new Error("TextBuffer is destroyed");
   }
   setStyledText(text) {
+    this.guard();
     this.lib.textBufferReset(this.bufferPtr);
     this._length = 0;
     this._lineInfo = undefined;
     for (const chunk of text.chunks) {
       const textBytes = this.lib.encoder.encode(chunk.text);
-      const result = this.lib.textBufferWriteChunk(this.bufferPtr, textBytes, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
-      if (result & 1) {
-        this._capacity = this.lib.textBufferGetCapacity(this.bufferPtr);
-      }
+      this.lib.textBufferWriteChunk(this.bufferPtr, textBytes, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
     }
     this.lib.textBufferFinalizeLineInfo(this.bufferPtr);
     this._length = this.lib.textBufferGetLength(this.bufferPtr);
   }
   setDefaultFg(fg2) {
+    this.guard();
     this.lib.textBufferSetDefaultFg(this.bufferPtr, fg2);
   }
   setDefaultBg(bg2) {
+    this.guard();
     this.lib.textBufferSetDefaultBg(this.bufferPtr, bg2);
   }
   setDefaultAttributes(attributes) {
+    this.guard();
     this.lib.textBufferSetDefaultAttributes(this.bufferPtr, attributes);
   }
   resetDefaults() {
+    this.guard();
     this.lib.textBufferResetDefaults(this.bufferPtr);
   }
   get length() {
+    this.guard();
     return this._length;
   }
-  get capacity() {
-    return this._capacity;
-  }
   get ptr() {
+    this.guard();
     return this.bufferPtr;
   }
   getSelectedText() {
+    this.guard();
     if (this._length === 0)
       return "";
     const selectedBytes = this.lib.getSelectedTextBytes(this.bufferPtr, this.length * 4);
@@ -5724,6 +6194,7 @@ class TextBuffer {
     return this.lib.decoder.decode(selectedBytes);
   }
   getPlainText() {
+    this.guard();
     if (this._length === 0)
       return "";
     const plainBytes = this.lib.getPlainTextBytes(this.bufferPtr, this.length * 4);
@@ -5732,72 +6203,87 @@ class TextBuffer {
     return this.lib.decoder.decode(plainBytes);
   }
   get lineInfo() {
+    this.guard();
     if (!this._lineInfo) {
       this._lineInfo = this.lib.textBufferGetLineInfo(this.bufferPtr);
     }
     return this._lineInfo;
   }
   setSelection(start, end, bgColor, fgColor) {
+    this.guard();
     this.lib.textBufferSetSelection(this.bufferPtr, start, end, bgColor || null, fgColor || null);
   }
   resetSelection() {
+    this.guard();
     this.lib.textBufferResetSelection(this.bufferPtr);
   }
   setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    this.guard();
     return this.lib.textBufferSetLocalSelection(this.bufferPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
   }
   resetLocalSelection() {
+    this.guard();
     this.lib.textBufferResetLocalSelection(this.bufferPtr);
   }
   getSelection() {
+    this.guard();
     return this.lib.textBufferGetSelection(this.bufferPtr);
   }
   hasSelection() {
+    this.guard();
     return this.getSelection() !== null;
   }
   insertChunkGroup(index, text, fg2, bg2, attributes) {
+    this.guard();
     const textBytes = this.lib.encoder.encode(text);
     this.insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes);
   }
   insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes) {
+    this.guard();
     this._length = this.lib.textBufferInsertChunkGroup(this.bufferPtr, index, textBytes, fg2 || null, bg2 || null, attributes ?? null);
     this._lineInfo = undefined;
   }
   removeChunkGroup(index) {
+    this.guard();
     this._length = this.lib.textBufferRemoveChunkGroup(this.bufferPtr, index);
     this._lineInfo = undefined;
   }
   replaceChunkGroup(index, text, fg2, bg2, attributes) {
+    this.guard();
     const textBytes = this.lib.encoder.encode(text);
     this.replaceEncodedChunkGroup(index, textBytes, fg2, bg2, attributes);
   }
   replaceEncodedChunkGroup(index, textBytes, fg2, bg2, attributes) {
+    this.guard();
     this._length = this.lib.textBufferReplaceChunkGroup(this.bufferPtr, index, textBytes, fg2 || null, bg2 || null, attributes ?? null);
     this._lineInfo = undefined;
   }
   get chunkGroupCount() {
+    this.guard();
     return this.lib.textBufferGetChunkGroupCount(this.bufferPtr);
   }
+  setWrapWidth(width) {
+    this.guard();
+    this.lib.textBufferSetWrapWidth(this.bufferPtr, width ?? 0);
+    this._lineInfo = undefined;
+  }
+  setWrapMode(mode) {
+    this.guard();
+    this.lib.textBufferSetWrapMode(this.bufferPtr, mode);
+    this._lineInfo = undefined;
+  }
   destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
     this.lib.destroyTextBuffer(this.bufferPtr);
   }
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter3 } from "events";
-var BrandedRenderable = Symbol.for("@opentui/core/Renderable");
-var LayoutEvents;
-((LayoutEvents2) => {
-  LayoutEvents2["LAYOUT_CHANGED"] = "layout-changed";
-  LayoutEvents2["ADDED"] = "added";
-  LayoutEvents2["REMOVED"] = "removed";
-  LayoutEvents2["RESIZED"] = "resized";
-})(LayoutEvents ||= {});
-var RenderableEvents;
-((RenderableEvents2) => {
-  RenderableEvents2["FOCUSED"] = "focused";
-  RenderableEvents2["BLURRED"] = "blurred";
-})(RenderableEvents ||= {});
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/lib/renderable.validations.ts
 function validateOptions(id, options) {
   if (typeof options.width === "number") {
     if (options.width < 0) {
@@ -5869,20 +6355,43 @@ function isSizeType(value) {
   }
   return isValidPercentage(value);
 }
+
+// src/Renderable.ts
+var BrandedRenderable = Symbol.for("@opentui/core/Renderable");
+var LayoutEvents;
+((LayoutEvents2) => {
+  LayoutEvents2["LAYOUT_CHANGED"] = "layout-changed";
+  LayoutEvents2["ADDED"] = "added";
+  LayoutEvents2["REMOVED"] = "removed";
+  LayoutEvents2["RESIZED"] = "resized";
+})(LayoutEvents ||= {});
+var RenderableEvents;
+((RenderableEvents2) => {
+  RenderableEvents2["FOCUSED"] = "focused";
+  RenderableEvents2["BLURRED"] = "blurred";
+})(RenderableEvents ||= {});
 function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter3 {
+class BaseRenderable extends EventEmitter2 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
-  id;
+  _id;
   num;
   _dirty = false;
+  parent = null;
+  _visible = true;
   constructor(options) {
     super();
     this.num = BaseRenderable.renderableNumber++;
-    this.id = options.id ?? `renderable-${this.num}`;
+    this._id = options.id ?? `renderable-${this.num}`;
+  }
+  get id() {
+    return this._id;
+  }
+  set id(value) {
+    this._id = value;
   }
   get isDirty() {
     return this._dirty;
@@ -5893,7 +6402,18 @@ class BaseRenderable extends EventEmitter3 {
   markDirty() {
     this._dirty = true;
   }
+  destroy() {}
+  destroyRecursively() {}
+  get visible() {
+    return this._visible;
+  }
+  set visible(value) {
+    this._visible = value;
+  }
 }
+var yogaConfig = src_default.Config.create();
+yogaConfig.setUseWebDefaults(false);
+yogaConfig.setPointScaleFactor(1);
 
 class Renderable extends BaseRenderable {
   static renderablesByNumber = new Map;
@@ -5908,31 +6428,33 @@ class Renderable extends BaseRenderable {
   _widthValue = 0;
   _heightValue = 0;
   _zIndex;
-  _visible;
   selectable = false;
   buffered;
   frameBuffer = null;
   _focusable = false;
   _focused = false;
-  keyHandler = getKeyHandler();
   keypressHandler = null;
+  pasteHandler = null;
   _live = false;
   _liveCount = 0;
   _sizeChangeListener = undefined;
   _mouseListener = null;
   _mouseListeners = {};
+  _pasteListener = undefined;
   _keyListeners = {};
-  layoutNode;
+  yogaNode;
   _positionType = "relative";
   _overflow = "visible";
   _position = {};
-  renderableMap = new Map;
-  renderableArray = [];
+  renderableMapById = new Map;
+  _childrenInLayoutOrder = [];
+  _childrenInZIndexOrder = [];
   needsZIndexSort = false;
   parent = null;
   childrenPrimarySortDirty = true;
   childrenSortedByPrimaryAxis = [];
   _newChildren = [];
+  onLifecyclePass = null;
   renderBefore;
   renderAfter;
   constructor(ctx, options) {
@@ -5955,14 +6477,24 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
-    this.layoutNode = createTrackedNode({ renderable: this });
-    this.layoutNode.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
+    this.yogaNode = src_default.Node.create(yogaConfig);
+    this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
     this.setupYogaProperties(options);
     this.applyEventOptions(options);
     if (this.buffered) {
       this.createFrameBuffer();
     }
   }
+  get id() {
+    return this._id;
+  }
+  set id(value) {
+    if (this.parent) {
+      this.parent.renderableMapById.delete(this.id);
+      this.parent.renderableMapById.set(value, this);
+    }
+    super.id = value;
+  }
   get focusable() {
     return this._focusable;
   }
@@ -5973,7 +6505,7 @@ class Renderable extends BaseRenderable {
     return this._visible;
   }
   get primaryAxis() {
-    const dir = this.layoutNode.yogaNode.getFlexDirection();
+    const dir = this.yogaNode.getFlexDirection();
     return dir === 2 || dir === 3 ? "row" : "column";
   }
   set visible(value) {
@@ -5981,7 +6513,7 @@ class Renderable extends BaseRenderable {
       return;
     const wasVisible = this._visible;
     this._visible = value;
-    this.layoutNode.yogaNode.setDisplay(value ? Display.Flex : Display.None);
+    this.yogaNode.setDisplay(value ? Display.Flex : Display.None);
     if (this._live) {
       if (!wasVisible && value) {
         this.propagateLiveCount(1);
@@ -6018,7 +6550,14 @@ class Renderable extends BaseRenderable {
         this.handleKeyPress(key);
       }
     };
-    this.keyHandler.on("keypress", this.keypressHandler);
+    this.pasteHandler = (text) => {
+      this._pasteListener?.call(this, text);
+      if (this.handlePaste) {
+        this.handlePaste(text);
+      }
+    };
+    this.ctx.keyInput.on("keypress", this.keypressHandler);
+    this.ctx.keyInput.on("paste", this.pasteHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
@@ -6027,9 +6566,13 @@ class Renderable extends BaseRenderable {
     this._focused = false;
     this.requestRender();
     if (this.keypressHandler) {
-      this.keyHandler.off("keypress", this.keypressHandler);
+      this.ctx.keyInput.off("keypress", this.keypressHandler);
       this.keypressHandler = null;
     }
+    if (this.pasteHandler) {
+      this.ctx.keyInput.off("paste", this.pasteHandler);
+      this.pasteHandler = null;
+    }
     this.emit("blurred" /* BLURRED */);
   }
   get focused() {
@@ -6055,12 +6598,14 @@ class Renderable extends BaseRenderable {
     this.parent?.propagateLiveCount(delta);
   }
   findDescendantById(id) {
-    for (const child of this.renderableArray) {
+    for (const child of this._childrenInLayoutOrder) {
       if (child.id === id)
         return child;
-      const found = child.findDescendantById(id);
-      if (found)
-        return found;
+      if (isRenderable(child)) {
+        const found = child.findDescendantById(id);
+        if (found)
+          return found;
+      }
     }
     return;
   }
@@ -6146,7 +6691,7 @@ class Renderable extends BaseRenderable {
   set width(value) {
     if (isDimensionType(value)) {
       this._width = value;
-      this.layoutNode.setWidth(value);
+      this.yogaNode.setWidth(value);
       this.requestRender();
     }
   }
@@ -6156,7 +6701,7 @@ class Renderable extends BaseRenderable {
   set height(value) {
     if (isDimensionType(value)) {
       this._height = value;
-      this.layoutNode.setHeight(value);
+      this.yogaNode.setHeight(value);
       this.requestRender();
     }
   }
@@ -6174,17 +6719,17 @@ class Renderable extends BaseRenderable {
   }
   ensureZIndexSorted() {
     if (this.needsZIndexSort) {
-      this.renderableArray.sort((a, b) => a.zIndex > b.zIndex ? 1 : a.zIndex < b.zIndex ? -1 : 0);
+      this._childrenInZIndexOrder.sort((a, b) => a.zIndex > b.zIndex ? 1 : a.zIndex < b.zIndex ? -1 : 0);
       this.needsZIndexSort = false;
     }
   }
   getChildrenSortedByPrimaryAxis() {
-    if (!this.childrenPrimarySortDirty && this.childrenSortedByPrimaryAxis.length === this.renderableArray.length) {
+    if (!this.childrenPrimarySortDirty && this.childrenSortedByPrimaryAxis.length === this._childrenInLayoutOrder.length) {
       return this.childrenSortedByPrimaryAxis;
     }
-    const dir = this.layoutNode.yogaNode.getFlexDirection();
+    const dir = this.yogaNode.getFlexDirection();
     const axis = dir === 2 || dir === 3 ? "x" : "y";
-    const sorted = [...this.renderableArray];
+    const sorted = [...this._childrenInLayoutOrder];
     sorted.sort((a, b) => {
       const va = axis === "y" ? a.y : a.x;
       const vb = axis === "y" ? b.y : b.x;
@@ -6195,7 +6740,7 @@ class Renderable extends BaseRenderable {
     return this.childrenSortedByPrimaryAxis;
   }
   setupYogaProperties(options) {
-    const node = this.layoutNode.yogaNode;
+    const node = this.yogaNode;
     if (isFlexBasisType(options.flexBasis)) {
       node.setFlexBasis(options.flexBasis);
     }
@@ -6213,8 +6758,7 @@ class Renderable extends BaseRenderable {
     if (options.flexShrink !== undefined) {
       node.setFlexShrink(options.flexShrink);
     } else {
-      const shrinkValue = options.flexGrow && options.flexGrow > 0 ? 1 : 0;
-      node.setFlexShrink(shrinkValue);
+      node.setFlexShrink(1);
     }
     if (options.flexDirection !== undefined) {
       node.setFlexDirection(parseFlexDirection(options.flexDirection));
@@ -6233,11 +6777,11 @@ class Renderable extends BaseRenderable {
     }
     if (isDimensionType(options.width)) {
       this._width = options.width;
-      this.layoutNode.setWidth(options.width);
+      this.yogaNode.setWidth(options.width);
     }
     if (isDimensionType(options.height)) {
       this._height = options.height;
-      this.layoutNode.setHeight(options.height);
+      this.yogaNode.setHeight(options.height);
     }
     this._positionType = options.position === "absolute" ? "absolute" : "relative";
     if (this._positionType !== "relative") {
@@ -6266,7 +6810,7 @@ class Renderable extends BaseRenderable {
     this.setupMarginAndPadding(options);
   }
   setupMarginAndPadding(options) {
-    const node = this.layoutNode.yogaNode;
+    const node = this.yogaNode;
     if (isMarginType(options.margin)) {
       node.setMargin(Edge.Top, options.margin);
       node.setMargin(Edge.Right, options.margin);
@@ -6308,7 +6852,7 @@ class Renderable extends BaseRenderable {
     if (!isPositionTypeType(positionType) || this._positionType === positionType)
       return;
     this._positionType = positionType;
-    this.layoutNode.yogaNode.setPositionType(parsePositionType(positionType));
+    this.yogaNode.setPositionType(parsePositionType(positionType));
     this.requestRender();
   }
   get overflow() {
@@ -6318,7 +6862,7 @@ class Renderable extends BaseRenderable {
     if (!isOverflowType(overflow) || this._overflow === overflow)
       return;
     this._overflow = overflow;
-    this.layoutNode.yogaNode.setOverflow(parseOverflow(overflow));
+    this.yogaNode.setOverflow(parseOverflow(overflow));
     this.requestRender();
   }
   setPosition(position) {
@@ -6326,7 +6870,7 @@ class Renderable extends BaseRenderable {
     this.updateYogaPosition(position);
   }
   updateYogaPosition(position) {
-    const node = this.layoutNode.yogaNode;
+    const node = this.yogaNode;
     const { top, right, bottom, left } = position;
     if (isPositionType(top)) {
       if (top === "auto") {
@@ -6359,66 +6903,66 @@ class Renderable extends BaseRenderable {
     this.requestRender();
   }
   set flexGrow(grow) {
-    this.layoutNode.yogaNode.setFlexGrow(grow);
+    this.yogaNode.setFlexGrow(grow);
     this.requestRender();
   }
   set flexShrink(shrink) {
-    this.layoutNode.yogaNode.setFlexShrink(shrink);
+    this.yogaNode.setFlexShrink(shrink);
     this.requestRender();
   }
   set flexDirection(direction) {
-    this.layoutNode.yogaNode.setFlexDirection(parseFlexDirection(direction));
+    this.yogaNode.setFlexDirection(parseFlexDirection(direction));
     this.requestRender();
   }
   set flexWrap(wrap) {
-    this.layoutNode.yogaNode.setFlexWrap(parseWrap(wrap));
+    this.yogaNode.setFlexWrap(parseWrap(wrap));
     this.requestRender();
   }
   set alignItems(alignItems) {
-    this.layoutNode.yogaNode.setAlignItems(parseAlign(alignItems));
+    this.yogaNode.setAlignItems(parseAlign(alignItems));
     this.requestRender();
   }
   set justifyContent(justifyContent) {
-    this.layoutNode.yogaNode.setJustifyContent(parseJustify(justifyContent));
+    this.yogaNode.setJustifyContent(parseJustify(justifyContent));
     this.requestRender();
   }
   set alignSelf(alignSelf) {
-    this.layoutNode.yogaNode.setAlignSelf(parseAlign(alignSelf));
+    this.yogaNode.setAlignSelf(parseAlign(alignSelf));
     this.requestRender();
   }
   set flexBasis(basis) {
     if (isFlexBasisType(basis)) {
-      this.layoutNode.yogaNode.setFlexBasis(basis);
+      this.yogaNode.setFlexBasis(basis);
       this.requestRender();
     }
   }
   set minWidth(minWidth) {
     if (isSizeType(minWidth)) {
-      this.layoutNode.yogaNode.setMinWidth(minWidth);
+      this.yogaNode.setMinWidth(minWidth);
       this.requestRender();
     }
   }
   set maxWidth(maxWidth) {
     if (isSizeType(maxWidth)) {
-      this.layoutNode.yogaNode.setMaxWidth(maxWidth);
+      this.yogaNode.setMaxWidth(maxWidth);
       this.requestRender();
     }
   }
   set minHeight(minHeight) {
     if (isSizeType(minHeight)) {
-      this.layoutNode.yogaNode.setMinHeight(minHeight);
+      this.yogaNode.setMinHeight(minHeight);
       this.requestRender();
     }
   }
   set maxHeight(maxHeight) {
     if (isSizeType(maxHeight)) {
-      this.layoutNode.yogaNode.setMaxHeight(maxHeight);
+      this.yogaNode.setMaxHeight(maxHeight);
       this.requestRender();
     }
   }
   set margin(margin) {
     if (isMarginType(margin)) {
-      const node = this.layoutNode.yogaNode;
+      const node = this.yogaNode;
       node.setMargin(Edge.Top, margin);
       node.setMargin(Edge.Right, margin);
       node.setMargin(Edge.Bottom, margin);
@@ -6428,31 +6972,31 @@ class Renderable extends BaseRenderable {
   }
   set marginTop(margin) {
     if (isMarginType(margin)) {
-      this.layoutNode.yogaNode.setMargin(Edge.Top, margin);
+      this.yogaNode.setMargin(Edge.Top, margin);
       this.requestRender();
     }
   }
   set marginRight(margin) {
     if (isMarginType(margin)) {
-      this.layoutNode.yogaNode.setMargin(Edge.Right, margin);
+      this.yogaNode.setMargin(Edge.Right, margin);
       this.requestRender();
     }
   }
   set marginBottom(margin) {
     if (isMarginType(margin)) {
-      this.layoutNode.yogaNode.setMargin(Edge.Bottom, margin);
+      this.yogaNode.setMargin(Edge.Bottom, margin);
       this.requestRender();
     }
   }
   set marginLeft(margin) {
     if (isMarginType(margin)) {
-      this.layoutNode.yogaNode.setMargin(Edge.Left, margin);
+      this.yogaNode.setMargin(Edge.Left, margin);
       this.requestRender();
     }
   }
   set padding(padding) {
     if (isPaddingType(padding)) {
-      const node = this.layoutNode.yogaNode;
+      const node = this.yogaNode;
       node.setPadding(Edge.Top, padding);
       node.setPadding(Edge.Right, padding);
       node.setPadding(Edge.Bottom, padding);
@@ -6462,33 +7006,33 @@ class Renderable extends BaseRenderable {
   }
   set paddingTop(padding) {
     if (isPaddingType(padding)) {
-      this.layoutNode.yogaNode.setPadding(Edge.Top, padding);
+      this.yogaNode.setPadding(Edge.Top, padding);
       this.requestRender();
     }
   }
   set paddingRight(padding) {
     if (isPaddingType(padding)) {
-      this.layoutNode.yogaNode.setPadding(Edge.Right, padding);
+      this.yogaNode.setPadding(Edge.Right, padding);
       this.requestRender();
     }
   }
   set paddingBottom(padding) {
     if (isPaddingType(padding)) {
-      this.layoutNode.yogaNode.setPadding(Edge.Bottom, padding);
+      this.yogaNode.setPadding(Edge.Bottom, padding);
       this.requestRender();
     }
   }
   set paddingLeft(padding) {
     if (isPaddingType(padding)) {
-      this.layoutNode.yogaNode.setPadding(Edge.Left, padding);
+      this.yogaNode.setPadding(Edge.Left, padding);
       this.requestRender();
     }
   }
   getLayoutNode() {
-    return this.layoutNode;
+    return this.yogaNode;
   }
   updateFromLayout() {
-    const layout = this.layoutNode.yogaNode.getComputedLayout();
+    const layout = this.yogaNode.getComputedLayout();
     const oldX = this._x;
     const oldY = this._y;
     this._x = layout.left;
@@ -6564,7 +7108,7 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
-    if (this.renderableMap.has(renderable.id)) {
+    if (this.renderableMapById.has(renderable.id)) {
       console.warn(`A renderable with id ${renderable.id} already exists in ${this.id}, removing it`);
       this.remove(renderable.id);
     }
@@ -6572,16 +7116,22 @@ class Renderable extends BaseRenderable {
     const childLayoutNode = renderable.getLayoutNode();
     let insertedIndex;
     if (index !== undefined) {
-      this.renderableArray.splice(index, 0, renderable);
-      this._forceLayoutUpdateFor = this.renderableArray.slice(index);
-      insertedIndex = this.layoutNode.insertChild(childLayoutNode, index);
+      insertedIndex = Math.max(0, Math.min(index, this._childrenInLayoutOrder.length));
+      this._childrenInLayoutOrder.splice(index, 0, renderable);
+      this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(index);
+      this.yogaNode.insertChild(childLayoutNode, insertedIndex);
     } else {
-      this.renderableArray.push(renderable);
-      insertedIndex = this.layoutNode.addChild(childLayoutNode);
+      insertedIndex = this._childrenInLayoutOrder.length;
+      this._childrenInLayoutOrder.push(renderable);
+      this.yogaNode.insertChild(childLayoutNode, insertedIndex);
     }
     this.needsZIndexSort = true;
     this.childrenPrimarySortDirty = true;
-    this.renderableMap.set(renderable.id, renderable);
+    this.renderableMapById.set(renderable.id, renderable);
+    this._childrenInZIndexOrder.push(renderable);
+    if (typeof renderable.onLifecyclePass === "function") {
+      this._ctx.registerLifecyclePass(renderable);
+    }
     this._newChildren.push(renderable);
     if (renderable._liveCount > 0) {
       this.propagateLiveCount(renderable._liveCount);
@@ -6590,6 +7140,9 @@ class Renderable extends BaseRenderable {
     return insertedIndex;
   }
   insertBefore(obj, anchor) {
+    if (!anchor) {
+      return this.add(obj);
+    }
     if (!obj) {
       return -1;
     }
@@ -6597,60 +7150,91 @@ class Renderable extends BaseRenderable {
     if (!renderable) {
       return -1;
     }
-    if (!anchor) {
-      return this.add(renderable);
+    if (renderable.isDestroyed) {
+      if (true) {
+        console.warn(`Renderable with id ${renderable.id} was already destroyed, skipping insertBefore`);
+      }
+      return -1;
     }
     if (!isRenderable(anchor)) {
       throw new Error("Anchor must be a Renderable");
     }
-    if (!this.renderableMap.has(anchor.id)) {
-      throw new Error("Anchor does not exist");
+    if (anchor.isDestroyed) {
+      if (true) {
+        console.warn(`Anchor with id ${anchor.id} was already destroyed, skipping insertBefore`);
+      }
+      return -1;
     }
-    const anchorIndex = this.renderableArray.indexOf(anchor);
-    if (anchorIndex === -1) {
+    if (!this.renderableMapById.has(anchor.id)) {
       throw new Error("Anchor does not exist");
     }
-    return this.add(renderable, anchorIndex);
+    if (renderable.parent === this) {
+      this.yogaNode.removeChild(renderable.getLayoutNode());
+      this._childrenInLayoutOrder.splice(this._childrenInLayoutOrder.indexOf(renderable), 1);
+    } else if (renderable.parent) {
+      this.replaceParent(renderable);
+      this.needsZIndexSort = true;
+      this.renderableMapById.set(renderable.id, renderable);
+      if (typeof renderable.onLifecyclePass === "function") {
+        this._ctx.registerLifecyclePass(renderable);
+      }
+      if (renderable._liveCount > 0) {
+        this.propagateLiveCount(renderable._liveCount);
+      }
+    }
+    this._newChildren.push(renderable);
+    this.childrenPrimarySortDirty = true;
+    const anchorIndex = this._childrenInLayoutOrder.indexOf(anchor);
+    const insertedIndex = Math.max(0, Math.min(anchorIndex, this._childrenInLayoutOrder.length));
+    this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(insertedIndex);
+    this._childrenInLayoutOrder.splice(insertedIndex, 0, renderable);
+    this.yogaNode.insertChild(renderable.getLayoutNode(), insertedIndex);
+    return insertedIndex;
   }
   getRenderable(id) {
-    return this.renderableMap.get(id);
+    return this.renderableMapById.get(id);
   }
   remove(id) {
     if (!id) {
       return;
     }
-    if (this.renderableMap.has(id)) {
-      const obj = this.renderableMap.get(id);
+    if (this.renderableMapById.has(id)) {
+      const obj = this.renderableMapById.get(id);
       if (obj) {
         if (obj._liveCount > 0) {
           this.propagateLiveCount(-obj._liveCount);
         }
         const childLayoutNode = obj.getLayoutNode();
-        this.layoutNode.removeChild(childLayoutNode);
+        this.yogaNode.removeChild(childLayoutNode);
         this.requestRender();
         obj.onRemove();
         obj.parent = null;
+        this._ctx.unregisterLifecyclePass(obj);
+        this.renderableMapById.delete(id);
+        const index = this._childrenInLayoutOrder.findIndex((obj2) => obj2.id === id);
+        if (index !== -1) {
+          this._childrenInLayoutOrder.splice(index, 1);
+        }
+        const zIndexIndex = this._childrenInZIndexOrder.findIndex((obj2) => obj2.id === id);
+        if (zIndexIndex !== -1) {
+          this._childrenInZIndexOrder.splice(zIndexIndex, 1);
+        }
+        this.childrenPrimarySortDirty = true;
       }
-      this.renderableMap.delete(id);
-      const index = this.renderableArray.findIndex((obj2) => obj2.id === id);
-      if (index !== -1) {
-        this.renderableArray.splice(index, 1);
-      }
-      this.childrenPrimarySortDirty = true;
     }
   }
   onRemove() {}
   getChildren() {
-    return [...this.renderableArray];
+    return [...this._childrenInLayoutOrder];
   }
   getChildrenCount() {
-    return this.renderableArray.length;
+    return this._childrenInLayoutOrder.length;
   }
   updateLayout(deltaTime, renderList = []) {
     if (!this.visible)
       return;
-    this.updateFromLayout();
     this.onUpdate(deltaTime);
+    this.updateFromLayout();
     renderList.push({ action: "render", renderable: this });
     if (this._newChildren.length > 0) {
       for (const child of this._newChildren) {
@@ -6702,7 +7286,7 @@ class Renderable extends BaseRenderable {
     }
   }
   _getChildren() {
-    return this.renderableArray;
+    return this._childrenInZIndexOrder;
   }
   onUpdate(deltaTime) {}
   getScissorRect() {
@@ -6729,19 +7313,21 @@ class Renderable extends BaseRenderable {
       this.frameBuffer.destroy();
       this.frameBuffer = null;
     }
-    for (const child of this.renderableArray) {
+    for (const child of this._childrenInLayoutOrder) {
       this.remove(child.id);
     }
-    this.renderableArray = [];
-    this.renderableMap.clear();
+    this._childrenInLayoutOrder = [];
+    this.renderableMapById.clear();
     Renderable.renderablesByNumber.delete(this.num);
     this.blur();
     this.removeAllListeners();
     this.destroySelf();
-    this.layoutNode.destroy();
+    try {
+      this.yogaNode.free();
+    } catch (e) {}
   }
   destroyRecursively() {
-    for (const child of this.renderableArray) {
+    for (const child of this._childrenInLayoutOrder) {
       child.destroyRecursively();
     }
     this.destroy();
@@ -6816,6 +7402,12 @@ class Renderable extends BaseRenderable {
     else
       delete this._mouseListeners["scroll"];
   }
+  set onPaste(handler) {
+    this._pasteListener = handler;
+  }
+  get onPaste() {
+    return this._pasteListener;
+  }
   set onKeyDown(handler) {
     if (handler)
       this._keyListeners["down"] = handler;
@@ -6842,32 +7434,32 @@ class Renderable extends BaseRenderable {
     this.onMouseOver = options.onMouseOver;
     this.onMouseOut = options.onMouseOut;
     this.onMouseScroll = options.onMouseScroll;
+    this.onPaste = options.onPaste;
     this.onKeyDown = options.onKeyDown;
     this.onSizeChange = options.onSizeChange;
   }
 }
 
 class RootRenderable extends Renderable {
-  yogaConfig;
   renderList = [];
   constructor(ctx) {
     super(ctx, { id: "__root__", zIndex: 0, visible: true, width: ctx.width, height: ctx.height, enableLayout: true });
-    this.yogaConfig = src_default.Config.create();
-    this.yogaConfig.setUseWebDefaults(false);
-    this.yogaConfig.setPointScaleFactor(1);
-    if (this.layoutNode) {
-      this.layoutNode.destroy();
-    }
-    this.layoutNode = createTrackedNode({}, this.yogaConfig);
-    this.layoutNode.setWidth(ctx.width);
-    this.layoutNode.setHeight(ctx.height);
-    this.layoutNode.yogaNode.setFlexDirection(FlexDirection.Column);
+    if (this.yogaNode) {
+      this.yogaNode.free();
+    }
+    this.yogaNode = src_default.Node.create(yogaConfig);
+    this.yogaNode.setWidth(ctx.width);
+    this.yogaNode.setHeight(ctx.height);
+    this.yogaNode.setFlexDirection(FlexDirection.Column);
     this.calculateLayout();
   }
   render(buffer, deltaTime) {
     if (!this.visible)
       return;
-    if (this.layoutNode.yogaNode.isDirty()) {
+    for (const renderable of this._ctx.getLifecyclePasses()) {
+      renderable.onLifecyclePass?.call(renderable);
+    }
+    if (this.yogaNode.isDirty()) {
       this.calculateLayout();
     }
     this.renderList.length = 0;
@@ -6897,7 +7489,7 @@ class RootRenderable extends Renderable {
     }
   }
   calculateLayout() {
-    this.layoutNode.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
+    this.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
@@ -6905,15 +7497,6 @@ class RootRenderable extends Renderable {
     this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
-  onUpdate(deltaTime) {}
-  destroySelf() {
-    if (this.layoutNode) {
-      this.layoutNode.destroy();
-    }
-    try {
-      this.yogaConfig.free();
-    } catch (error) {}
-  }
 }
 
 // src/renderables/composition/vnode.ts
@@ -7083,7 +7666,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path from "path";
@@ -7091,9 +7674,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
-class Capture extends EventEmitter4 {
+class Capture extends EventEmitter3 {
   output = [];
   constructor() {
     super();
@@ -7156,8 +7739,20 @@ function getCallerInfo() {
   return { functionName, fullPath, fileName, lineNumber, columnNumber };
 }
 var capture = singleton("ConsoleCapture", () => new Capture);
+registerEnvVar({
+  name: "OTUI_USE_CONSOLE",
+  description: "Whether to use the console. Will not capture console output if set to false.",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "SHOW_CONSOLE",
+  description: "Show the console at startup if set to true.",
+  type: "boolean",
+  default: false
+});
 
-class TerminalConsoleCache extends EventEmitter5 {
+class TerminalConsoleCache extends EventEmitter4 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -7173,7 +7768,7 @@ class TerminalConsoleCache extends EventEmitter5 {
     this.overrideConsoleMethods();
   }
   setupConsoleCapture() {
-    if (process.env.OTUI_USE_CONSOLE === "false")
+    if (!env.OTUI_USE_CONSOLE)
       return;
     const mockStdout = new CapturedWritableStream("stdout", capture);
     const mockStderr = new CapturedWritableStream("stderr", capture);
@@ -7278,7 +7873,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter5 {
+class TerminalConsole extends EventEmitter4 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -7338,7 +7933,7 @@ class TerminalConsole extends EventEmitter5 {
     terminalConsoleCache.on("entry", (logEntry) => {
       this._handleNewLog(logEntry);
     });
-    if (process.env.SHOW_CONSOLE === "true") {
+    if (env.SHOW_CONSOLE) {
       this.show();
     }
   }
@@ -7737,39 +8332,8 @@ class TerminalConsole extends EventEmitter5 {
   }
 }
 
-// src/ansi.ts
-var ANSI = {
-  switchToAlternateScreen: "\x1B[?1049h",
-  switchToMainScreen: "\x1B[?1049l",
-  reset: "\x1B[0m",
-  hideCursor: "\x1B[?25l",
-  showCursor: "\x1B[?25h",
-  resetCursorColor: "\x1B]12;default\x07",
-  saveCursorState: "\x1B[s",
-  restoreCursorState: "\x1B[u",
-  queryPixelSize: "\x1B[14t",
-  scrollDown: (lines) => `\x1B[${lines}T`,
-  scrollUp: (lines) => `\x1B[${lines}S`,
-  moveCursor: (row, col) => `\x1B[${row};${col}H`,
-  moveCursorAndClear: (row, col) => `\x1B[${row};${col}H\x1B[J`,
-  clearFromCursor: "\x1B[J",
-  setRgbBackground: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
-  resetBackground: "\x1B[49m",
-  enableMouseTracking: "\x1B[?1000h",
-  disableMouseTracking: "\x1B[?1000l",
-  enableButtonEventTracking: "\x1B[?1002h",
-  disableButtonEventTracking: "\x1B[?1002l",
-  enableAnyEventTracking: "\x1B[?1003h",
-  disableAnyEventTracking: "\x1B[?1003l",
-  enableSGRMouseMode: "\x1B[?1006h",
-  disableSGRMouseMode: "\x1B[?1006l",
-  makeRoomForRenderer: (height) => `
-`.repeat(height) + `\x1B[${height}A`,
-  clearRendererSpace: (height) => `\x1B[${height}A\x1B[1G\x1B[J`
-};
-
 // src/renderer.ts
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -7847,6 +8411,19 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
 }
 
 // src/renderer.ts
+registerEnvVar({
+  name: "OTUI_DUMP_CAPTURES",
+  description: "Dump captured output when the renderer exits.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_NO_NATIVE_RENDER",
+  description: "Disable native rendering. This will not actually output ansi and is useful for debugging.",
+  type: "boolean",
+  default: false
+});
+
 class MouseEvent {
   type;
   button;
@@ -7898,6 +8475,20 @@ singleton("ProcessExitSignals", () => {
     });
   });
 });
+var rendererTracker = singleton("RendererTracker", () => {
+  const renderers = new Set;
+  return {
+    addRenderer: (renderer) => {
+      renderers.add(renderer);
+    },
+    removeRenderer: (renderer) => {
+      renderers.delete(renderer);
+      if (renderers.size === 0) {
+        process.stdin.pause();
+      }
+    }
+  };
+});
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
     await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -7927,7 +8518,7 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
 })(CliRenderEvents ||= {});
-class CliRenderer extends EventEmitter6 {
+class CliRenderer extends EventEmitter5 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -7939,6 +8530,7 @@ class CliRenderer extends EventEmitter6 {
   currentRenderBuffer;
   _isRunning = false;
   targetFps = 30;
+  automaticMemorySnapshot = false;
   memorySnapshotInterval;
   memorySnapshotTimer = null;
   lastMemorySnapshot = {
@@ -7981,6 +8573,7 @@ class CliRenderer extends EventEmitter6 {
   };
   _console;
   _resolution = null;
+  _keyHandler;
   animationRequest = new Map;
   resizeTimeoutId = null;
   resizeDebounceDelay = 100;
@@ -8005,12 +8598,74 @@ class CliRenderer extends EventEmitter6 {
   };
   _useConsole = true;
   mouseParser = new MouseParser;
-  sigwinchHandler = null;
+  sigwinchHandler = (() => {
+    const width = this.stdout.columns || 80;
+    const height = this.stdout.rows || 24;
+    this.handleResize(width, height);
+  }).bind(this);
   _capabilities = null;
   _latestPointer = { x: 0, y: 0 };
   _currentFocusedRenderable = null;
+  lifecyclePasses = new Set;
+  handleError = ((error) => {
+    this.stop();
+    this.destroy();
+    new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, 100);
+    }).then(() => {
+      this.realStdoutWrite.call(this.stdout, `
+`.repeat(this._terminalHeight));
+      this.realStdoutWrite.call(this.stdout, `
+=== FATAL ERROR OCCURRED ===
+`);
+      this.dumpOutputCache();
+      this.realStdoutWrite.call(this.stdout, `
+Error details:
+`);
+      this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
+      this.realStdoutWrite.call(this.stdout, `
+`);
+      this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
+      this.realStdoutWrite.call(this.stdout, `
+`);
+      process.exit(1);
+    });
+  }).bind(this);
+  dumpOutputCache(optionalMessage = "") {
+    const cachedLogs = this.console.getCachedLogs();
+    const capturedOutput = capture.claimOutput();
+    if (capturedOutput.length > 0 || cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, optionalMessage);
+    }
+    if (cachedLogs.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `Console cache:
+`);
+      this.realStdoutWrite.call(this.stdout, cachedLogs);
+    }
+    if (capturedOutput.length > 0) {
+      this.realStdoutWrite.call(this.stdout, `
+Captured output:
+`);
+      this.realStdoutWrite.call(this.stdout, capturedOutput + `
+`);
+    }
+    this.realStdoutWrite.call(this.stdout, ANSI.reset);
+  }
+  exitHandler = (() => {
+    this.destroy();
+    if (env.OTUI_DUMP_CAPTURES) {
+      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+`);
+    }
+  }).bind(this);
+  warningHandler = ((warning) => {
+    console.warn(JSON.stringify(warning.message, null, 2));
+  }).bind(this);
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
+    rendererTracker.addRenderer(this);
     this.stdin = stdin;
     this.stdout = stdout;
     this.realStdoutWrite = stdout.write;
@@ -8031,7 +8686,7 @@ class CliRenderer extends EventEmitter6 {
     this.exitOnCtrlC = config.exitOnCtrlC === undefined ? true : config.exitOnCtrlC;
     this.resizeDebounceDelay = config.debounceDelay || 100;
     this.targetFps = config.targetFps || 30;
-    this.memorySnapshotInterval = config.memorySnapshotInterval || 5000;
+    this.memorySnapshotInterval = config.memorySnapshotInterval ?? 0;
     this.gatherStats = config.gatherStats || false;
     this.maxStatSamples = config.maxStatSamples || 300;
     this.enableMouseMovement = config.enableMouseMovement || true;
@@ -8041,63 +8696,18 @@ class CliRenderer extends EventEmitter6 {
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
     this.root = new RootRenderable(this);
-    this.takeMemorySnapshot();
     if (this.memorySnapshotInterval > 0) {
       this.startMemorySnapshotTimer();
     }
     this.stdout.write = this.interceptStdoutWrite.bind(this);
-    this.sigwinchHandler = () => {
-      const width2 = this.stdout.columns || 80;
-      const height2 = this.stdout.rows || 24;
-      this.handleResize(width2, height2);
-    };
     process.on("SIGWINCH", this.sigwinchHandler);
-    const handleError = (error) => {
-      this.stop();
-      this.destroy();
-      new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(true);
-        }, 100);
-      }).then(() => {
-        this.realStdoutWrite.call(this.stdout, `
-`.repeat(this._terminalHeight));
-        this.realStdoutWrite.call(this.stdout, `
-=== FATAL ERROR OCCURRED ===
-`);
-        this.realStdoutWrite.call(this.stdout, `Console cache:
-`);
-        this.realStdoutWrite.call(this.stdout, this.console.getCachedLogs());
-        this.realStdoutWrite.call(this.stdout, `
-Captured output:
-`);
-        const capturedOutput = capture.claimOutput();
-        if (capturedOutput) {
-          this.realStdoutWrite.call(this.stdout, capturedOutput + `
-`);
-        }
-        this.realStdoutWrite.call(this.stdout, `
-Error details:
-`);
-        this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
-        this.realStdoutWrite.call(this.stdout, `
-`);
-        this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
-        this.realStdoutWrite.call(this.stdout, `
-`);
-        process.exit(1);
-      });
-    };
-    process.on("warning", (warning) => {
-      console.warn(JSON.stringify(warning.message, null, 2));
-    });
-    process.on("uncaughtException", handleError);
-    process.on("unhandledRejection", handleError);
-    process.on("exit", () => {
-      this.destroy();
-    });
+    process.on("warning", this.warningHandler);
+    process.on("uncaughtException", this.handleError);
+    process.on("unhandledRejection", this.handleError);
+    process.on("exit", this.exitHandler);
     this._console = new TerminalConsole(this, config.consoleOptions);
     this.useConsole = config.useConsole ?? true;
+    this._keyHandler = new KeyHandler(this.stdin, config.useKittyKeyboard ?? false);
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
       this.animationRequest.set(id, callback);
@@ -8112,13 +8722,23 @@ Error details:
       global.window = {};
     }
     global.window.requestAnimationFrame = requestAnimationFrame;
-    if (process.env.OTUI_NO_NATIVE_RENDER === "true") {
+    if (env.OTUI_NO_NATIVE_RENDER) {
       this.renderNative = () => {
         if (this._splitHeight > 0) {
           this.flushStdoutCache(this._splitHeight);
         }
       };
     }
+    this.setupInput();
+  }
+  registerLifecyclePass(renderable) {
+    this.lifecyclePasses.add(renderable);
+  }
+  unregisterLifecyclePass(renderable) {
+    this.lifecyclePasses.delete(renderable);
+  }
+  getLifecyclePasses() {
+    return this.lifecyclePasses;
   }
   get currentFocusedRenderable() {
     return this._currentFocusedRenderable;
@@ -8172,6 +8792,9 @@ Error details:
   get console() {
     return this._console;
   }
+  get keyInput() {
+    return this._keyHandler;
+  }
   get terminalWidth() {
     return this._terminalWidth;
   }
@@ -8260,7 +8883,6 @@ Error details:
     return true;
   };
   disableStdoutInterception() {
-    this.flushStdoutCache(this._splitHeight);
     this.stdout.write = this.realStdoutWrite;
   }
   flushStdoutCache(space, force = false) {
@@ -8271,10 +8893,13 @@ Error details:
     const flush = ANSI.moveCursorAndClear(rendererStartLine, 1);
     const outputLine = this._terminalHeight - this._splitHeight;
     const move = ANSI.moveCursor(outputLine, 1);
-    const backgroundColor = this.backgroundColor.toInts();
-    const newlines = " ".repeat(this.width) + `
+    let clear = "";
+    if (space > 0) {
+      const backgroundColor = this.backgroundColor.toInts();
+      const newlines = " ".repeat(this.width) + `
 `.repeat(space);
-    const clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+      clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+    }
     this.writeOut(flush + move + output + clear);
     return true;
   }
@@ -8300,11 +8925,6 @@ Error details:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
-    if (this.stdin.setRawMode) {
-      this.stdin.setRawMode(true);
-    }
-    this.stdin.resume();
-    this.stdin.setEncoding("utf8");
     await new Promise((resolve) => {
       const timeout = setTimeout(() => {
         this.stdin.off("data", capListener);
@@ -8323,32 +8943,40 @@ Error details:
     if (this._useMouse) {
       this.enableMouse();
     }
-    this.stdin.on("data", (data) => {
-      const str = data.toString();
-      if (this.waitingForPixelResolution && /\x1b\[4;\d+;\d+t/.test(str)) {
-        const match = str.match(/\x1b\[4;(\d+);(\d+)t/);
-        if (match) {
-          const resolution = {
-            width: parseInt(match[2]),
-            height: parseInt(match[1])
-          };
-          this._resolution = resolution;
-          this.waitingForPixelResolution = false;
-          return;
-        }
-      }
-      if (this.exitOnCtrlC && str === "\x03") {
-        process.nextTick(() => {
-          process.exit();
-        });
-        return;
-      }
-      if (this._useMouse && this.handleMouseData(data)) {
+    this.queryPixelResolution();
+  }
+  stdinListener = ((data) => {
+    const str = data.toString();
+    if (this.waitingForPixelResolution && /\x1b\[4;\d+;\d+t/.test(str)) {
+      const match = str.match(/\x1b\[4;(\d+);(\d+)t/);
+      if (match) {
+        const resolution = {
+          width: parseInt(match[2]),
+          height: parseInt(match[1])
+        };
+        this._resolution = resolution;
+        this.waitingForPixelResolution = false;
         return;
       }
-      this.emit("key", data);
-    });
-    this.queryPixelResolution();
+    }
+    if (this.exitOnCtrlC && str === "\x03") {
+      process.nextTick(() => {
+        this.destroy();
+      });
+      return;
+    }
+    if (this._useMouse && this.handleMouseData(data)) {
+      return;
+    }
+    this.emit("key", data);
+  }).bind(this);
+  setupInput() {
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", this.stdinListener);
   }
   handleMouseData(data) {
     const mouseEvent = this.mouseParser.parseMouseEvent(data);
@@ -8375,7 +9003,7 @@ Error details:
       this.lastOverRenderableNum = maybeRenderableId;
       const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
       if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && !this.currentSelection?.isSelecting && !mouseEvent.modifiers.ctrl) {
-        if (maybeRenderable && maybeRenderable.selectable && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
+        if (maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
           this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
           const event2 = new MouseEvent(maybeRenderable, mouseEvent);
           maybeRenderable.processMouseEvent(event2);
@@ -8463,6 +9091,8 @@ Error details:
     return false;
   }
   takeMemorySnapshot() {
+    if (this.isDestroyed)
+      return;
     const memoryUsage = process.memoryUsage();
     this.lastMemorySnapshot = {
       heapUsed: memoryUsage.heapUsed,
@@ -8473,13 +9103,17 @@ Error details:
     this.emit("memory:snapshot", this.lastMemorySnapshot);
   }
   startMemorySnapshotTimer() {
-    if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
-    }
+    this.stopMemorySnapshotTimer();
     this.memorySnapshotTimer = setInterval(() => {
       this.takeMemorySnapshot();
     }, this.memorySnapshotInterval);
   }
+  stopMemorySnapshotTimer() {
+    if (this.memorySnapshotTimer) {
+      clearInterval(this.memorySnapshotTimer);
+      this.memorySnapshotTimer = null;
+    }
+  }
   setMemorySnapshotInterval(interval) {
     this.memorySnapshotInterval = interval;
     if (this._isRunning && interval > 0) {
@@ -8507,7 +9141,7 @@ Error details:
   }
   queryPixelResolution() {
     this.waitingForPixelResolution = true;
-    this.writeOut(ANSI.queryPixelSize);
+    this.lib.queryPixelResolution(this.rendererPtr);
   }
   processResize(width, height) {
     if (width === this._terminalWidth && height === this._terminalHeight)
@@ -8549,6 +9183,16 @@ Error details:
     this.requestRender();
   }
   toggleDebugOverlay() {
+    const willBeEnabled = !this.debugOverlay.enabled;
+    if (willBeEnabled && !this.memorySnapshotInterval) {
+      this.memorySnapshotInterval = 3000;
+      this.startMemorySnapshotTimer();
+      this.automaticMemorySnapshot = true;
+    } else if (!willBeEnabled && this.automaticMemorySnapshot) {
+      this.stopMemorySnapshotTimer();
+      this.memorySnapshotInterval = 0;
+      this.automaticMemorySnapshot = false;
+    }
     this.debugOverlay.enabled = !this.debugOverlay.enabled;
     this.lib.setDebugOverlay(this.rendererPtr, this.debugOverlay.enabled, this.debugOverlay.corner);
     this.emit("debugOverlay:toggle" /* DEBUG_OVERLAY_TOGGLE */, this.debugOverlay.enabled);
@@ -8560,9 +9204,6 @@ Error details:
     this.lib.setDebugOverlay(this.rendererPtr, this.debugOverlay.enabled, this.debugOverlay.corner);
     this.requestRender();
   }
-  clearTerminal() {
-    this.lib.clearTerminal(this.rendererPtr);
-  }
   setTerminalTitle(title) {
     this.lib.setTerminalTitle(this.rendererPtr, title);
   }
@@ -8675,19 +9316,37 @@ Error details:
     }
   }
   destroy() {
-    this.stdin.setRawMode(false);
+    process.removeListener("SIGWINCH", this.sigwinchHandler);
+    process.removeListener("uncaughtException", this.handleError);
+    process.removeListener("unhandledRejection", this.handleError);
+    process.removeListener("warning", this.warningHandler);
+    capture.removeListener("write", this.captureCallback);
+    if (this.memorySnapshotTimer) {
+      clearInterval(this.memorySnapshotTimer);
+    }
     if (this.isDestroyed)
       return;
     this.isDestroyed = true;
+    if (this.renderTimeout) {
+      clearTimeout(this.renderTimeout);
+      this.renderTimeout = null;
+    }
+    this._isRunning = false;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
-    if (this.sigwinchHandler) {
-      process.removeListener("SIGWINCH", this.sigwinchHandler);
-      this.sigwinchHandler = null;
-    }
+    this.root.destroyRecursively();
+    this._keyHandler.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
-    this.lib.destroyRenderer(this.rendererPtr, this._useAlternateScreen, this._splitHeight);
+    if (this._splitHeight > 0) {
+      this.flushStdoutCache(this._splitHeight, true);
+    }
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
+    this.stdin.removeListener("data", this.stdinListener);
+    this.lib.destroyRenderer(this.rendererPtr);
+    rendererTracker.removeRenderer(this);
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -8744,7 +9403,9 @@ Error details:
       postProcessFn(this.nextRenderBuffer, deltaTime);
     }
     this._console.renderToBuffer(this.nextRenderBuffer);
-    this.renderNative();
+    if (!this.isDestroyed) {
+      this.renderNative();
+    }
     const overallFrameTime = performance.now() - overallStart;
     this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
     if (this.gatherStats) {
@@ -8820,7 +9481,7 @@ Error details:
   clearSelection() {
     if (this.currentSelection) {
       for (const renderable of this.currentSelection.touchedRenderables) {
-        if (renderable.selectable) {
+        if (renderable.selectable && !renderable.isDestroyed) {
           renderable.onSelectionChanged(null);
         }
       }
@@ -8911,7 +9572,7 @@ Error details:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, TrackedNode, createTrackedNode, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isValidPercentage, isMarginType, isPaddingType, isPositionType, isPositionTypeType, isOverflowType, isDimensionType, isFlexBasisType, isSizeType, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, generateEnvMarkdown, generateEnvColored, env, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
 
-//# debugId=22DC4532C30EE05864756E2164756E21
-//# sourceMappingURL=index-a6ydv6yb.js.map
+//# debugId=FA47EE78BCA83E8664756E2164756E21
+//# sourceMappingURL=index-6kvgbzah.js.map