@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/zig.ts

@@ -0,0 +1,3884 @@
+import { dlopen, toArrayBuffer, JSCallback, ptr, type Pointer } from "bun:ffi"
+import { existsSync, writeFileSync } from "fs"
+import { EventEmitter } from "events"
+import {
+  type CursorStyle,
+  type CursorStyleOptions,
+  type TargetChannel,
+  type DebugOverlayCorner,
+  type WidthMethod,
+  type Highlight,
+  type LineInfo,
+  type MousePointerStyle,
+} from "./types.js"
+export type { LineInfo, AllocatorStats, BuildOptions }
+
+import { RGBA } from "./lib/RGBA.js"
+import { OptimizedBuffer } from "./buffer.js"
+import { TextBuffer } from "./text-buffer.js"
+import { env, registerEnvVar } from "./lib/env.js"
+import {
+  StyledChunkStruct,
+  HighlightStruct,
+  LogicalCursorStruct,
+  VisualCursorStruct,
+  TerminalCapabilitiesStruct,
+  EncodedCharStruct,
+  LineInfoStruct,
+  MeasureResultStruct,
+  CursorStateStruct,
+  CursorStyleOptionsStruct,
+  GridDrawOptionsStruct,
+  NativeSpanFeedOptionsStruct,
+  NativeSpanFeedStatsStruct,
+  ReserveInfoStruct,
+  BuildOptionsStruct,
+  AllocatorStatsStruct,
+} from "./zig-structs.js"
+import type {
+  NativeSpanFeedOptions,
+  NativeSpanFeedStats,
+  ReserveInfo,
+  BuildOptions,
+  AllocatorStats,
+} from "./zig-structs.js"
+import { isBunfsPath } from "./lib/bunfs.js"
+
+const module = await import(`@fairyhunter13/opentui-core-${process.platform}-${process.arch}/index.ts`)
+let 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,
+})
+
+// Env vars used in terminal.zig
+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,
+})
+
+// Cursor & mouse pointer style mappings (avoid recreation on each call)
+const CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2, default: 3 } as const
+const CURSOR_ID_TO_STYLE = ["block", "line", "underline", "default"] as const
+const MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4, "not-allowed": 5 } as const
+
+// Global singleton state for FFI tracing to prevent duplicate exit handlers
+let globalTraceSymbols: Record<string, number[]> | null = null
+let globalFFILogPath: string | null = null
+let exitHandlerRegistered = false
+
+function toPointer(value: number | bigint): Pointer {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range")
+    }
+    return Number(value) as Pointer
+  }
+  return value as Pointer
+}
+
+function toNumber(value: number | bigint): number {
+  return typeof value === "bigint" ? Number(value) : value
+}
+
+function getOpenTUILib(libPath?: string) {
+  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",
+    },
+    bufferColorMatrix: {
+      args: ["ptr", "ptr", "ptr", "usize", "f32", "u8"],
+      returns: "void",
+    },
+    bufferColorMatrixUniform: {
+      args: ["ptr", "ptr", "f32", "u8"],
+      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", "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<T extends Record<string, any>>(symbols: T): T {
+  // Initialize global state on first call
+  if (!globalTraceSymbols) {
+    globalTraceSymbols = {}
+  }
+
+  // Initialize global debug log path on first call
+  if (env.OTUI_DEBUG_FFI && !globalFFILogPath) {
+    const now = new Date()
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0]
+    globalFFILogPath = `ffi_otui_debug_${timestamp}.log`
+  }
+
+  const debugSymbols: Record<string, any> = {}
+  let hasTracing = false
+
+  Object.entries(symbols).forEach(([key, value]) => {
+    debugSymbols[key] = value
+  })
+
+  if (env.OTUI_DEBUG_FFI && globalFFILogPath) {
+    const logPath = globalFFILogPath
+    const writeSync = (msg: string) => {
+      writeFileSync(logPath, msg + "\n", { flag: "a" })
+    }
+
+    Object.entries(symbols).forEach(([key, value]) => {
+      if (typeof value === "function") {
+        debugSymbols[key] = (...args: any[]) => {
+          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") {
+        // Initialize trace array for this symbol if not exists
+        if (!globalTraceSymbols![key]) {
+          globalTraceSymbols![key] = []
+        }
+
+        const originalFunc = debugSymbols[key]
+        debugSymbols[key] = (...args: any[]) => {
+          const start = performance.now()
+          const result = originalFunc(...args)
+          const end = performance.now()
+          globalTraceSymbols![key].push(end - start)
+          return result
+        }
+      }
+    })
+  }
+
+  // Register exit handler only once
+  if ((env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) && !exitHandlerRegistered) {
+    exitHandlerRegistered = true
+
+    process.on("exit", () => {
+      if (globalTraceSymbols) {
+        const allStats: Array<{
+          name: string
+          count: number
+          total: number
+          average: number
+          min: number
+          max: number
+          median: number
+          p90: number
+          p99: number
+        }> = []
+
+        for (const [key, timings] of Object.entries(globalTraceSymbols)) {
+          if (!Array.isArray(timings) || timings.length === 0) {
+            continue
+          }
+
+          const sortedTimings = [...timings].sort((a, b) => a - b)
+          const count = sortedTimings.length
+
+          const total = sortedTimings.reduce((acc, t) => acc + t, 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, b) => b.total - a.total)
+
+        const lines: string[] = []
+        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 statWidthMin = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length))
+          const statWidthMax = 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(statWidthMin)} | ` +
+              `${maxHeader.padStart(statWidthMax)} | ` +
+              `${medHeader.padStart(medianWidth)} | ` +
+              `${p90Header.padStart(p90Width)} | ` +
+              `${p99Header.padStart(p99Width)}`,
+          )
+          lines.push(
+            `${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(statWidthMin)}-+-${"-".repeat(statWidthMax)}-+-${"-".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(statWidthMin)} | ` +
+                `${stat.max.toFixed(2).padStart(statWidthMax)} | ` +
+                `${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 = 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 as T
+}
+
+// Log levels matching Zig's LogLevel enum
+export enum LogLevel {
+  Error = 0,
+  Warn = 1,
+  Info = 2,
+  Debug = 3,
+}
+
+/**
+ * VisualCursor represents a cursor position with both visual and logical coordinates.
+ * Visual coordinates (visualRow, visualCol) are VIEWPORT-RELATIVE.
+ * This means visualRow=0 is the first visible line in the viewport, not the first line in the document.
+ * Logical coordinates (logicalRow, logicalCol) are document-absolute.
+ */
+export interface VisualCursor {
+  visualRow: number // Viewport-relative row (0 = top of viewport)
+  visualCol: number // Viewport-relative column (0 = left edge of viewport when not wrapping)
+  logicalRow: number // Document-absolute row
+  logicalCol: number // Document-absolute column
+  offset: number // Global display-width offset from buffer start
+}
+
+export interface LogicalCursor {
+  row: number
+  col: number
+  offset: number
+}
+
+export interface CursorState {
+  x: number
+  y: number
+  visible: boolean
+  style: CursorStyle
+  blinking: boolean
+  color: RGBA
+}
+
+export type NativeSpanFeedEventHandler = (eventId: number, arg0: Pointer, arg1: number | bigint) => void
+
+export interface RenderLib {
+  createRenderer: (width: number, height: number, options?: { testing?: boolean; remote?: boolean }) => Pointer | null
+  setTerminalEnvVar: (renderer: Pointer, key: string, value: string) => boolean
+  destroyRenderer: (renderer: Pointer) => void
+  setUseThread: (renderer: Pointer, useThread: boolean) => void
+  setBackgroundColor: (renderer: Pointer, color: RGBA) => void
+  setRenderOffset: (renderer: Pointer, offset: number) => void
+  updateStats: (renderer: Pointer, time: number, fps: number, frameCallbackTime: number) => void
+  updateMemoryStats: (renderer: Pointer, heapUsed: number, heapTotal: number, arrayBuffers: number) => void
+  render: (renderer: Pointer, force: boolean) => void
+  getNextBuffer: (renderer: Pointer) => OptimizedBuffer
+  getCurrentBuffer: (renderer: Pointer) => OptimizedBuffer
+  createOptimizedBuffer: (
+    width: number,
+    height: number,
+    widthMethod: WidthMethod,
+    respectAlpha?: boolean,
+    id?: string,
+  ) => OptimizedBuffer
+  destroyOptimizedBuffer: (bufferPtr: Pointer) => void
+  drawFrameBuffer: (
+    targetBufferPtr: Pointer,
+    destX: number,
+    destY: number,
+    bufferPtr: Pointer,
+    sourceX?: number,
+    sourceY?: number,
+    sourceWidth?: number,
+    sourceHeight?: number,
+  ) => void
+  getBufferWidth: (buffer: Pointer) => number
+  getBufferHeight: (buffer: Pointer) => number
+  bufferClear: (buffer: Pointer, color: RGBA) => void
+  bufferGetCharPtr: (buffer: Pointer) => Pointer
+  bufferGetFgPtr: (buffer: Pointer) => Pointer
+  bufferGetBgPtr: (buffer: Pointer) => Pointer
+  bufferGetAttributesPtr: (buffer: Pointer) => Pointer
+  bufferGetRespectAlpha: (buffer: Pointer) => boolean
+  bufferSetRespectAlpha: (buffer: Pointer, respectAlpha: boolean) => void
+  bufferGetId: (buffer: Pointer) => string
+  bufferGetRealCharSize: (buffer: Pointer) => number
+  bufferWriteResolvedChars: (buffer: Pointer, outputBuffer: Uint8Array, addLineBreaks: boolean) => number
+  bufferDrawText: (
+    buffer: Pointer,
+    text: string,
+    x: number,
+    y: number,
+    color: RGBA,
+    bgColor?: RGBA,
+    attributes?: number,
+  ) => void
+  bufferSetCellWithAlphaBlending: (
+    buffer: Pointer,
+    x: number,
+    y: number,
+    char: string,
+    color: RGBA,
+    bgColor: RGBA,
+    attributes?: number,
+  ) => void
+  bufferSetCell: (
+    buffer: Pointer,
+    x: number,
+    y: number,
+    char: string,
+    color: RGBA,
+    bgColor: RGBA,
+    attributes?: number,
+  ) => void
+  bufferFillRect: (buffer: Pointer, x: number, y: number, width: number, height: number, color: RGBA) => void
+  bufferColorMatrix: (
+    buffer: Pointer,
+    matrixPtr: Pointer,
+    cellMaskPtr: Pointer,
+    cellMaskCount: number,
+    strength: number,
+    target: TargetChannel,
+  ) => void
+  bufferColorMatrixUniform: (buffer: Pointer, matrixPtr: Pointer, strength: number, target: TargetChannel) => void
+  bufferDrawSuperSampleBuffer: (
+    buffer: Pointer,
+    x: number,
+    y: number,
+    pixelDataPtr: Pointer,
+    pixelDataLength: number,
+    format: "bgra8unorm" | "rgba8unorm",
+    alignedBytesPerRow: number,
+  ) => void
+  bufferDrawPackedBuffer: (
+    buffer: Pointer,
+    dataPtr: Pointer,
+    dataLen: number,
+    posX: number,
+    posY: number,
+    terminalWidthCells: number,
+    terminalHeightCells: number,
+  ) => void
+  bufferDrawGrayscaleBuffer: (
+    buffer: Pointer,
+    posX: number,
+    posY: number,
+    intensitiesPtr: Pointer,
+    srcWidth: number,
+    srcHeight: number,
+    fg: RGBA | null,
+    bg: RGBA | null,
+  ) => void
+  bufferDrawGrayscaleBufferSupersampled: (
+    buffer: Pointer,
+    posX: number,
+    posY: number,
+    intensitiesPtr: Pointer,
+    srcWidth: number,
+    srcHeight: number,
+    fg: RGBA | null,
+    bg: RGBA | null,
+  ) => void
+  bufferDrawGrid: (
+    buffer: Pointer,
+    borderChars: Uint32Array,
+    borderFg: RGBA,
+    borderBg: RGBA,
+    columnOffsets: Int32Array,
+    columnCount: number,
+    rowOffsets: Int32Array,
+    rowCount: number,
+    options: { drawInner: boolean; drawOuter: boolean },
+  ) => void
+  bufferDrawBox: (
+    buffer: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    borderChars: Uint32Array,
+    packedOptions: number,
+    borderColor: RGBA,
+    backgroundColor: RGBA,
+    title: string | null,
+    bottomTitle: string | null,
+  ) => void
+  bufferResize: (buffer: Pointer, width: number, height: number) => void
+  resizeRenderer: (renderer: Pointer, width: number, height: number) => void
+  setCursorPosition: (renderer: Pointer, x: number, y: number, visible: boolean) => void
+  setCursorColor: (renderer: Pointer, color: RGBA) => void
+  getCursorState: (renderer: Pointer) => CursorState
+  setCursorStyleOptions: (renderer: Pointer, options: CursorStyleOptions) => void
+  setDebugOverlay: (renderer: Pointer, enabled: boolean, corner: DebugOverlayCorner) => void
+  clearTerminal: (renderer: Pointer) => void
+  setTerminalTitle: (renderer: Pointer, title: string) => void
+  copyToClipboardOSC52: (renderer: Pointer, target: number, payload: Uint8Array) => boolean
+  clearClipboardOSC52: (renderer: Pointer, target: number) => boolean
+  addToHitGrid: (renderer: Pointer, x: number, y: number, width: number, height: number, id: number) => void
+  clearCurrentHitGrid: (renderer: Pointer) => void
+  hitGridPushScissorRect: (renderer: Pointer, x: number, y: number, width: number, height: number) => void
+  hitGridPopScissorRect: (renderer: Pointer) => void
+  hitGridClearScissorRects: (renderer: Pointer) => void
+  addToCurrentHitGridClipped: (
+    renderer: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    id: number,
+  ) => void
+  checkHit: (renderer: Pointer, x: number, y: number) => number
+  getHitGridDirty: (renderer: Pointer) => boolean
+  dumpHitGrid: (renderer: Pointer) => void
+  dumpBuffers: (renderer: Pointer, timestamp?: number) => void
+  dumpStdoutBuffer: (renderer: Pointer, timestamp?: number) => void
+  restoreTerminalModes: (renderer: Pointer) => void
+  enableMouse: (renderer: Pointer, enableMovement: boolean) => void
+  disableMouse: (renderer: Pointer) => void
+  enableKittyKeyboard: (renderer: Pointer, flags: number) => void
+  disableKittyKeyboard: (renderer: Pointer) => void
+  setKittyKeyboardFlags: (renderer: Pointer, flags: number) => void
+  getKittyKeyboardFlags: (renderer: Pointer) => number
+  setupTerminal: (renderer: Pointer, useAlternateScreen: boolean) => void
+  suspendRenderer: (renderer: Pointer) => void
+  resumeRenderer: (renderer: Pointer) => void
+  queryPixelResolution: (renderer: Pointer) => void
+  writeOut: (renderer: Pointer, data: string | Uint8Array) => void
+
+  // TextBuffer methods
+  createTextBuffer: (widthMethod: WidthMethod) => TextBuffer
+  destroyTextBuffer: (buffer: Pointer) => void
+  textBufferGetLength: (buffer: Pointer) => number
+  textBufferGetByteSize: (buffer: Pointer) => number
+
+  textBufferReset: (buffer: Pointer) => void
+  textBufferClear: (buffer: Pointer) => void
+  textBufferRegisterMemBuffer: (buffer: Pointer, bytes: Uint8Array, owned?: boolean) => number
+  textBufferReplaceMemBuffer: (buffer: Pointer, memId: number, bytes: Uint8Array, owned?: boolean) => boolean
+  textBufferClearMemRegistry: (buffer: Pointer) => void
+  textBufferSetTextFromMem: (buffer: Pointer, memId: number) => void
+  textBufferAppend: (buffer: Pointer, bytes: Uint8Array) => void
+  textBufferAppendFromMemId: (buffer: Pointer, memId: number) => void
+  textBufferLoadFile: (buffer: Pointer, path: string) => boolean
+  textBufferSetStyledText: (
+    buffer: Pointer,
+    chunks: Array<{ text: string; fg?: RGBA | null; bg?: RGBA | null; attributes?: number; link?: { url: string } }>,
+  ) => void
+  textBufferSetDefaultFg: (buffer: Pointer, fg: RGBA | null) => void
+  textBufferSetDefaultBg: (buffer: Pointer, bg: RGBA | null) => void
+  textBufferSetDefaultAttributes: (buffer: Pointer, attributes: number | null) => void
+  textBufferResetDefaults: (buffer: Pointer) => void
+  textBufferGetTabWidth: (buffer: Pointer) => number
+  textBufferSetTabWidth: (buffer: Pointer, width: number) => void
+  textBufferGetLineCount: (buffer: Pointer) => number
+  getPlainTextBytes: (buffer: Pointer, maxLength: number) => Uint8Array | null
+  textBufferGetTextRange: (
+    buffer: Pointer,
+    startOffset: number,
+    endOffset: number,
+    maxLength: number,
+  ) => Uint8Array | null
+  textBufferGetTextRangeByCoords: (
+    buffer: Pointer,
+    startRow: number,
+    startCol: number,
+    endRow: number,
+    endCol: number,
+    maxLength: number,
+  ) => Uint8Array | null
+
+  // TextBufferView methods
+  createTextBufferView: (textBuffer: Pointer) => Pointer
+  destroyTextBufferView: (view: Pointer) => void
+  textBufferViewSetSelection: (
+    view: Pointer,
+    start: number,
+    end: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ) => void
+  textBufferViewResetSelection: (view: Pointer) => void
+  textBufferViewGetSelection: (view: Pointer) => { start: number; end: number } | null
+  textBufferViewSetLocalSelection: (
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ) => boolean
+  textBufferViewUpdateSelection: (view: Pointer, end: number, bgColor: RGBA | null, fgColor: RGBA | null) => void
+  textBufferViewUpdateLocalSelection: (
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ) => boolean
+  textBufferViewResetLocalSelection: (view: Pointer) => void
+  textBufferViewSetWrapWidth: (view: Pointer, width: number) => void
+  textBufferViewSetWrapMode: (view: Pointer, mode: "none" | "char" | "word") => void
+  textBufferViewSetViewportSize: (view: Pointer, width: number, height: number) => void
+  textBufferViewSetViewport: (view: Pointer, x: number, y: number, width: number, height: number) => void
+  textBufferViewGetLineInfo: (view: Pointer) => LineInfo
+  textBufferViewGetLogicalLineInfo: (view: Pointer) => LineInfo
+  textBufferViewGetSelectedTextBytes: (view: Pointer, maxLength: number) => Uint8Array | null
+  textBufferViewGetPlainTextBytes: (view: Pointer, maxLength: number) => Uint8Array | null
+  textBufferViewSetTabIndicator: (view: Pointer, indicator: number) => void
+  textBufferViewSetTabIndicatorColor: (view: Pointer, color: RGBA) => void
+  textBufferViewSetTruncate: (view: Pointer, truncate: boolean) => void
+  textBufferViewMeasureForDimensions: (
+    view: Pointer,
+    width: number,
+    height: number,
+  ) => { lineCount: number; widthColsMax: number } | null
+  textBufferViewGetVirtualLineCount: (view: Pointer) => number
+
+  readonly encoder: TextEncoder
+  readonly decoder: TextDecoder
+  bufferDrawTextBufferView: (buffer: Pointer, view: Pointer, x: number, y: number) => void
+  bufferDrawEditorView: (buffer: Pointer, view: Pointer, x: number, y: number) => void
+
+  // EditBuffer methods
+  createEditBuffer: (widthMethod: WidthMethod) => Pointer
+  destroyEditBuffer: (buffer: Pointer) => void
+  editBufferSetText: (buffer: Pointer, textBytes: Uint8Array) => void
+  editBufferSetTextFromMem: (buffer: Pointer, memId: number) => void
+  editBufferReplaceText: (buffer: Pointer, textBytes: Uint8Array) => void
+  editBufferReplaceTextFromMem: (buffer: Pointer, memId: number) => void
+  editBufferGetText: (buffer: Pointer, maxLength: number) => Uint8Array | null
+  editBufferInsertChar: (buffer: Pointer, char: string) => void
+  editBufferInsertText: (buffer: Pointer, text: string) => void
+  editBufferDeleteChar: (buffer: Pointer) => void
+  editBufferDeleteCharBackward: (buffer: Pointer) => void
+  editBufferDeleteRange: (buffer: Pointer, startLine: number, startCol: number, endLine: number, endCol: number) => void
+  editBufferNewLine: (buffer: Pointer) => void
+  editBufferDeleteLine: (buffer: Pointer) => void
+  editBufferMoveCursorLeft: (buffer: Pointer) => void
+  editBufferMoveCursorRight: (buffer: Pointer) => void
+  editBufferMoveCursorUp: (buffer: Pointer) => void
+  editBufferMoveCursorDown: (buffer: Pointer) => void
+  editBufferGotoLine: (buffer: Pointer, line: number) => void
+  editBufferSetCursor: (buffer: Pointer, line: number, col: number) => void
+  editBufferSetCursorToLineCol: (buffer: Pointer, line: number, col: number) => void
+  editBufferSetCursorByOffset: (buffer: Pointer, offset: number) => void
+  editBufferGetCursorPosition: (buffer: Pointer) => LogicalCursor
+  editBufferGetId: (buffer: Pointer) => number
+  editBufferGetTextBuffer: (buffer: Pointer) => Pointer
+  editBufferDebugLogRope: (buffer: Pointer) => void
+  editBufferUndo: (buffer: Pointer, maxLength: number) => Uint8Array | null
+  editBufferRedo: (buffer: Pointer, maxLength: number) => Uint8Array | null
+  editBufferCanUndo: (buffer: Pointer) => boolean
+  editBufferCanRedo: (buffer: Pointer) => boolean
+  editBufferClearHistory: (buffer: Pointer) => void
+  editBufferClear: (buffer: Pointer) => void
+  editBufferGetNextWordBoundary: (buffer: Pointer) => { row: number; col: number; offset: number }
+  editBufferGetPrevWordBoundary: (buffer: Pointer) => { row: number; col: number; offset: number }
+  editBufferGetEOL: (buffer: Pointer) => { row: number; col: number; offset: number }
+  editBufferOffsetToPosition: (buffer: Pointer, offset: number) => { row: number; col: number; offset: number } | null
+  editBufferPositionToOffset: (buffer: Pointer, row: number, col: number) => number
+  editBufferGetLineStartOffset: (buffer: Pointer, row: number) => number
+  editBufferGetTextRange: (
+    buffer: Pointer,
+    startOffset: number,
+    endOffset: number,
+    maxLength: number,
+  ) => Uint8Array | null
+  editBufferGetTextRangeByCoords: (
+    buffer: Pointer,
+    startRow: number,
+    startCol: number,
+    endRow: number,
+    endCol: number,
+    maxLength: number,
+  ) => Uint8Array | null
+
+  // EditorView methods
+  createEditorView: (editBufferPtr: Pointer, viewportWidth: number, viewportHeight: number) => Pointer
+  destroyEditorView: (view: Pointer) => void
+  editorViewSetViewportSize: (view: Pointer, width: number, height: number) => void
+  editorViewSetViewport: (
+    view: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    moveCursor: boolean,
+  ) => void
+  editorViewGetViewport: (view: Pointer) => { offsetY: number; offsetX: number; height: number; width: number }
+  editorViewSetScrollMargin: (view: Pointer, margin: number) => void
+  editorViewSetWrapMode: (view: Pointer, mode: "none" | "char" | "word") => void
+  editorViewGetVirtualLineCount: (view: Pointer) => number
+  editorViewGetTotalVirtualLineCount: (view: Pointer) => number
+  editorViewGetTextBufferView: (view: Pointer) => Pointer
+  editorViewSetSelection: (
+    view: Pointer,
+    start: number,
+    end: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ) => void
+  editorViewResetSelection: (view: Pointer) => void
+  editorViewGetSelection: (view: Pointer) => { start: number; end: number } | null
+  editorViewSetLocalSelection: (
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+    updateCursor: boolean,
+    followCursor: boolean,
+  ) => boolean
+
+  editorViewUpdateSelection: (view: Pointer, end: number, bgColor: RGBA | null, fgColor: RGBA | null) => void
+  editorViewUpdateLocalSelection: (
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+    updateCursor: boolean,
+    followCursor: boolean,
+  ) => boolean
+
+  editorViewResetLocalSelection: (view: Pointer) => void
+  editorViewGetSelectedTextBytes: (view: Pointer, maxLength: number) => Uint8Array | null
+  editorViewGetCursor: (view: Pointer) => { row: number; col: number }
+  editorViewGetText: (view: Pointer, maxLength: number) => Uint8Array | null
+  editorViewGetVisualCursor: (view: Pointer) => VisualCursor
+  editorViewMoveUpVisual: (view: Pointer) => void
+  editorViewMoveDownVisual: (view: Pointer) => void
+  editorViewDeleteSelectedText: (view: Pointer) => void
+  editorViewSetCursorByOffset: (view: Pointer, offset: number) => void
+  editorViewGetNextWordBoundary: (view: Pointer) => VisualCursor
+  editorViewGetPrevWordBoundary: (view: Pointer) => VisualCursor
+  editorViewGetEOL: (view: Pointer) => VisualCursor
+  editorViewGetVisualSOL: (view: Pointer) => VisualCursor
+  editorViewGetVisualEOL: (view: Pointer) => VisualCursor
+  editorViewGetLineInfo: (view: Pointer) => LineInfo
+  editorViewGetLogicalLineInfo: (view: Pointer) => LineInfo
+  editorViewSetPlaceholderStyledText: (
+    view: Pointer,
+    chunks: Array<{ text: string; fg?: RGBA | null; bg?: RGBA | null; attributes?: number }>,
+  ) => void
+  editorViewSetTabIndicator: (view: Pointer, indicator: number) => void
+  editorViewSetTabIndicatorColor: (view: Pointer, color: RGBA) => void
+
+  bufferPushScissorRect: (buffer: Pointer, x: number, y: number, width: number, height: number) => void
+  bufferPopScissorRect: (buffer: Pointer) => void
+  bufferClearScissorRects: (buffer: Pointer) => void
+  bufferPushOpacity: (buffer: Pointer, opacity: number) => void
+  bufferPopOpacity: (buffer: Pointer) => void
+  bufferGetCurrentOpacity: (buffer: Pointer) => number
+  bufferClearOpacity: (buffer: Pointer) => void
+  textBufferAddHighlightByCharRange: (buffer: Pointer, highlight: Highlight) => void
+  textBufferAddHighlight: (buffer: Pointer, lineIdx: number, highlight: Highlight) => void
+  textBufferRemoveHighlightsByRef: (buffer: Pointer, hlRef: number) => void
+  textBufferClearLineHighlights: (buffer: Pointer, lineIdx: number) => void
+  textBufferClearAllHighlights: (buffer: Pointer) => void
+  textBufferSetSyntaxStyle: (buffer: Pointer, style: Pointer | null) => void
+  textBufferGetLineHighlights: (buffer: Pointer, lineIdx: number) => Array<Highlight>
+  textBufferGetHighlightCount: (buffer: Pointer) => number
+
+  getArenaAllocatedBytes: () => number
+  getBuildOptions: () => BuildOptions
+  getAllocatorStats: () => AllocatorStats
+
+  createSyntaxStyle: () => Pointer
+  destroySyntaxStyle: (style: Pointer) => void
+  syntaxStyleRegister: (style: Pointer, name: string, fg: RGBA | null, bg: RGBA | null, attributes: number) => number
+  syntaxStyleResolveByName: (style: Pointer, name: string) => number | null
+  syntaxStyleGetStyleCount: (style: Pointer) => number
+
+  getTerminalCapabilities: (renderer: Pointer) => any
+  processCapabilityResponse: (renderer: Pointer, response: string) => void
+
+  encodeUnicode: (
+    text: string,
+    widthMethod: WidthMethod,
+  ) => { ptr: Pointer; data: Array<{ width: number; char: number }> } | null
+  freeUnicode: (encoded: { ptr: Pointer; data: Array<{ width: number; char: number }> }) => void
+  bufferDrawChar: (buffer: Pointer, char: number, x: number, y: number, fg: RGBA, bg: RGBA, attributes?: number) => void
+
+  registerNativeSpanFeedStream: (stream: Pointer, handler: NativeSpanFeedEventHandler) => void
+  unregisterNativeSpanFeedStream: (stream: Pointer) => void
+  createNativeSpanFeed: (options?: NativeSpanFeedOptions | null) => Pointer
+  attachNativeSpanFeed: (stream: Pointer) => number
+  destroyNativeSpanFeed: (stream: Pointer) => void
+  streamWrite: (stream: Pointer, data: Uint8Array | string) => number
+  streamCommit: (stream: Pointer) => number
+  streamDrainSpans: (stream: Pointer, outBuffer: Uint8Array, maxSpans: number) => number
+  streamClose: (stream: Pointer) => number
+  streamSetOptions: (stream: Pointer, options: NativeSpanFeedOptions) => number
+  streamGetStats: (stream: Pointer) => NativeSpanFeedStats | null
+  streamReserve: (stream: Pointer, minLen: number) => { status: number; info: ReserveInfo | null }
+  streamCommitReserved: (stream: Pointer, length: number) => number
+
+  onNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void
+  onceNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void
+  offNativeEvent: (name: string, handler: (data: ArrayBuffer) => void) => void
+  onAnyNativeEvent: (handler: (name: string, data: ArrayBuffer) => void) => void
+}
+
+class FFIRenderLib implements RenderLib {
+  private opentui: ReturnType<typeof getOpenTUILib>
+  public readonly encoder: TextEncoder = new TextEncoder()
+  public readonly decoder: TextDecoder = new TextDecoder()
+  private logCallbackWrapper: any // Store the FFI callback wrapper
+  private eventCallbackWrapper: any // Store the FFI event callback wrapper
+  private _nativeEvents: EventEmitter = new EventEmitter()
+  private _anyEventHandlers: Array<(name: string, data: ArrayBuffer) => void> = []
+  private nativeSpanFeedCallbackWrapper: JSCallback | null = null
+  private nativeSpanFeedHandlers = new Map<Pointer, NativeSpanFeedEventHandler>()
+
+  constructor(libPath?: string) {
+    this.opentui = getOpenTUILib(libPath)
+    this.setupLogging()
+    this.setupEventBus()
+  }
+
+  private setupLogging() {
+    if (this.logCallbackWrapper) {
+      return
+    }
+
+    const logCallback = new JSCallback(
+      (level: number, msgPtr: Pointer, msgLenBigInt: bigint | number) => {
+        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)
+  }
+
+  private setLogCallback(callbackPtr: Pointer) {
+    this.opentui.symbols.setLogCallback(callbackPtr)
+  }
+
+  private setupEventBus() {
+    if (this.eventCallbackWrapper) {
+      return
+    }
+
+    const eventCallback = new JSCallback(
+      (namePtr: Pointer, nameLenBigInt: bigint | number, dataPtr: Pointer, dataLenBigInt: bigint | number) => {
+        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: ArrayBuffer
+          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)
+  }
+
+  private ensureNativeSpanFeedCallback(): JSCallback {
+    if (this.nativeSpanFeedCallbackWrapper) {
+      return this.nativeSpanFeedCallbackWrapper
+    }
+
+    const callback = new JSCallback(
+      (streamPtr: Pointer, eventId: number, arg0: Pointer, arg1: number | bigint) => {
+        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
+  }
+
+  private setEventCallback(callbackPtr: Pointer) {
+    this.opentui.symbols.setEventCallback(callbackPtr)
+  }
+
+  public createRenderer(width: number, height: number, options: { testing?: boolean; remote?: boolean } = {}) {
+    const testing = options.testing ?? false
+    const remote = options.remote ?? false
+    return this.opentui.symbols.createRenderer(width, height, testing, remote)
+  }
+
+  public setTerminalEnvVar(renderer: Pointer, key: string, value: string): boolean {
+    const keyBytes = this.encoder.encode(key)
+    const valueBytes = this.encoder.encode(value)
+    return this.opentui.symbols.setTerminalEnvVar(renderer, keyBytes, keyBytes.length, valueBytes, valueBytes.length)
+  }
+
+  public destroyRenderer(renderer: Pointer): void {
+    this.opentui.symbols.destroyRenderer(renderer)
+  }
+
+  public setUseThread(renderer: Pointer, useThread: boolean) {
+    this.opentui.symbols.setUseThread(renderer, useThread)
+  }
+
+  public setBackgroundColor(renderer: Pointer, color: RGBA) {
+    this.opentui.symbols.setBackgroundColor(renderer, color.buffer)
+  }
+
+  public setRenderOffset(renderer: Pointer, offset: number) {
+    this.opentui.symbols.setRenderOffset(renderer, offset)
+  }
+
+  public updateStats(renderer: Pointer, time: number, fps: number, frameCallbackTime: number) {
+    this.opentui.symbols.updateStats(renderer, time, fps, frameCallbackTime)
+  }
+
+  public updateMemoryStats(renderer: Pointer, heapUsed: number, heapTotal: number, arrayBuffers: number) {
+    this.opentui.symbols.updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers)
+  }
+
+  public getNextBuffer(renderer: Pointer): OptimizedBuffer {
+    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 OptimizedBuffer(this, bufferPtr, width, height, { id: "next buffer", widthMethod: "unicode" })
+  }
+
+  public getCurrentBuffer(renderer: Pointer): OptimizedBuffer {
+    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 OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer", widthMethod: "unicode" })
+  }
+
+  public bufferGetCharPtr(buffer: Pointer): Pointer {
+    const ptr = this.opentui.symbols.bufferGetCharPtr(buffer)
+    if (!ptr) {
+      throw new Error("Failed to get char pointer")
+    }
+    return ptr
+  }
+
+  public bufferGetFgPtr(buffer: Pointer): Pointer {
+    const ptr = this.opentui.symbols.bufferGetFgPtr(buffer)
+    if (!ptr) {
+      throw new Error("Failed to get fg pointer")
+    }
+    return ptr
+  }
+
+  public bufferGetBgPtr(buffer: Pointer): Pointer {
+    const ptr = this.opentui.symbols.bufferGetBgPtr(buffer)
+    if (!ptr) {
+      throw new Error("Failed to get bg pointer")
+    }
+    return ptr
+  }
+
+  public bufferGetAttributesPtr(buffer: Pointer): Pointer {
+    const ptr = this.opentui.symbols.bufferGetAttributesPtr(buffer)
+    if (!ptr) {
+      throw new Error("Failed to get attributes pointer")
+    }
+    return ptr
+  }
+
+  public bufferGetRespectAlpha(buffer: Pointer): boolean {
+    return this.opentui.symbols.bufferGetRespectAlpha(buffer)
+  }
+
+  public bufferSetRespectAlpha(buffer: Pointer, respectAlpha: boolean): void {
+    this.opentui.symbols.bufferSetRespectAlpha(buffer, respectAlpha)
+  }
+
+  public bufferGetId(buffer: Pointer): string {
+    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))
+  }
+
+  public bufferGetRealCharSize(buffer: Pointer): number {
+    return this.opentui.symbols.bufferGetRealCharSize(buffer)
+  }
+
+  public bufferWriteResolvedChars(buffer: Pointer, outputBuffer: Uint8Array, addLineBreaks: boolean): number {
+    const bytesWritten = this.opentui.symbols.bufferWriteResolvedChars(
+      buffer,
+      outputBuffer,
+      outputBuffer.length,
+      addLineBreaks,
+    )
+    return typeof bytesWritten === "bigint" ? Number(bytesWritten) : bytesWritten
+  }
+
+  public getBufferWidth(buffer: Pointer): number {
+    return this.opentui.symbols.getBufferWidth(buffer)
+  }
+
+  public getBufferHeight(buffer: Pointer): number {
+    return this.opentui.symbols.getBufferHeight(buffer)
+  }
+
+  public bufferClear(buffer: Pointer, color: RGBA) {
+    this.opentui.symbols.bufferClear(buffer, color.buffer)
+  }
+
+  public bufferDrawText(
+    buffer: Pointer,
+    text: string,
+    x: number,
+    y: number,
+    color: RGBA,
+    bgColor?: RGBA,
+    attributes?: number,
+  ) {
+    const textBytes = this.encoder.encode(text)
+    const textLength = textBytes.byteLength
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = color.buffer
+
+    this.opentui.symbols.bufferDrawText(buffer, textBytes, textLength, x, y, fg, bg, attributes ?? 0)
+  }
+
+  public bufferSetCellWithAlphaBlending(
+    buffer: Pointer,
+    x: number,
+    y: number,
+    char: string,
+    color: RGBA,
+    bgColor: RGBA,
+    attributes?: number,
+  ) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0)!
+    const bg = bgColor.buffer
+    const fg = color.buffer
+
+    this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x, y, charPtr, fg, bg, attributes ?? 0)
+  }
+
+  public bufferSetCell(
+    buffer: Pointer,
+    x: number,
+    y: number,
+    char: string,
+    color: RGBA,
+    bgColor: RGBA,
+    attributes?: number,
+  ) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0)!
+    const bg = bgColor.buffer
+    const fg = color.buffer
+
+    this.opentui.symbols.bufferSetCell(buffer, x, y, charPtr, fg, bg, attributes ?? 0)
+  }
+
+  public bufferFillRect(buffer: Pointer, x: number, y: number, width: number, height: number, color: RGBA) {
+    const bg = color.buffer
+    this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg)
+  }
+
+  public bufferColorMatrix(
+    buffer: Pointer,
+    matrixPtr: Pointer,
+    cellMaskPtr: Pointer,
+    cellMaskCount: number,
+    strength: number,
+    target: TargetChannel,
+  ): void {
+    this.opentui.symbols.bufferColorMatrix(buffer, matrixPtr, cellMaskPtr, cellMaskCount, strength, target)
+  }
+
+  public bufferColorMatrixUniform(buffer: Pointer, matrixPtr: Pointer, strength: number, target: TargetChannel): void {
+    this.opentui.symbols.bufferColorMatrixUniform(buffer, matrixPtr, strength, target)
+  }
+
+  public bufferDrawSuperSampleBuffer(
+    buffer: Pointer,
+    x: number,
+    y: number,
+    pixelDataPtr: Pointer,
+    pixelDataLength: number,
+    format: "bgra8unorm" | "rgba8unorm",
+    alignedBytesPerRow: number,
+  ): void {
+    const formatId = format === "bgra8unorm" ? 0 : 1
+    this.opentui.symbols.bufferDrawSuperSampleBuffer(
+      buffer,
+      x,
+      y,
+      pixelDataPtr,
+      pixelDataLength,
+      formatId,
+      alignedBytesPerRow,
+    )
+  }
+
+  public bufferDrawPackedBuffer(
+    buffer: Pointer,
+    dataPtr: Pointer,
+    dataLen: number,
+    posX: number,
+    posY: number,
+    terminalWidthCells: number,
+    terminalHeightCells: number,
+  ): void {
+    this.opentui.symbols.bufferDrawPackedBuffer(
+      buffer,
+      dataPtr,
+      dataLen,
+      posX,
+      posY,
+      terminalWidthCells,
+      terminalHeightCells,
+    )
+  }
+
+  public bufferDrawGrayscaleBuffer(
+    buffer: Pointer,
+    posX: number,
+    posY: number,
+    intensitiesPtr: Pointer,
+    srcWidth: number,
+    srcHeight: number,
+    fg: RGBA | null,
+    bg: RGBA | null,
+  ): void {
+    this.opentui.symbols.bufferDrawGrayscaleBuffer(
+      buffer,
+      posX,
+      posY,
+      intensitiesPtr,
+      srcWidth,
+      srcHeight,
+      fg?.buffer ?? null,
+      bg?.buffer ?? null,
+    )
+  }
+
+  public bufferDrawGrayscaleBufferSupersampled(
+    buffer: Pointer,
+    posX: number,
+    posY: number,
+    intensitiesPtr: Pointer,
+    srcWidth: number,
+    srcHeight: number,
+    fg: RGBA | null,
+    bg: RGBA | null,
+  ): void {
+    this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(
+      buffer,
+      posX,
+      posY,
+      intensitiesPtr,
+      srcWidth,
+      srcHeight,
+      fg?.buffer ?? null,
+      bg?.buffer ?? null,
+    )
+  }
+
+  public bufferDrawGrid(
+    buffer: Pointer,
+    borderChars: Uint32Array,
+    borderFg: RGBA,
+    borderBg: RGBA,
+    columnOffsets: Int32Array,
+    columnCount: number,
+    rowOffsets: Int32Array,
+    rowCount: number,
+    options: { drawInner: boolean; drawOuter: boolean },
+  ): void {
+    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),
+    )
+  }
+
+  public bufferDrawBox(
+    buffer: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    borderChars: Uint32Array,
+    packedOptions: number,
+    borderColor: RGBA,
+    backgroundColor: RGBA,
+    title: string | null,
+    bottomTitle: string | null,
+  ): void {
+    const titleBytes = title ? this.encoder.encode(title) : null
+    const titleLen = title ? titleBytes!.length : 0
+    const titlePtr = title ? titleBytes : null
+
+    const bottomTitleBytes = bottomTitle ? this.encoder.encode(bottomTitle) : null
+    const bottomTitleLen = bottomTitle ? bottomTitleBytes!.length : 0
+    const bottomTitlePtr = bottomTitle ? bottomTitleBytes : null
+
+    this.opentui.symbols.bufferDrawBox(
+      buffer,
+      x,
+      y,
+      width,
+      height,
+      borderChars,
+      packedOptions,
+      borderColor.buffer,
+      backgroundColor.buffer,
+      titlePtr,
+      titleLen,
+      bottomTitlePtr,
+      bottomTitleLen,
+    )
+  }
+
+  public bufferResize(buffer: Pointer, width: number, height: number): void {
+    this.opentui.symbols.bufferResize(buffer, width, height)
+  }
+
+  // Link API
+  public linkAlloc(url: string): number {
+    const urlBytes = this.encoder.encode(url)
+    return this.opentui.symbols.linkAlloc(urlBytes, urlBytes.length)
+  }
+
+  public linkGetUrl(linkId: number, maxLen: number = 512): string {
+    const outBuffer = new Uint8Array(maxLen)
+    const actualLen = this.opentui.symbols.linkGetUrl(linkId, outBuffer, maxLen)
+    return this.decoder.decode(outBuffer.slice(0, actualLen))
+  }
+
+  public attributesWithLink(baseAttributes: number, linkId: number): number {
+    return this.opentui.symbols.attributesWithLink(baseAttributes, linkId)
+  }
+
+  public attributesGetLinkId(attributes: number): number {
+    return this.opentui.symbols.attributesGetLinkId(attributes)
+  }
+
+  public resizeRenderer(renderer: Pointer, width: number, height: number) {
+    this.opentui.symbols.resizeRenderer(renderer, width, height)
+  }
+
+  public setCursorPosition(renderer: Pointer, x: number, y: number, visible: boolean) {
+    this.opentui.symbols.setCursorPosition(renderer, x, y, visible)
+  }
+
+  public setCursorColor(renderer: Pointer, color: RGBA) {
+    this.opentui.symbols.setCursorColor(renderer, color.buffer)
+  }
+
+  public getCursorState(renderer: Pointer): CursorState {
+    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: RGBA.fromValues(struct.r, struct.g, struct.b, struct.a),
+    }
+  }
+
+  public setCursorStyleOptions(renderer: Pointer, options: CursorStyleOptions): void {
+    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))
+  }
+
+  public render(renderer: Pointer, force: boolean) {
+    this.opentui.symbols.render(renderer, force)
+  }
+
+  public createOptimizedBuffer(
+    width: number,
+    height: number,
+    widthMethod: WidthMethod,
+    respectAlpha: boolean = false,
+    id?: string,
+  ): OptimizedBuffer {
+    if (Number.isNaN(width) || Number.isNaN(height)) {
+      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack)
+    }
+
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1
+    const idToUse = id || "unnamed buffer"
+    const idBytes = this.encoder.encode(idToUse)
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(
+      width,
+      height,
+      respectAlpha,
+      widthMethodCode,
+      idBytes,
+      idBytes.length,
+    )
+    if (!bufferPtr) {
+      throw new Error(`Failed to create optimized buffer: ${width}x${height}`)
+    }
+
+    return new OptimizedBuffer(this, bufferPtr, width, height, { respectAlpha, id, widthMethod })
+  }
+
+  public destroyOptimizedBuffer(bufferPtr: Pointer) {
+    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr)
+  }
+
+  public drawFrameBuffer(
+    targetBufferPtr: Pointer,
+    destX: number,
+    destY: number,
+    bufferPtr: Pointer,
+    sourceX?: number,
+    sourceY?: number,
+    sourceWidth?: number,
+    sourceHeight?: number,
+  ) {
+    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)
+  }
+
+  public setDebugOverlay(renderer: Pointer, enabled: boolean, corner: DebugOverlayCorner) {
+    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner)
+  }
+
+  public clearTerminal(renderer: Pointer) {
+    this.opentui.symbols.clearTerminal(renderer)
+  }
+
+  public setTerminalTitle(renderer: Pointer, title: string) {
+    const titleBytes = this.encoder.encode(title)
+    this.opentui.symbols.setTerminalTitle(renderer, titleBytes, titleBytes.length)
+  }
+
+  public copyToClipboardOSC52(renderer: Pointer, target: number, payload: Uint8Array): boolean {
+    return this.opentui.symbols.copyToClipboardOSC52(renderer, target, payload, payload.length)
+  }
+
+  public clearClipboardOSC52(renderer: Pointer, target: number): boolean {
+    return this.opentui.symbols.clearClipboardOSC52(renderer, target)
+  }
+
+  public addToHitGrid(renderer: Pointer, x: number, y: number, width: number, height: number, id: number) {
+    this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id)
+  }
+
+  public clearCurrentHitGrid(renderer: Pointer) {
+    this.opentui.symbols.clearCurrentHitGrid(renderer)
+  }
+
+  public hitGridPushScissorRect(renderer: Pointer, x: number, y: number, width: number, height: number) {
+    this.opentui.symbols.hitGridPushScissorRect(renderer, x, y, width, height)
+  }
+
+  public hitGridPopScissorRect(renderer: Pointer) {
+    this.opentui.symbols.hitGridPopScissorRect(renderer)
+  }
+
+  public hitGridClearScissorRects(renderer: Pointer) {
+    this.opentui.symbols.hitGridClearScissorRects(renderer)
+  }
+
+  public addToCurrentHitGridClipped(
+    renderer: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    id: number,
+  ) {
+    this.opentui.symbols.addToCurrentHitGridClipped(renderer, x, y, width, height, id)
+  }
+
+  public checkHit(renderer: Pointer, x: number, y: number): number {
+    return this.opentui.symbols.checkHit(renderer, x, y)
+  }
+
+  public getHitGridDirty(renderer: Pointer): boolean {
+    return this.opentui.symbols.getHitGridDirty(renderer)
+  }
+
+  public dumpHitGrid(renderer: Pointer): void {
+    this.opentui.symbols.dumpHitGrid(renderer)
+  }
+
+  public dumpBuffers(renderer: Pointer, timestamp?: number): void {
+    const ts = timestamp ?? Date.now()
+    this.opentui.symbols.dumpBuffers(renderer, ts)
+  }
+
+  public dumpStdoutBuffer(renderer: Pointer, timestamp?: number): void {
+    const ts = timestamp ?? Date.now()
+    this.opentui.symbols.dumpStdoutBuffer(renderer, ts)
+  }
+
+  public restoreTerminalModes(renderer: Pointer): void {
+    this.opentui.symbols.restoreTerminalModes(renderer)
+  }
+
+  public enableMouse(renderer: Pointer, enableMovement: boolean): void {
+    this.opentui.symbols.enableMouse(renderer, enableMovement)
+  }
+
+  public disableMouse(renderer: Pointer): void {
+    this.opentui.symbols.disableMouse(renderer)
+  }
+
+  public enableKittyKeyboard(renderer: Pointer, flags: number): void {
+    this.opentui.symbols.enableKittyKeyboard(renderer, flags)
+  }
+
+  public disableKittyKeyboard(renderer: Pointer): void {
+    this.opentui.symbols.disableKittyKeyboard(renderer)
+  }
+
+  public setKittyKeyboardFlags(renderer: Pointer, flags: number): void {
+    this.opentui.symbols.setKittyKeyboardFlags(renderer, flags)
+  }
+
+  public getKittyKeyboardFlags(renderer: Pointer): number {
+    return this.opentui.symbols.getKittyKeyboardFlags(renderer)
+  }
+
+  public setupTerminal(renderer: Pointer, useAlternateScreen: boolean): void {
+    this.opentui.symbols.setupTerminal(renderer, useAlternateScreen)
+  }
+
+  public suspendRenderer(renderer: Pointer): void {
+    this.opentui.symbols.suspendRenderer(renderer)
+  }
+
+  public resumeRenderer(renderer: Pointer): void {
+    this.opentui.symbols.resumeRenderer(renderer)
+  }
+
+  public queryPixelResolution(renderer: Pointer): void {
+    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.
+   */
+  public writeOut(renderer: Pointer, data: string | Uint8Array): void {
+    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
+  public createTextBuffer(widthMethod: WidthMethod): TextBuffer {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1
+    const bufferPtr = this.opentui.symbols.createTextBuffer(widthMethodCode)
+    if (!bufferPtr) {
+      throw new Error(`Failed to create TextBuffer`)
+    }
+
+    return new TextBuffer(this, bufferPtr)
+  }
+
+  public destroyTextBuffer(buffer: Pointer): void {
+    this.opentui.symbols.destroyTextBuffer(buffer)
+  }
+
+  public textBufferGetLength(buffer: Pointer): number {
+    return this.opentui.symbols.textBufferGetLength(buffer)
+  }
+
+  public textBufferGetByteSize(buffer: Pointer): number {
+    return this.opentui.symbols.textBufferGetByteSize(buffer)
+  }
+
+  public textBufferReset(buffer: Pointer): void {
+    this.opentui.symbols.textBufferReset(buffer)
+  }
+
+  public textBufferClear(buffer: Pointer): void {
+    this.opentui.symbols.textBufferClear(buffer)
+  }
+
+  public textBufferSetDefaultFg(buffer: Pointer, fg: RGBA | null): void {
+    const fgPtr = fg ? fg.buffer : null
+    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr)
+  }
+
+  public textBufferSetDefaultBg(buffer: Pointer, bg: RGBA | null): void {
+    const bgPtr = bg ? bg.buffer : null
+    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr)
+  }
+
+  public textBufferSetDefaultAttributes(buffer: Pointer, attributes: number | null): void {
+    const attrValue = attributes === null ? null : new Uint8Array([attributes])
+    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue)
+  }
+
+  public textBufferResetDefaults(buffer: Pointer): void {
+    this.opentui.symbols.textBufferResetDefaults(buffer)
+  }
+
+  public textBufferGetTabWidth(buffer: Pointer): number {
+    return this.opentui.symbols.textBufferGetTabWidth(buffer)
+  }
+
+  public textBufferSetTabWidth(buffer: Pointer, width: number): void {
+    this.opentui.symbols.textBufferSetTabWidth(buffer, width)
+  }
+
+  public textBufferRegisterMemBuffer(buffer: Pointer, bytes: Uint8Array, owned: boolean = false): number {
+    const result = this.opentui.symbols.textBufferRegisterMemBuffer(buffer, bytes, bytes.length, owned)
+    if (result === 0xffff) {
+      throw new Error("Failed to register memory buffer")
+    }
+    return result
+  }
+
+  public textBufferReplaceMemBuffer(
+    buffer: Pointer,
+    memId: number,
+    bytes: Uint8Array,
+    owned: boolean = false,
+  ): boolean {
+    return this.opentui.symbols.textBufferReplaceMemBuffer(buffer, memId, bytes, bytes.length, owned)
+  }
+
+  public textBufferClearMemRegistry(buffer: Pointer): void {
+    this.opentui.symbols.textBufferClearMemRegistry(buffer)
+  }
+
+  public textBufferSetTextFromMem(buffer: Pointer, memId: number): void {
+    this.opentui.symbols.textBufferSetTextFromMem(buffer, memId)
+  }
+
+  public textBufferAppend(buffer: Pointer, bytes: Uint8Array): void {
+    this.opentui.symbols.textBufferAppend(buffer, bytes, bytes.length)
+  }
+
+  public textBufferAppendFromMemId(buffer: Pointer, memId: number): void {
+    this.opentui.symbols.textBufferAppendFromMemId(buffer, memId)
+  }
+
+  public textBufferLoadFile(buffer: Pointer, path: string): boolean {
+    const pathBytes = this.encoder.encode(path)
+    return this.opentui.symbols.textBufferLoadFile(buffer, pathBytes, pathBytes.length)
+  }
+
+  public textBufferSetStyledText(
+    buffer: Pointer,
+    chunks: Array<{ text: string; fg?: RGBA | null; bg?: RGBA | null; attributes?: number; link?: { url: string } }>,
+  ): void {
+    if (chunks.length === 0) {
+      this.textBufferClear(buffer)
+      return
+    }
+
+    const chunksBuffer = StyledChunkStruct.packList(chunks)
+    this.opentui.symbols.textBufferSetStyledText(buffer, ptr(chunksBuffer), chunks.length)
+  }
+
+  public textBufferGetLineCount(buffer: Pointer): number {
+    return this.opentui.symbols.textBufferGetLineCount(buffer)
+  }
+
+  private textBufferGetPlainText(buffer: Pointer, outPtr: Pointer, maxLen: number): number {
+    const result = this.opentui.symbols.textBufferGetPlainText(buffer, outPtr, maxLen)
+    return typeof result === "bigint" ? Number(result) : result
+  }
+
+  public getPlainTextBytes(buffer: Pointer, maxLength: number): Uint8Array | null {
+    const outBuffer = new Uint8Array(maxLength)
+
+    const actualLen = this.textBufferGetPlainText(buffer, ptr(outBuffer), maxLength)
+
+    if (actualLen === 0) {
+      return null
+    }
+
+    return outBuffer.slice(0, actualLen)
+  }
+
+  public textBufferGetTextRange(
+    buffer: Pointer,
+    startOffset: number,
+    endOffset: number,
+    maxLength: number,
+  ): Uint8Array | null {
+    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)
+  }
+
+  public textBufferGetTextRangeByCoords(
+    buffer: Pointer,
+    startRow: number,
+    startCol: number,
+    endRow: number,
+    endCol: number,
+    maxLength: number,
+  ): Uint8Array | null {
+    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
+  public createTextBufferView(textBuffer: Pointer): Pointer {
+    const viewPtr = this.opentui.symbols.createTextBufferView(textBuffer)
+    if (!viewPtr) {
+      throw new Error("Failed to create TextBufferView")
+    }
+    return viewPtr
+  }
+
+  public destroyTextBufferView(view: Pointer): void {
+    this.opentui.symbols.destroyTextBufferView(view)
+  }
+
+  public textBufferViewSetSelection(
+    view: Pointer,
+    start: number,
+    end: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ): void {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    this.opentui.symbols.textBufferViewSetSelection(view, start, end, bg, fg)
+  }
+
+  public textBufferViewResetSelection(view: Pointer): void {
+    this.opentui.symbols.textBufferViewResetSelection(view)
+  }
+
+  public textBufferViewGetSelection(view: Pointer): { start: number; end: number } | null {
+    const packedInfo = this.textBufferViewGetSelectionInfo(view)
+
+    // Check for no selection marker (0xFFFFFFFF_FFFFFFFF)
+    if (packedInfo === 0xffff_ffff_ffff_ffffn) {
+      return null
+    }
+
+    const start = Number(packedInfo >> 32n)
+    const end = Number(packedInfo & 0xffff_ffffn)
+
+    return { start, end }
+  }
+
+  private textBufferViewGetSelectionInfo(view: Pointer): bigint {
+    return this.opentui.symbols.textBufferViewGetSelectionInfo(view)
+  }
+
+  public textBufferViewSetLocalSelection(
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ): boolean {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    return this.opentui.symbols.textBufferViewSetLocalSelection(view, anchorX, anchorY, focusX, focusY, bg, fg)
+  }
+
+  public textBufferViewUpdateSelection(view: Pointer, end: number, bgColor: RGBA | null, fgColor: RGBA | null): void {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    this.opentui.symbols.textBufferViewUpdateSelection(view, end, bg, fg)
+  }
+
+  public textBufferViewUpdateLocalSelection(
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ): boolean {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    return this.opentui.symbols.textBufferViewUpdateLocalSelection(view, anchorX, anchorY, focusX, focusY, bg, fg)
+  }
+
+  public textBufferViewResetLocalSelection(view: Pointer): void {
+    this.opentui.symbols.textBufferViewResetLocalSelection(view)
+  }
+
+  public textBufferViewSetWrapWidth(view: Pointer, width: number): void {
+    this.opentui.symbols.textBufferViewSetWrapWidth(view, width)
+  }
+
+  public textBufferViewSetWrapMode(view: Pointer, mode: "none" | "char" | "word"): void {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2
+    this.opentui.symbols.textBufferViewSetWrapMode(view, modeValue)
+  }
+
+  public textBufferViewSetViewportSize(view: Pointer, width: number, height: number): void {
+    this.opentui.symbols.textBufferViewSetViewportSize(view, width, height)
+  }
+
+  public textBufferViewSetViewport(view: Pointer, x: number, y: number, width: number, height: number): void {
+    this.opentui.symbols.textBufferViewSetViewport(view, x, y, width, height)
+  }
+
+  public textBufferViewGetLineInfo(view: Pointer): LineInfo {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size)
+    this.textBufferViewGetLineInfoDirect(view, ptr(outBuffer))
+    const struct = LineInfoStruct.unpack(outBuffer)
+
+    const lineStartCols = struct.startCols as number[]
+    const lineWidthCols = struct.widthCols as number[]
+    const lineWidthColsMax = struct.widthColsMax
+
+    return {
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
+      lineSources: struct.sources as number[],
+      lineWraps: struct.wraps as number[],
+    }
+  }
+
+  public textBufferViewGetLogicalLineInfo(view: Pointer): LineInfo {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size)
+    this.textBufferViewGetLogicalLineInfoDirect(view, ptr(outBuffer))
+    const struct = LineInfoStruct.unpack(outBuffer)
+
+    const lineStartCols = struct.startCols as number[]
+    const lineWidthCols = struct.widthCols as number[]
+    const lineWidthColsMax = struct.widthColsMax
+
+    return {
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
+      lineSources: struct.sources as number[],
+      lineWraps: struct.wraps as number[],
+    }
+  }
+
+  public textBufferViewGetVirtualLineCount(view: Pointer): number {
+    return this.opentui.symbols.textBufferViewGetVirtualLineCount(view)
+  }
+
+  private textBufferViewGetLineInfoDirect(view: Pointer, outPtr: Pointer): void {
+    this.opentui.symbols.textBufferViewGetLineInfoDirect(view, outPtr)
+  }
+
+  private textBufferViewGetLogicalLineInfoDirect(view: Pointer, outPtr: Pointer): void {
+    this.opentui.symbols.textBufferViewGetLogicalLineInfoDirect(view, outPtr)
+  }
+
+  private textBufferViewGetSelectedText(view: Pointer, outPtr: Pointer, maxLen: number): number {
+    const result = this.opentui.symbols.textBufferViewGetSelectedText(view, outPtr, maxLen)
+    return typeof result === "bigint" ? Number(result) : result
+  }
+
+  private textBufferViewGetPlainText(view: Pointer, outPtr: Pointer, maxLen: number): number {
+    const result = this.opentui.symbols.textBufferViewGetPlainText(view, outPtr, maxLen)
+    return typeof result === "bigint" ? Number(result) : result
+  }
+
+  public textBufferViewGetSelectedTextBytes(view: Pointer, maxLength: number): Uint8Array | null {
+    const outBuffer = new Uint8Array(maxLength)
+
+    const actualLen = this.textBufferViewGetSelectedText(view, ptr(outBuffer), maxLength)
+
+    if (actualLen === 0) {
+      return null
+    }
+
+    return outBuffer.slice(0, actualLen)
+  }
+
+  public textBufferViewGetPlainTextBytes(view: Pointer, maxLength: number): Uint8Array | null {
+    const outBuffer = new Uint8Array(maxLength)
+
+    const actualLen = this.textBufferViewGetPlainText(view, ptr(outBuffer), maxLength)
+
+    if (actualLen === 0) {
+      return null
+    }
+
+    return outBuffer.slice(0, actualLen)
+  }
+
+  public textBufferViewSetTabIndicator(view: Pointer, indicator: number): void {
+    this.opentui.symbols.textBufferViewSetTabIndicator(view, indicator)
+  }
+
+  public textBufferViewSetTabIndicatorColor(view: Pointer, color: RGBA): void {
+    this.opentui.symbols.textBufferViewSetTabIndicatorColor(view, color.buffer)
+  }
+
+  public textBufferViewSetTruncate(view: Pointer, truncate: boolean): void {
+    this.opentui.symbols.textBufferViewSetTruncate(view, truncate)
+  }
+
+  public textBufferViewMeasureForDimensions(
+    view: Pointer,
+    width: number,
+    height: number,
+  ): { lineCount: number; widthColsMax: number } | null {
+    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
+  }
+
+  public textBufferAddHighlightByCharRange(buffer: Pointer, highlight: Highlight): void {
+    const packedHighlight = HighlightStruct.pack(highlight)
+    this.opentui.symbols.textBufferAddHighlightByCharRange(buffer, ptr(packedHighlight))
+  }
+
+  public textBufferAddHighlight(buffer: Pointer, lineIdx: number, highlight: Highlight): void {
+    const packedHighlight = HighlightStruct.pack(highlight)
+    this.opentui.symbols.textBufferAddHighlight(buffer, lineIdx, ptr(packedHighlight))
+  }
+
+  public textBufferRemoveHighlightsByRef(buffer: Pointer, hlRef: number): void {
+    this.opentui.symbols.textBufferRemoveHighlightsByRef(buffer, hlRef)
+  }
+
+  public textBufferClearLineHighlights(buffer: Pointer, lineIdx: number): void {
+    this.opentui.symbols.textBufferClearLineHighlights(buffer, lineIdx)
+  }
+
+  public textBufferClearAllHighlights(buffer: Pointer): void {
+    this.opentui.symbols.textBufferClearAllHighlights(buffer)
+  }
+
+  public textBufferSetSyntaxStyle(buffer: Pointer, style: Pointer | null): void {
+    this.opentui.symbols.textBufferSetSyntaxStyle(buffer, style)
+  }
+
+  public textBufferGetLineHighlights(buffer: Pointer, lineIdx: number): Array<Highlight> {
+    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
+  }
+
+  public textBufferGetHighlightCount(buffer: Pointer): number {
+    return this.opentui.symbols.textBufferGetHighlightCount(buffer)
+  }
+
+  public getArenaAllocatedBytes(): number {
+    const result = this.opentui.symbols.getArenaAllocatedBytes()
+    return typeof result === "bigint" ? Number(result) : result
+  }
+
+  public getBuildOptions(): BuildOptions {
+    const optionsBuffer = new ArrayBuffer(BuildOptionsStruct.size)
+    this.opentui.symbols.getBuildOptions(ptr(optionsBuffer))
+    const options = BuildOptionsStruct.unpack(optionsBuffer)
+
+    return {
+      gpaSafeStats: !!options.gpaSafeStats,
+      gpaMemoryLimitTracking: !!options.gpaMemoryLimitTracking,
+    }
+  }
+
+  public getAllocatorStats(): AllocatorStats {
+    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,
+    }
+  }
+
+  public bufferDrawTextBufferView(buffer: Pointer, view: Pointer, x: number, y: number): void {
+    this.opentui.symbols.bufferDrawTextBufferView(buffer, view, x, y)
+  }
+
+  public bufferDrawEditorView(buffer: Pointer, view: Pointer, x: number, y: number): void {
+    this.opentui.symbols.bufferDrawEditorView(buffer, view, x, y)
+  }
+
+  // EditorView methods
+  public createEditorView(editBufferPtr: Pointer, viewportWidth: number, viewportHeight: number): Pointer {
+    const viewPtr = this.opentui.symbols.createEditorView(editBufferPtr, viewportWidth, viewportHeight)
+    if (!viewPtr) {
+      throw new Error("Failed to create EditorView")
+    }
+    return viewPtr
+  }
+
+  public destroyEditorView(view: Pointer): void {
+    this.opentui.symbols.destroyEditorView(view)
+  }
+
+  public editorViewSetViewportSize(view: Pointer, width: number, height: number): void {
+    this.opentui.symbols.editorViewSetViewportSize(view, width, height)
+  }
+
+  public editorViewSetViewport(
+    view: Pointer,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    moveCursor: boolean,
+  ): void {
+    this.opentui.symbols.editorViewSetViewport(view, x, y, width, height, moveCursor)
+  }
+
+  public editorViewGetViewport(view: Pointer): { offsetY: number; offsetX: number; height: number; width: number } {
+    const x = new Uint32Array(1)
+    const y = new Uint32Array(1)
+    const width = new Uint32Array(1)
+    const height = new Uint32Array(1)
+
+    this.opentui.symbols.editorViewGetViewport(view, ptr(x), ptr(y), ptr(width), ptr(height))
+
+    return {
+      offsetX: x[0],
+      offsetY: y[0],
+      width: width[0],
+      height: height[0],
+    }
+  }
+
+  public editorViewSetScrollMargin(view: Pointer, margin: number): void {
+    this.opentui.symbols.editorViewSetScrollMargin(view, margin)
+  }
+
+  public editorViewSetWrapMode(view: Pointer, mode: "none" | "char" | "word"): void {
+    const modeValue = mode === "none" ? 0 : mode === "char" ? 1 : 2
+    this.opentui.symbols.editorViewSetWrapMode(view, modeValue)
+  }
+
+  public editorViewGetVirtualLineCount(view: Pointer): number {
+    return this.opentui.symbols.editorViewGetVirtualLineCount(view)
+  }
+
+  public editorViewGetTotalVirtualLineCount(view: Pointer): number {
+    return this.opentui.symbols.editorViewGetTotalVirtualLineCount(view)
+  }
+
+  public editorViewGetTextBufferView(view: Pointer): Pointer {
+    const result = this.opentui.symbols.editorViewGetTextBufferView(view)
+    if (!result) {
+      throw new Error("Failed to get TextBufferView from EditorView")
+    }
+    return result
+  }
+
+  public editorViewGetLineInfo(view: Pointer): LineInfo {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size)
+    this.opentui.symbols.editorViewGetLineInfoDirect(view, ptr(outBuffer))
+    const struct = LineInfoStruct.unpack(outBuffer)
+
+    const lineStartCols = struct.startCols as number[]
+    const lineWidthCols = struct.widthCols as number[]
+    const lineWidthColsMax = struct.widthColsMax
+
+    return {
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
+      lineSources: struct.sources as number[],
+      lineWraps: struct.wraps as number[],
+    }
+  }
+
+  public editorViewGetLogicalLineInfo(view: Pointer): LineInfo {
+    const outBuffer = new ArrayBuffer(LineInfoStruct.size)
+    this.opentui.symbols.editorViewGetLogicalLineInfoDirect(view, ptr(outBuffer))
+    const struct = LineInfoStruct.unpack(outBuffer)
+
+    const lineStartCols = struct.startCols as number[]
+    const lineWidthCols = struct.widthCols as number[]
+    const lineWidthColsMax = struct.widthColsMax
+
+    return {
+      lineStartCols,
+      lineWidthCols,
+      lineWidthColsMax,
+      lineSources: struct.sources as number[],
+      lineWraps: struct.wraps as number[],
+    }
+  }
+
+  // EditBuffer implementations
+  public createEditBuffer(widthMethod: WidthMethod): Pointer {
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1
+    const bufferPtr = this.opentui.symbols.createEditBuffer(widthMethodCode)
+    if (!bufferPtr) {
+      throw new Error("Failed to create EditBuffer")
+    }
+    return bufferPtr
+  }
+
+  public destroyEditBuffer(buffer: Pointer): void {
+    this.opentui.symbols.destroyEditBuffer(buffer)
+  }
+
+  public editBufferSetText(buffer: Pointer, textBytes: Uint8Array): void {
+    this.opentui.symbols.editBufferSetText(buffer, textBytes, textBytes.length)
+  }
+
+  public editBufferSetTextFromMem(buffer: Pointer, memId: number): void {
+    this.opentui.symbols.editBufferSetTextFromMem(buffer, memId)
+  }
+
+  public editBufferReplaceText(buffer: Pointer, textBytes: Uint8Array): void {
+    this.opentui.symbols.editBufferReplaceText(buffer, textBytes, textBytes.length)
+  }
+
+  public editBufferReplaceTextFromMem(buffer: Pointer, memId: number): void {
+    this.opentui.symbols.editBufferReplaceTextFromMem(buffer, memId)
+  }
+
+  public editBufferGetText(buffer: Pointer, maxLength: number): Uint8Array | null {
+    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)
+  }
+
+  public editBufferInsertChar(buffer: Pointer, char: string): void {
+    const charBytes = this.encoder.encode(char)
+    this.opentui.symbols.editBufferInsertChar(buffer, charBytes, charBytes.length)
+  }
+
+  public editBufferInsertText(buffer: Pointer, text: string): void {
+    const textBytes = this.encoder.encode(text)
+    this.opentui.symbols.editBufferInsertText(buffer, textBytes, textBytes.length)
+  }
+
+  public editBufferDeleteChar(buffer: Pointer): void {
+    this.opentui.symbols.editBufferDeleteChar(buffer)
+  }
+
+  public editBufferDeleteCharBackward(buffer: Pointer): void {
+    this.opentui.symbols.editBufferDeleteCharBackward(buffer)
+  }
+
+  public editBufferDeleteRange(
+    buffer: Pointer,
+    startLine: number,
+    startCol: number,
+    endLine: number,
+    endCol: number,
+  ): void {
+    this.opentui.symbols.editBufferDeleteRange(buffer, startLine, startCol, endLine, endCol)
+  }
+
+  public editBufferNewLine(buffer: Pointer): void {
+    this.opentui.symbols.editBufferNewLine(buffer)
+  }
+
+  public editBufferDeleteLine(buffer: Pointer): void {
+    this.opentui.symbols.editBufferDeleteLine(buffer)
+  }
+
+  public editBufferMoveCursorLeft(buffer: Pointer): void {
+    this.opentui.symbols.editBufferMoveCursorLeft(buffer)
+  }
+
+  public editBufferMoveCursorRight(buffer: Pointer): void {
+    this.opentui.symbols.editBufferMoveCursorRight(buffer)
+  }
+
+  public editBufferMoveCursorUp(buffer: Pointer): void {
+    this.opentui.symbols.editBufferMoveCursorUp(buffer)
+  }
+
+  public editBufferMoveCursorDown(buffer: Pointer): void {
+    this.opentui.symbols.editBufferMoveCursorDown(buffer)
+  }
+
+  public editBufferGotoLine(buffer: Pointer, line: number): void {
+    this.opentui.symbols.editBufferGotoLine(buffer, line)
+  }
+
+  public editBufferSetCursor(buffer: Pointer, line: number, byteOffset: number): void {
+    this.opentui.symbols.editBufferSetCursor(buffer, line, byteOffset)
+  }
+
+  public editBufferSetCursorToLineCol(buffer: Pointer, line: number, col: number): void {
+    this.opentui.symbols.editBufferSetCursorToLineCol(buffer, line, col)
+  }
+
+  public editBufferSetCursorByOffset(buffer: Pointer, offset: number): void {
+    this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset)
+  }
+
+  public editBufferGetCursorPosition(buffer: Pointer): LogicalCursor {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size)
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr(cursorBuffer))
+    return LogicalCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editBufferGetId(buffer: Pointer): number {
+    return this.opentui.symbols.editBufferGetId(buffer)
+  }
+
+  public editBufferGetTextBuffer(buffer: Pointer): Pointer {
+    const result = this.opentui.symbols.editBufferGetTextBuffer(buffer)
+    if (!result) {
+      throw new Error("Failed to get TextBuffer from EditBuffer")
+    }
+    return result
+  }
+
+  public editBufferDebugLogRope(buffer: Pointer): void {
+    this.opentui.symbols.editBufferDebugLogRope(buffer)
+  }
+
+  public editBufferUndo(buffer: Pointer, maxLength: number): Uint8Array | null {
+    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)
+  }
+
+  public editBufferRedo(buffer: Pointer, maxLength: number): Uint8Array | null {
+    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)
+  }
+
+  public editBufferCanUndo(buffer: Pointer): boolean {
+    return this.opentui.symbols.editBufferCanUndo(buffer)
+  }
+
+  public editBufferCanRedo(buffer: Pointer): boolean {
+    return this.opentui.symbols.editBufferCanRedo(buffer)
+  }
+
+  public editBufferClearHistory(buffer: Pointer): void {
+    this.opentui.symbols.editBufferClearHistory(buffer)
+  }
+
+  public editBufferClear(buffer: Pointer): void {
+    this.opentui.symbols.editBufferClear(buffer)
+  }
+
+  public editBufferGetNextWordBoundary(buffer: Pointer): LogicalCursor {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size)
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr(cursorBuffer))
+    return LogicalCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editBufferGetPrevWordBoundary(buffer: Pointer): LogicalCursor {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size)
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr(cursorBuffer))
+    return LogicalCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editBufferGetEOL(buffer: Pointer): LogicalCursor {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size)
+    this.opentui.symbols.editBufferGetEOL(buffer, ptr(cursorBuffer))
+    return LogicalCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editBufferOffsetToPosition(buffer: Pointer, offset: number): LogicalCursor | null {
+    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size)
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr(cursorBuffer))
+    if (!success) return null
+    return LogicalCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editBufferPositionToOffset(buffer: Pointer, row: number, col: number): number {
+    return this.opentui.symbols.editBufferPositionToOffset(buffer, row, col)
+  }
+
+  public editBufferGetLineStartOffset(buffer: Pointer, row: number): number {
+    return this.opentui.symbols.editBufferGetLineStartOffset(buffer, row)
+  }
+
+  public editBufferGetTextRange(
+    buffer: Pointer,
+    startOffset: number,
+    endOffset: number,
+    maxLength: number,
+  ): Uint8Array | null {
+    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)
+  }
+
+  public editBufferGetTextRangeByCoords(
+    buffer: Pointer,
+    startRow: number,
+    startCol: number,
+    endRow: number,
+    endCol: number,
+    maxLength: number,
+  ): Uint8Array | null {
+    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
+  public editorViewSetSelection(
+    view: Pointer,
+    start: number,
+    end: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+  ): void {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    this.opentui.symbols.editorViewSetSelection(view, start, end, bg, fg)
+  }
+
+  public editorViewResetSelection(view: Pointer): void {
+    this.opentui.symbols.editorViewResetSelection(view)
+  }
+
+  public editorViewGetSelection(view: Pointer): { start: number; end: number } | null {
+    const packedInfo = this.opentui.symbols.editorViewGetSelection(view)
+    if (packedInfo === 0xffff_ffff_ffff_ffffn) {
+      return null
+    }
+    const start = Number(packedInfo >> 32n)
+    const end = Number(packedInfo & 0xffff_ffffn)
+    return { start, end }
+  }
+
+  public editorViewSetLocalSelection(
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+    updateCursor: boolean,
+    followCursor: boolean,
+  ): boolean {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    return this.opentui.symbols.editorViewSetLocalSelection(
+      view,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bg,
+      fg,
+      updateCursor,
+      followCursor,
+    )
+  }
+
+  public editorViewUpdateSelection(view: Pointer, end: number, bgColor: RGBA | null, fgColor: RGBA | null): void {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    this.opentui.symbols.editorViewUpdateSelection(view, end, bg, fg)
+  }
+
+  public editorViewUpdateLocalSelection(
+    view: Pointer,
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor: RGBA | null,
+    fgColor: RGBA | null,
+    updateCursor: boolean,
+    followCursor: boolean,
+  ): boolean {
+    const bg = bgColor ? bgColor.buffer : null
+    const fg = fgColor ? fgColor.buffer : null
+    return this.opentui.symbols.editorViewUpdateLocalSelection(
+      view,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bg,
+      fg,
+      updateCursor,
+      followCursor,
+    )
+  }
+
+  public editorViewResetLocalSelection(view: Pointer): void {
+    this.opentui.symbols.editorViewResetLocalSelection(view)
+  }
+
+  public editorViewGetSelectedTextBytes(view: Pointer, maxLength: number): Uint8Array | null {
+    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)
+  }
+
+  public editorViewGetCursor(view: Pointer): { row: number; col: number } {
+    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] }
+  }
+
+  public editorViewGetText(view: Pointer, maxLength: number): Uint8Array | null {
+    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)
+  }
+
+  public editorViewGetVisualCursor(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetVisualCursor(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editorViewMoveUpVisual(view: Pointer): void {
+    this.opentui.symbols.editorViewMoveUpVisual(view)
+  }
+
+  public editorViewMoveDownVisual(view: Pointer): void {
+    this.opentui.symbols.editorViewMoveDownVisual(view)
+  }
+
+  public editorViewDeleteSelectedText(view: Pointer): void {
+    this.opentui.symbols.editorViewDeleteSelectedText(view)
+  }
+
+  public editorViewSetCursorByOffset(view: Pointer, offset: number): void {
+    this.opentui.symbols.editorViewSetCursorByOffset(view, offset)
+  }
+
+  public editorViewGetNextWordBoundary(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editorViewGetPrevWordBoundary(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editorViewGetEOL(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetEOL(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editorViewGetVisualSOL(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetVisualSOL(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public editorViewGetVisualEOL(view: Pointer): VisualCursor {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size)
+    this.opentui.symbols.editorViewGetVisualEOL(view, ptr(cursorBuffer))
+    return VisualCursorStruct.unpack(cursorBuffer)
+  }
+
+  public bufferPushScissorRect(buffer: Pointer, x: number, y: number, width: number, height: number): void {
+    this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height)
+  }
+
+  public bufferPopScissorRect(buffer: Pointer): void {
+    this.opentui.symbols.bufferPopScissorRect(buffer)
+  }
+
+  public bufferClearScissorRects(buffer: Pointer): void {
+    this.opentui.symbols.bufferClearScissorRects(buffer)
+  }
+
+  public bufferPushOpacity(buffer: Pointer, opacity: number): void {
+    this.opentui.symbols.bufferPushOpacity(buffer, opacity)
+  }
+
+  public bufferPopOpacity(buffer: Pointer): void {
+    this.opentui.symbols.bufferPopOpacity(buffer)
+  }
+
+  public bufferGetCurrentOpacity(buffer: Pointer): number {
+    return this.opentui.symbols.bufferGetCurrentOpacity(buffer)
+  }
+
+  public bufferClearOpacity(buffer: Pointer): void {
+    this.opentui.symbols.bufferClearOpacity(buffer)
+  }
+
+  public getTerminalCapabilities(renderer: Pointer) {
+    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,
+      },
+    }
+  }
+
+  public processCapabilityResponse(renderer: Pointer, response: string): void {
+    const responseBytes = this.encoder.encode(response)
+    this.opentui.symbols.processCapabilityResponse(renderer, responseBytes, responseBytes.length)
+  }
+
+  public encodeUnicode(
+    text: string,
+    widthMethod: WidthMethod,
+  ): { ptr: Pointer; data: Array<{ width: number; char: number }> } | null {
+    const textBytes = this.encoder.encode(text)
+    const widthMethodCode = widthMethod === "wcwidth" ? 0 : 1
+
+    const outPtrBuffer = new ArrayBuffer(8) // Pointer size
+    const outLenBuffer = new ArrayBuffer(8) // usize
+
+    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]) as Pointer
+    const resultLen = Number(outLenView[0])
+
+    if (resultLen === 0) {
+      return { ptr: resultPtr, data: [] }
+    }
+
+    // Convert pointer to ArrayBuffer and use EncodedCharStruct to unpack the list
+    const byteLen = resultLen * EncodedCharStruct.size
+    const raw = toArrayBuffer(resultPtr, 0, byteLen)
+    const data = EncodedCharStruct.unpackList(raw, resultLen)
+
+    return { ptr: resultPtr, data }
+  }
+
+  public freeUnicode(encoded: { ptr: Pointer; data: Array<{ width: number; char: number }> }): void {
+    this.opentui.symbols.freeUnicode(encoded.ptr, encoded.data.length)
+  }
+
+  public bufferDrawChar(
+    buffer: Pointer,
+    char: number,
+    x: number,
+    y: number,
+    fg: RGBA,
+    bg: RGBA,
+    attributes: number = 0,
+  ): void {
+    this.opentui.symbols.bufferDrawChar(buffer, char, x, y, fg.buffer, bg.buffer, attributes)
+  }
+
+  public registerNativeSpanFeedStream(stream: Pointer, handler: NativeSpanFeedEventHandler): void {
+    const callback = this.ensureNativeSpanFeedCallback()
+    this.nativeSpanFeedHandlers.set(toPointer(stream), handler)
+    this.opentui.symbols.streamSetCallback(stream, callback.ptr)
+  }
+
+  public unregisterNativeSpanFeedStream(stream: Pointer): void {
+    this.opentui.symbols.streamSetCallback(stream, null)
+    this.nativeSpanFeedHandlers.delete(toPointer(stream))
+  }
+
+  public createNativeSpanFeed(options?: NativeSpanFeedOptions | null): Pointer {
+    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)
+  }
+
+  public attachNativeSpanFeed(stream: Pointer): number {
+    return this.opentui.symbols.attachNativeSpanFeed(stream)
+  }
+
+  public destroyNativeSpanFeed(stream: Pointer): void {
+    this.opentui.symbols.destroyNativeSpanFeed(stream)
+    this.nativeSpanFeedHandlers.delete(toPointer(stream))
+  }
+
+  public streamWrite(stream: Pointer, data: Uint8Array | string): number {
+    const bytes = typeof data === "string" ? this.encoder.encode(data) : data
+    return this.opentui.symbols.streamWrite(stream, ptr(bytes), bytes.length)
+  }
+
+  public streamCommit(stream: Pointer): number {
+    return this.opentui.symbols.streamCommit(stream)
+  }
+
+  public streamDrainSpans(stream: Pointer, outBuffer: Uint8Array, maxSpans: number): number {
+    const count = this.opentui.symbols.streamDrainSpans(stream, ptr(outBuffer), maxSpans)
+    return toNumber(count)
+  }
+
+  public streamClose(stream: Pointer): number {
+    return this.opentui.symbols.streamClose(stream)
+  }
+
+  public streamSetOptions(stream: Pointer, options: NativeSpanFeedOptions): number {
+    const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options)
+    return this.opentui.symbols.streamSetOptions(stream, ptr(optionsBuffer))
+  }
+
+  public streamGetStats(stream: Pointer): NativeSpanFeedStats | null {
+    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,
+    }
+  }
+
+  public streamReserve(stream: Pointer, minLen: number): { status: number; info: ReserveInfo | null } {
+    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) }
+  }
+
+  public streamCommitReserved(stream: Pointer, length: number): number {
+    return this.opentui.symbols.streamCommitReserved(stream, length)
+  }
+
+  public createSyntaxStyle(): Pointer {
+    const stylePtr = this.opentui.symbols.createSyntaxStyle()
+    if (!stylePtr) {
+      throw new Error("Failed to create SyntaxStyle")
+    }
+    return stylePtr
+  }
+
+  public destroySyntaxStyle(style: Pointer): void {
+    this.opentui.symbols.destroySyntaxStyle(style)
+  }
+
+  public syntaxStyleRegister(
+    style: Pointer,
+    name: string,
+    fg: RGBA | null,
+    bg: RGBA | null,
+    attributes: number,
+  ): number {
+    const nameBytes = this.encoder.encode(name)
+    const fgPtr = fg ? fg.buffer : null
+    const bgPtr = bg ? bg.buffer : null
+    return this.opentui.symbols.syntaxStyleRegister(style, nameBytes, nameBytes.length, fgPtr, bgPtr, attributes)
+  }
+
+  public syntaxStyleResolveByName(style: Pointer, name: string): number | null {
+    const nameBytes = this.encoder.encode(name)
+    const id = this.opentui.symbols.syntaxStyleResolveByName(style, nameBytes, nameBytes.length)
+    return id === 0 ? null : id
+  }
+
+  public syntaxStyleGetStyleCount(style: Pointer): number {
+    const result = this.opentui.symbols.syntaxStyleGetStyleCount(style)
+    return typeof result === "bigint" ? Number(result) : result
+  }
+
+  public editorViewSetPlaceholderStyledText(
+    view: Pointer,
+    chunks: Array<{ text: string; fg?: RGBA | null; bg?: RGBA | null; attributes?: number }>,
+  ): void {
+    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)
+  }
+
+  public editorViewSetTabIndicator(view: Pointer, indicator: number): void {
+    this.opentui.symbols.editorViewSetTabIndicator(view, indicator)
+  }
+
+  public editorViewSetTabIndicatorColor(view: Pointer, color: RGBA): void {
+    this.opentui.symbols.editorViewSetTabIndicatorColor(view, color.buffer)
+  }
+
+  public onNativeEvent(name: string, handler: (data: ArrayBuffer) => void): void {
+    this._nativeEvents.on(name, handler)
+  }
+
+  public onceNativeEvent(name: string, handler: (data: ArrayBuffer) => void): void {
+    this._nativeEvents.once(name, handler)
+  }
+
+  public offNativeEvent(name: string, handler: (data: ArrayBuffer) => void): void {
+    this._nativeEvents.off(name, handler)
+  }
+
+  public onAnyNativeEvent(handler: (name: string, data: ArrayBuffer) => void): void {
+    this._anyEventHandlers.push(handler)
+  }
+}
+
+let opentuiLibPath: string | undefined
+let opentuiLib: RenderLib | undefined
+
+export function setRenderLibPath(libPath: string) {
+  if (opentuiLibPath !== libPath) {
+    opentuiLibPath = libPath
+    opentuiLib = undefined
+  }
+}
+
+export function resolveRenderLib(): RenderLib {
+  if (!opentuiLib) {
+    try {
+      opentuiLib = new FFIRenderLib(opentuiLibPath)
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize OpenTUI render library: ${error instanceof Error ? error.message : "Unknown error"}`,
+      )
+    }
+  }
+  return opentuiLib
+}
+
+// Try eager loading
+try {
+  opentuiLib = new FFIRenderLib(opentuiLibPath)
+} catch (error) {}