One core behind N frontends, the board's own runner moved in, and every board cap on one screen

## The wire is the effect stream, not a new protocol

`pardes --detach` leaves a core running with no terminal; `pardes --attach` is a frontend that owns
a terminal and a socket and nothing else. N frontends on one core all look at the same screen —
`screen -x`, not N sessions.

The codec (`src/detached/wire.zig`) carries exactly one `Event` or one `Host.VTable` call per
message. That is not a coincidence and it is why there is no third vocabulary to keep in step: the
core's IO seam was already a struct of function pointers with plain-data arguments, so a socket is
a legal implementation of it. `nested.zig`'s socket could not be reused — it carries a builtin
command line, and a command line cannot carry a frame.

ARCHITECTURE-NEUTRAL on purpose, not as decoration. The frontend on the far end may be
riscv32-freestanding on the ESP32-P4 while the core is x86_64 Linux, so every field is an explicit
little-endian fixed width and no message is a blit of a native struct. A protocol that only works
between two builds of the same compiler would have thrown away the one frontend that motivated it.

## The board comes in; its toolchain stays out

`src/p4.zig` becomes `src/esp32p4.zig`, and the pardes half of `../05-zig-p4` — the vaxis-over-
serial runner, the UART editor terminal, the keystroke rescue ring, the on-die test suite — moves
into `src/esp32p4/`. `build.zig.zon` gains `.zig_p4 = .{ .path = "../05-zig-p4" }`, so
`zig build -Dplatform=esp32p4 -Desp32p4-firmware` builds, flashes, monitors and self-tests the
board from this repo's `build.zig`.

The DIVISION is the point. What moved is what only pardes wants: the runner that drives a pardes
core over a serial line. What stayed is everything a second project would also want — the HAL, the
register/radio/oracle layers, the linker script, `_start`. `zig_p4` declares no dependencies of its
own and its `build()` early-returns when it is not the root package, so this costs the package
graph exactly zero packages and the editor's own builds nothing at all.

## limits.zig: nine forgettable places become one budget

Nine `platform == .esp32p4` capacity tests lived in nine files. They were never nine decisions —
they are ONE decision, how much memory this build may spend, taken nine times where no reader could
see the total. `src/limits.zig` puts the whole budget on one screen with every cap named against
what it is measured against, derived from two booleans.

The payoff is testability on a machine that is not the board: the caps are ordinary comptime values,
so a host build can be compiled against the board's numbers and the parking, eviction and clamping
paths a 240 KiB core takes get exercised by the normal test suite instead of only over a UART.

## A bare `zig build`

`zig build` with no arguments now builds the tty and GUI binaries and installs them into
`~/.local/bin`, and says so once on stdout with the flag that overrides it. The old default built
one binary into `zig-out` — a path nothing on a `PATH` ever looks at, which made "build it" and
"use it" two different commands for no reason.

1 files changed, 89 insertions, 8 deletions

diff --git a/src/file_pane.zig b/src/file_pane.zig
index e0150de2..5c7f4b77 100644
--- a/src/file_pane.zig
+++ b/src/file_pane.zig
@@ -16,14 +16,9 @@ const syntax = @import("syntax.zig");
 const tracy = @import("tracy.zig");
 const term_pane = @import("term_pane.zig");
 const dump = @import("dump.zig");
+const limits = @import("limits.zig");
 
 const SYNTAX_CONTEXT_AFTER_ROWS: usize = 2;
-/// EDIT BOUNDARIES REMEMBERED PER FILE PANE. Every entry owns a gpa copy of
-/// the WHOLE file, so this number multiplies heap, not just the pane: 256 of
-/// them is not a bound a 384 KiB board could ever reach anyway. `pushHistory`
-/// evicts and frees the oldest once full, so the smaller ring loses the
-/// deepest undo steps and nothing else — no truncation, no dropped edit.
-const undo_max = if (@import("pardes_config").platform == .p4) 16 else 256;
 
 /// Content and primary selection at one file edit boundary. Keeping only the
 /// primary avoids putting pardes.MAX_SELS ranges in every history entry.
@@ -54,9 +49,9 @@ pub const State = struct {
     highlights: []u8 = &.{},
     highlight_start: usize = 0,
     syntax_dirty: bool = true,
-    undo: [undo_max]Snapshot = undefined,
+    undo: [limits.undo_max]Snapshot = undefined,
     undo_len: usize = 0,
-    redo: [undo_max]Snapshot = undefined,
+    redo: [limits.undo_max]Snapshot = undefined,
     redo_len: usize = 0,
 };
 
@@ -220,6 +215,92 @@ test "display columns map complete Unicode graphemes" {
     try std.testing.expectEqual(@as(usize, 2), graphemeDisplayWidth("👩\u{200d}🚀"));
 }
 
+test "the ASCII arm of graphemeDisplayWidth matches the gwidth it skips" {
+    // The arm claims a one-byte printable ASCII grapheme is one cell without asking `gwidth`. That
+    // is only worth having if the two never disagree, so ask both for every byte the arm can see -
+    // including \t, \r, the rest of the C0 controls and DEL, which the range test excludes and
+    // which must therefore still come back from `gwidth` (or, for the tab, from the config).
+    const ref = struct {
+        fn width(grapheme: []const u8) usize {
+            if (std.mem.eql(u8, grapheme, "\t")) return config.tab_width;
+            return @max(1, @as(usize, vaxis.gwidth.gwidth(grapheme, .unicode)));
+        }
+    }.width;
+
+    var one: [1]u8 = undefined;
+    var b: u8 = 0;
+    while (b < 0x80) : (b += 1) {
+        one[0] = b;
+        try std.testing.expectEqual(ref(one[0..1]), graphemeDisplayWidth(one[0..1]));
+    }
+    // Multi-byte clusters never reach the arm (len != 1), so they pin that it does not widen its
+    // claim: a combining sequence and a ZWJ emoji are one and two cells, a CJK glyph is two, and
+    // an invalid byte is the one cell `gwidth` reports for U+FFFD-shaped input.
+    for ([_][]const u8{
+        "e\u{301}",  "a\u{903}",           "1\u{fe0f}\u{20e3}", "\u{4e16}",
+        "\u{1f642}", "\u{1f1e6}\u{1f1e7}", "\xff",              "\xe4\xb8",
+    }) |g| try std.testing.expectEqual(ref(g), graphemeDisplayWidth(g));
+}
+
+test "the ASCII run in fitEnd survives an exhaustive byte sweep" {
+    // The case list in the test above is hand-picked; this one is not. Every byte 0x00..0x7f is
+    // placed next to every neighbour that can change the answer - a combining mark, a ZWJ
+    // sequence, a spacing mark, a variation selector, a wide glyph, and a bad start byte, a
+    // truncated tail and a bad continuation - and every break column is compared against the
+    // grapheme walk. An off-by-one column here moves text between wrapped rows, so equality is
+    // exact, not approximate.
+    const reference = struct {
+        fn fitEnd(text: []const u8, start: usize, width: usize) usize {
+            var end = start;
+            var used: usize = 0;
+            while (end < text.len) {
+                const next_end = modal.nextGrapheme(text, end);
+                const next_used = used +| graphemeDisplayWidth(text[end..next_end]);
+                if (next_used > width) return if (end == start) next_end else end;
+                used = next_used;
+                end = next_end;
+            }
+            return end;
+        }
+    }.fitEnd;
+
+    const neighbours = [_][]const u8{
+        "",                   "z",        "\u{301}",  "\u{200d}\u{1f680}",
+        "\u{903}",            "\u{fe0f}", "\u{4e16}", "\u{1f642}",
+        "\u{1f1e6}\u{1f1e7}", "\xff",     "\xe4\xb8", "\xe4\x28\xb8",
+    };
+    var buf: [16]u8 = undefined;
+    // The same pair again behind an ASCII prefix, so a break can land exactly at the run boundary
+    // as well as before it and inside the multi-byte cluster that follows it.
+    var prefixed: [18]u8 = undefined;
+    prefixed[0] = 'a';
+    prefixed[1] = 'b';
+    var b: u8 = 0;
+    while (b < 0x80) : (b += 1) {
+        buf[0] = b;
+        for (neighbours) |tail| {
+            @memcpy(buf[1..][0..tail.len], tail);
+            const pair = buf[0 .. 1 + tail.len];
+            @memcpy(prefixed[2..][0..pair.len], pair);
+            for ([_][]const u8{ pair, prefixed[0 .. 2 + pair.len] }) |text| {
+                var width: usize = 0;
+                while (width <= text.len + 3) : (width += 1) {
+                    var start: usize = 0;
+                    while (start <= text.len) : (start += 1) {
+                        std.testing.expectEqual(
+                            reference(text, start, width),
+                            fitEnd(text, start, width),
+                        ) catch |e| {
+                            std.debug.print("fitEnd({any}, {d}, {d})\n", .{ text, start, width });
+                            return e;
+                        };
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn fitEnd(text: []const u8, start: usize, width: usize) usize {
     var end = start;
     var used: usize = 0;