summaryrefslogtreecommitdiff
path: root/src/echo.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/echo.zig')
-rw-r--r--src/echo.zig781
1 files changed, 781 insertions, 0 deletions
diff --git a/src/echo.zig b/src/echo.zig
new file mode 100644
index 00000000..4acd3d11
--- /dev/null
+++ b/src/echo.zig
@@ -0,0 +1,781 @@
+//! Predicted echo for a replica's terminal panes, mosh's way
+//! (docs/next-daemon.md, "Phase 6: predicted echo notes"). A key typed into
+//! a terminal goes to the authority, and its echo comes back as screen state
+//! a round trip later: this shows it at once.
+//!
+//! Presentation only. The overlay is the replica's own (`Pardes.echo`, a
+//! `.local` field the rollback copy skips), painted over a terminal's body
+//! after it is drawn (`paint`, from body_layer.renderBody, which the tty and
+//! the GUI share). The core's emulator stays the authority's, and no digest
+//! sees any of this.
+//!
+//! What is predicted: a printable character at the cursor, backspace, and
+//! left and right, in tty mode on the primary screen at the live bottom. Any
+//! other input this replica could not apply itself (Enter, Tab, a chord, a
+//! paste, a click) stops prediction until the authority has confirmed it and
+//! its echo has had `grace` to come back: predictions start again from the
+//! screen's own cursor. So a key typed after Tab waits a round trip; it is
+//! never drawn where the completion was not.
+//!
+//! Judged as mosh does, once the authority confirmed the key and `grace`
+//! passed: at a delta, a cell the screen shows goes, and one it does not is
+//! a misprediction, and every prediction goes. With no delta (nothing
+//! changed: no echo), a frame judges it `stale` later. Shown at once at a
+//! shell's prompt (pardes's OSC 133 marks say its line editor echoes);
+//! elsewhere only once an echo was confirmed there since the last key that
+//! was not predicted (`cat`, a shell without marks), and underlined; never
+//! after a shown misprediction until an echo is confirmed again. A password
+//! prompt or a program that ignores input confirms none, so nothing typed
+//! there is ever shown.
+const std = @import("std");
+const pardes = @import("pardes.zig");
+const terminal = pardes.panes.terminal;
+const Pardes = pardes.Pardes;
+const Pane = pardes.Pane;
+const Surface = pardes.Surface;
+const Key = pardes.Key;
+
+const ms = std.time.ns_per_ms;
+/// After the authority confirmed a key, how long its echo has to come back
+/// before a delta that does not show it makes a misprediction (mosh's
+/// ECHO_TIMEOUT): the shell's echo, then the authority's next frame.
+// ponytail: fixed; a loaded host's later echo makes a drawn character go and
+// come back. The echo delay measured per terminal would be the bound.
+pub const grace_ns = 50 * ms;
+/// With no delta at all, how much longer a frame waits to judge a key.
+pub const stale_ns = 250 * ms;
+const never = std.math.maxInt(u64);
+/// Cells predicted at once: a line typed a round trip ahead.
+const max = 64;
+
+/// A cell predicted: `cp` at column `x` of absolute row `row` (the
+/// authority's numbering, screen_state's), a space for a cell backspace
+/// cleared; `was` what the screen showed there before; `seq` the key's.
+pub const Cell = struct { x: u16, row: u64, cp: u21, was: u21, seq: u32, due: u64 = never };
+pub const Cursor = struct { x: u16, row: u64, seq: u32, due: u64 = never };
+
+pub const Stats = struct {
+ /// Keys into a terminal predicted, and not.
+ predicted: u32 = 0,
+ unpredicted: u32 = 0,
+ /// Cells the screen showed when judged; cells and cursors it did not.
+ confirmed: u32 = 0,
+ mispredicted: u32 = 0,
+ cursor_missed: u32 = 0,
+};
+
+pub const Echo = struct {
+ /// Off: nothing predicted (the harness's baseline).
+ on: bool = true,
+ /// The harness's clock (ns); the monotonic one when null.
+ now: ?u64 = null,
+ /// Its client's view, and the terminal it predicts into.
+ view: u8 = 0,
+ pane: u8 = 0,
+ serial: u32 = 0,
+ /// Each terminal's last delta: its active area's first row, absolute.
+ tops: [pardes.MAX_PANES]u64 = @splat(0),
+ cells: [max]Cell = undefined,
+ n: u8 = 0,
+ cursor: ?Cursor = null,
+ /// The newest of its client's inputs the authority confirmed.
+ acked: u32 = 0,
+ /// The newest input not predicted, and when its echo is due: nothing is
+ /// predicted until then. `wait_key`: it was a key forwarded to this
+ /// terminal (no other pane's), so the keys typed into it meanwhile wait
+ /// in `deferred`, to be predicted over the screen that shows its doing.
+ wait: u32 = 0,
+ wait_due: u64 = 0,
+ wait_key: bool = false,
+ deferred: [max]Deferred = undefined,
+ nd: u8 = 0,
+ /// An echo confirmed since the last key not predicted: shown off a
+ /// prompt too. A shown misprediction since the last confirmed echo:
+ /// shown nowhere.
+ trusted: bool = false,
+ doubt: bool = false,
+ /// What it draws changed: the client draws a frame.
+ changed: bool = false,
+ stats: Stats = .{},
+ /// Each key's prediction as it is made, when set (the harness's; on
+ /// the C heap).
+ log: ?*std.ArrayListUnmanaged(Predicted) = null,
+
+ pub const Predicted = struct { seq: u32, cell: ?Cell, cursor: Cursor };
+
+ fn time(e: *const Echo) u64 {
+ return e.now orelse pardes.FrameStats.nowNs();
+ }
+
+ const Deferred = struct { seq: u32, kind: ?Kind, due: u64 = never };
+
+ fn drop(e: *Echo) void {
+ if (e.n > 0 or e.cursor != null) e.changed = true;
+ e.n = 0;
+ e.cursor = null;
+ }
+
+ fn waiting(e: *const Echo) bool {
+ return e.acked < e.wait or e.time() < e.wait_due;
+ }
+
+ fn waitFor(e: *Echo, seq: u32, key: bool) void {
+ e.wait = seq;
+ e.wait_due = never;
+ e.wait_key = key;
+ e.nd = 0;
+ }
+
+ /// Its client's input `seq`, after the replica took it: `applied`,
+ /// it was applied here at once (so it was no key into a terminal).
+ pub fn typed(e: *Echo, c: *Pardes, view: u8, ev: pardes.Event, seq: u32, applied: bool) void {
+ e.view = view;
+ if (applied or comptime !terminal.enabled) return;
+ switch (ev) {
+ // ponytail: a motion or focus report a program asked for could
+ // move its cursor; the judgement catches that.
+ .mouse => |m| if (m.kind == .motion) return,
+ .pointer_leave, .focus => return,
+ else => {},
+ }
+ const id = keyboardPane(c, view) orelse {
+ // Another pane's, or not a key: where the keys after it go is
+ // not known here until the authority has it. ponytail: so they
+ // wait for it too, each, until a pause.
+ e.waitFor(seq, false);
+ return;
+ };
+ if (id != e.pane or c.panes[id].?.serial != e.serial) {
+ e.drop();
+ e.nd = 0;
+ e.pane = @intCast(id);
+ e.serial = c.panes[id].?.serial;
+ }
+ const kind = kindOf(ev);
+ const key = forwarded(c, ev);
+ // A key that is not one of those predicted says nothing of the
+ // program the keys after it reach (Enter: a password prompt's).
+ if (kind == null) e.trusted = false;
+ if (!e.on) {
+ e.stats.unpredicted += 1;
+ return e.waitFor(seq, key);
+ }
+ // Behind keys still deferred: after them, in order.
+ e.catchUp(c);
+ if (e.waiting() or e.nd > 0) {
+ if (e.wait_key and key and e.nd < max) {
+ e.deferred[e.nd] = .{ .seq = seq, .kind = kind };
+ e.nd += 1;
+ return;
+ }
+ e.stats.unpredicted += 1;
+ return e.waitFor(seq, false);
+ }
+ if (kind) |k| if (e.predict(c.panes[id].?, k, seq)) {
+ e.stats.predicted += 1;
+ e.changed = true;
+ return;
+ };
+ e.stats.unpredicted += 1;
+ e.waitFor(seq, key);
+ }
+
+ /// The wait over (its key's doing on the screen), the keys deferred
+ /// behind it that the screen does not show yet are predicted over it,
+ /// in order; those it shows are not. One the authority has whose echo
+ /// may be on its way puts it off until its grace has passed.
+ fn catchUp(e: *Echo, c: *Pardes) void {
+ if (e.nd == 0 or e.waiting()) return;
+ const now = e.time();
+ var i: usize = 0;
+ while (i < e.nd and e.deferred[i].due <= now) i += 1;
+ if (i < e.nd and e.deferred[i].due != never) return;
+ e.stats.unpredicted += @intCast(i);
+ const pane = c.panes[e.pane] orelse return e.waitFor(e.wait, false);
+ if (pane.serial != e.serial) return e.waitFor(e.wait, false);
+ while (i < e.nd) : (i += 1) {
+ const d = e.deferred[i];
+ if (d.kind) |k| if (e.predict(pane, k, d.seq)) {
+ e.stats.predicted += 1;
+ e.changed = true;
+ continue;
+ };
+ // The next to wait for, the rest behind it.
+ e.stats.unpredicted += 1;
+ const rest = e.nd - i - 1;
+ std.mem.copyForwards(Deferred, e.deferred[0..rest], e.deferred[i + 1 .. e.nd]);
+ e.wait = d.seq;
+ e.wait_due = never;
+ e.wait_key = true;
+ e.nd = @intCast(rest);
+ return;
+ }
+ e.nd = 0;
+ }
+
+ /// Whether a key `kind` into terminal `pane` was predicted.
+ fn predict(e: *Echo, pane: *Pane, kind: Kind, seq: u32) bool {
+ const state = pane.terminal orelse return false;
+ const vt = &state.vt;
+ if (vt.screens.active_key != .primary or !terminal.atBottom(pane) or !vt.modes.get(.cursor_visible)) return false;
+ const top = e.tops[e.pane];
+ const screen = vt.screens.active;
+ const cur: Cursor = e.cursor orelse .{ .x = @intCast(screen.cursor.x), .row = top + screen.cursor.y, .seq = 0 };
+ if (cur.row < top or cur.row - top >= vt.rows or e.n == max) return false;
+ var next: Cursor = .{ .x = cur.x, .row = cur.row, .seq = seq };
+ var cell: ?Cell = null;
+ switch (kind) {
+ .char => |cp| {
+ // The last column wraps as a program pleases; a cell that
+ // holds another character is a line edited in its middle,
+ // or a suggestion (fish's) being left: the shell redraws
+ // what is right of it. ponytail: mosh's shift of the rest
+ // would cover bash's middle, and mispredict fish's.
+ if (cur.x + 1 >= vt.cols) return false;
+ const under = e.cpAt(state, cur.x, cur.row);
+ if (!blank(under) and under != cp) return false;
+ cell = .{ .x = cur.x, .row = cur.row, .cp = cp, .was = under, .seq = seq };
+ next.x += 1;
+ },
+ // At the end of a line only: in its middle a line editor moves
+ // the rest left.
+ .backspace => {
+ if (cur.x == 0 or !e.isInput(state, cur.x - 1, cur.row) or !blank(e.cpAt(state, cur.x, cur.row))) return false;
+ cell = .{ .x = cur.x - 1, .row = cur.row, .cp = ' ', .was = e.cpAt(state, cur.x - 1, cur.row), .seq = seq };
+ next.x -= 1;
+ },
+ .left => {
+ if (cur.x == 0 or !e.isInput(state, cur.x - 1, cur.row)) return false;
+ next.x -= 1;
+ },
+ // Over typed text only: past its end, fish takes the right
+ // arrow for its suggestion (another colour).
+ .right => {
+ if (cur.x + 1 >= vt.cols or !e.isText(state, cur.x, cur.row)) return false;
+ next.x += 1;
+ },
+ }
+ if (cell) |want| e.put(want);
+ e.cursor = next;
+ if (e.log) |l| l.append(std.heap.c_allocator, .{ .seq = seq, .cell = cell, .cursor = next }) catch {};
+ return true;
+ }
+
+ fn put(e: *Echo, want: Cell) void {
+ for (e.cells[0..e.n]) |*have| if (have.x == want.x and have.row == want.row) {
+ const was = have.was;
+ have.* = want;
+ have.was = was;
+ return;
+ };
+ e.cells[e.n] = want;
+ e.n += 1;
+ }
+
+ fn mine(e: *const Echo, x: u16, row: u64) ?*const Cell {
+ for (e.cells[0..e.n]) |*have| if (have.x == x and have.row == row) return have;
+ return null;
+ }
+
+ /// What the screen shows at a cell as predicted so far.
+ fn cpAt(e: *const Echo, state: *terminal.State, x: u16, row: u64) u21 {
+ if (e.mine(x, row)) |have| return have.cp;
+ return e.screenCp(state, x, row);
+ }
+
+ /// What the screen itself shows there; off its active area, a
+ /// codepoint no key types.
+ fn screenCp(e: *const Echo, state: *terminal.State, x: u16, row: u64) u21 {
+ const ci = e.screenCell(state, x, row) orelse return 0x10ffff;
+ return ci.cell.codepoint();
+ }
+
+ fn screenCell(e: *const Echo, state: *terminal.State, x: u16, row: u64) ?terminal.PageCell {
+ if (comptime !terminal.enabled) return null;
+ const top = e.tops[e.pane];
+ if (row < top or row - top >= state.vt.rows) return null;
+ return state.vt.screens.active.pages.getCell(.{ .active = .{ .x = x, .y = @intCast(row - top) } });
+ }
+
+ /// A prompt's input there, or a character predicted.
+ fn isInput(e: *const Echo, state: *terminal.State, x: u16, row: u64) bool {
+ if (e.mine(x, row)) |have| return !blank(have.cp);
+ const ci = e.screenCell(state, x, row) orelse return false;
+ return ci.cell.semantic_content == .input;
+ }
+
+ /// Typed text there: a character predicted, or a prompt's input in the
+ /// colour of the cell before it.
+ fn isText(e: *const Echo, state: *terminal.State, x: u16, row: u64) bool {
+ if (e.mine(x, row)) |have| return !blank(have.cp);
+ const ci = e.screenCell(state, x, row) orelse return false;
+ if (ci.cell.semantic_content != .input or blank(ci.cell.codepoint())) return false;
+ if (x == 0) return true;
+ const before = e.screenCell(state, x - 1, row) orelse return false;
+ return before.cell.style_id == ci.cell.style_id;
+ }
+
+ /// The authority confirmed its client's input `seq`.
+ pub fn confirmed(e: *Echo, c: *Pardes, seq: u32) void {
+ e.acked = seq;
+ const due = e.time() + grace_ns;
+ for (e.deferred[0..e.nd]) |*d| if (d.seq <= seq and d.due == never) {
+ d.due = due;
+ };
+ for (e.cells[0..e.n]) |*cell| if (cell.seq <= seq and cell.due == never) {
+ cell.due = due;
+ };
+ if (e.cursor) |*cur| if (cur.seq <= seq and cur.due == never) {
+ cur.due = due;
+ };
+ if (e.wait <= seq and e.wait_due == never) {
+ // The authority stepped a key this did not predict, after every
+ // one it did: its deltas from here show that key's doing, which
+ // no prediction knew of. They go, judged neither way.
+ e.wait_due = due;
+ e.drop();
+ }
+ e.catchUp(c);
+ }
+
+ /// Terminal `id`'s delta was applied, its active area's first row now
+ /// `top`.
+ pub fn delta(e: *Echo, c: *Pardes, id: u8, top: u64) void {
+ if (id == e.pane and top != e.tops[id] and (e.n > 0 or e.cursor != null)) {
+ // Scrolled: the rows predicted are others now.
+ e.tops[id] = top;
+ return e.drop();
+ }
+ e.tops[id] = top;
+ if (id == e.pane) e.judge(c, 0);
+ e.catchUp(c);
+ }
+
+ /// Once a frame: what is stale judged. Whether to draw.
+ pub fn frame(e: *Echo, c: *Pardes) bool {
+ if (e.n > 0 or e.cursor != null) e.judge(c, stale_ns);
+ e.catchUp(c);
+ defer e.changed = false;
+ return e.changed;
+ }
+
+ fn judge(e: *Echo, c: *Pardes, slack: u64) void {
+ if (comptime !terminal.enabled) return;
+ if (e.n == 0 and e.cursor == null) return;
+ const now = e.time();
+ const pane = c.panes[e.pane] orelse return e.drop();
+ if (pane.serial != e.serial) return e.drop();
+ const state = pane.terminal orelse return e.drop();
+ if (state.vt.screens.active_key != .primary) return e.drop();
+ const shown = e.visible(c);
+ var i: usize = 0;
+ while (i < e.n) {
+ const cell = e.cells[i];
+ if (now < cell.due) {
+ i += 1;
+ continue;
+ }
+ if (!blank(cell.cp) and e.screenCp(state, cell.x, cell.row) != cell.cp) {
+ if (now < cell.due + slack) {
+ i += 1;
+ continue;
+ }
+ e.stats.mispredicted += 1;
+ if (shown) e.doubt = true;
+ e.trusted = false;
+ return e.drop();
+ }
+ // Shown, or a space (mosh: too easy to show by chance to vouch).
+ // A key before the last one not predicted vouches for nothing
+ // after it (a line's characters for the password prompt its
+ // Enter brought up).
+ if (!blank(cell.cp)) {
+ e.stats.confirmed += 1;
+ if (cell.was != cell.cp and cell.seq > e.wait) {
+ e.trusted = true;
+ e.doubt = false;
+ }
+ }
+ e.cells[i] = e.cells[e.n - 1];
+ e.n -= 1;
+ e.changed = true;
+ }
+ const cur = e.cursor orelse return;
+ if (now < cur.due) return;
+ const screen = state.vt.screens.active;
+ if (screen.cursor.x == cur.x and e.tops[e.pane] + screen.cursor.y == cur.row) {
+ e.cursor = null;
+ e.changed = true;
+ } else if (now >= cur.due + slack) {
+ e.stats.cursor_missed += 1;
+ e.drop();
+ }
+ }
+
+ /// Whether its predictions are drawn now.
+ pub fn visible(e: *const Echo, c: *const Pardes) bool {
+ if (e.doubt) return false;
+ if (e.trusted) return true;
+ const pane = c.panes[e.pane] orelse return false;
+ return atPrompt(pane);
+ }
+
+ /// Over terminal pane `id`'s body, as renderBody drew it: the
+ /// characters predicted and the cursor after them.
+ pub fn paint(e: *const Echo, p: *const Pardes, s: *Surface, pane: *const Pane, id: usize, tx: u16, tw: u16, body_y: u16, body_h: u16, active: bool) void {
+ if (comptime !terminal.enabled) return;
+ if (e.n == 0 and e.cursor == null) return;
+ if (id != e.pane or pane.serial != e.serial or p.view != e.view or pane.body.mode != .tty) return;
+ if (!e.visible(p)) return;
+ const state = pane.terminal orelse return;
+ const sb = state.vt.screens.active.pages.scrollbar();
+ const top = e.tops[id];
+ // Off a prompt, the trust is inferred: underlined, as mosh does.
+ const flag = !atPrompt(pane);
+ const at = struct {
+ fn f(sb_: @TypeOf(sb), pan: u16, h: u16, top_: u64, row: u64) ?u16 {
+ if (row < top_ or row - top_ >= sb_.len) return null;
+ const screen_row = sb_.total - sb_.len + (row - top_);
+ if (screen_row < sb_.offset + pan) return null;
+ const y = screen_row - sb_.offset - pan;
+ return if (y < h) @intCast(y) else null;
+ }
+ }.f;
+ for (e.cells[0..e.n]) |cell| {
+ const y = at(sb, pane.pan, body_h, top, cell.row) orelse continue;
+ if (cell.x >= tw) continue;
+ const dst = s.at(tx + cell.x, body_y + y);
+ // Typed text continues the text before it (mosh's heuristic).
+ var style = dst.style;
+ if (cell.x > 0) {
+ const before = s.at(tx + cell.x - 1, body_y + y);
+ if (!before.default and !blank(before.text[0])) style = before.style;
+ }
+ if (flag and !blank(cell.cp)) style.ul = .single;
+ dst.default = false;
+ dst.text[0] = @intCast(cell.cp);
+ dst.len = 1;
+ dst.style = style;
+ }
+ if (!active or pane.focus != .body) return;
+ const cur = e.cursor orelse return;
+ const y = at(sb, pane.pan, body_h, top, cur.row) orelse return;
+ if (cur.x < tw) s.cursor = .{ .x = tx + cur.x, .y = body_y + y };
+ }
+};
+
+const Kind = union(enum) { char: u21, backspace, left, right };
+
+fn kindOf(ev: pardes.Event) ?Kind {
+ const k = switch (ev) {
+ .key => |k| k,
+ else => return null,
+ };
+ if (k.ctrl or k.alt) return null;
+ switch (k.cp) {
+ Key.backspace => return .backspace,
+ Key.left => return .left,
+ Key.right => return .right,
+ else => {},
+ }
+ // As forwardKey sends it. ponytail: ASCII only; a width table would
+ // let the rest in.
+ const cp: u21 = if (k.text.len == 1)
+ k.text[0]
+ else if (k.text.len == 0 and k.cp >= 'a' and k.cp <= 'z' and k.shift)
+ k.cp - 'a' + 'A'
+ else if (k.text.len == 0)
+ k.cp
+ else
+ return null;
+ return if (cp >= 0x20 and cp < 0x7f) .{ .char = cp } else null;
+}
+
+/// Whether key `ev` goes to the terminal's program as it is (forwardKey's)
+/// and not to pardes: Esc backs out of the pane, the tty chord leaves tty
+/// mode, Ctrl-V pastes the register.
+fn forwarded(c: *const Pardes, ev: pardes.Event) bool {
+ const k = switch (ev) {
+ .key => |k| k,
+ else => return false,
+ };
+ if (k.cp == Key.escape) return false;
+ return !(k.ctrl and (k.cp == c.opts.tty_toggle or k.cp == 'v' or k.cp == 'V'));
+}
+
+fn blank(cp: u21) bool {
+ return cp == 0 or cp == ' ';
+}
+
+/// At a shell's prompt, reading its input: pardes's marks (a B and no C
+/// since) and the cursor's own, on the primary screen. A shell without
+/// pardes's marks is trusted only once its echo is confirmed.
+fn atPrompt(pane: *const Pane) bool {
+ if (comptime !terminal.enabled) return false;
+ const state = pane.terminal orelse return false;
+ return state.vt.screens.active_key == .primary and state.stream.handler.phase == .input and terminal.promptInputReady(pane);
+}
+
+/// The terminal view `view`'s keys go to, in tty mode: none when they go
+/// elsewhere (a prompt, a header, window mode, another pane).
+fn keyboardPane(c: *const Pardes, view: u8) ?usize {
+ const live = c.view == view;
+ const part = if (live) null else &(c.parked[view] orelse return null).view;
+ const id = if (part) |v| v.active else c.active;
+ if (if (part) |v| v.window_pick != null or v.header_focus else c.window_pick != null or c.header_focus) return null;
+ const pane = c.panes[id] orelse return null;
+ if (!pane.isTerminal() or pane.terminal == null or pane.prompt != .none) return null;
+ const mode = if (live) pane.body.mode else pane.pv[view].body.mode;
+ const focus = if (live) pane.focus else pane.pv[view].focus;
+ return if (mode == .tty and focus == .body) id else null;
+}
+
+// ---- tests: one authority and one replica, its shell played by hand ----
+
+const testing = std.testing;
+const replica = @import("replica.zig");
+
+const Rig = struct {
+ a: *replica.Authority,
+ r: *replica.Replica,
+ screens: replica.Screens,
+ peer: u16,
+ shell: u8,
+ /// What the authority wrote its shell's pty.
+ written: std.ArrayListUnmanaged(u8) = .empty,
+ now: u64 = 1_000 * ms,
+
+ fn ptyWrite(ctx: ?*anyopaque, _: u8, bytes: []const u8) void {
+ const g: *Rig = @ptrCast(@alignCast(ctx.?));
+ g.written.appendSlice(testing.allocator, bytes) catch {};
+ }
+ fn watched(_: ?*anyopaque) bool {
+ return false;
+ }
+ const vtable: pardes.Host.VTable = .{ .watched = watched, .pty_write = ptyWrite };
+
+ fn init(g: *Rig) !void {
+ const gpa = testing.allocator;
+ g.written = .empty;
+ g.now = 1_000 * ms;
+ g.a = try replica.Authority.init(gpa, .{ .cols = 60, .rows = 16, .boot = .tty_shell }, .{ .ctx = g, .vtable = &vtable }, true);
+ g.screens = .init(gpa);
+ g.peer = try g.screens.addPeer();
+ g.r = try replica.Replica.init(gpa, 1, try g.a.unit(0, 0), true);
+ g.shell = for (g.a.core.panes, 0..) |slot, id| {
+ if (slot) |pane| if (pane.isTerminal()) break @intCast(id);
+ } else return error.NoShell;
+ g.r.echo.now = g.now;
+ }
+
+ fn deinit(g: *Rig) void {
+ g.r.deinit();
+ g.screens.deinit(g.a.core);
+ g.a.deinit();
+ g.written.deinit(testing.allocator);
+ }
+
+ fn later(g: *Rig, dt: u64) void {
+ g.now += dt;
+ g.r.echo.now = g.now;
+ }
+
+ /// The shell prints `bytes`; the replica gets the unit and the delta.
+ fn prints(g: *Rig, bytes: []const u8) !void {
+ g.a.output(.{ .output = .{ .pane = g.shell, .bytes = bytes } });
+ try g.sync();
+ }
+
+ fn sync(g: *Rig) !void {
+ const gpa = testing.allocator;
+ if (try g.a.pending()) |u| g.r.confirm(u);
+ g.r.settle();
+ var msgs: std.ArrayListUnmanaged([]u8) = .empty;
+ defer {
+ for (msgs.items) |m| gpa.free(m);
+ msgs.deinit(gpa);
+ }
+ try g.screens.flush(g.a.core, g.peer, &msgs);
+ for (msgs.items) |m| if (g.r.screen(m)) |reply| {
+ _ = try g.screens.take(g.a.core, g.peer, reply);
+ };
+ }
+
+ /// The replica's client types `k`; the message for the authority.
+ fn key(g: *Rig, k: Key) ![]u8 {
+ return testing.allocator.dupe(u8, try g.r.input(.{ .key = k }));
+ }
+
+ /// The authority takes it, and the replica its unit.
+ fn take(g: *Rig, msg: []u8) !void {
+ defer testing.allocator.free(msg);
+ if (try g.a.pending()) |u| g.r.confirm(u);
+ g.r.confirm(try g.a.take(msg));
+ g.r.settle();
+ }
+
+ /// What the replica's screen shows at the shell's cursor row, drawn,
+ /// and whether the cell at `x` is underlined.
+ fn drawn(g: *Rig, arena: *std.heap.ArenaAllocator, x: u16) !struct { cp: u8, ul: bool, cursor: ?u16 } {
+ _ = arena.reset(.retain_capacity);
+ const c = g.r.core();
+ c.needs_frame = true;
+ const s = try c.render(arena.allocator());
+ const pane = c.panes[g.shell].?;
+ const body = s.region(.body, g.shell).?.rect;
+ const y = body.y + terminal.gridCursor(pane).y;
+ const cell = s.at(body.x + x, y);
+ return .{ .cp = cell.text[0], .ul = cell.style.ul != .off, .cursor = if (s.cursor) |cur| if (cur.y == y) cur.x - body.x else null else null };
+ }
+};
+
+const prompt = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07";
+
+test "keys typed at a shell's prompt are drawn at once, and the authority's echo takes their place" {
+ if (comptime !terminal.enabled) return error.SkipZigTest;
+ var g: Rig = undefined;
+ try g.init();
+ defer g.deinit();
+ try g.prints(prompt);
+ var arena: std.heap.ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+ const before = try g.drawn(&arena, 2);
+ try testing.expectEqual(@as(?u16, 2), before.cursor);
+ // Typed: shown at once, the cursor past it, and nothing underlined at
+ // a prompt.
+ const l = try g.key(.{ .cp = 'l', .text = "l" });
+ const s = try g.key(.{ .cp = 's', .text = "s" });
+ try testing.expectEqual(@as(u32, 2), g.r.echo.stats.predicted);
+ var shown = try g.drawn(&arena, 2);
+ try testing.expectEqual(@as(u8, 'l'), shown.cp);
+ try testing.expect(!shown.ul);
+ try testing.expectEqual(@as(?u16, 4), shown.cursor);
+ try testing.expectEqual(@as(u8, 's'), (try g.drawn(&arena, 3)).cp);
+ // The authority's core draws no overlay of its own.
+ try testing.expect(g.a.core.echo == null);
+ // The authority takes them, its shell echoes, the delta lands after the
+ // grace: confirmed, and the screen's own cells and cursor shown.
+ try g.take(l);
+ try g.take(s);
+ try testing.expectEqualStrings("ls", g.written.items);
+ g.later(grace_ns);
+ try g.prints("ls");
+ try testing.expectEqual(@as(u8, 0), g.r.echo.n);
+ try testing.expect(g.r.echo.cursor == null);
+ try testing.expectEqual(@as(u32, 2), g.r.echo.stats.confirmed);
+ shown = try g.drawn(&arena, 3);
+ try testing.expectEqual(@as(u8, 's'), shown.cp);
+ try testing.expectEqual(@as(?u16, 4), shown.cursor);
+ // Backspace at the end of the line, shown at once.
+ const bs = try g.key(.{ .cp = Key.backspace });
+ shown = try g.drawn(&arena, 3);
+ try testing.expectEqual(@as(u8, ' '), shown.cp);
+ try testing.expectEqual(@as(?u16, 3), shown.cursor);
+ try g.take(bs);
+ g.later(grace_ns);
+ try g.prints("\x08\x1b[K");
+ try testing.expectEqual(@as(u32, 0), g.r.echo.stats.mispredicted + g.r.echo.stats.cursor_missed);
+ try testing.expect(g.r.quiet());
+ try testing.expectEqual(replica.digestOf(g.a), g.r.digest());
+}
+
+test "a password prompt shows nothing typed, and a full-screen program is not predicted" {
+ if (comptime !terminal.enabled) return error.SkipZigTest;
+ var g: Rig = undefined;
+ try g.init();
+ defer g.deinit();
+ try g.prints(prompt ++ "sudo ls\r\n\x1b]133;C;aid=pardes\x07[sudo] password: ");
+ var arena: std.heap.ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+ const x = terminal.gridCursor(g.r.core().panes[g.shell].?).x;
+ const k = try g.key(.{ .cp = 'h', .text = "h" });
+ // Predicted, and not drawn: nothing has confirmed an echo here.
+ try testing.expectEqual(@as(u32, 1), g.r.echo.stats.predicted);
+ try testing.expectEqual(@as(u8, ' '), (try g.drawn(&arena, x)).cp);
+ try g.take(k);
+ // No echo, so no delta: a frame lets it go once it is stale.
+ g.later(grace_ns + stale_ns);
+ _ = g.r.echoFrame();
+ try testing.expectEqual(@as(u8, 0), g.r.echo.n);
+ try testing.expectEqual(@as(u32, 1), g.r.echo.stats.mispredicted);
+ // The next key still shows nothing.
+ const k2 = try g.key(.{ .cp = 'i', .text = "i" });
+ try testing.expectEqual(@as(u8, ' '), (try g.drawn(&arena, x)).cp);
+ try g.take(k2);
+ // vim: the alternate screen, never predicted.
+ try g.prints("\r\n\x1b]133;D;1;aid=pardes\x07" ++ prompt ++ "vim\r\n\x1b]133;C;aid=pardes\x07\x1b[?1049h\x1b[H~");
+ g.later(grace_ns + stale_ns);
+ _ = g.r.echoFrame();
+ const before = g.r.echo.stats.predicted;
+ try g.take(try g.key(.{ .cp = 'i', .text = "i" }));
+ try testing.expectEqual(before, g.r.echo.stats.predicted);
+}
+
+test "a misprediction takes every prediction back and shows none until an echo is confirmed; after Tab nothing is predicted until its echo" {
+ if (comptime !terminal.enabled) return error.SkipZigTest;
+ var g: Rig = undefined;
+ try g.init();
+ defer g.deinit();
+ try g.prints(prompt);
+ var arena: std.heap.ArenaAllocator = .init(testing.allocator);
+ defer arena.deinit();
+ // A line editor that echoes something else (vi's command mode): shown,
+ // then taken back.
+ const a = try g.key(.{ .cp = 'a', .text = "a" });
+ try testing.expectEqual(@as(u8, 'a'), (try g.drawn(&arena, 2)).cp);
+ try g.take(a);
+ g.later(grace_ns);
+ try g.prints("A");
+ try testing.expectEqual(@as(u32, 1), g.r.echo.stats.mispredicted);
+ try testing.expect(g.r.echo.doubt);
+ try testing.expectEqual(@as(u8, 'A'), (try g.drawn(&arena, 2)).cp);
+ // Doubted: predicted, not drawn, until one is confirmed.
+ const b = try g.key(.{ .cp = 'b', .text = "b" });
+ try testing.expectEqual(@as(u8, ' '), (try g.drawn(&arena, 3)).cp);
+ try g.take(b);
+ g.later(grace_ns);
+ try g.prints("b");
+ try testing.expect(!g.r.echo.doubt);
+ const c = try g.key(.{ .cp = 'c', .text = "c" });
+ try testing.expectEqual(@as(u8, 'c'), (try g.drawn(&arena, 4)).cp);
+ // Tab: not predicted, and neither is what follows until the authority
+ // has it and its echo has had its grace.
+ const tab = try g.key(.{ .cp = Key.tab });
+ const d = try g.key(.{ .cp = 'd', .text = "d" });
+ try testing.expectEqual(@as(u32, 1), g.r.echo.stats.unpredicted);
+ try g.take(c);
+ try testing.expectEqual(@as(u8, 'c'), (try g.drawn(&arena, 4)).cp);
+ // The authority has Tab (and the key after it): what was predicted
+ // before it goes, the screen's own shown.
+ try g.take(tab);
+ try g.take(d);
+ try testing.expectEqual(@as(u8, 0), g.r.echo.n);
+ g.later(grace_ns);
+ try g.prints("c" ++ "ompleted d");
+ // `d`, typed behind Tab, the screen showed by then: not predicted.
+ try testing.expectEqual(@as(u32, 2), g.r.echo.stats.unpredicted);
+ const e = try g.key(.{ .cp = 'e', .text = "e" });
+ try testing.expectEqual(@as(u8, 'e'), (try g.drawn(&arena, 15)).cp);
+ try g.take(e);
+ g.later(grace_ns);
+ try g.prints("e");
+ // A key typed behind Tab that the authority does not have yet is
+ // predicted once Tab's doing is on the screen, where it now goes.
+ const tab2 = try g.key(.{ .cp = Key.tab });
+ const f = try g.key(.{ .cp = 'f', .text = "f" });
+ try g.take(tab2);
+ try g.prints("ff");
+ try testing.expectEqual(@as(u8, 0), g.r.echo.n);
+ g.later(grace_ns);
+ _ = g.r.echoFrame();
+ try testing.expectEqual(@as(u8, 1), g.r.echo.n);
+ try testing.expectEqual(@as(u8, 'f'), (try g.drawn(&arena, 18)).cp);
+ try g.take(f);
+ g.later(grace_ns);
+ try g.prints("f");
+ try testing.expectEqual(@as(u8, 0), g.r.echo.n);
+ try testing.expectEqual(@as(u32, 1), g.r.echo.stats.mispredicted);
+ try testing.expectEqual(@as(u32, 0), g.r.echo.stats.cursor_missed);
+ try testing.expect(g.r.quiet());
+ try testing.expectEqual(replica.digestOf(g.a), g.r.digest());
+}