@opentui/core 0.0.0-20250908-4906ddad → 0.0.0-20250915-f5db043a

package/{index-d6kwx5pm.js → index-6esrcarp.js}

@@ -1,3 +1,4 @@
+// @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -1790,21 +1791,11 @@ class TrackedNode extends EventEmitter {
   }
   setWidth(width) {
     this._width = width;
-    const parsedWidth = this.parseWidth(width);
-    if (parsedWidth === "auto") {
-      this.yogaNode.setWidthAuto();
-    } else {
-      this.yogaNode.setWidth(parsedWidth);
-    }
+    this.yogaNode.setWidth(width);
   }
   setHeight(height) {
     this._height = height;
-    const parsedHeight = this.parseHeight(height);
-    if (parsedHeight === "auto") {
-      this.yogaNode.setHeightAuto();
-    } else {
-      this.yogaNode.setHeight(parsedHeight);
-    }
+    this.yogaNode.setHeight(height);
   }
   addChild(childNode) {
     if (childNode.parent) {
@@ -1917,6 +1908,237 @@ function createTrackedNode(metadata = {}, yogaConfig) {
 
 // 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;
+    }
+  }
+  if (field1[2]) {
+    const base = parseInt(field1[2], 10);
+    if (!isNaN(base) && base > 0 && base <= 1114111) {
+      baseCodepoint = base;
+    }
+  }
+  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 {
+      return null;
+    }
+  }
+  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;
+      }
+    }
+    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";
+    }
+  }
+  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);
+      }
+    }
+  }
+  if (text === "") {
+    const isPrintable = key.name.length > 0 && !kittyKeyMap[codepoint];
+    if (isPrintable) {
+      if (key.shift && shiftedCodepoint) {
+        text = String.fromCodePoint(shiftedCodepoint);
+      } else {
+        text = key.name;
+      }
+    }
+  }
+  if (key.name === " " && key.shift && !key.ctrl && !key.meta) {
+    text = " ";
+  }
+  if (text) {
+    key.sequence = text;
+  }
+  return key;
+}
+
+// src/lib/parse.keypress.ts
 var metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
 var fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
 var keyName = {
@@ -2000,7 +2222,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 +2244,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 +2293,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;
@@ -2096,26 +2331,43 @@ function singleton(key, factory) {
 
 // src/lib/KeyHandler.ts
 class KeyHandler extends EventEmitter2 {
-  constructor() {
+  stdin;
+  useKittyKeyboard;
+  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;
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("data", (key) => {
+      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;
+      }
     });
   }
   destroy() {
-    process.stdin.removeAllListeners("data");
+    this.stdin.removeAllListeners("data");
   }
 }
 var keyHandler = null;
-function getKeyHandler() {
+function getKeyHandler(useKittyKeyboard = false) {
   if (!keyHandler) {
-    keyHandler = singleton("KeyHandler", () => new KeyHandler);
+    keyHandler = singleton("KeyHandler", () => new KeyHandler(process.stdin, useKittyKeyboard));
   }
   return keyHandler;
 }
@@ -3936,11 +4188,40 @@ 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 textEncoder = new TextEncoder;
+var BrandedStyledText = Symbol.for("@opentui/core/StyledText");
+function isStyledText(obj) {
+  return obj && obj[BrandedStyledText];
+}
 
 class StyledText {
+  [BrandedStyledText] = true;
   chunks;
   textRenderable;
   constructor(chunks) {
@@ -3998,11 +4279,9 @@ class StyledText {
   }
 }
 function stringToStyledText(content) {
-  const textEncoder2 = new TextEncoder;
   const chunk = {
     __isChunk: true,
-    text: textEncoder2.encode(content),
-    plainText: content
+    text: content
   };
   return new StyledText([chunk]);
 }
@@ -4016,21 +4295,18 @@ function applyStyle(input, style) {
     return {
       __isChunk: true,
       text: existingChunk.text,
-      plainText: existingChunk.plainText,
       fg,
       bg,
       attributes: mergedAttrs
     };
   } else {
     const plainTextStr = String(input);
-    const text = textEncoder.encode(plainTextStr);
     const fg = style.fg ? parseColor(style.fg) : undefined;
     const bg = style.bg ? parseColor(style.bg) : undefined;
     const attributes = createTextAttributes(style);
     return {
       __isChunk: true,
-      text,
-      plainText: plainTextStr,
+      text: plainTextStr,
       fg,
       bg,
       attributes
@@ -4077,8 +4353,7 @@ function t(strings, ...values) {
     if (raw) {
       chunks.push({
         __isChunk: true,
-        text: textEncoder.encode(raw),
-        plainText: raw,
+        text: raw,
         attributes: 0
       });
     }
@@ -4089,8 +4364,7 @@ function t(strings, ...values) {
       const plainTextStr = String(val);
       chunks.push({
         __isChunk: true,
-        text: textEncoder.encode(plainTextStr),
-        plainText: plainTextStr,
+        text: plainTextStr,
         attributes: 0
       });
     }
@@ -4150,7 +4424,6 @@ class SyntaxStyle {
     return this.mergedStyleCache.size;
   }
 }
-var textEncoder2 = new TextEncoder;
 function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
   const chunks = [];
   if (node.type === "text") {
@@ -4158,8 +4431,7 @@ function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
     const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
     chunks.push({
       __isChunk: true,
-      text: textEncoder2.encode(node.value),
-      plainText: node.value,
+      text: node.value,
       fg: mergedStyle.fg,
       bg: mergedStyle.bg,
       attributes: mergedStyle.attributes
@@ -4718,10 +4990,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);
@@ -4751,9 +5029,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;
   }
@@ -4761,22 +5036,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;
@@ -4809,21 +5097,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;
@@ -4832,18 +5128,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);
   }
 }
@@ -4856,17 +5156,17 @@ if (!existsSync(targetLibPath)) {
 }
 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: {
@@ -4953,6 +5253,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"
@@ -5186,6 +5494,115 @@ function getOpenTUILib(libPath) {
       returns: "void"
     }
   });
+  if (process.env.DEBUG_FFI === "true" || process.env.TRACE_FFI === "true") {
+    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 (process.env.DEBUG_FFI === "true") {
+    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 (process.env.TRACE_FFI === "true") {
+    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) => {
@@ -5249,11 +5666,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);
@@ -5329,6 +5746,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);
   }
@@ -5676,21 +6100,28 @@ class TextBuffer {
   _length = 0;
   _capacity;
   _lineInfo;
+  _destroyed = false;
   constructor(lib, ptr2, capacity) {
     this.lib = lib;
     this.bufferPtr = ptr2;
     this._capacity = capacity;
   }
-  static create(capacity = 256, widthMethod) {
+  static create(capacity = 64, widthMethod) {
     const lib = resolveRenderLib();
     return lib.createTextBuffer(capacity, 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 result = this.lib.textBufferWriteChunk(this.bufferPtr, chunk.text, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
+      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);
       }
@@ -5699,27 +6130,35 @@ class TextBuffer {
     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() {
+    this.guard();
     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);
@@ -5728,6 +6167,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);
@@ -5736,53 +6176,69 @@ 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);
   }
   destroy() {
+    if (this._destroyed)
+      return;
+    this._destroyed = true;
     this.lib.destroyTextBuffer(this.bufferPtr);
   }
 }
@@ -5877,12 +6333,40 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class Renderable extends EventEmitter3 {
+class BaseRenderable extends EventEmitter3 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
-  static renderablesByNumber = new Map;
   id;
   num;
+  _dirty = false;
+  parent = null;
+  _visible = true;
+  constructor(options) {
+    super();
+    this.num = BaseRenderable.renderableNumber++;
+    this.id = options.id ?? `renderable-${this.num}`;
+  }
+  get isDirty() {
+    return this._dirty;
+  }
+  markClean() {
+    this._dirty = false;
+  }
+  markDirty() {
+    this._dirty = true;
+  }
+  destroy() {}
+  destroyRecursively() {}
+  get visible() {
+    return this._visible;
+  }
+  set visible(value) {
+    this._visible = value;
+  }
+}
+
+class Renderable extends BaseRenderable {
+  static renderablesByNumber = new Map;
   _isDestroyed = false;
   _ctx;
   _translateX = 0;
@@ -5894,14 +6378,11 @@ class Renderable extends EventEmitter3 {
   _widthValue = 0;
   _heightValue = 0;
   _zIndex;
-  _visible;
   selectable = false;
   buffered;
   frameBuffer = null;
-  _dirty = false;
-  focusable = false;
+  _focusable = false;
   _focused = false;
-  keyHandler = getKeyHandler();
   keypressHandler = null;
   _live = false;
   _liveCount = 0;
@@ -5919,12 +6400,12 @@ class Renderable extends EventEmitter3 {
   parent = null;
   childrenPrimarySortDirty = true;
   childrenSortedByPrimaryAxis = [];
+  _newChildren = [];
+  onLifecyclePass = null;
   renderBefore;
   renderAfter;
   constructor(ctx, options) {
-    super();
-    this.num = Renderable.renderableNumber++;
-    this.id = options.id ?? `renderable-${this.num}`;
+    super(options);
     this._ctx = ctx;
     Renderable.renderablesByNumber.set(this.num, this);
     validateOptions(this.id, options);
@@ -5951,12 +6432,19 @@ class Renderable extends EventEmitter3 {
       this.createFrameBuffer();
     }
   }
+  get focusable() {
+    return this._focusable;
+  }
   get ctx() {
     return this._ctx;
   }
   get visible() {
     return this._visible;
   }
+  get primaryAxis() {
+    const dir = this.layoutNode.yogaNode.getFlexDirection();
+    return dir === 2 || dir === 3 ? "row" : "column";
+  }
   set visible(value) {
     if (this._visible === value)
       return;
@@ -5988,8 +6476,9 @@ class Renderable extends EventEmitter3 {
     return false;
   }
   focus() {
-    if (this._focused || !this.focusable)
+    if (this._focused || !this._focusable)
       return;
+    this._ctx.focusRenderable(this);
     this._focused = true;
     this.requestRender();
     this.keypressHandler = (key) => {
@@ -5998,16 +6487,16 @@ class Renderable extends EventEmitter3 {
         this.handleKeyPress(key);
       }
     };
-    this.keyHandler.on("keypress", this.keypressHandler);
+    this.ctx.keyInput.on("keypress", this.keypressHandler);
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
-    if (!this._focused || !this.focusable)
+    if (!this._focused || !this._focusable)
       return;
     this._focused = false;
     this.requestRender();
     if (this.keypressHandler) {
-      this.keyHandler.off("keypress", this.keypressHandler);
+      this.ctx.keyInput.off("keypress", this.keypressHandler);
       this.keypressHandler = null;
     }
     this.emit("blurred" /* BLURRED */);
@@ -6034,9 +6523,6 @@ class Renderable extends EventEmitter3 {
     this._liveCount += delta;
     this.parent?.propagateLiveCount(delta);
   }
-  get isDirty() {
-    return this._dirty;
-  }
   findDescendantById(id) {
     for (const child of this.renderableArray) {
       if (child.id === id)
@@ -6047,11 +6533,8 @@ class Renderable extends EventEmitter3 {
     }
     return;
   }
-  markClean() {
-    this._dirty = false;
-  }
   requestRender() {
-    this._dirty = true;
+    this.markDirty();
     this._ctx.requestRender();
   }
   get translateX() {
@@ -6164,80 +6647,6 @@ class Renderable extends EventEmitter3 {
       this.needsZIndexSort = false;
     }
   }
-  getChildrenInViewport(viewport, padding = 10, minTriggerSize = 16) {
-    if (this.renderableArray.length < minTriggerSize)
-      return this.renderableArray;
-    const viewportTop = viewport.y - padding;
-    const viewportBottom = viewport.y + viewport.height + padding;
-    const viewportLeft = viewport.x - padding;
-    const viewportRight = viewport.x + viewport.width + padding;
-    const dir = this.layoutNode.yogaNode.getFlexDirection();
-    const isRow = dir === 2 || dir === 3;
-    const children = this.getChildrenSortedByPrimaryAxis();
-    const totalChildren = children.length;
-    if (totalChildren === 0)
-      return [];
-    const vpStart = isRow ? viewportLeft : viewportTop;
-    const vpEnd = isRow ? viewportRight : viewportBottom;
-    let lo = 0;
-    let hi = totalChildren - 1;
-    let candidate = -1;
-    while (lo <= hi) {
-      const mid = lo + hi >> 1;
-      const c = children[mid];
-      const start = isRow ? c.x : c.y;
-      const end = isRow ? c.x + c.width : c.y + c.height;
-      if (end < vpStart) {
-        lo = mid + 1;
-      } else if (start > vpEnd) {
-        hi = mid - 1;
-      } else {
-        candidate = mid;
-        break;
-      }
-    }
-    const visibleChildren = [];
-    if (candidate === -1) {
-      return visibleChildren;
-    }
-    let left = candidate;
-    while (left - 1 >= 0) {
-      const prev = children[left - 1];
-      if ((isRow ? prev.x + prev.width : prev.y + prev.height) < vpStart)
-        break;
-      left--;
-    }
-    let right = candidate + 1;
-    while (right < totalChildren) {
-      const next = children[right];
-      if ((isRow ? next.x : next.y) > vpEnd)
-        break;
-      right++;
-    }
-    for (let i = left;i < right; i++) {
-      const child = children[i];
-      if (isRow) {
-        const childBottom = child.y + child.height;
-        if (childBottom < viewportTop)
-          continue;
-        const childTop = child.y;
-        if (childTop > viewportBottom)
-          continue;
-      } else {
-        const childRight = child.x + child.width;
-        if (childRight < viewportLeft)
-          continue;
-        const childLeft = child.x;
-        if (childLeft > viewportRight)
-          continue;
-      }
-      visibleChildren.push(child);
-    }
-    if (visibleChildren.length > 1) {
-      visibleChildren.sort((a, b) => a.zIndex > b.zIndex ? 1 : a.zIndex < b.zIndex ? -1 : 0);
-    }
-    return visibleChildren;
-  }
   getChildrenSortedByPrimaryAxis() {
     if (!this.childrenPrimarySortDirty && this.childrenSortedByPrimaryAxis.length === this.renderableArray.length) {
       return this.childrenSortedByPrimaryAxis;
@@ -6609,6 +7018,7 @@ class Renderable extends EventEmitter3 {
     }
     obj.parent = this;
   }
+  _forceLayoutUpdateFor = null;
   add(obj, index) {
     if (!obj) {
       return -1;
@@ -6632,6 +7042,7 @@ class Renderable extends EventEmitter3 {
     let insertedIndex;
     if (index !== undefined) {
       this.renderableArray.splice(index, 0, renderable);
+      this._forceLayoutUpdateFor = this.renderableArray.slice(index);
       insertedIndex = this.layoutNode.insertChild(childLayoutNode, index);
     } else {
       this.renderableArray.push(renderable);
@@ -6640,6 +7051,10 @@ class Renderable extends EventEmitter3 {
     this.needsZIndexSort = true;
     this.childrenPrimarySortDirty = true;
     this.renderableMap.set(renderable.id, renderable);
+    if (typeof renderable.onLifecyclePass === "function") {
+      this._ctx.registerLifecyclePass(renderable);
+    }
+    this._newChildren.push(renderable);
     if (renderable._liveCount > 0) {
       this.propagateLiveCount(renderable._liveCount);
     }
@@ -6657,6 +7072,9 @@ class Renderable extends EventEmitter3 {
     if (!anchor) {
       return this.add(renderable);
     }
+    if (!isRenderable(anchor)) {
+      throw new Error("Anchor must be a Renderable");
+    }
     if (!this.renderableMap.has(anchor.id)) {
       throw new Error("Anchor does not exist");
     }
@@ -6684,6 +7102,7 @@ class Renderable extends EventEmitter3 {
         this.requestRender();
         obj.onRemove();
         obj.parent = null;
+        this._ctx.unregisterLifecyclePass(obj);
       }
       this.renderableMap.delete(id);
       const index = this.renderableArray.findIndex((obj2) => obj2.id === id);
@@ -6700,11 +7119,44 @@ class Renderable extends EventEmitter3 {
   getChildrenCount() {
     return this.renderableArray.length;
   }
-  render(buffer, deltaTime) {
+  updateLayout(deltaTime, renderList = []) {
     if (!this.visible)
       return;
     this.onUpdate(deltaTime);
     this.updateFromLayout();
+    renderList.push({ action: "render", renderable: this });
+    if (this._newChildren.length > 0) {
+      for (const child of this._newChildren) {
+        child.updateFromLayout();
+      }
+      this._newChildren = [];
+    }
+    if (this._forceLayoutUpdateFor) {
+      for (const child of this._forceLayoutUpdateFor) {
+        child.updateFromLayout();
+      }
+      this._forceLayoutUpdateFor = null;
+    }
+    this.ensureZIndexSorted();
+    const shouldPushScissor = this._overflow !== "visible" && this.width > 0 && this.height > 0;
+    if (shouldPushScissor) {
+      const scissorRect = this.getScissorRect();
+      renderList.push({
+        action: "pushScissorRect",
+        x: scissorRect.x,
+        y: scissorRect.y,
+        width: scissorRect.width,
+        height: scissorRect.height
+      });
+    }
+    for (const child of this._getChildren()) {
+      child.updateLayout(deltaTime, renderList);
+    }
+    if (shouldPushScissor) {
+      renderList.push({ action: "popScissorRect" });
+    }
+  }
+  render(buffer, deltaTime) {
     let renderBuffer = buffer;
     if (this.buffered && this.frameBuffer) {
       renderBuffer = this.frameBuffer;
@@ -6718,18 +7170,6 @@ class Renderable extends EventEmitter3 {
     }
     this.markClean();
     this._ctx.addToHitGrid(this.x, this.y, this.width, this.height, this.num);
-    this.ensureZIndexSorted();
-    const shouldPushScissor = this._overflow !== "visible" && this.width > 0 && this.height > 0;
-    if (shouldPushScissor) {
-      const scissorRect = this.getScissorRect();
-      renderBuffer.pushScissorRect(scissorRect.x, scissorRect.y, scissorRect.width, scissorRect.height);
-    }
-    for (const child of this._getChildren()) {
-      child.render(renderBuffer, deltaTime);
-    }
-    if (shouldPushScissor) {
-      renderBuffer.popScissorRect();
-    }
     if (this.buffered && this.frameBuffer) {
       buffer.drawFrameBuffer(this.x, this.y, this.frameBuffer);
     }
@@ -6882,6 +7322,7 @@ class Renderable extends EventEmitter3 {
 
 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();
@@ -6896,6 +7337,32 @@ class RootRenderable extends Renderable {
     this.layoutNode.yogaNode.setFlexDirection(FlexDirection.Column);
     this.calculateLayout();
   }
+  render(buffer, deltaTime) {
+    if (!this.visible)
+      return;
+    for (const renderable of this._ctx.getLifecyclePasses()) {
+      renderable.onLifecyclePass?.call(renderable);
+    }
+    if (this.layoutNode.yogaNode.isDirty()) {
+      this.calculateLayout();
+    }
+    this.renderList.length = 0;
+    this.updateLayout(deltaTime, this.renderList);
+    for (let i = 1;i < this.renderList.length; i++) {
+      const command = this.renderList[i];
+      switch (command.action) {
+        case "render":
+          command.renderable.render(buffer, deltaTime);
+          break;
+        case "pushScissorRect":
+          buffer.pushScissorRect(command.x, command.y, command.width, command.height);
+          break;
+        case "popScissorRect":
+          buffer.popScissorRect();
+          break;
+      }
+    }
+  }
   propagateLiveCount(delta) {
     const oldCount = this._liveCount;
     this._liveCount += delta;
@@ -6914,15 +7381,7 @@ class RootRenderable extends Renderable {
     this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
-  onUpdate() {
-    if (this.layoutNode.yogaNode.isDirty()) {
-      this.calculateLayout();
-    }
-  }
   destroySelf() {
-    if (this.layoutNode) {
-      this.layoutNode.destroy();
-    }
     try {
       this.yogaConfig.free();
     } catch (error) {}
@@ -7783,6 +8242,83 @@ var ANSI = {
 
 // src/renderer.ts
 import { EventEmitter as EventEmitter6 } from "events";
+
+// src/lib/objects-in-viewport.ts
+function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
+  if (objects.length < minTriggerSize)
+    return objects;
+  const viewportTop = viewport.y - padding;
+  const viewportBottom = viewport.y + viewport.height + padding;
+  const viewportLeft = viewport.x - padding;
+  const viewportRight = viewport.x + viewport.width + padding;
+  const isRow = direction === "row";
+  const children = objects;
+  const totalChildren = children.length;
+  if (totalChildren === 0)
+    return [];
+  const vpStart = isRow ? viewportLeft : viewportTop;
+  const vpEnd = isRow ? viewportRight : viewportBottom;
+  let lo = 0;
+  let hi = totalChildren - 1;
+  let candidate = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const c = children[mid];
+    const start = isRow ? c.x : c.y;
+    const end = isRow ? c.x + c.width : c.y + c.height;
+    if (end < vpStart) {
+      lo = mid + 1;
+    } else if (start > vpEnd) {
+      hi = mid - 1;
+    } else {
+      candidate = mid;
+      break;
+    }
+  }
+  const visibleChildren = [];
+  if (candidate === -1) {
+    return visibleChildren;
+  }
+  let left = candidate;
+  while (left - 1 >= 0) {
+    const prev = children[left - 1];
+    if ((isRow ? prev.x + prev.width : prev.y + prev.height) < vpStart)
+      break;
+    left--;
+  }
+  let right = candidate + 1;
+  while (right < totalChildren) {
+    const next = children[right];
+    if ((isRow ? next.x : next.y) > vpEnd)
+      break;
+    right++;
+  }
+  for (let i = left;i < right; i++) {
+    const child = children[i];
+    if (isRow) {
+      const childBottom = child.y + child.height;
+      if (childBottom < viewportTop)
+        continue;
+      const childTop = child.y;
+      if (childTop > viewportBottom)
+        continue;
+    } else {
+      const childRight = child.x + child.width;
+      if (childRight < viewportLeft)
+        continue;
+      const childLeft = child.x;
+      if (childLeft > viewportRight)
+        continue;
+    }
+    visibleChildren.push(child);
+  }
+  if (visibleChildren.length > 1) {
+    visibleChildren.sort((a, b) => a.zIndex > b.zIndex ? 1 : a.zIndex < b.zIndex ? -1 : 0);
+  }
+  return visibleChildren;
+}
+
+// src/renderer.ts
 class MouseEvent {
   type;
   button;
@@ -7917,6 +8453,7 @@ class CliRenderer extends EventEmitter6 {
   };
   _console;
   _resolution = null;
+  _keyHandler;
   animationRequest = new Map;
   resizeTimeoutId = null;
   resizeDebounceDelay = 100;
@@ -7941,9 +8478,57 @@ 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.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);
+    });
+  }).bind(this);
+  exitHandler = (() => {
+    this.destroy();
+  }).bind(this);
+  warningHandler = ((warning) => {
+    console.warn(JSON.stringify(warning.message, null, 2));
+  }).bind(this);
   constructor(lib, rendererPtr, stdin, stdout, width, height, config = {}) {
     super();
     this.stdin = stdin;
@@ -7966,7 +8551,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;
@@ -7981,61 +8566,18 @@ class CliRenderer extends EventEmitter6 {
       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);
+      this.requestLive();
       return id;
     };
     global.cancelAnimationFrame = (handle) => {
@@ -8053,6 +8595,27 @@ Error details:
         }
       };
     }
+    this.setupInput();
+  }
+  registerLifecyclePass(renderable) {
+    this.lifecyclePasses.add(renderable);
+  }
+  unregisterLifecyclePass(renderable) {
+    this.lifecyclePasses.delete(renderable);
+  }
+  getLifecyclePasses() {
+    return this.lifecyclePasses;
+  }
+  get currentFocusedRenderable() {
+    return this._currentFocusedRenderable;
+  }
+  focusRenderable(renderable) {
+    if (this._currentFocusedRenderable === renderable)
+      return;
+    if (this._currentFocusedRenderable) {
+      this._currentFocusedRenderable.blur();
+    }
+    this._currentFocusedRenderable = renderable;
   }
   addToHitGrid(x, y, width, height, id) {
     if (id !== this.capturedRenderable?.num) {
@@ -8095,6 +8658,9 @@ Error details:
   get console() {
     return this._console;
   }
+  get keyInput() {
+    return this._keyHandler;
+  }
   get terminalWidth() {
     return this._terminalWidth;
   }
@@ -8194,10 +8760,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;
   }
@@ -8246,32 +8815,35 @@ 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(() => {
+        process.exit();
+      });
+      return;
+    }
+    if (this._useMouse && this.handleMouseData(data)) {
+      return;
+    }
+    this.emit("key", data);
+  }).bind(this);
+  setupInput() {
+    this.stdin.on("data", this.stdinListener);
   }
   handleMouseData(data) {
     const mouseEvent = this.mouseParser.parseMouseEvent(data);
@@ -8298,7 +8870,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);
@@ -8386,6 +8958,8 @@ Error details:
     return false;
   }
   takeMemorySnapshot() {
+    if (this.isDestroyed)
+      return;
     const memoryUsage = process.memoryUsage();
     this.lastMemorySnapshot = {
       heapUsed: memoryUsage.heapUsed,
@@ -8598,19 +9172,28 @@ Error details:
     }
   }
   destroy() {
-    this.stdin.setRawMode(false);
+    this.stdin.removeListener("data", this.stdinListener);
+    process.removeListener("SIGWINCH", this.sigwinchHandler);
+    process.removeListener("uncaughtException", this.handleError);
+    process.removeListener("unhandledRejection", this.handleError);
+    process.removeListener("exit", this.exitHandler);
+    process.removeListener("warning", this.warningHandler);
+    capture.removeListener("write", this.captureCallback);
+    if (this.memorySnapshotTimer) {
+      clearInterval(this.memorySnapshotTimer);
+    }
+    if (this.stdin.setRawMode) {
+      this.stdin.setRawMode(false);
+    }
     if (this.isDestroyed)
       return;
     this.isDestroyed = true;
     this.waitingForPixelResolution = false;
     this.capturedRenderable = undefined;
-    if (this.sigwinchHandler) {
-      process.removeListener("SIGWINCH", this.sigwinchHandler);
-      this.sigwinchHandler = null;
-    }
+    this._keyHandler.destroy();
     this._console.deactivate();
     this.disableStdoutInterception();
-    this.lib.destroyRenderer(this.rendererPtr, this._useAlternateScreen, this._splitHeight);
+    this.lib.destroyRenderer(this.rendererPtr);
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -8646,7 +9229,10 @@ Error details:
     const frameRequests = Array.from(this.animationRequest.values());
     this.animationRequest.clear();
     const animationRequestStart = performance.now();
-    frameRequests.forEach((callback) => callback(deltaTime));
+    frameRequests.forEach((callback) => {
+      callback(deltaTime);
+      this.dropLive();
+    });
     const animationRequestEnd = performance.now();
     const animationRequestTime = animationRequestEnd - animationRequestStart;
     const start = performance.now();
@@ -8740,7 +9326,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);
         }
       }
@@ -8815,7 +9401,7 @@ Error details:
     }
   }
   walkSelectableRenderables(container, selectionBounds, selectedRenderables, touchedRenderables) {
-    const children = container.getChildrenInViewport(selectionBounds, 0);
+    const children = getObjectsInViewport(selectionBounds, container.getChildrenSortedByPrimaryAxis(), container.primaryAxis, 0);
     for (const child of children) {
       if (child.selectable) {
         const hasSelection = child.onSelectionChanged(this.currentSelection);
@@ -8831,7 +9417,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, 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, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
+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, 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, 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 };
 
-//# debugId=071E012DDCE3FA6064756E2164756E21
-//# sourceMappingURL=index-d6kwx5pm.js.map
+//# debugId=ACCACBFBC5B1AC8B64756E2164756E21
+//# sourceMappingURL=index-6esrcarp.js.map