f04db7c5

feat: a drag over a zoomed tile paints what it crossed

a73x 2026-08-22 13:13

Commit message

feat: a drag over a zoomed tile paints what it crossed

The zoomed half of the selection, and the easy one: `renderClipped` is
top-anchored, so a terminal row IS a grid row and the only conversion
left is the history the daemon holds under it. The Core already
receives the mouse bytes unsplit, already knows whether the session's
application wants them, and owns the replica, the paint and the thread
they run on — so it paints its own highlight and needs no shared state
at all. The wall's loop cannot do that, and does not.

The highlight rides through the painters as a CALLBACK, asked per row.
`select` and `paint` are siblings at layer 1 and may not import each
other, so the join is `interact.Highlight` — which converts as well as
adapts, absolute rows to grid rows against the history count of the
frame being painted. A paint with no selection installs no callback and
emits the bytes it emitted before this existed.

A delta cannot paint a highlighted row. It paints what the daemon sent,
as the daemon sent it, so a row under the inversion would come back
plain and the selection would develop holes wherever the session was
still writing; a held selection takes the full-repaint arm the resync
and the contradiction already share.

When the session's application asks for the mouse, the application gets
the drag — tmux's rule on `mouse_any_flag`, and the one mux's mode
mirror already follows. The selection is CLEARED there rather than
merely ignored: one left standing would sit inverted on a screen that
has stopped being ours to draw on.

A resync clears it too, and for a different reason: absolute rows are
counted from the oldest row the daemon still retains, so a resync
renames the whole space and a kept highlight is an inversion over rows
nobody selected.

Scrolled back, a drag selects nothing. `renderScrollback` blits VT
bytes the daemon composed with no engine behind them, so there is no
row on that screen this Core can name — refused, rather than answered
against the live view the user is not looking at.

Rows past the grid name no line; columns past it clamp. The right edge
is where a hand overshoots, and an out-of-range column is what makes
the daemon answer `.invalid` — a round trip spent to be told so is a
copy the user does not get.

Patch: 063cec67
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GiryvVYESzBqqtf5cH1uoA

build.zig

Old		New
@@ -232,7 +232,7 @@ const mod_table = [_]ModSpec{
232	// must be drivable by anything holding a transport — the CLI client	232	// must be drivable by anything holding a transport — the CLI client
233	// today, a wall tile from the wall's phase-3 convergence on — and it	233	// today, a wall tile from the wall's phase-3 convergence on — and it
234	// names no transport type for exactly that reason (see its header).	234	// names no transport type for exactly that reason (see its header).
235	.{ .name = "interact", .path = "src/interact.zig", .layer = 2, .imports = &.{ "engine", "protocol", "replica", "predict", "client_core", "paint" } },	235	.{ .name = "interact", .path = "src/interact.zig", .layer = 2, .imports = &.{ "engine", "protocol", "replica", "predict", "client_core", "paint", "select" } },
236	// quic and quic_server both: the listener it owns, and the vocabulary	236	// quic and quic_server both: the listener it owns, and the vocabulary
237	// it names directly (the key it loads, the idle default it falls back	237	// it names directly (the key it loads, the idle default it falls back
238	// to). xdg is for endpoint_req's lazy bind — the default key path,	238	// to). xdg is for endpoint_req's lazy bind — the default key path,

src/interact.zig

@@ @@ -41,6 +41,41 @@ const client_core = @import("client_core"); @@
+// Named `paint_mod` because paintOverlay holds a local ArrayList called
+// `paint`, which a container-level `paint` would collide with.
+const paint_mod = @import("paint");
+const select = @import("select");
+/// What `select` answers, in the shape `paint` asks for.
+///
+/// The two are siblings at layer 1 and may not import one another, so
+/// somebody above both has to join them; this is the smaller half of that
+/// join, and the wall reuses it rather than keeping a second copy
+/// (`wallview.paintStripe`).
+///
+/// It converts as well as adapts. `select` speaks ABSOLUTE rows —
+/// counted from the oldest row the daemon retains — and a painter speaks
+/// grid rows, so the history count of the frame being painted is what
+/// turns one into the other. Reading it from the same replica the paint
+/// is walking is the point: a highlight resolved against one frame's
+/// history and painted onto another's is a highlight on the wrong lines.
+pub const Highlight = struct {
+    drag: *const select.Drag,
+    /// Which tile the drag belongs to. Zero for a zoomed `Core`, which is
+    /// the only session on its screen; the wall passes the real index.
+    tile: usize,
+    history_rows: u32,
+    /// A paint with no selection on it asks nothing per row and emits
+    /// exactly the bytes it emitted before this feature existed.
+    pub fn sink(self: *const Highlight) paint_mod.Highlight {
+        if (self.drag.range() == null) return .{};
+        return .{ .ctx = @constCast(self), .span = &spanOf };
+    }
+    fn spanOf(ctx: ?*anyopaque, row: u16, cols: u16) ?paint_mod.Span {
+        const self: *const Highlight = @ptrCast(@alignCast(ctx.?));
+        const s = self.drag.span(self.tile, self.history_rows + row, cols) orelse return null;
+        return .{ .from = s.from, .to = s.to };
+    }
+};
+// Ctrl-\. In a live session it is the command prefix (see PrefixFilter);
+// while dialling or reconnecting there is no session to command, so a bare
@@ @@ -1185,6 +1220,11 @@ pub const Core = struct { @@
+    /// Mouse reports arrive in the same reads as keystrokes; this splits
+    /// them back out, across read boundaries.
+    mouse: MouseFilter = .{},
+    /// The mux selection over THIS session, while this Core holds the
+    /// terminal. A demoted wall tile has `claim == .none` and so never
+    /// sees a report at all: unzoomed, the drag belongs to the wall's own
+    /// keyboard loop, over its own hit-test.
+    drag: select.Drag = .{},
+    /// Scroll mode: 0 = live; N = viewing the screenful whose bottom sits N
+    /// rows above live. Rows rather than pages because the wheel moves by a
+    /// few lines and the keys move by a screen — one unit that expresses
@@ @@ -1388,6 +1428,16 @@ pub const Core = struct { @@
+        return self.rep.eng;
+    /// The selection as this frame's paint must see it.
+    ///
+    /// Returned BY VALUE and kept on the caller's stack for the length of
+    /// the paint: `sink()` hands the painter a pointer to it, and the
+    /// history count it carries is read from the replica the paint is
+    /// about to walk.
+    fn highlight(self: *Core) Highlight {
+        return .{ .drag = &self.drag, .tile = 0, .history_rows = self.rep.history_rows };
+    }
+    /// May this Core paint now, and hold that answer until `endPaint`?
+    /// Every write of GRID bytes goes through this pair; see `Sink`.
+    fn beginPaint(self: *Core) bool {
@@ @@ -1410,7 +1460,8 @@ pub const Core = struct { @@
+    pub fn repaint(self: *Core) !void {
+        if (!self.beginPaint()) return;
+        defer self.endPaint();
+        const hl = self.highlight();
+        try paint_mod.renderClipped(self.alloc, self.rep.eng, self.size, hl.sink(), self.out_fd);
+        paintOverlay(self.alloc, &self.overlay, self.rep.eng.cursorPos(), self.size, self.out_fd);
@@ @@ -1419,7 +1470,8 @@ pub const Core = struct { @@
+    fn paintFull(self: *Core) !void {
+        if (!self.beginPaint()) return;
+        defer self.endPaint();
+        const hl = self.highlight();
+        try paint_mod.renderClipped(self.alloc, self.rep.eng, self.size, hl.sink(), self.out_fd);
+    /// A one-line marker in the corner, painted over by the next full
@@ @@ -1496,7 +1548,13 @@ pub const Core = struct { @@
+        // on scroll exit comes from it.
+        if (self.scroll_rows == 0 and self.beginPaint()) {
+            defer self.endPaint();
+            // A held selection takes the full-repaint arm too. A delta
+            // paints the rows the daemon sent AS THE DAEMON SENT THEM, so
+            // a row under the highlight would come back un-inverted and
+            // the selection would develop holes wherever the session was
+            // still writing. Affordable for the same reason the arm above
+            // is: a selection is a thing a hand holds for a moment.
+            if (self.repaint_after_resync or verdict == .contradicted or self.drag.range() != null) {
+                // First frame back after a reconnect. The daemon sent only
+                // what changed, which is correct — but the screen still
+                // carries the banner, so repaint the whole thing from the
@@ @@ -1513,7 +1571,8 @@ pub const Core = struct { @@
+                // the overlay below it are ONE hold of the sink (a zoom that
+                // moved between them would put the two halves of this frame
+                // on two different screens), and the sink is not reentrant.
+                const hl = self.highlight();
+                try paint_mod.renderClipped(self.alloc, self.rep.eng, self.size, hl.sink(), self.out_fd);
+                self.repaint_after_resync = false;
+            } else {
+                try paint_mod.paintDeltaClipped(self.alloc, payload, self.size, self.out_fd);
@@ @@ -1746,13 +1805,31 @@ pub const Core = struct { @@
+        // with the escape deleted.
+        var keys = typed;
+        var wheel: i32 = 0;
+        // What is on screen before this read's reports are read, so the
+        // repaint below is spent only on a highlight that actually moved.
+        // A drag reports on every cell the pointer crosses.
+        const was = self.drag.range();
+        if (self.claim == .none or self.semantic.terminal_modes.appMouse()) {
+            self.mouse.reset();
+            // The application asked for the mouse, so the application gets
+            // the drag and there is no mux selection here — the same rule
+            // the mode mirror already follows, and tmux's on
+            // `mouse_any_flag`. Shift+drag stays the terminal's own escape
+            // hatch. Cleared rather than merely ignored: a selection made
+            // before the application asked would otherwise sit inverted on
+            // a screen that no longer belongs to it.
+            self.drag.clear();
+        } else {
+            const m = self.mouse.feed(typed, &self.mouse_buf);
+            keys = m.forward;
+            wheel = m.wheel;
+            self.dragReports(m.events);
+        // This Core owns its own screen and its own thread — a tile's pump
+        // is what runs `forward` — so the highlight is painted here rather
+        // than left in shared state for somebody else to draw. The wall's
+        // unzoomed loop cannot do that and does not (`wallview.paintStripe`).
+        if (!std.meta.eql(was, self.drag.range())) try self.paintFull();
+        // Alternate scroll (tmux calls it that; DEC 1007 is the terminal's
+        // own version). The alt screen has no scrollback — `historyRows`
@@ @@ -1847,6 +1924,59 @@ pub const Core = struct { @@
+        return .ok;
+    /// Feed this read's mouse reports to the drag.
+    ///
+    /// Left button only. Middle is the terminal's own paste and right its
+    /// menu, and stealing either would be a surprise with no answer. The
+    /// button word arrives from the filter verbatim, motion bit and
+    /// modifiers included, so it is the low two bits that name the button.
+    ///
+    /// A plain click is a defined no-op here, which is the difference
+    /// between this driver and the wall's: at the wall a click moves the
+    /// selection between stripes, and a zoomed tile is the only session on
+    /// its screen, so there is nothing for a click to select.
+    fn dragReports(self: *Core, events: []const MouseFilter.Event) void {
+        for (events) |ev| {
+            if (ev.button & 0b11 != 0) continue;
+            const cell: select.Cell = .{ .row = ev.row, .col = ev.col };
+            switch (ev.kind) {
+                .press => self.drag.press(cell, self.hitTest(ev)),
+                .motion => self.drag.motion(cell, self.hitTest(ev)),
+                .release => _ = self.drag.release(),
+            }
+        }
+    }
+    /// Which line of this session a report landed on, or null for a report
+    /// that names none.
+    ///
+    /// The mapping is trivial and that is the whole reason selection lives
+    /// in the Core while zoomed: `renderClipped` is top-anchored, so a
+    /// terminal row IS a grid row, and the only conversion left is the
+    /// history the daemon is holding under it.
+    fn hitTest(self: *Core, ev: MouseFilter.Event) ?select.Hit {
+        // Scrolled back, nothing on this screen is addressable:
+        // `renderScrollback` blits VT bytes the daemon composed, with no
+        // engine behind them, so there is no row here to name. Refused
+        // rather than half-answered — the alternative is a selection whose
+        // coordinates belong to the live view the user is not looking at.
+        if (self.scroll_rows > 0) return null;
+        const grid_rows: u16 = @intCast(self.rep.eng.term.rows);
+        const cols: u16 = @intCast(self.rep.eng.term.cols);
+        // Rows past the grid (a terminal taller than the daemon's grid)
+        // hold no session line: `renderClipped` never painted them.
+        if (ev.row >= @min(grid_rows, self.size.rows)) return null;
+        return .{
+            .tile = 0,
+            .row = self.rep.history_rows + ev.row,
+            // Columns clamp instead of refusing, because the right edge is
+            // where a hand naturally overshoots. An out-of-range column is
+            // what makes the daemon answer `.invalid`, and a round trip
+            // spent to be told so is a copy the user does not get.
+            .col = @min(ev.col, cols -| 1),
+        };
+    }
+    /// Go back to the live view without painting it — what a driver does
+    /// BEFORE a reconnect, where the resync's own repaint is what will
+    /// arrive.
@@ @@ -1877,6 +2007,10 @@ pub const Core = struct { @@
+    /// predicted against a connection that no longer exists — dropping it
+    /// is not an accusation, so the counters stay where they are.
+    pub fn reattached(self: *Core) void {
+        // The absolute row space is counted from the oldest row the daemon
+        // retains, and a resync renames it outright — so a highlight kept
+        // across one is an inversion over rows nobody selected.
+        self.drag.clear();
+        self.rep.state_since_attach = false;
+        self.repaint_after_resync = true;
+        self.overlay.flush();
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+/// A transport that swallows everything. `forward` writes the keystrokes
+/// it did not consume, and none of these tests are about those bytes.
+const NullTransport = struct {
+    fn writeFrame(_: *NullTransport, _: proto.MsgType, _: []const u8) !void {}
+};
+/// A zoomed Core on a pipe, with a claim, ready to be dragged over.
+fn dragFixture(alloc: std.mem.Allocator, out_fd: std.posix.fd_t) !Core {
+    var core = try Core.initSized(alloc, -1, out_fd, .{ .cols = 20, .rows = 6 });
+    core.is_tty = true;
+    // A drag only happens on a terminal this Core took over — which is
+    // exactly the promoted-tile case, and the reason an unzoomed tile
+    // never reaches any of this.
+    _ = core.claimTerminal();
+    core.rep.eng.feed("row-zero\r\nrow-one\r\nrow-two\r\nrow-three");
+    return core;
+}
+test "interact: a drag at a zoomed tile inverts what it crossed, and a click does not" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf); // the claim
+    // Press on row 1, column 2. Nothing is painted: a press that turns out
+    // to be a click must not flicker an inversion on its way past.
+    _ = try core.forward(&tr, "\x1b[<0;3;2M");
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+    // Drag to column 6 of the same row.
+    _ = try core.forward(&tr, "\x1b[<32;7;2M");
+    const painted = drainPipe(p[0], &buf);
+    // Columns 2..6 of grid row 1, addressed by column and inverted: the
+    // span opens at column 3 (1-based) and the tail resumes at column 8.
+    try std.testing.expect(std.mem.indexOf(u8, painted, "\x1b[3G\x1b[0m\x1b[7m") != null);
+    try std.testing.expect(std.mem.indexOf(u8, painted, "\x1b[0m\x1b[8G") != null);
+    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, painted, "\x1b[7m"));
+    // The neighbouring rows are ordinary dumps in the same repaint.
+    try std.testing.expect(std.mem.indexOf(u8, painted, "row-zero") != null);
+    try std.testing.expect(std.mem.indexOf(u8, painted, "row-two") != null);
+    // The release does not move the highlight, so it does not repaint one.
+    _ = try core.forward(&tr, "\x1b[<0;7;2m");
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+    // A press elsewhere puts the selection away — and the repaint that
+    // says so carries no inversion at all.
+    _ = try core.forward(&tr, "\x1b[<0;1;4M");
+    const cleared = drainPipe(p[0], &buf);
+    try std.testing.expect(std.mem.indexOf(u8, cleared, "row-three") != null);
+    try std.testing.expect(std.mem.indexOf(u8, cleared, "\x1b[7m") == null);
+    // ...and that press is a click, which a zoomed tile answers with
+    // nothing: there is one session on this screen to select.
+    _ = try core.forward(&tr, "\x1b[<0;1;4m");
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+}
+test "interact: the application that asked for the mouse gets the drag, and mux keeps no selection" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    _ = try core.forward(&tr, "\x1b[<0;3;2M");
+    _ = try core.forward(&tr, "\x1b[<32;7;2M");
+    try std.testing.expect(std.mem.indexOf(u8, drainPipe(p[0], &buf), "\x1b[7m") != null);
+    // vim's `set mouse=a` arrives mid-drag. The reports are the
+    // application's from here, and the selection standing on its screen is
+    // not mux's to keep.
+    core.semantic.terminal_modes = .{
+        .bracketed_paste = false,
+        .mouse_normal = true,
+        .mouse_button = true,
+        .mouse_sgr = true,
+    };
+    _ = try core.forward(&tr, "\x1b[<32;9;2M");
+    const after = drainPipe(p[0], &buf);
+    try std.testing.expect(std.mem.indexOf(u8, after, "row-one") != null);
+    try std.testing.expect(std.mem.indexOf(u8, after, "\x1b[7m") == null);
+    // A further drag under the application selects nothing at all.
+    _ = try core.forward(&tr, "\x1b[<32;11;2M");
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+}
+test "interact: a drag while scrolled back selects nothing" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    // Viewing history: `renderScrollback` blits daemon VT bytes with no
+    // engine behind them, so nothing on this screen is a row this Core can
+    // name. Refused outright rather than answered against the live view
+    // the user is not looking at.
+    core.scroll_rows = 4;
+    _ = try core.forward(&tr, "\x1b[<0;3;2M");
+    _ = try core.forward(&tr, "\x1b[<32;7;2M");
+    try std.testing.expect(core.drag.range() == null);
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+}
+test "interact: a reattach drops the highlight, because the rows have been renamed" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    _ = try core.forward(&tr, "\x1b[<0;3;2M");
+    _ = try core.forward(&tr, "\x1b[<32;7;3M");
+    try std.testing.expect(core.drag.range() != null);
+    _ = drainPipe(p[0], &buf);
+    // Absolute rows count from the oldest row the daemon still retains,
+    // and a resync renames that space outright.
+    core.reattached();
+    try std.testing.expect(core.drag.range() == null);
+    try core.repaint();
+    try std.testing.expect(std.mem.indexOf(u8, drainPipe(p[0], &buf), "\x1b[7m") == null);
+}
+test "interact: the anchor is an absolute row, and the paint converts it back" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    // A session with history behind it, which is every session that has
+    // been used. The number is what makes the two directions of the
+    // conversion distinguishable at all: with none retained, a grid row
+    // and an absolute row are the same integer and neither half of the
+    // arithmetic is under test.
+    core.rep.history_rows = 500;
+    _ = try core.forward(&tr, "\x1b[<0;3;2M");
+    _ = try core.forward(&tr, "\x1b[<32;7;2M");
+    const r = core.drag.range().?;
+    // Terminal row 1 is grid row 1 is the 501st retained row — the space
+    // `protocol.SelectionReq` speaks, and the one a scroll cannot rename.
+    try std.testing.expectEqual(@as(u32, 501), r.from.row);
+    try std.testing.expectEqual(@as(u32, 501), r.to.row);
+    // ...and the paint puts the inversion back on grid row 1, which is the
+    // other half of the same arithmetic: a painter that took the absolute
+    // row literally would invert a row 500 below the one pointed at, or
+    // none at all.
+    const painted = drainPipe(p[0], &buf);
+    try std.testing.expect(std.mem.indexOf(u8, painted, "\x1b[2;1H\x1b[0mro\x1b[3G\x1b[0m\x1b[7m") != null);
+}
+test "interact: only the left button drags" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    var core = try dragFixture(alloc, p[1]);
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    // Middle button (1) and right (2). One is the terminal's own paste and
+    // the other its menu; stealing either would be a surprise with no
+    // answer, and the button word arrives with the motion bit set on a
+    // drag — 33 is a middle-button drag, not a press of button 33.
+    _ = try core.forward(&tr, "\x1b[<1;3;2M");
+    _ = try core.forward(&tr, "\x1b[<33;7;2M");
+    try std.testing.expect(core.drag.range() == null);
+    _ = try core.forward(&tr, "\x1b[<2;3;3M");
+    _ = try core.forward(&tr, "\x1b[<34;7;3M");
+    try std.testing.expect(core.drag.range() == null);
+    try std.testing.expectError(error.WouldBlock, std.posix.read(p[0], &buf));
+}
+test "interact: a row past the grid names no line, and a column past it clamps" {
+    const alloc = std.testing.allocator;
+    const p = try std.posix.pipe2(.{ .NONBLOCK = true });
+    defer std.posix.close(p[0]);
+    defer std.posix.close(p[1]);
+    // A terminal taller and wider than the daemon's grid, which latest-wins
+    // leaves routinely.
+    var core = try Core.initSized(alloc, -1, p[1], .{ .cols = 40, .rows = 12 });
+    core.is_tty = true;
+    _ = core.claimTerminal();
+    defer core.deinit();
+    var tr: NullTransport = .{};
+    var buf: [8192]u8 = undefined;
+    _ = drainPipe(p[0], &buf);
+    // The grid is smaller than the Core's clip size: 20x6 against 40x12.
+    try core.rep.eng.resize(20, 6);
+    core.rep.eng.feed("row-zero\r\nrow-one\r\nrow-two");
+    // Row 8 is inside the terminal and past the grid: `renderClipped`
+    // never painted a session line there.
+    _ = try core.forward(&tr, "\x1b[<0;3;9M");
+    try std.testing.expect(core.drag.range() == null);
+    // Column 34 is past the grid's right edge. It clamps to the last
+    // column instead of refusing — the right edge is where a hand
+    // overshoots — and an out-of-range column is what makes the daemon
+    // answer `.invalid` when the selection is asked for.
+    _ = try core.forward(&tr, "\x1b[<0;35;2M");
+    _ = try core.forward(&tr, "\x1b[<32;3;2M");
+    const r = core.drag.range().?;
+    try std.testing.expectEqual(@as(u16, 19), r.to.col);
+    try std.testing.expectEqual(@as(u16, 2), r.from.col);
+}
+test "interact: only lifecycle and agent-channel frames come back to the driver" {
+    const alloc = std.testing.allocator;
+    // No terminal at either end: every paint and every side channel is

src/paint.zig

Old		New
@@ -18,6 +18,36 @@ const proto = @import("protocol");
18	pub const sync_begin = "\x1b[?2026h\x1b[?25l";	18	pub const sync_begin = "\x1b[?2026h\x1b[?25l";
19	pub const sync_end = "\x1b[?25h\x1b[?2026l";	19	pub const sync_end = "\x1b[?25h\x1b[?2026l";
20		20
		21	/// Inclusive grid columns of one row, painted inverted.
		22	pub const Span = struct { from: u16, to: u16 };
		23
		24	/// Which columns of a grid row a painter must invert, asked per row.
		25	///
		26	/// A callback and not a list of rows, for a layering reason and a
		27	/// practical one. The answer comes from `select.zig`, which is layer 1
		28	/// like this module — neither may import the other — so the shape of a
		29	/// selection cannot be named here; and a painter emits row by row anyway,
		30	/// so per-row is the question it already has to ask. `cols` is handed
		31	/// DOWN rather than remembered by the caller: the width the highlight is
		32	/// clamped to must be the width this paint is about to use, and
		33	/// `Engine.dumpVtRowSpan` asserts it.
		34	///
		35	/// Null `span` — the default — is a paint with no selection on it, which
		36	/// is nearly every paint.
		37	pub const Highlight = struct {
		38	ctx: ?*anyopaque = null,
		39	span: ?const fn (?anyopaque, row: u16, cols: u16) ?Span = null,
		40	};
		41
		42	/// One grid row, inverted where the highlight says so. The single place
		43	/// the two painters agree about what a selection does to a row.
		44	fn dumpRow(alloc: std.mem.Allocator, replica: *Engine, y: u16, hl: Highlight) ![]u8 {
		45	const ask = hl.span orelse return replica.dumpVtRow(alloc, y);
		46	const s = ask(hl.ctx, y, @intCast(replica.term.cols)) orelse
		47	return replica.dumpVtRow(alloc, y);
		48	return replica.dumpVtRowSpan(alloc, y, s.from, s.to);
		49	}
		50
21	pub fn clampCursor(cur: Engine.CursorPos, tty: proto.Size) Engine.CursorPos {	51	pub fn clampCursor(cur: Engine.CursorPos, tty: proto.Size) Engine.CursorPos {
22	return .{	52	return .{
23	.x = @min(cur.x, tty.cols -\| 1),	53	.x = @min(cur.x, tty.cols -\| 1),
@@ -29,7 +59,13 @@ pub fn clampCursor(cur: Engine.CursorPos, tty: proto.Size) Engine.CursorPos {
29	/// grid-sized (may exceed the tty under latest-wins); rows beyond the tty	59	/// grid-sized (may exceed the tty under latest-wins); rows beyond the tty
30	/// are skipped and long rows clip at the right edge because autowrap is	60	/// are skipped and long rows clip at the right edge because autowrap is
31	/// off (DECAWM, set at attach).	61	/// off (DECAWM, set at attach).
32	pub fn renderClipped(alloc: std.mem.Allocator, replica: *Engine, tty: proto.Size, out_fd: std.posix.fd_t) !void {	62	pub fn renderClipped(
		63	alloc: std.mem.Allocator,
		64	replica: *Engine,
		65	tty: proto.Size,
		66	hl: Highlight,
		67	out_fd: std.posix.fd_t,
		68	) !void {
33	var paint: std.ArrayList(u8) = .empty;	69	var paint: std.ArrayList(u8) = .empty;
34	defer paint.deinit(alloc);	70	defer paint.deinit(alloc);
35	try paint.appendSlice(alloc, sync_begin ++ "\x1b[H\x1b[2J");	71	try paint.appendSlice(alloc, sync_begin ++ "\x1b[H\x1b[2J");
@@ -40,7 +76,7 @@ pub fn renderClipped(alloc: std.mem.Allocator, replica: *Engine, tty: proto.Size
40	while (y < limit) : (y += 1) {	76	while (y < limit) : (y += 1) {
41	var cup: [16]u8 = undefined;	77	var cup: [16]u8 = undefined;
42	try paint.appendSlice(alloc, try std.fmt.bufPrint(&cup, "\x1b[{d};1H", .{y + 1}));	78	try paint.appendSlice(alloc, try std.fmt.bufPrint(&cup, "\x1b[{d};1H", .{y + 1}));
43	const row = try replica.dumpVtRow(alloc, y);	79	const row = try dumpRow(alloc, replica, y, hl);
44	defer alloc.free(row);	80	defer alloc.free(row);
45	try paint.appendSlice(alloc, row);	81	try paint.appendSlice(alloc, row);
46	}	82	}
@@ -154,6 +190,7 @@ pub fn renderStripe(
154	replica: *Engine,	190	replica: *Engine,
155	row_off: u16,	191	row_off: u16,
156	view: proto.Size,	192	view: proto.Size,
		193	hl: Highlight,
157	out_fd: std.posix.fd_t,	194	out_fd: std.posix.fd_t,
158	) !void {	195	) !void {
159	var paint: std.ArrayList(u8) = .empty;	196	var paint: std.ArrayList(u8) = .empty;
@@ -171,7 +208,7 @@ pub fn renderStripe(
171	}) {	208	}) {
172	var cup: [16]u8 = undefined;	209	var cup: [16]u8 = undefined;
173	try paint.appendSlice(alloc, try std.fmt.bufPrint(&cup, "\x1b[{d};1H\x1b[2K", .{out_row}));	210	try paint.appendSlice(alloc, try std.fmt.bufPrint(&cup, "\x1b[{d};1H\x1b[2K", .{out_row}));
174	const row = try replica.dumpVtRow(alloc, y);	211	const row = try dumpRow(alloc, replica, y, hl);
175	defer alloc.free(row);	212	defer alloc.free(row);
176	try paint.appendSlice(alloc, row);	213	try paint.appendSlice(alloc, row);
177	}	214	}
@@ -210,7 +247,7 @@ test "renderStripe paints the grid bottom at the stripe offset, no wipe, no curs
210	defer std.posix.close(pipe[0]);	247	defer std.posix.close(pipe[0]);
211	// 3 view rows over a 5-row grid, cursor on row 4: the window keeps the	248	// 3 view rows over a 5-row grid, cursor on row 4: the window keeps the
212	// cursor on its last row — grid rows 2..4 — at offset 4.	249	// cursor on its last row — grid rows 2..4 — at offset 4.
213	try renderStripe(alloc, replica, 4, .{ .cols = 20, .rows = 3 }, pipe[1]);	250	try renderStripe(alloc, replica, 4, .{ .cols = 20, .rows = 3 }, .{}, pipe[1]);
214	std.posix.close(pipe[1]);	251	std.posix.close(pipe[1]);
215		252
216	var out: [4096]u8 = undefined;	253	var out: [4096]u8 = undefined;
@@ -245,7 +282,7 @@ test "renderStripe with the cursor high shows the grid top, not blank bottom row
245		282
246	const pipe = try std.posix.pipe();	283	const pipe = try std.posix.pipe();
247	defer std.posix.close(pipe[0]);	284	defer std.posix.close(pipe[0]);
248	try renderStripe(alloc, replica, 0, .{ .cols = 20, .rows = 8 }, pipe[1]);	285	try renderStripe(alloc, replica, 0, .{ .cols = 20, .rows = 8 }, .{}, pipe[1]);
249	std.posix.close(pipe[1]);	286	std.posix.close(pipe[1]);
250		287
251	var out: [8192]u8 = undefined;	288	var out: [8192]u8 = undefined;
@@ -266,7 +303,7 @@ test "renderStripe clears stripe rows a short grid does not reach" {
266	defer std.posix.close(pipe[0]);	303	defer std.posix.close(pipe[0]);
267	// 4 view rows over a 2-row grid at offset 0: rows 3 and 4 must be	304	// 4 view rows over a 2-row grid at offset 0: rows 3 and 4 must be
268	// cleared, not skipped.	305	// cleared, not skipped.
269	try renderStripe(alloc, replica, 0, .{ .cols = 20, .rows = 4 }, pipe[1]);	306	try renderStripe(alloc, replica, 0, .{ .cols = 20, .rows = 4 }, .{}, pipe[1]);
270	std.posix.close(pipe[1]);	307	std.posix.close(pipe[1]);
271		308
272	var out: [4096]u8 = undefined;	309	var out: [4096]u8 = undefined;
@@ -277,6 +314,78 @@ test "renderStripe clears stripe rows a short grid does not reach" {
277	try std.testing.expect(std.mem.indexOf(u8, text, "\x1b[4;1H\x1b[2K") != null);	314	try std.testing.expect(std.mem.indexOf(u8, text, "\x1b[4;1H\x1b[2K") != null);
278	}	315	}
279		316
		317	/// A highlight of two fixed rows, standing in for what `select.Drag`
		318	/// answers: rows 1 and 2, from column 3 to the width the painter offers.
		319	const TestHighlight = struct {
		320	cols_seen: u16 = 0,
		321
		322	fn span(ctx: ?*anyopaque, row: u16, cols: u16) ?Span {
		323	const self: *TestHighlight = @ptrCast(@alignCast(ctx.?));
		324	self.cols_seen = cols;
		325	if (row != 1 and row != 2) return null;
		326	return .{ .from = 3, .to = cols -\| 1 };
		327	}
		328
		329	fn hl(self: *TestHighlight) Highlight {
		330	return .{ .ctx = self, .span = &span };
		331	}
		332	};
		333
		334	test "renderClipped inverts the highlighted rows and leaves the rest alone" {
		335	const alloc = std.testing.allocator;
		336	var replica = try Engine.init(alloc, .{ .cols = 12, .rows = 4 });
		337	defer replica.deinit();
		338	replica.feed("row-zero\r\nrow-one\r\nrow-two\r\nrow-three");
		339
		340	const pipe = try std.posix.pipe();
		341	defer std.posix.close(pipe[0]);
		342	var h: TestHighlight = .{};
		343	try renderClipped(alloc, replica, .{ .cols = 80, .rows = 24 }, h.hl(), pipe[1]);
		344	std.posix.close(pipe[1]);
		345
		346	var out: [8192]u8 = undefined;
		347	const n = try std.posix.read(pipe[0], &out);
		348	const text = out[0..n];
		349	// The two highlighted rows carry an inversion; the rows above and
		350	// below are ordinary dumps and must not.
		351	try std.testing.expectEqual(@as(usize, 2), std.mem.count(u8, text, "\x1b[7m"));
		352	const r0 = std.mem.indexOf(u8, text, "row-zero").?;
		353	const r1 = std.mem.indexOf(u8, text, "\x1b[7m").?;
		354	const r3 = std.mem.indexOf(u8, text, "row-three").?;
		355	try std.testing.expect(r0 < r1 and r1 < r3);
		356	// The span begins at column 4 (0-based 3), which only the CHA says.
		357	try std.testing.expect(std.mem.indexOf(u8, text, "\x1b[4G\x1b[0m\x1b[7m") != null);
		358	// The width the highlight was clamped to is the GRID's, not the tty's:
		359	// a 12-column replica painted on an 80-column terminal has 68 columns
		360	// no cell can be selected in, and asking the daemon for one is a round
		361	// trip spent to be told `.invalid`.
		362	try std.testing.expectEqual(@as(u16, 12), h.cols_seen);
		363	}
		364
		365	test "renderStripe inverts a highlighted row inside the stripe" {
		366	const alloc = std.testing.allocator;
		367	var replica = try Engine.init(alloc, .{ .cols = 12, .rows = 4 });
		368	defer replica.deinit();
		369	replica.feed("row-zero\r\nrow-one\r\nrow-two\r\nrow-three");
		370
		371	const pipe = try std.posix.pipe();
		372	defer std.posix.close(pipe[0]);
		373	var h: TestHighlight = .{};
		374	// The whole grid fits the view, so the window starts at grid row 0 and
		375	// the highlight's rows 1 and 2 are the stripe's second and third.
		376	try renderStripe(alloc, replica, 0, .{ .cols = 12, .rows = 4 }, h.hl(), pipe[1]);
		377	std.posix.close(pipe[1]);
		378
		379	var out: [8192]u8 = undefined;
		380	const n = try std.posix.read(pipe[0], &out);
		381	const text = out[0..n];
		382	try std.testing.expectEqual(@as(usize, 2), std.mem.count(u8, text, "\x1b[7m"));
		383	// GRID rows, not terminal rows: the highlight is asked about the row
		384	// of the session, and the stripe offset is the painter's business.
		385	try std.testing.expect(std.mem.indexOf(u8, text, "\x1b[2;1H\x1b[2K\x1b[0mrow\x1b[4G\x1b[0m\x1b[7m") != null);
		386	try std.testing.expect(std.mem.indexOf(u8, text, "\x1b[1;1H\x1b[2K\x1b[0mrow-zero") != null);
		387	}
		388
280	test "paintBanner parks an inverse label top-right without moving the cursor" {	389	test "paintBanner parks an inverse label top-right without moving the cursor" {
281	const pipe = try std.posix.pipe();	390	const pipe = try std.posix.pipe();
282	defer std.posix.close(pipe[0]);	391	defer std.posix.close(pipe[0]);
@@ -333,7 +442,7 @@ test "renderClipped paints only rows that fit and clamps the cursor" {
333	const pipe = try std.posix.pipe();	442	const pipe = try std.posix.pipe();
334	defer std.posix.close(pipe[0]);	443	defer std.posix.close(pipe[0]);
335	// Local tty is smaller than the 100x30 grid.	444	// Local tty is smaller than the 100x30 grid.
336	try renderClipped(alloc, replica, .{ .cols = 80, .rows = 24 }, pipe[1]);	445	try renderClipped(alloc, replica, .{ .cols = 80, .rows = 24 }, .{}, pipe[1]);
337	std.posix.close(pipe[1]);	446	std.posix.close(pipe[1]);
338		447
339	var out: std.ArrayList(u8) = .empty;	448	var out: std.ArrayList(u8) = .empty;
@@ -372,7 +481,7 @@ test "renderClipped stops at the grid when the tty is the larger one" {
372		481
373	const pipe = try std.posix.pipe();	482	const pipe = try std.posix.pipe();
374	defer std.posix.close(pipe[0]);	483	defer std.posix.close(pipe[0]);
375	try renderClipped(alloc, replica, .{ .cols = 80, .rows = 24 }, pipe[1]);	484	try renderClipped(alloc, replica, .{ .cols = 80, .rows = 24 }, .{}, pipe[1]);
376	std.posix.close(pipe[1]);	485	std.posix.close(pipe[1]);
377		486
378	var out: std.ArrayList(u8) = .empty;	487	var out: std.ArrayList(u8) = .empty;

src/wallview.zig

Old		New
@@ -833,7 +833,7 @@ fn paintStripe(t: Tile, alloc: std.mem.Allocator, eng: Engine, history_rows: u
833	.history_rows = history_rows,	833	.history_rows = history_rows,
834	.win_start = paint.stripeWinStart(@intCast(eng.term.rows), eng.cursorPos().y, view.rows),	834	.win_start = paint.stripeWinStart(@intCast(eng.term.rows), eng.cursorPos().y, view.rows),
835	};	835	};
836	paint.renderStripe(alloc, eng, t.stripe.top + 1, view, t.shared.out_fd) catch {};	836	paint.renderStripe(alloc, eng, t.stripe.top + 1, view, .{}, t.shared.out_fd) catch {};
837	return true;	837	return true;
838	}	838	}
839		839