@opentui/core 0.0.0-20251010-2eed09fd → 0.0.0-20251026-8b7fde6b

package/{index-kqk5knmb.js → index-hgxcxzxa.js}

@@ -27,7 +27,7 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 
-// ../../node_modules/yoga-layout/dist/src/index.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
 var exports_src = {};
 __export(exports_src, {
   default: () => src_default,
@@ -51,7 +51,7 @@ __export(exports_src, {
   Align: () => Align
 });
 
-// ../../node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/binaries/yoga-wasm-base64-esm.js
 var loadYoga = (() => {
   var _scriptDir = import.meta.url;
   return function(loadYoga2) {
@@ -1356,7 +1356,7 @@ var loadYoga = (() => {
 })();
 var yoga_wasm_base64_esm_default = loadYoga;
 
-// ../../node_modules/yoga-layout/dist/src/generated/YGEnums.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/generated/YGEnums.js
 var Align = /* @__PURE__ */ function(Align2) {
   Align2[Align2["Auto"] = 0] = "Auto";
   Align2[Align2["FlexStart"] = 1] = "FlexStart";
@@ -1559,7 +1559,7 @@ var constants = {
 };
 var YGEnums_default = constants;
 
-// ../../node_modules/yoga-layout/dist/src/wrapAssembly.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/wrapAssembly.js
 function wrapAssembly(lib) {
   function patch(prototype, name, fn) {
     const original = prototype[name];
@@ -1661,7 +1661,7 @@ function wrapAssembly(lib) {
   };
 }
 
-// ../../node_modules/yoga-layout/dist/src/index.js
+// ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
 var Yoga = wrapAssembly(await yoga_wasm_base64_esm_default());
 var src_default = Yoga;
 
@@ -2092,6 +2092,12 @@ var parseKeypress = (s = "", options = {}) => {
   } else if (!s) {
     s = "";
   }
+  if (/^\x1b\[<\d+;\d+;\d+[Mm]$/.test(s)) {
+    return null;
+  }
+  if (s.startsWith("\x1B[M") && s.length >= 6) {
+    return null;
+  }
   const key = {
     name: "",
     ctrl: false,
@@ -2110,11 +2116,14 @@ var parseKeypress = (s = "", options = {}) => {
       return kittyResult;
     }
   }
-  if (s === "\r") {
+  if (s === "\r" || s === "\x1B\r") {
     key.name = "return";
+    key.meta = s.length === 2;
   } else if (s === `
+` || s === `\x1B
 `) {
     key.name = "enter";
+    key.meta = s.length === 2;
   } else if (s === "\t") {
     key.name = "tab";
   } else if (s === "\b" || s === "\x1B\b" || s === "\x7F" || s === "\x1B\x7F") {
@@ -2277,6 +2286,9 @@ class KeyHandler extends EventEmitter {
         return;
       }
       const parsedKey = parseKeypress(key, { useKittyKeyboard: this.useKittyKeyboard });
+      if (!parsedKey) {
+        return;
+      }
       switch (parsedKey.eventType) {
         case "press":
           this.emit("keypress", new KeyEvent(parsedKey));
@@ -2406,18 +2418,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 +4315,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 +4398,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 +4425,9 @@ function parseAlign(value) {
   }
 }
 function parseBoxSizing(value) {
+  if (value == null) {
+    return BoxSizing.BorderBox;
+  }
   switch (value.toLowerCase()) {
     case "border-box":
       return BoxSizing.BorderBox;
@@ -4514,6 +4438,9 @@ function parseBoxSizing(value) {
   }
 }
 function parseDimension(value) {
+  if (value == null) {
+    return Dimension.Width;
+  }
   switch (value.toLowerCase()) {
     case "width":
       return Dimension.Width;
@@ -4524,6 +4451,9 @@ function parseDimension(value) {
   }
 }
 function parseDirection(value) {
+  if (value == null) {
+    return Direction.LTR;
+  }
   switch (value.toLowerCase()) {
     case "inherit":
       return Direction.Inherit;
@@ -4536,6 +4466,9 @@ function parseDirection(value) {
   }
 }
 function parseDisplay(value) {
+  if (value == null) {
+    return Display.Flex;
+  }
   switch (value.toLowerCase()) {
     case "flex":
       return Display.Flex;
@@ -4548,6 +4481,9 @@ function parseDisplay(value) {
   }
 }
 function parseEdge(value) {
+  if (value == null) {
+    return Edge.All;
+  }
   switch (value.toLowerCase()) {
     case "left":
       return Edge.Left;
@@ -4572,6 +4508,9 @@ function parseEdge(value) {
   }
 }
 function parseFlexDirection(value) {
+  if (value == null) {
+    return FlexDirection.Column;
+  }
   switch (value.toLowerCase()) {
     case "column":
       return FlexDirection.Column;
@@ -4586,6 +4525,9 @@ function parseFlexDirection(value) {
   }
 }
 function parseGutter(value) {
+  if (value == null) {
+    return Gutter.All;
+  }
   switch (value.toLowerCase()) {
     case "column":
       return Gutter.Column;
@@ -4598,6 +4540,9 @@ function parseGutter(value) {
   }
 }
 function parseJustify(value) {
+  if (value == null) {
+    return Justify.FlexStart;
+  }
   switch (value.toLowerCase()) {
     case "flex-start":
       return Justify.FlexStart;
@@ -4616,6 +4561,9 @@ function parseJustify(value) {
   }
 }
 function parseLogLevel(value) {
+  if (value == null) {
+    return LogLevel.Info;
+  }
   switch (value.toLowerCase()) {
     case "error":
       return LogLevel.Error;
@@ -4634,6 +4582,9 @@ function parseLogLevel(value) {
   }
 }
 function parseMeasureMode(value) {
+  if (value == null) {
+    return MeasureMode.Undefined;
+  }
   switch (value.toLowerCase()) {
     case "undefined":
       return MeasureMode.Undefined;
@@ -4646,6 +4597,9 @@ function parseMeasureMode(value) {
   }
 }
 function parseOverflow(value) {
+  if (value == null) {
+    return Overflow.Visible;
+  }
   switch (value.toLowerCase()) {
     case "visible":
       return Overflow.Visible;
@@ -4658,6 +4612,9 @@ function parseOverflow(value) {
   }
 }
 function parsePositionType(value) {
+  if (value == null) {
+    return PositionType.Relative;
+  }
   switch (value.toLowerCase()) {
     case "static":
       return PositionType.Static;
@@ -4670,6 +4627,9 @@ function parsePositionType(value) {
   }
 }
 function parseUnit(value) {
+  if (value == null) {
+    return Unit.Point;
+  }
   switch (value.toLowerCase()) {
     case "undefined":
       return Unit.Undefined;
@@ -4684,6 +4644,9 @@ function parseUnit(value) {
   }
 }
 function parseWrap(value) {
+  if (value == null) {
+    return Wrap.NoWrap;
+  }
   switch (value.toLowerCase()) {
     case "no-wrap":
       return Wrap.NoWrap;
@@ -6253,9 +6216,719 @@ function getTreeSitterClient() {
     return client2;
   });
 }
+
+// src/lib/extmarks.ts
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/lib/extmarks-history.ts
+class ExtmarksHistory {
+  undoStack = [];
+  redoStack = [];
+  saveSnapshot(extmarks, nextId) {
+    const snapshot = {
+      extmarks: new Map(Array.from(extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+      nextId
+    };
+    this.undoStack.push(snapshot);
+    this.redoStack = [];
+  }
+  undo() {
+    if (this.undoStack.length === 0)
+      return null;
+    return this.undoStack.pop();
+  }
+  redo() {
+    if (this.redoStack.length === 0)
+      return null;
+    return this.redoStack.pop();
+  }
+  pushRedo(snapshot) {
+    this.redoStack.push(snapshot);
+  }
+  pushUndo(snapshot) {
+    this.undoStack.push(snapshot);
+  }
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+}
+
+// src/lib/extmarks.ts
+class ExtmarksController extends EventEmitter4 {
+  editBuffer;
+  editorView;
+  extmarks = new Map;
+  nextId = 1;
+  destroyed = false;
+  history = new ExtmarksHistory;
+  originalMoveCursorLeft;
+  originalMoveCursorRight;
+  originalSetCursorByOffset;
+  originalMoveUpVisual;
+  originalMoveDownVisual;
+  originalDeleteCharBackward;
+  originalDeleteChar;
+  originalInsertText;
+  originalInsertChar;
+  originalDeleteRange;
+  originalSetText;
+  originalClear;
+  originalNewLine;
+  originalDeleteLine;
+  originalEditorViewDeleteSelectedText;
+  originalUndo;
+  originalRedo;
+  constructor(editBuffer, editorView) {
+    super();
+    this.editBuffer = editBuffer;
+    this.editorView = editorView;
+    this.originalMoveCursorLeft = editBuffer.moveCursorLeft.bind(editBuffer);
+    this.originalMoveCursorRight = editBuffer.moveCursorRight.bind(editBuffer);
+    this.originalSetCursorByOffset = editBuffer.setCursorByOffset.bind(editBuffer);
+    this.originalMoveUpVisual = editorView.moveUpVisual.bind(editorView);
+    this.originalMoveDownVisual = editorView.moveDownVisual.bind(editorView);
+    this.originalDeleteCharBackward = editBuffer.deleteCharBackward.bind(editBuffer);
+    this.originalDeleteChar = editBuffer.deleteChar.bind(editBuffer);
+    this.originalInsertText = editBuffer.insertText.bind(editBuffer);
+    this.originalInsertChar = editBuffer.insertChar.bind(editBuffer);
+    this.originalDeleteRange = editBuffer.deleteRange.bind(editBuffer);
+    this.originalSetText = editBuffer.setText.bind(editBuffer);
+    this.originalClear = editBuffer.clear.bind(editBuffer);
+    this.originalNewLine = editBuffer.newLine.bind(editBuffer);
+    this.originalDeleteLine = editBuffer.deleteLine.bind(editBuffer);
+    this.originalEditorViewDeleteSelectedText = editorView.deleteSelectedText.bind(editorView);
+    this.originalUndo = editBuffer.undo.bind(editBuffer);
+    this.originalRedo = editBuffer.redo.bind(editBuffer);
+    this.wrapCursorMovement();
+    this.wrapDeletion();
+    this.wrapInsertion();
+    this.wrapEditorViewDeleteSelectedText();
+    this.wrapUndoRedo();
+    this.setupContentChangeListener();
+  }
+  wrapCursorMovement() {
+    this.editBuffer.moveCursorLeft = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      if (targetOffset < 0) {
+        this.originalMoveCursorLeft();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset >= virtualExtmark.end) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.start - 1);
+        return;
+      }
+      this.originalMoveCursorLeft();
+    };
+    this.editBuffer.moveCursorRight = () => {
+      if (this.destroyed) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const targetOffset = currentOffset + 1;
+      const textLength = this.editBuffer.getText().length;
+      if (targetOffset > textLength) {
+        this.originalMoveCursorRight();
+        return;
+      }
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+        this.editBuffer.setCursorByOffset(virtualExtmark.end);
+        return;
+      }
+      this.originalMoveCursorRight();
+    };
+    this.editorView.moveUpVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveUpVisual();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalMoveUpVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editorView.moveDownVisual = () => {
+      if (this.destroyed) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalMoveDownVisual();
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalMoveDownVisual();
+      const newOffset = this.editorView.getVisualCursor().offset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(newOffset);
+      if (virtualExtmark) {
+        const distanceToStart = newOffset - virtualExtmark.start;
+        const distanceToEnd = virtualExtmark.end - newOffset;
+        if (distanceToStart < distanceToEnd) {
+          this.editorView.setCursorByOffset(virtualExtmark.start - 1);
+        } else {
+          this.editorView.setCursorByOffset(virtualExtmark.end);
+        }
+      }
+    };
+    this.editBuffer.setCursorByOffset = (offset) => {
+      if (this.destroyed) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hasSelection = this.editorView.hasSelection();
+      if (hasSelection) {
+        this.originalSetCursorByOffset(offset);
+        return;
+      }
+      const movingForward = offset > currentOffset;
+      if (movingForward) {
+        const virtualExtmark = this.findVirtualExtmarkContaining(offset);
+        if (virtualExtmark && currentOffset <= virtualExtmark.start) {
+          this.originalSetCursorByOffset(virtualExtmark.end);
+          return;
+        }
+      } else {
+        for (const extmark of this.extmarks.values()) {
+          if (extmark.virtual && currentOffset >= extmark.end && offset < extmark.end && offset >= extmark.start) {
+            this.originalSetCursorByOffset(extmark.start - 1);
+            return;
+          }
+        }
+      }
+      this.originalSetCursorByOffset(offset);
+    };
+  }
+  wrapDeletion() {
+    this.editBuffer.deleteCharBackward = () => {
+      if (this.destroyed) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset === 0) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteCharBackward();
+        return;
+      }
+      const targetOffset = currentOffset - 1;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.end) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.extmarks.delete(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.emit("extmark-deleted", {
+          extmark: virtualExtmark,
+          trigger: "backspace"
+        });
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteCharBackward();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteChar = () => {
+      if (this.destroyed) {
+        this.originalDeleteChar();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      const textLength = this.editBuffer.getText().length;
+      const hadSelection = this.editorView.hasSelection();
+      if (currentOffset >= textLength) {
+        this.originalDeleteChar();
+        return;
+      }
+      if (hadSelection) {
+        this.originalDeleteChar();
+        return;
+      }
+      const targetOffset = currentOffset;
+      const virtualExtmark = this.findVirtualExtmarkContaining(targetOffset);
+      if (virtualExtmark && currentOffset === virtualExtmark.start) {
+        const startCursor = this.offsetToPosition(virtualExtmark.start);
+        const endCursor = this.offsetToPosition(virtualExtmark.end);
+        const deleteOffset = virtualExtmark.start;
+        const deleteLength = virtualExtmark.end - virtualExtmark.start;
+        this.extmarks.delete(virtualExtmark.id);
+        this.originalDeleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col);
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+        this.emit("extmark-deleted", {
+          extmark: virtualExtmark,
+          trigger: "delete"
+        });
+        this.updateHighlights();
+        return;
+      }
+      this.originalDeleteChar();
+      this.adjustExtmarksAfterDeletion(targetOffset, 1);
+    };
+    this.editBuffer.deleteRange = (startLine, startCol, endLine, endCol) => {
+      if (this.destroyed) {
+        this.originalDeleteRange(startLine, startCol, endLine, endCol);
+        return;
+      }
+      this.saveSnapshot();
+      const startOffset = this.positionToOffset(startLine, startCol);
+      const endOffset = this.positionToOffset(endLine, endCol);
+      const length = endOffset - startOffset;
+      this.originalDeleteRange(startLine, startCol, endLine, endCol);
+      this.adjustExtmarksAfterDeletion(startOffset, length);
+    };
+    this.editBuffer.deleteLine = () => {
+      if (this.destroyed) {
+        this.originalDeleteLine();
+        return;
+      }
+      this.saveSnapshot();
+      const text = this.editBuffer.getText();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      let lineStart = 0;
+      for (let i = currentOffset - 1;i >= 0; i--) {
+        if (text[i] === `
+`) {
+          lineStart = i + 1;
+          break;
+        }
+      }
+      let lineEnd = text.length;
+      for (let i = currentOffset;i < text.length; i++) {
+        if (text[i] === `
+`) {
+          lineEnd = i + 1;
+          break;
+        }
+      }
+      const deleteLength = lineEnd - lineStart;
+      this.originalDeleteLine();
+      this.adjustExtmarksAfterDeletion(lineStart, deleteLength);
+    };
+  }
+  wrapInsertion() {
+    this.editBuffer.insertText = (text) => {
+      if (this.destroyed) {
+        this.originalInsertText(text);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertText(text);
+      this.adjustExtmarksAfterInsertion(currentOffset, text.length);
+    };
+    this.editBuffer.insertChar = (char) => {
+      if (this.destroyed) {
+        this.originalInsertChar(char);
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalInsertChar(char);
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+    this.editBuffer.setText = (text, opts) => {
+      if (this.destroyed) {
+        this.originalSetText(text, opts);
+        return;
+      }
+      if (opts?.history !== false) {
+        this.saveSnapshot();
+      }
+      this.clear();
+      this.originalSetText(text, opts);
+    };
+    this.editBuffer.clear = () => {
+      if (this.destroyed) {
+        this.originalClear();
+        return;
+      }
+      this.saveSnapshot();
+      this.clear();
+      this.originalClear();
+    };
+    this.editBuffer.newLine = () => {
+      if (this.destroyed) {
+        this.originalNewLine();
+        return;
+      }
+      this.saveSnapshot();
+      const currentOffset = this.editorView.getVisualCursor().offset;
+      this.originalNewLine();
+      this.adjustExtmarksAfterInsertion(currentOffset, 1);
+    };
+  }
+  wrapEditorViewDeleteSelectedText() {
+    this.editorView.deleteSelectedText = () => {
+      if (this.destroyed) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      this.saveSnapshot();
+      const selection = this.editorView.getSelection();
+      if (!selection) {
+        this.originalEditorViewDeleteSelectedText();
+        return;
+      }
+      const deleteOffset = Math.min(selection.start, selection.end);
+      const deleteLength = Math.abs(selection.end - selection.start);
+      this.originalEditorViewDeleteSelectedText();
+      if (deleteLength > 0) {
+        this.adjustExtmarksAfterDeletion(deleteOffset, deleteLength);
+      }
+    };
+  }
+  setupContentChangeListener() {
+    this.editBuffer.on("content-changed", () => {
+      if (this.destroyed)
+        return;
+      this.updateHighlights();
+    });
+  }
+  findVirtualExtmarkContaining(offset) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.virtual && offset >= extmark.start && offset < extmark.end) {
+        return extmark;
+      }
+    }
+    return null;
+  }
+  adjustExtmarksAfterInsertion(insertOffset, length) {
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.start >= insertOffset) {
+        extmark.start += length;
+        extmark.end += length;
+        this.emit("extmark-updated", extmark);
+      } else if (extmark.end > insertOffset) {
+        extmark.end += length;
+        this.emit("extmark-updated", extmark);
+      }
+    }
+    this.updateHighlights();
+  }
+  adjustExtmarksAfterDeletion(deleteOffset, length) {
+    const toDelete = [];
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.end <= deleteOffset) {
+        continue;
+      }
+      if (extmark.start >= deleteOffset + length) {
+        extmark.start -= length;
+        extmark.end -= length;
+        this.emit("extmark-updated", extmark);
+      } else if (extmark.start >= deleteOffset && extmark.end <= deleteOffset + length) {
+        toDelete.push(extmark.id);
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset + length) {
+        extmark.end -= length;
+        this.emit("extmark-updated", extmark);
+      } else if (extmark.start < deleteOffset && extmark.end > deleteOffset) {
+        extmark.end -= Math.min(extmark.end, deleteOffset + length) - deleteOffset;
+        this.emit("extmark-updated", extmark);
+      } else if (extmark.start < deleteOffset + length && extmark.end > deleteOffset + length) {
+        const overlap = deleteOffset + length - extmark.start;
+        extmark.start = deleteOffset;
+        extmark.end -= length;
+        this.emit("extmark-updated", extmark);
+      }
+    }
+    for (const id of toDelete) {
+      const extmark = this.extmarks.get(id);
+      if (extmark) {
+        this.extmarks.delete(id);
+        this.emit("extmark-deleted", {
+          extmark,
+          trigger: "manual"
+        });
+      }
+    }
+    this.updateHighlights();
+  }
+  offsetToPosition(offset) {
+    const text = this.editBuffer.getText();
+    let currentOffset = 0;
+    let row = 0;
+    let col = 0;
+    for (let i = 0;i < text.length && currentOffset < offset; i++) {
+      if (text[i] === `
+`) {
+        row++;
+        col = 0;
+      } else {
+        col++;
+      }
+      currentOffset++;
+    }
+    return { row, col };
+  }
+  positionToOffset(row, col) {
+    const text = this.editBuffer.getText();
+    let currentRow = 0;
+    let offset = 0;
+    for (let i = 0;i < text.length; i++) {
+      if (currentRow === row && offset - this.getLineStartOffset(row) === col) {
+        return offset;
+      }
+      if (text[i] === `
+`) {
+        currentRow++;
+      }
+      offset++;
+    }
+    return offset;
+  }
+  getLineStartOffset(targetRow) {
+    const text = this.editBuffer.getText();
+    let row = 0;
+    let offset = 0;
+    for (let i = 0;i < text.length; i++) {
+      if (row === targetRow) {
+        return offset;
+      }
+      if (text[i] === `
+`) {
+        row++;
+        offset = i + 1;
+      }
+    }
+    return offset;
+  }
+  updateHighlights() {
+    this.editBuffer.clearAllHighlights();
+    for (const extmark of this.extmarks.values()) {
+      if (extmark.styleId !== undefined) {
+        const startWithoutNewlines = this.offsetToCharOffset(extmark.start);
+        const endWithoutNewlines = this.offsetToCharOffset(extmark.end);
+        this.editBuffer.addHighlightByCharRange({
+          start: startWithoutNewlines,
+          end: endWithoutNewlines,
+          styleId: extmark.styleId,
+          priority: extmark.priority ?? 0,
+          hlRef: extmark.id
+        });
+      }
+    }
+  }
+  offsetToCharOffset(offset) {
+    const text = this.editBuffer.getText();
+    let charOffset = 0;
+    for (let i = 0;i < offset && i < text.length; i++) {
+      if (text[i] !== `
+`) {
+        charOffset++;
+      }
+    }
+    return charOffset;
+  }
+  create(options) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const id = this.nextId++;
+    const extmark = {
+      id,
+      start: options.start,
+      end: options.end,
+      virtual: options.virtual ?? false,
+      styleId: options.styleId,
+      priority: options.priority,
+      data: options.data
+    };
+    this.extmarks.set(id, extmark);
+    this.updateHighlights();
+    return id;
+  }
+  update(id, options) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const extmark = this.extmarks.get(id);
+    if (!extmark)
+      return false;
+    if (options.start !== undefined)
+      extmark.start = options.start;
+    if (options.end !== undefined)
+      extmark.end = options.end;
+    if (options.virtual !== undefined)
+      extmark.virtual = options.virtual;
+    if (options.styleId !== undefined)
+      extmark.styleId = options.styleId;
+    if (options.priority !== undefined)
+      extmark.priority = options.priority;
+    if (options.data !== undefined)
+      extmark.data = options.data;
+    this.emit("extmark-updated", extmark);
+    this.updateHighlights();
+    return true;
+  }
+  delete(id) {
+    if (this.destroyed) {
+      throw new Error("ExtmarksController is destroyed");
+    }
+    const extmark = this.extmarks.get(id);
+    if (!extmark)
+      return false;
+    this.extmarks.delete(id);
+    this.emit("extmark-deleted", {
+      extmark,
+      trigger: "manual"
+    });
+    this.updateHighlights();
+    return true;
+  }
+  get(id) {
+    if (this.destroyed)
+      return null;
+    return this.extmarks.get(id) ?? null;
+  }
+  getAll() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values());
+  }
+  getVirtual() {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => e.virtual);
+  }
+  getAtOffset(offset) {
+    if (this.destroyed)
+      return [];
+    return Array.from(this.extmarks.values()).filter((e) => offset >= e.start && offset < e.end);
+  }
+  clear() {
+    if (this.destroyed)
+      return;
+    for (const extmark of this.extmarks.values()) {
+      this.emit("extmark-deleted", {
+        extmark,
+        trigger: "manual"
+      });
+    }
+    this.extmarks.clear();
+    this.updateHighlights();
+  }
+  saveSnapshot() {
+    this.history.saveSnapshot(this.extmarks, this.nextId);
+  }
+  restoreSnapshot(snapshot) {
+    this.extmarks = new Map(Array.from(snapshot.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }]));
+    this.nextId = snapshot.nextId;
+    this.updateHighlights();
+  }
+  wrapUndoRedo() {
+    this.editBuffer.undo = () => {
+      if (this.destroyed) {
+        return this.originalUndo();
+      }
+      if (!this.history.canUndo()) {
+        return this.originalUndo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushRedo(currentSnapshot);
+      const snapshot = this.history.undo();
+      this.restoreSnapshot(snapshot);
+      return this.originalUndo();
+    };
+    this.editBuffer.redo = () => {
+      if (this.destroyed) {
+        return this.originalRedo();
+      }
+      if (!this.history.canRedo()) {
+        return this.originalRedo();
+      }
+      const currentSnapshot = {
+        extmarks: new Map(Array.from(this.extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
+        nextId: this.nextId
+      };
+      this.history.pushUndo(currentSnapshot);
+      const snapshot = this.history.redo();
+      this.restoreSnapshot(snapshot);
+      return this.originalRedo();
+    };
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.editBuffer.moveCursorLeft = this.originalMoveCursorLeft;
+    this.editBuffer.moveCursorRight = this.originalMoveCursorRight;
+    this.editBuffer.setCursorByOffset = this.originalSetCursorByOffset;
+    this.editorView.moveUpVisual = this.originalMoveUpVisual;
+    this.editorView.moveDownVisual = this.originalMoveDownVisual;
+    this.editBuffer.deleteCharBackward = this.originalDeleteCharBackward;
+    this.editBuffer.deleteChar = this.originalDeleteChar;
+    this.editBuffer.insertText = this.originalInsertText;
+    this.editBuffer.insertChar = this.originalInsertChar;
+    this.editBuffer.deleteRange = this.originalDeleteRange;
+    this.editBuffer.setText = this.originalSetText;
+    this.editBuffer.clear = this.originalClear;
+    this.editBuffer.newLine = this.originalNewLine;
+    this.editBuffer.deleteLine = this.originalDeleteLine;
+    this.editorView.deleteSelectedText = this.originalEditorViewDeleteSelectedText;
+    this.editBuffer.undo = this.originalUndo;
+    this.editBuffer.redo = this.originalRedo;
+    this.extmarks.clear();
+    this.history.clear();
+    this.destroyed = true;
+    this.removeAllListeners();
+  }
+}
+function createExtmarksController(editBuffer, editorView) {
+  return new ExtmarksController(editBuffer, editorView);
+}
 // 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 EventEmitter5 } from "events";
 
 // src/buffer.ts
 import { toArrayBuffer } from "bun:ffi";
@@ -6411,9 +7084,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,10 +7130,628 @@ class OptimizedBuffer {
   }
 }
 
-// src/zig.ts
-var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
-var targetLibPath = module.default;
-if (/\$bunfs/.test(targetLibPath)) {
+// ../../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;
+if (/\$bunfs/.test(targetLibPath)) {
   targetLibPath = targetLibPath.replace("../", "");
 }
 if (!existsSync2(targetLibPath)) {
@@ -6481,6 +7776,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    setEventCallback: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createRenderer: {
       args: ["u32", "u32", "bool"],
       returns: "ptr"
@@ -6709,15 +8008,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,74 +8036,402 @@ 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: {
+    textBufferReplaceMemBuffer: {
+      args: ["ptr", "u8", "ptr", "usize", "bool"],
+      returns: "bool"
+    },
+    textBufferClearMemRegistry: {
       args: ["ptr"],
       returns: "void"
     },
+    textBufferSetTextFromMem: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    textBufferLoadFile: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "bool"
+    },
+    textBufferSetStyledText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
     textBufferGetLineCount: {
       args: ["ptr"],
       returns: "u32"
     },
-    textBufferGetLineInfoDirect: {
-      args: ["ptr", "ptr", "ptr"],
-      returns: "u32"
+    textBufferGetPlainText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferAddHighlightByCharRange: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferAddHighlight: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "void"
     },
-    textBufferGetSelectionInfo: {
+    textBufferRemoveHighlightsByRef: {
+      args: ["ptr", "u16"],
+      returns: "void"
+    },
+    textBufferClearLineHighlights: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferClearAllHighlights: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetSyntaxStyle: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferGetLineHighlightsPtr: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "ptr"
+    },
+    textBufferFreeLineHighlights: {
+      args: ["ptr", "usize"],
+      returns: "void"
+    },
+    createTextBufferView: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    destroyTextBufferView: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewGetSelectionInfo: {
       args: ["ptr"],
       returns: "u64"
     },
-    textBufferGetSelectedText: {
+    textBufferViewSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    textBufferViewResetLocalSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewSetWrapWidth: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferViewSetWrapMode: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    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"
     },
-    textBufferGetPlainText: {
+    textBufferViewGetPlainText: {
       args: ["ptr", "ptr", "usize"],
       returns: "usize"
     },
-    textBufferSetLocalSelection: {
-      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
-      returns: "bool"
+    bufferDrawTextBufferView: {
+      args: ["ptr", "ptr", "i32", "i32"],
+      returns: "void"
+    },
+    bufferDrawEditorView: {
+      args: ["ptr", "ptr", "i32", "i32"],
+      returns: "void"
+    },
+    createEditorView: {
+      args: ["ptr", "u32", "u32"],
+      returns: "ptr"
     },
-    textBufferResetLocalSelection: {
+    destroyEditorView: {
       args: ["ptr"],
       returns: "void"
     },
-    textBufferInsertChunkGroup: {
-      args: ["ptr", "usize", "ptr", "u32", "ptr", "ptr", "u8"],
-      returns: "u32"
+    editorViewSetViewportSize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
     },
-    textBufferRemoveChunkGroup: {
-      args: ["ptr", "usize"],
+    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"
     },
-    textBufferReplaceChunkGroup: {
-      args: ["ptr", "usize", "ptr", "u32", "ptr", "ptr", "u8"],
+    editorViewGetTotalVirtualLineCount: {
+      args: ["ptr"],
       returns: "u32"
     },
-    textBufferGetChunkGroupCount: {
+    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"
     },
-    textBufferSetWrapWidth: {
-      args: ["ptr", "u32"],
+    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"],
+      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"
+    },
+    editBufferClear: {
+      args: ["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"
     },
-    textBufferSetWrapMode: {
-      args: ["ptr", "u8"],
+    editorViewGetEOL: {
+      args: ["ptr", "ptr"],
       returns: "void"
     },
     getArenaAllocatedBytes: {
       args: [],
       returns: "usize"
     },
-    bufferDrawTextBuffer: {
-      args: ["ptr", "ptr", "i32", "i32", "i32", "i32", "u32", "u32", "bool"],
+    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"
@@ -6937,9 +8564,13 @@ class FFIRenderLib {
   encoder = new TextEncoder;
   decoder = new TextDecoder;
   logCallbackWrapper;
+  eventCallbackWrapper;
+  _nativeEvents = new EventEmitter5;
+  _anyEventHandlers = [];
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.setupLogging();
+    this.setupEventBus();
   }
   setupLogging() {
     if (this.logCallbackWrapper) {
@@ -6951,7 +8582,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 +8617,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 +8699,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);
@@ -7124,142 +8797,520 @@ class FFIRenderLib {
   resizeRenderer(renderer, width, height) {
     this.opentui.symbols.resizeRenderer(renderer, width, height);
   }
-  setCursorPosition(renderer, x, y, visible) {
-    this.opentui.symbols.setCursorPosition(renderer, x, y, visible);
+  setCursorPosition(renderer, x, y, visible) {
+    this.opentui.symbols.setCursorPosition(renderer, x, y, visible);
+  }
+  setCursorStyle(renderer, style, blinking) {
+    const stylePtr = this.encoder.encode(style);
+    this.opentui.symbols.setCursorStyle(renderer, stylePtr, style.length, blinking);
+  }
+  setCursorColor(renderer, color) {
+    this.opentui.symbols.setCursorColor(renderer, color.buffer);
+  }
+  render(renderer, force) {
+    this.opentui.symbols.render(renderer, force);
+  }
+  createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
+    if (Number.isNaN(width) || Number.isNaN(height)) {
+      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
+    }
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const idToUse = id || "unnamed buffer";
+    const idBytes = this.encoder.encode(idToUse);
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, respectAlpha, widthMethodCode, idBytes, idBytes.length);
+    if (!bufferPtr) {
+      throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
+    }
+    return new OptimizedBuffer(this, bufferPtr, width, height, { respectAlpha, id });
+  }
+  destroyOptimizedBuffer(bufferPtr) {
+    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
+  }
+  drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, sourceX, sourceY, sourceWidth, sourceHeight) {
+    const srcX = sourceX ?? 0;
+    const srcY = sourceY ?? 0;
+    const srcWidth = sourceWidth ?? 0;
+    const srcHeight = sourceHeight ?? 0;
+    this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
+  }
+  setDebugOverlay(renderer, enabled, corner) {
+    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
+  }
+  clearTerminal(renderer) {
+    this.opentui.symbols.clearTerminal(renderer);
+  }
+  setTerminalTitle(renderer, title) {
+    const titleBytes = this.encoder.encode(title);
+    this.opentui.symbols.setTerminalTitle(renderer, titleBytes, titleBytes.length);
+  }
+  addToHitGrid(renderer, x, y, width, height, id) {
+    this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id);
+  }
+  checkHit(renderer, x, y) {
+    return this.opentui.symbols.checkHit(renderer, x, y);
+  }
+  dumpHitGrid(renderer) {
+    this.opentui.symbols.dumpHitGrid(renderer);
+  }
+  dumpBuffers(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpBuffers(renderer, ts);
+  }
+  dumpStdoutBuffer(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
+  }
+  enableMouse(renderer, enableMovement) {
+    this.opentui.symbols.enableMouse(renderer, enableMovement);
+  }
+  disableMouse(renderer) {
+    this.opentui.symbols.disableMouse(renderer);
+  }
+  enableKittyKeyboard(renderer, flags) {
+    this.opentui.symbols.enableKittyKeyboard(renderer, flags);
+  }
+  disableKittyKeyboard(renderer) {
+    this.opentui.symbols.disableKittyKeyboard(renderer);
+  }
+  setupTerminal(renderer, useAlternateScreen) {
+    this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
+  }
+  queryPixelResolution(renderer) {
+    this.opentui.symbols.queryPixelResolution(renderer);
+  }
+  createTextBuffer(widthMethod) {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
+    if (!bufferPtr) {
+      throw new Error(`Failed to create TextBuffer`);
+    }
+    return new TextBuffer(this, bufferPtr);
+  }
+  destroyTextBuffer(buffer) {
+    this.opentui.symbols.destroyTextBuffer(buffer);
+  }
+  textBufferGetLength(buffer) {
+    return this.opentui.symbols.textBufferGetLength(buffer);
+  }
+  textBufferGetByteSize(buffer) {
+    return this.opentui.symbols.textBufferGetByteSize(buffer);
+  }
+  textBufferReset(buffer) {
+    this.opentui.symbols.textBufferReset(buffer);
+  }
+  textBufferClear(buffer) {
+    this.opentui.symbols.textBufferClear(buffer);
+  }
+  textBufferSetDefaultFg(buffer, fg2) {
+    const fgPtr = fg2 ? fg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
+  }
+  textBufferSetDefaultBg(buffer, bg2) {
+    const bgPtr = bg2 ? bg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
+  }
+  textBufferSetDefaultAttributes(buffer, attributes) {
+    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
+    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
+  }
+  textBufferResetDefaults(buffer) {
+    this.opentui.symbols.textBufferResetDefaults(buffer);
+  }
+  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;
+  }
+  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);
+  }
+  textBufferGetPlainText(buffer, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  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;
+    }
+    const start = Number(packedInfo >> 32n);
+    const end = Number(packedInfo & 0xffff_ffffn);
+    return { start, end };
+  }
+  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);
+  }
+  textBufferViewGetSelectedText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetSelectedText(view, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  textBufferViewGetPlainText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetPlainText(view, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  textBufferViewGetSelectedTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr3(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferViewGetPlainTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, ptr3(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferAddHighlightByCharRange(buffer, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr3(packedHighlight));
+  }
+  textBufferAddHighlight(buffer, lineIdx, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr3(packedHighlight));
+  }
+  textBufferRemoveHighlightsByRef(buffer, hlRef) {
+    this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
+  }
+  textBufferClearLineHighlights(buffer, lineIdx) {
+    this.opentui.symbols.textBufferClearLineHighlights(buffer, lineIdx);
+  }
+  textBufferClearAllHighlights(buffer) {
+    this.opentui.symbols.textBufferClearAllHighlights(buffer);
+  }
+  textBufferSetSyntaxStyle(buffer, style) {
+    this.opentui.symbols.textBufferSetSyntaxStyle(buffer, style);
+  }
+  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;
+  }
+  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");
+    }
+    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 {
+      offsetX: x[0],
+      offsetY: y[0],
+      width: width[0],
+      height: height[0]
+    };
+  }
+  editorViewSetScrollMargin(view, margin) {
+    this.opentui.symbols.editorViewSetScrollMargin(view, margin);
   }
-  setCursorStyle(renderer, style, blinking) {
-    const stylePtr = this.encoder.encode(style);
-    this.opentui.symbols.setCursorStyle(renderer, stylePtr, style.length, blinking);
+  editorViewSetWrapMode(view, mode) {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
+    this.opentui.symbols.editorViewSetWrapMode(view, modeValue);
   }
-  setCursorColor(renderer, color) {
-    this.opentui.symbols.setCursorColor(renderer, color.buffer);
+  editorViewGetVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetVirtualLineCount(view);
   }
-  render(renderer, force) {
-    this.opentui.symbols.render(renderer, force);
+  editorViewGetTotalVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetTotalVirtualLineCount(view);
   }
-  createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
-    if (Number.isNaN(width) || Number.isNaN(height)) {
-      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
+  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 idToUse = id || "unnamed buffer";
-    const idBytes = this.encoder.encode(idToUse);
-    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, respectAlpha, widthMethodCode, idBytes, idBytes.length);
+    const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode);
     if (!bufferPtr) {
-      throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
+      throw new Error("Failed to create EditBuffer");
     }
-    return new OptimizedBuffer(this, bufferPtr, width, height, { respectAlpha, id });
+    return bufferPtr;
   }
-  destroyOptimizedBuffer(bufferPtr) {
-    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
+  destroyEditBuffer(buffer) {
+    this.opentui.symbols.destroyEditBuffer(buffer);
   }
-  drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, sourceX, sourceY, sourceWidth, sourceHeight) {
-    const srcX = sourceX ?? 0;
-    const srcY = sourceY ?? 0;
-    const srcWidth = sourceWidth ?? 0;
-    const srcHeight = sourceHeight ?? 0;
-    this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
+  editBufferSetText(buffer, textBytes, retainHistory = true) {
+    this.opentui.symbols.editBufferSetText(buffer, textBytes, textBytes.length, retainHistory);
   }
-  setDebugOverlay(renderer, enabled, corner) {
-    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
+  editBufferSetTextFromMem(buffer, memId, retainHistory = true) {
+    this.opentui.symbols.editBufferSetTextFromMem(buffer, memId, retainHistory);
   }
-  clearTerminal(renderer) {
-    this.opentui.symbols.clearTerminal(renderer);
+  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);
   }
-  setTerminalTitle(renderer, title) {
-    const titleBytes = this.encoder.encode(title);
-    this.opentui.symbols.setTerminalTitle(renderer, titleBytes, titleBytes.length);
+  editBufferInsertChar(buffer, char) {
+    const charBytes = this.encoder.encode(char);
+    this.opentui.symbols.editBufferInsertChar(buffer, charBytes, charBytes.length);
   }
-  addToHitGrid(renderer, x, y, width, height, id) {
-    this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id);
+  editBufferInsertText(buffer, text) {
+    const textBytes = this.encoder.encode(text);
+    this.opentui.symbols.editBufferInsertText(buffer, textBytes, textBytes.length);
   }
-  checkHit(renderer, x, y) {
-    return this.opentui.symbols.checkHit(renderer, x, y);
+  editBufferDeleteChar(buffer) {
+    this.opentui.symbols.editBufferDeleteChar(buffer);
   }
-  dumpHitGrid(renderer) {
-    this.opentui.symbols.dumpHitGrid(renderer);
+  editBufferDeleteCharBackward(buffer) {
+    this.opentui.symbols.editBufferDeleteCharBackward(buffer);
   }
-  dumpBuffers(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
-    this.opentui.symbols.dumpBuffers(renderer, ts);
+  editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol) {
+    this.opentui.symbols.editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol);
   }
-  dumpStdoutBuffer(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
-    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
+  editBufferNewLine(buffer) {
+    this.opentui.symbols.editBufferNewLine(buffer);
   }
-  enableMouse(renderer, enableMovement) {
-    this.opentui.symbols.enableMouse(renderer, enableMovement);
+  editBufferDeleteLine(buffer) {
+    this.opentui.symbols.editBufferDeleteLine(buffer);
   }
-  disableMouse(renderer) {
-    this.opentui.symbols.disableMouse(renderer);
+  editBufferMoveCursorLeft(buffer) {
+    this.opentui.symbols.editBufferMoveCursorLeft(buffer);
   }
-  enableKittyKeyboard(renderer, flags) {
-    this.opentui.symbols.enableKittyKeyboard(renderer, flags);
+  editBufferMoveCursorRight(buffer) {
+    this.opentui.symbols.editBufferMoveCursorRight(buffer);
   }
-  disableKittyKeyboard(renderer) {
-    this.opentui.symbols.disableKittyKeyboard(renderer);
+  editBufferMoveCursorUp(buffer) {
+    this.opentui.symbols.editBufferMoveCursorUp(buffer);
   }
-  setupTerminal(renderer, useAlternateScreen) {
-    this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
+  editBufferMoveCursorDown(buffer) {
+    this.opentui.symbols.editBufferMoveCursorDown(buffer);
   }
-  queryPixelResolution(renderer) {
-    this.opentui.symbols.queryPixelResolution(renderer);
+  editBufferGotoLine(buffer, line) {
+    this.opentui.symbols.editBufferGotoLine(buffer, line);
   }
-  createTextBuffer(widthMethod) {
-    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
-    const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
-    if (!bufferPtr) {
-      throw new Error(`Failed to create TextBuffer`);
+  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 cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  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 new TextBuffer(this, bufferPtr);
+    return result;
   }
-  destroyTextBuffer(buffer) {
-    this.opentui.symbols.destroyTextBuffer(buffer);
+  editBufferDebugLogRope(buffer) {
+    this.opentui.symbols.editBufferDebugLogRope(buffer);
   }
-  textBufferGetLength(buffer) {
-    return this.opentui.symbols.textBufferGetLength(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);
   }
-  textBufferReset(buffer) {
-    this.opentui.symbols.textBufferReset(buffer);
+  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);
   }
-  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);
+  editBufferCanUndo(buffer) {
+    return this.opentui.symbols.editBufferCanUndo(buffer);
   }
-  textBufferResetSelection(buffer) {
-    this.opentui.symbols.textBufferResetSelection(buffer);
+  editBufferCanRedo(buffer) {
+    return this.opentui.symbols.editBufferCanRedo(buffer);
   }
-  textBufferSetDefaultFg(buffer, fg2) {
-    const fgPtr = fg2 ? fg2.buffer : null;
-    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
+  editBufferClearHistory(buffer) {
+    this.opentui.symbols.editBufferClearHistory(buffer);
   }
-  textBufferSetDefaultBg(buffer, bg2) {
-    const bgPtr = bg2 ? bg2.buffer : null;
-    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
+  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);
+    }
   }
-  textBufferSetDefaultAttributes(buffer, attributes) {
-    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
-    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
+  editBufferSetPlaceholderColor(buffer, color) {
+    this.opentui.symbols.editBufferSetPlaceholderColor(buffer, color.buffer);
   }
-  textBufferResetDefaults(buffer) {
-    this.opentui.symbols.textBufferResetDefaults(buffer);
+  editBufferClear(buffer) {
+    this.opentui.symbols.editBufferClear(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);
+  editBufferGetNextWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
   }
-  textBufferFinalizeLineInfo(buffer) {
-    this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
+  editBufferGetPrevWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr3(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
   }
-  textBufferGetLineCount(buffer) {
-    return this.opentui.symbols.textBufferGetLineCount(buffer);
+  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);
   }
-  textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr) {
-    return this.opentui.symbols.textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr);
+  editorViewResetSelection(view) {
+    this.opentui.symbols.editorViewResetSelection(view);
   }
-  textBufferGetSelection(buffer) {
-    const packedInfo = this.textBufferGetSelectionInfo(buffer);
+  editorViewGetSelection(view) {
+    const packedInfo = this.opentui.symbols.editorViewGetSelection(view);
     if (packedInfo === 0xffff_ffff_ffff_ffffn) {
       return null;
     }
@@ -7267,92 +9318,67 @@ class FFIRenderLib {
     const end = Number(packedInfo & 0xffff_ffffn);
     return { start, end };
   }
-  textBufferGetSelectionInfo(buffer) {
-    return this.opentui.symbols.textBufferGetSelectionInfo(buffer);
-  }
-  textBufferGetSelectedText(buffer, outPtr, maxLen) {
-    const result = this.opentui.symbols.textBufferGetSelectedText(buffer, outPtr, maxLen);
-    return typeof result === "bigint" ? Number(result) : result;
+  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);
   }
-  textBufferGetPlainText(buffer, outPtr, maxLen) {
-    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
-    return typeof result === "bigint" ? Number(result) : result;
+  editorViewResetLocalSelection(view) {
+    this.opentui.symbols.editorViewResetLocalSelection(view);
   }
-  getSelectedTextBytes(buffer, maxLength) {
+  editorViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetSelectedText(buffer, ptr(outBuffer), maxLength);
-    if (actualLen === 0) {
+    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, actualLen);
+    return outBuffer.slice(0, len);
   }
-  getPlainTextBytes(buffer, maxLength) {
+  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.textBufferGetPlainText(buffer, ptr(outBuffer), maxLength);
-    if (actualLen === 0) {
+    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, 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);
-  }
-  textBufferResetLocalSelection(buffer) {
-    this.opentui.symbols.textBufferResetLocalSelection(buffer);
-  }
-  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);
+    return outBuffer.slice(0, len);
   }
-  textBufferRemoveChunkGroup(buffer, index) {
-    return this.opentui.symbols.textBufferRemoveChunkGroup(buffer, index);
+  editorViewGetVisualCursor(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
   }
-  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);
+  editorViewMoveUpVisual(view) {
+    this.opentui.symbols.editorViewMoveUpVisual(view);
   }
-  textBufferGetChunkGroupCount(buffer) {
-    const result = this.opentui.symbols.textBufferGetChunkGroupCount(buffer);
-    return typeof result === "bigint" ? Number(result) : result;
+  editorViewMoveDownVisual(view) {
+    this.opentui.symbols.editorViewMoveDownVisual(view);
   }
-  textBufferSetWrapWidth(buffer, width) {
-    this.opentui.symbols.textBufferSetWrapWidth(buffer, width);
+  editorViewDeleteSelectedText(view) {
+    this.opentui.symbols.editorViewDeleteSelectedText(view);
   }
-  textBufferSetWrapMode(buffer, mode) {
-    const modeValue = mode === "char" ? 0 : 1;
-    this.opentui.symbols.textBufferSetWrapMode(buffer, modeValue);
+  editorViewSetCursorByOffset(view, offset) {
+    this.opentui.symbols.editorViewSetCursorByOffset(view, offset);
   }
-  getArenaAllocatedBytes() {
-    const result = this.opentui.symbols.getArenaAllocatedBytes();
-    return typeof result === "bigint" ? Number(result) : result;
+  editorViewGetNextWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
   }
-  textBufferGetLineInfo(buffer) {
-    const lineCount = this.textBufferGetLineCount(buffer);
-    if (lineCount === 0) {
-      return { lineStarts: [], lineWidths: [], maxLineWidth: 0 };
-    }
-    const lineStarts = new Uint32Array(lineCount);
-    const lineWidths = new Uint32Array(lineCount);
-    const maxLineWidth = this.textBufferGetLineInfoDirect(buffer, ptr(lineStarts), ptr(lineWidths));
-    return {
-      maxLineWidth,
-      lineStarts: Array.from(lineStarts),
-      lineWidths: Array.from(lineWidths)
-    };
+  editorViewGetPrevWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
   }
-  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);
+  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 +9414,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 +9479,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 +9497,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 +9554,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() {
-    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() {
+  addHighlightByCharRange(highlight) {
     this.guard();
-    this.lib.textBufferResetSelection(this.bufferPtr);
+    this.lib.textBufferAddHighlightByCharRange(this.bufferPtr, highlight);
   }
-  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() {
+  addHighlight(lineIdx, highlight) {
     this.guard();
-    return this.getSelection() !== null;
+    this.lib.textBufferAddHighlight(this.bufferPtr, lineIdx, highlight);
   }
-  insertChunkGroup(index, text, fg2, bg2, attributes) {
+  removeHighlightsByRef(hlRef) {
     this.guard();
-    const textBytes = this.lib.encoder.encode(text);
-    this.insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes);
+    this.lib.textBufferRemoveHighlightsByRef(this.bufferPtr, hlRef);
   }
-  insertEncodedChunkGroup(index, textBytes, fg2, bg2, attributes) {
+  clearLineHighlights(lineIdx) {
     this.guard();
-    this._length = this.lib.textBufferInsertChunkGroup(this.bufferPtr, index, textBytes, fg2 || null, bg2 || null, attributes ?? null);
-    this._lineInfo = undefined;
+    this.lib.textBufferClearLineHighlights(this.bufferPtr, lineIdx);
   }
-  removeChunkGroup(index) {
+  clearAllHighlights() {
     this.guard();
-    this._length = this.lib.textBufferRemoveChunkGroup(this.bufferPtr, index);
-    this._lineInfo = undefined;
+    this.lib.textBufferClearAllHighlights(this.bufferPtr);
   }
-  replaceChunkGroup(index, text, fg2, bg2, attributes) {
+  getLineHighlights(lineIdx) {
     this.guard();
-    const textBytes = this.lib.encoder.encode(text);
-    this.replaceEncodedChunkGroup(index, textBytes, fg2, bg2, attributes);
+    return this.lib.textBufferGetLineHighlights(this.bufferPtr, lineIdx);
   }
-  replaceEncodedChunkGroup(index, textBytes, fg2, bg2, attributes) {
+  setSyntaxStyle(style) {
     this.guard();
-    this._length = this.lib.textBufferReplaceChunkGroup(this.bufferPtr, index, textBytes, fg2 || null, bg2 || null, attributes ?? null);
-    this._lineInfo = undefined;
+    this._syntaxStyle = style ?? undefined;
+    this.lib.textBufferSetSyntaxStyle(this.bufferPtr, style?.ptr ?? null);
   }
-  get chunkGroupCount() {
+  getSyntaxStyle() {
     this.guard();
-    return this.lib.textBufferGetChunkGroupCount(this.bufferPtr);
+    return this._syntaxStyle ?? null;
   }
-  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 +9630,7 @@ class TextBuffer {
 }
 
 // src/Renderable.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/lib/renderable.validations.ts
 function validateOptions(id, options) {
@@ -7656,7 +9723,7 @@ function isRenderable(obj) {
   return !!obj?.[BrandedRenderable];
 }
 
-class BaseRenderable extends EventEmitter4 {
+class BaseRenderable extends EventEmitter6 {
   [BrandedRenderable] = true;
   static renderableNumber = 1;
   _id;
@@ -7728,6 +9795,7 @@ class Renderable extends BaseRenderable {
   _positionType = "relative";
   _overflow = "visible";
   _position = {};
+  _flexShrink = 1;
   renderableMapById = new Map;
   _childrenInLayoutOrder = [];
   _childrenInZIndexOrder = [];
@@ -7974,6 +10042,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 +10056,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 +10114,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 +10265,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) {
@@ -8390,34 +10476,31 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
-    if (this.renderableMapById.has(renderable.id)) {
-      console.warn(`A renderable with id ${renderable.id} already exists in ${this.id}, removing it`);
-      this.remove(renderable.id);
+    const anchorRenderable = index !== undefined ? this._childrenInLayoutOrder[index] : undefined;
+    if (anchorRenderable) {
+      return this.insertBefore(renderable, anchorRenderable);
     }
-    this.replaceParent(renderable);
-    const childLayoutNode = renderable.getLayoutNode();
-    let insertedIndex;
-    if (index !== undefined) {
-      insertedIndex = Math.max(0, Math.min(index, this._childrenInLayoutOrder.length));
-      this._childrenInLayoutOrder.splice(index, 0, renderable);
-      this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(index);
-      this.yogaNode.insertChild(childLayoutNode, insertedIndex);
+    if (renderable.parent === this) {
+      this.yogaNode.removeChild(renderable.getLayoutNode());
+      this._childrenInLayoutOrder.splice(this._childrenInLayoutOrder.indexOf(renderable), 1);
     } else {
-      insertedIndex = this._childrenInLayoutOrder.length;
-      this._childrenInLayoutOrder.push(renderable);
-      this.yogaNode.insertChild(childLayoutNode, insertedIndex);
-    }
-    this.needsZIndexSort = true;
-    this.childrenPrimarySortDirty = true;
-    this.renderableMapById.set(renderable.id, renderable);
-    this._childrenInZIndexOrder.push(renderable);
-    if (typeof renderable.onLifecyclePass === "function") {
-      this._ctx.registerLifecyclePass(renderable);
+      this.replaceParent(renderable);
+      this.needsZIndexSort = true;
+      this.renderableMapById.set(renderable.id, renderable);
+      this._childrenInZIndexOrder.push(renderable);
+      if (typeof renderable.onLifecyclePass === "function") {
+        this._ctx.registerLifecyclePass(renderable);
+      }
+      if (renderable._liveCount > 0) {
+        this.propagateLiveCount(renderable._liveCount);
+      }
     }
     this._newChildren.push(renderable);
-    if (renderable._liveCount > 0) {
-      this.propagateLiveCount(renderable._liveCount);
-    }
+    const childLayoutNode = renderable.getLayoutNode();
+    const insertedIndex = this._childrenInLayoutOrder.length;
+    this._childrenInLayoutOrder.push(renderable);
+    this.yogaNode.insertChild(childLayoutNode, insertedIndex);
+    this.childrenPrimarySortDirty = true;
     this.requestRender();
     return insertedIndex;
   }
@@ -8472,6 +10555,7 @@ class Renderable extends BaseRenderable {
     this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(insertedIndex);
     this._childrenInLayoutOrder.splice(insertedIndex, 0, renderable);
     this.yogaNode.insertChild(renderable.getLayoutNode(), insertedIndex);
+    this.requestRender();
     return insertedIndex;
   }
   getRenderable(id) {
@@ -8960,7 +11044,7 @@ function delegate(mapping, vnode) {
 }
 
 // src/console.ts
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 import { Console } from "console";
 import fs from "fs";
 import path4 from "path";
@@ -8968,9 +11052,9 @@ import util2 from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 
-class Capture extends EventEmitter5 {
+class Capture extends EventEmitter7 {
   output = [];
   constructor() {
     super();
@@ -9046,11 +11130,12 @@ registerEnvVar({
   default: false
 });
 
-class TerminalConsoleCache extends EventEmitter6 {
+class TerminalConsoleCache extends EventEmitter8 {
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
   _cachingEnabled = true;
+  _originalConsole = null;
   get cachedLogs() {
     return this._cachedLogs;
   }
@@ -9058,6 +11143,9 @@ class TerminalConsoleCache extends EventEmitter6 {
     super();
   }
   activate() {
+    if (!this._originalConsole) {
+      this._originalConsole = global.console;
+    }
     this.setupConsoleCapture();
     this.overrideConsoleMethods();
   }
@@ -9107,8 +11195,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) {
@@ -9167,7 +11256,7 @@ var DEFAULT_CONSOLE_OPTIONS = {
 };
 var INDENT_WIDTH = 2;
 
-class TerminalConsole extends EventEmitter6 {
+class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
@@ -9627,7 +11716,7 @@ class TerminalConsole extends EventEmitter6 {
 }
 
 // src/renderer.ts
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // src/lib/objects-in-viewport.ts
 function getObjectsInViewport(viewport, objects, direction = "column", padding = 10, minTriggerSize = 16) {
@@ -9663,24 +11752,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)
@@ -9838,7 +11942,7 @@ var RendererControlState;
   RendererControlState2["EXPLICIT_STOPPED"] = "explicit_stopped";
 })(RendererControlState ||= {});
 
-class CliRenderer extends EventEmitter7 {
+class CliRenderer extends EventEmitter9 {
   static animationFrameId = 0;
   lib;
   rendererPtr;
@@ -9930,30 +12034,10 @@ class CliRenderer extends EventEmitter7 {
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   handleError = ((error) => {
-    this.stop();
-    this.destroy();
-    new Promise((resolve4) => {
-      setTimeout(() => {
-        resolve4(true);
-      }, 100);
-    }).then(() => {
-      this.realStdoutWrite.call(this.stdout, `
-`.repeat(this._terminalHeight));
-      this.realStdoutWrite.call(this.stdout, `
-=== FATAL ERROR OCCURRED ===
-`);
-      this.dumpOutputCache();
-      this.realStdoutWrite.call(this.stdout, `
-Error details:
-`);
-      this.realStdoutWrite.call(this.stdout, error.message || "unknown error");
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      this.realStdoutWrite.call(this.stdout, error.stack || error.toString());
-      this.realStdoutWrite.call(this.stdout, `
-`);
-      process.exit(1);
-    });
+    console.error(error);
+    if (true) {
+      this.console.show();
+    }
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
@@ -9978,8 +12062,10 @@ Captured output:
   exitHandler = (() => {
     this.destroy();
     if (env.OTUI_DUMP_CAPTURES) {
-      this.dumpOutputCache(`=== CAPTURED OUTPUT ===
+      Bun.sleep(100).then(() => {
+        this.dumpOutputCache(`=== CAPTURED OUTPUT ===
 `);
+      });
     }
   }).bind(this);
   warningHandler = ((warning) => {
@@ -10088,7 +12174,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);
@@ -10854,10 +12940,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) {
@@ -10937,7 +13025,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, ExtmarksController, createExtmarksController, 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=A4D3177124AD469F64756E2164756E21
-//# sourceMappingURL=index-kqk5knmb.js.map
+//# debugId=73F3B7C93A2E540464756E2164756E21
+//# sourceMappingURL=index-hgxcxzxa.js.map