96378b1a

test: the wheel works in a zoomed tile, and the demote gives it back

a73x 2026-08-20 04:19

Commit message

test: the wheel works in a zoomed tile, and the demote gives it back

Three scenarios, pin 48 -> 51.

The zoomed wheel borrows scenario 42's arithmetic verbatim (eight notches
= 24 rows = one screenful on 80x24) so a difference here is the wall's and
not the geometry's. Its lines are wln1..wln100 rather than bare numbers
because a wall's label bar carries the socket path, which carries the
run's pid: a bare 60 in a pid would pass the money assertion for no
reason.

The demoted half rides the same capture, anchored on a positive the same
leg proves, and counts the mouse-off writes: exactly two on this run, the
demote and the wall's exit. One is a wall that left the user's terminal
reporting clicks into their shell.

The app-owns-mouse leg is the one that forced code: a promote is answered
by resyncSnapshot, which carries no term_modes, so the handover cannot
come from a frame. claimTerminal level-sets what the Core already knew
from watching every mode sample while the tile was a stripe.

src/interact.zig

Old		New
@@ -2551,6 +2551,18 @@ test "interact: a borrowed terminal's claim is the client's, and every teardown
2551	}	2551	}
2552	}	2552	}
2553		2553
		2554	/// Everything waiting on a NON-BLOCKING pipe, as one slice. One escape
		2555	/// sequence per `write` is how these are emitted, so a reader that took the
		2556	/// first write for the whole answer would pin half a pair.
		2557	fn drainPipe(fd: std.posix.fd_t, buf: []u8) []const u8 {
		2558	var n: usize = 0;
		2559	while (std.posix.read(fd, buf[n..])) \|got\| {
		2560	if (got == 0) break;
		2561	n += got;
		2562	} else \|_\| {}
		2563	return buf[0..n];
		2564	}
		2565
2554	test "interact: a promote takes the mouse, a demote gives it back, a demote twice writes nothing" {	2566	test "interact: a promote takes the mouse, a demote gives it back, a demote twice writes nothing" {
2555	const alloc = std.testing.allocator;	2567	const alloc = std.testing.allocator;
2556	// Non-blocking, so a half of the pair that stopped writing FAILS here	2568	// Non-blocking, so a half of the pair that stopped writing FAILS here
@@ -2569,11 +2581,18 @@ test "interact: a promote takes the mouse, a demote gives it back, a demote twic
2569	core.is_tty = true;	2581	core.is_tty = true;
2570	defer core.deinit();	2582	defer core.deinit();
2571		2583
2572	var buf: [256]u8 = undefined;	2584	var buf: [512]u8 = undefined;
2573		2585
2574	try std.testing.expect(core.claimTerminal());	2586	try std.testing.expect(core.claimTerminal());
2575	try std.testing.expectEqual(Claim.session, core.claim);	2587	try std.testing.expectEqual(Claim.session, core.claim);
2576	try std.testing.expectEqualStrings(session_claim, buf[0..try std.posix.read(p[0], &buf)]);	2588	// Two writes, drained as one: the claim itself and then the SESSION's
		2589	// modes level-set on top of it.
		2590	const claimed = drainPipe(p[0], &buf);
		2591	try std.testing.expect(std.mem.startsWith(u8, claimed, session_claim));
		2592	// A mode the claim never names, so its presence can only be the
		2593	// level-set — the half a promote needs because `resyncSnapshot` answers
		2594	// a resize with no `term_modes` at all.
		2595	try std.testing.expect(std.mem.indexOf(u8, claimed, "\x1b[?1002l") != null);
2577		2596
2578	// A promote onto the tile already zoomed re-asserts the grid, not the	2597	// A promote onto the tile already zoomed re-asserts the grid, not the
2579	// modes: nothing is written a second time, so nothing has to come off	2598	// modes: nothing is written a second time, so nothing has to come off
@@ -2583,7 +2602,7 @@ test "interact: a promote takes the mouse, a demote gives it back, a demote twic
2583		2602
2584	core.releaseTerminal(.write);	2603	core.releaseTerminal(.write);
2585	try std.testing.expectEqual(Claim.none, core.claim);	2604	try std.testing.expectEqual(Claim.none, core.claim);
2586	try std.testing.expectEqualStrings(session_release, buf[0..try std.posix.read(p[0], &buf)]);	2605	try std.testing.expectEqualStrings(session_release, drainPipe(p[0], &buf));
2587		2606
2588	// A release with nothing claimed writes nothing. That is what makes	2607	// A release with nothing claimed writes nothing. That is what makes
2589	// `deinit` safe on a tile nobody ever zoomed — and what stops a wall	2608	// `deinit` safe on a tile nobody ever zoomed — and what stops a wall

test/e2e.sh

@@ @@ -332,6 +332,19 @@ D35PID="" @@
+SOCK39="${TMPDIR:-/tmp}/muxd-e2e-zoomdead-$$.sock"
+D36PID=""
+# The wheel inside a zoom (phase 3b). Two daemons for the wheel pair's own
+# reason, turned up one notch: each needs a session whose SHELL is fixed for
+# the session's whole life — one that scrolls and one that ASKS for the
+# mouse — and a mode another scenario's session set would follow the wall's
+# terminal around. Both use the daemon's DEFAULT session, so the wall
+# spelling is a bare `--sock PATH` and nothing has to create anything.
+SOCK41="${TMPDIR:-/tmp}/muxd-e2e-zoomwheel-$$.sock"
+D38PID=""
+ZWHEELSH="${TMPDIR:-/tmp}/mux-e2e-zoomwheel-$$.sh"
+SOCK42="${TMPDIR:-/tmp}/muxd-e2e-zoomappmouse-$$.sock"
+D39PID=""
+ZMOUSESH="${TMPDIR:-/tmp}/mux-e2e-zoomappmouse-$$.sh"
+# The wall as attach HISTORY (phase 2). A daemon AND a state home of its
+# own, for the dynamic-wall leg's reason turned up one notch: what these
+# two blocks read back is the wall FILE, and every `mux` in this suite now
@@ @@ -968,6 +981,8 @@ cleanup() { @@
+    [ -n "$D35PID" ] && kill "$D35PID" 2>/dev/null || true
+    [ -n "$D36PID" ] && kill "$D36PID" 2>/dev/null || true
+    [ -n "$D37PID" ] && kill "$D37PID" 2>/dev/null || true
+    [ -n "$D38PID" ] && kill "$D38PID" 2>/dev/null || true
+    [ -n "$D39PID" ] && kill "$D39PID" 2>/dev/null || true
+    # The stops still precede the socket rm below, like SOCK14-17 above:
+    # unlinking a socket first would leave a live daemon nothing could reach
+    # by path.
@@ @@ -990,6 +1005,8 @@ cleanup() { @@
+    [ -S "$SOCK38" ] && "$MUXD" stop --sock "$SOCK38" 2>/dev/null || true
+    [ -S "$SOCK39" ] && "$MUXD" stop --sock "$SOCK39" 2>/dev/null || true
+    [ -S "$SOCK40" ] && "$MUXD" stop --sock "$SOCK40" 2>/dev/null || true
+    [ -S "$SOCK41" ] && "$MUXD" stop --sock "$SOCK41" 2>/dev/null || true
+    [ -S "$SOCK42" ] && "$MUXD" stop --sock "$SOCK42" 2>/dev/null || true
+    # ---- the leak sweep (hygiene kit, 6a) ----
+    # Here rather than at the bottom of the file, which `set -e` reaches only
@@ @@ -1003,7 +1020,8 @@ cleanup() { @@
+        "$D14PID" "$D15PID" "$D16PID" "$D17PID" "$D18PID" "$D19PID" \
+        "$D20PID" "$D21PID" "$D22PID" "$D23PID" "$D24PID" "$D25PID" \
+        "$D26PID" "$D27PID" "$D28PID" "$D29PID" "$D30PID" "$D31PID" \
+        "$D32PID" "$D33PID" "$D34PID" "$D35PID" "$D36PID" "$D37PID" \
+        "$D38PID" "$D39PID"
+    _leak=0
+    leak_sweep "$_rc" || _leak=1
@@ @@ -1059,6 +1077,10 @@ cleanup() { @@
+    # and the daemon logs beside them.
+    rm -f "$OUT.whl" "$OUT.whl.err" "$OUT.whl.log" "$OUT.whl.d" "$WHEELSH" \
+        "$OUT.mse" "$OUT.mse.err" "$OUT.mse.log" "$OUT.mse.d" "$MOUSESH" \
+        "$SOCK41" "$OUT.zw.d" "$OUT.zwcap" "$OUT.zwcap.err" "$OUT.zwpc" \
+        "$OUT.zwcapg" "$OUT.zwstop" "$ZWHEELSH" \
+        "$SOCK42" "$OUT.zm2.d" "$OUT.zm2cap" "$OUT.zm2cap.err" "$OUT.zm2pc" \
+        "$OUT.zm2capg" "$OUT.zm2stop" "$ZMOUSESH" \
+        "$SOCK33" "$SOCK34" "$OUT.whlcap" "$OUT.msecap" \
+        "$OUT.whlstop" "$OUT.msestop"
+    rm -f "$OUT.pgr" "$OUT.pgr.err" "$OUT.pgr.log" "$OUT.pgr.d" "$LESSSH" \
+D35PID=""
+ok "an unzoomed wall forwards nothing; the zoom one keystroke later does"
+# ---- the wheel inside a zoom, and the mouse handed back on the way out --
+#
+# What phase 3b is FOR. A zoomed tile used to be keyboard-only: the wall
+# hand-rolled a subset of the client's input path, and the wheel — which
+# needs the session's own modes, the tile's scrollback view and the tile's
+# transport all in one place — was not in that subset. Now the tile's input
+# goes through the same `interact.Core` a plain client's does, so the wheel
+# arrives with it.
+#
+# Two claims, one run, because the second is the first read backwards and
+# has to be anchored on it:
+#
+#   * ZOOMED, the wheel scrolls the SESSION's history and never reaches its
+#     pty. Same arithmetic as the plain client's wheel leg (scenario 42) and
+#     deliberately the same pty size, so a difference here is the wall's and
+#     not the geometry's: eight notches in one write are 24 rows, exactly a
+#     screenful on 80x24, and the page that lands holds `wln60` — a line
+#     that is in the history and in nothing painted before it.
+#   * DEMOTED, the wheel reaches nothing at all, and the terminal is left
+#     with no mouse mode enabled. The demote is what pairs with the promote's
+#     claim, and it is the pair that turns over many times per wall where a
+#     client's turns over once per process.
+#
+# The lines are `wln1`..`wln100` rather than bare numbers because this
+# terminal is a WALL: its label bar carries the socket path, which carries
+# this run's pid, and a bare `60` in a pid would make the money assertion
+# pass for a reason that has nothing to do with the wheel.
+#
+# The wall's spelling is a bare `--sock PATH` — the daemon's DEFAULT
+# session, so nothing has to be created and the session's shell is fixed for
+# its whole life.
+cat > "$ZWHEELSH" <<'EOF'
+#!/bin/sh
+seq 1 100 | sed 's/^/wln/'
+exec /bin/cat
+EOF
+chmod +x "$ZWHEELSH"
+"$MUXD" run --sock "$SOCK41" --shell "$ZWHEELSH" > "$OUT.zw.d" 2>&1 &
+D38PID=$!
+wait_sock "$SOCK41" "$OUT.zw.d" "zoom-wheel daemon never bound"
+# The wall attaches only once seq has finished, scenario 42's reason: the
+# page the wheel fetches has to be content this tile was never sent.
+i=0
+until "$MUXD" dump --sock "$SOCK41" | grep -q "wln100"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: zoom wheel: session never finished seq"; exit 1; }
+    sleep 0.1
+done
+set +e
+timeout 90 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.zwcap" --err "$OUT.zwcap.err" -- \
+    "$MUX" wall "--sock $SOCK41" > "$OUT.zwpc" 2>&1 <<'EOF'
+expect wln100 20000
+settle 700 20000
+send \r
+settle 900 20000
+send \x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M
+expect wln60 15000
+send \x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M\x1b[<65;10;5M
+expect wln100 15000
+settle 500 15000
+send zwheelpin\n
+expect zwheelpin 15000
+settle 500 15000
+send \x1cw
+expect wln100 20000
+settle 900 20000
+send \x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5M\x1b[<64;10;5Mwallwheel
+settle 900 20000
+send q
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: zoom wheel: ptyclient leg exited $RC (did the zoomed wheel scroll, and come back?):"
+    cat "$OUT.zwpc"; exit 1; }
+# The anchor first, and it is a POSITIVE: a keystroke typed at the zoom
+# reached this session's pty. Everything silent below is measured against
+# it, so a leg that fell over early can never pass by having done nothing.
+timeout 20 "$MUXA" capture --sock "$SOCK41" > "$OUT.zwcapg" 2>&1
+grep -q "zwheelpin" "$OUT.zwcapg" || {
+    echo "e2e FAIL: zoom wheel: the zoom never typed into the session, so the"
+    echo "          silent halves below prove nothing:"
+    cat "$OUT.zwcapg"; cat "$OUT.zwpc"; exit 1; }
+# Twenty mouse reports were typed at a shell that echoes everything it is
+# given, and the session's grid must hold none: zoomed they were the
+# client's own wheel, demoted they were never forwarded at all.
+grep -qF -- "[<64;" "$OUT.zwcapg" && {
+    echo "e2e FAIL: zoom wheel: a mouse report reached the pty as input:"
+    cat "$OUT.zwcapg"; exit 1; }
+ok "a zoomed tile scrolls its session's history on the wheel, and the pty sees none of it"
+# The demoted half, on the same capture. Every letter of `wallwheel` is one
+# an unzoomed wall swallows — none is a selection key, `q` or `x` — which is
+# the same care scenario 45 spells out: a negative that cannot fail is not a
+# test.
+grep -q "wallwheel" "$OUT.zwcapg" && {
+    echo "e2e FAIL: zoom wheel: the DEMOTED wall forwarded keystrokes to the session:"
+    cat "$OUT.zwcapg"; exit 1; }
+# ...and the terminal was given back its mouse. `?1000l` is written exactly
+# twice on this run — once by the demote and once by the wall's own exit —
+# and the promote writes only `h`s, so a count of one is a demote that left
+# the user's terminal reporting clicks into their shell for the rest of the
+# wall's life. Counted with `grep -o`: these are escape sequences inside a
+# paint, with no newlines to make a line count mean anything.
+_zw_off=$(grep -oa "$(printf '\033')\[?1000l" "$OUT.zwcap" | wc -l)
+[ "$_zw_off" -ge 2 ] || {
+    echo "e2e FAIL: zoom wheel: mouse reporting was turned off $_zw_off time(s);"
+    echo "          the demote must take it off as well as the wall's exit:"
+    cat "$OUT.zwpc"; exit 1; }
+assert_stopped "$SOCK41" "$D38PID" "zoom wheel" "$OUT.zwstop"
+D38PID=""
+ok "a demoted tile forwards nothing and leaves no mouse mode on the wall's terminal"
+# ---- an application in a ZOOMED tile owns the mouse ---------------------
+#
+# Scenario 43 said this about a plain client; this says it about a tile,
+# where it is a stronger claim than it looks. A tile learns the session's
+# modes while it is a STRIPE — `interact.Core` decodes every `term_modes`
+# whatever the tile's claim is, and only the WRITE to the terminal is gated
+# — and the promote is answered by `resyncSnapshot`, which carries no modes
+# at all. So the handover cannot come from a frame: it has to come from what
+# the Core already knew, level-set onto the terminal at the moment of the
+# claim. Measured before that existed: `?1002h` never reached this capture
+# and the wheel was eaten as scrollback.
+#
+# 1002 is what makes the leg sharp. The wall asks its terminal for NO mouse
+# mode, and a promoted tile's own capture set is 1000+1006, so a `?1002h` on
+# this terminal can only be the session's, mirrored.
+cat > "$ZMOUSESH" <<'EOF'
+#!/bin/sh
+seq 1 100 | sed 's/^/mln/'
+printf '\033[?1000h\033[?1002h\033[?1006h'
+printf 'mapp-holds-the-mouse\n'
+exec /bin/cat
+EOF
+chmod +x "$ZMOUSESH"
+"$MUXD" run --sock "$SOCK42" --shell "$ZMOUSESH" > "$OUT.zm2.d" 2>&1 &
+D39PID=$!
+wait_sock "$SOCK42" "$OUT.zm2.d" "zoom-app-mouse daemon never bound"
+i=0
+until "$MUXD" dump --sock "$SOCK42" | grep -q "mapp-holds-the-mouse"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: zoom app mouse: session never armed"; exit 1; }
+    sleep 0.1
+done
+# The echo is the assertion: cat is in canonical mode with ECHOCTL, so bytes
+# that reach the pty come back as `^[[<64;10;5M` and bytes that do not, do
+# not.
+set +e
+timeout 90 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.zm2cap" --err "$OUT.zm2cap.err" -- \
+    "$MUX" wall "--sock $SOCK42" > "$OUT.zm2pc" 2>&1 <<'EOF'
+expect mapp-holds-the-mouse 20000
+settle 700 20000
+send \r
+settle 900 20000
+send \x1b[<64;10;5M
+expect [<64;10;5M 15000
+settle 500 15000
+send \x1cw
+settle 700 20000
+send q
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: zoom app mouse: ptyclient leg exited $RC (did the wheel reach the app?):"
+    cat "$OUT.zm2pc"; exit 1; }
+# The session's own grid, not just this terminal: the echo is the pty saying
+# it received the bytes.
+timeout 20 "$MUXA" capture --sock "$SOCK42" > "$OUT.zm2capg" 2>&1
+grep -qF -- "[<64;10;5M" "$OUT.zm2capg" || {
+    echo "e2e FAIL: zoom app mouse: the wheel never reached the application's pty:"
+    cat "$OUT.zm2capg"; exit 1; }
+# The mirror: this terminal was asked for the SESSION's modes at the
+# promote, not for the tile's own set.
+grep -qaF "$(printf '\033')[?1002h" "$OUT.zm2cap" || {
+    echo "e2e FAIL: zoom app mouse: the promote never mirrored the session's drag mode:"
+    cat "$OUT.zm2pc"; exit 1; }
+# And the negative that makes the pair a pair: this session has the same 77
+# rows of history as the leg above, and the same wheel byte moved none of it.
+grep -qa "mln60" "$OUT.zm2cap" && {
+    echo "e2e FAIL: zoom app mouse: the tile scrolled back on a wheel the app owned:"
+    cat "$OUT.zm2pc"; exit 1; }
+assert_stopped "$SOCK42" "$D39PID" "zoom app mouse" "$OUT.zm2stop"
+D39PID=""
+ok "an application in a zoomed tile gets the wheel, and the tile does not"
+# ---- a tile whose pump has died still says something ---------------------
+# Only pumps answer `repaint_gen`, so a tile whose pump has ENDED has
@@ @@ -6177,8 +6386,8 @@ DPID="" @@
+# convergence point either: what it asserts on is that file shrinking by
+# one line while the session it named goes on answering, which is two
+# facts a grid comparison speaks to neither of.
+[ "$OK_COUNT" = "51" ] || {
+    echo "e2e FAIL: $OK_COUNT scenario checkpoints ran, the pin says 51 —"
+    echo "          a scenario was added (update the pin) or silently lost"
+    exit 1
@@ @@ -6186,4 +6395,4 @@ DPID="" @@
+    echo "e2e FAIL: $CONV_COUNT convergence points ran, the pin says 35"
+    exit 1
+echo "e2e OK (51 scenarios, 35 convergence points)"