@opentui/core 0.5.4 → 0.5.7

package/{chunk-bun-1n307cze.js → chunk-bun-xmsp0nqq.js}

@@ -585,7 +585,7 @@ function toNodeFFIType(type, position) {
     case FFIType.napi_value:
       throw new Error(NODE_NAPI_UNSUPPORTED);
     case FFIType.buffer:
-      return "buffer";
+      return "pointer";
     default:
       return unsupportedNodeFFIType(type);
   }
@@ -6040,9 +6040,11 @@ class Selection {
   _isActive = true;
   _isDragging = true;
   _isStart = false;
-  constructor(anchorRenderable, anchor, focus) {
+  behavior;
+  constructor(anchorRenderable, anchor, focus, behavior = "cell") {
     this._anchor = new SelectionAnchor(anchorRenderable, anchor.x, anchor.y);
     this._focus = { ...focus };
+    this.behavior = behavior;
   }
   get isStart() {
     return this._isStart;
@@ -6133,7 +6135,8 @@ function convertGlobalToLocalSelection(globalSelection, localX, localY) {
     anchorY: globalSelection.anchor.y - localY,
     focusX: globalSelection.focus.x - localX,
     focusY: globalSelection.focus.y - localY,
-    isActive: true
+    isActive: true,
+    behavior: globalSelection.behavior
   };
 }
 
@@ -6168,36 +6171,37 @@ class ASCIIFontSelectionHelper {
     }
     const text = this.getText();
     const font = this.getFont();
-    const selStart = { x: localSelection.anchorX, y: localSelection.anchorY };
-    const selEnd = { x: localSelection.focusX, y: localSelection.focusY };
-    if (height - 1 < selStart.y || 0 > selEnd.y) {
+    const positions = getCharacterPositions(text, font);
+    const minY = Math.min(localSelection.anchorY, localSelection.focusY);
+    const maxY = Math.max(localSelection.anchorY, localSelection.focusY);
+    if (maxY < 0 || minY > height - 1) {
       this.localSelection = null;
       return previousSelection !== null;
     }
-    let startCharIndex = 0;
-    let endCharIndex = text.length;
-    if (selStart.y > height - 1) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selStart.y >= 0 && selStart.y <= height - 1) {
-      if (selStart.x > 0) {
-        startCharIndex = coordinateToCharacterIndex(selStart.x, text, font);
+    const indexAt = (x, y) => {
+      if (y < 0)
+        return 0;
+      if (y > height - 1)
+        return text.length;
+      if (x < 0)
+        return 0;
+      if (x >= width)
+        return text.length;
+      for (let index = 1;index < positions.length; index += 1) {
+        if (x < positions[index])
+          return index - 1;
       }
-    }
-    if (selEnd.y < 0) {
+      return text.length;
+    };
+    const anchorIndex = indexAt(localSelection.anchorX, localSelection.anchorY);
+    const focusIndex = indexAt(localSelection.focusX, localSelection.focusY);
+    const start = Math.min(anchorIndex, focusIndex);
+    const end = Math.min(Math.max(anchorIndex, focusIndex) + 1, text.length);
+    const samePoint = localSelection.anchorX === localSelection.focusX && localSelection.anchorY === localSelection.focusY;
+    if (samePoint || start >= end) {
       this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
-      if (selEnd.x >= 0) {
-        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
-      } else {
-        endCharIndex = 0;
-      }
-    }
-    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
-      this.localSelection = { start: startCharIndex, end: endCharIndex };
     } else {
-      this.localSelection = null;
+      this.localSelection = { start, end };
     }
     return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
@@ -11437,7 +11441,7 @@ class OptimizedBuffer {
     if (matrix.length !== 16)
       throw new RangeError(`colorMatrix matrix must have length 16, got ${matrix.length}`);
     const cellMaskCount = Math.floor(cellMask.length / 3);
-    this.lib.bufferColorMatrix(this.bufferPtr, ptr(matrix), ptr(cellMask), cellMaskCount, strength, target);
+    this.lib.bufferColorMatrix(this.bufferPtr, matrix, cellMask, cellMaskCount, strength, target);
   }
   colorMatrixUniform(matrix, strength = 1, target = 3 /* Both */) {
     this.guard();
@@ -11445,7 +11449,7 @@ class OptimizedBuffer {
       throw new RangeError(`colorMatrixUniform matrix must have length 16, got ${matrix.length}`);
     if (strength === 0)
       return;
-    this.lib.bufferColorMatrixUniform(this.bufferPtr, ptr(matrix), strength, target);
+    this.lib.bufferColorMatrixUniform(this.bufferPtr, matrix, strength, target);
   }
   drawFrameBuffer(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
     this.guard();
@@ -11466,9 +11470,9 @@ class OptimizedBuffer {
     this.guard();
     this.lib.bufferDrawEditorView(this.bufferPtr, editorView.ptr, x, y);
   }
-  drawSuperSampleBuffer(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
+  drawSuperSampleBuffer(x, y, pixelData, pixelDataLength, format, alignedBytesPerRow) {
     this.guard();
-    this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, toPointer(pixelDataPtr), pixelDataLength, format, alignedBytesPerRow);
+    this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, typeof pixelData === "number" || typeof pixelData === "bigint" ? toPointer(pixelData) : pixelData, pixelDataLength, format, alignedBytesPerRow);
   }
   drawImage(image, x, y, width, height, pixelWidth = 0, pixelHeight = 0, sourceX = 0, sourceY = 0, sourceWidth = image.width, sourceHeight = image.height, protocol = "auto") {
     this.guard();
@@ -11487,17 +11491,17 @@ class OptimizedBuffer {
     }
     return this.lib.bufferDrawImage(this.bufferPtr, image.ptr, x, y, width, height, pixelWidth, pixelHeight, sourceX, sourceY, sourceWidth, sourceHeight, protocol);
   }
-  drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
+  drawPackedBuffer(data, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.guard();
-    this.lib.bufferDrawPackedBuffer(this.bufferPtr, toPointer(dataPtr), dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
+    this.lib.bufferDrawPackedBuffer(this.bufferPtr, typeof data === "number" || typeof data === "bigint" ? toPointer(data) : data, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
   drawGrayscaleBuffer(posX, posY, intensities, srcWidth, srcHeight, fg2 = null, bg2 = null) {
     this.guard();
-    this.lib.bufferDrawGrayscaleBuffer(this.bufferPtr, posX, posY, ptr(intensities), srcWidth, srcHeight, fg2, bg2);
+    this.lib.bufferDrawGrayscaleBuffer(this.bufferPtr, posX, posY, intensities, srcWidth, srcHeight, fg2, bg2);
   }
   drawGrayscaleBufferSupersampled(posX, posY, intensities, srcWidth, srcHeight, fg2 = null, bg2 = null) {
     this.guard();
-    this.lib.bufferDrawGrayscaleBufferSupersampled(this.bufferPtr, posX, posY, ptr(intensities), srcWidth, srcHeight, fg2, bg2);
+    this.lib.bufferDrawGrayscaleBufferSupersampled(this.bufferPtr, posX, posY, intensities, srcWidth, srcHeight, fg2, bg2);
   }
   resize(width, height) {
     this.guard();
@@ -13201,6 +13205,28 @@ var CursorStateStruct = defineStruct([
   ["b", "f32"],
   ["a", "f32"]
 ]);
+var EmbeddedTerminalCursorStruct = defineStruct([
+  ["x", "u16"],
+  ["y", "u16"],
+  ["hasValue", "bool_u8"],
+  ["visible", "bool_u8"],
+  ["blinking", "bool_u8"],
+  ["wideTail", "bool_u8"],
+  ["style", "u8"],
+  ["colorHasValue", "bool_u8"],
+  ["colorR", "u8"],
+  ["colorG", "u8"],
+  ["colorB", "u8"],
+  ["padding", "u8"]
+]);
+var EmbeddedTerminalKeyOptionsStruct = defineStruct([
+  ["action", "u8"],
+  ["composing", "u8"],
+  ["mods", "u16"],
+  ["consumedMods", "u16"],
+  ["padding", "u16"],
+  ["unshiftedCodepoint", "u32"]
+]);
 var CursorStyleOptionsStruct = defineStruct([
   ["style", "u8", { default: 255 }],
   ["blinking", "u8", { default: 255 }],
@@ -13517,14 +13543,56 @@ function toSafeFFIU32Length(value, label) {
 function isFFIU32(value) {
   return Number.isInteger(value) && value >= 0 && value <= MAX_FFI_U32;
 }
-function ptrOrNull(value) {
-  return value.byteLength === 0 ? null : ptr(value);
+function viewOrNull(value) {
+  return value.byteLength === 0 ? null : value;
 }
-function rgbaPtr(value) {
-  return ptr(value.buffer);
+function retainedPtrOrNull(value) {
+  if (value.byteLength === 0)
+    return null;
+  value.buffer;
+  return ptr(value);
+}
+var EMBEDDED_TERMINAL_ERRORS = {
+  [-1]: "invalid value or handle",
+  [-2]: "out of memory",
+  [-3]: "embedded terminal support is unavailable",
+  [-4]: "output buffer is too small",
+  [-5]: "processing failed"
+};
+function embeddedTerminalResult(status, operation) {
+  if (status >= 0)
+    return status;
+  throw new Error(`Embedded terminal ${operation} failed: ${EMBEDDED_TERMINAL_ERRORS[status] ?? `status ${status}`}`);
+}
+function embeddedTerminalDimension(value, name) {
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    throw new RangeError(`Embedded terminal ${name} must be an integer between 1 and 65535`);
+  }
+  return value;
 }
-function optionalRgbaPtr(value) {
-  return value ? rgbaPtr(value) : null;
+function embeddedTerminalI32(value, name) {
+  if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+    throw new RangeError(`Embedded terminal ${name} must be a signed 32-bit integer`);
+  }
+  return value;
+}
+function embeddedTerminalF32(value, name) {
+  if (!Number.isFinite(value) || Math.abs(value) > 340282346638528860000000000000000000000) {
+    throw new RangeError(`Embedded terminal ${name} must be a finite 32-bit float`);
+  }
+  return value;
+}
+function rgbaBuffer(value) {
+  return value.buffer;
+}
+function optionalRgbaBuffer(value) {
+  return value ? rgbaBuffer(value) : null;
+}
+function selectionBehaviorByte(behavior) {
+  return behavior === "word" ? 1 : behavior === "line" ? 2 : 0;
+}
+function editorLocalSelectionFlags(updateCursor, followCursor, behavior) {
+  return ffiBool(updateCursor) | ffiBool(followCursor) << 1 | selectionBehaviorByte(behavior) << 2;
 }
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
@@ -13560,6 +13628,70 @@ function getOpenTUILib(libPath) {
       args: ["u32", "u32", "u32"],
       returns: "bool"
     },
+    createEmbeddedTerminal: {
+      args: ["u16", "u16", "u32", "ptr"],
+      returns: "i32"
+    },
+    destroyEmbeddedTerminal: {
+      args: ["u32"],
+      returns: "void"
+    },
+    embeddedTerminalWrite: {
+      args: ["u32", "ptr", "u32"],
+      returns: "i32"
+    },
+    embeddedTerminalResize: {
+      args: ["u32", "u16", "u16"],
+      returns: "i32"
+    },
+    embeddedTerminalInvalidate: {
+      args: ["u32"],
+      returns: "i32"
+    },
+    embeddedTerminalScroll: {
+      args: ["u32", "i32"],
+      returns: "i32"
+    },
+    embeddedTerminalSetSelection: {
+      args: ["u32", "u16", "u16", "u16", "u16"],
+      returns: "i32"
+    },
+    embeddedTerminalClearSelection: {
+      args: ["u32"],
+      returns: "i32"
+    },
+    embeddedTerminalGetSelectedText: {
+      args: ["u32", "buffer", "u32", "buffer"],
+      returns: "i32"
+    },
+    embeddedTerminalCompose: {
+      args: ["u32", "u32", "i32", "i32"],
+      returns: "i32"
+    },
+    embeddedTerminalCursor: {
+      args: ["u32", "ptr"],
+      returns: "i32"
+    },
+    embeddedTerminalEncodeKey: {
+      args: ["u32", "ptr", "ptr", "u32", "ptr", "u32", "ptr", "u32", "ptr"],
+      returns: "i32"
+    },
+    embeddedTerminalEncodeMouse: {
+      args: ["u32", "u8", "i8", "u16", "f32", "f32", "u8", "ptr", "u32"],
+      returns: "i32"
+    },
+    embeddedTerminalEncodePaste: {
+      args: ["u32", "ptr", "u32", "ptr", "u32"],
+      returns: "i32"
+    },
+    embeddedTerminalEncodeFocus: {
+      args: ["u32", "u8", "ptr", "u32"],
+      returns: "i32"
+    },
+    embeddedTerminalDrainResponses: {
+      args: ["u32", "ptr", "u32"],
+      returns: "i32"
+    },
     createRenderer: {
       args: ["u32", "u32", "u8", "u8", "ptr"],
       returns: "u32"
@@ -13581,7 +13713,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     setBackgroundColor: {
-      args: ["u32", "ptr"],
+      args: ["u32", "buffer"],
       returns: "void"
     },
     setRenderOffset: {
@@ -13629,7 +13761,7 @@ function getOpenTUILib(libPath) {
       returns: "u64"
     },
     commitSplitFooterSnapshot: {
-      args: ["u32", "u32", "u32", "bool", "bool", "u32", "bool", "bool", "bool"],
+      args: ["u32", "u32", "u32", "u8", "u32"],
       returns: "u64"
     },
     getNextBuffer: {
@@ -13641,7 +13773,7 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     rendererSetPaletteState: {
-      args: ["u32", "ptr", "u32", "ptr", "ptr", "u32"],
+      args: ["u32", "buffer", "u32", "buffer", "buffer", "u32"],
       returns: "void"
     },
     queryPixelResolution: {
@@ -13653,7 +13785,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     createOptimizedBuffer: {
-      args: ["u32", "u32", "bool", "u8", "ptr", "u32"],
+      args: ["u32", "u32", "u8", "u8", "buffer", "u32"],
       returns: "u32"
     },
     destroyOptimizedBuffer: {
@@ -13673,7 +13805,7 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     bufferClear: {
-      args: ["u32", "ptr"],
+      args: ["u32", "buffer"],
       returns: "void"
     },
     bufferGetCharPtr: {
@@ -13701,7 +13833,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     bufferGetId: {
-      args: ["u32", "ptr", "u32"],
+      args: ["u32", "buffer", "u32"],
       returns: "u32"
     },
     bufferGetRealCharSize: {
@@ -13713,19 +13845,19 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     bufferDrawText: {
-      args: ["u32", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      args: ["u32", "ptr", "u32", "u32", "u32", "buffer", "ptr", "u32"],
       returns: "void"
     },
     bufferSetCellWithAlphaBlending: {
-      args: ["u32", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      args: ["u32", "u32", "u32", "u32", "buffer", "buffer", "u32"],
       returns: "void"
     },
     bufferSetCell: {
-      args: ["u32", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      args: ["u32", "u32", "u32", "u32", "buffer", "buffer", "u32"],
       returns: "void"
     },
     bufferFillRect: {
-      args: ["u32", "u32", "u32", "u32", "u32", "ptr"],
+      args: ["u32", "u32", "u32", "u32", "u32", "buffer"],
       returns: "void"
     },
     bufferColorMatrix: {
@@ -13765,7 +13897,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     setCursorColor: {
-      args: ["u32", "ptr"],
+      args: ["u32", "buffer"],
       returns: "void"
     },
     getCursorState: {
@@ -13777,7 +13909,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     setDebugOverlay: {
-      args: ["u32", "bool", "u8"],
+      args: ["u32", "u8", "u8"],
       returns: "void"
     },
     clearTerminal: {
@@ -13893,11 +14025,26 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     bufferDrawGrid: {
-      args: ["u32", "ptr", "ptr", "ptr", "ptr", "u32", "ptr", "u32", "ptr"],
+      args: ["u32", "buffer", "buffer", "buffer", "buffer", "u32", "buffer", "u32", "ptr"],
       returns: "void"
     },
     bufferDrawBox: {
-      args: ["u32", "i32", "i32", "u32", "u32", "ptr", "u32", "ptr", "ptr", "ptr", "ptr", "u32", "ptr", "u32"],
+      args: [
+        "u32",
+        "i32",
+        "i32",
+        "u32",
+        "u32",
+        "buffer",
+        "u32",
+        "buffer",
+        "buffer",
+        "buffer",
+        "ptr",
+        "u32",
+        "ptr",
+        "u32"
+      ],
       returns: "void"
     },
     bufferPushScissorRect: {
@@ -14169,7 +14316,7 @@ function getOpenTUILib(libPath) {
       returns: "u64"
     },
     textBufferViewSetLocalSelection: {
-      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "u8"],
       returns: "bool"
     },
     textBufferViewUpdateSelection: {
@@ -14177,13 +14324,21 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     textBufferViewUpdateLocalSelection: {
-      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "u8"],
       returns: "bool"
     },
     textBufferViewResetLocalSelection: {
       args: ["u32"],
       returns: "void"
     },
+    textBufferViewSetSelectionOccupancy: {
+      args: ["u32", "u8"],
+      returns: "void"
+    },
+    textBufferViewGetSelectionOccupancy: {
+      args: ["u32"],
+      returns: "u8"
+    },
     textBufferViewSetWrapWidth: {
       args: ["u32", "u32"],
       returns: "void"
@@ -14229,7 +14384,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     textBufferViewSetTabIndicatorColor: {
-      args: ["u32", "ptr"],
+      args: ["u32", "buffer"],
       returns: "void"
     },
     textBufferViewSetTruncate: {
@@ -14265,7 +14420,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     editorViewGetViewport: {
-      args: ["u32", "ptr", "ptr", "ptr", "ptr"],
+      args: ["u32", "buffer", "buffer", "buffer", "buffer"],
       returns: "void"
     },
     editorViewSetScrollMargin: {
@@ -14469,7 +14624,7 @@ function getOpenTUILib(libPath) {
       returns: "u64"
     },
     editorViewSetLocalSelection: {
-      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "bool", "bool"],
+      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "u8"],
       returns: "bool"
     },
     editorViewUpdateSelection: {
@@ -14477,19 +14632,35 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     editorViewUpdateLocalSelection: {
-      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "bool", "bool"],
+      args: ["u32", "i32", "i32", "i32", "i32", "ptr", "ptr", "u8"],
       returns: "bool"
     },
     editorViewResetLocalSelection: {
       args: ["u32"],
       returns: "void"
     },
+    editorViewConvertSelectionToCell: {
+      args: ["u32"],
+      returns: "bool"
+    },
+    editorViewSetSelectionOccupancy: {
+      args: ["u32", "u8"],
+      returns: "void"
+    },
+    editorViewSetSelectionInclusive: {
+      args: ["u32", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetSelectionColors: {
+      args: ["u32", "ptr", "ptr"],
+      returns: "void"
+    },
     editorViewGetSelectedTextBytes: {
       args: ["u32", "ptr", "u32"],
       returns: "u32"
     },
     editorViewGetCursor: {
-      args: ["u32", "ptr", "ptr"],
+      args: ["u32", "buffer", "buffer"],
       returns: "void"
     },
     editorViewGetText: {
@@ -14536,6 +14707,10 @@ function getOpenTUILib(libPath) {
       args: ["u32", "ptr"],
       returns: "void"
     },
+    editorViewGotoVisualLineEnd: {
+      args: ["u32"],
+      returns: "void"
+    },
     editorViewSetPlaceholderStyledText: {
       args: ["u32", "ptr", "u32"],
       returns: "void"
@@ -14545,7 +14720,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     editorViewSetTabIndicatorColor: {
-      args: ["u32", "ptr"],
+      args: ["u32", "buffer"],
       returns: "void"
     },
     getArenaAllocatedBytes: {
@@ -14584,21 +14759,21 @@ function getOpenTUILib(libPath) {
     imageRetainIccCache: { args: [], returns: "void" },
     imageReleaseIccCache: { args: [], returns: "void" },
     imageTestFailIccProfileCopyAllocationOnce: { args: [], returns: "void" },
-    imageDecode: { args: ["ptr", "u32", "ptr"], returns: "u32" },
-    imageCreateFromRgba: { args: ["ptr", "u64", "u32", "u32", "u32", "ptr"], returns: "u32" },
+    imageDecode: { args: ["ptr", "u32", "buffer"], returns: "u32" },
+    imageCreateFromRgba: { args: ["ptr", "u64", "u32", "u32", "u32", "buffer"], returns: "u32" },
     imageDestroy: { args: ["u32"], returns: "void" },
-    imageRetain: { args: ["u32", "ptr"], returns: "u32" },
+    imageRetain: { args: ["u32", "buffer"], returns: "u32" },
     imageGetInfo: { args: ["u32", "ptr"], returns: "u32" },
     imageMaterialize: { args: ["u32"], returns: "u32" },
     imageEnsureEncodedPng: { args: ["u32"], returns: "u32" },
     imageGetPixelsPtr: { args: ["u32"], returns: "ptr" },
-    imageClone: { args: ["u32", "ptr"], returns: "u32" },
+    imageClone: { args: ["u32", "buffer"], returns: "u32" },
     imageCopyPixels: { args: ["u32", "ptr", "u64", "u32", "u8"], returns: "u32" },
-    imageResize: { args: ["u32", "u32", "u32", "u32", "ptr"], returns: "u32" },
-    imageExtract: { args: ["u32", "u32", "u32", "u32", "u32", "ptr"], returns: "u32" },
-    imageExtend: { args: ["u32", "u32", "u32", "u32", "u32", "ptr", "ptr"], returns: "u32" },
-    imageTransform: { args: ["u32", "u32", "ptr"], returns: "u32" },
-    imageComposite: { args: ["u32", "u32", "i32", "i32", "u32", "u8", "ptr"], returns: "u32" },
+    imageResize: { args: ["u32", "u32", "u32", "u32", "buffer"], returns: "u32" },
+    imageExtract: { args: ["u32", "u32", "u32", "u32", "u32", "buffer"], returns: "u32" },
+    imageExtend: { args: ["u32", "u32", "u32", "u32", "u32", "buffer", "buffer"], returns: "u32" },
+    imageTransform: { args: ["u32", "u32", "buffer"], returns: "u32" },
+    imageComposite: { args: ["u32", "u32", "i32", "i32", "u32", "u8", "buffer"], returns: "u32" },
     getTerminalCapabilities: {
       args: ["u32", "ptr"],
       returns: "void"
@@ -14616,7 +14791,7 @@ function getOpenTUILib(libPath) {
       returns: "void"
     },
     bufferDrawChar: {
-      args: ["u32", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      args: ["u32", "u32", "u32", "u32", "buffer", "buffer", "u32"],
       returns: "void"
     },
     yogaConfigCreate: {
@@ -14836,7 +15011,7 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     audioGetPlaybackDeviceName: {
-      args: ["u32", "u32", "ptr", "u32"],
+      args: ["u32", "u32", "buffer", "u32"],
       returns: "u32"
     },
     audioIsPlaybackDeviceDefault: {
@@ -14860,7 +15035,7 @@ function getOpenTUILib(libPath) {
       returns: "u32"
     },
     audioGetCaptureDeviceName: {
-      args: ["u32", "u32", "ptr", "u32"],
+      args: ["u32", "u32", "buffer", "u32"],
       returns: "u32"
     },
     audioIsCaptureDeviceDefault: {
@@ -14888,7 +15063,7 @@ function getOpenTUILib(libPath) {
       returns: "bool"
     },
     audioReadCapture: {
-      args: ["u32", "ptr", "u32", "u32", "ptr"],
+      args: ["u32", "buffer", "u32", "u32", "ptr"],
       returns: "i32"
     },
     audioGetCaptureStats: {
@@ -14944,7 +15119,7 @@ function getOpenTUILib(libPath) {
       returns: "i32"
     },
     audioLoad: {
-      args: ["u32", "ptr", "u32", "ptr"],
+      args: ["u32", "buffer", "u32", "ptr"],
       returns: "i32"
     },
     audioUnload: {
@@ -14964,7 +15139,7 @@ function getOpenTUILib(libPath) {
       returns: "i32"
     },
     audioCreateGroup: {
-      args: ["u32", "ptr", "u32", "ptr"],
+      args: ["u32", "buffer", "u32", "ptr"],
       returns: "i32"
     },
     audioSetGroupVolume: {
@@ -14976,15 +15151,15 @@ function getOpenTUILib(libPath) {
       returns: "i32"
     },
     audioMixToBuffer: {
-      args: ["u32", "ptr", "u32", "u8"],
+      args: ["u32", "buffer", "u32", "u8"],
       returns: "i32"
     },
     audioEnableTap: {
-      args: ["u32", "bool", "u32"],
+      args: ["u32", "u8", "u32"],
       returns: "i32"
     },
     audioReadTap: {
-      args: ["u32", "ptr", "u32", "u8", "ptr"],
+      args: ["u32", "buffer", "u32", "u8", "ptr"],
       returns: "i32"
     },
     audioGetStats: {
@@ -15012,7 +15187,7 @@ function getOpenTUILib(libPath) {
       returns: "i32"
     },
     streamDrainSpans: {
-      args: ["ptr", "ptr", "u32"],
+      args: ["ptr", "buffer", "u32"],
       returns: "u32"
     },
     streamClose: {
@@ -15199,7 +15374,6 @@ class FFIRenderLib {
   opentui;
   iccCacheClient = false;
   yogaLayout = new Float32Array(6);
-  yogaLayoutPtr = ptr(this.yogaLayout);
   ffiStructStorage = {
     logicalCursor: {
       ...allocStruct(LogicalCursorStruct),
@@ -15219,6 +15393,8 @@ class FFIRenderLib {
       ...allocStruct(MeasureResultStruct),
       result: { lineCount: 0, widthColsMax: 0 }
     },
+    embeddedTerminalCursor: allocStruct(EmbeddedTerminalCursorStruct),
+    embeddedTerminalKeyOptions: allocStruct(EmbeddedTerminalKeyOptionsStruct),
     audioStreamStats: {
       ...allocStruct(AudioStreamStatsStruct),
       result: {
@@ -15264,6 +15440,134 @@ class FFIRenderLib {
   nativeRenderableSetMeasureTarget(handle, kind, target) {
     return Boolean(this.opentui.symbols.nativeRenderableSetMeasureTarget(handle, kind, target));
   }
+  createEmbeddedTerminal(options) {
+    const cols = embeddedTerminalDimension(options.cols, "columns");
+    const rows = embeddedTerminalDimension(options.rows, "rows");
+    const maxScrollback = toSafeFFIU32Length(options.maxScrollback ?? 1e4, "Embedded terminal maxScrollback");
+    const out = new Uint32Array(1);
+    embeddedTerminalResult(this.opentui.symbols.createEmbeddedTerminal(cols, rows, maxScrollback, out), "creation");
+    if (!out[0])
+      throw new Error("Embedded terminal creation returned an invalid handle");
+    return out[0];
+  }
+  destroyEmbeddedTerminal(handle) {
+    this.opentui.symbols.destroyEmbeddedTerminal(handle);
+  }
+  embeddedTerminalWrite(handle, data) {
+    const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
+    const length = toSafeFFIU32Length(bytes.byteLength, "Embedded terminal write length");
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalWrite(handle, length === 0 ? null : bytes, length), "write");
+  }
+  embeddedTerminalResize(handle, cols, rows) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalResize(handle, embeddedTerminalDimension(cols, "columns"), embeddedTerminalDimension(rows, "rows")), "resize");
+  }
+  embeddedTerminalInvalidate(handle) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalInvalidate(handle), "invalidation");
+  }
+  embeddedTerminalScroll(handle, delta) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalScroll(handle, embeddedTerminalI32(delta, "scroll delta")), "scroll");
+  }
+  embeddedTerminalSetSelection(handle, start, end) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalSetSelection(handle, embeddedTerminalDimension(start.x + 1, "selection start x") - 1, embeddedTerminalDimension(start.y + 1, "selection start y") - 1, embeddedTerminalDimension(end.x + 1, "selection end x") - 1, embeddedTerminalDimension(end.y + 1, "selection end y") - 1), "selection update");
+  }
+  embeddedTerminalClearSelection(handle) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalClearSelection(handle), "selection clear");
+  }
+  embeddedTerminalGetSelectedText(handle) {
+    const required = new Uint32Array(1);
+    const read = (output2) => this.opentui.symbols.embeddedTerminalGetSelectedText(handle, viewOrNull(output2), output2.byteLength, required);
+    const initial = new Uint8Array(256);
+    const status = read(initial);
+    if (status >= 0)
+      return initial.slice(0, status);
+    if (status !== -4 || required[0] <= initial.byteLength)
+      embeddedTerminalResult(status, "selection query");
+    const output = new Uint8Array(required[0]);
+    const length = embeddedTerminalResult(read(output), "selection query");
+    return output.slice(0, length);
+  }
+  embeddedTerminalCompose(handle, target, x, y) {
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalCompose(handle, target, embeddedTerminalI32(x, "composition x"), embeddedTerminalI32(y, "composition y")), "compose");
+  }
+  embeddedTerminalCursor(handle) {
+    const storage = this.ffiStructStorage.embeddedTerminalCursor;
+    embeddedTerminalResult(this.opentui.symbols.embeddedTerminalCursor(handle, storage.buffer), "cursor query");
+    const result = EmbeddedTerminalCursorStruct.unpack(storage.buffer);
+    return {
+      x: result.x,
+      y: result.y,
+      hasValue: result.hasValue,
+      visible: result.visible,
+      blinking: result.blinking,
+      wideTail: result.wideTail,
+      style: ["bar", "block", "underline", "block-hollow"][result.style] ?? "block",
+      ...result.colorHasValue ? { color: { r: result.colorR, g: result.colorG, b: result.colorB } } : {}
+    };
+  }
+  embeddedTerminalEncodeKey(handle, key) {
+    const options = this.ffiStructStorage.embeddedTerminalKeyOptions;
+    EmbeddedTerminalKeyOptionsStruct.packInto({
+      action: { release: 0, press: 1, repeat: 2 }[key.action ?? "press"],
+      composing: key.composing ? 1 : 0,
+      mods: key.mods ?? 0,
+      consumedMods: key.consumedMods ?? 0,
+      padding: 0,
+      unshiftedCodepoint: key.unshiftedCodepoint ?? 0
+    }, options.view, 0);
+    const keyCode = key.key ? this.encoder.encode(key.key) : new Uint8Array;
+    const keyCodeLength = toSafeFFIU32Length(keyCode.byteLength, "Embedded terminal physical key length");
+    const text = key.text ? this.encoder.encode(key.text) : new Uint8Array;
+    const textLength = toSafeFFIU32Length(text.byteLength, "Embedded terminal key text length");
+    const required = new Uint32Array(1);
+    const encode = (output2) => this.opentui.symbols.embeddedTerminalEncodeKey(handle, options.buffer, keyCodeLength === 0 ? null : keyCode, keyCodeLength, textLength === 0 ? null : text, textLength, output2, output2.byteLength, required);
+    const initial = new Uint8Array(Math.max(64, textLength));
+    const status = encode(initial);
+    if (status >= 0)
+      return initial.slice(0, status);
+    if (status !== -4 || required[0] <= initial.byteLength)
+      embeddedTerminalResult(status, "key encoding");
+    const output = new Uint8Array(required[0]);
+    const length = embeddedTerminalResult(encode(output), "key encoding");
+    return output.slice(0, length);
+  }
+  embeddedTerminalEncodeMouse(handle, mouse) {
+    const output = new Uint8Array(128);
+    const length = embeddedTerminalResult(this.opentui.symbols.embeddedTerminalEncodeMouse(handle, { press: 0, release: 1, motion: 2 }[mouse.action], mouse.button ? { unknown: 0, left: 1, right: 2, middle: 3, four: 4, five: 5, six: 6, seven: 7 }[mouse.button] : -1, mouse.mods ?? 0, embeddedTerminalF32(mouse.x, "mouse x"), embeddedTerminalF32(mouse.y, "mouse y"), mouse.anyButtonPressed ? 1 : 0, output, output.byteLength), "mouse encoding");
+    return output.slice(0, length);
+  }
+  embeddedTerminalEncodePaste(handle, input) {
+    const inputLength = toSafeFFIU32Length(input.byteLength, "Embedded terminal paste length");
+    const outputLength = toSafeFFIU32Length(inputLength + 16, "Embedded terminal paste output length");
+    const output = new Uint8Array(outputLength);
+    const length = embeddedTerminalResult(this.opentui.symbols.embeddedTerminalEncodePaste(handle, inputLength === 0 ? null : input, inputLength, output, output.byteLength), "paste encoding");
+    return output.slice(0, length);
+  }
+  embeddedTerminalEncodeFocus(handle, focused) {
+    const output = new Uint8Array(16);
+    const length = embeddedTerminalResult(this.opentui.symbols.embeddedTerminalEncodeFocus(handle, focused ? 1 : 0, output, output.byteLength), "focus encoding");
+    return output.slice(0, length);
+  }
+  embeddedTerminalDrainResponses(handle) {
+    const chunks = [];
+    while (true) {
+      const output = new Uint8Array(64 * 1024);
+      const status = this.opentui.symbols.embeddedTerminalDrainResponses(handle, output, output.byteLength);
+      if (status === -4)
+        continue;
+      const length = embeddedTerminalResult(status, "response drain");
+      if (length > 0)
+        chunks.push(output.slice(0, length));
+      if (length < output.byteLength)
+        break;
+    }
+    const result = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.byteLength, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  }
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.imageRetainIccCache();
@@ -15417,7 +15721,7 @@ class FFIRenderLib {
   setTerminalEnvVar(renderer, key, value) {
     const keyBytes = this.encoder.encode(key);
     const valueBytes = this.encoder.encode(value);
-    return this.opentui.symbols.setTerminalEnvVar(renderer, ptrOrNull(keyBytes), keyBytes.byteLength, ptrOrNull(valueBytes), valueBytes.byteLength);
+    return this.opentui.symbols.setTerminalEnvVar(renderer, viewOrNull(keyBytes), keyBytes.byteLength, viewOrNull(valueBytes), valueBytes.byteLength);
   }
   destroyRenderer(renderer, flushInput = false) {
     this.opentui.symbols.destroyRenderer(renderer, ffiBool(flushInput));
@@ -15429,7 +15733,7 @@ class FFIRenderLib {
     this.opentui.symbols.setClearOnShutdown(renderer, ffiBool(clear));
   }
   setBackgroundColor(renderer, color) {
-    this.opentui.symbols.setBackgroundColor(renderer, rgbaPtr(color));
+    this.opentui.symbols.setBackgroundColor(renderer, rgbaBuffer(color));
   }
   setRenderOffset(renderer, offset) {
     this.opentui.symbols.setRenderOffset(renderer, offset);
@@ -15457,7 +15761,7 @@ class FFIRenderLib {
   }
   getRenderStats(renderer) {
     const statsBuffer = new ArrayBuffer(NativeRenderStatsStruct.size);
-    this.opentui.symbols.getRenderStats(renderer, ptr(statsBuffer));
+    this.opentui.symbols.getRenderStats(renderer, statsBuffer);
     const stats = NativeRenderStatsStruct.unpack(statsBuffer);
     return {
       nativeLastFrameTime: stats.lastFrameTime,
@@ -15492,7 +15796,7 @@ class FFIRenderLib {
     for (let index = 0;index < palette.length; index++) {
       paletteBuffer.set(palette[index].buffer, index * 4);
     }
-    this.opentui.symbols.rendererSetPaletteState(renderer, ptr(paletteBuffer), palette.length, rgbaPtr(defaultForeground), rgbaPtr(defaultBackground), paletteEpoch >>> 0);
+    this.opentui.symbols.rendererSetPaletteState(renderer, paletteBuffer, palette.length, rgbaBuffer(defaultForeground), rgbaBuffer(defaultBackground), paletteEpoch >>> 0);
   }
   bufferGetCharPtr(buffer) {
     const ptr3 = this.opentui.symbols.bufferGetCharPtr(buffer);
@@ -15531,14 +15835,14 @@ class FFIRenderLib {
   bufferGetId(buffer) {
     const maxLen = 256;
     const outBuffer = new Uint8Array(maxLen);
-    const actualLen = this.opentui.symbols.bufferGetId(buffer, ptr(outBuffer), maxLen);
+    const actualLen = this.opentui.symbols.bufferGetId(buffer, outBuffer, maxLen);
     return this.decoder.decode(outBuffer.slice(0, actualLen));
   }
   bufferGetRealCharSize(buffer) {
     return this.opentui.symbols.bufferGetRealCharSize(buffer);
   }
   bufferWriteResolvedChars(buffer, outputBuffer, addLineBreaks) {
-    return this.opentui.symbols.bufferWriteResolvedChars(buffer, ptrOrNull(outputBuffer), outputBuffer.byteLength, ffiBool(addLineBreaks));
+    return this.opentui.symbols.bufferWriteResolvedChars(buffer, viewOrNull(outputBuffer), outputBuffer.byteLength, ffiBool(addLineBreaks));
   }
   getBufferWidth(buffer) {
     return this.opentui.symbols.getBufferWidth(buffer);
@@ -15547,39 +15851,39 @@ class FFIRenderLib {
     return this.opentui.symbols.getBufferHeight(buffer);
   }
   bufferClear(buffer, color) {
-    this.opentui.symbols.bufferClear(buffer, rgbaPtr(color));
+    this.opentui.symbols.bufferClear(buffer, rgbaBuffer(color));
   }
   bufferDrawText(buffer, text, x, y, color, bgColor, attributes) {
     const textBytes = this.encoder.encode(text);
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = rgbaPtr(color);
-    this.opentui.symbols.bufferDrawText(buffer, ptrOrNull(textBytes), textBytes.byteLength, x, y, fg2, bg2, attributes ?? 0);
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = rgbaBuffer(color);
+    this.opentui.symbols.bufferDrawText(buffer, viewOrNull(textBytes), textBytes.byteLength, x, y, fg2, bg2, attributes ?? 0);
   }
   bufferSetCellWithAlphaBlending(buffer, x, y, char, color, bgColor, attributes) {
     const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
-    const bg2 = rgbaPtr(bgColor);
-    const fg2 = rgbaPtr(color);
+    const bg2 = rgbaBuffer(bgColor);
+    const fg2 = rgbaBuffer(color);
     this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x, y, charPtr, fg2, bg2, attributes ?? 0);
   }
   bufferSetCell(buffer, x, y, char, color, bgColor, attributes) {
     const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
-    const bg2 = rgbaPtr(bgColor);
-    const fg2 = rgbaPtr(color);
+    const bg2 = rgbaBuffer(bgColor);
+    const fg2 = rgbaBuffer(color);
     this.opentui.symbols.bufferSetCell(buffer, x, y, charPtr, fg2, bg2, attributes ?? 0);
   }
   bufferFillRect(buffer, x, y, width, height, color) {
-    const bg2 = rgbaPtr(color);
+    const bg2 = rgbaBuffer(color);
     this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg2);
   }
-  bufferColorMatrix(buffer, matrixPtr, cellMaskPtr, cellMaskCount, strength, target) {
-    this.opentui.symbols.bufferColorMatrix(buffer, matrixPtr, cellMaskPtr, cellMaskCount, strength, target);
+  bufferColorMatrix(buffer, matrix, cellMask, cellMaskCount, strength, target) {
+    this.opentui.symbols.bufferColorMatrix(buffer, matrix, cellMask, cellMaskCount, strength, target);
   }
-  bufferColorMatrixUniform(buffer, matrixPtr, strength, target) {
-    this.opentui.symbols.bufferColorMatrixUniform(buffer, matrixPtr, strength, target);
+  bufferColorMatrixUniform(buffer, matrix, strength, target) {
+    this.opentui.symbols.bufferColorMatrixUniform(buffer, matrix, strength, target);
   }
-  bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
+  bufferDrawSuperSampleBuffer(buffer, x, y, pixelData, pixelDataLength, format, alignedBytesPerRow) {
     const formatId = format === "bgra8unorm" ? 0 : 1;
-    this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, formatId, alignedBytesPerRow);
+    this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelData, pixelDataLength, formatId, alignedBytesPerRow);
   }
   bufferDrawImage(buffer, image, x, y, width, height, pixelWidth, pixelHeight, sourceX, sourceY, sourceWidth, sourceHeight, protocol) {
     const protocolId = { auto: 0, kitty: 1, sixel: 2, blocks: 3 }[protocol];
@@ -15599,38 +15903,38 @@ class FFIRenderLib {
     }, storage.view, 0);
     return Boolean(this.opentui.symbols.bufferDrawImage(buffer, image, storage.buffer));
   }
-  bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
-    this.opentui.symbols.bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
+  bufferDrawPackedBuffer(buffer, data, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
+    this.opentui.symbols.bufferDrawPackedBuffer(buffer, data, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
-  bufferDrawGrayscaleBuffer(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2, bg2) {
-    this.opentui.symbols.bufferDrawGrayscaleBuffer(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, optionalRgbaPtr(fg2), optionalRgbaPtr(bg2));
+  bufferDrawGrayscaleBuffer(buffer, posX, posY, intensities, srcWidth, srcHeight, fg2, bg2) {
+    this.opentui.symbols.bufferDrawGrayscaleBuffer(buffer, posX, posY, intensities, srcWidth, srcHeight, optionalRgbaBuffer(fg2), optionalRgbaBuffer(bg2));
   }
-  bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2, bg2) {
-    this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, optionalRgbaPtr(fg2), optionalRgbaPtr(bg2));
+  bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensities, srcWidth, srcHeight, fg2, bg2) {
+    this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensities, srcWidth, srcHeight, optionalRgbaBuffer(fg2), optionalRgbaBuffer(bg2));
   }
   bufferDrawGrid(buffer, borderChars, borderFg, borderBg, columnOffsets, columnCount, rowOffsets, rowCount, options) {
     GridDrawOptionsStruct.packInto({ drawInner: options.drawInner, drawOuter: options.drawOuter }, this.ffiStructStorage.gridDrawOptions.view, 0);
-    this.opentui.symbols.bufferDrawGrid(buffer, ptr(borderChars), rgbaPtr(borderFg), rgbaPtr(borderBg), ptr(columnOffsets), columnCount, ptr(rowOffsets), rowCount, this.ffiStructStorage.gridDrawOptions.buffer);
+    this.opentui.symbols.bufferDrawGrid(buffer, borderChars, rgbaBuffer(borderFg), rgbaBuffer(borderBg), columnOffsets, columnCount, rowOffsets, rowCount, this.ffiStructStorage.gridDrawOptions.buffer);
   }
   bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, titleColor, title, bottomTitle) {
     const titleBytes = title ? this.encoder.encode(title) : null;
     const titleLen = titleBytes?.byteLength ?? 0;
-    const titlePtr = titleBytes ? ptr(titleBytes) : null;
+    const titleBuffer = titleBytes ? titleBytes : null;
     const bottomTitleBytes = bottomTitle ? this.encoder.encode(bottomTitle) : null;
     const bottomTitleLen = bottomTitleBytes?.byteLength ?? 0;
-    const bottomTitlePtr = bottomTitleBytes ? ptr(bottomTitleBytes) : null;
-    this.opentui.symbols.bufferDrawBox(buffer, x, y, width, height, ptr(borderChars), packedOptions, rgbaPtr(borderColor), rgbaPtr(backgroundColor), rgbaPtr(titleColor), titlePtr, titleLen, bottomTitlePtr, bottomTitleLen);
+    const bottomTitleBuffer = bottomTitleBytes ? bottomTitleBytes : null;
+    this.opentui.symbols.bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, rgbaBuffer(borderColor), rgbaBuffer(backgroundColor), rgbaBuffer(titleColor), titleBuffer, titleLen, bottomTitleBuffer, bottomTitleLen);
   }
   bufferResize(buffer, width, height) {
     this.opentui.symbols.bufferResize(buffer, width, height);
   }
   linkAlloc(url) {
     const urlBytes = this.encoder.encode(url);
-    return this.opentui.symbols.linkAlloc(ptrOrNull(urlBytes), urlBytes.byteLength);
+    return this.opentui.symbols.linkAlloc(viewOrNull(urlBytes), urlBytes.byteLength);
   }
   linkGetUrl(linkId, maxLen = 512) {
     const outBuffer = new Uint8Array(maxLen);
-    const actualLen = this.opentui.symbols.linkGetUrl(linkId, ptrOrNull(outBuffer), maxLen);
+    const actualLen = this.opentui.symbols.linkGetUrl(linkId, viewOrNull(outBuffer), maxLen);
     return this.decoder.decode(outBuffer.slice(0, actualLen));
   }
   attributesWithLink(baseAttributes, linkId) {
@@ -15646,11 +15950,11 @@ class FFIRenderLib {
     this.opentui.symbols.setCursorPosition(renderer, x, y, ffiBool(visible));
   }
   setCursorColor(renderer, color) {
-    this.opentui.symbols.setCursorColor(renderer, rgbaPtr(color));
+    this.opentui.symbols.setCursorColor(renderer, rgbaBuffer(color));
   }
   getCursorState(renderer) {
     const cursorBuffer = new ArrayBuffer(CursorStateStruct.size);
-    this.opentui.symbols.getCursorState(renderer, ptr(cursorBuffer));
+    this.opentui.symbols.getCursorState(renderer, cursorBuffer);
     const struct = CursorStateStruct.unpack(cursorBuffer);
     return {
       x: struct.x,
@@ -15682,7 +15986,8 @@ class FFIRenderLib {
     return this.unpackRenderOperationResult(this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, ffiBool(force)));
   }
   commitSplitFooterSnapshot(renderer, snapshot, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame = true, finalizeFrame = true) {
-    return this.unpackRenderOperationResult(this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, ffiBool(startOnNewLine), ffiBool(trailingNewline), pinnedRenderOffset, ffiBool(force), ffiBool(beginFrame), ffiBool(finalizeFrame)));
+    const flags = ffiBool(startOnNewLine) | ffiBool(trailingNewline) << 1 | ffiBool(force) << 2 | ffiBool(beginFrame) << 3 | ffiBool(finalizeFrame) << 4;
+    return this.unpackRenderOperationResult(this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, flags, pinnedRenderOffset));
   }
   createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
     if (Number.isNaN(width) || Number.isNaN(height)) {
@@ -15691,7 +15996,7 @@ class FFIRenderLib {
     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, ffiBool(respectAlpha), widthMethodCode, ptr(idBytes), idBytes.byteLength);
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, ffiBool(respectAlpha), widthMethodCode, idBytes, idBytes.byteLength);
     if (!bufferPtr) {
       throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
     }
@@ -15715,12 +16020,12 @@ class FFIRenderLib {
   }
   setTerminalTitle(renderer, title) {
     const titleBytes = this.encoder.encode(title);
-    this.opentui.symbols.setTerminalTitle(renderer, ptrOrNull(titleBytes), titleBytes.byteLength);
+    this.opentui.symbols.setTerminalTitle(renderer, viewOrNull(titleBytes), titleBytes.byteLength);
   }
   copyToClipboardOSC52(renderer, target, textUtf8) {
     if (textUtf8.byteLength > 4294967295)
       return false;
-    return Boolean(this.opentui.symbols.copyToClipboardOSC52(renderer, target, ptrOrNull(textUtf8), textUtf8.byteLength));
+    return Boolean(this.opentui.symbols.copyToClipboardOSC52(renderer, target, viewOrNull(textUtf8), textUtf8.byteLength));
   }
   clearClipboardOSC52(renderer, target) {
     return Boolean(this.opentui.symbols.clearClipboardOSC52(renderer, target));
@@ -15895,7 +16200,7 @@ class FFIRenderLib {
     const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     if (bytes.length === 0)
       return;
-    this.opentui.symbols.writeOut(renderer, ptrOrNull(bytes), bytes.byteLength);
+    this.opentui.symbols.writeOut(renderer, viewOrNull(bytes), bytes.byteLength);
   }
   yogaConfigCreate() {
     const config = this.opentui.symbols.yogaConfigCreate();
@@ -16007,7 +16312,7 @@ class FFIRenderLib {
   }
   yogaNodeGetComputedLayout(node) {
     const layout = this.yogaLayout;
-    this.opentui.symbols.yogaNodeGetComputedLayout(node, this.yogaLayoutPtr);
+    this.opentui.symbols.yogaNodeGetComputedLayout(node, this.yogaLayout);
     return {
       left: layout[0],
       top: layout[1],
@@ -16104,16 +16409,16 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferClear(buffer);
   }
   textBufferSetDefaultFg(buffer, fg2) {
-    const fgPtr = optionalRgbaPtr(fg2);
-    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
+    const fgBuffer = optionalRgbaBuffer(fg2);
+    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgBuffer);
   }
   textBufferSetDefaultBg(buffer, bg2) {
-    const bgPtr = optionalRgbaPtr(bg2);
-    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
+    const bgBuffer = optionalRgbaBuffer(bg2);
+    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgBuffer);
   }
   textBufferSetDefaultAttributes(buffer, attributes) {
     const attrValue = attributes === null ? null : new Uint32Array([attributes]);
-    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue ? ptr(attrValue) : null);
+    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
   }
   textBufferResetDefaults(buffer) {
     this.opentui.symbols.textBufferResetDefaults(buffer);
@@ -16125,14 +16430,14 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferSetTabWidth(buffer, width);
   }
   textBufferRegisterMemBuffer(buffer, bytes, owned = false) {
-    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, ptrOrNull(bytes), bytes.byteLength, ffiBool(owned));
+    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, retainedPtrOrNull(bytes), bytes.byteLength, ffiBool(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, ptrOrNull(bytes), bytes.byteLength, ffiBool(owned));
+    return this.opentui.symbols.textBufferReplaceMemBuffer(buffer, memId, retainedPtrOrNull(bytes), bytes.byteLength, ffiBool(owned));
   }
   textBufferClearMemRegistry(buffer) {
     this.opentui.symbols.textBufferClearMemRegistry(buffer);
@@ -16141,14 +16446,14 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferSetTextFromMem(buffer, memId);
   }
   textBufferAppend(buffer, bytes) {
-    this.opentui.symbols.textBufferAppend(buffer, ptrOrNull(bytes), bytes.byteLength);
+    this.opentui.symbols.textBufferAppend(buffer, retainedPtrOrNull(bytes), bytes.byteLength);
   }
   textBufferAppendFromMemId(buffer, memId) {
     this.opentui.symbols.textBufferAppendFromMemId(buffer, memId);
   }
   textBufferLoadFile(buffer, path3) {
     const pathBytes = this.encoder.encode(path3);
-    return this.opentui.symbols.textBufferLoadFile(buffer, ptrOrNull(pathBytes), pathBytes.byteLength);
+    return this.opentui.symbols.textBufferLoadFile(buffer, viewOrNull(pathBytes), pathBytes.byteLength);
   }
   textBufferSetStyledText(buffer, chunks) {
     if (chunks.length === 0) {
@@ -16161,12 +16466,12 @@ class FFIRenderLib {
   textBufferGetLineCount(buffer) {
     return this.opentui.symbols.textBufferGetLineCount(buffer);
   }
-  textBufferGetPlainText(buffer, outPtr, maxLen) {
-    return this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
+  textBufferGetPlainText(buffer, outBuffer, maxLen) {
+    return this.opentui.symbols.textBufferGetPlainText(buffer, outBuffer, maxLen);
   }
   getPlainTextBytes(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetPlainText(buffer, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.textBufferGetPlainText(buffer, viewOrNull(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -16174,7 +16479,7 @@ class FFIRenderLib {
   }
   textBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0) {
       return null;
@@ -16183,7 +16488,7 @@ class FFIRenderLib {
   }
   textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0) {
       return null;
@@ -16201,8 +16506,8 @@ class FFIRenderLib {
     this.opentui.symbols.destroyTextBufferView(view);
   }
   textBufferViewSetSelection(view, start, end, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
     this.opentui.symbols.textBufferViewSetSelection(view, start, end, bg2, fg2);
   }
   textBufferViewResetSelection(view) {
@@ -16220,24 +16525,30 @@ class FFIRenderLib {
   textBufferViewGetSelectionInfo(view) {
     return this.opentui.symbols.textBufferViewGetSelectionInfo(view);
   }
-  textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
-    return Boolean(this.opentui.symbols.textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2));
+  textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, behavior) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    return Boolean(this.opentui.symbols.textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, selectionBehaviorByte(behavior)));
   }
   textBufferViewUpdateSelection(view, end, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
     this.opentui.symbols.textBufferViewUpdateSelection(view, end, bg2, fg2);
   }
-  textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
-    return Boolean(this.opentui.symbols.textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2));
+  textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, behavior) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    return Boolean(this.opentui.symbols.textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, selectionBehaviorByte(behavior)));
   }
   textBufferViewResetLocalSelection(view) {
     this.opentui.symbols.textBufferViewResetLocalSelection(view);
   }
+  textBufferViewSetSelectionOccupancy(view, occupancy) {
+    this.opentui.symbols.textBufferViewSetSelectionOccupancy(view, occupancy === "boundary" ? 1 : 0);
+  }
+  textBufferViewGetSelectionOccupancy(view) {
+    return this.opentui.symbols.textBufferViewGetSelectionOccupancy(view) === 1 ? "boundary" : "cell";
+  }
   textBufferViewSetWrapWidth(view, width) {
     this.opentui.symbols.textBufferViewSetWrapWidth(view, width);
   }
@@ -16256,7 +16567,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLineInfoDirect(view, ptr(outBuffer));
+    this.textBufferViewGetLineInfoDirect(view, outBuffer);
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -16271,7 +16582,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
+    this.textBufferViewGetLogicalLineInfoDirect(view, outBuffer);
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -16287,21 +16598,21 @@ class FFIRenderLib {
   textBufferViewGetVirtualLineCount(view) {
     return this.opentui.symbols.textBufferViewGetVirtualLineCount(view);
   }
-  textBufferViewGetLineInfoDirect(view, outPtr) {
-    this.opentui.symbols.textBufferViewGetLineInfoDirect(view, outPtr);
+  textBufferViewGetLineInfoDirect(view, outBuffer) {
+    this.opentui.symbols.textBufferViewGetLineInfoDirect(view, outBuffer);
   }
-  textBufferViewGetLogicalLineInfoDirect(view, outPtr) {
-    this.opentui.symbols.textBufferViewGetLogicalLineInfoDirect(view, outPtr);
+  textBufferViewGetLogicalLineInfoDirect(view, outBuffer) {
+    this.opentui.symbols.textBufferViewGetLogicalLineInfoDirect(view, outBuffer);
   }
-  textBufferViewGetSelectedText(view, outPtr, maxLen) {
-    return this.opentui.symbols.textBufferViewGetSelectedText(view, outPtr, maxLen);
+  textBufferViewGetSelectedText(view, outBuffer, maxLen) {
+    return this.opentui.symbols.textBufferViewGetSelectedText(view, outBuffer, maxLen);
   }
-  textBufferViewGetPlainText(view, outPtr, maxLen) {
-    return this.opentui.symbols.textBufferViewGetPlainText(view, outPtr, maxLen);
+  textBufferViewGetPlainText(view, outBuffer, maxLen) {
+    return this.opentui.symbols.textBufferViewGetPlainText(view, outBuffer, maxLen);
   }
   textBufferViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetSelectedText(view, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, viewOrNull(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -16309,7 +16620,7 @@ class FFIRenderLib {
   }
   textBufferViewGetPlainTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetPlainText(view, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, viewOrNull(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -16319,7 +16630,7 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferViewSetTabIndicator(view, indicator);
   }
   textBufferViewSetTabIndicatorColor(view, color) {
-    this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, rgbaPtr(color));
+    this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, rgbaBuffer(color));
   }
   textBufferViewSetTruncate(view, truncate) {
     this.opentui.symbols.textBufferViewSetTruncate(view, ffiBool(truncate));
@@ -16334,11 +16645,11 @@ class FFIRenderLib {
   }
   textBufferAddHighlightByCharRange(buffer, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, packedHighlight);
   }
   textBufferAddHighlight(buffer, lineIdx, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, packedHighlight);
   }
   textBufferRemoveHighlightsByRef(buffer, hlRef) {
     this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
@@ -16354,7 +16665,7 @@ class FFIRenderLib {
   }
   textBufferGetLineHighlights(buffer, lineIdx) {
     const outCountBuf = new Uint32Array(1);
-    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr(outCountBuf));
+    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, outCountBuf);
     if (!nativePtr)
       return [];
     const count = outCountBuf[0];
@@ -16373,7 +16684,7 @@ class FFIRenderLib {
   }
   getBuildOptions() {
     const optionsBuffer = new ArrayBuffer(BuildOptionsStruct.size);
-    this.opentui.symbols.getBuildOptions(ptr(optionsBuffer));
+    this.opentui.symbols.getBuildOptions(optionsBuffer);
     const options = BuildOptionsStruct.unpack(optionsBuffer);
     return {
       gpaSafeStats: !!options.gpaSafeStats,
@@ -16382,7 +16693,7 @@ class FFIRenderLib {
   }
   getAllocatorStats() {
     const statsBuffer = new ArrayBuffer(AllocatorStatsStruct.size);
-    this.opentui.symbols.getAllocatorStats(ptr(statsBuffer));
+    this.opentui.symbols.getAllocatorStats(statsBuffer);
     const stats = AllocatorStatsStruct.unpack(statsBuffer);
     return {
       totalRequestedBytes: toNumber(stats.totalRequestedBytes),
@@ -16419,7 +16730,7 @@ class FFIRenderLib {
     const y = new Uint32Array(1);
     const width = new Uint32Array(1);
     const height = new Uint32Array(1);
-    this.opentui.symbols.editorViewGetViewport(view, ptr(x), ptr(y), ptr(width), ptr(height));
+    this.opentui.symbols.editorViewGetViewport(view, x, y, width, height);
     return {
       offsetX: x[0],
       offsetY: y[0],
@@ -16449,7 +16760,7 @@ class FFIRenderLib {
   }
   editorViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr(outBuffer));
+    this.opentui.symbols.editorViewGetLineInfoDirect(view, outBuffer);
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -16464,7 +16775,7 @@ class FFIRenderLib {
   }
   editorViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
+    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, outBuffer);
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -16489,20 +16800,20 @@ class FFIRenderLib {
     this.opentui.symbols.destroyEditBuffer(buffer);
   }
   editBufferSetText(buffer, textBytes) {
-    this.opentui.symbols.editBufferSetText(buffer, ptrOrNull(textBytes), textBytes.byteLength);
+    this.opentui.symbols.editBufferSetText(buffer, viewOrNull(textBytes), textBytes.byteLength);
   }
   editBufferSetTextFromMem(buffer, memId) {
     this.opentui.symbols.editBufferSetTextFromMem(buffer, memId);
   }
   editBufferReplaceText(buffer, textBytes) {
-    this.opentui.symbols.editBufferReplaceText(buffer, ptrOrNull(textBytes), textBytes.byteLength);
+    this.opentui.symbols.editBufferReplaceText(buffer, viewOrNull(textBytes), textBytes.byteLength);
   }
   editBufferReplaceTextFromMem(buffer, memId) {
     this.opentui.symbols.editBufferReplaceTextFromMem(buffer, memId);
   }
   editBufferGetText(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetText(buffer, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16510,11 +16821,11 @@ class FFIRenderLib {
   }
   editBufferInsertChar(buffer, char) {
     const charBytes = this.encoder.encode(char);
-    this.opentui.symbols.editBufferInsertChar(buffer, ptrOrNull(charBytes), charBytes.byteLength);
+    this.opentui.symbols.editBufferInsertChar(buffer, viewOrNull(charBytes), charBytes.byteLength);
   }
   editBufferInsertText(buffer, text) {
     const textBytes = this.encoder.encode(text);
-    this.opentui.symbols.editBufferInsertText(buffer, ptrOrNull(textBytes), textBytes.byteLength);
+    this.opentui.symbols.editBufferInsertText(buffer, viewOrNull(textBytes), textBytes.byteLength);
   }
   editBufferDeleteChar(buffer) {
     this.opentui.symbols.editBufferDeleteChar(buffer);
@@ -16576,7 +16887,7 @@ class FFIRenderLib {
   }
   editBufferUndo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferUndo(buffer, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16584,7 +16895,7 @@ class FFIRenderLib {
   }
   editBufferRedo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferRedo(buffer, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16636,7 +16947,7 @@ class FFIRenderLib {
   }
   editBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16644,15 +16955,15 @@ class FFIRenderLib {
   }
   editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
     return usesBunFFI ? outBuffer.slice(0, len) : trimNodeFFIOutputBytes(outBuffer, len);
   }
   editorViewSetSelection(view, start, end, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
     this.opentui.symbols.editorViewSetSelection(view, start, end, bg2, fg2);
   }
   editorViewResetSelection(view) {
@@ -16667,27 +16978,43 @@ class FFIRenderLib {
     const end = Number(packedInfo & 0xffff_ffffn);
     return { start, end };
   }
-  editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
-    return Boolean(this.opentui.symbols.editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, ffiBool(updateCursor), ffiBool(followCursor)));
+  editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor, behavior) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    return Boolean(this.opentui.symbols.editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, editorLocalSelectionFlags(updateCursor, followCursor, behavior)));
   }
   editorViewUpdateSelection(view, end, bgColor, fgColor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
     this.opentui.symbols.editorViewUpdateSelection(view, end, bg2, fg2);
   }
-  editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
-    const bg2 = optionalRgbaPtr(bgColor);
-    const fg2 = optionalRgbaPtr(fgColor);
-    return Boolean(this.opentui.symbols.editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, ffiBool(updateCursor), ffiBool(followCursor)));
+  editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor, behavior) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    return Boolean(this.opentui.symbols.editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, editorLocalSelectionFlags(updateCursor, followCursor, behavior)));
   }
   editorViewResetLocalSelection(view) {
     this.opentui.symbols.editorViewResetLocalSelection(view);
   }
+  editorViewConvertSelectionToCell(view) {
+    return Boolean(this.opentui.symbols.editorViewConvertSelectionToCell(view));
+  }
+  editorViewSetSelectionOccupancy(view, occupancy) {
+    this.opentui.symbols.editorViewSetSelectionOccupancy(view, occupancy === "boundary" ? 1 : 0);
+  }
+  editorViewSetSelectionInclusive(view, start, end, bgColor, fgColor) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    this.opentui.symbols.editorViewSetSelectionInclusive(view, start, end, bg2, fg2);
+  }
+  editorViewSetSelectionColors(view, bgColor, fgColor) {
+    const bg2 = optionalRgbaBuffer(bgColor);
+    const fg2 = optionalRgbaBuffer(fgColor);
+    this.opentui.symbols.editorViewSetSelectionColors(view, bg2, fg2);
+  }
   editorViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16696,12 +17023,12 @@ class FFIRenderLib {
   editorViewGetCursor(view) {
     const row = new Uint32Array(1);
     const col = new Uint32Array(1);
-    this.opentui.symbols.editorViewGetCursor(view, ptr(row), ptr(col));
+    this.opentui.symbols.editorViewGetCursor(view, row, col);
     return { row: row[0], col: col[0] };
   }
   editorViewGetText(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetText(view, ptrOrNull(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetText(view, viewOrNull(outBuffer), maxLength);
     const len = actualLen;
     if (len === 0)
       return null;
@@ -16755,6 +17082,9 @@ class FFIRenderLib {
     const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
     return { ...cursor };
   }
+  editorViewGotoVisualLineEnd(view) {
+    this.opentui.symbols.editorViewGotoVisualLineEnd(view);
+  }
   bufferPushScissorRect(buffer, x, y, width, height) {
     this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height);
   }
@@ -16778,7 +17108,7 @@ class FFIRenderLib {
   }
   getTerminalCapabilities(renderer) {
     const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
-    this.opentui.symbols.getTerminalCapabilities(renderer, ptr(capsBuffer));
+    this.opentui.symbols.getTerminalCapabilities(renderer, capsBuffer);
     const caps = TerminalCapabilitiesStruct.unpack(capsBuffer);
     return {
       kitty_keyboard: caps.kitty_keyboard,
@@ -16811,14 +17141,14 @@ class FFIRenderLib {
   }
   processCapabilityResponse(renderer, response) {
     const responseBytes = this.encoder.encode(response);
-    this.opentui.symbols.processCapabilityResponse(renderer, ptrOrNull(responseBytes), responseBytes.byteLength);
+    this.opentui.symbols.processCapabilityResponse(renderer, viewOrNull(responseBytes), responseBytes.byteLength);
   }
   encodeUnicode(text, widthMethod) {
     const textBytes = this.encoder.encode(text);
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const outPtrBuffer = new ArrayBuffer(8);
     const outLenBuffer = new ArrayBuffer(8);
-    const success = this.opentui.symbols.encodeUnicode(ptrOrNull(textBytes), textBytes.byteLength, ptr(outPtrBuffer), ptr(outLenBuffer), widthMethodCode);
+    const success = this.opentui.symbols.encodeUnicode(viewOrNull(textBytes), textBytes.byteLength, outPtrBuffer, outLenBuffer, widthMethodCode);
     if (!success) {
       return null;
     }
@@ -16838,11 +17168,11 @@ class FFIRenderLib {
     this.opentui.symbols.freeUnicode(encoded.ptr, encoded.data.length);
   }
   bufferDrawChar(buffer, char, x, y, fg2, bg2, attributes = 0) {
-    this.opentui.symbols.bufferDrawChar(buffer, char, x, y, rgbaPtr(fg2), rgbaPtr(bg2), attributes);
+    this.opentui.symbols.bufferDrawChar(buffer, char, x, y, rgbaBuffer(fg2), rgbaBuffer(bg2), attributes);
   }
   createAudioEngine(options) {
     const optionsBuffer = options == null ? null : AudioCreateOptionsStruct.pack(options);
-    const engineHandle = this.opentui.symbols.createAudioEngine(optionsBuffer ? ptr(optionsBuffer) : null);
+    const engineHandle = this.opentui.symbols.createAudioEngine(optionsBuffer);
     return engineHandle ? engineHandle : null;
   }
   destroyAudioEngine(engine) {
@@ -16856,7 +17186,7 @@ class FFIRenderLib {
   }
   audioGetPlaybackDeviceName(engine, index) {
     const outBuffer = new Uint8Array(512);
-    const bytesWritten = toNumber(this.opentui.symbols.audioGetPlaybackDeviceName(engine, index, ptr(outBuffer), outBuffer.length));
+    const bytesWritten = toNumber(this.opentui.symbols.audioGetPlaybackDeviceName(engine, index, outBuffer, outBuffer.length));
     const safeBytesWritten = Math.max(0, Math.min(outBuffer.length, bytesWritten));
     return this.decoder.decode(outBuffer.subarray(0, safeBytesWritten));
   }
@@ -16946,7 +17276,7 @@ class FFIRenderLib {
     } catch {
       return -1;
     }
-    return this.opentui.symbols.audioStart(engine, optionsBuffer ? ptr(optionsBuffer) : null);
+    return this.opentui.symbols.audioStart(engine, optionsBuffer);
   }
   audioStartMixer(engine) {
     return this.opentui.symbols.audioStartMixer(engine);
@@ -17005,7 +17335,7 @@ class FFIRenderLib {
   audioLoad(engine, data) {
     const outBuffer = new ArrayBuffer(4);
     const dataLength = toSafeFFIU32Length(data.byteLength, "Audio data length");
-    const status = this.opentui.symbols.audioLoad(engine, ptr(data), dataLength, ptr(outBuffer));
+    const status = this.opentui.symbols.audioLoad(engine, data, dataLength, outBuffer);
     if (status !== 0) {
       return { status, soundId: null };
     }
@@ -17020,7 +17350,7 @@ class FFIRenderLib {
       return { status: -1, voiceId: null };
     const outBuffer = new ArrayBuffer(4);
     const optionsBuffer = options ? AudioVoiceOptionsStruct.pack(options) : null;
-    const status = this.opentui.symbols.audioPlay(engine, soundId, optionsBuffer ? ptr(optionsBuffer) : null, ptr(outBuffer));
+    const status = this.opentui.symbols.audioPlay(engine, soundId, optionsBuffer, outBuffer);
     if (status !== 0) {
       return { status, voiceId: null };
     }
@@ -17039,7 +17369,7 @@ class FFIRenderLib {
     const outBuffer = new ArrayBuffer(4);
     const nameBytes = this.encoder.encode(name);
     const nameLength = toSafeFFIU32Length(nameBytes.byteLength, "Audio group name length");
-    const status = this.opentui.symbols.audioCreateGroup(engine, ptr(nameBytes), nameLength, ptr(outBuffer));
+    const status = this.opentui.symbols.audioCreateGroup(engine, nameBytes, nameLength, outBuffer);
     if (status !== 0) {
       return { status, groupId: null };
     }
@@ -17053,14 +17383,14 @@ class FFIRenderLib {
     return this.opentui.symbols.audioSetMasterVolume(engine, volume);
   }
   audioMixToBuffer(engine, outBuffer, frameCount, channels) {
-    return this.opentui.symbols.audioMixToBuffer(engine, ptr(outBuffer), frameCount, channels);
+    return this.opentui.symbols.audioMixToBuffer(engine, outBuffer, frameCount, channels);
   }
   audioEnableTap(engine, enabled, capacityFrames) {
     return this.opentui.symbols.audioEnableTap(engine, ffiBool(enabled), capacityFrames);
   }
   audioReadTap(engine, outBuffer, frameCount, channels) {
     const outFramesReadBuffer = new ArrayBuffer(4);
-    const status = this.opentui.symbols.audioReadTap(engine, ptr(outBuffer), frameCount, channels, ptr(outFramesReadBuffer));
+    const status = this.opentui.symbols.audioReadTap(engine, outBuffer, frameCount, channels, outFramesReadBuffer);
     if (status !== 0) {
       return { status, framesRead: 0 };
     }
@@ -17069,7 +17399,7 @@ class FFIRenderLib {
   }
   audioGetStats(engine) {
     const statsBuffer = new ArrayBuffer(AudioStatsStruct.size);
-    const status = this.opentui.symbols.audioGetStats(engine, ptr(statsBuffer));
+    const status = this.opentui.symbols.audioGetStats(engine, statsBuffer);
     if (status !== 0) {
       return null;
     }
@@ -17094,7 +17424,7 @@ class FFIRenderLib {
   }
   createNativeSpanFeed(options) {
     const optionsBuffer = options == null ? null : NativeSpanFeedOptionsStruct.pack(options);
-    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr(optionsBuffer) : null);
+    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer);
     if (!streamPtr) {
       throw new Error("Failed to create stream");
     }
@@ -17109,13 +17439,13 @@ class FFIRenderLib {
   }
   streamWrite(stream, data) {
     const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
-    return this.opentui.symbols.streamWrite(stream, ptrOrNull(bytes), bytes.byteLength);
+    return this.opentui.symbols.streamWrite(stream, viewOrNull(bytes), bytes.byteLength);
   }
   streamCommit(stream) {
     return this.opentui.symbols.streamCommit(stream);
   }
   streamDrainSpans(stream, outBuffer, maxSpans) {
-    const count = this.opentui.symbols.streamDrainSpans(stream, ptr(outBuffer), maxSpans);
+    const count = this.opentui.symbols.streamDrainSpans(stream, outBuffer, maxSpans);
     return toNumber(count);
   }
   streamClose(stream) {
@@ -17123,11 +17453,11 @@ class FFIRenderLib {
   }
   streamSetOptions(stream, options) {
     const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options);
-    return this.opentui.symbols.streamSetOptions(stream, ptr(optionsBuffer));
+    return this.opentui.symbols.streamSetOptions(stream, optionsBuffer);
   }
   streamGetStats(stream) {
     const statsBuffer = new ArrayBuffer(NativeSpanFeedStatsStruct.size);
-    const status = this.opentui.symbols.streamGetStats(stream, ptr(statsBuffer));
+    const status = this.opentui.symbols.streamGetStats(stream, statsBuffer);
     if (status !== 0) {
       return null;
     }
@@ -17141,7 +17471,7 @@ class FFIRenderLib {
   }
   streamReserve(stream, minLen) {
     const reserveBuffer = new ArrayBuffer(ReserveInfoStruct.size);
-    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr(reserveBuffer));
+    const status = this.opentui.symbols.streamReserve(stream, minLen, reserveBuffer);
     if (status !== 0) {
       return { status, info: null };
     }
@@ -17162,13 +17492,13 @@ class FFIRenderLib {
   }
   syntaxStyleRegister(style, name, fg2, bg2, attributes) {
     const nameBytes = this.encoder.encode(name);
-    const fgPtr = optionalRgbaPtr(fg2);
-    const bgPtr = optionalRgbaPtr(bg2);
-    return this.opentui.symbols.syntaxStyleRegister(style, ptrOrNull(nameBytes), nameBytes.byteLength, fgPtr, bgPtr, attributes);
+    const fgBuffer = optionalRgbaBuffer(fg2);
+    const bgBuffer = optionalRgbaBuffer(bg2);
+    return this.opentui.symbols.syntaxStyleRegister(style, viewOrNull(nameBytes), nameBytes.byteLength, fgBuffer, bgBuffer, attributes);
   }
   syntaxStyleResolveByName(style, name) {
     const nameBytes = this.encoder.encode(name);
-    const id = this.opentui.symbols.syntaxStyleResolveByName(style, ptrOrNull(nameBytes), nameBytes.byteLength);
+    const id = this.opentui.symbols.syntaxStyleResolveByName(style, viewOrNull(nameBytes), nameBytes.byteLength);
     return id === 0 ? null : id;
   }
   syntaxStyleGetStyleCount(style) {
@@ -17266,7 +17596,7 @@ class FFIRenderLib {
     this.opentui.symbols.editorViewSetTabIndicator(view, indicator);
   }
   editorViewSetTabIndicatorColor(view, color) {
-    this.opentui.symbols.editorViewSetTabIndicatorColor(view, rgbaPtr(color));
+    this.opentui.symbols.editorViewSetTabIndicatorColor(view, rgbaBuffer(color));
   }
   onNativeEvent(name, handler) {
     this._nativeEvents.on(name, handler);
@@ -18269,5 +18599,5 @@ var yoga_default = Yoga;
 
 export { toArrayBuffer, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, sleep, stringWidth2 as stringWidth, resolveBundledFilePath, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, 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, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, terminalNamedSingleStrokeKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, destroyTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, createHostClipboard, createClipboard, ClipboardTarget, createRendererClipboardAdapter, Clipboard, detectLinks, OptimizedBuffer, TextBuffer, SpanInfoStruct, NativeAudioStreamFormat, NativeAudioStreamState, NativeAudioStreamStateNames, NativeAudioStreamCloseReason, NativeAudioStreamState2 as NativeAudioStreamState1, NativeAudioStreamCloseReason2 as NativeAudioStreamCloseReason1, NativeAudioStreamFormat2 as NativeAudioStreamFormat1, NativeClipboardOperationStatus, NativeClipboardStartStatus, NativeClipboardCancelStatus, NativeClipboardCopyStatus, NativeClipboardDestroyStatus, NativeClipboardShutdownStatus, LogLevel2 as LogLevel, NativeMeasureTargetKind, setRenderLibPath, resolveRenderLib, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel as LogLevel1, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_BASELINE, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_AROUND, ALIGN_SPACE_EVENLY, BOX_SIZING_BORDER_BOX, BOX_SIZING_CONTENT_BOX, DIMENSION_WIDTH, DIMENSION_HEIGHT, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, DISPLAY_CONTENTS, EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_START, EDGE_END, EDGE_HORIZONTAL, EDGE_VERTICAL, EDGE_ALL, ERRATA_NONE, ERRATA_STRETCH_FLEX_BASIS, ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING, ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE, ERRATA_ALL, ERRATA_CLASSIC, EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_COLUMN, GUTTER_ROW, GUTTER_ALL, JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_EVENLY, LOG_LEVEL_ERROR, LOG_LEVEL_WARN, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, LOG_LEVEL_FATAL, MEASURE_MODE_UNDEFINED, MEASURE_MODE_EXACTLY, MEASURE_MODE_AT_MOST, NODE_TYPE_DEFAULT, NODE_TYPE_TEXT, OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, POSITION_TYPE_ABSOLUTE, UNIT_UNDEFINED, UNIT_POINT, UNIT_PERCENT, UNIT_AUTO, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, Config, Node, exports_yoga, yoga_default };
 
-//# debugId=8AC4CFB5CFC8941664756E2164756E21
-//# sourceMappingURL=chunk-bun-1n307cze.js.map
+//# debugId=CCD1F52D948CB76B64756E2164756E21
+//# sourceMappingURL=chunk-bun-xmsp0nqq.js.map