63427849

feat: the client grid, pinned against the engine as its oracle

a73x 2026-09-04 18:04

Commit message

feat: the client grid, pinned against the engine as its oracle

grid.zig is the flat cell store a replica will hold instead of a second
emulator: rows of Cell, each slicing its text out of the row's own byte
list, filled from protocol.CellRow and nothing else. It imports only std
and protocol.zig, so it still compiles for wasm32-freestanding, and the
bridge that turns an authored screen into one -- Engine.mirrorInto -- and
the tests that grade it live in engine.zig, where ghostty already is.

Two rules moved off the brief, both because the engine is the authority
and the brief's expected values were not what the engine produces.

dumpPlain drops the trailing blank ROWS. ghostty's plainString ends the
dump at the last row with anything on it, so a 24-row screen holding two
lines dumps two lines and no newline after them; the first draft joined
all 24 and the oracle read back twenty-two extra newlines. Interior blank
rows still stand -- they are a gap the user typed, not an unwritten tail.
The unit test's expected string moved with the rule, "a b\n\n" to "a b".

clipCol on a full-width pane returns the last COLUMN, not the last written
one. On a 6-wide grid holding four cells, the brief expected 3 and both
the engine and the code it shipped return 5: trailing blanks are cells a
pane paints like any other, and only a wide glyph cut by the pane edge
steps the answer inward.

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

src/engine/engine.zig

@@ @@ -4,6 +4,10 @@ @@
+const std = @import("std");
+const vt = @import("ghostty-vt");
+const proto = @import("protocol.zig");
+/// The client-side grid this engine is the oracle for. A direct file import
+/// rather than the `term` root, so `grid.zig` never pulls ghostty into the
+/// wasm build by importing back.
+const Grid = @import("grid.zig").Grid;
+/// MuxHandler's own `vt` method shadows the `vt` import inside its body,
+/// so the dep types it names are spelled through these aliases.
@@ @@ -350,7 +354,7 @@ pub const Engine = struct { @@
+    /// The last grid column of row `y` that fits in `view`, or null when not one
+    /// character does. Inwards, unlike `snapWide`: a pane edge is a wall, and
+    /// half a wide glyph past it is a column stolen from the neighbour.
+    pub fn clipCol(self: *Engine, y: u16, view: RowView) ?u16 {
+        if (view.cols == 0 or self.term.cols == 0) return null;
+        var hi: u16 = @min(view.cols - 1, @as(u16, @intCast(self.term.cols - 1)));
+        const screen = self.term.screens.active;
@@ @@ -375,7 +379,7 @@ pub const Engine = struct { @@
+    /// ghostty then emits the WHOLE character, which in `dumpVtRowSpan`'s three
+    /// pieces emits a straddling one TWICE. Outwards: half a character under the
+    /// pointer means the character is under the pointer.
+    pub fn snapWide(self: *Engine, y: u16, from: u16, to: u16) struct { from: u16, to: u16 } {
+        const screen = self.term.screens.active;
+        const last: u16 = @intCast(self.term.cols - 1);
+        var lo = from;
@@ @@ -695,6 +699,22 @@ pub const Engine = struct { @@
+        return .{ .first = first, .count = n, .bytes = try list.toOwnedSlice(alloc) };
+    /// Encode every viewport row into `g` — the test bridge between an
+    /// authored screen and the grid a client would hold, and the only way a
+    /// harness gets a Grid from bytes without a daemon.
+    pub fn mirrorInto(self: *Engine, g: *Grid) !void {
+        if (g.cols != self.term.cols or g.rows != self.term.rows)
+            try g.resize(@intCast(self.term.cols), @intCast(self.term.rows));
+        var y: u16 = 0;
+        while (y < self.term.rows) : (y += 1) {
+            const row = try self.encodeViewportRow(self.alloc, y);
+            defer self.alloc.free(row);
+            try g.applyRow(y, row);
+        }
+        const cur = self.cursorPos();
+        g.cursor = .{ .x = cur.x, .y = cur.y };
+    }
+    /// Screen-space rows, zero being the oldest retained. Formatting writes
+    /// into a fixed-size allocation: hostile coordinates cannot blow it up.
+    pub fn extractSelection(
+        std.debug.print("\ncells-measure {s}: vt={d} cells={d} ratio={d:.2}\n", .{ s.name, v, c, @as(f64, @floatFromInt(c)) / @as(f64, @floatFromInt(v)) });
+/// The engine's plain dump with each row's trailing spaces removed, which is
+/// the form a client can hold. ghostty dumps with `trim = false`, so a space
+/// a program actually wrote at the end of a row survives into
+/// `Engine.dumpPlain`; no replica ever held one, because the VT formatter
+/// that fed the old wire trims trailing whitespace (see `dumpVtRowSpan`) and
+/// the e2e convergence diff strips it as a formatting difference between two
+/// correct grids. The grid trims per row for the same reason, so the oracle
+/// compares through the same trim rather than pretending the two dumps agree
+/// on bytes nothing downstream distinguishes.
+fn trimRowTails(alloc: std.mem.Allocator, s: []const u8) ![]const u8 {
+    var out: std.ArrayList(u8) = .empty;
+    errdefer out.deinit(alloc);
+    var it = std.mem.splitScalar(u8, s, '\n');
+    var first = true;
+    while (it.next()) |line| {
+        if (!first) try out.append(alloc, '\n');
+        first = false;
+        try out.appendSlice(alloc, std.mem.trimRight(u8, line, " "));
+    }
+    return out.toOwnedSlice(alloc);
+}
+test "grid oracle: the grid's dumpPlain and cursor agree with the engine's for every screen shape" {
+    const alloc = std.testing.allocator;
+    const screens = [_][]const u8{
+        "plain text\r\nsecond line",
+        "w\u{6f22}\u{5b57}x e\u{301} \u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F467} end",
+        "\x1b[1;31mred bold\x1b[0m \x1b[44mblue bg\x1b[0m\x1b[K",
+        "short\r\n\r\n\r\nafter blanks",
+        "\x1b[?1049h\x1b[HTUI on alt\x1b[5;10Hcursor here",
+        "line one\r\nline two\r\n" ** 30, // scrolled: history exists, viewport is the tail
+        "\x1b[3;1Hcol\x1b[3;40Hfar\x1b[8;1H",
+        "hello   \r\nworld  ", // typed default spaces at both row ends
+        "\x1b[1mbold  \x1b[0m", // a styled trailing space: text on the wire, not a blank
+        "\x1b[44mpad  \x1b[0m", // a bg-coloured pad, the shape every status bar ends with
+    };
+    for (screens) |s| {
+        var e = try Engine.init(alloc, .{ .cols = 80, .rows = 24 });
+        defer e.deinit();
+        e.feed(s);
+        const g = try Grid.init(alloc, 1, 1);
+        defer g.deinit();
+        try e.mirrorInto(g);
+        const raw = try e.dumpPlain(alloc);
+        defer alloc.free(raw);
+        const want = try trimRowTails(alloc, raw);
+        defer alloc.free(want);
+        const got = try g.dumpPlain(alloc);
+        defer alloc.free(got);
+        try std.testing.expectEqualStrings(want, got);
+        try std.testing.expectEqual(e.cursorPos().x, g.cursor.x);
+        try std.testing.expectEqual(e.cursorPos().y, g.cursor.y);
+    }
+}
+test "grid oracle: clipCol and snapWide agree with the engine's on rows with wide glyphs" {
+    const alloc = std.testing.allocator;
+    var e = try Engine.init(alloc, .{ .cols = 10, .rows = 2 });
+    defer e.deinit();
+    // Two rows whose wide glyphs sit in different columns, so an answer read
+    // off row 0 is wrong for row 1 and the sweep says which row it asked.
+    e.feed("\u{6f22}a\u{5b57}b\r\na\u{6f22}b\u{5b57}");
+    const g = try Grid.init(alloc, 1, 1);
+    defer g.deinit();
+    try e.mirrorInto(g);
+    // A pane that starts at screen column 7: both sides answer in GRID
+    // columns, so the offset must not reach the answer.
+    const col_off: u16 = 7;
+    var y: u16 = 0;
+    while (y < 2) : (y += 1) {
+        var cols: u16 = 0;
+        while (cols <= 10) : (cols += 1) {
+            const view = Engine.RowView{ .col_off = col_off, .cols = cols };
+            try std.testing.expectEqual(e.clipCol(y, view), g.clipCol(y, .{ .col_off = col_off, .cols = cols }));
+        }
+        var from: u16 = 0;
+        while (from < 6) : (from += 1) {
+            var to: u16 = from;
+            while (to < 6) : (to += 1) {
+                const a = e.snapWide(y, from, to);
+                const b = g.snapWide(y, from, to);
+                try std.testing.expectEqual(a.from, b.from);
+                try std.testing.expectEqual(a.to, b.to);
+            }
+        }
+    }
+}

src/engine/grid.zig

@@ @@ -0,0 +1,338 @@ @@
+//! The client's grid: what a replica holds instead of an emulator. Cells
+//! arrive already parsed (protocol.CellRow) and are copied into rows; the
+//! only rules here are the two wide-glyph rules a painter needs and the
+//! plain-text dump every harness compares against the daemon's.
+//!
+//! Deliberately platform-free: no posix, no fds, no clocks, no escape
+//! bytes — this compiles for wasm32-freestanding and sits under rule 4.
+const std = @import("std");
+const proto = @import("protocol.zig");
+pub const CursorPos = struct { x: u16, y: u16 };
+pub const Cell = struct {
+    style: proto.CellStyle = .{},
+    wide: proto.Wide = .narrow,
+    text_off: u32 = 0,
+    text_len: u8 = 0,
+    pub fn isBlank(self: Cell) bool {
+        return self.text_len == 0 and self.wide == .narrow and self.style.isDefault();
+    }
+};
+pub const Row = struct {
+    cells: []Cell,
+    /// Every cell's text, back to back; a cell slices into it.
+    text: std.ArrayListUnmanaged(u8) = .empty,
+    pub fn textOf(self: *const Row, c: Cell) []const u8 {
+        return self.text.items[c.text_off .. c.text_off + c.text_len];
+    }
+    fn blank(self: *Row) void {
+        @memset(self.cells, .{});
+        self.text.clearRetainingCapacity();
+    }
+    pub fn deinit(self: *Row, alloc: std.mem.Allocator) void {
+        alloc.free(self.cells);
+        self.text.deinit(alloc);
+    }
+};
+pub const RowView = struct { col_off: u16, cols: u16 };
+/// Decode one CellRow into `into` (already sized to `cols`). Two passes on
+/// purpose — validate, then fill — so a bad payload leaves the row as it
+/// was without a scratch copy: the caller resyncs from a snapshot, and half
+/// a row would paint as a lie until then.
+pub fn decodeRow(alloc: std.mem.Allocator, into: *Row, bytes: []const u8, cols: u16) ![]const u8 {
+    if (cols > proto.max_cols) return error.BadPayload;
+    var check = try proto.CellRowReader.init(bytes);
+    if (check.ncells > cols) return error.BadPayload;
+    var text_total: usize = 0;
+    while (try check.next()) |c| text_total += c.text.len;
+    // Every byte has been read once and is well-formed; nothing below can fail
+    // except the allocation, which happens before the row is touched.
+    try into.text.ensureTotalCapacity(alloc, text_total);
+    into.blank();
+    var r = proto.CellRowReader.init(bytes) catch unreachable;
+    var x: usize = 0;
+    while (r.next() catch unreachable) |c| : (x += 1) {
+        into.cells[x] = .{
+            .style = c.style,
+            .wide = c.wide,
+            .text_off = @intCast(into.text.items.len),
+            .text_len = @intCast(c.text.len),
+        };
+        into.text.appendSliceAssumeCapacity(c.text);
+    }
+    return r.remaining();
+}
+/// A column span, inclusive at both ends.
+pub const ColSpan = struct { from: u16, to: u16 };
+/// The last column of `r` (a row `cols` wide) that fits in `view`, or null
+/// when not one character does. Inward: half a wide glyph past a pane edge
+/// is a column stolen from the neighbour.
+pub fn clipColOf(r: *const Row, cols: u16, view: RowView) ?u16 {
+    if (view.cols == 0 or cols == 0) return null;
+    var hi: u16 = @min(view.cols - 1, cols - 1);
+    if (r.cells[hi].wide == .wide) {
+        if (hi == 0) return null;
+        hi -= 1;
+    }
+    return hi;
+}
+/// Widen [from, to] to whole glyphs. Outward: half a character under the
+/// pointer means the character is under the pointer.
+///
+/// The two ends are accepted in either order and normalised, where the
+/// engine's snapWide requires from <= to and its caller asserts it: a drag
+/// runs backwards as often as forwards, and the grid is what a painter calls.
+/// A column at or past `cols` reads no cell and moves nothing, which is what
+/// the engine does with one (its pin off the end of the row is null).
+pub fn snapWideOf(r: *const Row, cols: u16, from: u16, to: u16) ColSpan {
+    var lo = @min(from, to);
+    var hi = @max(from, to);
+    if (lo > 0 and lo < cols and r.cells[lo].wide == .spacer_tail) lo -= 1;
+    if (hi + 1 < cols and r.cells[hi].wide == .wide) hi += 1;
+    return .{ .from = lo, .to = hi };
+}
+pub fn decodeRows(alloc: std.mem.Allocator, bytes: []const u8, count: u16, cols: u16) ![]Row {
+    const rows = try alloc.alloc(Row, count);
+    var made: usize = 0;
+    errdefer {
+        for (rows[0..made]) |*r| r.deinit(alloc);
+        alloc.free(rows);
+    }
+    var rest = bytes;
+    for (rows) |*r| {
+        r.* = .{ .cells = try alloc.alloc(Cell, cols) };
+        made += 1;
+        @memset(r.cells, .{});
+        rest = try decodeRow(alloc, r, rest, cols);
+    }
+    return rows;
+}
+pub fn freeRows(alloc: std.mem.Allocator, rows: []Row) void {
+    for (rows) |*r| r.deinit(alloc);
+    alloc.free(rows);
+}
+pub const Grid = struct {
+    alloc: std.mem.Allocator,
+    cols: u16,
+    rows: u16,
+    cursor: CursorPos = .{ .x = 0, .y = 0 },
+    lines: []Row,
+    pub fn init(alloc: std.mem.Allocator, cols: u16, rows: u16) !*Grid {
+        const g = try alloc.create(Grid);
+        errdefer alloc.destroy(g);
+        g.* = .{ .alloc = alloc, .cols = cols, .rows = rows, .lines = &.{} };
+        try g.allocLines(cols, rows);
+        return g;
+    }
+    fn allocLines(self: *Grid, cols: u16, rows: u16) !void {
+        const lines = try self.alloc.alloc(Row, rows);
+        var made: usize = 0;
+        errdefer {
+            for (lines[0..made]) |*r| r.deinit(self.alloc);
+            self.alloc.free(lines);
+        }
+        for (lines) |*r| {
+            r.* = .{ .cells = try self.alloc.alloc(Cell, cols) };
+            made += 1;
+            @memset(r.cells, .{});
+        }
+        self.freeLines();
+        self.lines = lines;
+        self.cols = cols;
+        self.rows = rows;
+    }
+    fn freeLines(self: *Grid) void {
+        for (self.lines) |*r| r.deinit(self.alloc);
+        self.alloc.free(self.lines);
+        self.lines = &.{};
+    }
+    pub fn deinit(self: *Grid) void {
+        self.freeLines();
+        self.alloc.destroy(self);
+    }
+    /// A resize is a blank grid: the snapshot that carries it repaints every row.
+    pub fn resize(self: *Grid, cols: u16, rows: u16) !void {
+        try self.allocLines(cols, rows);
+        self.cursor = .{ .x = 0, .y = 0 };
+    }
+    pub fn clear(self: *Grid) void {
+        for (self.lines) |*r| r.blank();
+        self.cursor = .{ .x = 0, .y = 0 };
+    }
+    pub fn applyRow(self: *Grid, y: u16, bytes: []const u8) !void {
+        if (y >= self.rows) return error.BadPayload;
+        _ = try decodeRow(self.alloc, &self.lines[y], bytes, self.cols);
+    }
+    pub fn row(self: *const Grid, y: u16) *const Row {
+        return &self.lines[y];
+    }
+    /// The screen as text: a space per blank or spacer-less empty cell,
+    /// nothing for a spacer, rows joined by newlines, the trailing blank ROWS
+    /// dropped along with the newlines that would have separated them (a
+    /// screen is 24 rows tall whatever is on it, so an unwritten tail is not
+    /// text), and every row's trailing spaces trimmed.
+    ///
+    /// Interior blank rows stay: they are a gap the user typed.
+    ///
+    /// The trailing-space trim is where this differs from Engine.dumpPlain,
+    /// which is ghostty's plainString and dumps with `trim = false`, so a
+    /// space a program wrote at the end of a row survives it. A client never
+    /// holds such a space, and never did: the VT formatter that fed the old
+    /// wire trims trailing whitespace before a row leaves the daemon, and the
+    /// e2e convergence diff strips trailing whitespace on both sides as a
+    /// formatting difference between two correct grids. Trimming here makes
+    /// the two agree on everything a client can observe. The engine.zig
+    /// oracle test compares through the same trim and is the authority.
+    pub fn dumpPlain(self: *const Grid, alloc: std.mem.Allocator) ![]const u8 {
+        var out: std.ArrayList(u8) = .empty;
+        errdefer out.deinit(alloc);
+        for (self.lines, 0..) |*r, y| {
+            const start = out.items.len;
+            for (r.cells) |c| {
+                switch (c.wide) {
+                    .spacer_tail, .spacer_head => continue,
+                    .narrow, .wide => {},
+                }
+                if (c.text_len == 0) try out.append(alloc, ' ') else try out.appendSlice(alloc, r.textOf(c));
+            }
+            while (out.items.len > start and out.items[out.items.len - 1] == ' ') out.items.len -= 1;
+            if (y + 1 < self.lines.len) try out.append(alloc, '\n');
+        }
+        while (out.items.len > 0 and out.items[out.items.len - 1] == '\n') out.items.len -= 1;
+        return out.toOwnedSlice(alloc);
+    }
+    pub fn clipCol(self: *const Grid, y: u16, view: RowView) ?u16 {
+        return clipColOf(&self.lines[y], self.cols, view);
+    }
+    pub fn snapWide(self: *const Grid, y: u16, from: u16, to: u16) ColSpan {
+        return snapWideOf(&self.lines[y], self.cols, from, to);
+    }
+};
+test "grid: applyRow fills the row and blanks the rest of the width" {
+    const alloc = std.testing.allocator;
+    const g = try Grid.init(alloc, 6, 2);
+    defer g.deinit();
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(alloc);
+    var w = try proto.CellRowWriter.begin(&list, alloc);
+    try w.cell(.{ .fg = proto.colorPalette(2) }, .narrow, "h");
+    try w.cell(.{}, .wide, "漢");
+    try w.cell(.{}, .spacer_tail, "");
+    w.finish();
+    try g.applyRow(1, list.items);
+    const r = g.row(1);
+    try std.testing.expectEqualStrings("h", r.textOf(r.cells[0]));
+    try std.testing.expectEqual(proto.colorPalette(2), r.cells[0].style.fg);
+    try std.testing.expectEqual(proto.Wide.wide, r.cells[1].wide);
+    try std.testing.expectEqual(proto.Wide.spacer_tail, r.cells[2].wide);
+    try std.testing.expectEqual(@as(u8, 0), r.cells[3].text_len);
+    try std.testing.expect(r.cells[5].style.isDefault());
+    // Row 0 was never written and is blank.
+    try std.testing.expectEqual(@as(u8, 0), g.row(0).cells[0].text_len);
+}
+test "grid: a row wider than the grid is BadPayload and leaves the row untouched" {
+    const alloc = std.testing.allocator;
+    const g = try Grid.init(alloc, 2, 1);
+    defer g.deinit();
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(alloc);
+    var w = try proto.CellRowWriter.begin(&list, alloc);
+    try w.cell(.{}, .narrow, "a");
+    try w.cell(.{}, .narrow, "b");
+    try w.cell(.{}, .narrow, "c");
+    w.finish();
+    try std.testing.expectError(error.BadPayload, g.applyRow(0, list.items));
+    try std.testing.expectEqual(@as(u8, 0), g.row(0).cells[0].text_len);
+}
+test "grid: dumpPlain trims trailing blanks per row, joins rows with newlines, and drops the blank tail" {
+    const alloc = std.testing.allocator;
+    const g = try Grid.init(alloc, 6, 3);
+    defer g.deinit();
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(alloc);
+    var w = try proto.CellRowWriter.begin(&list, alloc);
+    try w.cell(.{}, .narrow, "a");
+    try w.cell(.{}, .narrow, "");
+    try w.cell(.{}, .narrow, "b");
+    w.finish();
+    try g.applyRow(0, list.items);
+    const s = try g.dumpPlain(alloc);
+    defer alloc.free(s);
+    // Rows 1 and 2 were never written, so the engine's dump ends at row 0.
+    try std.testing.expectEqualStrings("a b", s);
+}
+test "grid: clipCol steps inward off a wide glyph at the pane edge; snapWide steps outward" {
+    const alloc = std.testing.allocator;
+    const g = try Grid.init(alloc, 6, 2);
+    defer g.deinit();
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(alloc);
+    var w = try proto.CellRowWriter.begin(&list, alloc);
+    try w.cell(.{}, .narrow, "a");
+    try w.cell(.{}, .wide, "漢");
+    try w.cell(.{}, .spacer_tail, "");
+    try w.cell(.{}, .narrow, "b");
+    w.finish();
+    // Row 1, not row 0: both answers are for the row asked about.
+    try g.applyRow(1, list.items);
+    // The pane starts at screen column 4; every answer below is a GRID column,
+    // so the offset must not reach it.
+    // A pane 2 wide would cut 漢 in half: the last column that fits is 0.
+    try std.testing.expectEqual(@as(?u16, 0), g.clipCol(1, .{ .col_off = 4, .cols = 2 }));
+    // A pane as wide as the grid clips at the last COLUMN, not at the last
+    // written one: trailing blanks are cells a pane paints like any other.
+    try std.testing.expectEqual(@as(?u16, 5), g.clipCol(1, .{ .col_off = 4, .cols = 6 }));
+    try std.testing.expectEqual(@as(?u16, null), g.clipCol(1, .{ .col_off = 4, .cols = 0 }));
+    // The unwritten row 0 has no wide glyph, so nothing steps inward there.
+    try std.testing.expectEqual(@as(?u16, 1), g.clipCol(0, .{ .col_off = 4, .cols = 2 }));
+    // A drag from the spacer to the wide cell covers the whole glyph.
+    const s = g.snapWide(1, 2, 1);
+    try std.testing.expectEqual(@as(u16, 1), s.from);
+    try std.testing.expectEqual(@as(u16, 2), s.to);
+}
+test "grid: decodeRows reads a dense run and refuses a short one" {
+    const alloc = std.testing.allocator;
+    var list: std.ArrayList(u8) = .empty;
+    defer list.deinit(alloc);
+    var i: usize = 0;
+    while (i < 2) : (i += 1) {
+        var w = try proto.CellRowWriter.begin(&list, alloc);
+        try w.cell(.{}, .narrow, "x");
+        w.finish();
+    }
+    const rows = try decodeRows(alloc, list.items, 2, 4);
+    defer freeRows(alloc, rows);
+    try std.testing.expectEqual(@as(usize, 2), rows.len);
+    try std.testing.expectEqualStrings("x", rows[1].textOf(rows[1].cells[0]));
+    try std.testing.expectError(error.BadPayload, decodeRows(alloc, list.items, 3, 4));
+}

src/engine/protocol.zig

Old		New
@@ -54,6 +54,9 @@ pub const MsgType = enum(u8) {
54		54
55	pub const max_payload = 16 * 1024 * 1024;	55	pub const max_payload = 16 * 1024 * 1024;
56		56
		57	/// The widest row a client will decode; a wider claim is a bad payload, not an allocation.
		58	pub const max_cols: u16 = 4096;
		59
57	/// One type byte + u32 LE payload length.	60	/// One type byte + u32 LE payload length.
58	pub const frame_header_len = 5;	61	pub const frame_header_len = 5;
59		62

src/engine/term.zig

Old		New
@@ -1,16 +1,18 @@
1	//! The terminal component: the wire contract, the authoritative engine,	1	//! The terminal component: the wire contract, the authoritative engine,
2	//! the delta minting that feeds replicas, and the one replay core. One	2	//! the delta minting that feeds replicas, and the one replay core. One
3	//! table row — the four files are one owner, and only this root is a seam,	3	//! table row — every file below is one owner, and only this root is a seam,
4	//! so a second module claiming any of them is a file-in-multiple-modules	4	//! so a second module claiming any of them is a file-in-multiple-modules
5	//! compile error.	5	//! compile error.
6	pub const protocol = @import("protocol.zig");	6	pub const protocol = @import("protocol.zig");
7	pub const engine = @import("engine.zig");	7	pub const engine = @import("engine.zig");
8	pub const delta = @import("delta.zig");	8	pub const delta = @import("delta.zig");
9	pub const replica = @import("replica.zig");	9	pub const replica = @import("replica.zig");
		10	pub const grid = @import("grid.zig");
10		11
11	test {	12	test {
12	_ = protocol;	13	_ = protocol;
13	_ = engine;	14	_ = engine;
14	_ = delta;	15	_ = delta;
15	_ = replica;	16	_ = replica;
		17	_ = grid;
16	}	18	}