perf(tui): optimize editor and text layout wrapping

Optimize TUI editor/plain-text layout hot paths.\n\n- reuse wrap segment widths in editor visual-line layout\n- reuse segment widths for editor logical column advancement\n- preallocate editor and text layout line arrays\n- avoid redundant token whitespace scans\n- add printable-ASCII token width fast path\n\nAutoresearch benchmark improved from 514.174ms to 73.791ms with edit/text line counts unchanged.\n\nChecks passed: zig build test, CI formatting, CI linux/macos tests.

Author: igorsheg

src/tui/edit/layout.zig

@@ -54,6 +54,7 @@ fn buildVirtualLines(buffer: *const EditBuffer, config: LayoutConfig, allocator:
     errdefer lines.deinit(allocator);
 
     const items = buffer.text();
+    try lines.ensureTotalCapacity(allocator, estimateVirtualLineCapacity(items.len, config.width_cols));
     const first_text_width = if (config.width_cols > config.first_line_text_col)
         config.width_cols - config.first_line_text_col
     else
@@ -103,6 +104,11 @@ fn buildVirtualLines(buffer: *const EditBuffer, config: LayoutConfig, allocator:
     return try lines.toOwnedSlice(allocator);
 }
 
+fn estimateVirtualLineCapacity(text_len: usize, width_cols: u32) usize {
+    if (text_len == 0) return 1;
+    return @max(@as(usize, 1), text_len / @max(@as(usize, width_cols), 1) + 2);
+}
+
 fn appendWrappedSlices(
     out: *std.ArrayList(VirtualLine),
     line_text: []const u8,
@@ -129,14 +135,17 @@ fn appendWrappedSlices(
             .byte_end = base_start + @as(u32, @intCast(segment.end)),
             .logical_line = logical_line,
             .logical_col_start = logical_col_start,
-            .width_cols = @intCast(grapheme_mod.strWidth(line_text[segment.start..segment.end], width_method)),
+            .width_cols = segment.width_cols,
             .text_col = current_text_col,
             .kind = current_kind,
         });
 
         if (segment.next_start >= line_text.len) break;
 
-        logical_col_start += @intCast(grapheme_mod.strWidth(line_text[start..segment.next_start], width_method));
+        // Editor layout uses default SegmentOptions, which preserve separator bytes:
+        // the measured segment covers the same byte range used for logical column advancement.
+        std.debug.assert(segment.next_start == segment.end);
+        logical_col_start += segment.width_cols;
         start = segment.next_start;
         current_kind = .wrapped_continuation;
         current_text_col = continuation_text_col;

src/tui/text/layout.zig

@@ -164,6 +164,7 @@ fn wrapLogicalLines(text: []const u8, allocator: std.mem.Allocator, max_width: ?
 
     var lines: std.ArrayListUnmanaged(Line) = .empty;
     errdefer lines.deinit(allocator);
+    try lines.ensureTotalCapacity(allocator, estimateLineCapacity(text.len, max_width));
 
     if (text.len == 0) {
         try lines.append(allocator, .{ .start = 0, .end = 0 });
@@ -200,6 +201,7 @@ fn wrapLogicalLinesWithBreaks(text: []const u8, allocator: std.mem.Allocator, ma
 
     var lines: std.ArrayListUnmanaged(Line) = .empty;
     errdefer lines.deinit(allocator);
+    try lines.ensureTotalCapacity(allocator, estimateLineCapacity(text.len, max_width));
 
     if (text.len == 0) {
         try lines.append(allocator, .{ .start = 0, .end = 0 });
@@ -223,6 +225,12 @@ fn wrapLogicalLinesWithBreaks(text: []const u8, allocator: std.mem.Allocator, ma
     return try lines.toOwnedSlice(allocator);
 }
 
+fn estimateLineCapacity(text_len: usize, max_width: ?u32) usize {
+    if (text_len == 0) return 1;
+    const width = if (max_width) |w| @max(@as(usize, w), 1) else text_len;
+    return @max(@as(usize, 1), text_len / width + 2);
+}
+
 fn appendCharWrappedLine(lines: *std.ArrayListUnmanaged(Line), allocator: std.mem.Allocator, text: []const u8, line_start: usize, line_end: usize, max_width: u32, width_method: grapheme.WidthMethod) !void {
     if (line_start == line_end) {
         try lines.append(allocator, .{ .start = line_start, .end = line_start });

src/tui/wrap/breaks.zig

@@ -42,9 +42,8 @@ pub fn nextSegment(
 
     while (current_start < line.len) {
         const token = nextToken(line, current_start);
-        const token_text = token.text(line);
-        const token_width = grapheme.strWidth(token_text, width_method);
-        const token_is_whitespace = isAllWhitespace(token_text);
+        const token_width = token.width(line, width_method);
+        const token_is_whitespace = isWhitespace(line[token.start]);
 
         if (token_width > max_width) {
             if (current_width > 0) {
@@ -105,33 +104,35 @@ pub fn nextSegment(
 pub const Token = struct {
     start: usize,
     end: usize,
+    ascii_printable: bool,
 
     pub fn text(self: Token, line: []const u8) []const u8 {
         return line[self.start..self.end];
     }
+
+    pub fn width(self: Token, line: []const u8, width_method: grapheme.WidthMethod) usize {
+        if (self.ascii_printable) return self.end - self.start;
+        return grapheme.strWidth(self.text(line), width_method);
+    }
 };
 
 pub fn nextToken(line: []const u8, start: usize) Token {
-    if (start >= line.len) return .{ .start = start, .end = start };
+    if (start >= line.len) return .{ .start = start, .end = start, .ascii_printable = true };
     const is_ws = isWhitespace(line[start]);
     var pos = start;
+    var ascii_printable = true;
     while (pos < line.len) : (pos += 1) {
-        if (isWhitespace(line[pos]) != is_ws) break;
+        const c = line[pos];
+        if (isWhitespace(c) != is_ws) break;
+        if (c < 0x20 or c > 0x7E) ascii_printable = false;
     }
-    return .{ .start = start, .end = pos };
+    return .{ .start = start, .end = pos, .ascii_printable = ascii_printable };
 }
 
 pub fn isWhitespace(c: u8) bool {
     return c == ' ' or c == '\t';
 }
 
-pub fn isAllWhitespace(s: []const u8) bool {
-    for (s) |c| {
-        if (!isWhitespace(c)) return false;
-    }
-    return true;
-}
-
 pub fn skipWhitespace(line: []const u8, start: usize) usize {
     var pos = start;
     while (pos < line.len and isWhitespace(line[pos])) : (pos += 1) {}
@@ -191,3 +192,10 @@ test "nextSegment preserve policy keeps separator bytes on previous line" {
     const seg2 = nextSegment("hello world", seg1.next_start, 5, true, .{}, .wcwidth).?;
     try testing.expectEqualStrings("world", seg2.text("hello world"));
 }
+
+test "token width fast path matches grapheme width for printable ascii" {
+    const text = "plain ascii token";
+    const token = nextToken(text, 0);
+    try testing.expect(token.ascii_printable);
+    try testing.expectEqual(grapheme.strWidth(token.text(text), .wcwidth), token.width(text, .wcwidth));
+}