@opentui/core 0.1.28 → 0.1.30

package/{index-phjxdb6g.js → index-0qmm1k4p.js}

@@ -2406,18 +2406,22 @@ function hexToRgb(hex) {
   hex = hex.replace(/^#/, "");
   if (hex.length === 3) {
     hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  } else if (hex.length === 4) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
   }
-  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex) && !/^[0-9A-Fa-f]{8}$/.test(hex)) {
     console.warn(`Invalid hex color: ${hex}, defaulting to magenta`);
     return RGBA.fromValues(1, 0, 1, 1);
   }
   const r = parseInt(hex.substring(0, 2), 16) / 255;
   const g = parseInt(hex.substring(2, 4), 16) / 255;
   const b = parseInt(hex.substring(4, 6), 16) / 255;
-  return RGBA.fromValues(r, g, b, 1);
+  const a = hex.length === 8 ? parseInt(hex.substring(6, 8), 16) / 255 : 1;
+  return RGBA.fromValues(r, g, b, a);
 }
 function rgbToHex(rgb) {
-  return "#" + [rgb.r, rgb.g, rgb.b].map((x) => {
+  const components = rgb.a === 1 ? [rgb.r, rgb.g, rgb.b] : [rgb.r, rgb.g, rgb.b, rgb.a];
+  return "#" + components.map((x) => {
     const hex = Math.floor(Math.max(0, Math.min(1, x) * 255)).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
   }).join("");
@@ -4299,104 +4303,6 @@ function t(strings, ...values) {
   return new StyledText(chunks);
 }
 
-// src/lib/syntax-style.ts
-function convertThemeToStyles(theme) {
-  const flatStyles = {};
-  for (const tokenStyle of theme) {
-    const styleDefinition = {};
-    if (tokenStyle.style.foreground) {
-      styleDefinition.fg = parseColor(tokenStyle.style.foreground);
-    }
-    if (tokenStyle.style.background) {
-      styleDefinition.bg = parseColor(tokenStyle.style.background);
-    }
-    if (tokenStyle.style.bold !== undefined) {
-      styleDefinition.bold = tokenStyle.style.bold;
-    }
-    if (tokenStyle.style.italic !== undefined) {
-      styleDefinition.italic = tokenStyle.style.italic;
-    }
-    if (tokenStyle.style.underline !== undefined) {
-      styleDefinition.underline = tokenStyle.style.underline;
-    }
-    if (tokenStyle.style.dim !== undefined) {
-      styleDefinition.dim = tokenStyle.style.dim;
-    }
-    for (const scope of tokenStyle.scope) {
-      flatStyles[scope] = styleDefinition;
-    }
-  }
-  return flatStyles;
-}
-
-class SyntaxStyle {
-  styles;
-  mergedStyleCache;
-  constructor(styles) {
-    this.styles = styles;
-    this.mergedStyleCache = new Map;
-  }
-  static fromTheme(theme) {
-    const flatStyles = convertThemeToStyles(theme);
-    return new SyntaxStyle(flatStyles);
-  }
-  mergeStyles(...styleNames) {
-    const cacheKey = styleNames.join(":");
-    const cached = this.mergedStyleCache.get(cacheKey);
-    if (cached)
-      return cached;
-    const styleDefinition = {};
-    for (const name of styleNames) {
-      const style = this.getStyle(name);
-      if (!style)
-        continue;
-      if (style.fg)
-        styleDefinition.fg = style.fg;
-      if (style.bg)
-        styleDefinition.bg = style.bg;
-      if (style.bold !== undefined)
-        styleDefinition.bold = style.bold;
-      if (style.italic !== undefined)
-        styleDefinition.italic = style.italic;
-      if (style.underline !== undefined)
-        styleDefinition.underline = style.underline;
-      if (style.dim !== undefined)
-        styleDefinition.dim = style.dim;
-    }
-    const attributes = createTextAttributes({
-      bold: styleDefinition.bold,
-      italic: styleDefinition.italic,
-      underline: styleDefinition.underline,
-      dim: styleDefinition.dim
-    });
-    const merged = {
-      fg: styleDefinition.fg,
-      bg: styleDefinition.bg,
-      attributes
-    };
-    this.mergedStyleCache.set(cacheKey, merged);
-    return merged;
-  }
-  getStyle(name) {
-    if (Object.prototype.hasOwnProperty.call(this.styles, name)) {
-      return this.styles[name];
-    }
-    if (name.includes(".")) {
-      const baseName = name.split(".")[0];
-      if (Object.prototype.hasOwnProperty.call(this.styles, baseName)) {
-        return this.styles[baseName];
-      }
-    }
-    return;
-  }
-  clearCache() {
-    this.mergedStyleCache.clear();
-  }
-  getCacheSize() {
-    return this.mergedStyleCache.size;
-  }
-}
-
 // src/lib/hast-styled-text.ts
 function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
   const chunks = [];
@@ -4480,6 +4386,9 @@ class MacOSScrollAccel {
 
 // src/lib/yoga.options.ts
 function parseAlign(value) {
+  if (value == null) {
+    return Align.Auto;
+  }
   switch (value.toLowerCase()) {
     case "auto":
       return Align.Auto;
@@ -4504,6 +4413,9 @@ function parseAlign(value) {
   }
 }
 function parseBoxSizing(value) {
+  if (value == null) {
+    return BoxSizing.BorderBox;
+  }
   switch (value.toLowerCase()) {
     case "border-box":
       return BoxSizing.BorderBox;
@@ -4514,6 +4426,9 @@ function parseBoxSizing(value) {
   }
 }
 function parseDimension(value) {
+  if (value == null) {
+    return Dimension.Width;
+  }
   switch (value.toLowerCase()) {
     case "width":
       return Dimension.Width;
@@ -4524,6 +4439,9 @@ function parseDimension(value) {
   }
 }
 function parseDirection(value) {
+  if (value == null) {
+    return Direction.LTR;
+  }
   switch (value.toLowerCase()) {
     case "inherit":
       return Direction.Inherit;
@@ -4536,6 +4454,9 @@ function parseDirection(value) {
   }
 }
 function parseDisplay(value) {
+  if (value == null) {
+    return Display.Flex;
+  }
   switch (value.toLowerCase()) {
     case "flex":
       return Display.Flex;
@@ -4548,6 +4469,9 @@ function parseDisplay(value) {
   }
 }
 function parseEdge(value) {
+  if (value == null) {
+    return Edge.All;
+  }
   switch (value.toLowerCase()) {
     case "left":
       return Edge.Left;
@@ -4572,6 +4496,9 @@ function parseEdge(value) {
   }
 }
 function parseFlexDirection(value) {
+  if (value == null) {
+    return FlexDirection.Column;
+  }
   switch (value.toLowerCase()) {
     case "column":
       return FlexDirection.Column;
@@ -4586,6 +4513,9 @@ function parseFlexDirection(value) {
   }
 }
 function parseGutter(value) {
+  if (value == null) {
+    return Gutter.All;
+  }
   switch (value.toLowerCase()) {
     case "column":
       return Gutter.Column;
@@ -4598,6 +4528,9 @@ function parseGutter(value) {
   }
 }
 function parseJustify(value) {
+  if (value == null) {
+    return Justify.FlexStart;
+  }
   switch (value.toLowerCase()) {
     case "flex-start":
       return Justify.FlexStart;
@@ -4616,6 +4549,9 @@ function parseJustify(value) {
   }
 }
 function parseLogLevel(value) {
+  if (value == null) {
+    return LogLevel.Info;
+  }
   switch (value.toLowerCase()) {
     case "error":
       return LogLevel.Error;
@@ -4634,6 +4570,9 @@ function parseLogLevel(value) {
   }
 }
 function parseMeasureMode(value) {
+  if (value == null) {
+    return MeasureMode.Undefined;
+  }
   switch (value.toLowerCase()) {
     case "undefined":
       return MeasureMode.Undefined;
@@ -4646,6 +4585,9 @@ function parseMeasureMode(value) {
   }
 }
 function parseOverflow(value) {
+  if (value == null) {
+    return Overflow.Visible;
+  }
   switch (value.toLowerCase()) {
     case "visible":
       return Overflow.Visible;
@@ -4658,6 +4600,9 @@ function parseOverflow(value) {
   }
 }
 function parsePositionType(value) {
+  if (value == null) {
+    return PositionType.Relative;
+  }
   switch (value.toLowerCase()) {
     case "static":
       return PositionType.Static;
@@ -4670,6 +4615,9 @@ function parsePositionType(value) {
   }
 }
 function parseUnit(value) {
+  if (value == null) {
+    return Unit.Point;
+  }
   switch (value.toLowerCase()) {
     case "undefined":
       return Unit.Undefined;
@@ -4684,6 +4632,9 @@ function parseUnit(value) {
   }
 }
 function parseWrap(value) {
+  if (value == null) {
+    return Wrap.NoWrap;
+  }
   switch (value.toLowerCase()) {
     case "no-wrap":
       return Wrap.NoWrap;
@@ -6254,8 +6205,9 @@ function getTreeSitterClient() {
   });
 }
 // src/zig.ts
-import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
+import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/buffer.ts
 import { toArrayBuffer } from "bun:ffi";
@@ -6411,9 +6363,13 @@ class OptimizedBuffer {
     this._destroyed = true;
     this.lib.destroyOptimizedBuffer(this.bufferPtr);
   }
-  drawTextBuffer(textBuffer, x, y, clipRect) {
+  drawTextBuffer(textBufferView, x, y) {
+    this.guard();
+    this.lib.bufferDrawTextBufferView(this.bufferPtr, textBufferView.ptr, x, y);
+  }
+  drawEditorView(editorView, x, y) {
     this.guard();
-    this.lib.bufferDrawTextBuffer(this.bufferPtr, textBuffer.ptr, x, y, clipRect);
+    this.lib.bufferDrawEditorView(this.bufferPtr, editorView.ptr, x, y);
   }
   drawSuperSampleBuffer(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
     this.guard();
@@ -6453,6 +6409,624 @@ class OptimizedBuffer {
   }
 }
 
+// ../../node_modules/.bun/bun-ffi-structs@0.1.0+ca84541ac88a3075/node_modules/bun-ffi-structs/index.js
+import { ptr, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
+function fatalError(...args) {
+  const message = args.join(" ");
+  console.error("FATAL ERROR:", message);
+  throw new Error(message);
+}
+var pointerSize = process.arch === "x64" || process.arch === "arm64" ? 8 : 4;
+var typeSizes = {
+  u8: 1,
+  bool_u8: 1,
+  bool_u32: 4,
+  u16: 2,
+  i16: 2,
+  u32: 4,
+  u64: 8,
+  f32: 4,
+  f64: 8,
+  pointer: pointerSize,
+  i32: 4
+};
+var primitiveKeys = Object.keys(typeSizes);
+function isPrimitiveType(type) {
+  return typeof type === "string" && primitiveKeys.includes(type);
+}
+var typeAlignments = { ...typeSizes };
+var typeGetters = {
+  u8: (view, offset) => view.getUint8(offset),
+  bool_u8: (view, offset) => Boolean(view.getUint8(offset)),
+  bool_u32: (view, offset) => Boolean(view.getUint32(offset, true)),
+  u16: (view, offset) => view.getUint16(offset, true),
+  i16: (view, offset) => view.getInt16(offset, true),
+  u32: (view, offset) => view.getUint32(offset, true),
+  u64: (view, offset) => view.getBigUint64(offset, true),
+  f32: (view, offset) => view.getFloat32(offset, true),
+  f64: (view, offset) => view.getFloat64(offset, true),
+  i32: (view, offset) => view.getInt32(offset, true),
+  pointer: (view, offset) => pointerSize === 8 ? view.getBigUint64(offset, true) : BigInt(view.getUint32(offset, true))
+};
+function isObjectPointerDef(type) {
+  return typeof type === "object" && type !== null && type.__type === "objectPointer";
+}
+function alignOffset(offset, align) {
+  return offset + (align - 1) & ~(align - 1);
+}
+function isEnum(type) {
+  return typeof type === "object" && type.__type === "enum";
+}
+function isStruct(type) {
+  return typeof type === "object" && type.__type === "struct";
+}
+function primitivePackers(type) {
+  let pack;
+  let unpack;
+  switch (type) {
+    case "u8":
+      pack = (view, off, val) => view.setUint8(off, val);
+      unpack = (view, off) => view.getUint8(off);
+      break;
+    case "bool_u8":
+      pack = (view, off, val) => view.setUint8(off, val ? 1 : 0);
+      unpack = (view, off) => Boolean(view.getUint8(off));
+      break;
+    case "bool_u32":
+      pack = (view, off, val) => view.setUint32(off, val ? 1 : 0, true);
+      unpack = (view, off) => Boolean(view.getUint32(off, true));
+      break;
+    case "u16":
+      pack = (view, off, val) => view.setUint16(off, val, true);
+      unpack = (view, off) => view.getUint16(off, true);
+      break;
+    case "i16":
+      pack = (view, off, val) => view.setInt16(off, val, true);
+      unpack = (view, off) => view.getInt16(off, true);
+      break;
+    case "u32":
+      pack = (view, off, val) => view.setUint32(off, val, true);
+      unpack = (view, off) => view.getUint32(off, true);
+      break;
+    case "i32":
+      pack = (view, off, val) => view.setInt32(off, val, true);
+      unpack = (view, off) => view.getInt32(off, true);
+      break;
+    case "u64":
+      pack = (view, off, val) => view.setBigUint64(off, BigInt(val), true);
+      unpack = (view, off) => view.getBigUint64(off, true);
+      break;
+    case "f32":
+      pack = (view, off, val) => view.setFloat32(off, val, true);
+      unpack = (view, off) => view.getFloat32(off, true);
+      break;
+    case "f64":
+      pack = (view, off, val) => view.setFloat64(off, val, true);
+      unpack = (view, off) => view.getFloat64(off, true);
+      break;
+    case "pointer":
+      pack = (view, off, val) => {
+        pointerSize === 8 ? view.setBigUint64(off, val ? BigInt(val) : 0n, true) : view.setUint32(off, val ? Number(val) : 0, true);
+      };
+      unpack = (view, off) => {
+        const bint = pointerSize === 8 ? view.getBigUint64(off, true) : BigInt(view.getUint32(off, true));
+        return Number(bint);
+      };
+      break;
+    default:
+      fatalError(`Unsupported primitive type: ${type}`);
+  }
+  return { pack, unpack };
+}
+var { pack: pointerPacker, unpack: pointerUnpacker } = primitivePackers("pointer");
+function packObjectArray(val) {
+  const buffer = new ArrayBuffer(val.length * pointerSize);
+  const bufferView = new DataView(buffer);
+  for (let i = 0;i < val.length; i++) {
+    const instance = val[i];
+    const ptrValue = instance?.ptr ?? null;
+    pointerPacker(bufferView, i * pointerSize, ptrValue);
+  }
+  return bufferView;
+}
+var encoder = new TextEncoder;
+function defineStruct(fields, structDefOptions) {
+  let offset = 0;
+  let maxAlign = 1;
+  const layout = [];
+  const lengthOfFields = {};
+  const lengthOfRequested = [];
+  const arrayFieldsMetadata = {};
+  for (const [name, typeOrStruct, options = {}] of fields) {
+    if (options.condition && !options.condition()) {
+      continue;
+    }
+    let size = 0, align = 0;
+    let pack;
+    let unpack;
+    let needsLengthOf = false;
+    let lengthOfDef = null;
+    if (isPrimitiveType(typeOrStruct)) {
+      size = typeSizes[typeOrStruct];
+      align = typeAlignments[typeOrStruct];
+      ({ pack, unpack } = primitivePackers(typeOrStruct));
+    } else if (typeof typeOrStruct === "string" && typeOrStruct === "cstring") {
+      size = pointerSize;
+      align = pointerSize;
+      pack = (view, off, val) => {
+        const bufPtr = val ? ptr(encoder.encode(val + "\x00")) : null;
+        pointerPacker(view, off, bufPtr);
+      };
+      unpack = (view, off) => {
+        const ptrVal = pointerUnpacker(view, off);
+        return ptrVal;
+      };
+    } else if (typeof typeOrStruct === "string" && typeOrStruct === "char*") {
+      size = pointerSize;
+      align = pointerSize;
+      pack = (view, off, val) => {
+        const bufPtr = val ? ptr(encoder.encode(val)) : null;
+        pointerPacker(view, off, bufPtr);
+      };
+      unpack = (view, off) => {
+        const ptrVal = pointerUnpacker(view, off);
+        return ptrVal;
+      };
+    } else if (isEnum(typeOrStruct)) {
+      const base = typeOrStruct.type;
+      size = typeSizes[base];
+      align = typeAlignments[base];
+      const { pack: packEnum } = primitivePackers(base);
+      pack = (view, off, val) => {
+        const num = typeOrStruct.to(val);
+        packEnum(view, off, num);
+      };
+      unpack = (view, off) => {
+        const raw = typeGetters[base](view, off);
+        return typeOrStruct.from(raw);
+      };
+    } else if (isStruct(typeOrStruct)) {
+      if (options.asPointer === true) {
+        size = pointerSize;
+        align = pointerSize;
+        pack = (view, off, val, obj, options2) => {
+          if (!val) {
+            pointerPacker(view, off, null);
+            return;
+          }
+          const nestedBuf = typeOrStruct.pack(val, options2);
+          pointerPacker(view, off, ptr(nestedBuf));
+        };
+        unpack = (view, off) => {
+          throw new Error("Not implemented yet");
+        };
+      } else {
+        size = typeOrStruct.size;
+        align = typeOrStruct.align;
+        pack = (view, off, val, obj, options2) => {
+          const nestedBuf = typeOrStruct.pack(val, options2);
+          const nestedView = new Uint8Array(nestedBuf);
+          const dView = new Uint8Array(view.buffer);
+          dView.set(nestedView, off);
+        };
+        unpack = (view, off) => {
+          const slice = view.buffer.slice(off, off + size);
+          return typeOrStruct.unpack(slice);
+        };
+      }
+    } else if (isObjectPointerDef(typeOrStruct)) {
+      size = pointerSize;
+      align = pointerSize;
+      pack = (view, off, value) => {
+        const ptrValue = value?.ptr ?? null;
+        if (ptrValue === undefined) {
+          console.warn(`Field '${name}' expected object with '.ptr' property, but got undefined pointer value from:`, value);
+          pointerPacker(view, off, null);
+        } else {
+          pointerPacker(view, off, ptrValue);
+        }
+      };
+      unpack = (view, off) => {
+        return pointerUnpacker(view, off);
+      };
+    } else if (Array.isArray(typeOrStruct) && typeOrStruct.length === 1 && typeOrStruct[0] !== undefined) {
+      const [def] = typeOrStruct;
+      size = pointerSize;
+      align = pointerSize;
+      let arrayElementSize;
+      if (isEnum(def)) {
+        arrayElementSize = typeSizes[def.type];
+        pack = (view, off, val, obj) => {
+          if (!val || val.length === 0) {
+            pointerPacker(view, off, null);
+            return;
+          }
+          const buffer = new ArrayBuffer(val.length * arrayElementSize);
+          const bufferView = new DataView(buffer);
+          for (let i = 0;i < val.length; i++) {
+            const num = def.to(val[i]);
+            bufferView.setUint32(i * arrayElementSize, num, true);
+          }
+          pointerPacker(view, off, ptr(buffer));
+        };
+        unpack = null;
+        needsLengthOf = true;
+        lengthOfDef = def;
+      } else if (isStruct(def)) {
+        arrayElementSize = def.size;
+        pack = (view, off, val, obj, options2) => {
+          if (!val || val.length === 0) {
+            pointerPacker(view, off, null);
+            return;
+          }
+          const buffer = new ArrayBuffer(val.length * arrayElementSize);
+          const bufferView = new DataView(buffer);
+          for (let i = 0;i < val.length; i++) {
+            def.packInto(val[i], bufferView, i * arrayElementSize, options2);
+          }
+          pointerPacker(view, off, ptr(buffer));
+        };
+        unpack = (view, off) => {
+          throw new Error("Not implemented yet");
+        };
+      } else if (isPrimitiveType(def)) {
+        arrayElementSize = typeSizes[def];
+        const { pack: primitivePack } = primitivePackers(def);
+        pack = (view, off, val) => {
+          if (!val || val.length === 0) {
+            pointerPacker(view, off, null);
+            return;
+          }
+          const buffer = new ArrayBuffer(val.length * arrayElementSize);
+          const bufferView = new DataView(buffer);
+          for (let i = 0;i < val.length; i++) {
+            primitivePack(bufferView, i * arrayElementSize, val[i]);
+          }
+          pointerPacker(view, off, ptr(buffer));
+        };
+        unpack = null;
+        needsLengthOf = true;
+        lengthOfDef = def;
+      } else if (isObjectPointerDef(def)) {
+        arrayElementSize = pointerSize;
+        pack = (view, off, val) => {
+          if (!val || val.length === 0) {
+            pointerPacker(view, off, null);
+            return;
+          }
+          const packedView = packObjectArray(val);
+          pointerPacker(view, off, ptr(packedView.buffer));
+        };
+        unpack = () => {
+          throw new Error("not implemented yet");
+        };
+      } else {
+        throw new Error(`Unsupported array element type for ${name}: ${JSON.stringify(def)}`);
+      }
+      const lengthOfField = Object.values(lengthOfFields).find((f) => f.lengthOf === name);
+      if (lengthOfField && isPrimitiveType(lengthOfField.type)) {
+        const { pack: lengthPack } = primitivePackers(lengthOfField.type);
+        arrayFieldsMetadata[name] = {
+          elementSize: arrayElementSize,
+          arrayOffset: offset,
+          lengthOffset: lengthOfField.offset,
+          lengthPack
+        };
+      }
+    } else {
+      throw new Error(`Unsupported field type for ${name}: ${JSON.stringify(typeOrStruct)}`);
+    }
+    offset = alignOffset(offset, align);
+    if (options.unpackTransform) {
+      const originalUnpack = unpack;
+      unpack = (view, off) => options.unpackTransform(originalUnpack(view, off));
+    }
+    if (options.packTransform) {
+      const originalPack = pack;
+      pack = (view, off, val, obj, packOptions) => originalPack(view, off, options.packTransform(val), obj, packOptions);
+    }
+    if (options.optional) {
+      const originalPack = pack;
+      if (isStruct(typeOrStruct) && !options.asPointer) {
+        pack = (view, off, val, obj, packOptions) => {
+          if (val || options.mapOptionalInline) {
+            originalPack(view, off, val, obj, packOptions);
+          }
+        };
+      } else {
+        pack = (view, off, val, obj, packOptions) => originalPack(view, off, val ?? 0, obj, packOptions);
+      }
+    }
+    if (options.lengthOf) {
+      const originalPack = pack;
+      pack = (view, off, val, obj, packOptions) => {
+        const targetValue = obj[options.lengthOf];
+        let length = 0;
+        if (targetValue) {
+          if (typeof targetValue === "string") {
+            length = Buffer.byteLength(targetValue);
+          } else {
+            length = targetValue.length;
+          }
+        }
+        return originalPack(view, off, length, obj, packOptions);
+      };
+    }
+    let validateFunctions;
+    if (options.validate) {
+      validateFunctions = Array.isArray(options.validate) ? options.validate : [options.validate];
+    }
+    const layoutField = {
+      name,
+      offset,
+      size,
+      align,
+      validate: validateFunctions,
+      optional: !!options.optional || !!options.lengthOf || options.default !== undefined,
+      default: options.default,
+      pack,
+      unpack,
+      type: typeOrStruct,
+      lengthOf: options.lengthOf
+    };
+    layout.push(layoutField);
+    if (options.lengthOf) {
+      lengthOfFields[options.lengthOf] = layoutField;
+    }
+    if (needsLengthOf) {
+      if (!lengthOfDef)
+        fatalError(`Internal error: needsLengthOf=true but lengthOfDef is null for ${name}`);
+      lengthOfRequested.push({ requester: layoutField, def: lengthOfDef });
+    }
+    offset += size;
+    maxAlign = Math.max(maxAlign, align);
+  }
+  for (const { requester, def } of lengthOfRequested) {
+    const lengthOfField = lengthOfFields[requester.name];
+    if (!lengthOfField) {
+      throw new Error(`lengthOf field not found for array field ${requester.name}`);
+    }
+    if (isPrimitiveType(def)) {
+      const elemSize = typeSizes[def];
+      const { unpack: primitiveUnpack } = primitivePackers(def);
+      requester.unpack = (view, off) => {
+        const result = [];
+        const length = lengthOfField.unpack(view, lengthOfField.offset);
+        const ptrAddress = pointerUnpacker(view, off);
+        if (ptrAddress === 0n && length > 0) {
+          throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
+        }
+        if (ptrAddress === 0n || length === 0) {
+          return [];
+        }
+        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
+        const bufferView = new DataView(buffer);
+        for (let i = 0;i < length; i++) {
+          result.push(primitiveUnpack(bufferView, i * elemSize));
+        }
+        return result;
+      };
+    } else {
+      const elemSize = def.type === "u32" ? 4 : 8;
+      requester.unpack = (view, off) => {
+        const result = [];
+        const length = lengthOfField.unpack(view, lengthOfField.offset);
+        const ptrAddress = pointerUnpacker(view, off);
+        if (ptrAddress === 0n && length > 0) {
+          throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
+        }
+        if (ptrAddress === 0n || length === 0) {
+          return [];
+        }
+        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
+        const bufferView = new DataView(buffer);
+        for (let i = 0;i < length; i++) {
+          result.push(def.from(bufferView.getUint32(i * elemSize, true)));
+        }
+        return result;
+      };
+    }
+  }
+  const totalSize = alignOffset(offset, maxAlign);
+  const description = layout.map((f) => ({
+    name: f.name,
+    offset: f.offset,
+    size: f.size,
+    align: f.align,
+    optional: f.optional,
+    type: f.type,
+    lengthOf: f.lengthOf
+  }));
+  const layoutByName = new Map(description.map((f) => [f.name, f]));
+  const arrayFields = new Map(Object.entries(arrayFieldsMetadata));
+  return {
+    __type: "struct",
+    size: totalSize,
+    align: maxAlign,
+    hasMapValue: !!structDefOptions?.mapValue,
+    layoutByName,
+    arrayFields,
+    pack(obj, options) {
+      const buf = new ArrayBuffer(totalSize);
+      const view = new DataView(buf);
+      let mappedObj = obj;
+      if (structDefOptions?.mapValue) {
+        mappedObj = structDefOptions.mapValue(obj);
+      }
+      for (const field of layout) {
+        const value = mappedObj[field.name] ?? field.default;
+        if (!field.optional && value === undefined) {
+          fatalError(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`);
+        }
+        if (field.validate) {
+          for (const validateFn of field.validate) {
+            validateFn(value, field.name, {
+              hints: options?.validationHints,
+              input: mappedObj
+            });
+          }
+        }
+        field.pack(view, field.offset, value, mappedObj, options);
+      }
+      return view.buffer;
+    },
+    packInto(obj, view, offset2, options) {
+      let mappedObj = obj;
+      if (structDefOptions?.mapValue) {
+        mappedObj = structDefOptions.mapValue(obj);
+      }
+      for (const field of layout) {
+        const value = mappedObj[field.name] ?? field.default;
+        if (!field.optional && value === undefined) {
+          console.warn(`packInto missing value for non-optional field '${field.name}' at offset ${offset2 + field.offset}. Writing default or zero.`);
+        }
+        if (field.validate) {
+          for (const validateFn of field.validate) {
+            validateFn(value, field.name, {
+              hints: options?.validationHints,
+              input: mappedObj
+            });
+          }
+        }
+        field.pack(view, offset2 + field.offset, value, mappedObj, options);
+      }
+    },
+    unpack(buf) {
+      if (buf.byteLength < totalSize) {
+        fatalError(`Buffer size (${buf.byteLength}) is smaller than struct size (${totalSize}) for unpacking.`);
+      }
+      const view = new DataView(buf);
+      const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
+      for (const field of layout) {
+        if (!field.unpack) {
+          continue;
+        }
+        try {
+          result[field.name] = field.unpack(view, field.offset);
+        } catch (e) {
+          console.error(`Error unpacking field '${field.name}' at offset ${field.offset}:`, e);
+          throw e;
+        }
+      }
+      if (structDefOptions?.reduceValue) {
+        return structDefOptions.reduceValue(result);
+      }
+      return result;
+    },
+    packList(objects, options) {
+      if (objects.length === 0) {
+        return new ArrayBuffer(0);
+      }
+      const buffer = new ArrayBuffer(totalSize * objects.length);
+      const view = new DataView(buffer);
+      for (let i = 0;i < objects.length; i++) {
+        let mappedObj = objects[i];
+        if (structDefOptions?.mapValue) {
+          mappedObj = structDefOptions.mapValue(objects[i]);
+        }
+        for (const field of layout) {
+          const value = mappedObj[field.name] ?? field.default;
+          if (!field.optional && value === undefined) {
+            fatalError(`Packing non-optional field '${field.name}' at index ${i} but value is undefined (and no default provided)`);
+          }
+          if (field.validate) {
+            for (const validateFn of field.validate) {
+              validateFn(value, field.name, {
+                hints: options?.validationHints,
+                input: mappedObj
+              });
+            }
+          }
+          field.pack(view, i * totalSize + field.offset, value, mappedObj, options);
+        }
+      }
+      return buffer;
+    },
+    unpackList(buf, count) {
+      if (count === 0) {
+        return [];
+      }
+      const expectedSize = totalSize * count;
+      if (buf.byteLength < expectedSize) {
+        fatalError(`Buffer size (${buf.byteLength}) is smaller than expected size (${expectedSize}) for unpacking ${count} structs.`);
+      }
+      const view = new DataView(buf);
+      const results = [];
+      for (let i = 0;i < count; i++) {
+        const offset2 = i * totalSize;
+        const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
+        for (const field of layout) {
+          if (!field.unpack) {
+            continue;
+          }
+          try {
+            result[field.name] = field.unpack(view, offset2 + field.offset);
+          } catch (e) {
+            console.error(`Error unpacking field '${field.name}' at index ${i}, offset ${offset2 + field.offset}:`, e);
+            throw e;
+          }
+        }
+        if (structDefOptions?.reduceValue) {
+          results.push(structDefOptions.reduceValue(result));
+        } else {
+          results.push(result);
+        }
+      }
+      return results;
+    },
+    describe() {
+      return description;
+    }
+  };
+}
+
+// src/zig-structs.ts
+import { ptr as ptr2, toArrayBuffer as toArrayBuffer3 } from "bun:ffi";
+var rgbaPackTransform = (rgba) => rgba ? ptr2(rgba.buffer) : null;
+var rgbaUnpackTransform = (ptr3) => ptr3 ? RGBA.fromArray(new Float32Array(toArrayBuffer3(ptr3))) : undefined;
+var StyledChunkStruct = defineStruct([
+  ["text", "char*"],
+  ["text_len", "u64", { lengthOf: "text" }],
+  [
+    "fg",
+    "pointer",
+    {
+      optional: true,
+      packTransform: rgbaPackTransform,
+      unpackTransform: rgbaUnpackTransform
+    }
+  ],
+  [
+    "bg",
+    "pointer",
+    {
+      optional: true,
+      packTransform: rgbaPackTransform,
+      unpackTransform: rgbaUnpackTransform
+    }
+  ],
+  ["attributes", "u8", { optional: true }]
+]);
+var HighlightStruct = defineStruct([
+  ["start", "u32"],
+  ["end", "u32"],
+  ["styleId", "u32"],
+  ["priority", "u8", { default: 0 }],
+  ["hlRef", "u16", { default: 0 }]
+]);
+var LogicalCursorStruct = defineStruct([
+  ["row", "u32"],
+  ["col", "u32"],
+  ["offset", "u32"]
+]);
+var VisualCursorStruct = defineStruct([
+  ["visualRow", "u32"],
+  ["visualCol", "u32"],
+  ["logicalRow", "u32"],
+  ["logicalCol", "u32"],
+  ["offset", "u32"]
+]);
+
 // src/zig.ts
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
 var targetLibPath = module.default;
@@ -6481,6 +7055,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    setEventCallback: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createRenderer: {
       args: ["u32", "u32", "bool"],
       returns: "ptr"
@@ -6709,15 +7287,15 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "u32"
     },
-    textBufferReset: {
+    textBufferGetByteSize: {
       args: ["ptr"],
-      returns: "void"
+      returns: "u32"
     },
-    textBufferSetSelection: {
-      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+    textBufferReset: {
+      args: ["ptr"],
       returns: "void"
     },
-    textBufferResetSelection: {
+    textBufferClear: {
       args: ["ptr"],
       returns: "void"
     },
@@ -6737,76 +7315,400 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
-    textBufferWriteChunk: {
-      args: ["ptr", "ptr", "u32", "ptr", "ptr", "ptr"],
-      returns: "u32"
+    textBufferRegisterMemBuffer: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "u16"
     },
-    textBufferFinalizeLineInfo: {
-      args: ["ptr"],
-      returns: "void"
+    textBufferReplaceMemBuffer: {
+      args: ["ptr", "u8", "ptr", "usize", "bool"],
+      returns: "bool"
     },
-    textBufferGetLineCount: {
+    textBufferClearMemRegistry: {
       args: ["ptr"],
-      returns: "u32"
+      returns: "void"
     },
-    textBufferGetLineInfoDirect: {
-      args: ["ptr", "ptr", "ptr"],
-      returns: "u32"
+    textBufferSetTextFromMem: {
+      args: ["ptr", "u8"],
+      returns: "void"
     },
-    textBufferGetSelectionInfo: {
-      args: ["ptr"],
-      returns: "u64"
+    textBufferLoadFile: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "bool"
     },
-    textBufferGetSelectedText: {
+    textBufferSetStyledText: {
       args: ["ptr", "ptr", "usize"],
-      returns: "usize"
+      returns: "void"
+    },
+    textBufferGetLineCount: {
+      args: ["ptr"],
+      returns: "u32"
     },
     textBufferGetPlainText: {
       args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
-    textBufferSetLocalSelection: {
-      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
-      returns: "bool"
+    textBufferAddHighlightByCharRange: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferAddHighlight: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "void"
+    },
+    textBufferRemoveHighlightsByRef: {
+      args: ["ptr", "u16"],
+      returns: "void"
+    },
+    textBufferClearLineHighlights: {
+      args: ["ptr", "u32"],
+      returns: "void"
     },
-    textBufferResetLocalSelection: {
+    textBufferClearAllHighlights: {
       args: ["ptr"],
       returns: "void"
     },
-    textBufferInsertChunkGroup: {
-      args: ["ptr", "usize", "ptr", "u32", "ptr", "ptr", "u8"],
-      returns: "u32"
+    textBufferSetSyntaxStyle: {
+      args: ["ptr", "ptr"],
+      returns: "void"
     },
-    textBufferRemoveChunkGroup: {
+    textBufferGetLineHighlightsPtr: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "ptr"
+    },
+    textBufferFreeLineHighlights: {
       args: ["ptr", "usize"],
-      returns: "u32"
+      returns: "void"
     },
-    textBufferReplaceChunkGroup: {
-      args: ["ptr", "usize", "ptr", "u32", "ptr", "ptr", "u8"],
-      returns: "u32"
+    createTextBufferView: {
+      args: ["ptr"],
+      returns: "ptr"
     },
-    textBufferGetChunkGroupCount: {
+    destroyTextBufferView: {
       args: ["ptr"],
-      returns: "usize"
+      returns: "void"
+    },
+    textBufferViewSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
     },
-    textBufferSetWrapWidth: {
+    textBufferViewResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewGetSelectionInfo: {
+      args: ["ptr"],
+      returns: "u64"
+    },
+    textBufferViewSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    textBufferViewResetLocalSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewSetWrapWidth: {
       args: ["ptr", "u32"],
       returns: "void"
     },
-    textBufferSetWrapMode: {
+    textBufferViewSetWrapMode: {
       args: ["ptr", "u8"],
       returns: "void"
     },
-    getArenaAllocatedBytes: {
-      args: [],
+    textBufferViewSetViewportSize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    textBufferViewGetVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferViewGetLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
+    textBufferViewGetLogicalLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
+    textBufferViewGetSelectedText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferViewGetPlainText: {
+      args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
-    bufferDrawTextBuffer: {
-      args: ["ptr", "ptr", "i32", "i32", "i32", "i32", "u32", "u32", "bool"],
+    bufferDrawTextBufferView: {
+      args: ["ptr", "ptr", "i32", "i32"],
       returns: "void"
     },
-    getTerminalCapabilities: {
-      args: ["ptr", "ptr"],
+    bufferDrawEditorView: {
+      args: ["ptr", "ptr", "i32", "i32"],
+      returns: "void"
+    },
+    createEditorView: {
+      args: ["ptr", "u32", "u32"],
+      returns: "ptr"
+    },
+    destroyEditorView: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewSetViewportSize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editorViewGetViewport: {
+      args: ["ptr", "ptr", "ptr", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetScrollMargin: {
+      args: ["ptr", "f32"],
+      returns: "void"
+    },
+    editorViewSetWrapMode: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    editorViewGetVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    editorViewGetTotalVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    editorViewGetTextBufferView: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    createEditBuffer: {
+      args: ["u8"],
+      returns: "ptr"
+    },
+    destroyEditBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferSetText: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "void"
+    },
+    editBufferSetTextFromMem: {
+      args: ["ptr", "u8", "bool"],
+      returns: "void"
+    },
+    editBufferGetText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferInsertChar: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferInsertText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferDeleteChar: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteCharBackward: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteRange: {
+      args: ["ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferNewLine: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteLine: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorLeft: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorRight: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorUp: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorDown: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferGotoLine: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursor: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursorToLineCol: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursorByOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editBufferGetCursorPosition: {
+      args: ["ptr", "ptr", "ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetId: {
+      args: ["ptr"],
+      returns: "u16"
+    },
+    editBufferGetTextBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    editBufferDebugLogRope: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferUndo: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferRedo: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferCanUndo: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    editBufferCanRedo: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    editBufferClearHistory: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferSetPlaceholder: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferSetPlaceholderColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetNextWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewGetSelection: {
+      args: ["ptr"],
+      returns: "u64"
+    },
+    editorViewSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    editorViewResetLocalSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewGetSelectedTextBytes: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editorViewGetCursor: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editorViewGetVisualCursor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewMoveUpVisual: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewMoveDownVisual: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewDeleteSelectedText: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewSetCursorByOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editorViewGetNextWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    getArenaAllocatedBytes: {
+      args: [],
+      returns: "usize"
+    },
+    createSyntaxStyle: {
+      args: [],
+      returns: "ptr"
+    },
+    destroySyntaxStyle: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    syntaxStyleRegister: {
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u8"],
+      returns: "u32"
+    },
+    syntaxStyleResolveByName: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "u32"
+    },
+    syntaxStyleGetStyleCount: {
+      args: ["ptr"],
+      returns: "usize"
+    },
+    getTerminalCapabilities: {
+      args: ["ptr", "ptr"],
       returns: "void"
     },
     processCapabilityResponse: {
@@ -6937,9 +7839,13 @@ class FFIRenderLib {
   encoder = new TextEncoder;
   decoder = new TextDecoder;
   logCallbackWrapper;
+  eventCallbackWrapper;
+  _nativeEvents = new EventEmitter4;
+  _anyEventHandlers = [];
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.setupLogging();
+    this.setupEventBus();
   }
   setupLogging() {
     if (this.logCallbackWrapper) {
@@ -6951,7 +7857,7 @@ class FFIRenderLib {
         if (msgLen === 0 || !msgPtr) {
           return;
         }
-        const msgBuffer = toArrayBuffer2(msgPtr, 0, msgLen);
+        const msgBuffer = toArrayBuffer4(msgPtr, 0, msgLen);
         const msgBytes = new Uint8Array(msgBuffer);
         const message = this.decoder.decode(msgBytes);
         switch (level) {
@@ -6986,6 +7892,48 @@ class FFIRenderLib {
   setLogCallback(callbackPtr) {
     this.opentui.symbols.setLogCallback(callbackPtr);
   }
+  setupEventBus() {
+    if (this.eventCallbackWrapper) {
+      return;
+    }
+    const eventCallback = new JSCallback((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
+      try {
+        const nameLen = typeof nameLenBigInt === "bigint" ? Number(nameLenBigInt) : nameLenBigInt;
+        const dataLen = typeof dataLenBigInt === "bigint" ? Number(dataLenBigInt) : dataLenBigInt;
+        if (nameLen === 0 || !namePtr) {
+          return;
+        }
+        const nameBuffer = toArrayBuffer4(namePtr, 0, nameLen);
+        const nameBytes = new Uint8Array(nameBuffer);
+        const eventName = this.decoder.decode(nameBytes);
+        let eventData;
+        if (dataLen > 0 && dataPtr) {
+          eventData = toArrayBuffer4(dataPtr, 0, dataLen).slice();
+        } else {
+          eventData = new ArrayBuffer(0);
+        }
+        queueMicrotask(() => {
+          this._nativeEvents.emit(eventName, eventData);
+          for (const handler of this._anyEventHandlers) {
+            handler(eventName, eventData);
+          }
+        });
+      } catch (error) {
+        console.error("Error in native event callback:", error);
+      }
+    }, {
+      args: ["ptr", "usize", "ptr", "usize"],
+      returns: "void"
+    });
+    this.eventCallbackWrapper = eventCallback;
+    if (!eventCallback.ptr) {
+      throw new Error("Failed to create event callback");
+    }
+    this.setEventCallback(eventCallback.ptr);
+  }
+  setEventCallback(callbackPtr) {
+    this.opentui.symbols.setEventCallback(callbackPtr);
+  }
   createRenderer(width, height, options = { testing: false }) {
     return this.opentui.symbols.createRenderer(width, height, options.testing);
   }
@@ -7026,32 +7974,32 @@ class FFIRenderLib {
     return new OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer" });
   }
   bufferGetCharPtr(buffer) {
-    const ptr2 = this.opentui.symbols.bufferGetCharPtr(buffer);
-    if (!ptr2) {
+    const ptr4 = this.opentui.symbols.bufferGetCharPtr(buffer);
+    if (!ptr4) {
       throw new Error("Failed to get char pointer");
     }
-    return ptr2;
+    return ptr4;
   }
   bufferGetFgPtr(buffer) {
-    const ptr2 = this.opentui.symbols.bufferGetFgPtr(buffer);
-    if (!ptr2) {
+    const ptr4 = this.opentui.symbols.bufferGetFgPtr(buffer);
+    if (!ptr4) {
       throw new Error("Failed to get fg pointer");
     }
-    return ptr2;
+    return ptr4;
   }
   bufferGetBgPtr(buffer) {
-    const ptr2 = this.opentui.symbols.bufferGetBgPtr(buffer);
-    if (!ptr2) {
+    const ptr4 = this.opentui.symbols.bufferGetBgPtr(buffer);
+    if (!ptr4) {
       throw new Error("Failed to get bg pointer");
     }
-    return ptr2;
+    return ptr4;
   }
   bufferGetAttributesPtr(buffer) {
-    const ptr2 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
-    if (!ptr2) {
+    const ptr4 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
+    if (!ptr4) {
       throw new Error("Failed to get attributes pointer");
     }
-    return ptr2;
+    return ptr4;
   }
   bufferGetRespectAlpha(buffer) {
     return this.opentui.symbols.bufferGetRespectAlpha(buffer);
@@ -7219,16 +8167,14 @@ class FFIRenderLib {
   textBufferGetLength(buffer) {
     return this.opentui.symbols.textBufferGetLength(buffer);
   }
+  textBufferGetByteSize(buffer) {
+    return this.opentui.symbols.textBufferGetByteSize(buffer);
+  }
   textBufferReset(buffer) {
     this.opentui.symbols.textBufferReset(buffer);
   }
-  textBufferSetSelection(buffer, start, end, bgColor, fgColor) {
-    const bg2 = bgColor ? bgColor.buffer : null;
-    const fg2 = fgColor ? fgColor.buffer : null;
-    this.opentui.symbols.textBufferSetSelection(buffer, start, end, bg2, fg2);
-  }
-  textBufferResetSelection(buffer) {
-    this.opentui.symbols.textBufferResetSelection(buffer);
+  textBufferClear(buffer) {
+    this.opentui.symbols.textBufferClear(buffer);
   }
   textBufferSetDefaultFg(buffer, fg2) {
     const fgPtr = fg2 ? fg2.buffer : null;
@@ -7245,21 +8191,70 @@ class FFIRenderLib {
   textBufferResetDefaults(buffer) {
     this.opentui.symbols.textBufferResetDefaults(buffer);
   }
-  textBufferWriteChunk(buffer, textBytes, fg2, bg2, attributes) {
-    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);
+  textBufferRegisterMemBuffer(buffer, bytes, owned = false) {
+    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, owned);
+    if (result === 65535) {
+      throw new Error("Failed to register memory buffer");
+    }
+    return result;
   }
-  textBufferFinalizeLineInfo(buffer) {
-    this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
+  textBufferReplaceMemBuffer(buffer, memId, bytes, owned = false) {
+    return this.opentui.symbols.textBufferReplaceMemBuffer(buffer, memId, bytes, bytes.length, owned);
+  }
+  textBufferClearMemRegistry(buffer) {
+    this.opentui.symbols.textBufferClearMemRegistry(buffer);
+  }
+  textBufferSetTextFromMem(buffer, memId) {
+    this.opentui.symbols.textBufferSetTextFromMem(buffer, memId);
+  }
+  textBufferLoadFile(buffer, path4) {
+    const pathBytes = this.encoder.encode(path4);
+    return this.opentui.symbols.textBufferLoadFile(buffer, pathBytes, pathBytes.length);
+  }
+  textBufferSetStyledText(buffer, chunks) {
+    const nonEmptyChunks = chunks.filter((c) => c.text.length > 0);
+    if (nonEmptyChunks.length === 0) {
+      this.textBufferClear(buffer);
+      return;
+    }
+    const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
+    this.opentui.symbols.textBufferSetStyledText(buffer, ptr3(chunksBuffer), nonEmptyChunks.length);
   }
   textBufferGetLineCount(buffer) {
     return this.opentui.symbols.textBufferGetLineCount(buffer);
   }
-  textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr) {
-    return this.opentui.symbols.textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr);
+  textBufferGetPlainText(buffer, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
   }
-  textBufferGetSelection(buffer) {
-    const packedInfo = this.textBufferGetSelectionInfo(buffer);
+  getPlainTextBytes(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferGetPlainText(buffer, ptr3(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  createTextBufferView(textBuffer) {
+    const viewPtr = this.opentui.symbols.createTextBufferView(textBuffer);
+    if (!viewPtr) {
+      throw new Error("Failed to create TextBufferView");
+    }
+    return viewPtr;
+  }
+  destroyTextBufferView(view) {
+    this.opentui.symbols.destroyTextBufferView(view);
+  }
+  textBufferViewSetSelection(view, start, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.textBufferViewSetSelection(view, start, end, bg2, fg2);
+  }
+  textBufferViewResetSelection(view) {
+    this.opentui.symbols.textBufferViewResetSelection(view);
+  }
+  textBufferViewGetSelection(view) {
+    const packedInfo = this.textBufferViewGetSelectionInfo(view);
     if (packedInfo === 0xffff_ffff_ffff_ffffn) {
       return null;
     }
@@ -7267,92 +8262,401 @@ class FFIRenderLib {
     const end = Number(packedInfo & 0xffff_ffffn);
     return { start, end };
   }
-  textBufferGetSelectionInfo(buffer) {
-    return this.opentui.symbols.textBufferGetSelectionInfo(buffer);
+  textBufferViewGetSelectionInfo(view) {
+    return this.opentui.symbols.textBufferViewGetSelectionInfo(view);
+  }
+  textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  }
+  textBufferViewResetLocalSelection(view) {
+    this.opentui.symbols.textBufferViewResetLocalSelection(view);
+  }
+  textBufferViewSetWrapWidth(view, width) {
+    this.opentui.symbols.textBufferViewSetWrapWidth(view, width);
+  }
+  textBufferViewSetWrapMode(view, mode) {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
+    this.opentui.symbols.textBufferViewSetWrapMode(view, modeValue);
+  }
+  textBufferViewSetViewportSize(view, width, height) {
+    this.opentui.symbols.textBufferViewSetViewportSize(view, width, height);
+  }
+  textBufferViewGetLineInfo(view) {
+    const lineCount = this.textBufferViewGetLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.textBufferViewGetLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
+  textBufferViewGetLogicalLineInfo(view) {
+    const lineCount = this.textBufferViewGetLineCount(view);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+    }
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    const maxLineWidth = this.textBufferViewGetLogicalLineInfoDirect(view, ptr3(lineStarts), ptr3(lineWidths));
+    return {
+      maxLineWidth,
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
+  }
+  textBufferViewGetLineCount(view) {
+    return this.opentui.symbols.textBufferViewGetVirtualLineCount(view);
+  }
+  textBufferViewGetLineInfoDirect(view, lineStartsPtr, lineWidthsPtr) {
+    return this.opentui.symbols.textBufferViewGetLineInfoDirect(view, lineStartsPtr, lineWidthsPtr);
+  }
+  textBufferViewGetLogicalLineInfoDirect(view, lineStartsPtr, lineWidthsPtr) {
+    return this.opentui.symbols.textBufferViewGetLogicalLineInfoDirect(view, lineStartsPtr, lineWidthsPtr);
   }
-  textBufferGetSelectedText(buffer, outPtr, maxLen) {
-    const result = this.opentui.symbols.textBufferGetSelectedText(buffer, outPtr, maxLen);
+  textBufferViewGetSelectedText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetSelectedText(view, outPtr, maxLen);
     return typeof result === "bigint" ? Number(result) : result;
   }
-  textBufferGetPlainText(buffer, outPtr, maxLen) {
-    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
+  textBufferViewGetPlainText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetPlainText(view, outPtr, maxLen);
     return typeof result === "bigint" ? Number(result) : result;
   }
-  getSelectedTextBytes(buffer, maxLength) {
+  textBufferViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetSelectedText(buffer, ptr(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr3(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
     return outBuffer.slice(0, actualLen);
   }
-  getPlainTextBytes(buffer, maxLength) {
+  textBufferViewGetPlainTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetPlainText(buffer, ptr(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, ptr3(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
     return outBuffer.slice(0, actualLen);
   }
-  textBufferSetLocalSelection(buffer, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
-    const bg2 = bgColor ? bgColor.buffer : null;
-    const fg2 = fgColor ? fgColor.buffer : null;
-    return this.opentui.symbols.textBufferSetLocalSelection(buffer, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  textBufferAddHighlightByCharRange(buffer, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr3(packedHighlight));
   }
-  textBufferResetLocalSelection(buffer) {
-    this.opentui.symbols.textBufferResetLocalSelection(buffer);
+  textBufferAddHighlight(buffer, lineIdx, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr3(packedHighlight));
   }
-  textBufferInsertChunkGroup(buffer, index, textBytes, fg2, bg2, attributes) {
-    const fgPtr = fg2 ? fg2.buffer : null;
-    const bgPtr = bg2 ? bg2.buffer : null;
-    const attr = attributes ?? 255;
-    return this.opentui.symbols.textBufferInsertChunkGroup(buffer, index, textBytes, textBytes.length, fgPtr, bgPtr, attr);
+  textBufferRemoveHighlightsByRef(buffer, hlRef) {
+    this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
   }
-  textBufferRemoveChunkGroup(buffer, index) {
-    return this.opentui.symbols.textBufferRemoveChunkGroup(buffer, index);
-  }
-  textBufferReplaceChunkGroup(buffer, index, textBytes, fg2, bg2, attributes) {
-    const fgPtr = fg2 ? fg2.buffer : null;
-    const bgPtr = bg2 ? bg2.buffer : null;
-    const attr = attributes ?? 255;
-    return this.opentui.symbols.textBufferReplaceChunkGroup(buffer, index, textBytes, textBytes.length, fgPtr, bgPtr, attr);
+  textBufferClearLineHighlights(buffer, lineIdx) {
+    this.opentui.symbols.textBufferClearLineHighlights(buffer, lineIdx);
   }
-  textBufferGetChunkGroupCount(buffer) {
-    const result = this.opentui.symbols.textBufferGetChunkGroupCount(buffer);
-    return typeof result === "bigint" ? Number(result) : result;
+  textBufferClearAllHighlights(buffer) {
+    this.opentui.symbols.textBufferClearAllHighlights(buffer);
   }
-  textBufferSetWrapWidth(buffer, width) {
-    this.opentui.symbols.textBufferSetWrapWidth(buffer, width);
+  textBufferSetSyntaxStyle(buffer, style) {
+    this.opentui.symbols.textBufferSetSyntaxStyle(buffer, style);
   }
-  textBufferSetWrapMode(buffer, mode) {
-    const modeValue = mode === "char" ? 0 : 1;
-    this.opentui.symbols.textBufferSetWrapMode(buffer, modeValue);
+  textBufferGetLineHighlights(buffer, lineIdx) {
+    const outCountBuf = new BigUint64Array(1);
+    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr3(outCountBuf));
+    if (!nativePtr)
+      return [];
+    const count = Number(outCountBuf[0]);
+    const byteLen = count * HighlightStruct.size;
+    const raw = toArrayBuffer4(nativePtr, 0, byteLen);
+    const results = HighlightStruct.unpackList(raw, count);
+    this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
+    return results;
   }
   getArenaAllocatedBytes() {
     const result = this.opentui.symbols.getArenaAllocatedBytes();
     return typeof result === "bigint" ? Number(result) : result;
   }
-  textBufferGetLineInfo(buffer) {
-    const lineCount = this.textBufferGetLineCount(buffer);
-    if (lineCount === 0) {
-      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
+  bufferDrawTextBufferView(buffer, view, x, y) {
+    this.opentui.symbols.bufferDrawTextBufferView(buffer, view, x, y);
+  }
+  bufferDrawEditorView(buffer, view, x, y) {
+    this.opentui.symbols.bufferDrawEditorView(buffer, view, x, y);
+  }
+  createEditorView(editBufferPtr, viewportWidth, viewportHeight) {
+    const viewPtr = this.opentui.symbols.createEditorView(editBufferPtr, viewportWidth, viewportHeight);
+    if (!viewPtr) {
+      throw new Error("Failed to create EditorView");
     }
-    const lineStarts = new Uint32Array(lineCount);
-    const lineWidths = new Uint32Array(lineCount);
-    const maxLineWidth = this.textBufferGetLineInfoDirect(buffer, ptr(lineStarts), ptr(lineWidths));
+    return viewPtr;
+  }
+  destroyEditorView(view) {
+    this.opentui.symbols.destroyEditorView(view);
+  }
+  editorViewSetViewportSize(view, width, height) {
+    this.opentui.symbols.editorViewSetViewportSize(view, width, height);
+  }
+  editorViewGetViewport(view) {
+    const x = new Uint32Array(1);
+    const y = new Uint32Array(1);
+    const width = new Uint32Array(1);
+    const height = new Uint32Array(1);
+    this.opentui.symbols.editorViewGetViewport(view, ptr3(x), ptr3(y), ptr3(width), ptr3(height));
     return {
-      maxLineWidth,
-      lineStarts: Array.from(lineStarts),
-      lineWidths: Array.from(lineWidths)
+      offsetX: x[0],
+      offsetY: y[0],
+      width: width[0],
+      height: height[0]
     };
   }
-  bufferDrawTextBuffer(buffer, textBuffer, x, y, clipRect) {
-    const hasClipRect = clipRect !== undefined && clipRect !== null;
-    const clipX = clipRect?.x ?? 0;
-    const clipY = clipRect?.y ?? 0;
-    const clipWidth = clipRect?.width ?? 0;
-    const clipHeight = clipRect?.height ?? 0;
-    this.opentui.symbols.bufferDrawTextBuffer(buffer, textBuffer, x, y, clipX, clipY, clipWidth, clipHeight, hasClipRect);
+  editorViewSetScrollMargin(view, margin) {
+    this.opentui.symbols.editorViewSetScrollMargin(view, margin);
+  }
+  editorViewSetWrapMode(view, mode) {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
+    this.opentui.symbols.editorViewSetWrapMode(view, modeValue);
+  }
+  editorViewGetVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetVirtualLineCount(view);
+  }
+  editorViewGetTotalVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetTotalVirtualLineCount(view);
+  }
+  editorViewGetTextBufferView(view) {
+    const result = this.opentui.symbols.editorViewGetTextBufferView(view);
+    if (!result) {
+      throw new Error("Failed to get TextBufferView from EditorView");
+    }
+    return result;
+  }
+  createEditBuffer(widthMethod) {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode);
+    if (!bufferPtr) {
+      throw new Error("Failed to create EditBuffer");
+    }
+    return bufferPtr;
+  }
+  destroyEditBuffer(buffer) {
+    this.opentui.symbols.destroyEditBuffer(buffer);
+  }
+  editBufferSetText(buffer, textBytes, retainHistory = true) {
+    this.opentui.symbols.editBufferSetText(buffer, textBytes, textBytes.length, retainHistory);
+  }
+  editBufferSetTextFromMem(buffer, memId, retainHistory = true) {
+    this.opentui.symbols.editBufferSetTextFromMem(buffer, memId, retainHistory);
+  }
+  editBufferGetText(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferInsertChar(buffer, char) {
+    const charBytes = this.encoder.encode(char);
+    this.opentui.symbols.editBufferInsertChar(buffer, charBytes, charBytes.length);
+  }
+  editBufferInsertText(buffer, text) {
+    const textBytes = this.encoder.encode(text);
+    this.opentui.symbols.editBufferInsertText(buffer, textBytes, textBytes.length);
+  }
+  editBufferDeleteChar(buffer) {
+    this.opentui.symbols.editBufferDeleteChar(buffer);
+  }
+  editBufferDeleteCharBackward(buffer) {
+    this.opentui.symbols.editBufferDeleteCharBackward(buffer);
+  }
+  editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol) {
+    this.opentui.symbols.editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol);
+  }
+  editBufferNewLine(buffer) {
+    this.opentui.symbols.editBufferNewLine(buffer);
+  }
+  editBufferDeleteLine(buffer) {
+    this.opentui.symbols.editBufferDeleteLine(buffer);
+  }
+  editBufferMoveCursorLeft(buffer) {
+    this.opentui.symbols.editBufferMoveCursorLeft(buffer);
+  }
+  editBufferMoveCursorRight(buffer) {
+    this.opentui.symbols.editBufferMoveCursorRight(buffer);
+  }
+  editBufferMoveCursorUp(buffer) {
+    this.opentui.symbols.editBufferMoveCursorUp(buffer);
+  }
+  editBufferMoveCursorDown(buffer) {
+    this.opentui.symbols.editBufferMoveCursorDown(buffer);
+  }
+  editBufferGotoLine(buffer, line) {
+    this.opentui.symbols.editBufferGotoLine(buffer, line);
+  }
+  editBufferSetCursor(buffer, line, byteOffset) {
+    this.opentui.symbols.editBufferSetCursor(buffer, line, byteOffset);
+  }
+  editBufferSetCursorToLineCol(buffer, line, col) {
+    this.opentui.symbols.editBufferSetCursorToLineCol(buffer, line, col);
+  }
+  editBufferSetCursorByOffset(buffer, offset) {
+    this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset);
+  }
+  editBufferGetCursorPosition(buffer) {
+    const line = new Uint32Array(1);
+    const visualColumn = new Uint32Array(1);
+    const offset = new Uint32Array(1);
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(line), ptr3(visualColumn), ptr3(offset));
+    return {
+      line: line[0],
+      visualColumn: visualColumn[0],
+      offset: offset[0]
+    };
+  }
+  editBufferGetId(buffer) {
+    return this.opentui.symbols.editBufferGetId(buffer);
+  }
+  editBufferGetTextBuffer(buffer) {
+    const result = this.opentui.symbols.editBufferGetTextBuffer(buffer);
+    if (!result) {
+      throw new Error("Failed to get TextBuffer from EditBuffer");
+    }
+    return result;
+  }
+  editBufferDebugLogRope(buffer) {
+    this.opentui.symbols.editBufferDebugLogRope(buffer);
+  }
+  editBufferUndo(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferRedo(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferCanUndo(buffer) {
+    return this.opentui.symbols.editBufferCanUndo(buffer);
+  }
+  editBufferCanRedo(buffer) {
+    return this.opentui.symbols.editBufferCanRedo(buffer);
+  }
+  editBufferClearHistory(buffer) {
+    this.opentui.symbols.editBufferClearHistory(buffer);
+  }
+  editBufferSetPlaceholder(buffer, text) {
+    if (text === null) {
+      this.opentui.symbols.editBufferSetPlaceholder(buffer, null, 0);
+    } else {
+      const textBytes = this.encoder.encode(text);
+      this.opentui.symbols.editBufferSetPlaceholder(buffer, textBytes, textBytes.length);
+    }
+  }
+  editBufferSetPlaceholderColor(buffer, color) {
+    this.opentui.symbols.editBufferSetPlaceholderColor(buffer, color.buffer);
+  }
+  editBufferGetNextWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetPrevWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetEOL(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetEOL(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewSetSelection(view, start, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.editorViewSetSelection(view, start, end, bg2, fg2);
+  }
+  editorViewResetSelection(view) {
+    this.opentui.symbols.editorViewResetSelection(view);
+  }
+  editorViewGetSelection(view) {
+    const packedInfo = this.opentui.symbols.editorViewGetSelection(view);
+    if (packedInfo === 0xffff_ffff_ffff_ffffn) {
+      return null;
+    }
+    const start = Number(packedInfo >> 32n);
+    const end = Number(packedInfo & 0xffff_ffffn);
+    return { start, end };
+  }
+  editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  }
+  editorViewResetLocalSelection(view) {
+    this.opentui.symbols.editorViewResetLocalSelection(view);
+  }
+  editorViewGetSelectedTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editorViewGetCursor(view) {
+    const row = new Uint32Array(1);
+    const col = new Uint32Array(1);
+    this.opentui.symbols.editorViewGetCursor(view, ptr3(row), ptr3(col));
+    return { row: row[0], col: col[0] };
+  }
+  editorViewGetText(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetText(view, ptr3(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0)
+      return null;
+    return outBuffer.slice(0, len);
+  }
+  editorViewGetVisualCursor(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewMoveUpVisual(view) {
+    this.opentui.symbols.editorViewMoveUpVisual(view);
+  }
+  editorViewMoveDownVisual(view) {
+    this.opentui.symbols.editorViewMoveDownVisual(view);
+  }
+  editorViewDeleteSelectedText(view) {
+    this.opentui.symbols.editorViewDeleteSelectedText(view);
+  }
+  editorViewSetCursorByOffset(view, offset) {
+    this.opentui.symbols.editorViewSetCursorByOffset(view, offset);
+  }
+  editorViewGetNextWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetPrevWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetEOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetEOL(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
   }
   bufferPushScissorRect(buffer, x, y, width, height) {
     this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height);
@@ -7388,6 +8692,43 @@ class FFIRenderLib {
     const responseBytes = this.encoder.encode(response);
     this.opentui.symbols.processCapabilityResponse(renderer, responseBytes, responseBytes.length);
   }
+  createSyntaxStyle() {
+    const stylePtr = this.opentui.symbols.createSyntaxStyle();
+    if (!stylePtr) {
+      throw new Error("Failed to create SyntaxStyle");
+    }
+    return stylePtr;
+  }
+  destroySyntaxStyle(style) {
+    this.opentui.symbols.destroySyntaxStyle(style);
+  }
+  syntaxStyleRegister(style, name, fg2, bg2, attributes) {
+    const nameBytes = this.encoder.encode(name);
+    const fgPtr = fg2 ? fg2.buffer : null;
+    const bgPtr = bg2 ? bg2.buffer : null;
+    return this.opentui.symbols.syntaxStyleRegister(style, nameBytes, nameBytes.length, fgPtr, bgPtr, attributes);
+  }
+  syntaxStyleResolveByName(style, name) {
+    const nameBytes = this.encoder.encode(name);
+    const id = this.opentui.symbols.syntaxStyleResolveByName(style, nameBytes, nameBytes.length);
+    return id === 0 ? null : id;
+  }
+  syntaxStyleGetStyleCount(style) {
+    const result = this.opentui.symbols.syntaxStyleGetStyleCount(style);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  onNativeEvent(name, handler) {
+    this._nativeEvents.on(name, handler);
+  }
+  onceNativeEvent(name, handler) {
+    this._nativeEvents.once(name, handler);
+  }
+  offNativeEvent(name, handler) {
+    this._nativeEvents.off(name, handler);
+  }
+  onAnyNativeEvent(handler) {
+    this._anyEventHandlers.push(handler);
+  }
 }
 var opentuiLibPath;
 var opentuiLib;
@@ -7416,11 +8757,15 @@ class TextBuffer {
   lib;
   bufferPtr;
   _length = 0;
+  _byteSize = 0;
   _lineInfo;
   _destroyed = false;
-  constructor(lib, ptr2) {
+  _syntaxStyle;
+  _textBytes;
+  _memId;
+  constructor(lib, ptr4) {
     this.lib = lib;
-    this.bufferPtr = ptr2;
+    this.bufferPtr = ptr4;
   }
   static create(widthMethod) {
     const lib = resolveRenderLib();
@@ -7430,17 +8775,42 @@ class TextBuffer {
     if (this._destroyed)
       throw new Error("TextBuffer is destroyed");
   }
-  setStyledText(text) {
+  setText(text) {
     this.guard();
-    this.lib.textBufferReset(this.bufferPtr);
-    this._length = 0;
+    this._textBytes = this.lib.encoder.encode(text);
+    if (this._memId === undefined) {
+      this._memId = this.lib.textBufferRegisterMemBuffer(this.bufferPtr, this._textBytes, false);
+    } else {
+      this.lib.textBufferReplaceMemBuffer(this.bufferPtr, this._memId, this._textBytes, false);
+    }
+    this.lib.textBufferSetTextFromMem(this.bufferPtr, this._memId);
+    this._length = this.lib.textBufferGetLength(this.bufferPtr);
+    this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
     this._lineInfo = undefined;
-    for (const chunk of text.chunks) {
-      const textBytes = this.lib.encoder.encode(chunk.text);
-      this.lib.textBufferWriteChunk(this.bufferPtr, textBytes, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
+  }
+  loadFile(path4) {
+    this.guard();
+    const success = this.lib.textBufferLoadFile(this.bufferPtr, path4);
+    if (!success) {
+      throw new Error(`Failed to load file: ${path4}`);
     }
-    this.lib.textBufferFinalizeLineInfo(this.bufferPtr);
     this._length = this.lib.textBufferGetLength(this.bufferPtr);
+    this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
+    this._lineInfo = undefined;
+    this._textBytes = undefined;
+  }
+  setStyledText(text) {
+    this.guard();
+    const chunks = text.chunks.map((chunk) => ({
+      text: chunk.text,
+      fg: chunk.fg || null,
+      bg: chunk.bg || null,
+      attributes: chunk.attributes ?? 0
+    }));
+    this.lib.textBufferSetStyledText(this.bufferPtr, chunks);
+    this._length = this.lib.textBufferGetLength(this.bufferPtr);
+    this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
+    this._lineInfo = undefined;
   }
   setDefaultFg(fg2) {
     this.guard();
@@ -7462,97 +8832,72 @@ class TextBuffer {
     this.guard();
     return this._length;
   }
-  get ptr() {
+  get byteSize() {
     this.guard();
-    return this.bufferPtr;
+    return this._byteSize;
   }
-  getSelectedText() {
+  get ptr() {
     this.guard();
-    if (this._length === 0)
-      return "";
-    const selectedBytes = this.lib.getSelectedTextBytes(this.bufferPtr, this.length * 4);
-    if (!selectedBytes)
-      return "";
-    return this.lib.decoder.decode(selectedBytes);
+    return this.bufferPtr;
   }
   getPlainText() {
     this.guard();
-    if (this._length === 0)
+    if (this._byteSize === 0)
       return "";
-    const plainBytes = this.lib.getPlainTextBytes(this.bufferPtr, this.length * 4);
+    const plainBytes = this.lib.getPlainTextBytes(this.bufferPtr, this._byteSize);
     if (!plainBytes)
       return "";
     return this.lib.decoder.decode(plainBytes);
   }
-  get lineInfo() {
+  addHighlightByCharRange(highlight) {
     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);
+    this.lib.textBufferAddHighlightByCharRange(this.bufferPtr, highlight);
   }
-  resetLocalSelection() {
+  addHighlight(lineIdx, highlight) {
     this.guard();
-    this.lib.textBufferResetLocalSelection(this.bufferPtr);
+    this.lib.textBufferAddHighlight(this.bufferPtr, lineIdx, highlight);
   }
-  getSelection() {
+  removeHighlightsByRef(hlRef) {
     this.guard();
-    return this.lib.textBufferGetSelection(this.bufferPtr);
+    this.lib.textBufferRemoveHighlightsByRef(this.bufferPtr, hlRef);
   }
-  hasSelection() {
+  clearLineHighlights(lineIdx) {
     this.guard();
-    return this.getSelection() !== null;
+    this.lib.textBufferClearLineHighlights(this.bufferPtr, lineIdx);
   }
-  insertChunkGroup(index, text, fg2, bg2, attributes) {
+  clearAllHighlights() {
     this.guard();
-    const textBytes = this.lib.encoder.encode(text);
-    this.insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes);
+    this.lib.textBufferClearAllHighlights(this.bufferPtr);
   }
-  insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes) {
+  getLineHighlights(lineIdx) {
     this.guard();
-    this._length = this.lib.textBufferInsertChunkGroup(this.bufferPtr, index, textBytes, fg2 || null, bg2 || null, attributes ?? null);
-    this._lineInfo = undefined;
+    return this.lib.textBufferGetLineHighlights(this.bufferPtr, lineIdx);
   }
-  removeChunkGroup(index) {
+  setSyntaxStyle(style) {
     this.guard();
-    this._length = this.lib.textBufferRemoveChunkGroup(this.bufferPtr, index);
-    this._lineInfo = undefined;
+    this._syntaxStyle = style ?? undefined;
+    this.lib.textBufferSetSyntaxStyle(this.bufferPtr, style?.ptr ?? null);
   }
-  replaceChunkGroup(index, text, fg2, bg2, attributes) {
+  getSyntaxStyle() {
     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;
+    return this._syntaxStyle ?? null;
   }
-  get chunkGroupCount() {
-    this.guard();
-    return this.lib.textBufferGetChunkGroupCount(this.bufferPtr);
-  }
-  setWrapWidth(width) {
+  clear() {
     this.guard();
-    this.lib.textBufferSetWrapWidth(this.bufferPtr, width ?? 0);
+    this.lib.textBufferClear(this.bufferPtr);
+    this._length = 0;
+    this._byteSize = 0;
     this._lineInfo = undefined;
+    this._textBytes = undefined;
   }
-  setWrapMode(mode) {
+  reset() {
     this.guard();
-    this.lib.textBufferSetWrapMode(this.bufferPtr, mode);
+    this.lib.textBufferReset(this.bufferPtr);
+    this._length = 0;
+    this._byteSize = 0;
     this._lineInfo = undefined;
+    this._textBytes = undefined;
+    this._memId = undefined;
   }
   destroy() {
     if (this._destroyed)
@@ -7563,7 +8908,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -7656,7 +9001,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter4 {
+class BaseRenderable extends EventEmitter5 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -7728,6 +9073,7 @@ class Renderable extends BaseRenderable {
   _positionType = "relative";
   _overflow = "visible";
   _position = {};
+  _flexShrink = 1;
   renderableMapById = new Map;
   _childrenInLayoutOrder = [];
   _childrenInZIndexOrder = [];
@@ -7974,6 +9320,10 @@ class Renderable extends BaseRenderable {
     if (isDimensionType(value)) {
       this._width = value;
       this.yogaNode.setWidth(value);
+      if (typeof value === "number" && this._flexShrink === 1) {
+        this._flexShrink = 0;
+        this.yogaNode.setFlexShrink(0);
+      }
       this.requestRender();
     }
   }
@@ -7984,6 +9334,10 @@ class Renderable extends BaseRenderable {
     if (isDimensionType(value)) {
       this._height = value;
       this.yogaNode.setHeight(value);
+      if (typeof value === "number" && this._flexShrink === 1) {
+        this._flexShrink = 0;
+        this.yogaNode.setFlexShrink(0);
+      }
       this.requestRender();
     }
   }
@@ -8038,9 +9392,13 @@ class Renderable extends BaseRenderable {
       node.setFlexGrow(0);
     }
     if (options.flexShrink !== undefined) {
+      this._flexShrink = options.flexShrink;
       node.setFlexShrink(options.flexShrink);
     } else {
-      node.setFlexShrink(1);
+      const hasExplicitWidth = typeof options.width === "number";
+      const hasExplicitHeight = typeof options.height === "number";
+      this._flexShrink = hasExplicitWidth || hasExplicitHeight ? 0 : 1;
+      node.setFlexShrink(this._flexShrink);
     }
     if (options.flexDirection !== undefined) {
       node.setFlexDirection(parseFlexDirection(options.flexDirection));
@@ -8185,11 +9543,17 @@ class Renderable extends BaseRenderable {
     this.requestRender();
   }
   set flexGrow(grow) {
-    this.yogaNode.setFlexGrow(grow);
+    if (grow == null) {
+      this.yogaNode.setFlexGrow(0);
+    } else {
+      this.yogaNode.setFlexGrow(grow);
+    }
     this.requestRender();
   }
   set flexShrink(shrink) {
-    this.yogaNode.setFlexShrink(shrink);
+    const value = shrink == null ? 1 : shrink;
+    this._flexShrink = value;
+    this.yogaNode.setFlexShrink(value);
     this.requestRender();
   }
   set flexDirection(direction) {
@@ -8958,7 +10322,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path4 from "path";
@@ -8966,9 +10330,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
-class Capture extends EventEmitter5 {
+class Capture extends EventEmitter6 {
   output = [];
   constructor() {
     super();
@@ -9044,11 +10408,12 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter6 {
+class TerminalConsoleCache extends EventEmitter7 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
   _cachingEnabled = true;
+  _originalConsole = null;
   get cachedLogs() {
     return this._cachedLogs;
   }
@@ -9056,6 +10421,9 @@ class TerminalConsoleCache extends EventEmitter6 {
     super();
   }
   activate() {
+    if (!this._originalConsole) {
+      this._originalConsole = global.console;
+    }
     this.setupConsoleCapture();
     this.overrideConsoleMethods();
   }
@@ -9105,8 +10473,9 @@ class TerminalConsoleCache extends EventEmitter6 {
     this.restoreOriginalConsole();
   }
   restoreOriginalConsole() {
-    const originalNodeConsole = __require("console");
-    global.console = originalNodeConsole;
+    if (this._originalConsole) {
+      global.console = this._originalConsole;
+    }
     this.setupConsoleCapture();
   }
   addLogEntry(level, ...args) {
@@ -9165,7 +10534,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter6 {
+class TerminalConsole extends EventEmitter7 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -9625,7 +10994,7 @@ class TerminalConsole extends EventEmitter6 {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -9661,24 +11030,39 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   }
   const visibleChildren = [];
   if (candidate === -1) {
-    return visibleChildren;
+    candidate = lo > 0 ? lo - 1 : 0;
   }
+  const maxLookBehind = 50;
   let left = candidate;
+  let gapCount = 0;
   while (left - 1 >= 0) {
     const prev = children[left - 1];
-    if ((isRow ? prev.x + prev.width : prev.y + prev.height) < vpStart)
-      break;
+    const prevEnd = isRow ? prev.x + prev.width : prev.y + prev.height;
+    if (prevEnd <= vpStart) {
+      gapCount++;
+      if (gapCount >= maxLookBehind) {
+        break;
+      }
+    } else {
+      gapCount = 0;
+    }
     left--;
   }
   let right = candidate + 1;
   while (right < totalChildren) {
     const next = children[right];
-    if ((isRow ? next.x : next.y) > vpEnd)
+    if ((isRow ? next.x : next.y) >= vpEnd)
       break;
     right++;
   }
   for (let i = left;i < right; i++) {
     const child = children[i];
+    const start = isRow ? child.x : child.y;
+    const end = isRow ? child.x + child.width : child.y + child.height;
+    if (end <= vpStart)
+      continue;
+    if (start >= vpEnd)
+      break;
     if (isRow) {
       const childBottom = child.y + child.height;
       if (childBottom < viewportTop)
@@ -9836,7 +11220,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter7 {
+class CliRenderer extends EventEmitter8 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -10086,7 +11470,7 @@ Captured output:
   }
   get widthMethod() {
     const caps = this.capabilities;
-    return caps?.unicode === "unicode" ? "unicode" : "wcwidth";
+    return caps?.unicode === "wcwidth" ? "wcwidth" : "unicode";
   }
   writeOut(chunk, encoding, callback) {
     return this.realStdoutWrite.call(this.stdout, chunk, encoding, callback);
@@ -10852,10 +12236,12 @@ Captured output:
     }
     this.selectionContainers = [];
   }
-  startSelection(startRenderable, x, y) {
+  startSelection(renderable, x, y) {
+    if (!renderable.selectable)
+      return;
     this.clearSelection();
-    this.selectionContainers.push(startRenderable.parent || this.root);
-    this.currentSelection = new Selection(startRenderable, { x, y }, { x, y });
+    this.selectionContainers.push(renderable.parent || this.root);
+    this.currentSelection = new Selection(renderable, { x, y }, { x, y });
     this.notifySelectablesOfSelectionChange();
   }
   updateSelection(currentRenderable, x, y) {
@@ -10935,7 +12321,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, 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, convertThemeToStyles, SyntaxStyle, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, 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, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, 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, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, 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, RendererControlState, CliRenderer };
 
-//# debugId=0DCF9A9D3C7B24F664756E2164756E21
-//# sourceMappingURL=index-phjxdb6g.js.map
+//# debugId=19E28318FF03F69E64756E2164756E21
+//# sourceMappingURL=index-0qmm1k4p.js.map