79da83da

test: the grid's wide flags are pinned against ghostty's page cells

a73x 2026-09-04 18:04

Commit message

test: the grid's wide flags are pinned against ghostty's page cells

Deleting `Engine.clipCol` and `Engine.snapWide` took the only cross-check of a
mirrored grid's wide flags against ghostty's own with it. The plain dump cannot
replace it: a spacer mis-tagged as narrow carries the same text and shifts
every clip and every highlight past it by one column.

So the oracle reads `cell.wide` off the page the way `encodeRowAt` reads it and
asks the grid for the same answer at every column of every row. The screen puts
wide glyphs at two different columns on one row and ends another with a glyph
that does not fit its last column, so ghostty leaves a spacer_head there and
wraps the glyph to the row below. A tail assertion refuses a screen that does
not actually hold all four shapes, or the comparison is a loop over narrow
cells that grades nothing.

Watched to fail: mapping the encoder's spacer_head to narrow reports
"wide flag diverged at col 11 row 1: engine says spacer_head, grid says narrow".

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CsWfuJFQbTfGtKZLS5qw4q

src/engine/engine.zig

+        try std.testing.expectEqual(e.cursorPos().y, g.cursor.y);
+// The wide flag is the half of a cell that `dumpPlain` cannot grade: a spacer
+// mis-tagged as narrow carries the same text and shifts every clip and every
+// highlight past it by one column. So this reads ghostty's own `cell.wide`
+// through the page, the way `encodeRowAt` reads it, and asks the mirrored grid
+// for the same answer at every column of every row.
+test "grid oracle: every cell's wide flag matches ghostty's page cell" {
+    const alloc = std.testing.allocator;
+    const cols: u16 = 12;
+    const rows: u16 = 3;
+    var e = try Engine.init(alloc, .{ .cols = cols, .rows = rows });
+    defer e.deinit();
+    // Row 0 puts wide glyphs at two different columns, so a rule that only
+    // works at an even column fails here. Row 1 ends with a wide glyph that
+    // does not fit its last column: ghostty leaves a spacer_head there and
+    // wraps the glyph itself onto row 2.
+    e.feed("ab\u{6f22}cd\u{1F600}z\r\n0123456789a\u{6f22}");
+    const g = try Grid.init(alloc, 1, 1);
+    defer g.deinit();
+    try e.mirrorInto(g);
+    var seen = [_]bool{false} ** 4;
+    var y: u16 = 0;
+    while (y < rows) : (y += 1) {
+        const screen = e.term.screens.active;
+        const pin = screen.pages.pin(.{ .viewport = .{ .x = 0, .y = y } }).?;
+        const page = &pin.node.data;
+        const cells = page.getCells(pin.rowAndCell().row);
+        var x: u16 = 0;
+        while (x < cols) : (x += 1) {
+            const want: proto.Wide = switch (cells[x].wide) {
+                .narrow => .narrow,
+                .wide => .wide,
+                .spacer_tail => .spacer_tail,
+                .spacer_head => .spacer_head,
+            };
+            seen[@intFromEnum(want)] = true;
+            const got = g.lines[y].cells[x].wide;
+            if (got != want) {
+                std.debug.print(
+                    "wide flag diverged at col {d} row {d}: engine says {s}, grid says {s}\n",
+                    .{ x, y, @tagName(want), @tagName(got) },
+                );
+                return error.WideFlagDiverged;
+            }
+        }
+    }
+    // Without this the loop above could be twelve narrow cells three times over
+    // and grade nothing: the screen has to hold every shape it claims to.
+    for (seen, 0..) |s, i| {
+        if (!s) {
+            std.debug.print("screen never held a {s} cell\n", .{@tagName(@as(proto.Wide, @enumFromInt(i)))});
+            return error.ScreenMissesAWideShape;
+        }
+    }
+}