@opentui/core 0.2.0 → 0.2.2

package/{index-mw2x3082.js → index-jv9g79dk.js}

@@ -1,35 +1,5 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -10492,6 +10462,12 @@ function createExtmarksController(editBuffer, editorView) {
 
 // src/lib/terminal-palette.ts
 var SYSTEM_CLOCK2 = new SystemClock;
+registerEnvVar({
+  name: "OTUI_PALETTE_IDLE_TIMEOUT_MS",
+  description: "Milliseconds of silence after palette queries before using fallback colors.",
+  type: "number",
+  default: 300
+});
 var OSC4_RESPONSE = /\x1b]4;(\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 var OSC_SPECIAL_RESPONSE = /\x1b](\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 function scaleComponent(comp) {
@@ -10517,18 +10493,21 @@ class TerminalPalette {
   writeFn;
   activeQuerySessions = [];
   inLegacyTmux;
+  inTmux;
   oscSource;
   clock;
-  constructor(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
+  constructor(options) {
+    const { stdin, stdout, writeFn, isLegacyTmux, isTmux, oscSource, clock } = options;
     this.stdin = stdin;
     this.stdout = stdout;
     this.writeFn = writeFn || ((data) => stdout.write(data));
     this.inLegacyTmux = isLegacyTmux ?? false;
+    this.inTmux = isTmux ?? this.inLegacyTmux;
     this.oscSource = oscSource;
     this.clock = clock ?? SYSTEM_CLOCK2;
   }
-  writeOsc(osc) {
-    const data = this.inLegacyTmux ? wrapForTmux(osc) : osc;
+  writeOsc(osc, wrapForLegacyTmux = false) {
+    const data = wrapForLegacyTmux && this.inLegacyTmux ? wrapForTmux(osc) : osc;
     return this.writeFn(data);
   }
   cleanup() {
@@ -10623,10 +10602,10 @@ class TerminalPalette {
         finish(false);
       }, timeoutMs);
       session.subscribeInput(onData);
-      this.writeOsc("\x1B]4;0;?\x07");
+      this.writeOsc("\x1B]4;0;?\x07", true);
     });
   }
-  async queryPalette(indices, timeoutMs = 1200) {
+  async queryPalette(indices, timeoutMs = 1200, idleTimeoutMs = env.OTUI_PALETTE_IDLE_TIMEOUT_MS) {
     const out = this.stdout;
     const results = new Map;
     indices.forEach((i) => results.set(i, null));
@@ -10661,14 +10640,15 @@ class TerminalPalette {
           finish();
           return;
         }
-        idleTimer = session.resetTimer(idleTimer, finish, 150);
+        idleTimer = session.resetTimer(idleTimer, finish, idleTimeoutMs);
       };
       session.setTimer(finish, timeoutMs);
       session.subscribeInput(onData);
-      this.writeOsc(indices.map((i) => `\x1B]4;${i};?\x07`).join(""));
+      this.writeOsc(indices.map((i) => `\x1B]4;${i};?\x07`).join(""), true);
+      idleTimer = session.resetTimer(idleTimer, finish, idleTimeoutMs);
     });
   }
-  async querySpecialColors(timeoutMs = 1200) {
+  async querySpecialColors(timeoutMs = 1200, idleTimeoutMs = env.OTUI_PALETTE_IDLE_TIMEOUT_MS) {
     const out = this.stdout;
     const results = {
       10: null,
@@ -10681,6 +10661,7 @@ class TerminalPalette {
       17: null,
       19: null
     };
+    const queries = this.inTmux ? [10, 11, 12] : [10, 11, 12, 13, 14, 15, 16, 17, 19];
     if (!out.isTTY || !this.stdin.isTTY) {
       return results;
     }
@@ -10710,28 +10691,18 @@ class TerminalPalette {
         }
         if (buffer.length > 8192)
           buffer = buffer.slice(-4096);
-        const done = Object.values(results).filter((v) => v !== null).length;
-        if (done === Object.keys(results).length) {
+        if (queries.every((idx) => results[idx] !== null)) {
           finish();
           return;
         }
         if (!updated)
           return;
-        idleTimer = session.resetTimer(idleTimer, finish, 150);
+        idleTimer = session.resetTimer(idleTimer, finish, idleTimeoutMs);
       };
       session.setTimer(finish, timeoutMs);
       session.subscribeInput(onData);
-      this.writeOsc([
-        "\x1B]10;?\x07",
-        "\x1B]11;?\x07",
-        "\x1B]12;?\x07",
-        "\x1B]13;?\x07",
-        "\x1B]14;?\x07",
-        "\x1B]15;?\x07",
-        "\x1B]16;?\x07",
-        "\x1B]17;?\x07",
-        "\x1B]19;?\x07"
-      ].join(""));
+      this.writeOsc(queries.map((idx) => `\x1B]${idx};?\x07`).join(""));
+      idleTimer = session.resetTimer(idleTimer, finish, idleTimeoutMs);
     });
   }
   async detect(options) {
@@ -10752,9 +10723,10 @@ class TerminalPalette {
       };
     }
     const indicesToQuery = [...Array(size).keys()];
+    const idleTimeout = env.OTUI_PALETTE_IDLE_TIMEOUT_MS;
     const [paletteResults, specialColors] = await Promise.all([
-      this.queryPalette(indicesToQuery, timeout),
-      this.querySpecialColors(timeout)
+      this.queryPalette(indicesToQuery, timeout, idleTimeout),
+      this.querySpecialColors(timeout, idleTimeout)
     ]);
     return {
       palette: [...Array(size).keys()].map((i) => paletteResults.get(i) ?? null),
@@ -10770,8 +10742,8 @@ class TerminalPalette {
     };
   }
 }
-function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
-  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock);
+function createTerminalPalette(options) {
+  return new TerminalPalette(options);
 }
 var DEFAULT_FOREGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_FOREGROUND_RGB);
 var DEFAULT_BACKGROUND_FALLBACK = RGBA.fromInts(...DEFAULT_BACKGROUND_RGB);
@@ -10856,13 +10828,351 @@ function detectLinks(chunks, context) {
   }
   return chunks;
 }
+// src/platform/ffi.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+var FFIType = {
+  char: "char",
+  int8_t: "int8_t",
+  i8: "i8",
+  uint8_t: "uint8_t",
+  u8: "u8",
+  int16_t: "int16_t",
+  i16: "i16",
+  uint16_t: "uint16_t",
+  u16: "u16",
+  int32_t: "int32_t",
+  i32: "i32",
+  int: "int",
+  uint32_t: "uint32_t",
+  u32: "u32",
+  int64_t: "int64_t",
+  i64: "i64",
+  uint64_t: "uint64_t",
+  u64: "u64",
+  double: "double",
+  f64: "f64",
+  float: "float",
+  f32: "f32",
+  bool: "bool",
+  ptr: "ptr",
+  pointer: "pointer",
+  void: "void",
+  cstring: "cstring",
+  function: "function",
+  usize: "usize",
+  callback: "callback",
+  napi_env: "napi_env",
+  napi_value: "napi_value",
+  buffer: "buffer"
+};
+var FFI_UNAVAILABLE = "OpenTUI native FFI is not available for this runtime yet";
+var BUN_DLOPEN_NULL = "Bun FFI backend does not support dlopen(null)";
+var LIBRARY_CLOSED = "Cannot create FFI callback after library.close() has been called";
+var NODE_CALLBACK_THREADSAFE = "Node FFI callbacks are same-thread only and do not support threadsafe callbacks";
+var NODE_NAPI_UNSUPPORTED = "Node FFI backend does not support Bun N-API FFI types";
+var NODE_POINTER_OVERRIDE = "Node FFI backend does not support FFIFunction.ptr overrides";
+var NODE_PTR_VALUE = "node:ffi ptr() only supports ArrayBuffer and ArrayBufferView values backed by ArrayBuffer";
+var NODE_STRING_RETURN = "Node FFI backend does not normalize string return values (yet)";
+var NODE_USIZE_UNSUPPORTED = "Node FFI backend does not support usize until (yet)";
+var POINTER_NEGATIVE = "Pointer must be non-negative";
+var POINTER_UNSAFE = "Pointer exceeds safe integer range";
+function unavailable(cause) {
+  throw new Error(FFI_UNAVAILABLE, { cause });
+}
+function createUnsupportedBackend(cause) {
+  return {
+    dlopen() {
+      return unavailable(cause);
+    },
+    ptr() {
+      return unavailable(cause);
+    },
+    suffix: "",
+    toArrayBuffer() {
+      return unavailable(cause);
+    }
+  };
+}
+var isBun = typeof process !== "undefined" && typeof process.versions === "object" && process.versions !== null && typeof process.versions.bun === "string";
+var backend = await loadBackend();
+function importModule(specifier) {
+  return import(specifier);
+}
+async function loadBackend() {
+  if (isBun) {
+    return createBunBackend(await importModule("bun:ffi"));
+  }
+  try {
+    const nodeFfi = await importModule("node:ffi");
+    return createNodeBackend(nodeFfi.default ?? nodeFfi);
+  } catch (error) {
+    return createUnsupportedBackend(error);
+  }
+}
+function toPointer(value) {
+  if (isBun && typeof value === "bigint") {
+    return toSafeNumberPointer(value);
+  }
+  if (!isBun && typeof value === "number") {
+    return toSafeBigIntPointer(value);
+  }
+  return value;
+}
+function ffiBool(value) {
+  return value ? 1 : 0;
+}
+function toSafeNumberPointer(pointer) {
+  if (pointer < 0n) {
+    throw new Error(POINTER_NEGATIVE);
+  }
+  if (pointer > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(POINTER_UNSAFE);
+  }
+  return Number(pointer);
+}
+function toSafeBigIntPointer(pointer) {
+  if (pointer < 0) {
+    throw new Error(POINTER_NEGATIVE);
+  }
+  if (!Number.isSafeInteger(pointer)) {
+    throw new Error(POINTER_UNSAFE);
+  }
+  return BigInt(pointer);
+}
+function createManagedCallback(raw, callbacks) {
+  let ptr = raw.ptr;
+  let closed = false;
+  const instance = {
+    get ptr() {
+      return ptr;
+    },
+    get threadsafe() {
+      return raw.threadsafe;
+    },
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      callbacks.delete(instance);
+      try {
+        raw.close();
+      } finally {
+        ptr = null;
+      }
+    }
+  };
+  callbacks.add(instance);
+  return instance;
+}
+function normalizeBunDefinitions(definitions) {
+  return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, normalizeBunDefinition(definition)]));
+}
+function normalizeBunDefinition(definition) {
+  return {
+    args: definition.args,
+    returns: definition.returns,
+    ptr: definition.ptr == null ? undefined : toBunPointer(definition.ptr),
+    threadsafe: definition.threadsafe
+  };
+}
+function toBunPointer(pointer) {
+  return typeof pointer === "bigint" ? toSafeNumberPointer(pointer) : pointer;
+}
+function createBunBackend(bun) {
+  return {
+    dlopen(path5, symbols) {
+      if (path5 === null) {
+        throw new Error(BUN_DLOPEN_NULL);
+      }
+      const library = bun.dlopen(path5, normalizeBunDefinitions(symbols));
+      const callbacks = new Set;
+      let closed = false;
+      return {
+        symbols: library.symbols,
+        createCallback(callback, definition) {
+          if (closed) {
+            throw new Error(LIBRARY_CLOSED);
+          }
+          const raw = new bun.JSCallback(callback, normalizeBunDefinition(definition));
+          return createManagedCallback(raw, callbacks);
+        },
+        close() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            library.close();
+          } finally {
+            for (const callback of [...callbacks]) {
+              callback.close();
+            }
+          }
+        }
+      };
+    },
+    ptr: bun.ptr,
+    suffix: bun.suffix,
+    toArrayBuffer(pointer, offset, length) {
+      return bun.toArrayBuffer(toBunPointer(pointer), offset, length);
+    }
+  };
+}
+function createNodeBackend(nodeFfi) {
+  return {
+    dlopen(path5, symbols) {
+      const { lib, functions } = nodeFfi.dlopen(toNodeLibraryPath(path5), normalizeNodeDefinitions(symbols));
+      const callbacks = new Set;
+      let closed = false;
+      let libraryClosed = false;
+      return {
+        symbols: functions,
+        createCallback(callback, definition) {
+          if (closed) {
+            throw new Error(LIBRARY_CLOSED);
+          }
+          if (definition.threadsafe) {
+            throw new Error(NODE_CALLBACK_THREADSAFE);
+          }
+          const callbackPointer = lib.registerCallback(normalizeNodeDefinition(definition), callback);
+          const raw = {
+            ptr: callbackPointer,
+            threadsafe: false,
+            close() {
+              if (!libraryClosed) {
+                lib.unregisterCallback(callbackPointer);
+              }
+            }
+          };
+          return createManagedCallback(raw, callbacks);
+        },
+        close() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            libraryClosed = true;
+            lib.close();
+          } finally {
+            for (const callback of [...callbacks]) {
+              callback.close();
+            }
+          }
+        }
+      };
+    },
+    ptr(value) {
+      if (ArrayBuffer.isView(value)) {
+        if (!(value.buffer instanceof ArrayBuffer)) {
+          throw new TypeError(NODE_PTR_VALUE);
+        }
+        return nodeFfi.getRawPointer(value.buffer) + BigInt(value.byteOffset);
+      }
+      if (value instanceof ArrayBuffer) {
+        return nodeFfi.getRawPointer(value);
+      }
+      throw new TypeError(NODE_PTR_VALUE);
+    },
+    suffix: nodeFfi.suffix,
+    toArrayBuffer(pointer, offset, length) {
+      return nodeFfi.toArrayBuffer(toBigIntPointer(pointer) + BigInt(offset ?? 0), length, false);
+    }
+  };
+}
+function toNodeLibraryPath(path5) {
+  return path5 instanceof URL ? fileURLToPath2(path5) : path5;
+}
+function normalizeNodeDefinitions(definitions) {
+  return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, normalizeNodeDefinition(definition)]));
+}
+function normalizeNodeDefinition(definition) {
+  if (definition.ptr != null) {
+    throw new Error(NODE_POINTER_OVERRIDE);
+  }
+  return {
+    parameters: (definition.args ?? []).map((type) => toNodeFFIType(type, "parameter")),
+    result: toNodeFFIType(definition.returns ?? FFIType.void, "result")
+  };
+}
+function toNodeFFIType(type, position) {
+  switch (type) {
+    case FFIType.char:
+      return "char";
+    case FFIType.int8_t:
+    case FFIType.i8:
+      return "i8";
+    case FFIType.uint8_t:
+    case FFIType.u8:
+      return "u8";
+    case FFIType.int16_t:
+    case FFIType.i16:
+      return "i16";
+    case FFIType.uint16_t:
+    case FFIType.u16:
+      return "u16";
+    case FFIType.int32_t:
+    case FFIType.int:
+    case FFIType.i32:
+      return "i32";
+    case FFIType.uint32_t:
+    case FFIType.u32:
+      return "u32";
+    case FFIType.int64_t:
+    case FFIType.i64:
+      return "i64";
+    case FFIType.uint64_t:
+    case FFIType.u64:
+      return "u64";
+    case FFIType.double:
+    case FFIType.f64:
+      return "f64";
+    case FFIType.float:
+    case FFIType.f32:
+      return "f32";
+    case FFIType.bool:
+      return "bool";
+    case FFIType.ptr:
+    case FFIType.pointer:
+      return "pointer";
+    case FFIType.void:
+      return "void";
+    case FFIType.cstring:
+      if (position === "result") {
+        throw new Error(NODE_STRING_RETURN);
+      }
+      return "string";
+    case FFIType.function:
+    case FFIType.callback:
+      return "pointer";
+    case FFIType.usize:
+      throw new Error(NODE_USIZE_UNSUPPORTED);
+    case FFIType.napi_env:
+    case FFIType.napi_value:
+      throw new Error(NODE_NAPI_UNSUPPORTED);
+    case FFIType.buffer:
+      return "buffer";
+    default:
+      return unsupportedNodeFFIType(type);
+  }
+}
+function unsupportedNodeFFIType(type) {
+  throw new Error(`Unsupported FFIType for node:ffi: ${String(type)}`);
+}
+function toBigIntPointer(pointer) {
+  return typeof pointer === "bigint" ? pointer : BigInt(pointer);
+}
+var dlopen = backend.dlopen;
+var ptr = backend.ptr;
+var suffix = backend.suffix;
+var toArrayBuffer = backend.toArrayBuffer;
+
 // src/zig.ts
-import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
 import { existsSync as existsSync2, writeFileSync } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 
 // src/buffer.ts
-import { toArrayBuffer, ptr } from "bun:ffi";
 function packDrawOptions(border2, shouldFill, titleAlignment, bottomTitleAlignment) {
   let packed = 0;
   if (border2 === true) {
@@ -11097,11 +11407,11 @@ class OptimizedBuffer {
   }
   drawSuperSampleBuffer(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
     this.guard();
-    this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow);
+    this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, toPointer(pixelDataPtr), pixelDataLength, format, alignedBytesPerRow);
   }
   drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.guard();
-    this.lib.bufferDrawPackedBuffer(this.bufferPtr, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
+    this.lib.bufferDrawPackedBuffer(this.bufferPtr, toPointer(dataPtr), dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
   drawGrayscaleBuffer(posX, posY, intensities, srcWidth, srcHeight, fg2 = null, bg2 = null) {
     this.guard();
@@ -11178,14 +11488,63 @@ class OptimizedBuffer {
   }
 }
 
-// ../../node_modules/.bun/bun-ffi-structs@0.1.2+1fb4c65d43e298b9/node_modules/bun-ffi-structs/index.js
-import { ptr as ptr2, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
+// ../../node_modules/.bun/bun-ffi-structs@0.2.2+1fb4c65d43e298b9/node_modules/bun-ffi-structs/dist/index.js
+var FFI_LOAD_ERROR = "bun-ffi-structs requires Bun or Node.js with node:ffi enabled (--experimental-ffi --allow-ffi).";
+var backend2 = await loadBackend2();
+async function loadBackend2() {
+  if (typeof process !== "undefined" && "bun" in process.versions) {
+    return createBunBackend2(await importModule2("bun:ffi"));
+  }
+  try {
+    return createNodeBackend2(await importModule2("node:ffi"));
+  } catch (error) {
+    throw new Error(FFI_LOAD_ERROR, {
+      cause: error instanceof Error ? error : undefined
+    });
+  }
+}
+function importModule2(specifier) {
+  return import(specifier).then((module) => module.default ?? module);
+}
+function createBunBackend2(bun) {
+  return {
+    ptr: bun.ptr,
+    toArrayBuffer(pointer, offset, length) {
+      return bun.toArrayBuffer(toBunPointer2(pointer), offset, length);
+    }
+  };
+}
+function createNodeBackend2(nodeFfi) {
+  return {
+    ptr(value) {
+      if (ArrayBuffer.isView(value)) {
+        return nodeFfi.getRawPointer(value.buffer) + BigInt(value.byteOffset);
+      }
+      if (value instanceof ArrayBuffer) {
+        return nodeFfi.getRawPointer(value);
+      }
+      throw new TypeError("node:ffi ptr() only supports ArrayBuffer and ArrayBufferView values.");
+    },
+    toArrayBuffer(pointer, offset, length) {
+      return nodeFfi.toArrayBuffer(toBigIntPointer2(pointer) + BigInt(offset ?? 0), length, false);
+    }
+  };
+}
+function toBigIntPointer2(pointer) {
+  return typeof pointer === "bigint" ? pointer : BigInt(pointer);
+}
+function toBunPointer2(pointer) {
+  return typeof pointer === "bigint" ? Number(pointer) : pointer;
+}
+var ptr2 = backend2.ptr;
+var toArrayBuffer2 = backend2.toArrayBuffer;
 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 isBun2 = typeof process !== "undefined" && "bun" in process.versions;
 var typeSizes = {
   u8: 1,
   bool_u8: 1,
@@ -11197,7 +11556,8 @@ var typeSizes = {
   f32: 4,
   f64: 8,
   pointer: pointerSize,
-  i32: 4
+  i32: 4,
+  i64: 8
 };
 var primitiveKeys = Object.keys(typeSizes);
 function isPrimitiveType(type) {
@@ -11215,6 +11575,7 @@ var typeGetters = {
   f32: (view, offset) => view.getFloat32(offset, true),
   f64: (view, offset) => view.getFloat64(offset, true),
   i32: (view, offset) => view.getInt32(offset, true),
+  i64: (view, offset) => view.getBigInt64(offset, true),
   pointer: (view, offset) => pointerSize === 8 ? view.getBigUint64(offset, true) : BigInt(view.getUint32(offset, true))
 };
 function isObjectPointerDef(type) {
@@ -11278,6 +11639,10 @@ function primitivePackers(type) {
       pack = (view, off, val) => view.setInt32(off, val, true);
       unpack = (view, off) => view.getInt32(off, true);
       break;
+    case "i64":
+      pack = (view, off, val) => view.setBigInt64(off, BigInt(val), true);
+      unpack = (view, off) => view.getBigInt64(off, true);
+      break;
     case "u64":
       pack = (view, off, val) => view.setBigUint64(off, BigInt(val), true);
       unpack = (view, off) => view.getBigUint64(off, true);
@@ -11295,8 +11660,11 @@ function primitivePackers(type) {
         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);
+        if (pointerSize === 8) {
+          const value = view.getBigUint64(off, true);
+          return isBun2 ? Number(value) : value;
+        }
+        return view.getUint32(off, true);
       };
       break;
     default:
@@ -11305,6 +11673,26 @@ function primitivePackers(type) {
   return { pack, unpack };
 }
 var { pack: pointerPacker, unpack: pointerUnpacker } = primitivePackers("pointer");
+var retainedPointerTargets = new WeakMap;
+function retainPointerTarget(owner, target) {
+  const retained = retainedPointerTargets.get(owner);
+  if (retained) {
+    retained.push(target);
+  } else {
+    retainedPointerTargets.set(owner, [target]);
+  }
+}
+function retainIfPointerTargets(owner, target) {
+  if (retainedPointerTargets.has(target)) {
+    retainPointerTarget(owner, target);
+  }
+}
+function isNullPointer(pointer) {
+  return pointer == null || pointer === 0 || pointer === 0n;
+}
+function toItemCount(length) {
+  return typeof length === "bigint" ? Number(length) : length;
+}
 function packObjectArray(val) {
   const buffer = new ArrayBuffer(val.length * pointerSize);
   const bufferView = new DataView(buffer);
@@ -11341,8 +11729,14 @@ function defineStruct(fields, structDefOptions) {
       size = pointerSize;
       align = pointerSize;
       pack = (view, off, val) => {
-        const bufPtr = val ? ptr2(encoder.encode(val + "\x00")) : null;
+        if (!val) {
+          pointerPacker(view, off, null);
+          return;
+        }
+        const bytes = encoder.encode(val + "\x00");
+        const bufPtr = ptr2(bytes);
         pointerPacker(view, off, bufPtr);
+        retainPointerTarget(view.buffer, bytes);
       };
       unpack = (view, off) => {
         const ptrVal = pointerUnpacker(view, off);
@@ -11352,8 +11746,14 @@ function defineStruct(fields, structDefOptions) {
       size = pointerSize;
       align = pointerSize;
       pack = (view, off, val) => {
-        const bufPtr = val ? ptr2(encoder.encode(val)) : null;
+        if (!val) {
+          pointerPacker(view, off, null);
+          return;
+        }
+        const bytes = encoder.encode(val);
+        const bufPtr = ptr2(bytes);
         pointerPacker(view, off, bufPtr);
+        retainPointerTarget(view.buffer, bytes);
       };
       unpack = (view, off) => {
         const ptrVal = pointerUnpacker(view, off);
@@ -11384,6 +11784,7 @@ function defineStruct(fields, structDefOptions) {
           }
           const nestedBuf = typeOrStruct.pack(val, options2);
           pointerPacker(view, off, ptr2(nestedBuf));
+          retainPointerTarget(view.buffer, nestedBuf);
         };
         unpack = (view, off) => {
           throw new Error("Not implemented yet");
@@ -11396,6 +11797,7 @@ function defineStruct(fields, structDefOptions) {
           const nestedView = new Uint8Array(nestedBuf);
           const dView = new Uint8Array(view.buffer);
           dView.set(nestedView, off);
+          retainIfPointerTargets(view.buffer, nestedBuf);
         };
         unpack = (view, off) => {
           const slice = view.buffer.slice(off, off + size);
@@ -11436,6 +11838,7 @@ function defineStruct(fields, structDefOptions) {
             bufferView.setUint32(i * arrayElementSize, num, true);
           }
           pointerPacker(view, off, ptr2(buffer));
+          retainPointerTarget(view.buffer, buffer);
         };
         unpack = null;
         needsLengthOf = true;
@@ -11453,6 +11856,7 @@ function defineStruct(fields, structDefOptions) {
             def.packInto(val[i], bufferView, i * arrayElementSize, options2);
           }
           pointerPacker(view, off, ptr2(buffer));
+          retainPointerTarget(view.buffer, buffer);
         };
         unpack = (view, off) => {
           throw new Error("Not implemented yet");
@@ -11471,6 +11875,7 @@ function defineStruct(fields, structDefOptions) {
             primitivePack(bufferView, i * arrayElementSize, val[i]);
           }
           pointerPacker(view, off, ptr2(buffer));
+          retainPointerTarget(view.buffer, buffer);
         };
         unpack = null;
         needsLengthOf = true;
@@ -11484,6 +11889,7 @@ function defineStruct(fields, structDefOptions) {
           }
           const packedView = packObjectArray(val);
           pointerPacker(view, off, ptr2(packedView.buffer));
+          retainPointerTarget(view.buffer, packedView.buffer);
         };
         unpack = () => {
           throw new Error("not implemented yet");
@@ -11579,13 +11985,14 @@ function defineStruct(fields, structDefOptions) {
       throw new Error(`lengthOf field not found for array field ${requester.name}`);
     }
     if (def === "char*") {
+      const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
         const ptrAddress = pointerUnpacker(view, off);
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
-        if (ptrAddress === 0) {
+        const length = lengthOfField.unpack(view, off + relativeOffset);
+        if (isNullPointer(ptrAddress)) {
           return null;
         }
-        const byteLength = typeof length === "bigint" ? Number(length) : length;
+        const byteLength = toItemCount(length);
         if (byteLength === 0) {
           return "";
         }
@@ -11595,38 +12002,42 @@ function defineStruct(fields, structDefOptions) {
     } else if (isPrimitiveType(def)) {
       const elemSize = typeSizes[def];
       const { unpack: primitiveUnpack } = primitivePackers(def);
+      const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
         const result = [];
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
+        const length = lengthOfField.unpack(view, off + relativeOffset);
+        const itemCount = toItemCount(length);
         const ptrAddress = pointerUnpacker(view, off);
-        if (ptrAddress === 0n && length > 0) {
+        if (isNullPointer(ptrAddress) && itemCount > 0) {
           throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
         }
-        if (ptrAddress === 0n || length === 0) {
+        if (isNullPointer(ptrAddress) || itemCount === 0) {
           return [];
         }
-        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
+        const buffer = toArrayBuffer2(ptrAddress, 0, itemCount * elemSize);
         const bufferView = new DataView(buffer);
-        for (let i = 0;i < length; i++) {
+        for (let i = 0;i < itemCount; i++) {
           result.push(primitiveUnpack(bufferView, i * elemSize));
         }
         return result;
       };
     } else {
       const elemSize = def.type === "u32" ? 4 : 8;
+      const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
         const result = [];
-        const length = lengthOfField.unpack(view, lengthOfField.offset);
+        const length = lengthOfField.unpack(view, off + relativeOffset);
+        const itemCount = toItemCount(length);
         const ptrAddress = pointerUnpacker(view, off);
-        if (ptrAddress === 0n && length > 0) {
+        if (isNullPointer(ptrAddress) && itemCount > 0) {
           throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
         }
-        if (ptrAddress === 0n || length === 0) {
+        if (isNullPointer(ptrAddress) || itemCount === 0) {
           return [];
         }
-        const buffer = toArrayBuffer2(ptrAddress, 0, length * elemSize);
+        const buffer = toArrayBuffer2(ptrAddress, 0, itemCount * elemSize);
         const bufferView = new DataView(buffer);
-        for (let i = 0;i < length; i++) {
+        for (let i = 0;i < itemCount; i++) {
           result.push(def.from(bufferView.getUint32(i * elemSize, true)));
         }
         return result;
@@ -11787,9 +12198,8 @@ function defineStruct(fields, structDefOptions) {
 }
 
 // src/zig-structs.ts
-import { ptr as ptr3, toArrayBuffer as toArrayBuffer3 } from "bun:ffi";
-var rgbaPackTransform = (rgba) => rgba ? ptr3(rgba.buffer) : null;
-var rgbaUnpackTransform = (ptr4) => ptr4 ? RGBA.fromArray(new Uint16Array(toArrayBuffer3(ptr4, 0, 8))) : undefined;
+var rgbaPackTransform = (rgba) => rgba ? ptr(rgba.buffer) : null;
+var rgbaUnpackTransform = (ptr3) => ptr3 ? RGBA.fromArray(new Uint16Array(toArrayBuffer(ptr3, 0, 8))) : undefined;
 var StyledChunkStruct = defineStruct([
   ["text", "char*"],
   ["text_len", "u64", { lengthOf: "text" }],
@@ -11870,6 +12280,7 @@ var TerminalCapabilitiesStruct = defineStruct([
   ["hyperlinks", "bool_u8"],
   ["osc52", "bool_u8"],
   ["explicit_cursor_positioning", "bool_u8"],
+  ["in_tmux", "bool_u8"],
   ["term_name", "char*"],
   ["term_name_len", "u64", { lengthOf: "term_name" }],
   ["term_version", "char*"],
@@ -12026,20 +12437,11 @@ var MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4
 var globalTraceSymbols = null;
 var globalFFILogPath = null;
 var exitHandlerRegistered = false;
-function toPointer(value) {
-  if (typeof value === "bigint") {
-    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error("Pointer exceeds safe integer range");
-    }
-    return Number(value);
-  }
-  return value;
-}
 function toNumber(value) {
   return typeof value === "bigint" ? Number(value) : value;
 }
 function rgbaPtr(value) {
-  return ptr4(value.buffer);
+  return ptr(value.buffer);
 }
 function optionalRgbaPtr(value) {
   return value ? rgbaPtr(value) : null;
@@ -13058,6 +13460,7 @@ function getOpenTUILib(libPath) {
   });
   if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
     return {
+      ...rawSymbols,
       symbols: convertToDebugSymbols(rawSymbols.symbols)
     };
   }
@@ -13207,8 +13610,8 @@ class FFIRenderLib {
   opentui;
   encoder = new TextEncoder;
   decoder = new TextDecoder;
-  logCallbackWrapper;
-  eventCallbackWrapper;
+  logCallbackWrapper = null;
+  eventCallbackWrapper = null;
   _nativeEvents = new EventEmitter4;
   _anyEventHandlers = [];
   nativeSpanFeedCallbackWrapper = null;
@@ -13222,13 +13625,13 @@ class FFIRenderLib {
     if (this.logCallbackWrapper) {
       return;
     }
-    const logCallback = new JSCallback((level, msgPtr, msgLenBigInt) => {
+    const logCallback = this.opentui.createCallback((level, msgPtr, msgLenBigInt) => {
       try {
         const msgLen = typeof msgLenBigInt === "bigint" ? Number(msgLenBigInt) : msgLenBigInt;
         if (msgLen === 0 || !msgPtr) {
           return;
         }
-        const msgBuffer = toArrayBuffer4(msgPtr, 0, msgLen);
+        const msgBuffer = toArrayBuffer(msgPtr, 0, msgLen);
         const msgBytes = new Uint8Array(msgBuffer);
         const message = this.decoder.decode(msgBytes);
         switch (level) {
@@ -13267,19 +13670,19 @@ class FFIRenderLib {
     if (this.eventCallbackWrapper) {
       return;
     }
-    const eventCallback = new JSCallback((namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
+    const eventCallback = this.opentui.createCallback((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 nameBuffer = toArrayBuffer(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();
+          eventData = toArrayBuffer(dataPtr, 0, dataLen).slice();
         } else {
           eventData = new ArrayBuffer(0);
         }
@@ -13306,8 +13709,8 @@ class FFIRenderLib {
     if (this.nativeSpanFeedCallbackWrapper) {
       return this.nativeSpanFeedCallbackWrapper;
     }
-    const callback = new JSCallback((streamPtr, eventId, arg0, arg1) => {
-      const handler = this.nativeSpanFeedHandlers.get(toPointer(streamPtr));
+    const callback = this.opentui.createCallback((streamPtr, eventId, arg0, arg1) => {
+      const handler = this.nativeSpanFeedHandlers.get(streamPtr);
       if (handler) {
         handler(eventId, arg0, arg1);
       }
@@ -13327,7 +13730,7 @@ class FFIRenderLib {
   createRenderer(width, height, options = {}) {
     const testing = options.testing ?? false;
     const remote = options.remote ?? false;
-    return this.opentui.symbols.createRenderer(width, height, testing, remote);
+    return this.opentui.symbols.createRenderer(width, height, ffiBool(testing), ffiBool(remote));
   }
   setTerminalEnvVar(renderer, key, value) {
     const keyBytes = this.encoder.encode(key);
@@ -13338,10 +13741,10 @@ class FFIRenderLib {
     this.opentui.symbols.destroyRenderer(renderer);
   }
   setUseThread(renderer, useThread) {
-    this.opentui.symbols.setUseThread(renderer, useThread);
+    this.opentui.symbols.setUseThread(renderer, ffiBool(useThread));
   }
   setClearOnShutdown(renderer, clear) {
-    this.opentui.symbols.setClearOnShutdown(renderer, clear);
+    this.opentui.symbols.setClearOnShutdown(renderer, ffiBool(clear));
   }
   setBackgroundColor(renderer, color) {
     this.opentui.symbols.setBackgroundColor(renderer, rgbaPtr(color));
@@ -13390,41 +13793,41 @@ class FFIRenderLib {
     for (let index = 0;index < palette.length; index++) {
       paletteBuffer.set(palette[index].buffer, index * 4);
     }
-    this.opentui.symbols.rendererSetPaletteState(renderer, ptr4(paletteBuffer), palette.length, rgbaPtr(defaultForeground), rgbaPtr(defaultBackground), paletteEpoch >>> 0);
+    this.opentui.symbols.rendererSetPaletteState(renderer, ptr(paletteBuffer), palette.length, rgbaPtr(defaultForeground), rgbaPtr(defaultBackground), paletteEpoch >>> 0);
   }
   bufferGetCharPtr(buffer) {
-    const ptr5 = this.opentui.symbols.bufferGetCharPtr(buffer);
-    if (!ptr5) {
+    const ptr3 = this.opentui.symbols.bufferGetCharPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get char pointer");
     }
-    return ptr5;
+    return ptr3;
   }
   bufferGetFgPtr(buffer) {
-    const ptr5 = this.opentui.symbols.bufferGetFgPtr(buffer);
-    if (!ptr5) {
+    const ptr3 = this.opentui.symbols.bufferGetFgPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get fg pointer");
     }
-    return ptr5;
+    return ptr3;
   }
   bufferGetBgPtr(buffer) {
-    const ptr5 = this.opentui.symbols.bufferGetBgPtr(buffer);
-    if (!ptr5) {
+    const ptr3 = this.opentui.symbols.bufferGetBgPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get bg pointer");
     }
-    return ptr5;
+    return ptr3;
   }
   bufferGetAttributesPtr(buffer) {
-    const ptr5 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
-    if (!ptr5) {
+    const ptr3 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
+    if (!ptr3) {
       throw new Error("Failed to get attributes pointer");
     }
-    return ptr5;
+    return ptr3;
   }
   bufferGetRespectAlpha(buffer) {
     return this.opentui.symbols.bufferGetRespectAlpha(buffer);
   }
   bufferSetRespectAlpha(buffer, respectAlpha) {
-    this.opentui.symbols.bufferSetRespectAlpha(buffer, respectAlpha);
+    this.opentui.symbols.bufferSetRespectAlpha(buffer, ffiBool(respectAlpha));
   }
   bufferGetId(buffer) {
     const maxLen = 256;
@@ -13437,7 +13840,7 @@ class FFIRenderLib {
     return this.opentui.symbols.bufferGetRealCharSize(buffer);
   }
   bufferWriteResolvedChars(buffer, outputBuffer, addLineBreaks) {
-    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(buffer, outputBuffer, outputBuffer.length, addLineBreaks);
+    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(buffer, outputBuffer, outputBuffer.length, ffiBool(addLineBreaks));
     return typeof bytesWritten === "bigint" ? Number(bytesWritten) : bytesWritten;
   }
   getBufferWidth(buffer) {
@@ -13496,7 +13899,7 @@ class FFIRenderLib {
       drawInner: options.drawInner,
       drawOuter: options.drawOuter
     });
-    this.opentui.symbols.bufferDrawGrid(buffer, borderChars, rgbaPtr(borderFg), rgbaPtr(borderBg), columnOffsets, columnCount, rowOffsets, rowCount, ptr4(optionsBuffer));
+    this.opentui.symbols.bufferDrawGrid(buffer, borderChars, rgbaPtr(borderFg), rgbaPtr(borderBg), columnOffsets, columnCount, rowOffsets, rowCount, ptr(optionsBuffer));
   }
   bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, title, bottomTitle) {
     const titleBytes = title ? this.encoder.encode(title) : null;
@@ -13529,14 +13932,14 @@ class FFIRenderLib {
     this.opentui.symbols.resizeRenderer(renderer, width, height);
   }
   setCursorPosition(renderer, x, y, visible) {
-    this.opentui.symbols.setCursorPosition(renderer, x, y, visible);
+    this.opentui.symbols.setCursorPosition(renderer, x, y, ffiBool(visible));
   }
   setCursorColor(renderer, color) {
     this.opentui.symbols.setCursorColor(renderer, rgbaPtr(color));
   }
   getCursorState(renderer) {
     const cursorBuffer = new ArrayBuffer(CursorStateStruct.size);
-    this.opentui.symbols.getCursorState(renderer, ptr4(cursorBuffer));
+    this.opentui.symbols.getCursorState(renderer, ptr(cursorBuffer));
     const struct = CursorStateStruct.unpack(cursorBuffer);
     return {
       x: struct.x,
@@ -13552,16 +13955,16 @@ class FFIRenderLib {
     const blinking = options.blinking != null ? options.blinking ? 1 : 0 : 255;
     const cursor = options.cursor != null ? MOUSE_STYLE_TO_ID[options.cursor] : 255;
     const buffer = CursorStyleOptionsStruct.pack({ style, blinking, color: options.color, cursor });
-    this.opentui.symbols.setCursorStyleOptions(renderer, ptr4(buffer));
+    this.opentui.symbols.setCursorStyleOptions(renderer, ptr(buffer));
   }
   render(renderer, force) {
-    this.opentui.symbols.render(renderer, force);
+    this.opentui.symbols.render(renderer, ffiBool(force));
   }
   repaintSplitFooter(renderer, pinnedRenderOffset, force) {
-    return this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, force);
+    return this.opentui.symbols.repaintSplitFooter(renderer, pinnedRenderOffset, ffiBool(force));
   }
   commitSplitFooterSnapshot(renderer, snapshot, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame = true, finalizeFrame = true) {
-    return this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, startOnNewLine, trailingNewline, pinnedRenderOffset, force, beginFrame, finalizeFrame);
+    return this.opentui.symbols.commitSplitFooterSnapshot(renderer, snapshot.ptr, rowColumns, ffiBool(startOnNewLine), ffiBool(trailingNewline), pinnedRenderOffset, ffiBool(force), ffiBool(beginFrame), ffiBool(finalizeFrame));
   }
   createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
     if (Number.isNaN(width) || Number.isNaN(height)) {
@@ -13570,7 +13973,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, respectAlpha, widthMethodCode, idBytes, idBytes.length);
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, ffiBool(respectAlpha), widthMethodCode, idBytes, idBytes.length);
     if (!bufferPtr) {
       throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
     }
@@ -13587,7 +13990,7 @@ class FFIRenderLib {
     this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
   }
   setDebugOverlay(renderer, enabled, corner) {
-    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
+    this.opentui.symbols.setDebugOverlay(renderer, ffiBool(enabled), corner);
   }
   clearTerminal(renderer) {
     this.opentui.symbols.clearTerminal(renderer);
@@ -13641,7 +14044,7 @@ class FFIRenderLib {
     this.opentui.symbols.restoreTerminalModes(renderer);
   }
   enableMouse(renderer, enableMovement) {
-    this.opentui.symbols.enableMouse(renderer, enableMovement);
+    this.opentui.symbols.enableMouse(renderer, ffiBool(enableMovement));
   }
   disableMouse(renderer) {
     this.opentui.symbols.disableMouse(renderer);
@@ -13659,7 +14062,7 @@ class FFIRenderLib {
     return this.opentui.symbols.getKittyKeyboardFlags(renderer);
   }
   setupTerminal(renderer, useAlternateScreen) {
-    this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
+    this.opentui.symbols.setupTerminal(renderer, ffiBool(useAlternateScreen));
   }
   suspendRenderer(renderer) {
     this.opentui.symbols.suspendRenderer(renderer);
@@ -13677,7 +14080,7 @@ class FFIRenderLib {
     const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
     if (bytes.length === 0)
       return;
-    this.opentui.symbols.writeOut(renderer, ptr4(bytes), bytes.length);
+    this.opentui.symbols.writeOut(renderer, ptr(bytes), bytes.length);
   }
   createTextBuffer(widthMethod) {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
@@ -13724,14 +14127,14 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferSetTabWidth(buffer, width);
   }
   textBufferRegisterMemBuffer(buffer, bytes, owned = false) {
-    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, owned);
+    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, 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, bytes, bytes.length, owned);
+    return this.opentui.symbols.textBufferReplaceMemBuffer(buffer, memId, bytes, bytes.length, ffiBool(owned));
   }
   textBufferClearMemRegistry(buffer) {
     this.opentui.symbols.textBufferClearMemRegistry(buffer);
@@ -13755,7 +14158,7 @@ class FFIRenderLib {
       return;
     }
     const chunksBuffer = StyledChunkStruct.packList(chunks);
-    this.opentui.symbols.textBufferSetStyledText(buffer, ptr4(chunksBuffer), chunks.length);
+    this.opentui.symbols.textBufferSetStyledText(buffer, ptr(chunksBuffer), chunks.length);
   }
   textBufferGetLineCount(buffer) {
     return this.opentui.symbols.textBufferGetLineCount(buffer);
@@ -13766,7 +14169,7 @@ class FFIRenderLib {
   }
   getPlainTextBytes(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferGetPlainText(buffer, ptr4(outBuffer), maxLength);
+    const actualLen = this.textBufferGetPlainText(buffer, ptr(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -13774,7 +14177,7 @@ class FFIRenderLib {
   }
   textBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRange(buffer, startOffset, endOffset, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0) {
       return null;
@@ -13783,7 +14186,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, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0) {
       return null;
@@ -13856,7 +14259,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLineInfoDirect(view, ptr4(outBuffer));
+    this.textBufferViewGetLineInfoDirect(view, ptr(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -13871,7 +14274,7 @@ class FFIRenderLib {
   }
   textBufferViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.textBufferViewGetLogicalLineInfoDirect(view, ptr4(outBuffer));
+    this.textBufferViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -13903,7 +14306,7 @@ class FFIRenderLib {
   }
   textBufferViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetSelectedText(view, ptr4(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -13911,7 +14314,7 @@ class FFIRenderLib {
   }
   textBufferViewGetPlainTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.textBufferViewGetPlainText(view, ptr4(outBuffer), maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, ptr(outBuffer), maxLength);
     if (actualLen === 0) {
       return null;
     }
@@ -13924,11 +14327,11 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, rgbaPtr(color));
   }
   textBufferViewSetTruncate(view, truncate) {
-    this.opentui.symbols.textBufferViewSetTruncate(view, truncate);
+    this.opentui.symbols.textBufferViewSetTruncate(view, ffiBool(truncate));
   }
   textBufferViewMeasureForDimensions(view, width, height) {
     const resultBuffer = new ArrayBuffer(MeasureResultStruct.size);
-    const resultPtr = ptr4(new Uint8Array(resultBuffer));
+    const resultPtr = ptr(new Uint8Array(resultBuffer));
     const success = this.opentui.symbols.textBufferViewMeasureForDimensions(view, width, height, resultPtr);
     if (!success) {
       return null;
@@ -13938,11 +14341,11 @@ class FFIRenderLib {
   }
   textBufferAddHighlightByCharRange(buffer, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr4(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr(packedHighlight));
   }
   textBufferAddHighlight(buffer, lineIdx, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
-    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr4(packedHighlight));
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr(packedHighlight));
   }
   textBufferRemoveHighlightsByRef(buffer, hlRef) {
     this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
@@ -13958,12 +14361,12 @@ class FFIRenderLib {
   }
   textBufferGetLineHighlights(buffer, lineIdx) {
     const outCountBuf = new BigUint64Array(1);
-    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr4(outCountBuf));
+    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr(outCountBuf));
     if (!nativePtr)
       return [];
     const count = Number(outCountBuf[0]);
     const byteLen = count * HighlightStruct.size;
-    const raw = toArrayBuffer4(nativePtr, 0, byteLen);
+    const raw = toArrayBuffer(nativePtr, 0, byteLen);
     const results = HighlightStruct.unpackList(raw, count);
     this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
     return results;
@@ -13977,7 +14380,7 @@ class FFIRenderLib {
   }
   getBuildOptions() {
     const optionsBuffer = new ArrayBuffer(BuildOptionsStruct.size);
-    this.opentui.symbols.getBuildOptions(ptr4(optionsBuffer));
+    this.opentui.symbols.getBuildOptions(ptr(optionsBuffer));
     const options = BuildOptionsStruct.unpack(optionsBuffer);
     return {
       gpaSafeStats: !!options.gpaSafeStats,
@@ -13986,7 +14389,7 @@ class FFIRenderLib {
   }
   getAllocatorStats() {
     const statsBuffer = new ArrayBuffer(AllocatorStatsStruct.size);
-    this.opentui.symbols.getAllocatorStats(ptr4(statsBuffer));
+    this.opentui.symbols.getAllocatorStats(ptr(statsBuffer));
     const stats = AllocatorStatsStruct.unpack(statsBuffer);
     return {
       totalRequestedBytes: toNumber(stats.totalRequestedBytes),
@@ -14016,14 +14419,14 @@ class FFIRenderLib {
     this.opentui.symbols.editorViewSetViewportSize(view, width, height);
   }
   editorViewSetViewport(view, x, y, width, height, moveCursor) {
-    this.opentui.symbols.editorViewSetViewport(view, x, y, width, height, moveCursor);
+    this.opentui.symbols.editorViewSetViewport(view, x, y, width, height, ffiBool(moveCursor));
   }
   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, ptr4(x), ptr4(y), ptr4(width), ptr4(height));
+    this.opentui.symbols.editorViewGetViewport(view, ptr(x), ptr(y), ptr(width), ptr(height));
     return {
       offsetX: x[0],
       offsetY: y[0],
@@ -14053,7 +14456,7 @@ class FFIRenderLib {
   }
   editorViewGetLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr4(outBuffer));
+    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -14068,7 +14471,7 @@ class FFIRenderLib {
   }
   editorViewGetLogicalLineInfo(view) {
     const outBuffer = new ArrayBuffer(LineInfoStruct.size);
-    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr4(outBuffer));
+    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
     const struct = LineInfoStruct.unpack(outBuffer);
     const lineStartCols = struct.startCols;
     const lineWidthCols = struct.widthCols;
@@ -14106,7 +14509,7 @@ class FFIRenderLib {
   }
   editBufferGetText(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14161,7 +14564,7 @@ class FFIRenderLib {
   }
   editBufferGetCursorPosition(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr4(cursorBuffer));
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetId(buffer) {
@@ -14179,7 +14582,7 @@ class FFIRenderLib {
   }
   editBufferUndo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14187,7 +14590,7 @@ class FFIRenderLib {
   }
   editBufferRedo(buffer, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14207,22 +14610,22 @@ class FFIRenderLib {
   }
   editBufferGetNextWordBoundary(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr4(cursorBuffer));
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetPrevWordBoundary(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr4(cursorBuffer));
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferGetEOL(buffer) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetEOL(buffer, ptr4(cursorBuffer));
+    this.opentui.symbols.editBufferGetEOL(buffer, ptr(cursorBuffer));
     return LogicalCursorStruct.unpack(cursorBuffer);
   }
   editBufferOffsetToPosition(buffer, offset) {
     const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr4(cursorBuffer));
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr(cursorBuffer));
     if (!success)
       return null;
     return LogicalCursorStruct.unpack(cursorBuffer);
@@ -14235,7 +14638,7 @@ class FFIRenderLib {
   }
   editBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRange(buffer, startOffset, endOffset, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14243,7 +14646,7 @@ 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, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14269,7 +14672,7 @@ class FFIRenderLib {
   editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
     const bg2 = optionalRgbaPtr(bgColor);
     const fg2 = optionalRgbaPtr(fgColor);
-    return this.opentui.symbols.editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, updateCursor, followCursor);
+    return this.opentui.symbols.editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, ffiBool(updateCursor), ffiBool(followCursor));
   }
   editorViewUpdateSelection(view, end, bgColor, fgColor) {
     const bg2 = optionalRgbaPtr(bgColor);
@@ -14279,14 +14682,14 @@ class FFIRenderLib {
   editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
     const bg2 = optionalRgbaPtr(bgColor);
     const fg2 = optionalRgbaPtr(fgColor);
-    return this.opentui.symbols.editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, updateCursor, followCursor);
+    return this.opentui.symbols.editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2, ffiBool(updateCursor), ffiBool(followCursor));
   }
   editorViewResetLocalSelection(view) {
     this.opentui.symbols.editorViewResetLocalSelection(view);
   }
   editorViewGetSelectedTextBytes(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14295,12 +14698,12 @@ class FFIRenderLib {
   editorViewGetCursor(view) {
     const row = new Uint32Array(1);
     const col = new Uint32Array(1);
-    this.opentui.symbols.editorViewGetCursor(view, ptr4(row), ptr4(col));
+    this.opentui.symbols.editorViewGetCursor(view, ptr(row), ptr(col));
     return { row: row[0], col: col[0] };
   }
   editorViewGetText(view, maxLength) {
     const outBuffer = new Uint8Array(maxLength);
-    const actualLen = this.opentui.symbols.editorViewGetText(view, ptr4(outBuffer), maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetText(view, ptr(outBuffer), maxLength);
     const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
     if (len === 0)
       return null;
@@ -14308,7 +14711,7 @@ class FFIRenderLib {
   }
   editorViewGetVisualCursor(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualCursor(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewMoveUpVisual(view) {
@@ -14325,27 +14728,27 @@ class FFIRenderLib {
   }
   editorViewGetNextWordBoundary(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetPrevWordBoundary(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetEOL(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetEOL(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetEOL(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetVisualSOL(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualSOL(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetVisualSOL(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   editorViewGetVisualEOL(view) {
     const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualEOL(view, ptr4(cursorBuffer));
+    this.opentui.symbols.editorViewGetVisualEOL(view, ptr(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
   bufferPushScissorRect(buffer, x, y, width, height) {
@@ -14371,7 +14774,7 @@ class FFIRenderLib {
   }
   getTerminalCapabilities(renderer) {
     const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
-    this.opentui.symbols.getTerminalCapabilities(renderer, ptr4(capsBuffer));
+    this.opentui.symbols.getTerminalCapabilities(renderer, ptr(capsBuffer));
     const caps = TerminalCapabilitiesStruct.unpack(capsBuffer);
     return {
       kitty_keyboard: caps.kitty_keyboard,
@@ -14390,6 +14793,7 @@ class FFIRenderLib {
       hyperlinks: caps.hyperlinks,
       osc52: caps.osc52,
       explicit_cursor_positioning: caps.explicit_cursor_positioning,
+      in_tmux: caps.in_tmux,
       terminal: {
         name: caps.term_name ?? "",
         version: caps.term_version ?? "",
@@ -14406,7 +14810,7 @@ class FFIRenderLib {
     const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
     const outPtrBuffer = new ArrayBuffer(8);
     const outLenBuffer = new ArrayBuffer(8);
-    const success = this.opentui.symbols.encodeUnicode(textBytes, textBytes.length, ptr4(outPtrBuffer), ptr4(outLenBuffer), widthMethodCode);
+    const success = this.opentui.symbols.encodeUnicode(textBytes, textBytes.length, ptr(outPtrBuffer), ptr(outLenBuffer), widthMethodCode);
     if (!success) {
       return null;
     }
@@ -14418,7 +14822,7 @@ class FFIRenderLib {
       return { ptr: resultPtr, data: [] };
     }
     const byteLen = resultLen * EncodedCharStruct.size;
-    const raw = toArrayBuffer4(resultPtr, 0, byteLen);
+    const raw = toArrayBuffer(resultPtr, 0, byteLen);
     const data = EncodedCharStruct.unpackList(raw, resultLen);
     return { ptr: resultPtr, data };
   }
@@ -14430,37 +14834,37 @@ class FFIRenderLib {
   }
   registerNativeSpanFeedStream(stream, handler) {
     const callback = this.ensureNativeSpanFeedCallback();
-    this.nativeSpanFeedHandlers.set(toPointer(stream), handler);
+    this.nativeSpanFeedHandlers.set(stream, handler);
     this.opentui.symbols.streamSetCallback(stream, callback.ptr);
   }
   unregisterNativeSpanFeedStream(stream) {
     this.opentui.symbols.streamSetCallback(stream, null);
-    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+    this.nativeSpanFeedHandlers.delete(stream);
   }
   createNativeSpanFeed(options) {
     const optionsBuffer = options == null ? null : NativeSpanFeedOptionsStruct.pack(options);
-    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr4(optionsBuffer) : null);
+    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr(optionsBuffer) : null);
     if (!streamPtr) {
       throw new Error("Failed to create stream");
     }
-    return toPointer(streamPtr);
+    return streamPtr;
   }
   attachNativeSpanFeed(stream) {
     return this.opentui.symbols.attachNativeSpanFeed(stream);
   }
   destroyNativeSpanFeed(stream) {
     this.opentui.symbols.destroyNativeSpanFeed(stream);
-    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+    this.nativeSpanFeedHandlers.delete(stream);
   }
   streamWrite(stream, data) {
     const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
-    return this.opentui.symbols.streamWrite(stream, ptr4(bytes), bytes.length);
+    return this.opentui.symbols.streamWrite(stream, ptr(bytes), bytes.length);
   }
   streamCommit(stream) {
     return this.opentui.symbols.streamCommit(stream);
   }
   streamDrainSpans(stream, outBuffer, maxSpans) {
-    const count = this.opentui.symbols.streamDrainSpans(stream, ptr4(outBuffer), maxSpans);
+    const count = this.opentui.symbols.streamDrainSpans(stream, ptr(outBuffer), maxSpans);
     return toNumber(count);
   }
   streamClose(stream) {
@@ -14468,11 +14872,11 @@ class FFIRenderLib {
   }
   streamSetOptions(stream, options) {
     const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options);
-    return this.opentui.symbols.streamSetOptions(stream, ptr4(optionsBuffer));
+    return this.opentui.symbols.streamSetOptions(stream, ptr(optionsBuffer));
   }
   streamGetStats(stream) {
     const statsBuffer = new ArrayBuffer(NativeSpanFeedStatsStruct.size);
-    const status = this.opentui.symbols.streamGetStats(stream, ptr4(statsBuffer));
+    const status = this.opentui.symbols.streamGetStats(stream, ptr(statsBuffer));
     if (status !== 0) {
       return null;
     }
@@ -14486,7 +14890,7 @@ class FFIRenderLib {
   }
   streamReserve(stream, minLen) {
     const reserveBuffer = new ArrayBuffer(ReserveInfoStruct.size);
-    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr4(reserveBuffer));
+    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr(reserveBuffer));
     if (status !== 0) {
       return { status, info: null };
     }
@@ -14527,7 +14931,7 @@ class FFIRenderLib {
       return;
     }
     const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
-    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr4(chunksBuffer), nonEmptyChunks.length);
+    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr(chunksBuffer), nonEmptyChunks.length);
   }
   editorViewSetTabIndicator(view, indicator) {
     this.opentui.symbols.editorViewSetTabIndicator(view, indicator);
@@ -14582,9 +14986,9 @@ class TextBuffer {
   _textBytes;
   _memId;
   _appendedChunks = [];
-  constructor(lib, ptr5) {
+  constructor(lib, ptr3) {
     this.lib = lib;
-    this.bufferPtr = ptr5;
+    this.bufferPtr = ptr3;
   }
   static create(widthMethod) {
     const lib = resolveRenderLib();
@@ -16310,9 +16714,9 @@ class TextBufferView {
   viewPtr;
   textBuffer;
   _destroyed = false;
-  constructor(lib, ptr5, textBuffer) {
+  constructor(lib, ptr3, textBuffer) {
     this.lib = lib;
-    this.viewPtr = ptr5;
+    this.viewPtr = ptr3;
     this.textBuffer = textBuffer;
   }
   static create(textBuffer) {
@@ -16452,19 +16856,19 @@ class EditBuffer extends EventEmitter6 {
   _singleTextBytes = null;
   _singleTextMemId = null;
   _syntaxStyle;
-  constructor(lib, ptr5) {
+  constructor(lib, ptr3) {
     super();
     this.lib = lib;
-    this.bufferPtr = ptr5;
-    this.textBufferPtr = lib.editBufferGetTextBuffer(ptr5);
-    this.id = lib.editBufferGetId(ptr5);
+    this.bufferPtr = ptr3;
+    this.textBufferPtr = lib.editBufferGetTextBuffer(ptr3);
+    this.id = lib.editBufferGetId(ptr3);
     EditBuffer.registry.set(this.id, this);
     EditBuffer.subscribeToNativeEvents(lib);
   }
   static create(widthMethod) {
     const lib = resolveRenderLib();
-    const ptr5 = lib.createEditBuffer(widthMethod);
-    return new EditBuffer(lib, ptr5);
+    const ptr3 = lib.createEditBuffer(widthMethod);
+    return new EditBuffer(lib, ptr3);
   }
   static subscribeToNativeEvents(lib) {
     if (EditBuffer.nativeEventsSubscribed)
@@ -16757,9 +17161,9 @@ class EditorView {
   _destroyed = false;
   _extmarksController;
   _textBufferViewPtr;
-  constructor(lib, ptr5, editBuffer) {
+  constructor(lib, ptr3, editBuffer) {
     this.lib = lib;
-    this.viewPtr = ptr5;
+    this.viewPtr = ptr3;
     this.editBuffer = editBuffer;
   }
   static create(editBuffer, viewportWidth, viewportHeight) {
@@ -16978,14 +17382,14 @@ class SyntaxStyle {
   nameCache = new Map;
   styleDefs = new Map;
   mergedCache = new Map;
-  constructor(lib, ptr5) {
+  constructor(lib, ptr3) {
     this.lib = lib;
-    this.stylePtr = ptr5;
+    this.stylePtr = ptr3;
   }
   static create() {
     const lib = resolveRenderLib();
-    const ptr5 = lib.createSyntaxStyle();
-    return new SyntaxStyle(lib, ptr5);
+    const ptr3 = lib.createSyntaxStyle();
+    return new SyntaxStyle(lib, ptr3);
   }
   static fromTheme(theme) {
     const style = SyntaxStyle.create();
@@ -21085,6 +21489,7 @@ var CliRenderEvents;
   CliRenderEvents2["FOCUSED_RENDERABLE"] = "focused_renderable";
   CliRenderEvents2["FOCUSED_EDITOR"] = "focused_editor";
   CliRenderEvents2["THEME_MODE"] = "theme_mode";
+  CliRenderEvents2["PALETTE"] = "palette";
   CliRenderEvents2["CAPABILITIES"] = "capabilities";
   CliRenderEvents2["SELECTION"] = "selection";
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
@@ -21172,6 +21577,7 @@ class CliRenderer extends EventEmitter9 {
   animationRequest = new Map;
   resizeTimeoutId = null;
   capabilityTimeoutId = null;
+  xtVersionWaiters = new Set;
   splitStartupSeedTimeoutId = null;
   pendingSplitStartupCursorSeed = false;
   resizeDebounceDelay = 100;
@@ -21221,11 +21627,11 @@ class CliRenderer extends EventEmitter9 {
   _openConsoleOnError = true;
   _paletteDetector = null;
   _paletteCache = new Map;
-  _cachedPalette = null;
   _paletteDetectionPromise = null;
   _paletteDetectionSize = 0;
   _paletteEpoch = 0;
-  _publishedPaletteSignature = null;
+  _nativePaletteSignature = null;
+  _emittedPaletteSignature = null;
   _palettePublishGeneration = 0;
   _onDestroy;
   themeModeState;
@@ -21344,6 +21750,10 @@ Captured external output:
     this.themeModeHandler = (sequence) => {
       const result = this.themeModeState.handleSequence(sequence);
       if (result.changedMode) {
+        this.clearPaletteCache();
+        if (this.shouldSyncNativePaletteState() || this.listenerCount("palette" /* PALETTE */) > 0) {
+          this.refreshPalette();
+        }
         this.emit("theme_mode" /* THEME_MODE */, result.changedMode);
       }
       return result.handled;
@@ -22510,6 +22920,7 @@ Captured external output:
         explicitWidthCprActive: false,
         startupCursorCprActive: false
       }, true);
+      this.resolveXtVersionWaiters();
     }, 5000);
     if (this._useMouse) {
       this.enableMouse();
@@ -22531,7 +22942,9 @@ Captured external output:
       }, 120);
     }
     this.queryPixelResolution();
-    this.ensureNativePaletteState();
+    if (this.shouldSyncNativePaletteState()) {
+      this.refreshPalette();
+    }
   }
   stdinListener = ((chunk) => {
     const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -22574,6 +22987,9 @@ Captured external output:
     }
     this.lib.processCapabilityResponse(this.rendererPtr, sequence);
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
+    if (this._capabilities?.terminal?.from_xtversion) {
+      this.resolveXtVersionWaiters();
+    }
     if (hasStandardCapabilitySignature) {
       this.forceFullRepaintRequested = true;
       this.requestRender();
@@ -23218,6 +23634,7 @@ Captured external output:
       return;
     this._isDestroyed = true;
     this._destroyPending = true;
+    this._palettePublishGeneration++;
     if (this.rendering) {
       this.prepareDestroyDuringRender();
       return;
@@ -23291,10 +23708,10 @@ Captured external output:
     this._paletteCache.clear();
     this._paletteDetectionPromise = null;
     this._paletteDetectionSize = 0;
-    this._cachedPalette = null;
-    this._publishedPaletteSignature = null;
+    this._nativePaletteSignature = null;
+    this._emittedPaletteSignature = null;
     this._paletteEpoch = 0;
-    this._palettePublishGeneration = 0;
+    this.resolveXtVersionWaiters();
     this.themeModeState.dispose();
     this.emit("destroy" /* DESTROY */);
     try {
@@ -23611,36 +24028,72 @@ Captured external output:
   }
   ensurePaletteDetector() {
     if (!this._paletteDetector) {
+      const isTmux = Boolean(this.capabilities?.in_tmux || this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux"));
       const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
-      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
-        subscribeOsc: this.subscribeOsc.bind(this)
-      }, this.clock);
+      this._paletteDetector = createTerminalPalette({
+        stdin: this.stdin,
+        stdout: this.stdout,
+        writeFn: (data) => this._isDestroyed ? false : this.writeOut(data),
+        isLegacyTmux,
+        isTmux,
+        oscSource: {
+          subscribeOsc: this.subscribeOsc.bind(this)
+        },
+        clock: this.clock
+      });
     }
     return this._paletteDetector;
   }
   syncNativePaletteState(colors) {
     const signature = buildTerminalPaletteSignature(colors);
-    if (this._publishedPaletteSignature !== signature) {
+    if (this._nativePaletteSignature !== signature) {
       this._paletteEpoch = this._paletteEpoch + 1 >>> 0;
     }
-    this._publishedPaletteSignature = signature;
+    this._nativePaletteSignature = signature;
     const normalized = normalizeTerminalPalette(colors);
     this.lib.rendererSetPaletteState(this.rendererPtr, normalized.palette, normalized.defaultForeground, normalized.defaultBackground, this._paletteEpoch);
   }
-  ensureNativePaletteState() {
-    if (!this._terminalIsSetup || this._isDestroyed)
+  emitPaletteChange(colors) {
+    if (this.listenerCount("palette" /* PALETTE */) === 0)
       return;
+    const signature = buildTerminalPaletteSignature(colors);
+    if (this._emittedPaletteSignature === signature)
+      return;
+    this._emittedPaletteSignature = signature;
+    this.emit("palette" /* PALETTE */, colors);
+  }
+  resolveXtVersionWaiters() {
+    if (this.xtVersionWaiters.size === 0)
+      return;
+    const resolvers = [...this.xtVersionWaiters];
+    this.xtVersionWaiters.clear();
+    for (const resolve4 of resolvers) {
+      resolve4();
+    }
+  }
+  waitForXtVersion() {
+    if (this.capabilityTimeoutId === null || this._capabilities?.terminal?.from_xtversion) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve4) => {
+      this.xtVersionWaiters.add(resolve4);
+    });
+  }
+  shouldSyncNativePaletteState() {
+    return Boolean(this._terminalIsSetup && !this._isDestroyed && this._capabilities?.ansi256 && !this._capabilities?.rgb);
+  }
+  refreshPalette() {
     const publishGeneration = this._palettePublishGeneration;
-    this.getPalette({ size: NATIVE_PALETTE_QUERY_SIZE }).then((colors) => {
-      if (this._palettePublishGeneration === publishGeneration) {
-        this.syncNativePaletteState(colors);
-      }
-      this.requestRender();
+    this.getPalette({ size: NATIVE_PALETTE_QUERY_SIZE }).then(() => {
+      if (this._isDestroyed)
+        return;
+      if (this._palettePublishGeneration === publishGeneration)
+        this.requestRender();
     }).catch(() => {});
   }
   clearPaletteCache() {
+    this._palettePublishGeneration++;
     this._paletteCache.clear();
-    this._cachedPalette = null;
   }
   async getPalette(options) {
     if (this._controlState === "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
@@ -23650,15 +24103,22 @@ Captured external output:
     const detectionTimeout = options?.timeout;
     const cachedPalette = this.getCachedPaletteBySize(requestedSize);
     if (cachedPalette) {
-      this._cachedPalette = cachedPalette;
       return cachedPalette;
     }
+    const terminal = this._capabilities?.terminal;
+    const hasTmuxVersion = terminal?.name?.toLowerCase() === "tmux" && Boolean(terminal.version);
+    if (this._capabilities?.in_tmux && !hasTmuxVersion) {
+      await this.waitForXtVersion();
+      const afterCapabilityWait = this.getCachedPaletteBySize(requestedSize);
+      if (afterCapabilityWait) {
+        return afterCapabilityWait;
+      }
+    }
     if (this._paletteDetectionPromise) {
       if (this._paletteDetectionSize >= requestedSize) {
         return this._paletteDetectionPromise.then((palette) => {
           const cached = this.getCachedPaletteBySize(requestedSize);
           if (cached) {
-            this._cachedPalette = cached;
             return cached;
           }
           const projected = {
@@ -23666,14 +24126,12 @@ Captured external output:
             palette: palette.palette.slice(0, requestedSize)
           };
           this._paletteCache.set(requestedSize, projected);
-          this._cachedPalette = projected;
           return projected;
         });
       }
       await this._paletteDetectionPromise;
       const afterWait = this.getCachedPaletteBySize(requestedSize);
       if (afterWait) {
-        this._cachedPalette = afterWait;
         return afterWait;
       }
     }
@@ -23682,14 +24140,14 @@ Captured external output:
     this._paletteDetectionSize = requestedSize;
     this._paletteDetectionPromise = detector.detect({ ...options, timeout: detectionTimeout }).then((result) => {
       this._paletteCache.set(result.palette.length, result);
-      this._cachedPalette = result;
       this._paletteDetectionPromise = null;
       this._paletteDetectionSize = 0;
-      if (this._palettePublishGeneration === publishGeneration) {
-        if (result.palette.length >= NATIVE_PALETTE_QUERY_SIZE) {
+      if (!this._isDestroyed && this._palettePublishGeneration === publishGeneration) {
+        this.emitPaletteChange(result);
+        if (this.shouldSyncNativePaletteState() && result.palette.length >= NATIVE_PALETTE_QUERY_SIZE) {
           this.syncNativePaletteState(result);
-        } else if (this._terminalIsSetup && !this._paletteCache.has(NATIVE_PALETTE_QUERY_SIZE)) {
-          this.ensureNativePaletteState();
+        } else if (this.shouldSyncNativePaletteState() && !this._paletteCache.has(NATIVE_PALETTE_QUERY_SIZE)) {
+          this.refreshPalette();
         }
       }
       return result;
@@ -23700,12 +24158,11 @@ Captured external output:
     });
     const detected = await this._paletteDetectionPromise;
     const finalPalette = this.getCachedPaletteBySize(requestedSize) ?? detected;
-    this._cachedPalette = finalPalette;
     return finalPalette;
   }
 }
 
-export { __toESM, __commonJS, __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, 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, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, ANSI, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, TextRenderable, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, calculateRenderGeometry, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __export, __require, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, 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, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, detectLinks, toArrayBuffer, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, TextBufferView, EditBuffer, EditorView, convertThemeToStyles, SyntaxStyle, ANSI, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, TextRenderable, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingAction, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, EditBufferRenderableEvents, isEditBufferRenderable, EditBufferRenderable, calculateRenderGeometry, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=9856AC3785612B6364756E2164756E21
-//# sourceMappingURL=index-mw2x3082.js.map
+//# debugId=74349463B90D49D364756E2164756E21
+//# sourceMappingURL=index-jv9g79dk.js.map