@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/zig/text-buffer-view.zig

@@ -0,0 +1,1371 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const tb = @import("text-buffer.zig");
+const seg_mod = @import("text-buffer-segment.zig");
+const iter_mod = @import("text-buffer-iterators.zig");
+const gp = @import("grapheme.zig");
+const utf8 = @import("utf8.zig");
+
+const logger = @import("logger.zig");
+
+const UnifiedTextBuffer = tb.UnifiedTextBuffer;
+const RGBA = tb.RGBA;
+const TextSelection = tb.TextSelection;
+pub const WrapMode = tb.WrapMode;
+const TextChunk = seg_mod.TextChunk;
+const StyleSpan = tb.StyleSpan;
+const GraphemeInfo = seg_mod.GraphemeInfo;
+
+pub const TextBufferViewError = error{
+    OutOfMemory,
+};
+
+/// Viewport defines a rectangular window into the virtual line space
+pub const Viewport = struct {
+    x: u32,
+    y: u32,
+    width: u32,
+    height: u32,
+};
+
+pub const LineInfo = struct {
+    line_start_cols: []const u32,
+    line_width_cols: []const u32,
+    line_sources: []const u32,
+    line_wraps: []const u32,
+    line_width_cols_max: u32,
+};
+
+pub const WrapInfo = struct {
+    line_first_vline: []const u32,
+    line_vline_counts: []const u32,
+};
+
+/// Output structure for virtual line calculation
+pub const VirtualLineOutput = struct {
+    virtual_lines: *std.ArrayListUnmanaged(VirtualLine),
+    cached_line_starts: *std.ArrayListUnmanaged(u32),
+    cached_line_widths: *std.ArrayListUnmanaged(u32),
+    cached_line_sources: *std.ArrayListUnmanaged(u32),
+    cached_line_wrap_indices: *std.ArrayListUnmanaged(u32),
+    cached_line_first_vline: *std.ArrayListUnmanaged(u32),
+    cached_line_vline_counts: *std.ArrayListUnmanaged(u32),
+};
+
+/// Result from measuring dimensions without modifying cache
+pub const MeasureResult = struct {
+    line_count: u32,
+    width_cols_max: u32,
+};
+
+pub const VirtualLineSpanInfo = struct {
+    spans: []const StyleSpan,
+    source_line: usize,
+    col_offset: u32,
+};
+
+pub const VirtualChunk = struct {
+    grapheme_start: u32,
+    width: u32,
+    // Direct reference to source chunk for rendering
+    chunk: *const TextChunk,
+};
+
+pub const VirtualLine = struct {
+    chunks: std.ArrayListUnmanaged(VirtualChunk),
+    width_cols: u32,
+    col_offset: u32,
+    source_line: usize,
+    source_col_offset: u32,
+    is_truncated: bool,
+    ellipsis_pos: u32,
+    truncation_suffix_start: u32,
+
+    pub fn init() VirtualLine {
+        return .{
+            .chunks = .{},
+            .width_cols = 0,
+            .col_offset = 0,
+            .source_line = 0,
+            .source_col_offset = 0,
+            .is_truncated = false,
+            .ellipsis_pos = 0,
+            .truncation_suffix_start = 0,
+        };
+    }
+
+    pub fn deinit(self: *VirtualLine, allocator: Allocator) void {
+        self.chunks.deinit(allocator);
+    }
+};
+
+pub const LocalSelection = struct {
+    anchorX: i32,
+    anchorY: i32,
+    focusX: i32,
+    focusY: i32,
+    isActive: bool,
+};
+
+pub const TextBufferView = UnifiedTextBufferView;
+
+pub const UnifiedTextBufferView = struct {
+    const Self = @This();
+
+    text_buffer: *UnifiedTextBuffer,
+    original_text_buffer: *UnifiedTextBuffer,
+    view_id: u32,
+    selection: ?TextSelection,
+    selection_anchor_offset: ?u32,
+    viewport: ?Viewport,
+    wrap_width: ?u32,
+    wrap_mode: WrapMode,
+    virtual_lines: std.ArrayListUnmanaged(VirtualLine),
+    virtual_lines_dirty: bool,
+    cached_line_starts: std.ArrayListUnmanaged(u32),
+    cached_line_widths: std.ArrayListUnmanaged(u32),
+    cached_line_sources: std.ArrayListUnmanaged(u32),
+    cached_line_wrap_indices: std.ArrayListUnmanaged(u32),
+    cached_line_first_vline: std.ArrayListUnmanaged(u32),
+    cached_line_vline_counts: std.ArrayListUnmanaged(u32),
+    global_allocator: Allocator,
+    virtual_lines_arena: *std.heap.ArenaAllocator,
+
+    /// Persistent arena for measureForDimensions. Each call resets it with
+    /// retain_capacity to avoid mmap/munmap churn during streaming.
+    measure_arena: std.heap.ArenaAllocator,
+    tab_indicator: ?u32,
+    tab_indicator_color: ?RGBA,
+    truncate: bool,
+    ellipsis_chunk: TextChunk,
+    ellipsis_mem_id: u8,
+
+    // Measurement cache for Yoga layout. Keyed by (buffer, epoch, width, wrap_mode).
+    // Using epoch instead of dirty flag prevents stale returns when unrelated
+    // code paths clear dirty (e.g., updateVirtualLines).
+    cached_measure_width: ?u32,
+    cached_measure_wrap_mode: WrapMode,
+    cached_measure_result: ?MeasureResult,
+    cached_measure_epoch: u64,
+    cached_measure_buffer: ?*UnifiedTextBuffer,
+
+    truncation_applied: bool,
+    truncation_epoch: u64,
+    truncation_viewport: ?Viewport,
+
+    pub fn init(global_allocator: Allocator, text_buffer: *UnifiedTextBuffer) TextBufferViewError!*Self {
+        const self = global_allocator.create(Self) catch return TextBufferViewError.OutOfMemory;
+        errdefer global_allocator.destroy(self);
+
+        const virtual_lines_internal_arena = global_allocator.create(std.heap.ArenaAllocator) catch return TextBufferViewError.OutOfMemory;
+        errdefer global_allocator.destroy(virtual_lines_internal_arena);
+        virtual_lines_internal_arena.* = std.heap.ArenaAllocator.init(global_allocator);
+
+        const view_id = text_buffer.registerView() catch return TextBufferViewError.OutOfMemory;
+
+        const ellipsis_text = "...";
+        const ellipsis_mem_id = text_buffer.registerMemBuffer(ellipsis_text, false) catch return TextBufferViewError.OutOfMemory;
+        const ellipsis_chunk = text_buffer.createChunk(ellipsis_mem_id, 0, 3);
+
+        self.* = .{
+            .text_buffer = text_buffer,
+            .original_text_buffer = text_buffer,
+            .view_id = view_id,
+            .selection = null,
+            .selection_anchor_offset = null,
+            .viewport = null,
+            .wrap_width = null,
+            .wrap_mode = .none,
+            .virtual_lines = .{},
+            .virtual_lines_dirty = true,
+            .cached_line_starts = .{},
+            .cached_line_widths = .{},
+            .cached_line_sources = .{},
+            .cached_line_wrap_indices = .{},
+            .cached_line_first_vline = .{},
+            .cached_line_vline_counts = .{},
+            .global_allocator = global_allocator,
+            .virtual_lines_arena = virtual_lines_internal_arena,
+            .measure_arena = std.heap.ArenaAllocator.init(global_allocator),
+            .tab_indicator = null,
+            .tab_indicator_color = null,
+            .truncate = false,
+            .ellipsis_chunk = ellipsis_chunk,
+            .ellipsis_mem_id = ellipsis_mem_id,
+            .cached_measure_width = null,
+            .cached_measure_wrap_mode = .none,
+            .cached_measure_result = null,
+            .cached_measure_epoch = 0,
+            .cached_measure_buffer = null,
+            .truncation_applied = false,
+            .truncation_epoch = 0,
+            .truncation_viewport = null,
+        };
+
+        return self;
+    }
+
+    /// IMPORTANT: Views must be destroyed BEFORE their associated TextBuffer.
+    /// Destroying the TextBuffer first will cause use-after-free when calling deinit.
+    /// The TypeScript wrappers enforce this order via the destroy() methods.
+    pub fn deinit(self: *Self) void {
+        self.original_text_buffer.unregisterView(self.view_id);
+        self.virtual_lines_arena.deinit();
+        self.global_allocator.destroy(self.virtual_lines_arena);
+        self.measure_arena.deinit();
+        self.global_allocator.destroy(self);
+    }
+
+    pub fn setViewport(self: *Self, vp: ?Viewport) void {
+        self.viewport = vp;
+
+        // If viewport has width, set wrap width (wrapping behavior depends on wrap_mode)
+        if (vp) |viewport| {
+            if (self.wrap_width != viewport.width) {
+                self.wrap_width = viewport.width;
+                self.virtual_lines_dirty = true;
+                self.truncation_applied = false;
+            }
+        } else {
+            self.truncation_applied = false;
+        }
+    }
+
+    pub fn getViewport(self: *const Self) ?Viewport {
+        return self.viewport;
+    }
+
+    // This is a convenience method that preserves existing offset
+    pub fn setViewportSize(self: *Self, width: u32, height: u32) void {
+        if (self.viewport) |vp| {
+            self.setViewport(Viewport{
+                .x = vp.x,
+                .y = vp.y,
+                .width = width,
+                .height = height,
+            });
+        } else {
+            self.setViewport(Viewport{
+                .x = 0,
+                .y = 0,
+                .width = width,
+                .height = height,
+            });
+        }
+    }
+
+    pub fn setWrapWidth(self: *Self, width: ?u32) void {
+        if (self.wrap_width != width) {
+            self.wrap_width = width;
+            self.virtual_lines_dirty = true;
+            self.truncation_applied = false;
+        }
+    }
+
+    pub fn setWrapMode(self: *Self, mode: WrapMode) void {
+        if (self.wrap_mode != mode) {
+            self.wrap_mode = mode;
+            self.virtual_lines_dirty = true;
+            self.truncation_applied = false;
+        }
+    }
+
+    fn calculateChunkFitWord(self: *const Self, chunk: *const TextChunk, char_offset_in_chunk: u32, max_width: u32) tb.ChunkFitResult {
+        if (max_width == 0) return .{ .char_count = 0, .width = 0 };
+
+        const total_width = @as(u32, chunk.width) - char_offset_in_chunk;
+        if (total_width == 0) return .{ .char_count = 0, .width = 0 };
+        if (total_width <= max_width) return .{ .char_count = total_width, .width = total_width };
+
+        const wrap_offsets = self.text_buffer.getWrapOffsetsFor(chunk) catch {
+            const fit_width = @min(max_width, total_width);
+            return .{ .char_count = fit_width, .width = fit_width };
+        };
+
+        var last_boundary: ?u32 = null;
+        var first_boundary: ?u32 = null;
+
+        for (wrap_offsets) |wrap_break| {
+            const offset = @as(u32, wrap_break.char_offset);
+            if (offset < char_offset_in_chunk) continue;
+
+            const local_offset = offset - char_offset_in_chunk;
+            if (local_offset >= total_width) break;
+
+            const width_to_boundary = local_offset + 1;
+            if (first_boundary == null) first_boundary = width_to_boundary;
+
+            if (width_to_boundary <= max_width) {
+                last_boundary = width_to_boundary;
+            } else break;
+        }
+
+        if (last_boundary) |width| return .{ .char_count = width, .width = width };
+
+        const line_width = self.wrap_width orelse max_width;
+        const needs_force_break = (first_boundary orelse total_width) > line_width;
+
+        if (needs_force_break) {
+            const fit_width = @min(max_width, total_width);
+            return .{ .char_count = fit_width, .width = fit_width };
+        }
+
+        return .{ .char_count = 0, .width = 0 };
+    }
+
+    pub fn updateVirtualLines(self: *Self) void {
+        const buffer_dirty = self.text_buffer.isViewDirty(self.view_id);
+        if (!self.virtual_lines_dirty and !buffer_dirty) return;
+
+        _ = self.virtual_lines_arena.reset(.free_all);
+        self.virtual_lines = .{};
+        self.cached_line_starts = .{};
+        self.cached_line_widths = .{};
+        self.cached_line_sources = .{};
+        self.cached_line_wrap_indices = .{};
+        self.cached_line_first_vline = .{};
+        self.cached_line_vline_counts = .{};
+        self.truncation_applied = false;
+        const virtual_allocator = self.virtual_lines_arena.allocator();
+
+        // Create output structure for the generic function
+        const output = VirtualLineOutput{
+            .virtual_lines = &self.virtual_lines,
+            .cached_line_starts = &self.cached_line_starts,
+            .cached_line_widths = &self.cached_line_widths,
+            .cached_line_sources = &self.cached_line_sources,
+            .cached_line_wrap_indices = &self.cached_line_wrap_indices,
+            .cached_line_first_vline = &self.cached_line_first_vline,
+            .cached_line_vline_counts = &self.cached_line_vline_counts,
+        };
+
+        // Call the generic calculation function
+        calculateVirtualLinesGeneric(
+            self.text_buffer,
+            self.wrap_mode,
+            self.wrap_width,
+            virtual_allocator,
+            output,
+        );
+
+        self.virtual_lines_dirty = false;
+        self.text_buffer.clearViewDirty(self.view_id);
+    }
+
+    pub fn getVirtualLineCount(self: *Self) u32 {
+        self.updateVirtualLines();
+        return @intCast(self.virtual_lines.items.len);
+    }
+
+    pub fn getVirtualLines(self: *Self) []const VirtualLine {
+        self.updateVirtualLines();
+
+        const all_vlines = self.virtual_lines.items;
+
+        if (self.truncate and self.viewport != null) {
+            self.ensureTruncation();
+        }
+
+        if (self.viewport) |vp| {
+            const start_idx = @min(vp.y, @as(u32, @intCast(all_vlines.len)));
+            const end_idx = @min(start_idx + vp.height, @as(u32, @intCast(all_vlines.len)));
+            return all_vlines[start_idx..end_idx];
+        }
+
+        return all_vlines;
+    }
+
+    pub fn getCachedLineInfo(self: *Self) LineInfo {
+        self.updateVirtualLines();
+
+        // If viewport is set, return only the visible lines' info
+        if (self.viewport) |vp| {
+            const start_idx = @min(vp.y, @as(u32, @intCast(self.cached_line_starts.items.len)));
+            const end_idx = @min(start_idx + vp.height, @as(u32, @intCast(self.cached_line_starts.items.len)));
+
+            const viewport_line_start_cols = self.cached_line_starts.items[start_idx..end_idx];
+            const viewport_line_width_cols = self.cached_line_widths.items[start_idx..end_idx];
+            const viewport_line_sources = self.cached_line_sources.items[start_idx..end_idx];
+            const viewport_line_wraps = self.cached_line_wrap_indices.items[start_idx..end_idx];
+
+            var width_cols_max: u32 = 0;
+            for (viewport_line_width_cols) |w| {
+                width_cols_max = @max(width_cols_max, w);
+            }
+
+            return LineInfo{
+                .line_start_cols = viewport_line_start_cols,
+                .line_width_cols = viewport_line_width_cols,
+                .line_sources = viewport_line_sources,
+                .line_wraps = viewport_line_wraps,
+                .line_width_cols_max = width_cols_max,
+            };
+        }
+
+        return LineInfo{
+            .line_start_cols = self.cached_line_starts.items,
+            .line_width_cols = self.cached_line_widths.items,
+            .line_sources = self.cached_line_sources.items,
+            .line_wraps = self.cached_line_wrap_indices.items,
+            .line_width_cols_max = self.text_buffer.lineWidthColsMax(),
+        };
+    }
+
+    pub fn getLogicalLineInfo(self: *Self) LineInfo {
+        self.updateVirtualLines();
+
+        return LineInfo{
+            .line_start_cols = self.cached_line_starts.items,
+            .line_width_cols = self.cached_line_widths.items,
+            .line_sources = self.cached_line_sources.items,
+            .line_wraps = self.cached_line_wrap_indices.items,
+            .line_width_cols_max = self.text_buffer.lineWidthColsMax(),
+        };
+    }
+
+    pub fn getWrapInfo(self: *Self) WrapInfo {
+        self.updateVirtualLines();
+        return WrapInfo{
+            .line_first_vline = self.cached_line_first_vline.items,
+            .line_vline_counts = self.cached_line_vline_counts.items,
+        };
+    }
+
+    pub fn findVisualLineIndex(self: *Self, logical_row: u32, logical_col: u32) u32 {
+        self.updateVirtualLines();
+
+        const vlines = self.virtual_lines.items;
+        if (vlines.len == 0) return 0;
+
+        const wrap_info = self.getWrapInfo();
+
+        // Clamp logical_row to valid range
+        const clamped_row = if (logical_row >= wrap_info.line_first_vline.len)
+            if (wrap_info.line_first_vline.len > 0) wrap_info.line_first_vline.len - 1 else 0
+        else
+            logical_row;
+
+        if (clamped_row >= wrap_info.line_first_vline.len) return 0;
+
+        const first_vline_idx = wrap_info.line_first_vline[clamped_row];
+        const vline_count = wrap_info.line_vline_counts[clamped_row];
+
+        if (vline_count == 0) return first_vline_idx;
+
+        var i: u32 = 0;
+        while (i < vline_count) : (i += 1) {
+            const vline_idx = first_vline_idx + i;
+            if (vline_idx >= vlines.len) break;
+
+            const vline = &vlines[vline_idx];
+            const vline_start_col = vline.source_col_offset;
+            const vline_end_col = vline_start_col + vline.width_cols;
+
+            const is_last_vline = (i == vline_count - 1);
+
+            // For the end check: use < for all lines except the last line where we use <=
+            // This ensures that a position exactly at vline_end_col goes to the NEXT line
+            // unless this is the last line (where there is no next line)
+            const end_check = if (is_last_vline) logical_col <= vline_end_col else logical_col < vline_end_col;
+
+            if (logical_col >= vline_start_col and end_check) {
+                return vline_idx;
+            }
+        }
+
+        // If not found, return last virtual line for this logical line
+        const last_vline_idx = first_vline_idx + vline_count - 1;
+        if (last_vline_idx < vlines.len) {
+            return last_vline_idx;
+        }
+
+        return first_vline_idx;
+    }
+
+    pub fn getPlainTextIntoBuffer(self: *const Self, out_buffer: []u8) usize {
+        return self.text_buffer.getPlainTextIntoBuffer(out_buffer);
+    }
+
+    pub fn getArenaAllocatedBytes(self: *const Self) usize {
+        return self.virtual_lines_arena.queryCapacity();
+    }
+
+    pub fn setSelection(self: *Self, start: u32, end: u32, bgColor: ?RGBA, fgColor: ?RGBA) void {
+        self.selection = TextSelection{
+            .start = start,
+            .end = end,
+            .bgColor = bgColor,
+            .fgColor = fgColor,
+        };
+    }
+
+    pub fn updateSelection(self: *Self, end: u32, bgColor: ?RGBA, fgColor: ?RGBA) void {
+        if (self.selection) |sel| {
+            self.selection = TextSelection{
+                .start = sel.start,
+                .end = end,
+                .bgColor = bgColor,
+                .fgColor = fgColor,
+            };
+        }
+    }
+
+    pub fn resetSelection(self: *Self) void {
+        self.selection = null;
+    }
+
+    pub fn getSelection(self: *const Self) ?TextSelection {
+        return self.selection;
+    }
+
+    pub fn getTextBuffer(self: *const Self) *UnifiedTextBuffer {
+        return self.text_buffer;
+    }
+
+    pub fn switchToBuffer(self: *Self, buffer: *UnifiedTextBuffer) void {
+        self.text_buffer = buffer;
+        self.virtual_lines_dirty = true;
+    }
+
+    pub fn switchToOriginalBuffer(self: *Self) void {
+        if (self.text_buffer != self.original_text_buffer) {
+            self.text_buffer = self.original_text_buffer;
+            self.virtual_lines_dirty = true;
+        }
+    }
+
+    pub fn setLocalSelection(self: *Self, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?RGBA, fgColor: ?RGBA) bool {
+        self.updateVirtualLines();
+        if (self.truncate and self.viewport != null) {
+            self.ensureTruncation();
+        }
+
+        const anchor_above = anchorY < 0;
+        const focus_above = focusY < 0;
+        const max_y = @as(i32, @intCast(self.virtual_lines.items.len)) - 1;
+        const anchor_below = anchorY > max_y;
+        const focus_below = focusY > max_y;
+
+        if ((anchor_above and focus_above) or (anchor_below and focus_below)) {
+            const had_selection = self.selection != null;
+            self.selection = null;
+            self.selection_anchor_offset = null;
+            return had_selection;
+        }
+
+        const text_end_offset = self.getTextEndOffset();
+
+        const anchor_offset = if (anchor_above or anchorX < 0)
+            0
+        else if (anchor_below)
+            text_end_offset
+        else
+            self.coordsToCharOffset(anchorX, anchorY) orelse {
+                const had_selection = self.selection != null;
+                self.selection = null;
+                self.selection_anchor_offset = null;
+                return had_selection;
+            };
+
+        const focus_offset = if (focus_above or focusX < 0)
+            0
+        else if (focus_below)
+            text_end_offset
+        else
+            self.coordsToCharOffset(focusX, focusY) orelse {
+                const had_selection = self.selection != null;
+                self.selection = null;
+                self.selection_anchor_offset = null;
+                return had_selection;
+            };
+
+        self.selection_anchor_offset = anchor_offset;
+
+        const new_start = @min(anchor_offset, focus_offset);
+        const new_end = @max(anchor_offset, focus_offset);
+
+        // Always store selection, even if zero-width, to preserve anchor for updateLocalSelection
+        const new_selection = TextSelection{
+            .start = new_start,
+            .end = new_end,
+            .bgColor = bgColor,
+            .fgColor = fgColor,
+        };
+
+        const selection_changed = if (self.selection) |old_sel|
+            old_sel.start != new_selection.start or old_sel.end != new_selection.end
+        else
+            true;
+
+        self.selection = new_selection;
+        return selection_changed;
+    }
+
+    pub fn updateLocalSelection(self: *Self, anchorX: i32, anchorY: i32, focusX: i32, focusY: i32, bgColor: ?RGBA, fgColor: ?RGBA) bool {
+        if (self.selection_anchor_offset) |_| {
+            return self.updateLocalSelectionFocusOnly(focusX, focusY, bgColor, fgColor);
+        } else {
+            return self.setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor);
+        }
+    }
+
+    fn updateLocalSelectionFocusOnly(self: *Self, focusX: i32, focusY: i32, bgColor: ?RGBA, fgColor: ?RGBA) bool {
+        const anchor_offset = self.selection_anchor_offset orelse return false;
+
+        self.updateVirtualLines();
+        if (self.truncate and self.viewport != null) {
+            self.applyTruncation();
+        }
+
+        const focus_above = focusY < 0;
+        const max_y = @as(i32, @intCast(self.virtual_lines.items.len)) - 1;
+        const focus_below = focusY > max_y;
+
+        const text_end_offset = self.getTextEndOffset();
+
+        const focus_col_offset = if (focus_above or focusX < 0)
+            0
+        else if (focus_below)
+            text_end_offset
+        else
+            self.coordsToCharOffset(focusX, focusY) orelse return false;
+
+        const new_start = @min(anchor_offset, focus_col_offset);
+        var new_end = @max(anchor_offset, focus_col_offset);
+
+        if (focus_col_offset < anchor_offset) {
+            new_end = @min(new_end + 1, text_end_offset);
+        }
+
+        self.selection = TextSelection{
+            .start = new_start,
+            .end = new_end,
+            .bgColor = bgColor,
+            .fgColor = fgColor,
+        };
+
+        return true;
+    }
+
+    pub fn resetLocalSelection(self: *Self) void {
+        self.selection = null;
+        self.selection_anchor_offset = null;
+    }
+
+    fn getTextEndOffset(self: *Self) u32 {
+        if (self.truncate and self.viewport != null) {
+            self.ensureTruncation();
+        }
+
+        if (self.virtual_lines.items.len == 0) return 0;
+        const last_line_idx = self.virtual_lines.items.len - 1;
+        const last_vline = &self.virtual_lines.items[last_line_idx];
+
+        if (last_vline.is_truncated) {
+            return last_vline.col_offset + last_vline.truncation_suffix_start + (last_vline.width_cols - last_vline.ellipsis_pos - 3);
+        }
+
+        return last_vline.col_offset + last_vline.width_cols;
+    }
+
+    fn coordsToCharOffset(self: *Self, x: i32, y: i32) ?u32 {
+        self.updateVirtualLines();
+        if (self.truncate and self.viewport != null) {
+            self.ensureTruncation();
+        }
+
+        const y_offset: i32 = if (self.viewport) |vp| @intCast(vp.y) else 0;
+        const x_offset: i32 = if (self.viewport) |vp|
+            (if (self.wrap_mode == .none) @intCast(vp.x) else 0)
+        else
+            0;
+
+        if (self.virtual_lines.items.len == 0) {
+            return 0;
+        }
+
+        const abs_y = y + y_offset;
+        const abs_x = x + x_offset;
+
+        const clamped_y = @max(0, @min(abs_y, @as(i32, @intCast(self.virtual_lines.items.len)) - 1));
+
+        const vline_idx: usize = @intCast(clamped_y);
+        const vline = &self.virtual_lines.items[vline_idx];
+        const lineStart = vline.col_offset;
+        const lineWidth = vline.width_cols;
+
+        var localX = @max(0, @min(abs_x, @as(i32, @intCast(lineWidth))));
+
+        if (vline.is_truncated) {
+            const ellipsis_width: u32 = 3;
+            const localX_u32: u32 = @intCast(localX);
+
+            if (localX_u32 >= vline.ellipsis_pos and localX_u32 < vline.ellipsis_pos + ellipsis_width) {
+                localX = @intCast(vline.ellipsis_pos);
+            } else if (localX_u32 >= vline.ellipsis_pos + ellipsis_width) {
+                const suffix_offset = localX_u32 - vline.ellipsis_pos - ellipsis_width;
+                localX = @intCast(vline.truncation_suffix_start + suffix_offset);
+            }
+        }
+
+        const result = lineStart + @as(u32, @intCast(localX));
+
+        return result;
+    }
+
+    /// Pack selection info into u64 for efficient passing
+    /// Returns 0xFFFF_FFFF_FFFF_FFFF for no selection or zero-width selection
+    pub fn packSelectionInfo(self: *const Self) u64 {
+        if (self.selection) |sel| {
+            if (sel.start == sel.end) {
+                return 0xFFFF_FFFF_FFFF_FFFF;
+            }
+            return (@as(u64, sel.start) << 32) | @as(u64, sel.end);
+        } else {
+            return 0xFFFF_FFFF_FFFF_FFFF;
+        }
+    }
+
+    /// Get selected text into buffer - using efficient single-pass API
+    pub fn getSelectedTextIntoBuffer(self: *Self, out_buffer: []u8) usize {
+        const selection = self.selection orelse return 0;
+        if (selection.start == selection.end) return 0;
+        return self.text_buffer.getTextRange(selection.start, selection.end, out_buffer);
+    }
+
+    pub fn getVirtualLineSpans(self: *const Self, vline_idx: usize) VirtualLineSpanInfo {
+        if (vline_idx >= self.virtual_lines.items.len) {
+            return VirtualLineSpanInfo{ .spans = &[_]StyleSpan{}, .source_line = 0, .col_offset = 0 };
+        }
+
+        const vline = &self.virtual_lines.items[vline_idx];
+        const spans = self.text_buffer.getLineSpans(vline.source_line);
+
+        return VirtualLineSpanInfo{
+            .spans = spans,
+            .source_line = vline.source_line,
+            .col_offset = vline.source_col_offset,
+        };
+    }
+
+    pub fn setTabIndicator(self: *Self, indicator: ?u32) void {
+        self.tab_indicator = indicator;
+    }
+
+    pub fn getTabIndicator(self: *const Self) ?u32 {
+        return self.tab_indicator;
+    }
+
+    pub fn setTabIndicatorColor(self: *Self, color: ?RGBA) void {
+        self.tab_indicator_color = color;
+    }
+
+    pub fn getTabIndicatorColor(self: *const Self) ?RGBA {
+        return self.tab_indicator_color;
+    }
+
+    pub fn setTruncate(self: *Self, truncate: bool) void {
+        if (self.truncate != truncate) {
+            self.truncate = truncate;
+            self.virtual_lines_dirty = true;
+            self.truncation_applied = false;
+        }
+    }
+
+    pub fn getTruncate(self: *const Self) bool {
+        return self.truncate;
+    }
+
+    fn ensureTruncation(self: *Self) void {
+        if (!self.truncate or self.viewport == null) return;
+
+        const epoch = self.text_buffer.getContentEpoch();
+        if (self.truncation_applied and self.truncation_epoch == epoch and
+            self.truncation_viewport != null and self.viewport != null and
+            self.truncation_viewport.?.x == self.viewport.?.x and
+            self.truncation_viewport.?.y == self.viewport.?.y and
+            self.truncation_viewport.?.width == self.viewport.?.width and
+            self.truncation_viewport.?.height == self.viewport.?.height)
+        {
+            return;
+        }
+
+        self.applyTruncation();
+        self.truncation_applied = true;
+        self.truncation_epoch = epoch;
+        self.truncation_viewport = self.viewport;
+    }
+
+    fn applyTruncation(self: *Self) void {
+        const vp = self.viewport orelse return;
+        if (vp.width == 0) return;
+
+        const ellipsis_width: u32 = 3;
+
+        for (self.virtual_lines.items) |*vline| {
+            if (vline.width_cols <= vp.width) continue;
+
+            if (vp.width <= ellipsis_width) {
+                vline.chunks.clearRetainingCapacity();
+                vline.width_cols = 0;
+                vline.is_truncated = true;
+                vline.ellipsis_pos = 0;
+                vline.truncation_suffix_start = vline.width_cols;
+                continue;
+            }
+
+            const available_width = vp.width - ellipsis_width;
+            const prefix_width = available_width / 2;
+            const suffix_width = available_width - prefix_width;
+
+            var new_chunks: std.ArrayListUnmanaged(VirtualChunk) = .{};
+
+            var prefix_accumulated: u32 = 0;
+            for (vline.chunks.items) |chunk| {
+                if (prefix_accumulated >= prefix_width) break;
+
+                const space_left = prefix_width - prefix_accumulated;
+                if (chunk.width <= space_left) {
+                    new_chunks.append(self.virtual_lines_arena.allocator(), chunk) catch return;
+                    prefix_accumulated += chunk.width;
+                } else {
+                    var partial = chunk;
+                    partial.width = space_left;
+                    new_chunks.append(self.virtual_lines_arena.allocator(), partial) catch return;
+                    prefix_accumulated += space_left;
+                    break;
+                }
+            }
+
+            new_chunks.append(self.virtual_lines_arena.allocator(), VirtualChunk{
+                .grapheme_start = 0,
+                .width = ellipsis_width,
+                .chunk = &self.ellipsis_chunk,
+            }) catch return;
+
+            const suffix_start_pos = vline.width_cols - suffix_width;
+
+            var pos_accumulated: u32 = 0;
+            for (vline.chunks.items) |chunk| {
+                const chunk_end = pos_accumulated + chunk.width;
+
+                if (chunk_end <= suffix_start_pos) {
+                    pos_accumulated += chunk.width;
+                    continue;
+                }
+
+                if (pos_accumulated >= suffix_start_pos) {
+                    new_chunks.append(self.virtual_lines_arena.allocator(), chunk) catch return;
+                } else {
+                    const offset_in_chunk = suffix_start_pos - pos_accumulated;
+                    var partial = chunk;
+                    partial.grapheme_start += offset_in_chunk;
+                    partial.width = chunk.width - offset_in_chunk;
+                    new_chunks.append(self.virtual_lines_arena.allocator(), partial) catch return;
+                }
+
+                pos_accumulated += chunk.width;
+            }
+
+            vline.chunks.clearRetainingCapacity();
+            vline.chunks.appendSlice(self.virtual_lines_arena.allocator(), new_chunks.items) catch return;
+            vline.width_cols = vp.width;
+            vline.is_truncated = true;
+            vline.ellipsis_pos = prefix_width;
+            vline.truncation_suffix_start = suffix_start_pos;
+        }
+    }
+
+    /// Measure dimensions for given width/height WITHOUT modifying virtual lines cache
+    /// This is useful for Yoga measure functions that need to know dimensions without committing changes
+    /// Special case: width=0 or wrap_mode=.none means "measure intrinsic/max-content width" (no wrapping)
+    pub fn measureForDimensions(self: *Self, width: u32, height: u32) TextBufferViewError!MeasureResult {
+        _ = height; // Height is for future use, currently only width affects layout
+        const epoch = self.text_buffer.getContentEpoch();
+        if (self.cached_measure_result) |result| {
+            if (self.cached_measure_epoch == epoch and self.cached_measure_buffer == self.text_buffer) {
+                if (self.cached_measure_width) |cached_width| {
+                    if (cached_width == width and self.cached_measure_wrap_mode == self.wrap_mode) {
+                        return result;
+                    }
+                }
+            }
+        }
+
+        // No-wrap path avoids allocations by using marker-based line widths.
+        if (width == 0 or self.wrap_mode == .none) {
+            const line_count = self.text_buffer.lineCount();
+            var width_cols_max: u32 = 0;
+            var row: u32 = 0;
+            while (row < line_count) : (row += 1) {
+                width_cols_max = @max(width_cols_max, self.text_buffer.lineWidthAt(row));
+            }
+
+            const result = MeasureResult{
+                .line_count = line_count,
+                .width_cols_max = width_cols_max,
+            };
+
+            self.cached_measure_width = width;
+            self.cached_measure_wrap_mode = self.wrap_mode;
+            self.cached_measure_result = result;
+            self.cached_measure_epoch = epoch;
+            self.cached_measure_buffer = self.text_buffer;
+
+            return result;
+        }
+
+        // Reuse arena capacity to avoid allocation overhead during streaming.
+        _ = self.measure_arena.reset(.retain_capacity);
+        const measure_allocator = self.measure_arena.allocator();
+
+        // Create temporary output structures
+        var temp_virtual_lines = std.ArrayListUnmanaged(VirtualLine){};
+        var temp_line_starts = std.ArrayListUnmanaged(u32){};
+        var temp_line_widths = std.ArrayListUnmanaged(u32){};
+        var temp_line_sources = std.ArrayListUnmanaged(u32){};
+        var temp_line_wrap_indices = std.ArrayListUnmanaged(u32){};
+        var temp_line_first_vline = std.ArrayListUnmanaged(u32){};
+        var temp_line_vline_counts = std.ArrayListUnmanaged(u32){};
+
+        const output = VirtualLineOutput{
+            .virtual_lines = &temp_virtual_lines,
+            .cached_line_starts = &temp_line_starts,
+            .cached_line_widths = &temp_line_widths,
+            .cached_line_sources = &temp_line_sources,
+            .cached_line_wrap_indices = &temp_line_wrap_indices,
+            .cached_line_first_vline = &temp_line_first_vline,
+            .cached_line_vline_counts = &temp_line_vline_counts,
+        };
+
+        // Use width for wrap calculation
+        const wrap_width_for_measure = if (self.wrap_mode != .none and width > 0) width else null;
+
+        // Call generic calculation with temporary structures
+        calculateVirtualLinesGeneric(
+            self.text_buffer,
+            self.wrap_mode,
+            wrap_width_for_measure,
+            measure_allocator,
+            output,
+        );
+
+        // Calculate max width from temp structures
+        var width_cols_max: u32 = 0;
+        for (temp_line_widths.items) |w| {
+            width_cols_max = @max(width_cols_max, w);
+        }
+
+        const result = MeasureResult{
+            .line_count = @intCast(temp_virtual_lines.items.len),
+            .width_cols_max = width_cols_max,
+        };
+
+        self.cached_measure_width = width;
+        self.cached_measure_wrap_mode = self.wrap_mode;
+        self.cached_measure_result = result;
+        self.cached_measure_epoch = epoch;
+        self.cached_measure_buffer = self.text_buffer;
+
+        return result;
+    }
+
+    /// Generic virtual line calculation that writes to provided output structures
+    fn calculateVirtualLinesGeneric(
+        text_buffer: *UnifiedTextBuffer,
+        wrap_mode: WrapMode,
+        wrap_width: ?u32,
+        allocator: Allocator,
+        output: VirtualLineOutput,
+    ) void {
+        if (wrap_mode == .none or wrap_width == null) {
+            // No wrapping - create 1:1 mapping to real lines
+            const Context = struct {
+                text_buffer: *UnifiedTextBuffer,
+                allocator: Allocator,
+                output: VirtualLineOutput,
+                current_vline: ?VirtualLine = null,
+
+                fn segment_callback(ctx_ptr: *anyopaque, line_idx: u32, chunk: *const TextChunk, _: u32) void {
+                    _ = line_idx;
+                    const ctx = @as(*@This(), @ptrCast(@alignCast(ctx_ptr)));
+
+                    if (ctx.current_vline) |*vline| {
+                        vline.chunks.append(ctx.allocator, VirtualChunk{
+                            .grapheme_start = 0,
+                            .width = chunk.width,
+                            .chunk = chunk,
+                        }) catch {};
+                    }
+                }
+
+                fn line_end_callback(ctx_ptr: *anyopaque, line_info: iter_mod.LineInfo) void {
+                    const ctx = @as(*@This(), @ptrCast(@alignCast(ctx_ptr)));
+
+                    const first_vline_idx: u32 = @intCast(ctx.output.virtual_lines.items.len);
+                    ctx.output.cached_line_first_vline.append(ctx.allocator, first_vline_idx) catch {};
+                    ctx.output.cached_line_vline_counts.append(ctx.allocator, 1) catch {};
+
+                    var vline = if (ctx.current_vline) |v| v else VirtualLine.init();
+                    vline.width_cols = line_info.width_cols;
+                    vline.col_offset = line_info.col_offset;
+                    vline.source_line = line_info.line_idx;
+                    vline.source_col_offset = 0;
+
+                    ctx.output.virtual_lines.append(ctx.allocator, vline) catch {};
+                    ctx.output.cached_line_starts.append(ctx.allocator, vline.col_offset) catch {};
+                    ctx.output.cached_line_widths.append(ctx.allocator, vline.width_cols) catch {};
+                    ctx.output.cached_line_sources.append(ctx.allocator, @intCast(line_info.line_idx)) catch {};
+                    ctx.output.cached_line_wrap_indices.append(ctx.allocator, 0) catch {};
+
+                    ctx.current_vline = VirtualLine.init();
+                }
+            };
+
+            var ctx = Context{
+                .text_buffer = text_buffer,
+                .allocator = allocator,
+                .output = output,
+                .current_vline = VirtualLine.init(),
+            };
+
+            text_buffer.walkLinesAndSegments(&ctx, Context.segment_callback, Context.line_end_callback);
+        } else {
+            const wrap_w = wrap_width.?;
+
+            const WrapContext = struct {
+                text_buffer: *UnifiedTextBuffer,
+                allocator: Allocator,
+                output: VirtualLineOutput,
+                wrap_mode: WrapMode,
+                wrap_w: u32,
+                global_char_offset: u32 = 0,
+                line_idx: u32 = 0,
+                line_col_offset: u32 = 0,
+                line_position: u32 = 0,
+                current_vline: VirtualLine = VirtualLine.init(),
+                chunk_idx_in_line: u32 = 0,
+                current_line_first_vline_idx: u32 = 0,
+                current_line_vline_count: u32 = 0,
+
+                last_wrap_chunk_count: u32 = 0,
+                last_wrap_line_position: u32 = 0,
+                last_wrap_global_offset: u32 = 0,
+
+                fn commitVirtualLine(wctx: *@This()) void {
+                    wctx.current_vline.width_cols = wctx.line_position;
+                    wctx.current_vline.source_line = wctx.line_idx;
+                    wctx.current_vline.source_col_offset = wctx.line_col_offset;
+                    wctx.output.virtual_lines.append(wctx.allocator, wctx.current_vline) catch {};
+                    wctx.output.cached_line_starts.append(wctx.allocator, wctx.current_vline.col_offset) catch {};
+                    wctx.output.cached_line_widths.append(wctx.allocator, wctx.current_vline.width_cols) catch {};
+                    wctx.output.cached_line_sources.append(wctx.allocator, wctx.line_idx) catch {};
+                    wctx.output.cached_line_wrap_indices.append(wctx.allocator, wctx.current_line_vline_count) catch {};
+
+                    wctx.current_line_vline_count += 1;
+
+                    wctx.line_col_offset += wctx.line_position;
+                    wctx.current_vline = VirtualLine.init();
+                    wctx.current_vline.col_offset = wctx.global_char_offset;
+                    wctx.line_position = 0;
+
+                    wctx.last_wrap_chunk_count = 0;
+                    wctx.last_wrap_line_position = 0;
+                    wctx.last_wrap_global_offset = 0;
+                }
+
+                fn addVirtualChunk(wctx: *@This(), chunk: *const TextChunk, _: u32, start: u32, width_param: u32) void {
+                    wctx.current_vline.chunks.append(wctx.allocator, VirtualChunk{
+                        .grapheme_start = start,
+                        .width = width_param,
+                        .chunk = chunk,
+                    }) catch {};
+                    wctx.global_char_offset += width_param;
+                    wctx.line_position += width_param;
+                }
+
+                fn segment_callback(ctx_ptr: *anyopaque, _: u32, chunk: *const TextChunk, chunk_idx_in_line: u32) void {
+                    const wctx = @as(*@This(), @ptrCast(@alignCast(ctx_ptr)));
+                    wctx.chunk_idx_in_line = chunk_idx_in_line;
+
+                    if (wctx.wrap_mode == .word) {
+                        const chunk_bytes = chunk.getBytes(wctx.text_buffer.memRegistry());
+                        const wrap_offsets = wctx.text_buffer.getWrapOffsetsFor(chunk) catch &[_]utf8.WrapBreak{};
+                        const is_ascii_only = (chunk.flags & TextChunk.Flags.ASCII_ONLY) != 0;
+                        const graphemes: []const GraphemeInfo = if (is_ascii_only)
+                            &[_]GraphemeInfo{}
+                        else
+                            chunk.getGraphemes(wctx.text_buffer.memRegistry(), wctx.text_buffer.getAllocator(), wctx.text_buffer.tabWidth(), wctx.text_buffer.widthMethod()) catch &[_]GraphemeInfo{};
+                        var grapheme_idx: usize = 0;
+                        var col_delta: i64 = 0;
+
+                        // char_offset tracks COLUMN position within the chunk (not grapheme count)
+                        // chunk.width is also in columns. The loop processes the chunk column by column.
+                        var char_offset: u32 = 0; // Column offset within chunk
+                        var byte_offset: u32 = 0;
+                        var wrap_idx: usize = 0;
+
+                        while (char_offset < chunk.width) {
+                            const remaining_in_chunk = chunk.width - char_offset;
+                            const remaining_on_line = if (wctx.line_position < wctx.wrap_w) wctx.wrap_w - wctx.line_position else 0;
+
+                            var last_wrap_that_fits: ?u32 = null;
+                            var saved_wrap_idx = wrap_idx;
+                            while (wrap_idx < wrap_offsets.len) : (wrap_idx += 1) {
+                                const wrap_break = wrap_offsets[wrap_idx];
+
+                                const break_info = iter_mod.charOffsetToColumn(wrap_break.char_offset, graphemes, &grapheme_idx, &col_delta);
+                                const break_col = break_info.col;
+
+                                // Skip breaks that are before our current column position in the chunk
+                                if (break_col < char_offset) continue;
+
+                                // width_to_boundary: columns needed to reach and include this break
+                                // break_col is the column where the break character starts (relative to chunk)
+                                // char_offset is our current column position (relative to chunk)
+                                // To include the break character, we need: break_col - char_offset + width
+                                const width_to_boundary = break_col - char_offset + break_info.width;
+                                if (width_to_boundary > remaining_on_line or width_to_boundary > remaining_in_chunk) {
+                                    break;
+                                }
+                                last_wrap_that_fits = width_to_boundary;
+                                saved_wrap_idx = wrap_idx + 1;
+                            }
+                            wrap_idx = saved_wrap_idx;
+
+                            var to_add: u32 = 0;
+                            var has_wrap_after: bool = false;
+
+                            if (remaining_in_chunk <= remaining_on_line) {
+                                if (last_wrap_that_fits) |boundary_w| {
+                                    const would_fill_line = wctx.line_position + remaining_in_chunk >= wctx.wrap_w;
+                                    if (would_fill_line and boundary_w < remaining_in_chunk) {
+                                        to_add = boundary_w;
+                                        has_wrap_after = true;
+                                    } else {
+                                        to_add = remaining_in_chunk;
+                                        has_wrap_after = true;
+                                    }
+                                } else {
+                                    to_add = remaining_in_chunk;
+                                }
+                            } else if (last_wrap_that_fits) |boundary_w| {
+                                to_add = boundary_w;
+                                has_wrap_after = true;
+                            } else if (wctx.line_position == 0) {
+                                // Use tracked byte_offset instead of recalculating from scratch (avoids O(n²))
+                                const remaining_bytes = chunk_bytes[byte_offset..];
+                                const wrap_result = utf8.findWrapPosByWidth(remaining_bytes, remaining_on_line, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                to_add = wrap_result.columns_used;
+                                byte_offset += wrap_result.byte_offset;
+                                if (to_add == 0) {
+                                    to_add = 1;
+                                    const single_result = utf8.findWrapPosByWidth(remaining_bytes, 1, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                    byte_offset += single_result.byte_offset;
+                                }
+                            } else if (wctx.last_wrap_chunk_count > 0 and
+                                wctx.last_wrap_chunk_count <= wctx.current_vline.chunks.items.len)
+                            {
+                                var accumulated_width: u32 = 0;
+                                for (wctx.current_vline.chunks.items[0..wctx.last_wrap_chunk_count]) |vchunk| {
+                                    accumulated_width += vchunk.width;
+                                }
+
+                                const chunks_after_wrap = wctx.current_vline.chunks.items[wctx.last_wrap_chunk_count..];
+                                var chunks_to_move_count = chunks_after_wrap.len;
+                                var split_chunk: ?VirtualChunk = null;
+
+                                if (accumulated_width > wctx.last_wrap_line_position) {
+                                    const last_chunk_idx = wctx.last_wrap_chunk_count - 1;
+                                    const last_chunk = wctx.current_vline.chunks.items[last_chunk_idx];
+                                    const overhang = accumulated_width - wctx.last_wrap_line_position;
+
+                                    split_chunk = VirtualChunk{
+                                        .grapheme_start = last_chunk.grapheme_start + last_chunk.width - overhang,
+                                        .width = overhang,
+                                        .chunk = last_chunk.chunk,
+                                    };
+
+                                    wctx.current_vline.chunks.items[last_chunk_idx].width -= overhang;
+
+                                    chunks_to_move_count += 1;
+                                }
+
+                                const saved_chunks_result = wctx.allocator.alloc(VirtualChunk, chunks_to_move_count);
+                                if (saved_chunks_result) |saved_chunks| {
+                                    var saved_idx: usize = 0;
+
+                                    if (split_chunk) |sc| {
+                                        saved_chunks[saved_idx] = sc;
+                                        saved_idx += 1;
+                                    }
+
+                                    @memcpy(saved_chunks[saved_idx..], chunks_after_wrap);
+
+                                    wctx.line_position = wctx.last_wrap_line_position;
+                                    wctx.global_char_offset = wctx.last_wrap_global_offset;
+                                    wctx.current_vline.chunks.items.len = wctx.last_wrap_chunk_count;
+
+                                    commitVirtualLine(wctx);
+
+                                    for (saved_chunks) |vchunk| {
+                                        wctx.current_vline.chunks.append(wctx.allocator, vchunk) catch {};
+                                        wctx.global_char_offset += vchunk.width;
+                                        wctx.line_position += vchunk.width;
+                                    }
+                                } else |_| {
+                                    commitVirtualLine(wctx);
+                                }
+
+                                continue;
+                            } else {
+                                commitVirtualLine(wctx);
+                                if (char_offset > 0) {
+                                    const pos_result = utf8.findPosByWidth(chunk_bytes, char_offset, wctx.text_buffer.tabWidth(), is_ascii_only, false, wctx.text_buffer.widthMethod());
+                                    byte_offset = pos_result.byte_offset;
+                                }
+                                const remaining_bytes = chunk_bytes[byte_offset..];
+                                const wrap_result = utf8.findWrapPosByWidth(remaining_bytes, wctx.wrap_w, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                to_add = wrap_result.columns_used;
+                                byte_offset += wrap_result.byte_offset;
+                                if (to_add == 0) {
+                                    to_add = 1;
+                                    const single_result = utf8.findWrapPosByWidth(remaining_bytes, 1, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                    byte_offset += single_result.byte_offset;
+                                }
+                            }
+
+                            if (to_add > 0) {
+                                const position_before_add = wctx.line_position;
+                                const offset_before_add = wctx.global_char_offset;
+
+                                addVirtualChunk(wctx, chunk, chunk_idx_in_line, char_offset, to_add);
+                                char_offset += to_add;
+
+                                if (has_wrap_after) {
+                                    const wrap_pos_in_added = if (last_wrap_that_fits) |boundary_w|
+                                        @min(boundary_w, to_add)
+                                    else
+                                        to_add;
+
+                                    wctx.last_wrap_chunk_count = @intCast(wctx.current_vline.chunks.items.len);
+                                    wctx.last_wrap_line_position = position_before_add + wrap_pos_in_added;
+                                    wctx.last_wrap_global_offset = offset_before_add + wrap_pos_in_added;
+                                }
+
+                                if (wctx.line_position >= wctx.wrap_w and char_offset < chunk.width) {
+                                    if (has_wrap_after or wctx.last_wrap_chunk_count > 0) {
+                                        commitVirtualLine(wctx);
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        const chunk_bytes = chunk.getBytes(wctx.text_buffer.memRegistry());
+                        const is_ascii_only = (chunk.flags & TextChunk.Flags.ASCII_ONLY) != 0;
+                        var byte_offset: usize = 0;
+                        var char_offset: u32 = 0;
+
+                        while (char_offset < chunk.width) {
+                            const remaining_width = if (wctx.line_position < wctx.wrap_w) wctx.wrap_w - wctx.line_position else 0;
+
+                            if (remaining_width == 0) {
+                                if (wctx.line_position > 0) {
+                                    commitVirtualLine(wctx);
+                                    continue;
+                                }
+                                const remaining_bytes = chunk_bytes[byte_offset..];
+                                const force_result = utf8.findWrapPosByWidth(remaining_bytes, 1, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                if (force_result.grapheme_count > 0) {
+                                    addVirtualChunk(wctx, chunk, chunk_idx_in_line, char_offset, force_result.columns_used);
+                                    char_offset += force_result.columns_used;
+                                    byte_offset += force_result.byte_offset;
+                                } else {
+                                    break;
+                                }
+                                continue;
+                            }
+
+                            const remaining_bytes = chunk_bytes[byte_offset..];
+                            const wrap_result = utf8.findWrapPosByWidth(
+                                remaining_bytes,
+                                remaining_width,
+                                wctx.text_buffer.tabWidth(),
+                                is_ascii_only,
+                                wctx.text_buffer.widthMethod(),
+                            );
+
+                            if (wrap_result.grapheme_count == 0) {
+                                if (wctx.line_position > 0) {
+                                    commitVirtualLine(wctx);
+                                    continue;
+                                }
+                                const force_result = utf8.findWrapPosByWidth(remaining_bytes, 1000, wctx.text_buffer.tabWidth(), is_ascii_only, wctx.text_buffer.widthMethod());
+                                if (force_result.grapheme_count > 0) {
+                                    addVirtualChunk(wctx, chunk, chunk_idx_in_line, char_offset, force_result.columns_used);
+                                    char_offset += force_result.columns_used;
+                                    byte_offset += force_result.byte_offset;
+                                    if (char_offset < chunk.width) {
+                                        commitVirtualLine(wctx);
+                                    }
+                                }
+                                break;
+                            }
+
+                            addVirtualChunk(wctx, chunk, chunk_idx_in_line, char_offset, wrap_result.columns_used);
+                            char_offset += wrap_result.columns_used;
+                            byte_offset += wrap_result.byte_offset;
+
+                            if (wctx.line_position >= wctx.wrap_w and char_offset < chunk.width) {
+                                commitVirtualLine(wctx);
+                            }
+                        }
+                    }
+                }
+
+                fn line_end_callback(ctx_ptr: *anyopaque, line_info: iter_mod.LineInfo) void {
+                    const wctx = @as(*@This(), @ptrCast(@alignCast(ctx_ptr)));
+
+                    if (wctx.current_vline.chunks.items.len > 0 or line_info.width_cols == 0) {
+                        wctx.current_vline.width_cols = wctx.line_position;
+                        wctx.current_vline.source_line = wctx.line_idx;
+                        wctx.current_vline.source_col_offset = wctx.line_col_offset;
+                        wctx.output.virtual_lines.append(wctx.allocator, wctx.current_vline) catch {};
+                        wctx.output.cached_line_starts.append(wctx.allocator, wctx.current_vline.col_offset) catch {};
+                        wctx.output.cached_line_widths.append(wctx.allocator, wctx.current_vline.width_cols) catch {};
+                        wctx.output.cached_line_sources.append(wctx.allocator, wctx.line_idx) catch {};
+                        wctx.output.cached_line_wrap_indices.append(wctx.allocator, wctx.current_line_vline_count) catch {};
+                        wctx.current_line_vline_count += 1;
+                    }
+
+                    wctx.output.cached_line_first_vline.append(wctx.allocator, wctx.current_line_first_vline_idx) catch {};
+                    wctx.output.cached_line_vline_counts.append(wctx.allocator, wctx.current_line_vline_count) catch {};
+
+                    wctx.global_char_offset += 1;
+
+                    wctx.line_idx += 1;
+                    wctx.line_col_offset = 0;
+                    wctx.line_position = 0;
+                    wctx.current_vline = VirtualLine.init();
+                    wctx.current_vline.col_offset = wctx.global_char_offset;
+                    wctx.last_wrap_chunk_count = 0;
+                    wctx.last_wrap_line_position = 0;
+                    wctx.last_wrap_global_offset = 0;
+                    wctx.chunk_idx_in_line = 0;
+                    wctx.current_line_first_vline_idx = @intCast(wctx.output.virtual_lines.items.len);
+                    wctx.current_line_vline_count = 0;
+                }
+            };
+
+            var wrap_ctx = WrapContext{
+                .text_buffer = text_buffer,
+                .allocator = allocator,
+                .output = output,
+                .wrap_mode = wrap_mode,
+                .wrap_w = wrap_w,
+            };
+
+            text_buffer.walkLinesAndSegments(&wrap_ctx, WrapContext.segment_callback, WrapContext.line_end_callback);
+        }
+    }
+};