@xincli/opentui-core 0.4.6

package/src/zig/lib.zig

@@ -0,0 +1,2813 @@
+const std = @import("std");
+const build_options = @import("build_options");
+const Allocator = std.mem.Allocator;
+
+const ansi = @import("ansi.zig");
+const buffer = @import("buffer.zig");
+const renderer = @import("renderer.zig");
+const gp = @import("grapheme.zig");
+const link = @import("link.zig");
+const text_buffer = @import("text-buffer.zig");
+const text_buffer_view = @import("text-buffer-view.zig");
+const text_buffer_iterators = @import("text-buffer-iterators.zig");
+const edit_buffer_mod = @import("edit-buffer.zig");
+const editor_view = @import("editor-view.zig");
+const syntax_style = @import("syntax-style.zig");
+const terminal = @import("terminal.zig");
+const utf8 = @import("utf8.zig");
+const logger = @import("logger.zig");
+const event_bus = @import("event-bus.zig");
+const native_span_feed = @import("native-span-feed.zig");
+const native_audio = @import("audio.zig");
+const native_renderable = @import("native-renderable.zig");
+const buffer_effects = @import("buffer-methods.zig");
+const handles = @import("handles.zig");
+const native_yoga = @import("yoga.zig");
+
+pub const OptimizedBuffer = buffer.OptimizedBuffer;
+pub const CliRenderer = renderer.CliRenderer;
+pub const Terminal = terminal.Terminal;
+pub const RGBA = buffer.RGBA;
+pub const NativeHandle = handles.Handle;
+
+const INVALID_HANDLE: NativeHandle = 0;
+const EMPTY_U8 = [_]u8{0};
+const EMPTY_U32 = [_]u32{0};
+
+fn ptrToRGBA(color: [*]const u16) RGBA {
+    return .{ color[0], color[1], color[2], color[3] };
+}
+
+fn optionalPtrToRGBA(color: ?[*]const u16) ?RGBA {
+    if (color) |packed_color| {
+        return ptrToRGBA(packed_color);
+    }
+
+    return null;
+}
+
+fn erasePtr(ptr_value: anytype) *anyopaque {
+    return @ptrCast(ptr_value);
+}
+
+fn acquireRenderer(handle: NativeHandle) ?*renderer.CliRenderer {
+    return handles.acquire(handle, .renderer, renderer.CliRenderer);
+}
+
+fn acquireBuffer(handle: NativeHandle) ?*buffer.OptimizedBuffer {
+    return handles.acquire(handle, .optimized_buffer, buffer.OptimizedBuffer);
+}
+
+fn acquireTextBuffer(handle: NativeHandle) ?*text_buffer.UnifiedTextBuffer {
+    return handles.acquire(handle, .text_buffer, text_buffer.UnifiedTextBuffer);
+}
+
+fn acquireTextBufferView(handle: NativeHandle) ?*text_buffer_view.UnifiedTextBufferView {
+    return handles.acquire(handle, .text_buffer_view, text_buffer_view.UnifiedTextBufferView);
+}
+
+fn acquireEditBuffer(handle: NativeHandle) ?*edit_buffer_mod.EditBuffer {
+    return handles.acquire(handle, .edit_buffer, edit_buffer_mod.EditBuffer);
+}
+
+fn acquireEditorView(handle: NativeHandle) ?*editor_view.EditorView {
+    return handles.acquire(handle, .editor_view, editor_view.EditorView);
+}
+
+fn acquireSyntaxStyle(handle: NativeHandle) ?*syntax_style.SyntaxStyle {
+    return handles.acquire(handle, .syntax_style, syntax_style.SyntaxStyle);
+}
+
+fn acquireEventSink(handle: NativeHandle) ?*event_bus.EventSink {
+    return handles.acquire(handle, .event_sink, event_bus.EventSink);
+}
+
+fn acquireAudioEngine(handle: NativeHandle) ?*native_audio.Engine {
+    return handles.acquire(handle, .audio_engine, native_audio.Engine);
+}
+
+fn acquireNativeRenderable(handle: NativeHandle) ?*native_renderable.NativeRenderable {
+    return handles.acquire(handle, .native_renderable, native_renderable.NativeRenderable);
+}
+
+fn emptyLineInfo(outPtr: *ExternalLineInfo) void {
+    outPtr.* = .{
+        .start_cols_ptr = EMPTY_U32[0..].ptr,
+        .start_cols_len = 0,
+        .width_cols_ptr = EMPTY_U32[0..].ptr,
+        .width_cols_len = 0,
+        .sources_ptr = EMPTY_U32[0..].ptr,
+        .sources_len = 0,
+        .wraps_ptr = EMPTY_U32[0..].ptr,
+        .wraps_len = 0,
+        .width_cols_max = 0,
+    };
+}
+
+fn sliceFromPtrLen(ptr: ?[*]const u8, len: u32) []const u8 {
+    if (len == 0) {
+        return "";
+    }
+
+    return ptr.?[0..@as(usize, len)];
+}
+
+inline fn selectionStyle(bg: ?RGBA, fg: ?RGBA) text_buffer_view.SelectionStyle {
+    return .{
+        .bgColor = bg,
+        .fgColor = fg,
+    };
+}
+
+comptime {
+    _ = native_span_feed;
+    _ = native_audio;
+    _ = native_renderable;
+    _ = native_yoga;
+}
+
+export fn setLogCallback(callback: ?*const fn (level: u8, msgPtr: [*]const u8, msgLen: u32) callconv(.c) void) void {
+    logger.setLogCallback(callback);
+}
+
+export fn createEventSink(callback: ?event_bus.EventCallback) NativeHandle {
+    const sink = event_bus.createEventSink(globalAllocator, callback orelse return INVALID_HANDLE) catch return INVALID_HANDLE;
+    return handles.insert(.event_sink, erasePtr(sink)) catch {
+        event_bus.destroyEventSink(globalAllocator, sink);
+        return INVALID_HANDLE;
+    };
+}
+
+fn clearEditBufferEventSinkRefs(sink: *event_bus.EventSink) void {
+    var cursor: usize = 1;
+    while (handles.nextByKind(.edit_buffer, &cursor)) |edit_handle| {
+        const token = handles.pause(edit_handle, .edit_buffer, edit_buffer_mod.EditBuffer) orelse continue;
+        if (token.ptr.event_sink == sink) {
+            token.ptr.event_sink = null;
+        }
+        handles.unpause(token.handle);
+    }
+}
+
+export fn createNativeRenderable() NativeHandle {
+    const renderable = globalAllocator.create(native_renderable.NativeRenderable) catch return INVALID_HANDLE;
+    renderable.* = .{};
+    return handles.insert(.native_renderable, erasePtr(renderable)) catch {
+        globalAllocator.destroy(renderable);
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroyNativeRenderable(native_renderable_handle: NativeHandle) void {
+    const token = handles.beginDestroy(native_renderable_handle, .native_renderable, native_renderable.NativeRenderable) orelse return;
+    token.ptr.deinit();
+    globalAllocator.destroy(token.ptr);
+    handles.finishDestroy(token.handle);
+}
+
+export fn nativeRenderableAttachYogaNode(native_renderable_handle: NativeHandle, node: native_yoga.YGNodeRef) bool {
+    // Temporary bridge: JS-created Renderables still own Yoga nodes, so native
+    // renderables borrow and attach them after construction. This should go away
+    // when the renderable tree and Yoga ownership move native-side.
+    const renderable = acquireNativeRenderable(native_renderable_handle) orelse return false;
+    if (node == null) return false;
+    renderable.attachYogaNode(node);
+    return true;
+}
+
+export fn nativeRenderableSetMeasureTarget(
+    native_renderable_handle: NativeHandle,
+    kind: u32,
+    target_handle: NativeHandle,
+) bool {
+    const renderable = acquireNativeRenderable(native_renderable_handle) orelse return false;
+
+    // Resolve handles once at setup time. The Yoga measure callback then uses raw
+    // native pointers and does not pay handle-registry lookup cost on the hot path.
+    // Kind `none` clears the measure target; unknown kinds are rejected.
+    const measure_kind: native_renderable.MeasureTargetKind = switch (kind) {
+        @intFromEnum(native_renderable.MeasureTargetKind.none) => .none,
+        @intFromEnum(native_renderable.MeasureTargetKind.text_buffer_view) => .text_buffer_view,
+        @intFromEnum(native_renderable.MeasureTargetKind.editor_view) => .editor_view,
+        else => return false,
+    };
+
+    const target: native_renderable.MeasureTarget = switch (measure_kind) {
+        .none => .none,
+        .text_buffer_view => .{ .text_buffer_view = acquireTextBufferView(target_handle) orelse return false },
+        .editor_view => .{ .editor_view = acquireEditorView(target_handle) orelse return false },
+    };
+
+    renderable.setMeasureTarget(target);
+    return true;
+}
+
+export fn destroyEventSink(sink_handle: NativeHandle) void {
+    const token = handles.beginDestroy(sink_handle, .event_sink, event_bus.EventSink) orelse return;
+    clearEditBufferEventSinkRefs(token.ptr);
+    event_bus.destroyEventSink(globalAllocator, token.ptr);
+    handles.finishDestroy(token.handle);
+}
+
+var gpa: std.heap.GeneralPurposeAllocator(.{
+    .enable_memory_limit = build_options.gpa_safe_stats,
+    .safety = build_options.gpa_safe_stats,
+}) = .{};
+const globalAllocator = gpa.allocator();
+var arena = std.heap.ArenaAllocator.init(globalAllocator);
+const globalArena = arena.allocator();
+
+pub const ExternalBuildOptions = extern struct {
+    gpa_safe_stats: bool,
+    gpa_memory_limit_tracking: bool,
+};
+
+pub const ExternalAllocatorStats = extern struct {
+    total_requested_bytes: u64,
+    active_allocations: u64,
+    small_allocations: u64,
+    large_allocations: u64,
+    requested_bytes_valid: bool,
+};
+
+pub const ExternalRenderStats = extern struct {
+    last_frame_time: f64,
+    average_frame_time: f64,
+    render_time: f64,
+    // ABI names keep stdout terminology for compatibility; the value is the
+    // backend output write time for stdout, memory, or feed output.
+    stdout_write_time: f64,
+    frame_count: u64,
+    cells_updated: u32,
+    average_cells_updated: u32,
+    render_time_valid: bool,
+    stdout_write_time_valid: bool,
+};
+
+fn toNonNegativeU64(value: anytype) u64 {
+    const ValueType = @TypeOf(value);
+
+    return switch (@typeInfo(ValueType)) {
+        .int => |int_info| if (int_info.signedness == .signed) blk: {
+            const signed_value: i64 = @intCast(value);
+            if (signed_value <= 0) break :blk 0;
+            break :blk @intCast(signed_value);
+        } else @intCast(value),
+        .comptime_int => blk: {
+            if (value <= 0) break :blk 0;
+            break :blk @intCast(value);
+        },
+        else => 0,
+    };
+}
+
+const RequestedBytesInfo = struct {
+    bytes: u64,
+    valid: bool,
+};
+
+fn sanitizeRequestedBytes(value: u64) RequestedBytesInfo {
+    const signed_value: i64 = @bitCast(value);
+    if (signed_value < 0) {
+        return .{ .bytes = 0, .valid = false };
+    }
+
+    return .{ .bytes = @intCast(signed_value), .valid = true };
+}
+
+fn queryStatsField(comptime field_names: []const []const u8) ?u64 {
+    if (!@hasDecl(@TypeOf(gpa), "queryStats")) {
+        return null;
+    }
+
+    const stats = gpa.queryStats();
+    const StatsType = @TypeOf(stats);
+
+    inline for (field_names) |field_name| {
+        if (@hasField(StatsType, field_name)) {
+            return toNonNegativeU64(@field(stats, field_name));
+        }
+    }
+
+    return null;
+}
+
+fn getTotalRequestedBytesInfo() RequestedBytesInfo {
+    if (!build_options.gpa_safe_stats) {
+        return .{ .bytes = 0, .valid = false };
+    }
+
+    if (queryStatsField(&.{"total_requested_bytes"})) |value| {
+        return sanitizeRequestedBytes(value);
+    }
+
+    if (@hasField(@TypeOf(gpa), "total_requested_bytes")) {
+        if (@TypeOf(gpa.total_requested_bytes) == void) {
+            return .{ .bytes = 0, .valid = false };
+        }
+
+        return sanitizeRequestedBytes(toNonNegativeU64(gpa.total_requested_bytes));
+    }
+
+    return .{ .bytes = 0, .valid = false };
+}
+
+fn getSmallAllocationCount() u64 {
+    if (queryStatsField(&.{ "small_allocations", "small_allocation_count" })) |value| {
+        return value;
+    }
+
+    var total: u64 = 0;
+    for (gpa.buckets) |bucket_head| {
+        var current = bucket_head;
+        while (current) |bucket| {
+            const allocated: u64 = @intCast(bucket.allocated_count);
+            const freed: u64 = @intCast(bucket.freed_count);
+            if (allocated >= freed) {
+                total += allocated - freed;
+            }
+            current = bucket.next;
+        }
+    }
+
+    return total;
+}
+
+fn getLargeAllocationCount() u64 {
+    if (queryStatsField(&.{ "large_allocations", "large_allocation_count" })) |value| {
+        return value;
+    }
+
+    return @intCast(gpa.large_allocations.count());
+}
+
+export fn createNativeSpanFeed(options_ptr: ?*const native_span_feed.Options) ?*native_span_feed.Stream {
+    return native_span_feed.createNativeSpanFeedWithAllocator(globalAllocator, options_ptr);
+}
+
+export fn createAudioEngine(options_ptr: ?*const native_audio.CreateOptions) NativeHandle {
+    const engine = native_audio.create(globalAllocator, options_ptr) orelse return INVALID_HANDLE;
+    return handles.insert(.audio_engine, erasePtr(engine)) catch {
+        native_audio.destroy(engine);
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroyAudioEngine(engine_handle: NativeHandle) void {
+    const token = handles.beginDestroy(engine_handle, .audio_engine, native_audio.Engine) orelse return;
+    native_audio.destroy(token.ptr);
+    handles.finishDestroy(token.handle);
+}
+
+export fn audioRefreshPlaybackDevices(engine_handle: NativeHandle) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.refreshPlaybackDevices(object_ptr);
+}
+
+export fn audioGetPlaybackDeviceCount(engine_handle: NativeHandle) u32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return 0;
+    return native_audio.getPlaybackDeviceCount(object_ptr);
+}
+
+export fn audioGetPlaybackDeviceName(engine_handle: NativeHandle, index: u32, out_ptr: [*]u8, max_len: u32) u32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return 0;
+    return @intCast(native_audio.getPlaybackDeviceName(object_ptr, index, out_ptr, @as(usize, max_len)));
+}
+
+export fn audioIsPlaybackDeviceDefault(engine_handle: NativeHandle, index: u32) bool {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return false;
+    return native_audio.isPlaybackDeviceDefault(object_ptr, index);
+}
+
+export fn audioSelectPlaybackDevice(engine_handle: NativeHandle, index: u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.selectPlaybackDevice(object_ptr, index);
+}
+
+export fn audioClearPlaybackDeviceSelection(engine_handle: NativeHandle) void {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return;
+    native_audio.clearPlaybackDeviceSelection(object_ptr);
+}
+
+export fn audioStart(engine_handle: NativeHandle, options_ptr: ?*const native_audio.StartOptions) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.start(object_ptr, options_ptr);
+}
+
+export fn audioStartMixer(engine_handle: NativeHandle) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.startMixer(object_ptr);
+}
+
+export fn audioStop(engine_handle: NativeHandle) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.stop(object_ptr);
+}
+
+export fn audioLoad(engine_handle: NativeHandle, data_ptr: ?[*]const u8, data_len: u32, out_sound_id: ?*u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.load(object_ptr, data_ptr, @as(usize, data_len), out_sound_id);
+}
+
+export fn audioUnload(engine_handle: NativeHandle, sound_id: u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.unload(object_ptr, sound_id);
+}
+
+export fn audioPlay(engine_handle: NativeHandle, sound_id: u32, options_ptr: ?*const native_audio.VoiceOptions, out_voice_id: ?*u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.play(object_ptr, sound_id, options_ptr, out_voice_id);
+}
+
+export fn audioStopVoice(engine_handle: NativeHandle, voice_id: u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.stopVoice(object_ptr, voice_id);
+}
+
+export fn audioSetVoiceGroup(engine_handle: NativeHandle, voice_id: u32, group_id: u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.setVoiceGroup(object_ptr, voice_id, group_id);
+}
+
+export fn audioCreateGroup(engine_handle: NativeHandle, name_ptr: ?[*]const u8, name_len: u32, out_group_id: ?*u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.createGroup(object_ptr, name_ptr, @as(usize, name_len), out_group_id);
+}
+
+export fn audioSetGroupVolume(engine_handle: NativeHandle, group_id: u32, volume: f32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.setGroupVolume(object_ptr, group_id, volume);
+}
+
+export fn audioSetMasterVolume(engine_handle: NativeHandle, volume: f32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.setMasterVolume(object_ptr, volume);
+}
+
+export fn audioMixToBuffer(engine_handle: NativeHandle, out_ptr: ?[*]f32, frame_count: u32, channels: u8) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.mixToBuffer(object_ptr, out_ptr, frame_count, channels);
+}
+
+export fn audioEnableTap(engine_handle: NativeHandle, enabled: bool, capacity_frames: u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.enableTap(object_ptr, enabled, capacity_frames);
+}
+
+export fn audioReadTap(engine_handle: NativeHandle, out_ptr: ?[*]f32, frame_count: u32, channels: u8, out_frames_read: ?*u32) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.readTap(object_ptr, out_ptr, frame_count, channels, out_frames_read);
+}
+
+export fn audioGetStats(engine_handle: NativeHandle, out_stats: ?*native_audio.Stats) i32 {
+    const object_ptr = acquireAudioEngine(engine_handle) orelse return native_audio.Status.err_invalid;
+    return native_audio.getStats(object_ptr, out_stats);
+}
+
+export fn getArenaAllocatedBytes() u64 {
+    return @intCast(arena.queryCapacity());
+}
+
+export fn getBuildOptions(out_ptr: *ExternalBuildOptions) void {
+    out_ptr.* = .{
+        .gpa_safe_stats = build_options.gpa_safe_stats,
+        .gpa_memory_limit_tracking = build_options.gpa_safe_stats,
+    };
+}
+
+export fn getAllocatorStats(out_ptr: *ExternalAllocatorStats) void {
+    const small_allocations = getSmallAllocationCount();
+    const large_allocations = getLargeAllocationCount();
+    const active_allocations = small_allocations + large_allocations;
+    const requested_bytes = getTotalRequestedBytesInfo();
+
+    out_ptr.* = .{
+        .total_requested_bytes = requested_bytes.bytes,
+        .active_allocations = active_allocations,
+        .small_allocations = small_allocations,
+        .large_allocations = large_allocations,
+        .requested_bytes_valid = requested_bytes.valid,
+    };
+}
+
+/// Create a renderer.
+///
+/// Output transport selection:
+///   - `feedPtr != null`: writes go to the provided NativeSpanFeed stream
+///     (FeedBackend), which the TS side pipes onward to a user-supplied Writable
+///   - `feedPtr == null`: writes go through a buffered backend selected by
+///     `bufferedDestinationKind` (0 = process stdout, 1 = memory)
+///
+/// `remoteModeValue` is 0 = auto, 1 = local, 2 = remote. The TS side decides
+/// the appropriate default for process stdout, memory output, and feed output.
+fn registerRendererBufferHandles(renderer_handle: NativeHandle, rendererPtr: *renderer.CliRenderer) bool {
+    _ = handles.getOrInsertBorrowed(.optimized_buffer, erasePtr(rendererPtr.getCurrentBuffer()), renderer_handle) catch return false;
+    _ = handles.getOrInsertBorrowed(.optimized_buffer, erasePtr(rendererPtr.getNextBuffer()), renderer_handle) catch return false;
+    return true;
+}
+
+export fn createRenderer(
+    width: u32,
+    height: u32,
+    bufferedDestinationKind: u8,
+    remoteModeValue: u8,
+    feedPtr: ?*native_span_feed.Stream,
+) NativeHandle {
+    if (width == 0 or height == 0) {
+        logger.warn("Invalid renderer dimensions: {}x{}", .{ width, height });
+        return INVALID_HANDLE;
+    }
+
+    const remote_mode: terminal.Terminal.RemoteMode = switch (remoteModeValue) {
+        0 => .auto,
+        1 => .local,
+        2 => .remote,
+        else => .local,
+    };
+
+    const pool = gp.initGlobalPool(globalArena);
+    _ = link.initGlobalLinkPool(globalArena);
+    const output_target: renderer.CliRenderer.OutputTarget = if (feedPtr) |feed|
+        .{ .feed = feed }
+    else switch (bufferedDestinationKind) {
+        0 => .stdout,
+        1 => .memory,
+        else => {
+            logger.warn("Invalid buffered destination kind: {}", .{bufferedDestinationKind});
+            return INVALID_HANDLE;
+        },
+    };
+
+    const rendererPtr = renderer.CliRenderer.createWithOptions(globalAllocator, width, height, pool, .{
+        .remote_mode = remote_mode,
+        .output = output_target,
+    }) catch |err| {
+        logger.err("Failed to create renderer: {}", .{err});
+        return INVALID_HANDLE;
+    };
+
+    const renderer_handle = handles.insert(.renderer, erasePtr(rendererPtr)) catch {
+        rendererPtr.destroy();
+        return INVALID_HANDLE;
+    };
+    if (!registerRendererBufferHandles(renderer_handle, rendererPtr)) {
+        if (handles.beginDestroy(renderer_handle, .renderer, renderer.CliRenderer)) |token| {
+            handles.invalidateChildren(token.handle);
+            rendererPtr.destroy();
+            handles.finishDestroy(token.handle);
+        }
+        return INVALID_HANDLE;
+    }
+
+    return renderer_handle;
+}
+
+export fn setTerminalEnvVar(renderer_handle: NativeHandle, keyPtr: ?[*]const u8, keyLen: u32, valuePtr: ?[*]const u8, valueLen: u32) bool {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return false;
+    const key = sliceFromPtrLen(keyPtr, keyLen);
+    const value = sliceFromPtrLen(valuePtr, valueLen);
+    return object_ptr.setTerminalEnvVar(key, value);
+}
+
+export fn setUseThread(renderer_handle: NativeHandle, useThread: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setUseThread(useThread);
+}
+
+export fn setClearOnShutdown(renderer_handle: NativeHandle, clear: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setClearOnShutdown(clear);
+}
+
+export fn destroyRenderer(renderer_handle: NativeHandle) void {
+    const token = handles.beginDestroy(renderer_handle, .renderer, renderer.CliRenderer) orelse return;
+    handles.invalidateChildren(token.handle);
+    token.ptr.destroy();
+    handles.finishDestroy(token.handle);
+}
+
+export fn setBackgroundColor(renderer_handle: NativeHandle, color: [*]const u16) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setBackgroundColor(ptrToRGBA(color));
+}
+
+export fn setRenderOffset(renderer_handle: NativeHandle, offset: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setRenderOffset(offset);
+}
+
+export fn resetSplitScrollback(renderer_handle: NativeHandle, seedRows: u32, pinnedRenderOffset: u32) u32 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return 0;
+    return object_ptr.resetSplitScrollback(seedRows, pinnedRenderOffset);
+}
+
+export fn syncSplitScrollback(renderer_handle: NativeHandle, pinnedRenderOffset: u32) u32 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return 0;
+    return object_ptr.syncSplitScrollback(pinnedRenderOffset);
+}
+
+export fn getSplitOutputOffset(renderer_handle: NativeHandle, surfaceOffset: u32) u32 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return 0;
+    return object_ptr.getSplitOutputOffset(surfaceOffset);
+}
+
+export fn setPendingSplitFooterTransition(
+    renderer_handle: NativeHandle,
+    mode: u8,
+    sourceTopLine: u32,
+    sourceHeight: u32,
+    targetTopLine: u32,
+    targetHeight: u32,
+    scrollLines: u32,
+) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setPendingSplitFooterTransition(
+        @enumFromInt(mode),
+        sourceTopLine,
+        sourceHeight,
+        targetTopLine,
+        targetHeight,
+        scrollLines,
+    );
+}
+
+export fn clearPendingSplitFooterTransition(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.clearPendingSplitFooterTransition();
+}
+
+export fn updateStats(renderer_handle: NativeHandle, time: f64, fps: u32, frameCallbackTime: f64) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.updateStats(time, fps, frameCallbackTime);
+}
+
+export fn updateMemoryStats(renderer_handle: NativeHandle, heapUsed: u32, heapTotal: u32, arrayBuffers: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.updateMemoryStats(heapUsed, heapTotal, arrayBuffers);
+}
+
+export fn getRenderStats(renderer_handle: NativeHandle, outPtr: *ExternalRenderStats) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalRenderStats);
+        return;
+    };
+    const stats = object_ptr.getRenderStats();
+
+    outPtr.* = .{
+        .last_frame_time = stats.lastFrameTime,
+        .average_frame_time = stats.averageFrameTime,
+        .render_time = stats.renderTime orelse 0,
+        .stdout_write_time = stats.outputWriteTime orelse 0,
+        .frame_count = stats.frameCount,
+        .cells_updated = stats.cellsUpdated,
+        .average_cells_updated = stats.averageCellsUpdated,
+        .render_time_valid = stats.renderTime != null,
+        .stdout_write_time_valid = stats.outputWriteTime != null,
+    };
+}
+
+export fn getNextBuffer(renderer_handle: NativeHandle) NativeHandle {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return INVALID_HANDLE;
+    return handles.getOrInsertBorrowed(.optimized_buffer, erasePtr(object_ptr.getNextBuffer()), renderer_handle) catch INVALID_HANDLE;
+}
+
+export fn getCurrentBuffer(renderer_handle: NativeHandle) NativeHandle {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return INVALID_HANDLE;
+    return handles.getOrInsertBorrowed(.optimized_buffer, erasePtr(object_ptr.getCurrentBuffer()), renderer_handle) catch INVALID_HANDLE;
+}
+
+export fn setHyperlinksCapability(renderer_handle: NativeHandle, enabled: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.terminal.caps.hyperlinks = enabled;
+}
+
+export fn clearGlobalLinkPool() void {
+    link.deinitGlobalLinkPool();
+}
+
+export fn getBufferWidth(buffer_handle: NativeHandle) u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 0;
+    return object_ptr.width;
+}
+
+export fn getBufferHeight(buffer_handle: NativeHandle) u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 0;
+    return object_ptr.height;
+}
+
+fn packRenderResult(result: renderer.RenderResult) u64 {
+    return @as(u64, result.renderOffset) | (@as(u64, @intFromEnum(result.status)) << 32);
+}
+
+fn packFailedRenderResult() u64 {
+    return packRenderResult(.{ .renderOffset = 0, .status = .failed });
+}
+
+export fn render(renderer_handle: NativeHandle, force: bool) u8 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return @intFromEnum(renderer.RenderStatus.failed);
+    return @intFromEnum(object_ptr.render(force));
+}
+
+export fn repaintSplitFooter(
+    renderer_handle: NativeHandle,
+    pinnedRenderOffset: u32,
+    force: bool,
+) u64 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return packFailedRenderResult();
+    return packRenderResult(object_ptr.repaintSplitFooter(pinnedRenderOffset, force));
+}
+
+export fn commitSplitFooterSnapshot(
+    renderer_handle: NativeHandle,
+    snapshot_buffer_handle: NativeHandle,
+    rowColumns: u32,
+    startOnNewLine: bool,
+    trailingNewline: bool,
+    pinnedRenderOffset: u32,
+    force: bool,
+    beginFrame: bool,
+    finalizeFrame: bool,
+) u64 {
+    const renderer_ptr = acquireRenderer(renderer_handle) orelse return packFailedRenderResult();
+    const snapshot_ptr = acquireBuffer(snapshot_buffer_handle) orelse return packFailedRenderResult();
+
+    // JS passes rowColumns/startOnNewLine/trailingNewline per commit from
+    // writeToScrollback or captured stdout chunking. This entrypoint is the ABI
+    // boundary where that metadata enters the native split append algorithm.
+    // Route all commits through the batched renderer path so sync/cursor framing
+    // happens exactly once per JS flush cycle.
+    if (beginFrame and finalizeFrame) {
+        return packRenderResult(renderer_ptr.commitSplitFooterSnapshotBatched(
+            snapshot_ptr,
+            rowColumns,
+            startOnNewLine,
+            trailingNewline,
+            pinnedRenderOffset,
+            force,
+            true,
+            true,
+        ));
+    }
+
+    return packRenderResult(renderer_ptr.commitSplitFooterSnapshotBatched(
+        snapshot_ptr,
+        rowColumns,
+        startOnNewLine,
+        trailingNewline,
+        pinnedRenderOffset,
+        force,
+        beginFrame,
+        finalizeFrame,
+    ));
+}
+
+export fn createOptimizedBuffer(width: u32, height: u32, respectAlpha: bool, widthMethod: u8, idPtr: ?[*]const u8, idLen: u32) NativeHandle {
+    if (width == 0 or height == 0) {
+        logger.warn("Invalid buffer dimensions: {}x{}", .{ width, height });
+        return INVALID_HANDLE;
+    }
+
+    const pool = gp.initGlobalPool(globalArena);
+    const link_pool = link.initGlobalLinkPool(globalArena);
+    const wMethod: utf8.WidthMethod = if (widthMethod == 0) .wcwidth else .unicode;
+    const id = sliceFromPtrLen(idPtr, idLen);
+
+    const bufferPtr = buffer.OptimizedBuffer.init(globalAllocator, width, height, .{
+        .respectAlpha = respectAlpha,
+        .pool = pool,
+        .width_method = wMethod,
+        .id = id,
+        .link_pool = link_pool,
+    }) catch |err| {
+        logger.err("Failed to create optimized buffer: {}", .{err});
+        return INVALID_HANDLE;
+    };
+
+    return handles.insert(.optimized_buffer, erasePtr(bufferPtr)) catch {
+        bufferPtr.deinit();
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroyOptimizedBuffer(buffer_handle: NativeHandle) void {
+    const token = handles.beginDestroy(buffer_handle, .optimized_buffer, buffer.OptimizedBuffer) orelse return;
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+export fn destroyFrameBuffer(frame_buffer_handle: NativeHandle) void {
+    destroyOptimizedBuffer(frame_buffer_handle);
+}
+
+export fn drawFrameBuffer(target_handle: NativeHandle, destX: i32, destY: i32, frame_buffer_handle: NativeHandle, sourceX: u32, sourceY: u32, sourceWidth: u32, sourceHeight: u32) void {
+    const target_ptr = acquireBuffer(target_handle) orelse return;
+    const frame_ptr = acquireBuffer(frame_buffer_handle) orelse return;
+    const srcX = if (sourceX == 0) null else sourceX;
+    const srcY = if (sourceY == 0) null else sourceY;
+    const srcWidth = if (sourceWidth == 0) null else sourceWidth;
+    const srcHeight = if (sourceHeight == 0) null else sourceHeight;
+
+    target_ptr.drawFrameBuffer(destX, destY, frame_ptr, srcX, srcY, srcWidth, srcHeight);
+}
+
+export fn setCursorPosition(renderer_handle: NativeHandle, x: i32, y: i32, visible: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.terminal.setCursorPosition(@intCast(@max(1, x)), @intCast(@max(1, y)), visible);
+}
+
+pub const ExternalCapabilities = extern struct {
+    kitty_keyboard: bool,
+    kitty_graphics: bool,
+    rgb: bool,
+    ansi256: bool,
+    unicode: u8, // 0 = wcwidth, 1 = unicode
+    sgr_pixels: bool,
+    color_scheme_updates: bool,
+    explicit_width: bool,
+    scaled_text: bool,
+    sixel: bool,
+    focus_tracking: bool,
+    sync: bool,
+    bracketed_paste: bool,
+    hyperlinks: bool,
+    osc52: bool,
+    notifications: bool,
+    explicit_cursor_positioning: bool,
+    remote: bool,
+    multiplexer: u8,
+    term_name_ptr: [*]const u8,
+    term_name_len: usize,
+    term_version_ptr: [*]const u8,
+    term_version_len: usize,
+    term_from_xtversion: bool,
+    osc52_support: u8,
+};
+
+export fn getTerminalCapabilities(renderer_handle: NativeHandle, capsPtr: *ExternalCapabilities) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse {
+        capsPtr.* = std.mem.zeroes(ExternalCapabilities);
+        capsPtr.term_name_ptr = EMPTY_U8[0..].ptr;
+        capsPtr.term_version_ptr = EMPTY_U8[0..].ptr;
+        return;
+    };
+    const caps = object_ptr.getTerminalCapabilities();
+    const term = &object_ptr.terminal;
+
+    capsPtr.* = .{
+        .kitty_keyboard = caps.kitty_keyboard,
+        .kitty_graphics = caps.kitty_graphics,
+        .rgb = caps.rgb,
+        .ansi256 = caps.ansi256,
+        .unicode = if (caps.unicode == .wcwidth) 0 else 1,
+        .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,
+        .osc52_support = @intFromEnum(term.osc52_support),
+        .notifications = caps.notifications,
+        .explicit_cursor_positioning = caps.explicit_cursor_positioning,
+        .remote = caps.remote,
+        .multiplexer = @intFromEnum(term.multiplexer),
+        .term_name_ptr = &term.term_info.name,
+        .term_name_len = term.term_info.name_len,
+        .term_version_ptr = &term.term_info.version,
+        .term_version_len = term.term_info.version_len,
+        .term_from_xtversion = term.term_info.from_xtversion,
+    };
+}
+
+export fn processCapabilityResponse(renderer_handle: NativeHandle, responsePtr: ?[*]const u8, responseLen: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    const response = sliceFromPtrLen(responsePtr, responseLen);
+    object_ptr.processCapabilityResponse(response);
+}
+
+export fn setCursorColor(renderer_handle: NativeHandle, color: [*]const u16) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.terminal.setCursorColor(ptrToRGBA(color));
+}
+
+export fn rendererSetPaletteState(
+    renderer_handle: NativeHandle,
+    palettePtr: [*]const u16,
+    paletteLen: u32,
+    defaultFgPtr: [*]const u16,
+    defaultBgPtr: [*]const u16,
+    paletteEpoch: u32,
+) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    if (paletteLen < 256) return;
+
+    var palette: [256]renderer.RGBA = undefined;
+    var index: usize = 0;
+    while (index < palette.len) : (index += 1) {
+        const base = index * 4;
+        palette[index] = .{ palettePtr[base], palettePtr[base + 1], palettePtr[base + 2], palettePtr[base + 3] };
+    }
+
+    object_ptr.setPaletteState(palette[0..], ptrToRGBA(defaultFgPtr), ptrToRGBA(defaultBgPtr), paletteEpoch);
+}
+
+pub const CursorStyleOptions = extern struct {
+    style: u8,
+    blinking: u8,
+    color: ?[*]const u16,
+    cursor: u8,
+};
+
+export fn setCursorStyleOptions(renderer_handle: NativeHandle, options: *const CursorStyleOptions) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    const current = object_ptr.terminal.getCursorStyle();
+
+    const style = if (options.style <= 3) @as(terminal.CursorStyle, @enumFromInt(options.style)) else current.style;
+    const blinking = if (options.blinking <= 1) options.blinking == 1 else current.blinking;
+
+    if (options.style <= 3 or options.blinking <= 1) {
+        object_ptr.terminal.setCursorStyle(style, blinking);
+    }
+    if (options.color) |rgba| {
+        object_ptr.terminal.setCursorColor(ptrToRGBA(rgba));
+    }
+    if (options.cursor <= 5) {
+        object_ptr.terminal.setMousePointerStyle(@enumFromInt(options.cursor));
+    }
+}
+
+pub const ExternalCursorState = extern struct {
+    x: u32,
+    y: u32,
+    visible: bool,
+    style: u8,
+    blinking: bool,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+};
+
+export fn getCursorState(renderer_handle: NativeHandle, outPtr: *ExternalCursorState) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalCursorState);
+        return;
+    };
+    const pos = object_ptr.terminal.getCursorPosition();
+    const style = object_ptr.terminal.getCursorStyle();
+    const color = object_ptr.terminal.getCursorColor();
+
+    const styleTag: u8 = switch (style.style) {
+        .block => 0,
+        .line => 1,
+        .underline => 2,
+        .default => 3,
+    };
+
+    outPtr.* = .{
+        .x = pos.x,
+        .y = pos.y,
+        .visible = pos.visible,
+        .style = styleTag,
+        .blinking = style.blinking,
+        .r = ansi.redF(color),
+        .g = ansi.greenF(color),
+        .b = ansi.blueF(color),
+        .a = ansi.alphaF(color),
+    };
+}
+
+export fn setDebugOverlay(renderer_handle: NativeHandle, enabled: bool, corner: u8) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    const cornerEnum: renderer.DebugOverlayCorner = switch (corner) {
+        0 => .topLeft,
+        1 => .topRight,
+        2 => .bottomLeft,
+        else => .bottomRight,
+    };
+
+    object_ptr.setDebugOverlay(enabled, cornerEnum);
+}
+
+export fn clearTerminal(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.clearTerminal();
+}
+
+export fn setTerminalTitle(renderer_handle: NativeHandle, titlePtr: ?[*]const u8, titleLen: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    const title = sliceFromPtrLen(titlePtr, titleLen);
+    object_ptr.setTerminalTitle(title);
+}
+
+export fn copyToClipboardOSC52(renderer_handle: NativeHandle, target: u8, text_ptr: ?[*]const u8, text_len: u32) bool {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return false;
+    const targetEnum = std.meta.intToEnum(terminal.ClipboardTarget, target) catch .clipboard;
+    const text_utf8 = sliceFromPtrLen(text_ptr, text_len);
+    return object_ptr.copyToClipboardOSC52(targetEnum, text_utf8);
+}
+
+export fn clearClipboardOSC52(renderer_handle: NativeHandle, target: u8) bool {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return false;
+    const targetEnum = std.meta.intToEnum(terminal.ClipboardTarget, target) catch .clipboard;
+    return object_ptr.clearClipboardOSC52(targetEnum);
+}
+
+export fn triggerNotification(renderer_handle: NativeHandle, messagePtr: [*]const u8, messageLen: u32, titlePtr: ?[*]const u8, titleLen: u32) bool {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return false;
+    const message = messagePtr[0..@as(usize, messageLen)];
+    const title = if (titlePtr) |ptr| ptr[0..@as(usize, titleLen)] else null;
+    return object_ptr.triggerNotification(message, title);
+}
+
+// Buffer functions
+export fn bufferClear(buffer_handle: NativeHandle, bg: [*]const u16) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.clear(ptrToRGBA(bg), null);
+}
+
+export fn bufferGetCharPtr(buffer_handle: NativeHandle) ?[*]u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return null;
+    return object_ptr.getCharPtr();
+}
+
+export fn bufferGetFgPtr(buffer_handle: NativeHandle) ?[*]RGBA {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return null;
+    return object_ptr.getFgPtr();
+}
+
+export fn bufferGetBgPtr(buffer_handle: NativeHandle) ?[*]RGBA {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return null;
+    return object_ptr.getBgPtr();
+}
+
+export fn bufferGetAttributesPtr(buffer_handle: NativeHandle) ?[*]u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return null;
+    return object_ptr.getAttributesPtr();
+}
+
+export fn bufferGetRespectAlpha(buffer_handle: NativeHandle) bool {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return false;
+    return object_ptr.getRespectAlpha();
+}
+
+export fn bufferSetRespectAlpha(buffer_handle: NativeHandle, respectAlpha: bool) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.setRespectAlpha(respectAlpha);
+}
+
+export fn bufferGetId(buffer_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const id = object_ptr.getId();
+    const copyLen = @min(id.len, @as(usize, maxLen));
+    @memcpy(out[0..copyLen], id[0..copyLen]);
+    return @intCast(copyLen);
+}
+
+export fn bufferGetRealCharSize(buffer_handle: NativeHandle) u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 0;
+    return object_ptr.getRealCharSize();
+}
+
+export fn bufferWriteResolvedChars(buffer_handle: NativeHandle, outputPtr: ?[*]u8, outputLen: u32, addLineBreaks: bool) u32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 0;
+    if (outputLen == 0) return 0;
+
+    const output = outputPtr orelse return 0;
+    const output_slice = output[0..@as(usize, outputLen)];
+    return object_ptr.writeResolvedChars(output_slice, addLineBreaks) catch 0;
+}
+
+export fn bufferDrawText(buffer_handle: NativeHandle, text: ?[*]const u8, textLen: u32, x: u32, y: u32, fg: [*]const u16, bg: ?[*]const u16, attributes: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawText(
+        sliceFromPtrLen(text, textLen),
+        x,
+        y,
+        ptrToRGBA(fg),
+        optionalPtrToRGBA(bg),
+        attributes,
+    ) catch {};
+}
+
+export fn bufferSetCellWithAlphaBlending(buffer_handle: NativeHandle, x: u32, y: u32, char: u32, fg: [*]const u16, bg: [*]const u16, attributes: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.setCellWithAlphaBlending(x, y, char, ptrToRGBA(fg), ptrToRGBA(bg), attributes);
+}
+
+export fn bufferSetCell(buffer_handle: NativeHandle, x: u32, y: u32, char: u32, fg: [*]const u16, bg: [*]const u16, attributes: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.set(x, y, .{
+        .char = char,
+        .fg = ptrToRGBA(fg),
+        .bg = ptrToRGBA(bg),
+        .attributes = attributes,
+    });
+}
+
+export fn bufferFillRect(buffer_handle: NativeHandle, x: u32, y: u32, width: u32, height: u32, bg: [*]const u16) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.fillRect(x, y, width, height, ptrToRGBA(bg));
+}
+
+export fn bufferColorMatrix(buffer_handle: NativeHandle, matrixPtr: [*]const f32, cellMaskPtr: [*]const f32, cellMaskCount: u32, strength: f32, target: u8) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    if (cellMaskCount == 0) return;
+    const matrix = matrixPtr[0..16];
+    const len = @as(usize, cellMaskCount) * 3;
+    const cellMask = cellMaskPtr[0..len];
+    const targetEnum: buffer_effects.ColorTarget = @enumFromInt(target);
+    buffer_effects.colorMatrix(object_ptr, matrix, cellMask, strength, targetEnum);
+}
+
+export fn bufferColorMatrixUniform(buffer_handle: NativeHandle, matrixPtr: [*]const f32, strength: f32, target: u8) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    const matrix = matrixPtr[0..16];
+    const targetEnum: buffer_effects.ColorTarget = @enumFromInt(target);
+    buffer_effects.colorMatrixUniform(object_ptr, matrix, strength, targetEnum);
+}
+
+export fn bufferDrawPackedBuffer(buffer_handle: NativeHandle, data: [*]const u8, dataLen: u32, posX: u32, posY: u32, terminalWidthCells: u32, terminalHeightCells: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawPackedBuffer(data, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
+}
+
+export fn bufferDrawGrayscaleBuffer(buffer_handle: NativeHandle, posX: i32, posY: i32, intensities: [*]const f32, srcWidth: u32, srcHeight: u32, fg: ?[*]const u16, bg: ?[*]const u16) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawGrayscaleBuffer(
+        posX,
+        posY,
+        intensities,
+        srcWidth,
+        srcHeight,
+        optionalPtrToRGBA(fg),
+        optionalPtrToRGBA(bg),
+    );
+}
+
+export fn bufferDrawGrayscaleBufferSupersampled(buffer_handle: NativeHandle, posX: i32, posY: i32, intensities: [*]const f32, srcWidth: u32, srcHeight: u32, fg: ?[*]const u16, bg: ?[*]const u16) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawGrayscaleBufferSupersampled(
+        posX,
+        posY,
+        intensities,
+        srcWidth,
+        srcHeight,
+        optionalPtrToRGBA(fg),
+        optionalPtrToRGBA(bg),
+    );
+}
+
+export fn bufferPushScissorRect(buffer_handle: NativeHandle, x: i32, y: i32, width: u32, height: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.pushScissorRect(x, y, width, height) catch {};
+}
+
+export fn bufferPopScissorRect(buffer_handle: NativeHandle) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.popScissorRect();
+}
+
+export fn bufferClearScissorRects(buffer_handle: NativeHandle) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.clearScissorRects();
+}
+
+// Opacity stack functions
+export fn bufferPushOpacity(buffer_handle: NativeHandle, opacity: f32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.pushOpacity(opacity) catch {};
+}
+
+export fn bufferPopOpacity(buffer_handle: NativeHandle) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.popOpacity();
+}
+
+export fn bufferGetCurrentOpacity(buffer_handle: NativeHandle) f32 {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return 1;
+    return object_ptr.getCurrentOpacity();
+}
+
+export fn bufferClearOpacity(buffer_handle: NativeHandle) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.clearOpacity();
+}
+
+export fn bufferDrawSuperSampleBuffer(buffer_handle: NativeHandle, x: u32, y: u32, pixelData: [*]const u8, len: u32, format: u8, alignedBytesPerRow: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawSuperSampleBuffer(x, y, pixelData, len, format, alignedBytesPerRow);
+}
+
+export fn linkAlloc(urlPtr: ?[*]const u8, urlLen: u32) u32 {
+    const url = sliceFromPtrLen(urlPtr, urlLen);
+    const link_pool = link.initGlobalLinkPool(globalArena);
+    return link_pool.alloc(url) catch 0;
+}
+
+export fn linkGetUrl(id: u32, outPtr: ?[*]u8, maxLen: u32) u32 {
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const link_pool = link.initGlobalLinkPool(globalArena);
+    const url_bytes = link_pool.get(id) catch return 0;
+    const copyLen = @min(url_bytes.len, @as(usize, maxLen));
+    @memcpy(out[0..copyLen], url_bytes[0..copyLen]);
+    return @intCast(copyLen);
+}
+
+export fn attributesWithLink(baseAttributes: u32, linkId: u32) u32 {
+    return ansi.TextAttributes.setLinkId(baseAttributes, linkId);
+}
+
+export fn attributesGetLinkId(attributes: u32) u32 {
+    return ansi.TextAttributes.getLinkId(attributes);
+}
+
+pub const ExternalGridDrawOptions = extern struct {
+    draw_inner: bool,
+    draw_outer: bool,
+};
+
+export fn bufferDrawGrid(
+    buffer_handle: NativeHandle,
+    borderChars: [*]const u32,
+    borderFg: [*]const u16,
+    borderBg: [*]const u16,
+    columnOffsets: [*]const i32,
+    columnCount: u32,
+    rowOffsets: [*]const i32,
+    rowCount: u32,
+    options: *const ExternalGridDrawOptions,
+) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawGrid(
+        borderChars,
+        ptrToRGBA(borderFg),
+        ptrToRGBA(borderBg),
+        columnOffsets,
+        columnCount,
+        rowOffsets,
+        rowCount,
+        options.draw_inner,
+        options.draw_outer,
+    );
+}
+
+export fn bufferDrawBox(
+    buffer_handle: NativeHandle,
+    x: i32,
+    y: i32,
+    width: u32,
+    height: u32,
+    borderChars: [*]const u32,
+    packedOptions: u32,
+    borderColor: [*]const u16,
+    backgroundColor: [*]const u16,
+    titleColor: [*]const u16,
+    title: ?[*]const u8,
+    titleLen: u32,
+    bottomTitle: ?[*]const u8,
+    bottomTitleLen: u32,
+) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    const borderSides: buffer.BorderSides = .{
+        .top = (packedOptions & 0b1000) != 0,
+        .right = (packedOptions & 0b0100) != 0,
+        .bottom = (packedOptions & 0b0010) != 0,
+        .left = (packedOptions & 0b0001) != 0,
+    };
+
+    const shouldFill = ((packedOptions >> 4) & 1) != 0;
+    const titleAlignment = @as(u8, @intCast((packedOptions >> 5) & 0b11));
+    const bottomTitleAlignment = @as(u8, @intCast((packedOptions >> 7) & 0b11));
+    const titleSlice = if (title) |t| t[0..titleLen] else null;
+
+    const bottomTitleSlice = if (bottomTitle) |bt| bt[0..bottomTitleLen] else null;
+
+    object_ptr.drawBox(
+        x,
+        y,
+        width,
+        height,
+        borderChars,
+        borderSides,
+        ptrToRGBA(borderColor),
+        ptrToRGBA(backgroundColor),
+        ptrToRGBA(titleColor),
+        shouldFill,
+        titleSlice,
+        titleAlignment,
+        bottomTitleSlice,
+        bottomTitleAlignment,
+    ) catch {};
+}
+
+export fn bufferResize(buffer_handle: NativeHandle, width: u32, height: u32) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.resize(width, height) catch {};
+}
+
+export fn resizeRenderer(renderer_handle: NativeHandle, width: u32, height: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.resize(width, height) catch {};
+}
+
+export fn addToHitGrid(renderer_handle: NativeHandle, x: i32, y: i32, width: u32, height: u32, id: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.addToHitGrid(x, y, width, height, id);
+}
+
+export fn clearCurrentHitGrid(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.clearCurrentHitGrid();
+}
+
+export fn hitGridPushScissorRect(renderer_handle: NativeHandle, x: i32, y: i32, width: u32, height: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.hitGridPushScissorRect(x, y, width, height);
+}
+
+export fn hitGridPopScissorRect(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.hitGridPopScissorRect();
+}
+
+export fn hitGridClearScissorRects(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.hitGridClearScissorRects();
+}
+
+export fn addToCurrentHitGridClipped(renderer_handle: NativeHandle, x: i32, y: i32, width: u32, height: u32, id: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.addToCurrentHitGridClipped(x, y, width, height, id);
+}
+
+export fn checkHit(renderer_handle: NativeHandle, x: u32, y: u32) u32 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return 0;
+    return object_ptr.checkHit(x, y);
+}
+
+export fn getHitGridDirty(renderer_handle: NativeHandle) bool {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return false;
+    return object_ptr.getHitGridDirty();
+}
+
+export fn dumpHitGrid(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.dumpHitGrid();
+}
+
+export fn dumpBuffers(renderer_handle: NativeHandle, timestamp: i64) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.dumpBuffers(timestamp);
+}
+
+export fn dumpOutputBuffer(renderer_handle: NativeHandle, timestamp: i64) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.dumpOutputBuffer(timestamp);
+}
+
+export fn restoreTerminalModes(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.restoreTerminalModes();
+}
+
+export fn enableMouse(renderer_handle: NativeHandle, enableMovement: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.enableMouse(enableMovement);
+}
+
+export fn disableMouse(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.disableMouse();
+}
+
+export fn queryPixelResolution(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.queryPixelResolution();
+}
+
+export fn queryThemeColors(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.queryThemeColors();
+}
+
+export fn enableKittyKeyboard(renderer_handle: NativeHandle, flags: u8) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.enableKittyKeyboard(flags);
+}
+
+export fn disableKittyKeyboard(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.disableKittyKeyboard();
+}
+
+export fn setKittyKeyboardFlags(renderer_handle: NativeHandle, flags: u8) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setKittyKeyboardFlags(flags);
+}
+
+export fn getKittyKeyboardFlags(renderer_handle: NativeHandle) u8 {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return 0;
+    return object_ptr.getKittyKeyboardFlags();
+}
+
+export fn setupTerminal(renderer_handle: NativeHandle, useAlternateScreen: bool) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.setupTerminal(useAlternateScreen);
+}
+
+export fn suspendRenderer(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.suspendRenderer();
+}
+
+export fn resumeRenderer(renderer_handle: NativeHandle) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    object_ptr.resumeRenderer();
+}
+
+export fn writeOut(renderer_handle: NativeHandle, dataPtr: ?[*]const u8, dataLen: u32) void {
+    const object_ptr = acquireRenderer(renderer_handle) orelse return;
+    const data = sliceFromPtrLen(dataPtr, dataLen);
+    if (data.len == 0) return;
+    object_ptr.writeOut(data);
+}
+
+fn destroyTextBufferViewHandle(view_handle: NativeHandle) void {
+    const token = handles.beginDestroy(view_handle, .text_buffer_view, text_buffer_view.UnifiedTextBufferView) orelse return;
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+fn destroyTextBufferViewChildren(owner: NativeHandle) void {
+    while (handles.findChild(owner, .text_buffer_view)) |view_handle| {
+        destroyTextBufferViewHandle(view_handle);
+    }
+}
+
+export fn createTextBuffer(widthMethod: u8) NativeHandle {
+    const pool = gp.initGlobalPool(globalArena);
+    const link_pool = link.initGlobalLinkPool(globalArena);
+    const wMethod: utf8.WidthMethod = if (widthMethod == 0) .wcwidth else .unicode;
+
+    const tb = text_buffer.UnifiedTextBuffer.init(globalAllocator, pool, link_pool, wMethod) catch {
+        return INVALID_HANDLE;
+    };
+    return handles.insert(.text_buffer, erasePtr(tb)) catch {
+        tb.deinit();
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroyTextBuffer(tb_handle: NativeHandle) void {
+    const token = handles.beginDestroy(tb_handle, .text_buffer, text_buffer.UnifiedTextBuffer) orelse return;
+    destroyTextBufferViewChildren(token.handle);
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+export fn textBufferGetLength(tb_handle: NativeHandle) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    return object_ptr.getLength();
+}
+
+export fn textBufferGetByteSize(tb_handle: NativeHandle) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    return object_ptr.getByteSize();
+}
+
+export fn textBufferReset(tb_handle: NativeHandle) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.reset();
+}
+
+export fn textBufferClear(tb_handle: NativeHandle) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.clear();
+}
+
+export fn textBufferSetDefaultFg(tb_handle: NativeHandle, fg: ?[*]const u16) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.setDefaultFg(optionalPtrToRGBA(fg));
+}
+
+export fn textBufferSetDefaultBg(tb_handle: NativeHandle, bg: ?[*]const u16) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.setDefaultBg(optionalPtrToRGBA(bg));
+}
+
+export fn textBufferSetDefaultAttributes(tb_handle: NativeHandle, attr: ?[*]const u32) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    const attributes = if (attr) |a| a[0] else null;
+    object_ptr.setDefaultAttributes(attributes);
+}
+
+export fn textBufferResetDefaults(tb_handle: NativeHandle) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.resetDefaults();
+}
+
+export fn textBufferGetTabWidth(tb_handle: NativeHandle) u8 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    return object_ptr.tabWidth();
+}
+
+export fn textBufferSetTabWidth(tb_handle: NativeHandle, width: u8) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.setTabWidth(width);
+}
+
+export fn textBufferRegisterMemBuffer(tb_handle: NativeHandle, dataPtr: ?[*]const u8, dataLen: u32, owned: bool) u16 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0xFFFF;
+    const data = sliceFromPtrLen(dataPtr, dataLen);
+    const mem_id = object_ptr.registerMemBuffer(data, owned) catch return 0xFFFF;
+    return @intCast(mem_id);
+}
+
+export fn textBufferReplaceMemBuffer(tb_handle: NativeHandle, id: u8, dataPtr: ?[*]const u8, dataLen: u32, owned: bool) bool {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return false;
+    const data = sliceFromPtrLen(dataPtr, dataLen);
+    object_ptr.replaceMemBuffer(id, data, owned) catch return false;
+    return true;
+}
+
+export fn textBufferClearMemRegistry(tb_handle: NativeHandle) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.clearMemRegistry();
+}
+
+export fn textBufferSetTextFromMem(tb_handle: NativeHandle, id: u8) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.setTextFromMemId(id) catch {};
+}
+
+export fn textBufferAppend(tb_handle: NativeHandle, dataPtr: ?[*]const u8, dataLen: u32) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    const data = sliceFromPtrLen(dataPtr, dataLen);
+    object_ptr.append(data) catch {};
+}
+
+export fn textBufferAppendFromMemId(tb_handle: NativeHandle, id: u8) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.appendFromMemId(id) catch {};
+}
+
+export fn textBufferLoadFile(tb_handle: NativeHandle, pathPtr: ?[*]const u8, pathLen: u32) bool {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return false;
+    const path = sliceFromPtrLen(pathPtr, pathLen);
+    object_ptr.loadFile(path) catch return false;
+    return true;
+}
+
+export fn textBufferSetStyledText(
+    tb_handle: NativeHandle,
+    chunksPtr: ?[*]const text_buffer.StyledChunk,
+    chunkCount: u32,
+) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    if (chunkCount == 0) return;
+    const chunks = chunksPtr.?[0..@as(usize, chunkCount)];
+    object_ptr.setStyledText(chunks) catch {};
+}
+
+export fn textBufferGetLineCount(tb_handle: NativeHandle) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    return object_ptr.getLineCount();
+}
+
+export fn textBufferGetPlainText(tb_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getPlainTextIntoBuffer(outBuffer));
+}
+
+// TextBufferView functions (Array-based for backward compatibility)
+export fn createTextBufferView(tb_handle: NativeHandle) NativeHandle {
+    if (!handles.isOwned(tb_handle, .text_buffer)) return INVALID_HANDLE;
+
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return INVALID_HANDLE;
+    const view = text_buffer_view.UnifiedTextBufferView.init(globalAllocator, object_ptr) catch {
+        return INVALID_HANDLE;
+    };
+    return handles.insertOwnedChild(.text_buffer_view, erasePtr(view), tb_handle) catch {
+        view.deinit();
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroyTextBufferView(view_handle: NativeHandle) void {
+    destroyTextBufferViewHandle(view_handle);
+}
+
+export fn textBufferViewSetSelection(view_handle: NativeHandle, start: u32, end: u32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setSelectionStyle(start, end, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn textBufferViewResetSelection(view_handle: NativeHandle) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.resetSelection();
+}
+
+export fn textBufferViewGetSelectionInfo(view_handle: NativeHandle) u64 {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return std.math.maxInt(u64);
+    return object_ptr.packSelectionInfo();
+}
+
+export fn textBufferViewSetLocalSelection(view_handle: NativeHandle, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) bool {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return false;
+    return object_ptr.setLocalSelectionStyle(anchorX, anchorY, focusX, focusY, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn textBufferViewUpdateSelection(view_handle: NativeHandle, end: u32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.updateSelectionStyle(end, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn textBufferViewUpdateLocalSelection(view_handle: NativeHandle, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) bool {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return false;
+    return object_ptr.updateLocalSelectionStyle(anchorX, anchorY, focusX, focusY, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn textBufferViewResetLocalSelection(view_handle: NativeHandle) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.resetLocalSelection();
+}
+
+export fn textBufferViewSetWrapWidth(view_handle: NativeHandle, width: u32) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setWrapWidth(if (width == 0) null else width);
+}
+
+export fn textBufferViewSetWrapMode(view_handle: NativeHandle, mode: u8) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    const wrapMode: text_buffer.WrapMode = switch (mode) {
+        0 => .none,
+        1 => .char,
+        2 => .word,
+        else => .none,
+    };
+    object_ptr.setWrapMode(wrapMode);
+}
+
+export fn textBufferViewSetFirstLineOffset(view_handle: NativeHandle, offset: u32) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setFirstLineOffset(offset);
+}
+
+export fn textBufferViewSetViewportSize(view_handle: NativeHandle, width: u32, height: u32) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setViewportSize(width, height);
+}
+
+export fn textBufferViewSetViewport(view_handle: NativeHandle, x: u32, y: u32, width: u32, height: u32) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setViewport(.{
+        .x = x,
+        .y = y,
+        .width = width,
+        .height = height,
+    });
+}
+
+export fn textBufferViewGetVirtualLineCount(view_handle: NativeHandle) u32 {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return 0;
+    return object_ptr.getVirtualLineCount();
+}
+
+export fn textBufferViewGetLineInfoDirect(view_handle: NativeHandle, outPtr: *ExternalLineInfo) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse {
+        emptyLineInfo(outPtr);
+        return;
+    };
+    const line_info = object_ptr.getCachedLineInfo();
+
+    outPtr.* = .{
+        .start_cols_ptr = line_info.line_start_cols.ptr,
+        .start_cols_len = @intCast(line_info.line_start_cols.len),
+        .width_cols_ptr = line_info.line_width_cols.ptr,
+        .width_cols_len = @intCast(line_info.line_width_cols.len),
+        .sources_ptr = line_info.line_sources.ptr,
+        .sources_len = @intCast(line_info.line_sources.len),
+        .wraps_ptr = line_info.line_wraps.ptr,
+        .wraps_len = @intCast(line_info.line_wraps.len),
+        .width_cols_max = line_info.line_width_cols_max,
+    };
+}
+
+export fn textBufferViewGetLogicalLineInfoDirect(view_handle: NativeHandle, outPtr: *ExternalLineInfo) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse {
+        emptyLineInfo(outPtr);
+        return;
+    };
+    const line_info = object_ptr.getLogicalLineInfo();
+
+    outPtr.* = .{
+        .start_cols_ptr = line_info.line_start_cols.ptr,
+        .start_cols_len = @intCast(line_info.line_start_cols.len),
+        .width_cols_ptr = line_info.line_width_cols.ptr,
+        .width_cols_len = @intCast(line_info.line_width_cols.len),
+        .sources_ptr = line_info.line_sources.ptr,
+        .sources_len = @intCast(line_info.line_sources.len),
+        .wraps_ptr = line_info.line_wraps.ptr,
+        .wraps_len = @intCast(line_info.line_wraps.len),
+        .width_cols_max = line_info.line_width_cols_max,
+    };
+}
+
+export fn textBufferViewGetSelectedText(view_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getSelectedTextIntoBuffer(outBuffer));
+}
+
+export fn textBufferViewGetPlainText(view_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getPlainTextIntoBuffer(outBuffer));
+}
+
+export fn textBufferViewSetTabIndicator(view_handle: NativeHandle, indicator: u32) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setTabIndicator(indicator);
+}
+
+export fn textBufferViewSetTabIndicatorColor(view_handle: NativeHandle, color: [*]const u16) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setTabIndicatorColor(ptrToRGBA(color));
+}
+
+export fn textBufferViewSetTruncate(view_handle: NativeHandle, truncate: bool) void {
+    const object_ptr = acquireTextBufferView(view_handle) orelse return;
+    object_ptr.setTruncate(truncate);
+}
+
+pub const ExternalMeasureResult = extern struct {
+    line_count: u32,
+    width_cols_max: u32,
+};
+
+export fn textBufferViewMeasureForDimensions(view_handle: NativeHandle, width: u32, height: u32, outPtr: *ExternalMeasureResult) bool {
+    const object_ptr = acquireTextBufferView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalMeasureResult);
+        return false;
+    };
+    const result = object_ptr.measureForDimensions(width, height) catch return false;
+    outPtr.* = .{
+        .line_count = result.line_count,
+        .width_cols_max = result.width_cols_max,
+    };
+    return true;
+}
+
+// ===== EditBuffer Exports =====
+
+fn destroyEditorViewHandle(view_handle: NativeHandle) void {
+    const token = handles.beginDestroy(view_handle, .editor_view, editor_view.EditorView) orelse return;
+    handles.invalidateChildren(token.handle);
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+fn destroyEditorViewChildren(owner: NativeHandle) void {
+    while (handles.findChild(owner, .editor_view)) |view_handle| {
+        destroyEditorViewHandle(view_handle);
+    }
+}
+
+export fn createEditBuffer(widthMethod: u8, event_sink_handle: NativeHandle) NativeHandle {
+    const pool = gp.initGlobalPool(globalArena);
+    const link_pool = link.initGlobalLinkPool(globalArena);
+    const wMethod: utf8.WidthMethod = if (widthMethod == 0) .wcwidth else .unicode;
+    const event_sink_ptr = if (event_sink_handle == INVALID_HANDLE) null else acquireEventSink(event_sink_handle);
+    const event_sink = if (event_sink_ptr) |object_ptr| object_ptr else null;
+
+    const edit_buffer = edit_buffer_mod.EditBuffer.init(
+        globalAllocator,
+        pool,
+        link_pool,
+        wMethod,
+        event_sink,
+    ) catch return INVALID_HANDLE;
+
+    const edit_handle = handles.insert(.edit_buffer, erasePtr(edit_buffer)) catch {
+        edit_buffer.deinit();
+        return INVALID_HANDLE;
+    };
+    _ = handles.getOrInsertBorrowed(.text_buffer, erasePtr(edit_buffer.getTextBuffer()), edit_handle) catch {
+        if (handles.beginDestroy(edit_handle, .edit_buffer, edit_buffer_mod.EditBuffer)) |token| {
+            token.ptr.deinit();
+            handles.finishDestroy(token.handle);
+        }
+        return INVALID_HANDLE;
+    };
+    return edit_handle;
+}
+
+export fn destroyEditBuffer(edit_handle: NativeHandle) void {
+    const token = handles.beginDestroy(edit_handle, .edit_buffer, edit_buffer_mod.EditBuffer) orelse return;
+    destroyEditorViewChildren(token.handle);
+    handles.invalidateChildren(token.handle);
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+export fn editBufferGetTextBuffer(edit_handle: NativeHandle) NativeHandle {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return INVALID_HANDLE;
+    return handles.getOrInsertBorrowed(.text_buffer, erasePtr(object_ptr.getTextBuffer()), edit_handle) catch INVALID_HANDLE;
+}
+
+export fn editBufferInsertText(edit_handle: NativeHandle, textPtr: ?[*]const u8, textLen: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    const text = sliceFromPtrLen(textPtr, textLen);
+    object_ptr.insertText(text) catch {};
+}
+
+export fn editBufferDeleteRange(edit_handle: NativeHandle, start_row: u32, start_col: u32, end_row: u32, end_col: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    const start: edit_buffer_mod.Cursor = .{ .row = start_row, .col = start_col };
+    const end: edit_buffer_mod.Cursor = .{ .row = end_row, .col = end_col };
+    object_ptr.deleteRange(start, end) catch {};
+}
+
+export fn editBufferDeleteCharBackward(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.backspace() catch {};
+}
+
+export fn editBufferDeleteChar(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.deleteForward() catch {};
+}
+
+export fn editBufferMoveCursorLeft(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.moveLeft();
+}
+
+export fn editBufferMoveCursorRight(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.moveRight();
+}
+
+export fn editBufferMoveCursorUp(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.moveUp();
+}
+
+export fn editBufferMoveCursorDown(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.moveDown();
+}
+
+export fn editBufferGetCursor(edit_handle: NativeHandle, outRow: *u32, outCol: *u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outRow.* = 0;
+        outCol.* = 0;
+        return;
+    };
+    const cursor = object_ptr.getPrimaryCursor();
+    outRow.* = cursor.row;
+    outCol.* = cursor.col;
+}
+
+export fn editBufferSetCursor(edit_handle: NativeHandle, row: u32, col: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.setCursor(row, col) catch {};
+}
+
+export fn editBufferSetCursorToLineCol(edit_handle: NativeHandle, row: u32, col: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.setCursor(row, col) catch {};
+}
+
+export fn editBufferSetCursorByOffset(edit_handle: NativeHandle, offset: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.setCursorByOffset(offset) catch {};
+}
+
+export fn editBufferGetNextWordBoundary(edit_handle: NativeHandle, outPtr: *ExternalLogicalCursor) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalLogicalCursor);
+        return;
+    };
+    const cursor = object_ptr.getNextWordBoundary();
+    outPtr.* = .{
+        .row = cursor.row,
+        .col = cursor.col,
+        .offset = cursor.offset,
+    };
+}
+
+export fn editBufferGetPrevWordBoundary(edit_handle: NativeHandle, outPtr: *ExternalLogicalCursor) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalLogicalCursor);
+        return;
+    };
+    const cursor = object_ptr.getPrevWordBoundary();
+    outPtr.* = .{
+        .row = cursor.row,
+        .col = cursor.col,
+        .offset = cursor.offset,
+    };
+}
+
+export fn editBufferGetEOL(edit_handle: NativeHandle, outPtr: *ExternalLogicalCursor) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalLogicalCursor);
+        return;
+    };
+    const cursor = object_ptr.getEOL();
+    outPtr.* = .{
+        .row = cursor.row,
+        .col = cursor.col,
+        .offset = cursor.offset,
+    };
+}
+
+export fn editBufferOffsetToPosition(edit_handle: NativeHandle, offset: u32, outPtr: *ExternalLogicalCursor) bool {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalLogicalCursor);
+        return false;
+    };
+    const coords = text_buffer_iterators.offsetToCoords(object_ptr.tb.rope(), offset) orelse return false;
+    outPtr.* = .{
+        .row = coords.row,
+        .col = coords.col,
+        .offset = offset,
+    };
+    return true;
+}
+
+export fn editBufferPositionToOffset(edit_handle: NativeHandle, row: u32, col: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    return text_buffer_iterators.coordsToOffset(object_ptr.tb.rope(), row, col) orelse 0;
+}
+
+export fn editBufferGetLineStartOffset(edit_handle: NativeHandle, row: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    return text_buffer_iterators.coordsToOffset(object_ptr.tb.rope(), row, 0) orelse 0;
+}
+
+export fn editBufferGetTextRange(edit_handle: NativeHandle, start_offset: u32, end_offset: u32, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getTextRange(start_offset, end_offset, outBuffer) catch 0);
+}
+
+export fn editBufferGetTextRangeByCoords(edit_handle: NativeHandle, start_row: u32, start_col: u32, end_row: u32, end_col: u32, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getTextRangeByCoords(start_row, start_col, end_row, end_col, outBuffer));
+}
+
+export fn editBufferSetText(edit_handle: NativeHandle, textPtr: ?[*]const u8, textLen: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    const text = sliceFromPtrLen(textPtr, textLen);
+    object_ptr.setText(text) catch {};
+}
+
+export fn editBufferSetTextFromMem(edit_handle: NativeHandle, mem_id: u8) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.setTextFromMemId(mem_id) catch {};
+}
+
+export fn editBufferReplaceText(edit_handle: NativeHandle, textPtr: ?[*]const u8, textLen: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    const text = sliceFromPtrLen(textPtr, textLen);
+    object_ptr.replaceText(text) catch {};
+}
+
+export fn editBufferReplaceTextFromMem(edit_handle: NativeHandle, mem_id: u8) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.replaceTextFromMemId(mem_id) catch {};
+}
+
+export fn editBufferGetText(edit_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getText(outBuffer));
+}
+
+export fn editBufferInsertChar(edit_handle: NativeHandle, charPtr: ?[*]const u8, charLen: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    const text = sliceFromPtrLen(charPtr, charLen);
+    object_ptr.insertText(text) catch {};
+}
+
+export fn editBufferNewLine(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.insertText("\n") catch {};
+}
+
+export fn editBufferDeleteLine(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.deleteLine() catch {};
+}
+
+export fn editBufferGotoLine(edit_handle: NativeHandle, line: u32) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.gotoLine(line) catch {};
+}
+
+export fn editBufferGetCursorPosition(edit_handle: NativeHandle, outPtr: *ExternalLogicalCursor) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalLogicalCursor);
+        return;
+    };
+    const pos = object_ptr.getCursorPosition();
+    outPtr.* = .{
+        .row = pos.line,
+        .col = pos.visual_col,
+        .offset = pos.offset,
+    };
+}
+
+export fn editBufferGetId(edit_handle: NativeHandle) u16 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    return object_ptr.getId();
+}
+
+export fn editBufferDebugLogRope(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.debugLogRope();
+}
+
+export fn editBufferUndo(edit_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const prev_meta = object_ptr.undo() catch return 0;
+    const copyLen = @min(prev_meta.len, @as(usize, maxLen));
+    @memcpy(out[0..copyLen], prev_meta[0..copyLen]);
+    return @intCast(copyLen);
+}
+
+export fn editBufferRedo(edit_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const next_meta = object_ptr.redo() catch return 0;
+    const copyLen = @min(next_meta.len, @as(usize, maxLen));
+    @memcpy(out[0..copyLen], next_meta[0..copyLen]);
+    return @intCast(copyLen);
+}
+
+export fn editBufferCanUndo(edit_handle: NativeHandle) bool {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return false;
+    return object_ptr.canUndo();
+}
+
+export fn editBufferCanRedo(edit_handle: NativeHandle) bool {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return false;
+    return object_ptr.canRedo();
+}
+
+export fn editBufferClearHistory(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.clearHistory();
+}
+
+export fn editBufferClear(edit_handle: NativeHandle) void {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return;
+    object_ptr.clear() catch {};
+}
+
+// ===== EditorView Exports =====
+
+export fn createEditorView(edit_handle: NativeHandle, viewport_width: u32, viewport_height: u32) NativeHandle {
+    const object_ptr = acquireEditBuffer(edit_handle) orelse return INVALID_HANDLE;
+    const view = editor_view.EditorView.init(globalArena, object_ptr, viewport_width, viewport_height) catch return INVALID_HANDLE;
+    const view_handle = handles.insertOwnedChild(.editor_view, erasePtr(view), edit_handle) catch {
+        view.deinit();
+        return INVALID_HANDLE;
+    };
+    _ = handles.getOrInsertBorrowed(.text_buffer_view, erasePtr(view.getTextBufferView()), view_handle) catch {
+        if (handles.beginDestroy(view_handle, .editor_view, editor_view.EditorView)) |token| {
+            token.ptr.deinit();
+            handles.finishDestroy(token.handle);
+        }
+        return INVALID_HANDLE;
+    };
+    return view_handle;
+}
+
+export fn destroyEditorView(view_handle: NativeHandle) void {
+    destroyEditorViewHandle(view_handle);
+}
+
+export fn editorViewSetViewport(view_handle: NativeHandle, x: u32, y: u32, width: u32, height: u32, moveCursor: bool) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setViewport(.{ .x = x, .y = y, .width = width, .height = height }, moveCursor);
+}
+
+export fn editorViewClearViewport(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setViewport(null, false);
+}
+
+export fn editorViewGetViewport(view_handle: NativeHandle, outX: *u32, outY: *u32, outWidth: *u32, outHeight: *u32) bool {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outX.* = 0;
+        outY.* = 0;
+        outWidth.* = 0;
+        outHeight.* = 0;
+        return false;
+    };
+    if (object_ptr.getViewport()) |vp| {
+        outX.* = vp.x;
+        outY.* = vp.y;
+        outWidth.* = vp.width;
+        outHeight.* = vp.height;
+        return true;
+    }
+    return false;
+}
+
+export fn editorViewSetScrollMargin(view_handle: NativeHandle, margin: f32) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setScrollMargin(margin);
+}
+
+export fn editorViewGetVirtualLineCount(view_handle: NativeHandle) u32 {
+    const object_ptr = acquireEditorView(view_handle) orelse return 0;
+    // TODO: There is a getter for that directly, no?
+    return @intCast(object_ptr.getVirtualLines().len);
+}
+
+export fn editorViewGetTotalVirtualLineCount(view_handle: NativeHandle) u32 {
+    const object_ptr = acquireEditorView(view_handle) orelse return 0;
+    return object_ptr.getTotalVirtualLineCount();
+}
+
+export fn editorViewGetLineInfoDirect(view_handle: NativeHandle, outPtr: *ExternalLineInfo) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        emptyLineInfo(outPtr);
+        return;
+    };
+    const line_info = object_ptr.getCachedLineInfo();
+    outPtr.* = .{
+        .start_cols_ptr = line_info.line_start_cols.ptr,
+        .start_cols_len = @intCast(line_info.line_start_cols.len),
+        .width_cols_ptr = line_info.line_width_cols.ptr,
+        .width_cols_len = @intCast(line_info.line_width_cols.len),
+        .sources_ptr = line_info.line_sources.ptr,
+        .sources_len = @intCast(line_info.line_sources.len),
+        .wraps_ptr = line_info.line_wraps.ptr,
+        .wraps_len = @intCast(line_info.line_wraps.len),
+        .width_cols_max = line_info.line_width_cols_max,
+    };
+}
+
+export fn editorViewGetTextBufferView(view_handle: NativeHandle) NativeHandle {
+    const object_ptr = acquireEditorView(view_handle) orelse return INVALID_HANDLE;
+    return handles.getOrInsertBorrowed(.text_buffer_view, erasePtr(object_ptr.getTextBufferView()), view_handle) catch INVALID_HANDLE;
+}
+
+export fn editorViewGetLogicalLineInfoDirect(view_handle: NativeHandle, outPtr: *ExternalLineInfo) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        emptyLineInfo(outPtr);
+        return;
+    };
+    const line_info = object_ptr.getLogicalLineInfo();
+    outPtr.* = .{
+        .start_cols_ptr = line_info.line_start_cols.ptr,
+        .start_cols_len = @intCast(line_info.line_start_cols.len),
+        .width_cols_ptr = line_info.line_width_cols.ptr,
+        .width_cols_len = @intCast(line_info.line_width_cols.len),
+        .sources_ptr = line_info.line_sources.ptr,
+        .sources_len = @intCast(line_info.line_sources.len),
+        .wraps_ptr = line_info.line_wraps.ptr,
+        .wraps_len = @intCast(line_info.line_wraps.len),
+        .width_cols_max = line_info.line_width_cols_max,
+    };
+}
+
+export fn editorViewSetViewportSize(view_handle: NativeHandle, width: u32, height: u32) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setViewportSize(width, height);
+}
+
+export fn editorViewSetWrapMode(view_handle: NativeHandle, mode: u8) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    const wrapMode: text_buffer.WrapMode = switch (mode) {
+        0 => .none,
+        1 => .char,
+        2 => .word,
+        else => .none,
+    };
+    object_ptr.setWrapMode(wrapMode);
+}
+
+// EditorView selection methods - delegate to TextBufferView
+export fn editorViewSetSelection(view_handle: NativeHandle, start: u32, end: u32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.text_buffer_view.setSelectionStyle(start, end, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn editorViewResetSelection(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.text_buffer_view.resetSelection();
+}
+
+export fn editorViewGetSelection(view_handle: NativeHandle) u64 {
+    const object_ptr = acquireEditorView(view_handle) orelse return std.math.maxInt(u64);
+    return object_ptr.text_buffer_view.packSelectionInfo();
+}
+
+export fn editorViewSetLocalSelection(view_handle: NativeHandle, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?[*]const u16, fgColor: ?[*]const u16, updateCursor: bool, followCursor: bool) bool {
+    const object_ptr = acquireEditorView(view_handle) orelse return false;
+    object_ptr.setSelectionFollowCursor(followCursor);
+    const changed = object_ptr.text_buffer_view.setLocalSelectionStyle(anchorX, anchorY, focusX, focusY, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+    if (changed and updateCursor) {
+        object_ptr.syncCursorToSelectionFocus();
+    }
+    return changed;
+}
+
+export fn editorViewUpdateSelection(view_handle: NativeHandle, end: u32, bgColor: ?[*]const u16, fgColor: ?[*]const u16) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.text_buffer_view.updateSelectionStyle(end, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+}
+
+export fn editorViewUpdateLocalSelection(view_handle: NativeHandle, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?[*]const u16, fgColor: ?[*]const u16, updateCursor: bool, followCursor: bool) bool {
+    const object_ptr = acquireEditorView(view_handle) orelse return false;
+    object_ptr.setSelectionFollowCursor(followCursor);
+    const changed = object_ptr.text_buffer_view.updateLocalSelectionStyle(anchorX, anchorY, focusX, focusY, selectionStyle(optionalPtrToRGBA(bgColor), optionalPtrToRGBA(fgColor)));
+    if (changed and updateCursor) {
+        object_ptr.syncCursorToSelectionFocus();
+    }
+    return changed;
+}
+
+export fn editorViewResetLocalSelection(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setSelectionFollowCursor(false);
+    object_ptr.text_buffer_view.resetLocalSelection();
+}
+
+export fn editorViewGetSelectedTextBytes(view_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditorView(view_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.text_buffer_view.getSelectedTextIntoBuffer(outBuffer));
+}
+
+// EditorView cursor and text methods
+export fn editorViewGetCursor(view_handle: NativeHandle, outRow: *u32, outCol: *u32) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outRow.* = 0;
+        outCol.* = 0;
+        return;
+    };
+    const cursor = object_ptr.getPrimaryCursor();
+    outRow.* = cursor.row;
+    outCol.* = cursor.col;
+}
+
+export fn editorViewGetText(view_handle: NativeHandle, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireEditorView(view_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getText(outBuffer));
+}
+
+// ===== EditorView VisualCursor Exports =====
+
+export fn editorViewGetVisualCursor(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getVisualCursor();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewMoveUpVisual(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.moveUpVisual();
+}
+
+export fn editorViewMoveDownVisual(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.moveDownVisual();
+}
+
+export fn editorViewDeleteSelectedText(view_handle: NativeHandle) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.deleteSelectedText() catch {};
+}
+
+export fn editorViewSetCursorByOffset(view_handle: NativeHandle, offset: u32) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setCursorByOffset(offset) catch {};
+}
+
+export fn editorViewGetNextWordBoundary(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getNextWordBoundary();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewGetPrevWordBoundary(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getPrevWordBoundary();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewGetEOL(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getEOL();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewGetVisualSOL(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getVisualSOL();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewGetVisualEOL(view_handle: NativeHandle, outPtr: *ExternalVisualCursor) void {
+    const object_ptr = acquireEditorView(view_handle) orelse {
+        outPtr.* = std.mem.zeroes(ExternalVisualCursor);
+        return;
+    };
+    const vcursor = object_ptr.getVisualEOL();
+    outPtr.* = .{
+        .visual_row = vcursor.visual_row,
+        .visual_col = vcursor.visual_col,
+        .logical_row = vcursor.logical_row,
+        .logical_col = vcursor.logical_col,
+        .offset = vcursor.offset,
+    };
+}
+
+export fn editorViewSetPlaceholderStyledText(
+    view_handle: NativeHandle,
+    chunksPtr: ?[*]const text_buffer.StyledChunk,
+    chunkCount: u32,
+) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    if (chunkCount == 0) {
+        object_ptr.setPlaceholderStyledText(&[_]text_buffer.StyledChunk{}) catch {};
+        return;
+    }
+    const chunks = chunksPtr.?[0..@as(usize, chunkCount)];
+    object_ptr.setPlaceholderStyledText(chunks) catch {};
+}
+
+export fn editorViewSetTabIndicator(view_handle: NativeHandle, indicator: u32) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setTabIndicator(indicator);
+}
+
+export fn editorViewSetTabIndicatorColor(view_handle: NativeHandle, color: [*]const u16) void {
+    const object_ptr = acquireEditorView(view_handle) orelse return;
+    object_ptr.setTabIndicatorColor(ptrToRGBA(color));
+}
+
+export fn bufferDrawEditorView(
+    buffer_handle: NativeHandle,
+    view_handle: NativeHandle,
+    x: i32,
+    y: i32,
+) void {
+    const buffer_ptr = acquireBuffer(buffer_handle) orelse return;
+    const view_ptr = acquireEditorView(view_handle) orelse return;
+    buffer_ptr.drawEditorView(view_ptr, x, y);
+}
+
+export fn bufferDrawTextBufferView(
+    buffer_handle: NativeHandle,
+    view_handle: NativeHandle,
+    x: i32,
+    y: i32,
+) void {
+    const buffer_ptr = acquireBuffer(buffer_handle) orelse return;
+    const view_ptr = acquireTextBufferView(view_handle) orelse return;
+    buffer_ptr.drawTextBuffer(view_ptr, x, y);
+}
+
+pub const ExternalHighlight = extern struct {
+    start: u32,
+    end: u32,
+    style_id: u32,
+    priority: u8,
+    hl_ref: u16,
+};
+
+pub const ExternalLogicalCursor = extern struct {
+    row: u32,
+    col: u32,
+    offset: u32,
+};
+
+pub const ExternalVisualCursor = extern struct {
+    visual_row: u32,
+    visual_col: u32,
+    logical_row: u32,
+    logical_col: u32,
+    offset: u32,
+};
+
+pub const ExternalLineInfo = extern struct {
+    start_cols_ptr: [*]const u32,
+    start_cols_len: u32,
+    width_cols_ptr: [*]const u32,
+    width_cols_len: u32,
+    sources_ptr: [*]const u32,
+    sources_len: u32,
+    wraps_ptr: [*]const u32,
+    wraps_len: u32,
+    width_cols_max: u32,
+};
+
+export fn textBufferAddHighlightByCharRange(
+    tb_handle: NativeHandle,
+    hl_ptr: [*]const ExternalHighlight,
+) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    const hl = hl_ptr[0];
+    // For char-range highlights, start/end in the struct are unused (passed as char_start/char_end)
+    object_ptr.addHighlightByCharRange(hl.start, hl.end, hl.style_id, hl.priority, hl.hl_ref) catch {};
+}
+
+export fn textBufferAddHighlight(
+    tb_handle: NativeHandle,
+    line_idx: u32,
+    hl_ptr: [*]const ExternalHighlight,
+) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    const hl = hl_ptr[0];
+    // For line-based highlights, start/end are column offsets
+    object_ptr.addHighlight(line_idx, hl.start, hl.end, hl.style_id, hl.priority, hl.hl_ref) catch {};
+}
+
+export fn textBufferRemoveHighlightsByRef(tb_handle: NativeHandle, hl_ref: u16) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.removeHighlightsByRef(hl_ref);
+}
+
+export fn textBufferClearLineHighlights(tb_handle: NativeHandle, line_idx: u32) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.clearLineHighlights(line_idx);
+}
+
+export fn textBufferClearAllHighlights(tb_handle: NativeHandle) void {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return;
+    object_ptr.clearAllHighlights();
+}
+
+export fn textBufferSetSyntaxStyle(tb_handle: NativeHandle, style_handle: NativeHandle) bool {
+    const tb_ptr = acquireTextBuffer(tb_handle) orelse return false;
+    if (style_handle == INVALID_HANDLE) {
+        tb_ptr.setSyntaxStyle(null);
+        return true;
+    }
+    const style_ptr = acquireSyntaxStyle(style_handle) orelse return false;
+    tb_ptr.setSyntaxStyle(style_ptr);
+    return tb_ptr.getSyntaxStyle() == style_ptr;
+}
+
+export fn textBufferGetLineHighlightsPtr(
+    tb_handle: NativeHandle,
+    line_idx: u32,
+    out_count: *u32,
+) ?[*]const ExternalHighlight {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse {
+        out_count.* = 0;
+        return null;
+    };
+    const highs = object_ptr.getLineHighlightsSlice(@intCast(line_idx));
+
+    if (highs.len == 0) {
+        out_count.* = 0;
+        return null;
+    }
+
+    var slice = globalAllocator.alloc(ExternalHighlight, highs.len) catch return null;
+
+    for (highs, 0..) |hl, i| {
+        slice[i] = .{
+            .start = hl.col_start,
+            .end = hl.col_end,
+            .style_id = hl.style_id,
+            .priority = hl.priority,
+            .hl_ref = hl.hl_ref,
+        };
+    }
+
+    out_count.* = @intCast(highs.len);
+    return slice.ptr;
+}
+
+export fn textBufferFreeLineHighlights(ptr: [*]const ExternalHighlight, count: u32) void {
+    globalAllocator.free(@constCast(ptr)[0..@as(usize, count)]);
+}
+
+export fn textBufferGetHighlightCount(tb_handle: NativeHandle) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    return object_ptr.getHighlightCount();
+}
+
+export fn textBufferGetTextRange(tb_handle: NativeHandle, start_offset: u32, end_offset: u32, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getTextRange(start_offset, end_offset, outBuffer));
+}
+
+export fn textBufferGetTextRangeByCoords(tb_handle: NativeHandle, start_row: u32, start_col: u32, end_row: u32, end_col: u32, outPtr: ?[*]u8, maxLen: u32) u32 {
+    const object_ptr = acquireTextBuffer(tb_handle) orelse return 0;
+    if (maxLen == 0) return 0;
+
+    const out = outPtr orelse return 0;
+    const outBuffer = out[0..@as(usize, maxLen)];
+    return @intCast(object_ptr.getTextRangeByCoords(start_row, start_col, end_row, end_col, outBuffer));
+}
+
+// SyntaxStyle functions
+export fn createSyntaxStyle() NativeHandle {
+    const style = syntax_style.SyntaxStyle.init(globalAllocator) catch |err| {
+        logger.err("Failed to create SyntaxStyle: {}", .{err});
+        return INVALID_HANDLE;
+    };
+    return handles.insert(.syntax_style, erasePtr(style)) catch {
+        style.deinit();
+        return INVALID_HANDLE;
+    };
+}
+
+export fn destroySyntaxStyle(style_handle: NativeHandle) void {
+    const token = handles.beginDestroy(style_handle, .syntax_style, syntax_style.SyntaxStyle) orelse return;
+    token.ptr.deinit();
+    handles.finishDestroy(token.handle);
+}
+
+export fn syntaxStyleRegister(style_handle: NativeHandle, namePtr: ?[*]const u8, nameLen: u32, fg: ?[*]const u16, bg: ?[*]const u16, attributes: u32) u32 {
+    const object_ptr = acquireSyntaxStyle(style_handle) orelse return 0;
+    const name = sliceFromPtrLen(namePtr, nameLen);
+    return object_ptr.registerStyleDefinition(name, .{
+        .fg = optionalPtrToRGBA(fg),
+        .bg = optionalPtrToRGBA(bg),
+        .attributes = attributes,
+    }) catch 0;
+}
+
+export fn syntaxStyleResolveByName(style_handle: NativeHandle, namePtr: ?[*]const u8, nameLen: u32) u32 {
+    const object_ptr = acquireSyntaxStyle(style_handle) orelse return 0;
+    const name = sliceFromPtrLen(namePtr, nameLen);
+    return object_ptr.resolveByName(name) orelse 0;
+}
+
+export fn syntaxStyleGetStyleCount(style_handle: NativeHandle) u32 {
+    const object_ptr = acquireSyntaxStyle(style_handle) orelse return 0;
+    return @intCast(object_ptr.getStyleCount());
+}
+
+// Unicode encoding API
+
+pub const EncodedChar = extern struct {
+    width: u8,
+    char: u32,
+};
+
+export fn encodeUnicode(
+    textPtr: ?[*]const u8,
+    textLen: u32,
+    outPtr: *?[*]EncodedChar,
+    outLenPtr: *usize,
+    widthMethod: u8,
+) bool {
+    const text = sliceFromPtrLen(textPtr, textLen);
+
+    if (text.len == 0) {
+        outPtr.* = @ptrFromInt(0);
+        outLenPtr.* = 0;
+        return true;
+    }
+
+    const pool = gp.initGlobalPool(globalArena);
+    const wMethod: utf8.WidthMethod = if (widthMethod == 0) .wcwidth else .unicode;
+
+    // Check if ASCII only for optimization
+    const is_ascii_only = utf8.isAsciiOnly(text);
+
+    // Find grapheme info
+    var grapheme_list: std.ArrayListUnmanaged(utf8.GraphemeInfo) = .{};
+    defer grapheme_list.deinit(globalAllocator);
+
+    const tab_width: u8 = 2;
+    utf8.findGraphemeInfo(globalAllocator, text, tab_width, is_ascii_only, wMethod, &grapheme_list) catch return false;
+    const specials = grapheme_list.items;
+
+    // Allocate output array
+    const estimated_count = if (is_ascii_only) text.len else text.len * 2;
+    var result = globalAllocator.alloc(EncodedChar, estimated_count) catch return false;
+    var result_idx: usize = 0;
+    var success = false;
+    var pending_gid: ?u32 = null; // Track grapheme allocated but not yet stored in result
+
+    // Clean up result array and any allocated grapheme IDs on failure
+    defer {
+        if (!success) {
+            // Clean up pending grapheme that wasn't stored yet
+            if (pending_gid) |gid| {
+                // Try decref first (works if incref was called, refcount >= 1)
+                // If that fails (refcount was 0), use freeUnreferenced
+                pool.decref(gid) catch {
+                    pool.freeUnreferenced(gid) catch {};
+                };
+            }
+            // Decref any grapheme IDs we allocated before the failure
+            for (result[0..result_idx]) |encoded_char| {
+                if (gp.isGraphemeChar(encoded_char.char)) {
+                    const gid = gp.graphemeIdFromChar(encoded_char.char);
+                    pool.decref(gid) catch {};
+                }
+            }
+            globalAllocator.free(result);
+        }
+    }
+
+    var byte_offset: u32 = 0;
+    var col: u32 = 0;
+    var special_idx: usize = 0;
+
+    while (byte_offset < text.len) {
+        const at_special = special_idx < specials.len and specials[special_idx].col_offset == col;
+
+        var grapheme_bytes: []const u8 = undefined;
+        var g_width: u8 = undefined;
+
+        if (at_special) {
+            const g = specials[special_idx];
+            grapheme_bytes = text[g.byte_offset .. g.byte_offset + g.byte_len];
+            g_width = g.width;
+            byte_offset = g.byte_offset + g.byte_len;
+            special_idx += 1;
+        } else {
+            if (byte_offset >= text.len) break;
+            grapheme_bytes = text[byte_offset .. byte_offset + 1];
+            g_width = 1;
+            byte_offset += 1;
+        }
+
+        const cell_width = utf8.getWidthAt(text, if (at_special) specials[special_idx - 1].byte_offset else byte_offset - 1, tab_width, wMethod);
+        if (cell_width == 0) {
+            col += g_width;
+            continue;
+        }
+
+        // Encode the character
+        var encoded_char: u32 = 0;
+        if (grapheme_bytes.len == 1 and cell_width == 1 and grapheme_bytes[0] >= 32) {
+            // Simple ASCII character
+            encoded_char = @as(u32, grapheme_bytes[0]);
+        } else {
+            // Multi-byte or special character - allocate in pool
+            const gid = pool.alloc(grapheme_bytes) catch return false;
+            pending_gid = gid; // Track until stored in result
+            encoded_char = gp.packGraphemeStart(gid & gp.GRAPHEME_ID_MASK, cell_width);
+
+            // Incref since we're handing this off to the caller
+            // Note: incref can only fail if gid is invalid, which shouldn't happen
+            // for a freshly allocated gid. If it does fail, the slot leaks but
+            // this is an edge case that indicates a bug elsewhere.
+            pool.incref(gid) catch return false;
+        }
+
+        // Ensure we have space
+        if (result_idx >= result.len) {
+            const new_len = result.len * 2;
+            result = globalAllocator.realloc(result, new_len) catch return false;
+        }
+
+        result[result_idx] = EncodedChar{
+            .width = @intCast(cell_width),
+            .char = encoded_char,
+        };
+        pending_gid = null; // Successfully stored, no longer pending
+        result_idx += 1;
+        col += g_width;
+    }
+
+    // Trim to actual size
+    result = globalAllocator.realloc(result, result_idx) catch result;
+
+    outPtr.* = result.ptr;
+    outLenPtr.* = result_idx;
+    success = true;
+    return true;
+}
+
+export fn freeUnicode(charsPtr: ?[*]const EncodedChar, charsLen: u32) void {
+    if (charsLen == 0 or charsPtr == null) {
+        return;
+    }
+
+    const chars = charsPtr.?[0..@as(usize, charsLen)];
+    const pool = gp.initGlobalPool(globalArena);
+
+    for (chars) |encoded_char| {
+        const char = encoded_char.char;
+
+        // Check if this is a packed grapheme
+        if (gp.isGraphemeChar(char)) {
+            const gid = gp.graphemeIdFromChar(char);
+            pool.decref(gid) catch {};
+        }
+    }
+
+    // Free the array itself
+    globalAllocator.free(chars);
+}
+
+export fn bufferDrawChar(
+    buffer_handle: NativeHandle,
+    char: u32,
+    x: u32,
+    y: u32,
+    fg: [*]const u16,
+    bg: [*]const u16,
+    attributes: u32,
+) void {
+    const object_ptr = acquireBuffer(buffer_handle) orelse return;
+    object_ptr.drawChar(char, x, y, ptrToRGBA(fg), ptrToRGBA(bg), attributes);
+}