@gridland/web 0.2.27 → 0.2.29

package/dist/core-shims.js

@@ -572,21 +572,21 @@ var require_scheduler_development = __commonJS({
 
 // ../../node_modules/.bun/scheduler@0.27.0/node_modules/scheduler/index.js
 var require_scheduler = __commonJS({
-  "../../node_modules/.bun/scheduler@0.27.0/node_modules/scheduler/index.js"(exports, module) {
+  "../../node_modules/.bun/scheduler@0.27.0/node_modules/scheduler/index.js"(exports, module2) {
     "use strict";
     if (process.env.NODE_ENV === "production") {
-      module.exports = require_scheduler_production();
+      module2.exports = require_scheduler_production();
     } else {
-      module.exports = require_scheduler_development();
+      module2.exports = require_scheduler_development();
     }
   }
 });
 
 // ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.production.js
 var require_react_reconciler_production = __commonJS({
-  "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.production.js"(exports, module) {
+  "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.production.js"(exports, module2) {
     "use strict";
-    module.exports = function($$$config) {
+    module2.exports = function($$$config) {
       function createFiber(tag, pendingProps, key, mode) {
         return new FiberNode(tag, pendingProps, key, mode);
       }
@@ -8756,16 +8756,16 @@ var require_react_reconciler_production = __commonJS({
       };
       return exports2;
     };
-    module.exports.default = module.exports;
-    Object.defineProperty(module.exports, "__esModule", { value: true });
+    module2.exports.default = module2.exports;
+    Object.defineProperty(module2.exports, "__esModule", { value: true });
   }
 });
 
 // ../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.development.js
 var require_react_reconciler_development = __commonJS({
-  "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.development.js"(exports, module) {
+  "../../node_modules/.bun/react-reconciler@0.33.0+b1ab299f0a400331/node_modules/react-reconciler/cjs/react-reconciler.development.js"(exports, module2) {
     "use strict";
-    "production" !== process.env.NODE_ENV && (module.exports = function($$$config) {
+    "production" !== process.env.NODE_ENV && (module2.exports = function($$$config) {
       function findHook(fiber, id) {
         for (fiber = fiber.memoizedState; null !== fiber && 0 < id; )
           fiber = fiber.next, id--;
@@ -22530,18 +22530,18 @@ var require_react_reconciler_development = __commonJS({
       };
       exports2.updateContainerSync = updateContainerSync;
       return exports2;
-    }, module.exports.default = module.exports, Object.defineProperty(module.exports, "__esModule", { value: true }));
+    }, module2.exports.default = module2.exports, Object.defineProperty(module2.exports, "__esModule", { value: true }));
   }
 });
 
 // node_modules/react-reconciler/index.js
 var require_react_reconciler = __commonJS({
-  "node_modules/react-reconciler/index.js"(exports, module) {
+  "node_modules/react-reconciler/index.js"(exports, module2) {
     "use strict";
     if (process.env.NODE_ENV === "production") {
-      module.exports = require_react_reconciler_production();
+      module2.exports = require_react_reconciler_production();
     } else {
-      module.exports = require_react_reconciler_development();
+      module2.exports = require_react_reconciler_development();
     }
   }
 });
@@ -22570,12 +22570,12 @@ var require_react_reconciler_constants_development = __commonJS({
 
 // node_modules/react-reconciler/constants.js
 var require_constants = __commonJS({
-  "node_modules/react-reconciler/constants.js"(exports, module) {
+  "node_modules/react-reconciler/constants.js"(exports, module2) {
     "use strict";
     if (process.env.NODE_ENV === "production") {
-      module.exports = require_react_reconciler_constants_production();
+      module2.exports = require_react_reconciler_constants_production();
     } else {
-      module.exports = require_react_reconciler_constants_development();
+      module2.exports = require_react_reconciler_constants_development();
     }
   }
 });
@@ -24165,14 +24165,14 @@ var Justify = /* @__PURE__ */ (function(Justify3) {
   Justify3[Justify3["SpaceEvenly"] = 5] = "SpaceEvenly";
   return Justify3;
 })({});
-var LogLevel = /* @__PURE__ */ (function(LogLevel3) {
-  LogLevel3[LogLevel3["Error"] = 0] = "Error";
-  LogLevel3[LogLevel3["Warn"] = 1] = "Warn";
-  LogLevel3[LogLevel3["Info"] = 2] = "Info";
-  LogLevel3[LogLevel3["Debug"] = 3] = "Debug";
-  LogLevel3[LogLevel3["Verbose"] = 4] = "Verbose";
-  LogLevel3[LogLevel3["Fatal"] = 5] = "Fatal";
-  return LogLevel3;
+var LogLevel2 = /* @__PURE__ */ (function(LogLevel4) {
+  LogLevel4[LogLevel4["Error"] = 0] = "Error";
+  LogLevel4[LogLevel4["Warn"] = 1] = "Warn";
+  LogLevel4[LogLevel4["Info"] = 2] = "Info";
+  LogLevel4[LogLevel4["Debug"] = 3] = "Debug";
+  LogLevel4[LogLevel4["Verbose"] = 4] = "Verbose";
+  LogLevel4[LogLevel4["Fatal"] = 5] = "Fatal";
+  return LogLevel4;
 })({});
 var MeasureMode = /* @__PURE__ */ (function(MeasureMode4) {
   MeasureMode4[MeasureMode4["Undefined"] = 0] = "Undefined";
@@ -24259,12 +24259,12 @@ var constants = {
   JUSTIFY_SPACE_BETWEEN: Justify.SpaceBetween,
   JUSTIFY_SPACE_AROUND: Justify.SpaceAround,
   JUSTIFY_SPACE_EVENLY: Justify.SpaceEvenly,
-  LOG_LEVEL_ERROR: LogLevel.Error,
-  LOG_LEVEL_WARN: LogLevel.Warn,
-  LOG_LEVEL_INFO: LogLevel.Info,
-  LOG_LEVEL_DEBUG: LogLevel.Debug,
-  LOG_LEVEL_VERBOSE: LogLevel.Verbose,
-  LOG_LEVEL_FATAL: LogLevel.Fatal,
+  LOG_LEVEL_ERROR: LogLevel2.Error,
+  LOG_LEVEL_WARN: LogLevel2.Warn,
+  LOG_LEVEL_INFO: LogLevel2.Info,
+  LOG_LEVEL_DEBUG: LogLevel2.Debug,
+  LOG_LEVEL_VERBOSE: LogLevel2.Verbose,
+  LOG_LEVEL_FATAL: LogLevel2.Fatal,
   MEASURE_MODE_UNDEFINED: MeasureMode.Undefined,
   MEASURE_MODE_EXACTLY: MeasureMode.Exactly,
   MEASURE_MODE_AT_MOST: MeasureMode.AtMost,
@@ -31236,23 +31236,6 @@ function detectLinks(chunks, context) {
   return chunks;
 }
 
-// src/shims/renderer-stub.ts
-var CliRenderEvents = /* @__PURE__ */ ((CliRenderEvents2) => {
-  CliRenderEvents2["DESTROY"] = "destroy";
-  CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debug_overlay_toggle";
-  return CliRenderEvents2;
-})(CliRenderEvents || {});
-var CliRenderer = class extends EventEmitter {
-  root = null;
-  keyInput = new EventEmitter();
-  destroy() {
-    this.emit("destroy" /* DESTROY */);
-  }
-};
-function createCliRenderer() {
-  return Promise.resolve(new CliRenderer());
-}
-
 // ../../opentui/packages/core/src/renderables/FrameBuffer.ts
 var FrameBufferRenderable = class extends Renderable {
   frameBuffer;
@@ -40601,6 +40584,19 @@ var TabSelectRenderable = class extends Renderable {
   }
 };
 
+// ../../opentui/packages/core/src/zig-registry.ts
+var _renderLib;
+function registerRenderLib(lib) {
+  _renderLib = lib;
+}
+if (typeof globalThis.Bun !== "undefined") {
+  const zigPath = "./zig";
+  try {
+    await import(zigPath);
+  } catch {
+  }
+}
+
 // ../../opentui/packages/core/src/lib/selection.ts
 var SelectionAnchor = class {
   constructor(renderable, absoluteX, absoluteY) {
@@ -40811,6 +40807,23 @@ var BrowserInternalKeyHandler = class extends BrowserKeyHandler {
   }
 };
 
+// src/shims/renderer-stub.ts
+var CliRenderEvents = /* @__PURE__ */ ((CliRenderEvents2) => {
+  CliRenderEvents2["DESTROY"] = "destroy";
+  CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debug_overlay_toggle";
+  return CliRenderEvents2;
+})(CliRenderEvents || {});
+var CliRenderer = class extends EventEmitter {
+  root = null;
+  keyInput = new EventEmitter();
+  destroy() {
+    this.emit("destroy" /* DESTROY */);
+  }
+};
+function createCliRenderer() {
+  return Promise.resolve(new CliRenderer());
+}
+
 // ../../node_modules/.bun/yoga-layout@3.2.1/node_modules/yoga-layout/dist/src/index.js
 var src_exports2 = {};
 __export(src_exports2, {
@@ -40825,7 +40838,7 @@ __export(src_exports2, {
   FlexDirection: () => FlexDirection2,
   Gutter: () => Gutter2,
   Justify: () => Justify2,
-  LogLevel: () => LogLevel2,
+  LogLevel: () => LogLevel3,
   MeasureMode: () => MeasureMode3,
   NodeType: () => NodeType2,
   Overflow: () => Overflow2,
@@ -42148,14 +42161,14 @@ var Justify2 = /* @__PURE__ */ (function(Justify3) {
   Justify3[Justify3["SpaceEvenly"] = 5] = "SpaceEvenly";
   return Justify3;
 })({});
-var LogLevel2 = /* @__PURE__ */ (function(LogLevel3) {
-  LogLevel3[LogLevel3["Error"] = 0] = "Error";
-  LogLevel3[LogLevel3["Warn"] = 1] = "Warn";
-  LogLevel3[LogLevel3["Info"] = 2] = "Info";
-  LogLevel3[LogLevel3["Debug"] = 3] = "Debug";
-  LogLevel3[LogLevel3["Verbose"] = 4] = "Verbose";
-  LogLevel3[LogLevel3["Fatal"] = 5] = "Fatal";
-  return LogLevel3;
+var LogLevel3 = /* @__PURE__ */ (function(LogLevel4) {
+  LogLevel4[LogLevel4["Error"] = 0] = "Error";
+  LogLevel4[LogLevel4["Warn"] = 1] = "Warn";
+  LogLevel4[LogLevel4["Info"] = 2] = "Info";
+  LogLevel4[LogLevel4["Debug"] = 3] = "Debug";
+  LogLevel4[LogLevel4["Verbose"] = 4] = "Verbose";
+  LogLevel4[LogLevel4["Fatal"] = 5] = "Fatal";
+  return LogLevel4;
 })({});
 var MeasureMode3 = /* @__PURE__ */ (function(MeasureMode4) {
   MeasureMode4[MeasureMode4["Undefined"] = 0] = "Undefined";
@@ -42242,12 +42255,12 @@ var constants2 = {
   JUSTIFY_SPACE_BETWEEN: Justify2.SpaceBetween,
   JUSTIFY_SPACE_AROUND: Justify2.SpaceAround,
   JUSTIFY_SPACE_EVENLY: Justify2.SpaceEvenly,
-  LOG_LEVEL_ERROR: LogLevel2.Error,
-  LOG_LEVEL_WARN: LogLevel2.Warn,
-  LOG_LEVEL_INFO: LogLevel2.Info,
-  LOG_LEVEL_DEBUG: LogLevel2.Debug,
-  LOG_LEVEL_VERBOSE: LogLevel2.Verbose,
-  LOG_LEVEL_FATAL: LogLevel2.Fatal,
+  LOG_LEVEL_ERROR: LogLevel3.Error,
+  LOG_LEVEL_WARN: LogLevel3.Warn,
+  LOG_LEVEL_INFO: LogLevel3.Info,
+  LOG_LEVEL_DEBUG: LogLevel3.Debug,
+  LOG_LEVEL_VERBOSE: LogLevel3.Verbose,
+  LOG_LEVEL_FATAL: LogLevel3.Fatal,
   MEASURE_MODE_UNDEFINED: MeasureMode3.Undefined,
   MEASURE_MODE_EXACTLY: MeasureMode3.Exactly,
   MEASURE_MODE_AT_MOST: MeasureMode3.AtMost,
@@ -42608,6 +42621,2863 @@ var useTimeline = (options = {}) => {
   return timeline;
 };
 
+// src/shims/bun-ffi.ts
+function toArrayBuffer(_ptr, _offset, _size) {
+  return new ArrayBuffer(0);
+}
+function ptr(_buf) {
+  return 0;
+}
+function dlopen(_path, _symbols) {
+  return { symbols: {}, close() {
+  } };
+}
+var JSCallback = class {
+  ptr = 0;
+  constructor(_fn, _options) {
+  }
+  close() {
+  }
+};
+
+// src/shims/node-fs.ts
+function existsSync(_path) {
+  return false;
+}
+
+// src/shims/bun-ffi-structs.ts
+function defineStruct(_def) {
+  return class StubStruct {
+    constructor(..._args) {
+    }
+  };
+}
+function defineEnum(_def) {
+  return {};
+}
+
+// ../../opentui/packages/core/src/zig-structs.ts
+var rgbaPackTransform = (rgba) => rgba ? ptr(rgba.buffer) : null;
+var rgbaUnpackTransform = (ptr2) => ptr2 ? RGBA2.fromArray(new Float32Array(toArrayBuffer(ptr2))) : void 0;
+var StyledChunkStruct = defineStruct(
+  [
+    ["text", "char*"],
+    ["text_len", "u64", { lengthOf: "text" }],
+    [
+      "fg",
+      "pointer",
+      {
+        optional: true,
+        packTransform: rgbaPackTransform,
+        unpackTransform: rgbaUnpackTransform
+      }
+    ],
+    [
+      "bg",
+      "pointer",
+      {
+        optional: true,
+        packTransform: rgbaPackTransform,
+        unpackTransform: rgbaUnpackTransform
+      }
+    ],
+    ["attributes", "u32", { default: 0 }],
+    ["link", "char*", { default: "" }],
+    ["link_len", "u64", { lengthOf: "link" }]
+  ],
+  {
+    mapValue: (chunk) => {
+      if (!chunk.link || typeof chunk.link === "string") {
+        return chunk;
+      }
+      return {
+        ...chunk,
+        link: chunk.link.url
+      };
+    }
+  }
+);
+var HighlightStruct = defineStruct([
+  ["start", "u32"],
+  ["end", "u32"],
+  ["styleId", "u32"],
+  ["priority", "u8", { default: 0 }],
+  ["hlRef", "u16", { default: 0 }]
+]);
+var LogicalCursorStruct = defineStruct([
+  ["row", "u32"],
+  ["col", "u32"],
+  ["offset", "u32"]
+]);
+var VisualCursorStruct = defineStruct([
+  ["visualRow", "u32"],
+  ["visualCol", "u32"],
+  ["logicalRow", "u32"],
+  ["logicalCol", "u32"],
+  ["offset", "u32"]
+]);
+var UnicodeMethodEnum = defineEnum({ wcwidth: 0, unicode: 1 }, "u8");
+var TerminalCapabilitiesStruct = defineStruct([
+  ["kitty_keyboard", "bool_u8"],
+  ["kitty_graphics", "bool_u8"],
+  ["rgb", "bool_u8"],
+  ["unicode", UnicodeMethodEnum],
+  ["sgr_pixels", "bool_u8"],
+  ["color_scheme_updates", "bool_u8"],
+  ["explicit_width", "bool_u8"],
+  ["scaled_text", "bool_u8"],
+  ["sixel", "bool_u8"],
+  ["focus_tracking", "bool_u8"],
+  ["sync", "bool_u8"],
+  ["bracketed_paste", "bool_u8"],
+  ["hyperlinks", "bool_u8"],
+  ["osc52", "bool_u8"],
+  ["explicit_cursor_positioning", "bool_u8"],
+  ["term_name", "char*"],
+  ["term_name_len", "u64", { lengthOf: "term_name" }],
+  ["term_version", "char*"],
+  ["term_version_len", "u64", { lengthOf: "term_version" }],
+  ["term_from_xtversion", "bool_u8"]
+]);
+var EncodedCharStruct = defineStruct([
+  ["width", "u8"],
+  ["char", "u32"]
+]);
+var LineInfoStruct = defineStruct([
+  ["starts", ["u32"]],
+  ["startsLen", "u32", { lengthOf: "starts" }],
+  ["widths", ["u32"]],
+  ["widthsLen", "u32", { lengthOf: "widths" }],
+  ["sources", ["u32"]],
+  ["sourcesLen", "u32", { lengthOf: "sources" }],
+  ["wraps", ["u32"]],
+  ["wrapsLen", "u32", { lengthOf: "wraps" }],
+  ["maxWidth", "u32"]
+]);
+var MeasureResultStruct = defineStruct([
+  ["lineCount", "u32"],
+  ["maxWidth", "u32"]
+]);
+var CursorStateStruct = defineStruct([
+  ["x", "u32"],
+  ["y", "u32"],
+  ["visible", "bool_u8"],
+  ["style", "u8"],
+  ["blinking", "bool_u8"],
+  ["r", "f32"],
+  ["g", "f32"],
+  ["b", "f32"],
+  ["a", "f32"]
+]);
+var CursorStyleOptionsStruct = defineStruct([
+  ["style", "u8", { default: 255 }],
+  ["blinking", "u8", { default: 255 }],
+  [
+    "color",
+    "pointer",
+    {
+      optional: true,
+      packTransform: rgbaPackTransform,
+      unpackTransform: rgbaUnpackTransform
+    }
+  ],
+  ["cursor", "u8", { default: 255 }]
+]);
+var GridDrawOptionsStruct = defineStruct([
+  ["drawInner", "bool_u8", { default: true }],
+  ["drawOuter", "bool_u8", { default: true }]
+]);
+var BuildOptionsStruct = defineStruct([
+  ["gpaSafeStats", "bool_u8"],
+  ["gpaMemoryLimitTracking", "bool_u8"]
+]);
+var AllocatorStatsStruct = defineStruct([
+  ["totalRequestedBytes", "u64"],
+  ["activeAllocations", "u64"],
+  ["smallAllocations", "u64"],
+  ["largeAllocations", "u64"],
+  ["requestedBytesValid", "bool_u8"]
+]);
+var GrowthPolicyEnum = defineEnum({ grow: 0, block: 1 }, "u8");
+var NativeSpanFeedOptionsStruct = defineStruct([
+  ["chunkSize", "u32", { default: 64 * 1024 }],
+  ["initialChunks", "u32", { default: 2 }],
+  ["maxBytes", "u64", { default: 0n }],
+  ["growthPolicy", GrowthPolicyEnum, { default: "grow" }],
+  ["autoCommitOnFull", "bool_u8", { default: true }],
+  ["spanQueueCapacity", "u32", { default: 0 }]
+]);
+var NativeSpanFeedStatsStruct = defineStruct([
+  ["bytesWritten", "u64"],
+  ["spansCommitted", "u64"],
+  ["chunks", "u32"],
+  ["pendingSpans", "u32"]
+]);
+var SpanInfoStruct = defineStruct(
+  [
+    ["chunkPtr", "pointer"],
+    ["offset", "u32"],
+    ["len", "u32"],
+    ["chunkIndex", "u32"],
+    ["reserved", "u32", { default: 0 }]
+  ],
+  {
+    reduceValue: (value) => ({
+      chunkPtr: value.chunkPtr,
+      offset: value.offset,
+      len: value.len,
+      chunkIndex: value.chunkIndex
+    })
+  }
+);
+var ReserveInfoStruct = defineStruct(
+  [
+    ["ptr", "pointer"],
+    ["len", "u32"],
+    ["reserved", "u32", { default: 0 }]
+  ],
+  {
+    reduceValue: (value) => ({
+      ptr: value.ptr,
+      len: value.len
+    })
+  }
+);
+
+// ../../opentui/packages/core/src/lib/bunfs.ts
+function isBunfsPath(path) {
+  return path.includes("$bunfs") || /^B:[\\/]~BUN/i.test(path);
+}
+
+// ../../opentui/packages/core/src/zig.ts
+var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
+var targetLibPath = module.default;
+if (isBunfsPath(targetLibPath)) {
+  targetLibPath = targetLibPath.replace("../", "");
+}
+if (!existsSync(targetLibPath)) {
+  throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
+}
+registerEnvVar({
+  name: "OTUI_DEBUG_FFI",
+  description: "Enable debug logging for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OTUI_TRACE_FFI",
+  description: "Enable tracing for the FFI bindings.",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OPENTUI_FORCE_WCWIDTH",
+  description: "Use wcwidth for character width calculations",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OPENTUI_FORCE_UNICODE",
+  description: "Force Mode 2026 Unicode support in terminal capabilities",
+  type: "boolean",
+  default: false
+});
+registerEnvVar({
+  name: "OPENTUI_GRAPHICS",
+  description: "Enable Kitty graphics protocol detection",
+  type: "boolean",
+  default: true
+});
+registerEnvVar({
+  name: "OPENTUI_FORCE_NOZWJ",
+  description: "Use no_zwj width method (Unicode without ZWJ joining)",
+  type: "boolean",
+  default: false
+});
+var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2 };
+var CURSOR_ID_TO_STYLE = ["block", "line", "underline"];
+var MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4, "not-allowed": 5 };
+var globalTraceSymbols = null;
+var globalFFILogWriter = 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 getOpenTUILib(libPath) {
+  const resolvedLibPath = libPath || targetLibPath;
+  const rawSymbols = dlopen(resolvedLibPath, {
+    // Logging
+    setLogCallback: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    // Event bus
+    setEventCallback: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    // Renderer management
+    createRenderer: {
+      args: ["u32", "u32", "bool", "bool"],
+      returns: "ptr"
+    },
+    setTerminalEnvVar: {
+      args: ["ptr", "ptr", "usize", "ptr", "usize"],
+      returns: "bool"
+    },
+    destroyRenderer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    setUseThread: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    setBackgroundColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    setRenderOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    updateStats: {
+      args: ["ptr", "f64", "u32", "f64"],
+      returns: "void"
+    },
+    updateMemoryStats: {
+      args: ["ptr", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    render: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    getNextBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    getCurrentBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    queryPixelResolution: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    createOptimizedBuffer: {
+      args: ["u32", "u32", "bool", "u8", "ptr", "usize"],
+      returns: "ptr"
+    },
+    destroyOptimizedBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    drawFrameBuffer: {
+      args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    getBufferWidth: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    getBufferHeight: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferClear: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    bufferGetCharPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetFgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetBgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetAttributesPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetRespectAlpha: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    bufferSetRespectAlpha: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    bufferGetId: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    bufferGetRealCharSize: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferWriteResolvedChars: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "u32"
+    },
+    bufferDrawText: {
+      args: ["ptr", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    bufferSetCellWithAlphaBlending: {
+      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    bufferSetCell: {
+      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    bufferFillRect: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr"],
+      returns: "void"
+    },
+    bufferResize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    // Link API
+    linkAlloc: {
+      args: ["ptr", "u32"],
+      returns: "u32"
+    },
+    linkGetUrl: {
+      args: ["u32", "ptr", "u32"],
+      returns: "u32"
+    },
+    attributesWithLink: {
+      args: ["u32", "u32"],
+      returns: "u32"
+    },
+    attributesGetLinkId: {
+      args: ["u32"],
+      returns: "u32"
+    },
+    resizeRenderer: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    // Cursor functions (now renderer-scoped)
+    setCursorPosition: {
+      args: ["ptr", "i32", "i32", "bool"],
+      returns: "void"
+    },
+    setCursorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    getCursorState: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    // Cursor and mouse pointer style (combined)
+    setCursorStyleOptions: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    // Debug overlay
+    setDebugOverlay: {
+      args: ["ptr", "bool", "u8"],
+      returns: "void"
+    },
+    // Terminal control
+    clearTerminal: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    setTerminalTitle: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    copyToClipboardOSC52: {
+      args: ["ptr", "u8", "ptr", "usize"],
+      returns: "bool"
+    },
+    clearClipboardOSC52: {
+      args: ["ptr", "u8"],
+      returns: "bool"
+    },
+    bufferDrawSuperSampleBuffer: {
+      args: ["ptr", "u32", "u32", "ptr", "usize", "u8", "u32"],
+      returns: "void"
+    },
+    bufferDrawPackedBuffer: {
+      args: ["ptr", "ptr", "usize", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    bufferDrawGrayscaleBuffer: {
+      args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    bufferDrawGrayscaleBufferSupersampled: {
+      args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    bufferDrawGrid: {
+      args: ["ptr", "ptr", "ptr", "ptr", "ptr", "u32", "ptr", "u32", "ptr"],
+      returns: "void"
+    },
+    bufferDrawBox: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "ptr", "u32", "ptr", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    bufferPushScissorRect: {
+      args: ["ptr", "i32", "i32", "u32", "u32"],
+      returns: "void"
+    },
+    bufferPopScissorRect: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    bufferClearScissorRects: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    bufferPushOpacity: {
+      args: ["ptr", "f32"],
+      returns: "void"
+    },
+    bufferPopOpacity: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    bufferGetCurrentOpacity: {
+      args: ["ptr"],
+      returns: "f32"
+    },
+    bufferClearOpacity: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    addToHitGrid: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    clearCurrentHitGrid: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    hitGridPushScissorRect: {
+      args: ["ptr", "i32", "i32", "u32", "u32"],
+      returns: "void"
+    },
+    hitGridPopScissorRect: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    hitGridClearScissorRects: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    addToCurrentHitGridClipped: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    checkHit: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    getHitGridDirty: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    dumpHitGrid: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    dumpBuffers: {
+      args: ["ptr", "i64"],
+      returns: "void"
+    },
+    dumpStdoutBuffer: {
+      args: ["ptr", "i64"],
+      returns: "void"
+    },
+    restoreTerminalModes: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    enableMouse: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    disableMouse: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    enableKittyKeyboard: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    disableKittyKeyboard: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    setKittyKeyboardFlags: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    getKittyKeyboardFlags: {
+      args: ["ptr"],
+      returns: "u8"
+    },
+    setupTerminal: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    suspendRenderer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    resumeRenderer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    writeOut: {
+      args: ["ptr", "ptr", "u64"],
+      returns: "void"
+    },
+    // TextBuffer functions
+    createTextBuffer: {
+      args: ["u8"],
+      returns: "ptr"
+    },
+    destroyTextBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferGetLength: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferGetByteSize: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferReset: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferClear: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultFg: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultBg: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultAttributes: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferResetDefaults: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferGetTabWidth: {
+      args: ["ptr"],
+      returns: "u8"
+    },
+    textBufferSetTabWidth: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    textBufferRegisterMemBuffer: {
+      args: ["ptr", "ptr", "usize", "bool"],
+      returns: "u16"
+    },
+    textBufferReplaceMemBuffer: {
+      args: ["ptr", "u8", "ptr", "usize", "bool"],
+      returns: "bool"
+    },
+    textBufferClearMemRegistry: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetTextFromMem: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    textBufferAppend: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    textBufferAppendFromMemId: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    textBufferLoadFile: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "bool"
+    },
+    textBufferSetStyledText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    textBufferGetLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferGetPlainText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferAddHighlightByCharRange: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferAddHighlight: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "void"
+    },
+    textBufferRemoveHighlightsByRef: {
+      args: ["ptr", "u16"],
+      returns: "void"
+    },
+    textBufferClearLineHighlights: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferClearAllHighlights: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetSyntaxStyle: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferGetLineHighlightsPtr: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "ptr"
+    },
+    textBufferFreeLineHighlights: {
+      args: ["ptr", "usize"],
+      returns: "void"
+    },
+    textBufferGetHighlightCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferGetTextRange: {
+      args: ["ptr", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferGetTextRangeByCoords: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    // TextBufferView functions
+    createTextBufferView: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    destroyTextBufferView: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewGetSelectionInfo: {
+      args: ["ptr"],
+      returns: "u64"
+    },
+    textBufferViewSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    textBufferViewUpdateSelection: {
+      args: ["ptr", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewUpdateLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    textBufferViewResetLocalSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferViewSetWrapWidth: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferViewSetWrapMode: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    textBufferViewSetViewportSize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    textBufferViewSetViewport: {
+      args: ["ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    textBufferViewGetVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferViewGetLineInfoDirect: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewGetLogicalLineInfoDirect: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewGetSelectedText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferViewGetPlainText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferViewSetTabIndicator: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferViewSetTabIndicatorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferViewSetTruncate: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    textBufferViewMeasureForDimensions: {
+      args: ["ptr", "u32", "u32", "ptr"],
+      returns: "bool"
+    },
+    bufferDrawTextBufferView: {
+      args: ["ptr", "ptr", "i32", "i32"],
+      returns: "void"
+    },
+    bufferDrawEditorView: {
+      args: ["ptr", "ptr", "i32", "i32"],
+      returns: "void"
+    },
+    // EditorView functions
+    createEditorView: {
+      args: ["ptr", "u32", "u32"],
+      returns: "ptr"
+    },
+    destroyEditorView: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewSetViewportSize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editorViewSetViewport: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "bool"],
+      returns: "void"
+    },
+    editorViewGetViewport: {
+      args: ["ptr", "ptr", "ptr", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetScrollMargin: {
+      args: ["ptr", "f32"],
+      returns: "void"
+    },
+    editorViewSetWrapMode: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    editorViewGetVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    editorViewGetTotalVirtualLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    editorViewGetTextBufferView: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    editorViewGetLineInfoDirect: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetLogicalLineInfoDirect: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    // EditBuffer functions
+    createEditBuffer: {
+      args: ["u8"],
+      returns: "ptr"
+    },
+    destroyEditBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferSetText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferSetTextFromMem: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    editBufferReplaceText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferReplaceTextFromMem: {
+      args: ["ptr", "u8"],
+      returns: "void"
+    },
+    editBufferGetText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferInsertChar: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferInsertText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editBufferDeleteChar: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteCharBackward: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteRange: {
+      args: ["ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferNewLine: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferDeleteLine: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorLeft: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorRight: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorUp: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferMoveCursorDown: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferGotoLine: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursor: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursorToLineCol: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    editBufferSetCursorByOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editBufferGetCursorPosition: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetId: {
+      args: ["ptr"],
+      returns: "u16"
+    },
+    editBufferGetTextBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    editBufferDebugLogRope: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferUndo: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferRedo: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferCanUndo: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    editBufferCanRedo: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    editBufferClearHistory: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferClear: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editBufferGetNextWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editBufferOffsetToPosition: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "bool"
+    },
+    editBufferPositionToOffset: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    editBufferGetLineStartOffset: {
+      args: ["ptr", "u32"],
+      returns: "u32"
+    },
+    editBufferGetTextRange: {
+      args: ["ptr", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    editBufferGetTextRangeByCoords: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr", "usize"],
+      returns: "usize"
+    },
+    // EditorView selection and editing methods
+    editorViewSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewGetSelection: {
+      args: ["ptr"],
+      returns: "u64"
+    },
+    editorViewSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr", "bool", "bool"],
+      returns: "bool"
+    },
+    editorViewUpdateSelection: {
+      args: ["ptr", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewUpdateLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr", "bool", "bool"],
+      returns: "bool"
+    },
+    editorViewResetLocalSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewGetSelectedTextBytes: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    editorViewGetCursor: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    // EditorView VisualCursor methods
+    editorViewGetVisualCursor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewMoveUpVisual: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewMoveDownVisual: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewDeleteSelectedText: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    editorViewSetCursorByOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editorViewGetNextWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetPrevWordBoundary: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetVisualSOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetVisualEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewSetPlaceholderStyledText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    editorViewSetTabIndicator: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    editorViewSetTabIndicatorColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    getArenaAllocatedBytes: {
+      args: [],
+      returns: "usize"
+    },
+    getBuildOptions: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    getAllocatorStats: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    // SyntaxStyle functions
+    createSyntaxStyle: {
+      args: [],
+      returns: "ptr"
+    },
+    destroySyntaxStyle: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    syntaxStyleRegister: {
+      args: ["ptr", "ptr", "usize", "ptr", "ptr", "u8"],
+      returns: "u32"
+    },
+    syntaxStyleResolveByName: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "u32"
+    },
+    syntaxStyleGetStyleCount: {
+      args: ["ptr"],
+      returns: "usize"
+    },
+    // Terminal capability functions
+    getTerminalCapabilities: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    processCapabilityResponse: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "void"
+    },
+    // Unicode encoding API
+    encodeUnicode: {
+      args: ["ptr", "usize", "ptr", "ptr", "u8"],
+      returns: "bool"
+    },
+    freeUnicode: {
+      args: ["ptr", "usize"],
+      returns: "void"
+    },
+    bufferDrawChar: {
+      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    // NativeSpanFeed
+    createNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    attachNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    destroyNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    streamWrite: {
+      args: ["ptr", "ptr", "u64"],
+      returns: "i32"
+    },
+    streamCommit: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamDrainSpans: {
+      args: ["ptr", "ptr", "u32"],
+      returns: "u32"
+    },
+    streamClose: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamReserve: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "i32"
+    },
+    streamCommitReserved: {
+      args: ["ptr", "u32"],
+      returns: "i32"
+    },
+    streamSetOptions: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamGetStats: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamSetCallback: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    }
+  });
+  if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
+    return {
+      symbols: convertToDebugSymbols(rawSymbols.symbols)
+    };
+  }
+  return rawSymbols;
+}
+function convertToDebugSymbols(symbols) {
+  if (!globalTraceSymbols) {
+    globalTraceSymbols = {};
+  }
+  if (env.OTUI_DEBUG_FFI && !globalFFILogWriter) {
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+    const logFilePath = `ffi_otui_debug_${timestamp}.log`;
+    globalFFILogWriter = Bun.file(logFilePath).writer();
+  }
+  const debugSymbols = {};
+  let hasTracing = false;
+  Object.entries(symbols).forEach(([key, value]) => {
+    debugSymbols[key] = value;
+  });
+  if (env.OTUI_DEBUG_FFI && globalFFILogWriter) {
+    const writer = globalFFILogWriter;
+    const writeSync = (msg) => {
+      const buffer = new TextEncoder().encode(msg + "\n");
+      writer.write(buffer);
+      writer.flush();
+    };
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        debugSymbols[key] = (...args) => {
+          writeSync(`${key}(${args.map((arg) => String(arg)).join(", ")})`);
+          const result = value(...args);
+          writeSync(`${key} returned: ${String(result)}`);
+          return result;
+        };
+      }
+    });
+  }
+  if (env.OTUI_TRACE_FFI) {
+    hasTracing = true;
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        if (!globalTraceSymbols[key]) {
+          globalTraceSymbols[key] = [];
+        }
+        const originalFunc = debugSymbols[key];
+        debugSymbols[key] = (...args) => {
+          const start = performance.now();
+          const result = originalFunc(...args);
+          const end = performance.now();
+          globalTraceSymbols[key].push(end - start);
+          return result;
+        };
+      }
+    });
+  }
+  if ((env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) && !exitHandlerRegistered) {
+    exitHandlerRegistered = true;
+    process.on("exit", () => {
+      try {
+        if (globalFFILogWriter) {
+          globalFFILogWriter.end();
+        }
+      } catch (e) {
+      }
+      if (globalTraceSymbols) {
+        const allStats = [];
+        for (const [key, timings] of Object.entries(globalTraceSymbols)) {
+          if (!Array.isArray(timings) || timings.length === 0) {
+            continue;
+          }
+          const sortedTimings = [...timings].sort((a, b2) => a - b2);
+          const count = sortedTimings.length;
+          const total = sortedTimings.reduce((acc, t2) => acc + t2, 0);
+          const average = total / count;
+          const min = sortedTimings[0];
+          const max = sortedTimings[count - 1];
+          const medianIndex = Math.floor(count / 2);
+          const p90Index = Math.floor(count * 0.9);
+          const p99Index = Math.floor(count * 0.99);
+          const median = sortedTimings[medianIndex];
+          const p90 = sortedTimings[Math.min(p90Index, count - 1)];
+          const p99 = sortedTimings[Math.min(p99Index, count - 1)];
+          allStats.push({
+            name: key,
+            count,
+            total,
+            average,
+            min,
+            max,
+            median,
+            p90,
+            p99
+          });
+        }
+        allStats.sort((a, b2) => b2.total - a.total);
+        const lines = [];
+        lines.push("\n--- OpenTUI FFI Call Performance ---");
+        lines.push("Sorted by total time spent (descending)");
+        lines.push(
+          "-------------------------------------------------------------------------------------------------------------------------"
+        );
+        if (allStats.length === 0) {
+          lines.push("No trace data collected or all symbols had zero calls.");
+        } else {
+          const nameHeader = "Symbol";
+          const callsHeader = "Calls";
+          const totalHeader = "Total (ms)";
+          const avgHeader = "Avg (ms)";
+          const minHeader = "Min (ms)";
+          const maxHeader = "Max (ms)";
+          const medHeader = "Med (ms)";
+          const p90Header = "P90 (ms)";
+          const p99Header = "P99 (ms)";
+          const nameWidth = Math.max(nameHeader.length, ...allStats.map((s) => s.name.length));
+          const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
+          const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
+          const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
+          const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
+          const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
+          const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
+          const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
+          const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
+          lines.push(
+            `${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`
+          );
+          lines.push(
+            `${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`
+          );
+          allStats.forEach((stat) => {
+            lines.push(
+              `${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`
+            );
+          });
+        }
+        lines.push(
+          "-------------------------------------------------------------------------------------------------------------------------"
+        );
+        const output = lines.join("\n");
+        console.log(output);
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+          const traceFilePath = `ffi_otui_trace_${timestamp}.log`;
+          Bun.write(traceFilePath, output);
+        } catch (e) {
+          console.error("Failed to write FFI trace file:", e);
+        }
+      }
+    });
+  }
+  return debugSymbols;
+}
+var FFIRenderLib = class {
+  opentui;
+  encoder = new TextEncoder();
+  decoder = new TextDecoder();
+  logCallbackWrapper;
+  // Store the FFI callback wrapper
+  eventCallbackWrapper;
+  // Store the FFI event callback wrapper
+  _nativeEvents = new EventEmitter();
+  _anyEventHandlers = [];
+  nativeSpanFeedCallbackWrapper = null;
+  nativeSpanFeedHandlers = /* @__PURE__ */ new Map();
+  constructor(libPath) {
+    this.opentui = getOpenTUILib(libPath);
+    this.setupLogging();
+    this.setupEventBus();
+  }
+  setupLogging() {
+    if (this.logCallbackWrapper) {
+      return;
+    }
+    const logCallback = new JSCallback(
+      (level, msgPtr, msgLenBigInt) => {
+        try {
+          const msgLen = typeof msgLenBigInt === "bigint" ? Number(msgLenBigInt) : msgLenBigInt;
+          if (msgLen === 0 || !msgPtr) {
+            return;
+          }
+          const msgBuffer = toArrayBuffer(msgPtr, 0, msgLen);
+          const msgBytes = new Uint8Array(msgBuffer);
+          const message = this.decoder.decode(msgBytes);
+          switch (level) {
+            case LogLevel.Error:
+              console.error(message);
+              break;
+            case LogLevel.Warn:
+              console.warn(message);
+              break;
+            case LogLevel.Info:
+              console.info(message);
+              break;
+            case LogLevel.Debug:
+              console.debug(message);
+              break;
+            default:
+              console.log(message);
+          }
+        } catch (error) {
+          console.error("Error in Zig log callback:", error);
+        }
+      },
+      {
+        args: ["u8", "ptr", "usize"],
+        returns: "void"
+      }
+    );
+    this.logCallbackWrapper = logCallback;
+    if (!logCallback.ptr) {
+      throw new Error("Failed to create log callback");
+    }
+    this.setLogCallback(logCallback.ptr);
+  }
+  setLogCallback(callbackPtr) {
+    this.opentui.symbols.setLogCallback(callbackPtr);
+  }
+  setupEventBus() {
+    if (this.eventCallbackWrapper) {
+      return;
+    }
+    const eventCallback = new JSCallback(
+      (namePtr, nameLenBigInt, dataPtr, dataLenBigInt) => {
+        try {
+          const nameLen = typeof nameLenBigInt === "bigint" ? Number(nameLenBigInt) : nameLenBigInt;
+          const dataLen = typeof dataLenBigInt === "bigint" ? Number(dataLenBigInt) : dataLenBigInt;
+          if (nameLen === 0 || !namePtr) {
+            return;
+          }
+          const nameBuffer = toArrayBuffer(namePtr, 0, nameLen);
+          const nameBytes = new Uint8Array(nameBuffer);
+          const eventName = this.decoder.decode(nameBytes);
+          let eventData;
+          if (dataLen > 0 && dataPtr) {
+            eventData = toArrayBuffer(dataPtr, 0, dataLen).slice();
+          } else {
+            eventData = new ArrayBuffer(0);
+          }
+          queueMicrotask(() => {
+            this._nativeEvents.emit(eventName, eventData);
+            for (const handler of this._anyEventHandlers) {
+              handler(eventName, eventData);
+            }
+          });
+        } catch (error) {
+          console.error("Error in native event callback:", error);
+        }
+      },
+      {
+        args: ["ptr", "usize", "ptr", "usize"],
+        returns: "void"
+      }
+    );
+    this.eventCallbackWrapper = eventCallback;
+    if (!eventCallback.ptr) {
+      throw new Error("Failed to create event callback");
+    }
+    this.setEventCallback(eventCallback.ptr);
+  }
+  ensureNativeSpanFeedCallback() {
+    if (this.nativeSpanFeedCallbackWrapper) {
+      return this.nativeSpanFeedCallbackWrapper;
+    }
+    const callback = new JSCallback(
+      (streamPtr, eventId, arg0, arg1) => {
+        const handler = this.nativeSpanFeedHandlers.get(toPointer(streamPtr));
+        if (handler) {
+          handler(eventId, arg0, arg1);
+        }
+      },
+      {
+        args: ["ptr", "u32", "ptr", "u64"],
+        returns: "void"
+      }
+    );
+    this.nativeSpanFeedCallbackWrapper = callback;
+    if (!callback.ptr) {
+      throw new Error("Failed to create native span feed callback");
+    }
+    return callback;
+  }
+  setEventCallback(callbackPtr) {
+    this.opentui.symbols.setEventCallback(callbackPtr);
+  }
+  createRenderer(width, height, options = {}) {
+    const testing = options.testing ?? false;
+    const remote = options.remote ?? false;
+    return this.opentui.symbols.createRenderer(width, height, testing, remote);
+  }
+  setTerminalEnvVar(renderer, key, value) {
+    const keyBytes = this.encoder.encode(key);
+    const valueBytes = this.encoder.encode(value);
+    return this.opentui.symbols.setTerminalEnvVar(renderer, keyBytes, keyBytes.length, valueBytes, valueBytes.length);
+  }
+  destroyRenderer(renderer) {
+    this.opentui.symbols.destroyRenderer(renderer);
+  }
+  setUseThread(renderer, useThread) {
+    this.opentui.symbols.setUseThread(renderer, useThread);
+  }
+  setBackgroundColor(renderer, color) {
+    this.opentui.symbols.setBackgroundColor(renderer, color.buffer);
+  }
+  setRenderOffset(renderer, offset) {
+    this.opentui.symbols.setRenderOffset(renderer, offset);
+  }
+  updateStats(renderer, time, fps, frameCallbackTime) {
+    this.opentui.symbols.updateStats(renderer, time, fps, frameCallbackTime);
+  }
+  updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers) {
+    this.opentui.symbols.updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers);
+  }
+  getNextBuffer(renderer) {
+    const bufferPtr = this.opentui.symbols.getNextBuffer(renderer);
+    if (!bufferPtr) {
+      throw new Error("Failed to get next buffer");
+    }
+    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
+    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
+    return new BrowserBuffer(this, bufferPtr, width, height, { id: "next buffer", widthMethod: "unicode" });
+  }
+  getCurrentBuffer(renderer) {
+    const bufferPtr = this.opentui.symbols.getCurrentBuffer(renderer);
+    if (!bufferPtr) {
+      throw new Error("Failed to get current buffer");
+    }
+    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
+    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
+    return new BrowserBuffer(this, bufferPtr, width, height, { id: "current buffer", widthMethod: "unicode" });
+  }
+  bufferGetCharPtr(buffer) {
+    const ptr2 = this.opentui.symbols.bufferGetCharPtr(buffer);
+    if (!ptr2) {
+      throw new Error("Failed to get char pointer");
+    }
+    return ptr2;
+  }
+  bufferGetFgPtr(buffer) {
+    const ptr2 = this.opentui.symbols.bufferGetFgPtr(buffer);
+    if (!ptr2) {
+      throw new Error("Failed to get fg pointer");
+    }
+    return ptr2;
+  }
+  bufferGetBgPtr(buffer) {
+    const ptr2 = this.opentui.symbols.bufferGetBgPtr(buffer);
+    if (!ptr2) {
+      throw new Error("Failed to get bg pointer");
+    }
+    return ptr2;
+  }
+  bufferGetAttributesPtr(buffer) {
+    const ptr2 = this.opentui.symbols.bufferGetAttributesPtr(buffer);
+    if (!ptr2) {
+      throw new Error("Failed to get attributes pointer");
+    }
+    return ptr2;
+  }
+  bufferGetRespectAlpha(buffer) {
+    return this.opentui.symbols.bufferGetRespectAlpha(buffer);
+  }
+  bufferSetRespectAlpha(buffer, respectAlpha) {
+    this.opentui.symbols.bufferSetRespectAlpha(buffer, respectAlpha);
+  }
+  bufferGetId(buffer) {
+    const maxLen = 256;
+    const outBuffer = new Uint8Array(maxLen);
+    const actualLen = this.opentui.symbols.bufferGetId(buffer, outBuffer, maxLen);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    return this.decoder.decode(outBuffer.slice(0, len));
+  }
+  bufferGetRealCharSize(buffer) {
+    return this.opentui.symbols.bufferGetRealCharSize(buffer);
+  }
+  bufferWriteResolvedChars(buffer, outputBuffer, addLineBreaks) {
+    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(
+      buffer,
+      outputBuffer,
+      outputBuffer.length,
+      addLineBreaks
+    );
+    return typeof bytesWritten === "bigint" ? Number(bytesWritten) : bytesWritten;
+  }
+  getBufferWidth(buffer) {
+    return this.opentui.symbols.getBufferWidth(buffer);
+  }
+  getBufferHeight(buffer) {
+    return this.opentui.symbols.getBufferHeight(buffer);
+  }
+  bufferClear(buffer, color) {
+    this.opentui.symbols.bufferClear(buffer, color.buffer);
+  }
+  bufferDrawText(buffer, text, x2, y2, color, bgColor, attributes) {
+    const textBytes = this.encoder.encode(text);
+    const textLength = textBytes.byteLength;
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferDrawText(buffer, textBytes, textLength, x2, y2, fg2, bg2, attributes ?? 0);
+  }
+  bufferSetCellWithAlphaBlending(buffer, x2, y2, char, color, bgColor, attributes) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
+    const bg2 = bgColor.buffer;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x2, y2, charPtr, fg2, bg2, attributes ?? 0);
+  }
+  bufferSetCell(buffer, x2, y2, char, color, bgColor, attributes) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
+    const bg2 = bgColor.buffer;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferSetCell(buffer, x2, y2, charPtr, fg2, bg2, attributes ?? 0);
+  }
+  bufferFillRect(buffer, x2, y2, width, height, color) {
+    const bg2 = color.buffer;
+    this.opentui.symbols.bufferFillRect(buffer, x2, y2, width, height, bg2);
+  }
+  bufferDrawSuperSampleBuffer(buffer, x2, y2, pixelDataPtr, pixelDataLength, format2, alignedBytesPerRow) {
+    const formatId = format2 === "bgra8unorm" ? 0 : 1;
+    this.opentui.symbols.bufferDrawSuperSampleBuffer(
+      buffer,
+      x2,
+      y2,
+      pixelDataPtr,
+      pixelDataLength,
+      formatId,
+      alignedBytesPerRow
+    );
+  }
+  bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
+    this.opentui.symbols.bufferDrawPackedBuffer(
+      buffer,
+      dataPtr,
+      dataLen,
+      posX,
+      posY,
+      terminalWidthCells,
+      terminalHeightCells
+    );
+  }
+  bufferDrawGrayscaleBuffer(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2, bg2) {
+    this.opentui.symbols.bufferDrawGrayscaleBuffer(
+      buffer,
+      posX,
+      posY,
+      intensitiesPtr,
+      srcWidth,
+      srcHeight,
+      fg2?.buffer ?? null,
+      bg2?.buffer ?? null
+    );
+  }
+  bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2, bg2) {
+    this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(
+      buffer,
+      posX,
+      posY,
+      intensitiesPtr,
+      srcWidth,
+      srcHeight,
+      fg2?.buffer ?? null,
+      bg2?.buffer ?? null
+    );
+  }
+  bufferDrawGrid(buffer, borderChars, borderFg, borderBg, columnOffsets, columnCount, rowOffsets, rowCount, options) {
+    const optionsBuffer = GridDrawOptionsStruct.pack({
+      drawInner: options.drawInner,
+      drawOuter: options.drawOuter
+    });
+    this.opentui.symbols.bufferDrawGrid(
+      buffer,
+      borderChars,
+      borderFg.buffer,
+      borderBg.buffer,
+      columnOffsets,
+      columnCount,
+      rowOffsets,
+      rowCount,
+      ptr(optionsBuffer)
+    );
+  }
+  bufferDrawBox(buffer, x2, y2, width, height, borderChars, packedOptions, borderColor, backgroundColor, title) {
+    const titleBytes = title ? this.encoder.encode(title) : null;
+    const titleLen = title ? titleBytes.length : 0;
+    const titlePtr = title ? titleBytes : null;
+    this.opentui.symbols.bufferDrawBox(
+      buffer,
+      x2,
+      y2,
+      width,
+      height,
+      borderChars,
+      packedOptions,
+      borderColor.buffer,
+      backgroundColor.buffer,
+      titlePtr,
+      titleLen
+    );
+  }
+  bufferResize(buffer, width, height) {
+    this.opentui.symbols.bufferResize(buffer, width, height);
+  }
+  // Link API
+  linkAlloc(url) {
+    const urlBytes = this.encoder.encode(url);
+    return this.opentui.symbols.linkAlloc(urlBytes, urlBytes.length);
+  }
+  linkGetUrl(linkId, maxLen = 512) {
+    const outBuffer = new Uint8Array(maxLen);
+    const actualLen = this.opentui.symbols.linkGetUrl(linkId, outBuffer, maxLen);
+    return this.decoder.decode(outBuffer.slice(0, actualLen));
+  }
+  attributesWithLink(baseAttributes, linkId) {
+    return this.opentui.symbols.attributesWithLink(baseAttributes, linkId);
+  }
+  attributesGetLinkId(attributes) {
+    return this.opentui.symbols.attributesGetLinkId(attributes);
+  }
+  resizeRenderer(renderer, width, height) {
+    this.opentui.symbols.resizeRenderer(renderer, width, height);
+  }
+  setCursorPosition(renderer, x2, y2, visible) {
+    this.opentui.symbols.setCursorPosition(renderer, x2, y2, visible);
+  }
+  setCursorColor(renderer, color) {
+    this.opentui.symbols.setCursorColor(renderer, color.buffer);
+  }
+  getCursorState(renderer) {
+    const cursorBuffer = new ArrayBuffer(CursorStateStruct.size);
+    this.opentui.symbols.getCursorState(renderer, ptr(cursorBuffer));
+    const struct = CursorStateStruct.unpack(cursorBuffer);
+    return {
+      x: struct.x,
+      y: struct.y,
+      visible: struct.visible,
+      style: CURSOR_ID_TO_STYLE[struct.style] ?? "block",
+      blinking: struct.blinking,
+      color: RGBA2.fromValues(struct.r, struct.g, struct.b, struct.a)
+    };
+  }
+  setCursorStyleOptions(renderer, options) {
+    const style = options.style != null ? CURSOR_STYLE_TO_ID[options.style] : 255;
+    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, ptr(buffer));
+  }
+  render(renderer, force) {
+    this.opentui.symbols.render(renderer, force);
+  }
+  createOptimizedBuffer(width, height, widthMethod, respectAlpha = false, id) {
+    if (Number.isNaN(width) || Number.isNaN(height)) {
+      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
+    }
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const idToUse = id || "unnamed buffer";
+    const idBytes = this.encoder.encode(idToUse);
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(
+      width,
+      height,
+      respectAlpha,
+      widthMethodCode,
+      idBytes,
+      idBytes.length
+    );
+    if (!bufferPtr) {
+      throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
+    }
+    return new BrowserBuffer(this, bufferPtr, width, height, { respectAlpha, id, widthMethod });
+  }
+  destroyOptimizedBuffer(bufferPtr) {
+    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
+  }
+  drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, sourceX, sourceY, sourceWidth, sourceHeight) {
+    const srcX = sourceX ?? 0;
+    const srcY = sourceY ?? 0;
+    const srcWidth = sourceWidth ?? 0;
+    const srcHeight = sourceHeight ?? 0;
+    this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
+  }
+  setDebugOverlay(renderer, enabled, corner) {
+    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
+  }
+  clearTerminal(renderer) {
+    this.opentui.symbols.clearTerminal(renderer);
+  }
+  setTerminalTitle(renderer, title) {
+    const titleBytes = this.encoder.encode(title);
+    this.opentui.symbols.setTerminalTitle(renderer, titleBytes, titleBytes.length);
+  }
+  copyToClipboardOSC52(renderer, target, payload) {
+    return this.opentui.symbols.copyToClipboardOSC52(renderer, target, payload, payload.length);
+  }
+  clearClipboardOSC52(renderer, target) {
+    return this.opentui.symbols.clearClipboardOSC52(renderer, target);
+  }
+  addToHitGrid(renderer, x2, y2, width, height, id) {
+    this.opentui.symbols.addToHitGrid(renderer, x2, y2, width, height, id);
+  }
+  clearCurrentHitGrid(renderer) {
+    this.opentui.symbols.clearCurrentHitGrid(renderer);
+  }
+  hitGridPushScissorRect(renderer, x2, y2, width, height) {
+    this.opentui.symbols.hitGridPushScissorRect(renderer, x2, y2, width, height);
+  }
+  hitGridPopScissorRect(renderer) {
+    this.opentui.symbols.hitGridPopScissorRect(renderer);
+  }
+  hitGridClearScissorRects(renderer) {
+    this.opentui.symbols.hitGridClearScissorRects(renderer);
+  }
+  addToCurrentHitGridClipped(renderer, x2, y2, width, height, id) {
+    this.opentui.symbols.addToCurrentHitGridClipped(renderer, x2, y2, width, height, id);
+  }
+  checkHit(renderer, x2, y2) {
+    return this.opentui.symbols.checkHit(renderer, x2, y2);
+  }
+  getHitGridDirty(renderer) {
+    return this.opentui.symbols.getHitGridDirty(renderer);
+  }
+  dumpHitGrid(renderer) {
+    this.opentui.symbols.dumpHitGrid(renderer);
+  }
+  dumpBuffers(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpBuffers(renderer, ts);
+  }
+  dumpStdoutBuffer(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
+  }
+  restoreTerminalModes(renderer) {
+    this.opentui.symbols.restoreTerminalModes(renderer);
+  }
+  enableMouse(renderer, enableMovement) {
+    this.opentui.symbols.enableMouse(renderer, enableMovement);
+  }
+  disableMouse(renderer) {
+    this.opentui.symbols.disableMouse(renderer);
+  }
+  enableKittyKeyboard(renderer, flags) {
+    this.opentui.symbols.enableKittyKeyboard(renderer, flags);
+  }
+  disableKittyKeyboard(renderer) {
+    this.opentui.symbols.disableKittyKeyboard(renderer);
+  }
+  setKittyKeyboardFlags(renderer, flags) {
+    this.opentui.symbols.setKittyKeyboardFlags(renderer, flags);
+  }
+  getKittyKeyboardFlags(renderer) {
+    return this.opentui.symbols.getKittyKeyboardFlags(renderer);
+  }
+  setupTerminal(renderer, useAlternateScreen) {
+    this.opentui.symbols.setupTerminal(renderer, useAlternateScreen);
+  }
+  suspendRenderer(renderer) {
+    this.opentui.symbols.suspendRenderer(renderer);
+  }
+  resumeRenderer(renderer) {
+    this.opentui.symbols.resumeRenderer(renderer);
+  }
+  queryPixelResolution(renderer) {
+    this.opentui.symbols.queryPixelResolution(renderer);
+  }
+  /**
+   * Write data to stdout, synchronizing with the render thread if necessary.
+   * This should be used for ALL stdout writes to avoid race conditions when
+   * the render thread is active.
+   */
+  writeOut(renderer, data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (bytes.length === 0) return;
+    this.opentui.symbols.writeOut(renderer, ptr(bytes), bytes.length);
+  }
+  // TextBuffer methods
+  createTextBuffer(widthMethod) {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode);
+    if (!bufferPtr) {
+      throw new Error(`Failed to create TextBuffer`);
+    }
+    return new BrowserTextBuffer(this, bufferPtr);
+  }
+  destroyTextBuffer(buffer) {
+    this.opentui.symbols.destroyTextBuffer(buffer);
+  }
+  textBufferGetLength(buffer) {
+    return this.opentui.symbols.textBufferGetLength(buffer);
+  }
+  textBufferGetByteSize(buffer) {
+    return this.opentui.symbols.textBufferGetByteSize(buffer);
+  }
+  textBufferReset(buffer) {
+    this.opentui.symbols.textBufferReset(buffer);
+  }
+  textBufferClear(buffer) {
+    this.opentui.symbols.textBufferClear(buffer);
+  }
+  textBufferSetDefaultFg(buffer, fg2) {
+    const fgPtr = fg2 ? fg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
+  }
+  textBufferSetDefaultBg(buffer, bg2) {
+    const bgPtr = bg2 ? bg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
+  }
+  textBufferSetDefaultAttributes(buffer, attributes) {
+    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
+    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
+  }
+  textBufferResetDefaults(buffer) {
+    this.opentui.symbols.textBufferResetDefaults(buffer);
+  }
+  textBufferGetTabWidth(buffer) {
+    return this.opentui.symbols.textBufferGetTabWidth(buffer);
+  }
+  textBufferSetTabWidth(buffer, width) {
+    this.opentui.symbols.textBufferSetTabWidth(buffer, width);
+  }
+  textBufferRegisterMemBuffer(buffer, bytes, owned = false) {
+    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, owned);
+    if (result === 65535) {
+      throw new Error("Failed to register memory buffer");
+    }
+    return result;
+  }
+  textBufferReplaceMemBuffer(buffer, memId, bytes, owned = false) {
+    return this.opentui.symbols.textBufferReplaceMemBuffer(buffer, memId, bytes, bytes.length, owned);
+  }
+  textBufferClearMemRegistry(buffer) {
+    this.opentui.symbols.textBufferClearMemRegistry(buffer);
+  }
+  textBufferSetTextFromMem(buffer, memId) {
+    this.opentui.symbols.textBufferSetTextFromMem(buffer, memId);
+  }
+  textBufferAppend(buffer, bytes) {
+    this.opentui.symbols.textBufferAppend(buffer, bytes, bytes.length);
+  }
+  textBufferAppendFromMemId(buffer, memId) {
+    this.opentui.symbols.textBufferAppendFromMemId(buffer, memId);
+  }
+  textBufferLoadFile(buffer, path) {
+    const pathBytes = this.encoder.encode(path);
+    return this.opentui.symbols.textBufferLoadFile(buffer, pathBytes, pathBytes.length);
+  }
+  textBufferSetStyledText(buffer, chunks) {
+    if (chunks.length === 0) {
+      this.textBufferClear(buffer);
+      return;
+    }
+    const chunksBuffer = StyledChunkStruct.packList(chunks);
+    this.opentui.symbols.textBufferSetStyledText(buffer, ptr(chunksBuffer), chunks.length);
+  }
+  textBufferGetLineCount(buffer) {
+    return this.opentui.symbols.textBufferGetLineCount(buffer);
+  }
+  textBufferGetPlainText(buffer, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  getPlainTextBytes(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferGetPlainText(buffer, ptr(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
+    const outBuffer = new Uint8Array(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;
+    }
+    return outBuffer.slice(0, len);
+  }
+  textBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
+    const outBuffer = new Uint8Array(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;
+    }
+    return outBuffer.slice(0, len);
+  }
+  // TextBufferView methods
+  createTextBufferView(textBuffer) {
+    const viewPtr = this.opentui.symbols.createTextBufferView(textBuffer);
+    if (!viewPtr) {
+      throw new Error("Failed to create TextBufferView");
+    }
+    return viewPtr;
+  }
+  destroyTextBufferView(view) {
+    this.opentui.symbols.destroyTextBufferView(view);
+  }
+  textBufferViewSetSelection(view, start, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.textBufferViewSetSelection(view, start, end, bg2, fg2);
+  }
+  textBufferViewResetSelection(view) {
+    this.opentui.symbols.textBufferViewResetSelection(view);
+  }
+  textBufferViewGetSelection(view) {
+    const packedInfo = this.textBufferViewGetSelectionInfo(view);
+    if (packedInfo === 0xffffffffffffffffn) {
+      return null;
+    }
+    const start = Number(packedInfo >> 32n);
+    const end = Number(packedInfo & 0xffffffffn);
+    return { start, end };
+  }
+  textBufferViewGetSelectionInfo(view) {
+    return this.opentui.symbols.textBufferViewGetSelectionInfo(view);
+  }
+  textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  }
+  textBufferViewUpdateSelection(view, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.textBufferViewUpdateSelection(view, end, bg2, fg2);
+  }
+  textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  }
+  textBufferViewResetLocalSelection(view) {
+    this.opentui.symbols.textBufferViewResetLocalSelection(view);
+  }
+  textBufferViewSetWrapWidth(view, width) {
+    this.opentui.symbols.textBufferViewSetWrapWidth(view, width);
+  }
+  textBufferViewSetWrapMode(view, mode) {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
+    this.opentui.symbols.textBufferViewSetWrapMode(view, modeValue);
+  }
+  textBufferViewSetViewportSize(view, width, height) {
+    this.opentui.symbols.textBufferViewSetViewportSize(view, width, height);
+  }
+  textBufferViewSetViewport(view, x2, y2, width, height) {
+    this.opentui.symbols.textBufferViewSetViewport(view, x2, y2, width, height);
+  }
+  textBufferViewGetLineInfo(view) {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size);
+    this.textBufferViewGetLineInfoDirect(view, ptr(outBuffer));
+    const struct = LineInfoStruct.unpack(outBuffer);
+    return {
+      maxLineWidth: struct.maxWidth,
+      lineStarts: struct.starts,
+      lineWidths: struct.widths,
+      lineSources: struct.sources,
+      lineWraps: struct.wraps
+    };
+  }
+  textBufferViewGetLogicalLineInfo(view) {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size);
+    this.textBufferViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
+    const struct = LineInfoStruct.unpack(outBuffer);
+    return {
+      maxLineWidth: struct.maxWidth,
+      lineStarts: struct.starts,
+      lineWidths: struct.widths,
+      lineSources: struct.sources,
+      lineWraps: struct.wraps
+    };
+  }
+  textBufferViewGetVirtualLineCount(view) {
+    return this.opentui.symbols.textBufferViewGetVirtualLineCount(view);
+  }
+  textBufferViewGetLineInfoDirect(view, outPtr) {
+    this.opentui.symbols.textBufferViewGetLineInfoDirect(view, outPtr);
+  }
+  textBufferViewGetLogicalLineInfoDirect(view, outPtr) {
+    this.opentui.symbols.textBufferViewGetLogicalLineInfoDirect(view, outPtr);
+  }
+  textBufferViewGetSelectedText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetSelectedText(view, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  textBufferViewGetPlainText(view, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferViewGetPlainText(view, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  textBufferViewGetSelectedTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferViewGetPlainTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferViewGetPlainText(view, ptr(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferViewSetTabIndicator(view, indicator) {
+    this.opentui.symbols.textBufferViewSetTabIndicator(view, indicator);
+  }
+  textBufferViewSetTabIndicatorColor(view, color) {
+    this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, color.buffer);
+  }
+  textBufferViewSetTruncate(view, truncate) {
+    this.opentui.symbols.textBufferViewSetTruncate(view, truncate);
+  }
+  textBufferViewMeasureForDimensions(view, width, height) {
+    const resultBuffer = new ArrayBuffer(MeasureResultStruct.size);
+    const resultPtr = ptr(new Uint8Array(resultBuffer));
+    const success = this.opentui.symbols.textBufferViewMeasureForDimensions(view, width, height, resultPtr);
+    if (!success) {
+      return null;
+    }
+    const result = MeasureResultStruct.unpack(resultBuffer);
+    return result;
+  }
+  textBufferAddHighlightByCharRange(buffer, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr(packedHighlight));
+  }
+  textBufferAddHighlight(buffer, lineIdx, highlight) {
+    const packedHighlight = HighlightStruct.pack(highlight);
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr(packedHighlight));
+  }
+  textBufferRemoveHighlightsByRef(buffer, hlRef) {
+    this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef);
+  }
+  textBufferClearLineHighlights(buffer, lineIdx) {
+    this.opentui.symbols.textBufferClearLineHighlights(buffer, lineIdx);
+  }
+  textBufferClearAllHighlights(buffer) {
+    this.opentui.symbols.textBufferClearAllHighlights(buffer);
+  }
+  textBufferSetSyntaxStyle(buffer, style) {
+    this.opentui.symbols.textBufferSetSyntaxStyle(buffer, style);
+  }
+  textBufferGetLineHighlights(buffer, lineIdx) {
+    const outCountBuf = new BigUint64Array(1);
+    const nativePtr = this.opentui.symbols.textBufferGetLineHighlightsPtr(buffer, lineIdx, ptr(outCountBuf));
+    if (!nativePtr) return [];
+    const count = Number(outCountBuf[0]);
+    const byteLen = count * HighlightStruct.size;
+    const raw = toArrayBuffer(nativePtr, 0, byteLen);
+    const results = HighlightStruct.unpackList(raw, count);
+    this.opentui.symbols.textBufferFreeLineHighlights(nativePtr, count);
+    return results;
+  }
+  textBufferGetHighlightCount(buffer) {
+    return this.opentui.symbols.textBufferGetHighlightCount(buffer);
+  }
+  getArenaAllocatedBytes() {
+    const result = this.opentui.symbols.getArenaAllocatedBytes();
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  getBuildOptions() {
+    const optionsBuffer = new ArrayBuffer(BuildOptionsStruct.size);
+    this.opentui.symbols.getBuildOptions(ptr(optionsBuffer));
+    const options = BuildOptionsStruct.unpack(optionsBuffer);
+    return {
+      gpaSafeStats: !!options.gpaSafeStats,
+      gpaMemoryLimitTracking: !!options.gpaMemoryLimitTracking
+    };
+  }
+  getAllocatorStats() {
+    const statsBuffer = new ArrayBuffer(AllocatorStatsStruct.size);
+    this.opentui.symbols.getAllocatorStats(ptr(statsBuffer));
+    const stats = AllocatorStatsStruct.unpack(statsBuffer);
+    return {
+      totalRequestedBytes: toNumber(stats.totalRequestedBytes),
+      activeAllocations: toNumber(stats.activeAllocations),
+      smallAllocations: toNumber(stats.smallAllocations),
+      largeAllocations: toNumber(stats.largeAllocations),
+      requestedBytesValid: !!stats.requestedBytesValid
+    };
+  }
+  bufferDrawTextBufferView(buffer, view, x2, y2) {
+    this.opentui.symbols.bufferDrawTextBufferView(buffer, view, x2, y2);
+  }
+  bufferDrawEditorView(buffer, view, x2, y2) {
+    this.opentui.symbols.bufferDrawEditorView(buffer, view, x2, y2);
+  }
+  // EditorView methods
+  createEditorView(editBufferPtr, viewportWidth, viewportHeight) {
+    const viewPtr = this.opentui.symbols.createEditorView(editBufferPtr, viewportWidth, viewportHeight);
+    if (!viewPtr) {
+      throw new Error("Failed to create EditorView");
+    }
+    return viewPtr;
+  }
+  destroyEditorView(view) {
+    this.opentui.symbols.destroyEditorView(view);
+  }
+  editorViewSetViewportSize(view, width, height) {
+    this.opentui.symbols.editorViewSetViewportSize(view, width, height);
+  }
+  editorViewSetViewport(view, x2, y2, width, height, moveCursor) {
+    this.opentui.symbols.editorViewSetViewport(view, x2, y2, width, height, moveCursor);
+  }
+  editorViewGetViewport(view) {
+    const x2 = new Uint32Array(1);
+    const y2 = new Uint32Array(1);
+    const width = new Uint32Array(1);
+    const height = new Uint32Array(1);
+    this.opentui.symbols.editorViewGetViewport(view, ptr(x2), ptr(y2), ptr(width), ptr(height));
+    return {
+      offsetX: x2[0],
+      offsetY: y2[0],
+      width: width[0],
+      height: height[0]
+    };
+  }
+  editorViewSetScrollMargin(view, margin) {
+    this.opentui.symbols.editorViewSetScrollMargin(view, margin);
+  }
+  editorViewSetWrapMode(view, mode) {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2;
+    this.opentui.symbols.editorViewSetWrapMode(view, modeValue);
+  }
+  editorViewGetVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetVirtualLineCount(view);
+  }
+  editorViewGetTotalVirtualLineCount(view) {
+    return this.opentui.symbols.editorViewGetTotalVirtualLineCount(view);
+  }
+  editorViewGetTextBufferView(view) {
+    const result = this.opentui.symbols.editorViewGetTextBufferView(view);
+    if (!result) {
+      throw new Error("Failed to get TextBufferView from EditorView");
+    }
+    return result;
+  }
+  editorViewGetLineInfo(view) {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size);
+    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr(outBuffer));
+    const struct = LineInfoStruct.unpack(outBuffer);
+    return {
+      maxLineWidth: struct.maxWidth,
+      lineStarts: struct.starts,
+      lineWidths: struct.widths,
+      lineSources: struct.sources,
+      lineWraps: struct.wraps
+    };
+  }
+  editorViewGetLogicalLineInfo(view) {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size);
+    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr(outBuffer));
+    const struct = LineInfoStruct.unpack(outBuffer);
+    return {
+      maxLineWidth: struct.maxWidth,
+      lineStarts: struct.starts,
+      lineWidths: struct.widths,
+      lineSources: struct.sources,
+      lineWraps: struct.wraps
+    };
+  }
+  // EditBuffer implementations
+  createEditBuffer(widthMethod) {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1;
+    const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode);
+    if (!bufferPtr) {
+      throw new Error("Failed to create EditBuffer");
+    }
+    return bufferPtr;
+  }
+  destroyEditBuffer(buffer) {
+    this.opentui.symbols.destroyEditBuffer(buffer);
+  }
+  editBufferSetText(buffer, textBytes) {
+    this.opentui.symbols.editBufferSetText(buffer, textBytes, textBytes.length);
+  }
+  editBufferSetTextFromMem(buffer, memId) {
+    this.opentui.symbols.editBufferSetTextFromMem(buffer, memId);
+  }
+  editBufferReplaceText(buffer, textBytes) {
+    this.opentui.symbols.editBufferReplaceText(buffer, textBytes, textBytes.length);
+  }
+  editBufferReplaceTextFromMem(buffer, memId) {
+    this.opentui.symbols.editBufferReplaceTextFromMem(buffer, memId);
+  }
+  editBufferGetText(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferGetText(buffer, ptr(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferInsertChar(buffer, char) {
+    const charBytes = this.encoder.encode(char);
+    this.opentui.symbols.editBufferInsertChar(buffer, charBytes, charBytes.length);
+  }
+  editBufferInsertText(buffer, text) {
+    const textBytes = this.encoder.encode(text);
+    this.opentui.symbols.editBufferInsertText(buffer, textBytes, textBytes.length);
+  }
+  editBufferDeleteChar(buffer) {
+    this.opentui.symbols.editBufferDeleteChar(buffer);
+  }
+  editBufferDeleteCharBackward(buffer) {
+    this.opentui.symbols.editBufferDeleteCharBackward(buffer);
+  }
+  editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol) {
+    this.opentui.symbols.editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol);
+  }
+  editBufferNewLine(buffer) {
+    this.opentui.symbols.editBufferNewLine(buffer);
+  }
+  editBufferDeleteLine(buffer) {
+    this.opentui.symbols.editBufferDeleteLine(buffer);
+  }
+  editBufferMoveCursorLeft(buffer) {
+    this.opentui.symbols.editBufferMoveCursorLeft(buffer);
+  }
+  editBufferMoveCursorRight(buffer) {
+    this.opentui.symbols.editBufferMoveCursorRight(buffer);
+  }
+  editBufferMoveCursorUp(buffer) {
+    this.opentui.symbols.editBufferMoveCursorUp(buffer);
+  }
+  editBufferMoveCursorDown(buffer) {
+    this.opentui.symbols.editBufferMoveCursorDown(buffer);
+  }
+  editBufferGotoLine(buffer, line) {
+    this.opentui.symbols.editBufferGotoLine(buffer, line);
+  }
+  editBufferSetCursor(buffer, line, byteOffset) {
+    this.opentui.symbols.editBufferSetCursor(buffer, line, byteOffset);
+  }
+  editBufferSetCursorToLineCol(buffer, line, col) {
+    this.opentui.symbols.editBufferSetCursorToLineCol(buffer, line, col);
+  }
+  editBufferSetCursorByOffset(buffer, offset) {
+    this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset);
+  }
+  editBufferGetCursorPosition(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetId(buffer) {
+    return this.opentui.symbols.editBufferGetId(buffer);
+  }
+  editBufferGetTextBuffer(buffer) {
+    const result = this.opentui.symbols.editBufferGetTextBuffer(buffer);
+    if (!result) {
+      throw new Error("Failed to get TextBuffer from EditBuffer");
+    }
+    return result;
+  }
+  editBufferDebugLogRope(buffer) {
+    this.opentui.symbols.editBufferDebugLogRope(buffer);
+  }
+  editBufferUndo(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferUndo(buffer, ptr(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferRedo(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editBufferRedo(buffer, ptr(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) return null;
+    return outBuffer.slice(0, len);
+  }
+  editBufferCanUndo(buffer) {
+    return this.opentui.symbols.editBufferCanUndo(buffer);
+  }
+  editBufferCanRedo(buffer) {
+    return this.opentui.symbols.editBufferCanRedo(buffer);
+  }
+  editBufferClearHistory(buffer) {
+    this.opentui.symbols.editBufferClearHistory(buffer);
+  }
+  editBufferClear(buffer) {
+    this.opentui.symbols.editBufferClear(buffer);
+  }
+  editBufferGetNextWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetPrevWordBoundary(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr(cursorBuffer));
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferGetEOL(buffer) {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
+    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, ptr(cursorBuffer));
+    if (!success) return null;
+    return LogicalCursorStruct.unpack(cursorBuffer);
+  }
+  editBufferPositionToOffset(buffer, row, col) {
+    return this.opentui.symbols.editBufferPositionToOffset(buffer, row, col);
+  }
+  editBufferGetLineStartOffset(buffer, row) {
+    return this.opentui.symbols.editBufferGetLineStartOffset(buffer, row);
+  }
+  editBufferGetTextRange(buffer, startOffset, endOffset, maxLength) {
+    const outBuffer = new Uint8Array(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;
+    return outBuffer.slice(0, len);
+  }
+  editBufferGetTextRangeByCoords(buffer, startRow, startCol, endRow, endCol, maxLength) {
+    const outBuffer = new Uint8Array(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;
+    return outBuffer.slice(0, len);
+  }
+  // EditorView selection and editing implementations
+  editorViewSetSelection(view, start, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.editorViewSetSelection(view, start, end, bg2, fg2);
+  }
+  editorViewResetSelection(view) {
+    this.opentui.symbols.editorViewResetSelection(view);
+  }
+  editorViewGetSelection(view) {
+    const packedInfo = this.opentui.symbols.editorViewGetSelection(view);
+    if (packedInfo === 0xffffffffffffffffn) {
+      return null;
+    }
+    const start = Number(packedInfo >> 32n);
+    const end = Number(packedInfo & 0xffffffffn);
+    return { start, end };
+  }
+  editorViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.editorViewSetLocalSelection(
+      view,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bg2,
+      fg2,
+      updateCursor,
+      followCursor
+    );
+  }
+  editorViewUpdateSelection(view, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.editorViewUpdateSelection(view, end, bg2, fg2);
+  }
+  editorViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bgColor, fgColor, updateCursor, followCursor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.editorViewUpdateLocalSelection(
+      view,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bg2,
+      fg2,
+      updateCursor,
+      followCursor
+    );
+  }
+  editorViewResetLocalSelection(view) {
+    this.opentui.symbols.editorViewResetLocalSelection(view);
+  }
+  editorViewGetSelectedTextBytes(view, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.opentui.symbols.editorViewGetSelectedTextBytes(view, ptr(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) return null;
+    return outBuffer.slice(0, len);
+  }
+  editorViewGetCursor(view) {
+    const row = new Uint32Array(1);
+    const col = new Uint32Array(1);
+    this.opentui.symbols.editorViewGetCursor(view, 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, ptr(outBuffer), maxLength);
+    const len = typeof actualLen === "bigint" ? Number(actualLen) : actualLen;
+    if (len === 0) return null;
+    return outBuffer.slice(0, len);
+  }
+  editorViewGetVisualCursor(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewMoveUpVisual(view) {
+    this.opentui.symbols.editorViewMoveUpVisual(view);
+  }
+  editorViewMoveDownVisual(view) {
+    this.opentui.symbols.editorViewMoveDownVisual(view);
+  }
+  editorViewDeleteSelectedText(view) {
+    this.opentui.symbols.editorViewDeleteSelectedText(view);
+  }
+  editorViewSetCursorByOffset(view, offset) {
+    this.opentui.symbols.editorViewSetCursorByOffset(view, offset);
+  }
+  editorViewGetNextWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetPrevWordBoundary(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetEOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetEOL(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetVisualSOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualSOL(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetVisualEOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualEOL(view, ptr(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  bufferPushScissorRect(buffer, x2, y2, width, height) {
+    this.opentui.symbols.bufferPushScissorRect(buffer, x2, y2, width, height);
+  }
+  bufferPopScissorRect(buffer) {
+    this.opentui.symbols.bufferPopScissorRect(buffer);
+  }
+  bufferClearScissorRects(buffer) {
+    this.opentui.symbols.bufferClearScissorRects(buffer);
+  }
+  bufferPushOpacity(buffer, opacity) {
+    this.opentui.symbols.bufferPushOpacity(buffer, opacity);
+  }
+  bufferPopOpacity(buffer) {
+    this.opentui.symbols.bufferPopOpacity(buffer);
+  }
+  bufferGetCurrentOpacity(buffer) {
+    return this.opentui.symbols.bufferGetCurrentOpacity(buffer);
+  }
+  bufferClearOpacity(buffer) {
+    this.opentui.symbols.bufferClearOpacity(buffer);
+  }
+  getTerminalCapabilities(renderer) {
+    const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
+    this.opentui.symbols.getTerminalCapabilities(renderer, ptr(capsBuffer));
+    const caps = TerminalCapabilitiesStruct.unpack(capsBuffer);
+    return {
+      kitty_keyboard: caps.kitty_keyboard,
+      kitty_graphics: caps.kitty_graphics,
+      rgb: caps.rgb,
+      unicode: caps.unicode,
+      sgr_pixels: caps.sgr_pixels,
+      color_scheme_updates: caps.color_scheme_updates,
+      explicit_width: caps.explicit_width,
+      scaled_text: caps.scaled_text,
+      sixel: caps.sixel,
+      focus_tracking: caps.focus_tracking,
+      sync: caps.sync,
+      bracketed_paste: caps.bracketed_paste,
+      hyperlinks: caps.hyperlinks,
+      osc52: caps.osc52,
+      explicit_cursor_positioning: caps.explicit_cursor_positioning,
+      terminal: {
+        name: caps.term_name ?? "",
+        version: caps.term_version ?? "",
+        from_xtversion: caps.term_from_xtversion
+      }
+    };
+  }
+  processCapabilityResponse(renderer, response) {
+    const responseBytes = this.encoder.encode(response);
+    this.opentui.symbols.processCapabilityResponse(renderer, responseBytes, responseBytes.length);
+  }
+  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(
+      textBytes,
+      textBytes.length,
+      ptr(outPtrBuffer),
+      ptr(outLenBuffer),
+      widthMethodCode
+    );
+    if (!success) {
+      return null;
+    }
+    const outPtrView = new BigUint64Array(outPtrBuffer);
+    const outLenView = new BigUint64Array(outLenBuffer);
+    const resultPtr = Number(outPtrView[0]);
+    const resultLen = Number(outLenView[0]);
+    if (resultLen === 0) {
+      return { ptr: resultPtr, data: [] };
+    }
+    const byteLen = resultLen * EncodedCharStruct.size;
+    const raw = toArrayBuffer(resultPtr, 0, byteLen);
+    const data = EncodedCharStruct.unpackList(raw, resultLen);
+    return { ptr: resultPtr, data };
+  }
+  freeUnicode(encoded) {
+    this.opentui.symbols.freeUnicode(encoded.ptr, encoded.data.length);
+  }
+  bufferDrawChar(buffer, char, x2, y2, fg2, bg2, attributes = 0) {
+    this.opentui.symbols.bufferDrawChar(buffer, char, x2, y2, fg2.buffer, bg2.buffer, attributes);
+  }
+  registerNativeSpanFeedStream(stream, handler) {
+    const callback = this.ensureNativeSpanFeedCallback();
+    this.nativeSpanFeedHandlers.set(toPointer(stream), handler);
+    this.opentui.symbols.streamSetCallback(stream, callback.ptr);
+  }
+  unregisterNativeSpanFeedStream(stream) {
+    this.opentui.symbols.streamSetCallback(stream, null);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  createNativeSpanFeed(options) {
+    const optionsBuffer = options == null ? null : NativeSpanFeedOptionsStruct.pack(options);
+    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr(optionsBuffer) : null);
+    if (!streamPtr) {
+      throw new Error("Failed to create stream");
+    }
+    return toPointer(streamPtr);
+  }
+  attachNativeSpanFeed(stream) {
+    return this.opentui.symbols.attachNativeSpanFeed(stream);
+  }
+  destroyNativeSpanFeed(stream) {
+    this.opentui.symbols.destroyNativeSpanFeed(stream);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  streamWrite(stream, data) {
+    const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
+    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, ptr(outBuffer), maxSpans);
+    return toNumber(count);
+  }
+  streamClose(stream) {
+    return this.opentui.symbols.streamClose(stream);
+  }
+  streamSetOptions(stream, options) {
+    const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options);
+    return this.opentui.symbols.streamSetOptions(stream, ptr(optionsBuffer));
+  }
+  streamGetStats(stream) {
+    const statsBuffer = new ArrayBuffer(NativeSpanFeedStatsStruct.size);
+    const status = this.opentui.symbols.streamGetStats(stream, ptr(statsBuffer));
+    if (status !== 0) {
+      return null;
+    }
+    const stats = NativeSpanFeedStatsStruct.unpack(statsBuffer);
+    return {
+      bytesWritten: typeof stats.bytesWritten === "bigint" ? stats.bytesWritten : BigInt(stats.bytesWritten),
+      spansCommitted: typeof stats.spansCommitted === "bigint" ? stats.spansCommitted : BigInt(stats.spansCommitted),
+      chunks: stats.chunks,
+      pendingSpans: stats.pendingSpans
+    };
+  }
+  streamReserve(stream, minLen) {
+    const reserveBuffer = new ArrayBuffer(ReserveInfoStruct.size);
+    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr(reserveBuffer));
+    if (status !== 0) {
+      return { status, info: null };
+    }
+    return { status, info: ReserveInfoStruct.unpack(reserveBuffer) };
+  }
+  streamCommitReserved(stream, length) {
+    return this.opentui.symbols.streamCommitReserved(stream, length);
+  }
+  createSyntaxStyle() {
+    const stylePtr = this.opentui.symbols.createSyntaxStyle();
+    if (!stylePtr) {
+      throw new Error("Failed to create SyntaxStyle");
+    }
+    return stylePtr;
+  }
+  destroySyntaxStyle(style) {
+    this.opentui.symbols.destroySyntaxStyle(style);
+  }
+  syntaxStyleRegister(style, name, fg2, bg2, attributes) {
+    const nameBytes = this.encoder.encode(name);
+    const fgPtr = fg2 ? fg2.buffer : null;
+    const bgPtr = bg2 ? bg2.buffer : null;
+    return this.opentui.symbols.syntaxStyleRegister(style, nameBytes, nameBytes.length, fgPtr, bgPtr, attributes);
+  }
+  syntaxStyleResolveByName(style, name) {
+    const nameBytes = this.encoder.encode(name);
+    const id = this.opentui.symbols.syntaxStyleResolveByName(style, nameBytes, nameBytes.length);
+    return id === 0 ? null : id;
+  }
+  syntaxStyleGetStyleCount(style) {
+    const result = this.opentui.symbols.syntaxStyleGetStyleCount(style);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  editorViewSetPlaceholderStyledText(view, chunks) {
+    const nonEmptyChunks = chunks.filter((c) => c.text.length > 0);
+    if (nonEmptyChunks.length === 0) {
+      this.opentui.symbols.editorViewSetPlaceholderStyledText(view, null, 0);
+      return;
+    }
+    const chunksBuffer = StyledChunkStruct.packList(nonEmptyChunks);
+    this.opentui.symbols.editorViewSetPlaceholderStyledText(view, ptr(chunksBuffer), nonEmptyChunks.length);
+  }
+  editorViewSetTabIndicator(view, indicator) {
+    this.opentui.symbols.editorViewSetTabIndicator(view, indicator);
+  }
+  editorViewSetTabIndicatorColor(view, color) {
+    this.opentui.symbols.editorViewSetTabIndicatorColor(view, color.buffer);
+  }
+  onNativeEvent(name, handler) {
+    this._nativeEvents.on(name, handler);
+  }
+  onceNativeEvent(name, handler) {
+    this._nativeEvents.once(name, handler);
+  }
+  offNativeEvent(name, handler) {
+    this._nativeEvents.off(name, handler);
+  }
+  onAnyNativeEvent(handler) {
+    this._anyEventHandlers.push(handler);
+  }
+};
+var opentuiLibPath;
+try {
+  registerRenderLib(new FFIRenderLib(opentuiLibPath));
+} catch (error) {
+}
+
 // ../../opentui/packages/react/src/reconciler/renderer.ts
 import React3 from "react";