fix(buffer): use counted grapheme tracking to prevent WrongGeneration panics

The panic came from a model mismatch: GraphemeTracker tracked only ID presence,
while interned IDs can appear in multiple cells. During set(), remove->add
could briefly drop an ID to refcount 0, allowing slot reuse and generation bump.

Author: simonklee

packages/core/src/zig/buffer.zig

@@ -440,6 +440,7 @@ pub const OptimizedBuffer = struct {
         const prev_char = self.buffer.char[index];
         const prev_attr = self.buffer.attributes[index];
         const prev_link_id = ansi.TextAttributes.getLinkId(prev_attr);
+        var tracker_replaced = false;
 
         // If overwriting a grapheme span (start or continuation) with a different char, clear that span first
         if ((gp.isGraphemeChar(prev_char) or gp.isContinuationChar(prev_char)) and prev_char != cell.char) {
@@ -449,15 +450,14 @@ pub const OptimizedBuffer = struct {
             const right = gp.charRightExtent(prev_char);
             const id = gp.graphemeIdFromChar(prev_char);
 
-            // Skip tracker remove when the new cell reuses the same grapheme ID
-            // (different extent bits but same pool slot). Removing would decref
-            // to 0, freeing the slot; a concurrent alloc could then reuse it and
-            // bump the generation, making the later tracker.add() hit WrongGeneration.
-            const new_is_grapheme = gp.isGraphemeChar(cell.char);
-            const new_id = if (new_is_grapheme) gp.graphemeIdFromChar(cell.char) else 0;
-            if (!(new_is_grapheme and new_id == id)) {
-                self.grapheme_tracker.remove(id);
-            }
+            const new_grapheme_id: ?u32 = blk: {
+                if (!gp.isGraphemeChar(cell.char)) break :blk null;
+                const new_width = gp.charRightExtent(cell.char) + 1;
+                if (x + new_width > self.width) break :blk null;
+                break :blk gp.graphemeIdFromChar(cell.char);
+            };
+            self.grapheme_tracker.replace(id, new_grapheme_id);
+            tracker_replaced = true;
 
             const span_start = index - @min(left, index - row_start);
             const span_end = index + @min(right, row_end - index);
@@ -512,7 +512,10 @@ pub const OptimizedBuffer = struct {
             self.buffer.attributes[index] = cell.attributes;
 
             const id: u32 = gp.graphemeIdFromChar(cell.char);
-            self.grapheme_tracker.add(id);
+            const is_same_grapheme_start = gp.isGraphemeChar(prev_char) and prev_char == cell.char;
+            if (!tracker_replaced and !is_same_grapheme_start) {
+                self.grapheme_tracker.add(id);
+            }
 
             const new_link_id = ansi.TextAttributes.getLinkId(cell.attributes);
             if (prev_link_id != 0 and prev_link_id != new_link_id) {
@@ -598,7 +601,7 @@ pub const OptimizedBuffer = struct {
     /// Calculate the real byte size of the character buffer including grapheme pool data
     pub fn getRealCharSize(self: *const OptimizedBuffer) u32 {
         const total_chars = self.width * self.height;
-        const grapheme_count = self.grapheme_tracker.getGraphemeCount();
+        const grapheme_count = self.grapheme_tracker.getGraphemeCellCount();
         const total_grapheme_bytes = self.grapheme_tracker.getTotalGraphemeBytes();
 
         const regular_char_bytes = (total_chars - grapheme_count) * @sizeOf(u32);

packages/core/src/zig/grapheme.zig

@@ -499,18 +499,20 @@ pub fn deinitGlobalPool() void {
 
 pub const GraphemeTracker = struct {
     pool: *GraphemePool,
-    used_ids: std.AutoHashMap(u32, void),
+    used_ids: std.AutoHashMap(u32, u32), // id -> number of cells in this buffer
 
     pub fn init(allocator: std.mem.Allocator, pool: *GraphemePool) GraphemeTracker {
         return .{
             .pool = pool,
-            .used_ids = std.AutoHashMap(u32, void).init(allocator),
+            .used_ids = std.AutoHashMap(u32, u32).init(allocator),
         };
     }
 
     fn decRefAll(self: *GraphemeTracker) void {
         var it = self.used_ids.keyIterator();
         while (it.next()) |idp| {
+            // Pool refs are tracked per ID (first/last cell transition), so clear
+            // decrefs once per tracked ID, not once per per-buffer cell count.
             self.pool.decref(idp.*) catch {};
         }
     }
@@ -530,18 +532,34 @@ pub const GraphemeTracker = struct {
             std.debug.panic("GraphemeTracker.add failed: {}\n", .{err});
         };
         if (!res.found_existing) {
+            res.value_ptr.* = 1;
             self.pool.incref(id) catch |err| {
                 std.debug.panic("GraphemeTracker.add incref failed: {}\n", .{err});
             };
+        } else {
+            res.value_ptr.* += 1;
         }
     }
 
     pub fn remove(self: *GraphemeTracker, id: u32) void {
+        const count_ptr = self.used_ids.getPtr(id) orelse return;
+        if (count_ptr.* > 1) {
+            count_ptr.* -= 1;
+            return;
+        }
+
         if (self.used_ids.remove(id)) {
             self.pool.decref(id) catch {};
         }
     }
 
+    pub fn replace(self: *GraphemeTracker, old_id: ?u32, new_id: ?u32) void {
+        if (old_id != null and new_id != null and old_id.? == new_id.?) return;
+
+        if (new_id) |id| self.add(id);
+        if (old_id) |id| self.remove(id);
+    }
+
     pub fn contains(self: *const GraphemeTracker, id: u32) bool {
         return self.used_ids.contains(id);
     }
@@ -554,13 +572,23 @@ pub const GraphemeTracker = struct {
         return @intCast(self.used_ids.count());
     }
 
+    pub fn getGraphemeCellCount(self: *const GraphemeTracker) u32 {
+        var total: u32 = 0;
+        var it = self.used_ids.valueIterator();
+        while (it.next()) |count_ptr| {
+            total += count_ptr.*;
+        }
+        return total;
+    }
+
     pub fn getTotalGraphemeBytes(self: *const GraphemeTracker) u32 {
         var total_bytes: u32 = 0;
-        var it = self.used_ids.keyIterator();
-        while (it.next()) |idp| {
-            const id = idp.*;
+        var it = self.used_ids.iterator();
+        while (it.next()) |entry| {
+            const id = entry.key_ptr.*;
+            const count = entry.value_ptr.*;
             if (self.pool.get(id)) |bytes| {
-                total_bytes += @intCast(bytes.len);
+                total_bytes += @as(u32, @intCast(bytes.len)) * count;
             } else |_| {
                 // If we can't get the bytes, this shouldn't happen but handle gracefully
                 continue;

packages/core/src/zig/tests/grapheme_test.zig

@@ -647,6 +647,12 @@ test "GraphemeTracker - add same grapheme twice increfs once" {
         tracker.add(id); // Should not incref again
 
         try std.testing.expectEqual(@as(u32, 1), tracker.getGraphemeCount());
+        try std.testing.expectEqual(@as(u32, 2), tracker.getGraphemeCellCount());
+        try std.testing.expectEqual(@as(u32, 2), tracker.getTotalGraphemeBytes());
+
+        tracker.remove(id);
+        try std.testing.expect(tracker.contains(id));
+        try std.testing.expectEqual(@as(u32, 1), tracker.getGraphemeCellCount());
 
         // After deinit (via defer), tracker decrefs once, bringing refcount to 0
     }