5b97e538

test: 08_mouse moves to a file of its own

a73x 2026-08-26 19:06

Commit message

test: 08_mouse moves to a file of its own

the wheel and the mouse, in a terminal and in a tile — 8 scenarios, 667 lines. The legs move unedited; the runner
sources the file where they used to stand.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

test/e2e.sh

Old		New
@@ -102,7 +102,7 @@ done
102	E2E_DIR=$(dirname "$0")	102	E2E_DIR=$(dirname "$0")
103	. "$E2E_DIR/e2e_lib.sh"	103	. "$E2E_DIR/e2e_lib.sh"
104		104
105	E2E_GROUPS='01_boot 02_predict 03_side 04_handoff 05_session 06_web 07_wallcli'	105	E2E_GROUPS='01_boot 02_predict 03_side 04_handoff 05_session 06_web 07_wallcli 08_mouse'
106	# The groups that cannot stand alone, and what they need. E2E_ONLY refuses	106	# The groups that cannot stand alone, and what they need. E2E_ONLY refuses
107	# these by name rather than running them: a group whose fixtures are	107	# these by name rather than running them: a group whose fixtures are
108	# missing does not fail, it passes having tested something else — and a	108	# missing does not fail, it passes having tested something else — and a
@@ -145,670 +145,6 @@ for _g in $E2E_GROUPS; do
145	. "$E2E_DIR/e2e_$_g.sh"	145	. "$E2E_DIR/e2e_$_g.sh"
146	done	146	done
147		147
148	# The wheel pair. Each needs a scrollback of its own to scroll (or to prove
149	# it did not), which the long-lived /bin/sh daemon has no way to hold still,
150	# and the second one needs a session that ASKS for the mouse — a mode that
151	# would follow every other scenario sharing the daemon around.
152	SOCK33="${TMPDIR:-/tmp}/muxd-e2e-wheel-$$.sock"
153	defer_sock "$SOCK33"
154	WHEELSH="${TMPDIR:-/tmp}/mux-e2e-wheel-$$.sh"
155	defer_rm "$WHEELSH"
156	SOCK34="${TMPDIR:-/tmp}/muxd-e2e-appmouse-$$.sock"
157	defer_sock "$SOCK34"
158	MOUSESH="${TMPDIR:-/tmp}/mux-e2e-appmouse-$$.sh"
159	defer_rm "$MOUSESH"
160	# The alternate-screen half of the wheel: its own daemon because the
161	# session under test is a PAGER holding the alt screen for its whole life,
162	# which no other scenario could share a grid with. And the no-terminal
163	# half, whose session is a bare `cat` so that what reaches the pty is
164	# echoed back into the grid the assertion reads.
165	SOCK35="${TMPDIR:-/tmp}/muxd-e2e-pager-$$.sock"
166	defer_sock "$SOCK35"
167	LESSSH="${TMPDIR:-/tmp}/mux-e2e-pager-$$.sh"
168	defer_rm "$LESSSH"
169	LESSDATA="${TMPDIR:-/tmp}/mux-e2e-pager-$$.txt"
170	defer_rm "$LESSDATA"
171	SOCK36="${TMPDIR:-/tmp}/muxd-e2e-pipestdin-$$.sock"
172	defer_sock "$SOCK36"
173	# The focus-skip leg, on a daemon of its own for the grid-size reason: it
174	# asserts on grid sizes and on how many clients a session ever had at once,
175	# and a session another block created — or another block's client sitting
176	# on this daemon — would make both numbers say nothing.
177	SOCK37="${TMPDIR:-/tmp}/muxd-e2e-focusskip-$$.sock"
178	defer_sock "$SOCK37"
179	# The dead tile. Its own daemon because the leg needs a session name that
180	# does NOT exist — the daemon refuses the attach — and any other block's
181	# daemon might have one by that name.
182	SOCK39="${TMPDIR:-/tmp}/muxd-e2e-deadtile-$$.sock"
183	defer_sock "$SOCK39"
184	# The wheel inside the focused tile. Two daemons for the wheel pair's own
185	# reason, turned up one notch: each needs a session whose SHELL is fixed for
186	# the session's whole life — one that scrolls and one that ASKS for the
187	# mouse — and a mode another scenario's session set would follow the wall's
188	# terminal around. Both use the daemon's DEFAULT session, so the wall
189	# spelling is a bare `--sock PATH` and nothing has to create anything.
190	SOCK41="${TMPDIR:-/tmp}/muxd-e2e-wallwheel-$$.sock"
191	defer_sock "$SOCK41"
192	ZWHEELSH="${TMPDIR:-/tmp}/mux-e2e-wallwheel-$$.sh"
193	defer_rm "$ZWHEELSH"
194	SOCK42="${TMPDIR:-/tmp}/muxd-e2e-wallappmouse-$$.sock"
195	defer_sock "$SOCK42"
196	ZMOUSESH="${TMPDIR:-/tmp}/mux-e2e-wallappmouse-$$.sh"
197	defer_rm "$ZMOUSESH"
198
199	# ---- the wheel scrolls back, and an app that asks gets it instead -------
200	#
201	# The pair is one claim seen from both sides, so the two legs are the same
202	# session, the same bytes and opposite outcomes: a wheel report belongs to
203	# the scrollback until an application inside the session asks for the mouse,
204	# and then it belongs to that application.
205	#
206	# The bytes are real ones: `\x1b[<64;10;5M` is what a terminal writes for a
207	# wheel-up press once the client has asked for SGR reports (1006), which is
208	# the point — before this the client asked for nothing, so a terminal
209	# answered the wheel by SYNTHESISING arrow keys on the alternate screen
210	# (DEC 1007) and the session read them as input.
211	#
212	# (a) At the live view, eight notches in ONE write scroll a screenful back.
213	# Eight because a notch is three rows: 8*3 = 24, exactly what
214	# Shift+PageUp moves on this 80x24 terminal, which is what lets this
215	# leg borrow tp1's needle — "60" is in the history page (rows 54..77)
216	# and in nothing painted before it. One write rather than eight because
217	# that is how a terminal writes a spin, and because a burst that is not
218	# SUMMED lands three rows up instead of twenty-four: the needle fails.
219	cat > "$WHEELSH" <<'EOF'
220	#!/bin/sh
221	seq 1 100
222	exec /bin/cat
223	EOF
224	chmod +x "$WHEELSH"
225	start_daemon "$SOCK33" "$OUT.whl.d" "wheel daemon never bound" --shell "$WHEELSH"
226	D30PID=$DPID
227	# Attach only once seq has finished, for tp1's reason: the page the wheel
228	# fetches has to be content this client was never sent.
229	i=0
230	until "$MUXD" dump --sock "$SOCK33" \| grep -q "100"; do
231	i=$((i+1)); [ "$i" -lt 100 ] \|\| { echo "e2e FAIL: wheel session never finished seq"; exit 1; }
232	sleep 0.1
233	done
234	# `\x1b[0m100`, not "100": the client asks its own terminal for mouse
235	# reporting with `\x1b[?1000h`, so a bare "100" is in this capture before
236	# any row is. The SGR reset in front of it is the paint's, and nothing else
237	# writes that pair. (Measured: with the plain needle this leg passes on the
238	# mode enable and sends the wheel before the snapshot has landed.)
239	set +e
240	timeout 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.whl" --err "$OUT.whl.err" \
241	-- "$MUX" --sock "$SOCK33" > "$OUT.whl.log" 2>&1 <<'EOF'
242	expect \x1b[0m100 15000
243	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
244	expect 60 15000
245	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
246	expect \x1b[0m100 15000
247	send \x1b[<64;10;5Mwheel-and-key
248	settle 600 15000
249	send \x1cd
250	waitexit 10000
251	EOF
252	RC=$?
253	set -e
254	[ "$RC" -eq 0 ] \|\| {
255	echo "e2e FAIL: wheel: ptyclient leg exited $RC (did the wheel scroll, and come back?):"
256	cat "$OUT.whl.log"; exit 1; }
257	# The other half of "the wheel is the client's": the bytes are CONSUMED.
258	# Seventeen mouse reports were typed at a shell that would have echoed every
259	# one of them, and the session's grid must hold none.
260	timeout 20 "$MUXA" capture --sock "$SOCK33" > "$OUT.whlcap" 2>&1
261	grep -qF -- "[<64;" "$OUT.whlcap" && {
262	echo "e2e FAIL: wheel: a mouse report reached the pty as input:"
263	cat "$OUT.whlcap"; exit 1; }
264	# ...but a keystroke that shared its read with a notch is NOT consumed. The
265	# last send was one write holding both, typed at the live view: the wheel
266	# moved the view and the letters belong to the shell. Swallowing them as
267	# "the key that leaves scroll mode" loses input to a view the user had not
268	# seen yet, which is what this needle catches.
269	grep -qF -- "wheel-and-key" "$OUT.whlcap" \|\| {
270	echo "e2e FAIL: wheel: a keystroke sharing a read with a notch never reached the pty:"
271	cat "$OUT.whlcap"; exit 1; }
272	assert_stopped "$SOCK33" "$D30PID" "wheel" "$OUT.whlstop"
273	D30PID=""
274	ok "the wheel scrolls back and returns to live, and never reaches the pty"
275
276	# (b) The same session with an application holding the mouse. The script
277	# asks for tracking (1000), drag (1002) and SGR reports (1006) — vim's
278	# `set mouse=a` set — before becoming cat, so every wheel byte is the
279	# application's and the client must hand them over untouched.
280	#
281	# 1003 is the mode that makes this leg sharp, and it is 1003 rather
282	# than 1002 because the client's own capture set is 1000+1002+1006 —
283	# a `?1002h` here would be written whether the session asked or not,
284	# and asserting on it would be asserting nothing. 1003 (report motion
285	# with no button down) is a mode the client never wants for itself, so
286	# a `?1003h` on this terminal can only be the session's, mirrored. The
287	# script asks for it on top of vim's `set mouse=a` set.
288	cat > "$MOUSESH" <<'EOF'
289	#!/bin/sh
290	seq 1 100
291	printf '\033[?1000h\033[?1002h\033[?1003h\033[?1006h'
292	printf 'app-holds-the-mouse\n'
293	exec /bin/cat
294	EOF
295	chmod +x "$MOUSESH"
296	start_daemon "$SOCK34" "$OUT.mse.d" "app-mouse daemon never bound" --shell "$MOUSESH"
297	D31PID=$DPID
298	i=0
299	until "$MUXD" dump --sock "$SOCK34" \| grep -q "app-holds-the-mouse"; do
300	i=$((i+1)); [ "$i" -lt 100 ] \|\| { echo "e2e FAIL: app-mouse session never armed"; exit 1; }
301	sleep 0.1
302	done
303	# The modes are already set when this client attaches, so they arrive in
304	# the attach's own term_modes and there is no race to settle for. The echo
305	# is the assertion: cat is in canonical mode with ECHOCTL, so bytes that
306	# reach the pty come back as `^[[<64;10;5M` and bytes that do not, do not.
307	set +e
308	timeout 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.mse" --err "$OUT.mse.err" \
309	-- "$MUX" --sock "$SOCK34" > "$OUT.mse.log" 2>&1 <<'EOF'
310	expect app-holds-the-mouse 15000
311	send \x1b[<64;10;5M
312	expect [<64;10;5M 15000
313	send \x1cd
314	waitexit 10000
315	EOF
316	RC=$?
317	set -e
318	[ "$RC" -eq 0 ] \|\| {
319	echo "e2e FAIL: app mouse: ptyclient leg exited $RC (did the wheel reach the app?):"
320	cat "$OUT.mse.log"; exit 1; }
321	# The session's own grid, not just the client's screen: the echo is the pty
322	# saying it received the bytes.
323	timeout 20 "$MUXA" capture --sock "$SOCK34" > "$OUT.msecap" 2>&1
324	grep -qF -- "[<64;10;5M" "$OUT.msecap" \|\| {
325	echo "e2e FAIL: app mouse: the wheel never reached the application's pty:"
326	cat "$OUT.msecap"; exit 1; }
327	# The mirror: this terminal was asked for the session's modes, not the
328	# client's own set — and 1003 is outside that set, so this cannot pass on
329	# the client's own behalf.
330	grep -qaF "$(printf '\033[?1003h')" "$OUT.mse" \|\| {
331	echo "e2e FAIL: app mouse: the client never mirrored the session's any-motion mode"; exit 1; }
332	# And the negative that makes the pair a pair: this session has the same
333	# 77 rows of history as (a), and the same wheel byte moved none of it.
334	grep -qF -- "60" "$OUT.mse" && {
335	echo "e2e FAIL: app mouse: the client scrolled back on a wheel the app owned"; exit 1; }
336	assert_stopped "$SOCK34" "$D31PID" "app mouse" "$OUT.msestop"
337	D31PID=""
338	ok "an application that asked for the mouse gets the wheel, and the client does not"
339
340	# ---- the wheel on the alternate screen: a pager, not our scrollback ----
341	#
342	# The alt screen has no scrollback of ours — `historyRows` is 0 there by
343	# contract — so a notch that fell through to the scroll arithmetic was
344	# consumed by the mouse filter and then dropped. Measured on this very
345	# scenario before the fix: four notches, grid unmoved.
346	#
347	# `less +G` on 200 lines: the view starts at the END, so a wheel-UP is the
348	# direction with somewhere to go. Eight notches is 24 rows, one screenful,
349	# which moves the top from 178 to 154 — and 178 leaves the screen entirely,
350	# so the assertion has both a needle and its negative.
351	#
352	# LESS is cleared in the script rather than trusted: an operator with
353	# `LESS=--mouse` exported would have a pager that DOES ask for the mouse,
354	# which is the other leg's story, and this one would fail for a reason that
355	# has nothing to do with the code.
356	seq 1 200 > "$LESSDATA"
357	cat > "$LESSSH" <<EOF
358	#!/bin/sh
359	LESS=
360	export LESS
361	exec less +G $LESSDATA
362	EOF
363	chmod +x "$LESSSH"
364	start_daemon "$SOCK35" "$OUT.pgr.d" "pager daemon never bound" --shell "$LESSSH"
365	D32PID=$DPID
366	i=0
367	until "$MUXD" dump --sock "$SOCK35" \| grep -qx "200"; do
368	i=$((i+1)); [ "$i" -lt 100 ] \|\| {
369	echo "e2e FAIL: pager never reached the end of the file:"
370	"$MUXD" dump --sock "$SOCK35" \| tail -3; exit 1; }
371	sleep 0.1
372	done
373	set +e
374	timeout 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.pgr" --err "$OUT.pgr.err" \
375	-- "$MUX" --sock "$SOCK35" > "$OUT.pgr.log" 2>&1 <<'EOF'
376	expect 199 15000
377	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
378	settle 800 15000
379	send \x1cd
380	waitexit 10000
381	EOF
382	RC=$?
383	set -e
384	[ "$RC" -eq 0 ] \|\| {
385	echo "e2e FAIL: pager: ptyclient leg exited $RC:"; cat "$OUT.pgr.log"; exit 1; }
386	# `muxd dump`, not `muxa capture`: the assertions below are WHOLE-LINE ones
387	# and capture answers in JSON, where the grid is one line with escaped
388	# newlines in it — a `grep -x` against that can never match. (It did not,
389	# on the first run of this leg, while the grid underneath was exactly
390	# right.) dump prints the grid a row per line, which is what -x needs.
391	"$MUXD" dump --sock "$SOCK35" > "$OUT.pgrcap" 2>&1
392	# A whole line, because the pager's status line carries the file's PATH —
393	# which holds this run's pid and could spell any short number.
394	grep -qx "154" "$OUT.pgrcap" \|\| {
395	echo "e2e FAIL: pager: the wheel moved nothing on the alternate screen:"
396	cat "$OUT.pgrcap"; exit 1; }
397	grep -qx "178" "$OUT.pgrcap" && {
398	echo "e2e FAIL: pager: the old top row is still on screen, so the view did not move a screenful:"
399	cat "$OUT.pgrcap"; exit 1; }
400	# The pager never asked for the mouse, so it must never have SEEN a mouse
401	# report: what reached it was arrow keys, which leave no text behind.
402	grep -qF -- "[<64;" "$OUT.pgrcap" && {
403	echo "e2e FAIL: pager: a raw mouse report reached an application that never asked for one:"
404	cat "$OUT.pgrcap"; exit 1; }
405	assert_stopped "$SOCK35" "$D32PID" "pager" "$OUT.pgrstop"
406	D32PID=""
407	ok "the wheel scrolls a pager on the alternate screen, as arrow keys"
408
409	# ---- a client with no terminal filters nothing --------------------------
410	#
411	# The mouse filter is gated on this client having TAKEN a terminal over,
412	# and that gate has to be the alt-screen flag rather than the mode bits:
413	# a client whose stdin is a pipe never asked anyone for mouse reports, so
414	# nothing it reads can be one. Filtering there is pure loss — the bytes are
415	# whatever a script piped in, and an SGR-shaped escape in a heredoc is text
416	# somebody meant to send.
417	#
418	# `cat` as the session, so what arrives is echoed back and the grid IS the
419	# assertion: the bytes reached the pty or they did not.
420	start_daemon "$SOCK36" "$OUT.pipe.d" "pipe-stdin daemon never bound" --shell /bin/cat
421	D33PID=$DPID
422	# The detach chord is a SEPARATE write behind a sleep, and both halves of
423	# that are load-bearing. Without it the client stays attached after stdin
424	# ends — a pipe closing is not a session ending — and the leg would prove
425	# its point by timing out. And it cannot ride the same write as the
426	# payload: a chord ENDS its chunk (PrefixFilter), so bytes ahead of it in
427	# the same read are dropped, which would race the assertion away.
428	{ printf 'hello \033[<64;10;5M world\n'; sleep 1; printf '\034d'; } \|
429	timeout 20 "$MUX" --sock "$SOCK36" > "$OUT.pipe" 2>&1
430	RC=$?
431	[ "$RC" -eq 0 ] \|\| {
432	echo "e2e FAIL: pipe stdin: the client exited $RC:"; cat "$OUT.pipe"; exit 1; }
433	i=0
434	until timeout 20 "$MUXA" capture --sock "$SOCK36" 2>&1 \| grep -qF -- "world"; do
435	i=$((i+1)); [ "$i" -lt 100 ] \|\| {
436	echo "e2e FAIL: pipe stdin: the piped line never reached the pty:"
437	timeout 20 "$MUXA" capture --sock "$SOCK36"; exit 1; }
438	sleep 0.1
439	done
440	timeout 20 "$MUXA" capture --sock "$SOCK36" > "$OUT.pipecap" 2>&1
441	# The whole line, escape included. `cat` echoes control bytes as `^[`, so
442	# what a grid can show of `\x1b[<64;10;5M` is `[<64;10;5M` — and a client
443	# that ate the report leaves `hello world` with the middle missing.
444	grep -qF -- "[<64;10;5M" "$OUT.pipecap" \|\| {
445	echo "e2e FAIL: pipe stdin: an SGR-shaped escape was filtered out of a stream nobody was reporting on:"
446	cat "$OUT.pipecap"; exit 1; }
447	assert_stopped "$SOCK36" "$D33PID" "pipe stdin" "$OUT.pipestop"
448	D33PID=""
449	ok "a client with no terminal of its own forwards SGR-shaped bytes untouched"
450
451	# ---- focus skips between tiles, and the daemon never notices -----------
452	#
453	# Every tile's replica is hot whether or not it is the focus, so moving
454	# the focus between two tiles is a local repaint. No re-dial, no attach,
455	# no snapshot round trip — a claim about what did NOT happen, witnessed
456	# daemon-side rather than by a stopwatch.
457	#
458	# One ptyclient leg, two sessions' worth of typing on two tiles:
459	#
460	# type mark a with zs-one (a is focused from the first byte)
461	# Ctrl-\ n move the focus to tile 2 (session b)
462	# type mark b with zs-two
463	# Ctrl-\ 1 focus tile 1 (session a)
464	# type mark a again with zs-three
465	# Ctrl-\ d leave
466	#
467	# Two claims:
468	#
469	# * every marker landed in the session the focus was on, and in no
470	# other. zs-one and zs-three in a, zs-two in b, and each absent from
471	# the other session — the negatives are what prove the focus MOVED
472	# rather than the wall typing on at one connection.
473	# * the daemon accepted exactly TWO attaches for the whole run — one per
474	# tile, at wall startup. A `Ctrl-\ n` that re-dialled would be three or
475	# more, and the cumulative counter says so however briefly the extra
476	# connection lived. Focus is client-local and sends nothing on the wire.
477	start_daemon "$SOCK37" "$OUT.zs.d" "focus-skip daemon never bound" --shell /bin/sh
478	D34PID=$DPID
479
480	# Both sessions exist before the wall does, each with a marker so the wall
481	# has something to paint and this leg has an anchor to enter on.
482	pipe_mux "$OUT.zsa" "$OUT.zsa.err" timeout 40 "$MUX" --sock "$SOCK37" --session a
483	pipe_send 'printf "zsa-%%s\\n" pin\n'
484	await_out "$OUT.zsa" "zsa-pin" "zsa-pin never reached the client"
485	pipe_detach
486	wait_grid "$SOCK37" "zsa-pin" "focus skip: session a's marker" a
487	pipe_mux "$OUT.zsb" "$OUT.zsb.err" timeout 40 "$MUX" --sock "$SOCK37" --session b
488	pipe_send 'printf "zsb-%%s\\n" pin\n'
489	await_out "$OUT.zsb" "zsb-pin" "zsb-pin never reached the client"
490	pipe_detach
491	wait_grid "$SOCK37" "zsb-pin" "focus skip: session b's marker" b
492
493	ZSATT_BEFORE=$(attaches_now "$SOCK37")
494	watch_clients "$SOCK37" "$OUT.zswatch"
495	set +e
496	# tall: the aspect rule would cut columns at 92x30 (92 >= 60)
497	timeout 90 "$PTYCLIENT" --cols 40 --rows 30 --out "$OUT.zscap" --err "$OUT.zscap.err" -- \
498	"$MUX" wall "--sock $SOCK37#a" "--sock $SOCK37#b" > "$OUT.zspc" 2>&1 <<'EOF'
499	expect zsb-pin 20000
500	settle 700 20000
501	send printf 'zs-%s\\n' one\n
502	expect zs-one 15000
503	settle 400 15000
504	send \x1cn
505	settle 700 20000
506	send printf 'zs-%s\\n' two\n
507	expect zs-two 15000
508	settle 400 15000
509	send \x1c1
510	settle 700 20000
511	send printf 'zs-%s\\n' three\n
512	expect zs-three 15000
513	settle 400 15000
514	send \x1cd
515	waitexit 10000
516	EOF
517	RC=$?
518	set -e
519	unwatch_clients "$OUT.zswatch"
520	ZSATT_AFTER=$(attaches_now "$SOCK37")
521	[ "$RC" -eq 0 ] \|\| {
522	echo "e2e FAIL: focus skip: ptyclient leg exited $RC (did \\x1cn and \\x1c1 move the focus?):"
523	cat "$OUT.zspc"; exit 1; }
524	# Where each marker landed. `muxa capture` reads the session's own grid, so
525	# none of this can be an echo of what this script typed at a terminal.
526	timeout 20 "$MUXA" capture --sock "$SOCK37" --session a > "$OUT.zsfa" 2>&1
527	timeout 20 "$MUXA" capture --sock "$SOCK37" --session b > "$OUT.zsfb" 2>&1
528	#
529	# The markers are numbered rather than named after their sessions, and
530	# deliberately so: `zs-b` and `zs-back` were the first spelling, and `zs-b`
531	# matched inside `zs-back` — a negative grep that could never fail, in the
532	# leg whose whole content is negative greps. Numbered words share no
533	# prefix, which is the property this needs.
534	for _m in zs-one zs-three; do
535	grep -q "$_m" "$OUT.zsfa" \|\| {
536	echo "e2e FAIL: focus skip: session a never got $_m:"
537	cat "$OUT.zsfa"; exit 1; }
538	grep -q "$_m" "$OUT.zsfb" && {
539	echo "e2e FAIL: focus skip: $_m reached session b, which the focus had left:"
540	cat "$OUT.zsfb"; exit 1; }
541	done
542	grep -q "zs-two" "$OUT.zsfb" \|\| {
543	echo "e2e FAIL: focus skip: Ctrl-\\ n did not put the focus on session b:"
544	cat "$OUT.zsfb"; exit 1; }
545	grep -q "zs-two" "$OUT.zsfa" && {
546	echo "e2e FAIL: focus skip: zs-two reached session a, so the focus never moved:"
547	cat "$OUT.zsfa"; exit 1; }
548	# The whole point, said by the daemon: two tiles, two attaches, and never a
549	# third across a focus move each way. This is the leg the counter matters
550	# most in — the two moves it makes are exactly the ones a gauge could not
551	# tell from a re-dial, since a connection that closes as another opens
552	# never shows two at once.
553	assert_attach_delta "$ZSATT_BEFORE" "$ZSATT_AFTER" 2 "focus skip"
554	assert_never_two_clients "$OUT.zswatch" a "focus skip"
555	assert_never_two_clients "$OUT.zswatch" b "focus skip"
556	# Both tiles claimed their rect: 40 cols each (this leg's own width) and 14
557	# rows each (30 terminal rows cut into two stripes of 15, minus one label
558	# bar each). A focus move resizes nothing.
559	for _s in a b; do
560	timeout 20 "$MUXA" status --sock "$SOCK37" --session "$_s" > "$OUT.zsst$_s" 2>&1
561	grep -q '"cols":40' "$OUT.zsst$_s" \|\| {
562	echo "e2e FAIL: focus skip: session $_s is not at the width its tile claimed:"
563	cat "$OUT.zsst$_s"; exit 1; }
564	grep -q '"rows":14' "$OUT.zsst$_s" \|\| {
565	echo "e2e FAIL: focus skip: session $_s is not at the height its tile claimed:"
566	cat "$OUT.zsst$_s"; exit 1; }
567	done
568	assert_stopped "$SOCK37" "$D34PID" "focus skip" "$OUT.zsstop"
569	D34PID=""
570	ok "focus skips between tiles with Ctrl-\\ n / Ctrl-\\ l, and the daemon sees no new attach"
571
572	# ---- the wheel inside the focused tile ---------------------------------
573	#
574	# A tile's input goes through the same `interact.Core` a plain client's
575	# does, so the wheel arrives with it: the focused tile scrolls its
576	# session's history on the wheel and never reaches its pty. Same arithmetic
577	# as the plain client's wheel leg (scenario 42) and deliberately the same
578	# pty size, so a difference here is the wall's and not the geometry's:
579	# eight notches in one write are 24 rows, exactly a screenful on 80x24, and
580	# the page that lands holds `wln60` — a line that is in the history and in
581	# nothing painted before it.
582	#
583	# The lines are `wln1`..`wln100` rather than bare numbers because this
584	# terminal is a WALL: its label bar carries the socket path, which carries
585	# this run's pid, and a bare `60` in a pid would make the money assertion
586	# pass for a reason that has nothing to do with the wheel.
587	#
588	# The wall's spelling is a bare `--sock PATH` — the daemon's DEFAULT
589	# session, so nothing has to be created and the session's shell is fixed for
590	# its whole life. One tile, so no label bar: the geometry is the plain
591	# client's.
592	cat > "$ZWHEELSH" <<'EOF'
593	#!/bin/sh
594	seq 1 100 \| sed 's/^/wln/'
595	exec /bin/cat
596	EOF
597	chmod +x "$ZWHEELSH"
598	start_daemon "$SOCK41" "$OUT.zw.d" "wheel daemon never bound" --shell "$ZWHEELSH"
599	D38PID=$DPID
600	# The wall attaches only once seq has finished, scenario 42's reason: the
601	# page the wheel fetches has to be content this tile was never sent.
602	i=0
603	until "$MUXD" dump --sock "$SOCK41" \| grep -q "wln100"; do
604	i=$((i+1)); [ "$i" -lt 100 ] \|\| { echo "e2e FAIL: wheel: session never finished seq"; exit 1; }
605	sleep 0.1
606	done
607	set +e
608	timeout 90 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.zwcap" --err "$OUT.zwcap.err" -- \
609	"$MUX" wall "--sock $SOCK41" > "$OUT.zwpc" 2>&1 <<'EOF'
610	expect wln100 20000
611	settle 700 20000
612	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
613	expect wln60 15000
614	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
615	expect wln100 15000
616	settle 500 15000
617	send zwheelpin\n
618	expect zwheelpin 15000
619	settle 500 15000
620	send \x1cd
621	waitexit 10000
622	EOF
623	RC=$?
624	set -e
625	[ "$RC" -eq 0 ] \|\| {
626	echo "e2e FAIL: wheel: ptyclient leg exited $RC (did the focused wheel scroll?):"
627	cat "$OUT.zwpc"; exit 1; }
628	# The anchor first, and it is a POSITIVE: a keystroke typed at the focused
629	# tile reached this session's pty. The silent half below is measured against
630	# it, so a leg that fell over early can never pass by having done nothing.
631	timeout 20 "$MUXA" capture --sock "$SOCK41" > "$OUT.zwcapg" 2>&1
632	grep -q "zwheelpin" "$OUT.zwcapg" \|\| {
633	echo "e2e FAIL: wheel: the focus never typed into the session, so the"
634	echo " silent half below proves nothing:"
635	cat "$OUT.zwcapg"; cat "$OUT.zwpc"; exit 1; }
636	# The wheel reports were typed at a shell that echoes everything it is
637	# given, and the session's grid must hold none: the wheel is the client's
638	# own, never forwarded to the pty.
639	grep -qF -- "[<64;" "$OUT.zwcapg" && {
640	echo "e2e FAIL: wheel: a mouse report reached the pty as input:"
641	cat "$OUT.zwcapg"; exit 1; }
642	assert_stopped "$SOCK41" "$D38PID" "wheel" "$OUT.zwstop"
643	D38PID=""
644	ok "the focused tile scrolls its session's history on the wheel, and the pty sees none of it"
645
646	# ---- an application in the focused tile owns the mouse -----------------
647	#
648	# Scenario 43 said this about a plain client; this says it about a tile.
649	# A tile learns the session's modes while it is a STRIPE — `interact.Core`
650	# decodes every `term_modes` whatever the tile's claim is, and only the
651	# WRITE to the terminal is gated — so the handover cannot come from a frame:
652	# it has to come from what the Core already knew, level-set onto the
653	# terminal at the moment of the claim.
654	#
655	# 1003 is what makes the leg sharp, and it has to be 1003: the wall claims
656	# 1000+1002+1006 for itself and a focused tile claims the same set, so
657	# either of those would appear on this terminal with no session involved.
658	# 1003 is in nobody's own set, so a `?1003h` here can only be the session's,
659	# mirrored.
660	cat > "$ZMOUSESH" <<'EOF'
661	#!/bin/sh
662	seq 1 100 \| sed 's/^/mln/'
663	printf '\033[?1000h\033[?1002h\033[?1003h\033[?1006h'
664	printf 'mapp-holds-the-mouse\n'
665	exec /bin/cat
666	EOF
667	chmod +x "$ZMOUSESH"
668	start_daemon "$SOCK42" "$OUT.zm2.d" "app-mouse daemon never bound" --shell "$ZMOUSESH"
669	D39PID=$DPID
670	i=0
671	until "$MUXD" dump --sock "$SOCK42" \| grep -q "mapp-holds-the-mouse"; do
672	i=$((i+1)); [ "$i" -lt 100 ] \|\| { echo "e2e FAIL: app mouse: session never armed"; exit 1; }
673	sleep 0.1
674	done
675	# The echo is the assertion: cat is in canonical mode with ECHOCTL, so bytes
676	# that reach the pty come back as `^[[<64;10;5M` and bytes that do not, do
677	# not. The tile claims the terminal on its first pass, so the modes are
678	# level-set before the wheel is sent.
679	set +e
680	timeout 90 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.zm2cap" --err "$OUT.zm2cap.err" -- \
681	"$MUX" wall "--sock $SOCK42" > "$OUT.zm2pc" 2>&1 <<'EOF'
682	expect mapp-holds-the-mouse 20000
683	settle 700 20000
684	send \x1b[<64;10;5M
685	expect [<64;10;5M 15000
686	settle 500 15000
687	send \x1cd
688	waitexit 10000
689	EOF
690	RC=$?
691	set -e
692	[ "$RC" -eq 0 ] \|\| {
693	echo "e2e FAIL: app mouse: ptyclient leg exited $RC (did the wheel reach the app?):"
694	cat "$OUT.zm2pc"; exit 1; }
695	# The session's own grid, not just this terminal: the echo is the pty saying
696	# it received the bytes.
697	timeout 20 "$MUXA" capture --sock "$SOCK42" > "$OUT.zm2capg" 2>&1
698	grep -qF -- "[<64;10;5M" "$OUT.zm2capg" \|\| {
699	echo "e2e FAIL: app mouse: the wheel never reached the application's pty:"
700	cat "$OUT.zm2capg"; exit 1; }
701	# The mirror: this terminal was asked for the SESSION's modes at the claim,
702	# not for the tile's own set — and 1003 is outside that set.
703	grep -qaF "$(printf '\033')[?1003h" "$OUT.zm2cap" \|\| {
704	echo "e2e FAIL: app mouse: the claim never mirrored the session's any-motion mode:"
705	cat "$OUT.zm2pc"; exit 1; }
706	# And the negative that makes the pair a pair: this session has the same 77
707	# rows of history as the leg above, and the same wheel byte moved none of it.
708	grep -qa "mln60" "$OUT.zm2cap" && {
709	echo "e2e FAIL: app mouse: the tile scrolled back on a wheel the app owned:"
710	cat "$OUT.zm2pc"; exit 1; }
711	assert_stopped "$SOCK42" "$D39PID" "app mouse" "$OUT.zm2stop"
712	D39PID=""
713	ok "an application in the focused tile gets the wheel, and the tile does not"
714
715	# ---- a tile whose pump has died still says something -------------------
716	#
717	# A dead tile keeps its rect and narrates on its label bar — the only
718	# paint a pump with nobody left to answer `repaint_gen` ever does. The
719	# keyboard is the only thread left, and it draws that bar so the wall
720	# never silently loses a row.
721	#
722	# The tile here is dead by the most ordinary route: a spelling naming a
723	# session that does not exist. The daemon refuses the attach and that pump
724	# ends — `[refused]`, the state the wall already had a word for. Its bar
725	# says so from the first paint, and the live tile beside it is unharmed:
726	# the wall is still a wall, and the focus stays on the tile that can be
727	# typed at.
728	#
729	# Deliberately NOT asserted: that a `[reconnecting]` tile gets the same
730	# treatment. It must not — it still has a thread that will repaint its hot
731	# replica within a poll timeout, and the keyboard drawing over that would
732	# replace something true with something stale.
733	start_daemon "$SOCK39" "$OUT.zd.d" "dead-tile daemon never bound" --shell /bin/sh
734	D36PID=$DPID
735	pipe_mux "$OUT.zda" "$OUT.zda.err" timeout 40 "$MUX" --sock "$SOCK39" --session a
736	pipe_send 'printf "zdlive-%%s\\n" pin\n'
737	await_out "$OUT.zda" "zdlive-pin" "zdlive-pin never reached the client"
738	pipe_detach
739	wait_grid "$SOCK39" "zdlive-pin" "dead tile: the live session's marker" a
740
741	set +e
742	# tall: two tiles at 90x24 trip the aspect rule (90 >= 48); 70x36 stays
743	# stacked (70 < 72) and fits the bar label the assertion greps for
744	timeout 90 "$PTYCLIENT" --cols 70 --rows 36 --out "$OUT.zdcap" --err "$OUT.zdcap.err" -- \
745	"$MUX" wall "--sock $SOCK39#a" "--sock $SOCK39#ghost" > "$OUT.zdpc" 2>&1 <<'EOF'
746	expect zdlive-pin 20000
747	settle 800 20000
748	send printf 'zdagain-%s\\n' pin\n
749	expect zdagain-pin 15000
750	settle 400 15000
751	send \x1c2
752	settle 400 15000
753	send \x1c:abc
754	settle 400 15000
755	send \x1b
756	settle 400 15000
757	send \x1c:zz#bad name
758	settle 400 15000
759	send \r
760	expect [bad target 10000
761	settle 600 15000
762	send \x1c1
763	settle 400 15000
764	send \x1cd
765	waitexit 10000
766	EOF
767	RC=$?
768	set -e
769	[ "$RC" -eq 0 ] \|\| {
770	echo "e2e FAIL: dead tile: ptyclient leg exited $RC:"
771	cat "$OUT.zdpc"; exit 1; }
772	# The dead tile narrated its own refusal: the state word the bar can only
773	# have if the pump reached the refusal path. Painted from the first
774	# Painted from the first relayout, and never cleared.
775	grep -q -- "--sock $SOCK39#ghost \[refused\]" "$OUT.zdcap" \|\| {
776	echo "e2e FAIL: dead tile: the dead tile's bar never said [refused]"; exit 1; }
777	# The live tile is unharmed and answering — the wall is still a wall.
778	grep -q -- "--sock $SOCK39#a \[up\]" "$OUT.zdcap" \|\| {
779	echo "e2e FAIL: dead tile: the live tile's bar never said [up]"; exit 1; }
780	# The focus stayed on the live tile: the marker typed after the wall came
781	# up landed in a, which is the tile that can be typed at. A focus that
782	# landed on the dead one would have dropped these bytes.
783	timeout 20 "$MUXA" capture --sock "$SOCK39" --session a > "$OUT.zdcapa" 2>&1
784	grep -q "zdagain-pin" "$OUT.zdcapa" \|\| {
785	echo "e2e FAIL: dead tile: the live session never got the focused marker:"
786	cat "$OUT.zdcapa"; exit 1; }
787	# `Ctrl-\ :` is the one chord that works with the focus on a dead tile —
788	# the splits go through the pump's `ask`, and a dead pump answers nothing —
789	# so it is the one chord that can leave a line on a row nothing repaints.
790	# The oracle, not the byte stream: a banner LEFT on the screen is in the
791	# capture either way, and only the render says what the human was still
792	# looking at.
793	"$RENDER" --cols 70 --rows 36 < "$OUT.zdcap" > "$OUT.zdgrid" \|\| {
794	echo "e2e FAIL: dead tile: render oracle failed"
795	cat "$OUT.zdgrid"; exit 1; }
796	# The refusal reached the eyes that earned it. Nothing claims a dead tile,
797	# so a notice only the claim path can show would never have been seen.
798	grep -q "\[bad target" "$OUT.zdgrid" \|\| {
799	echo "e2e FAIL: dead tile: a refused prompt never narrated on the dead tile:"
800	cat "$OUT.zdgrid"; exit 1; }
801	grep -q ": zz#bad" "$OUT.zdgrid" && {
802	echo "e2e FAIL: dead tile: the refused prompt is still on the dead tile's row:"
803	cat "$OUT.zdgrid"; exit 1; }
804	# And Esc leaves nothing behind either: same row, same missing claim.
805	grep -q ": abc" "$OUT.zdgrid" && {
806	echo "e2e FAIL: dead tile: the cancelled prompt is still on the dead tile's row:"
807	cat "$OUT.zdgrid"; exit 1; }
808	assert_stopped "$SOCK39" "$D36PID" "dead tile" "$OUT.zdstop"
809	D36PID=""
810	ok "a tile whose pump has died narrates on its bar and on its prompt, and the focus stays on the live one"
811
812	# The wall as attach HISTORY (phase 2). A daemon AND a state home of its	148	# The wall as attach HISTORY (phase 2). A daemon AND a state home of its
813	# own, for the dynamic-wall leg's reason turned up one notch: what these	149	# own, for the dynamic-wall leg's reason turned up one notch: what these
814	# two blocks read back is the wall FILE, and every `mux` in this suite now	150	# two blocks read back is the wall FILE, and every `mux` in this suite now

test/e2e_08_mouse.sh

@@ @@ -0,0 +1,667 @@ @@
+# shellcheck shell=sh
+# e2e_08_mouse.sh — sourced by test/e2e.sh after e2e_lib.sh. Scenarios run in
+# the order they stand in; see the lib's header for what this file may
+# assume and what it must register.
+# The wheel pair. Each needs a scrollback of its own to scroll (or to prove
+# it did not), which the long-lived /bin/sh daemon has no way to hold still,
+# and the second one needs a session that ASKS for the mouse — a mode that
+# would follow every other scenario sharing the daemon around.
+SOCK33="${TMPDIR:-/tmp}/muxd-e2e-wheel-$$.sock"
+defer_sock "$SOCK33"
+WHEELSH="${TMPDIR:-/tmp}/mux-e2e-wheel-$$.sh"
+defer_rm "$WHEELSH"
+SOCK34="${TMPDIR:-/tmp}/muxd-e2e-appmouse-$$.sock"
+defer_sock "$SOCK34"
+MOUSESH="${TMPDIR:-/tmp}/mux-e2e-appmouse-$$.sh"
+defer_rm "$MOUSESH"
+# The alternate-screen half of the wheel: its own daemon because the
+# session under test is a PAGER holding the alt screen for its whole life,
+# which no other scenario could share a grid with. And the no-terminal
+# half, whose session is a bare `cat` so that what reaches the pty is
+# echoed back into the grid the assertion reads.
+SOCK35="${TMPDIR:-/tmp}/muxd-e2e-pager-$$.sock"
+defer_sock "$SOCK35"
+LESSSH="${TMPDIR:-/tmp}/mux-e2e-pager-$$.sh"
+defer_rm "$LESSSH"
+LESSDATA="${TMPDIR:-/tmp}/mux-e2e-pager-$$.txt"
+defer_rm "$LESSDATA"
+SOCK36="${TMPDIR:-/tmp}/muxd-e2e-pipestdin-$$.sock"
+defer_sock "$SOCK36"
+# The focus-skip leg, on a daemon of its own for the grid-size reason: it
+# asserts on grid sizes and on how many clients a session ever had at once,
+# and a session another block created — or another block's client sitting
+# on this daemon — would make both numbers say nothing.
+SOCK37="${TMPDIR:-/tmp}/muxd-e2e-focusskip-$$.sock"
+defer_sock "$SOCK37"
+# The dead tile. Its own daemon because the leg needs a session name that
+# does NOT exist — the daemon refuses the attach — and any other block's
+# daemon might have one by that name.
+SOCK39="${TMPDIR:-/tmp}/muxd-e2e-deadtile-$$.sock"
+defer_sock "$SOCK39"
+# The wheel inside the focused tile. 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-wallwheel-$$.sock"
+defer_sock "$SOCK41"
+ZWHEELSH="${TMPDIR:-/tmp}/mux-e2e-wallwheel-$$.sh"
+defer_rm "$ZWHEELSH"
+SOCK42="${TMPDIR:-/tmp}/muxd-e2e-wallappmouse-$$.sock"
+defer_sock "$SOCK42"
+ZMOUSESH="${TMPDIR:-/tmp}/mux-e2e-wallappmouse-$$.sh"
+defer_rm "$ZMOUSESH"
+# ---- the wheel scrolls back, and an app that asks gets it instead -------
+#
+# The pair is one claim seen from both sides, so the two legs are the same
+# session, the same bytes and opposite outcomes: a wheel report belongs to
+# the scrollback until an application inside the session asks for the mouse,
+# and then it belongs to that application.
+#
+# The bytes are real ones: `\x1b[<64;10;5M` is what a terminal writes for a
+# wheel-up press once the client has asked for SGR reports (1006), which is
+# the point — before this the client asked for nothing, so a terminal
+# answered the wheel by SYNTHESISING arrow keys on the alternate screen
+# (DEC 1007) and the session read them as input.
+#
+# (a) At the live view, eight notches in ONE write scroll a screenful back.
+#     Eight because a notch is three rows: 8*3 = 24, exactly what
+#     Shift+PageUp moves on this 80x24 terminal, which is what lets this
+#     leg borrow tp1's needle — "60" is in the history page (rows 54..77)
+#     and in nothing painted before it. One write rather than eight because
+#     that is how a terminal writes a spin, and because a burst that is not
+#     SUMMED lands three rows up instead of twenty-four: the needle fails.
+cat > "$WHEELSH" <<'EOF'
+#!/bin/sh
+seq 1 100
+exec /bin/cat
+EOF
+chmod +x "$WHEELSH"
+start_daemon "$SOCK33" "$OUT.whl.d" "wheel daemon never bound" --shell "$WHEELSH"
+D30PID=$DPID
+# Attach only once seq has finished, for tp1's reason: the page the wheel
+# fetches has to be content this client was never sent.
+i=0
+until "$MUXD" dump --sock "$SOCK33" | grep -q "100"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: wheel session never finished seq"; exit 1; }
+    sleep 0.1
+done
+# `\x1b[0m100`, not "100": the client asks its own terminal for mouse
+# reporting with `\x1b[?1000h`, so a bare "100" is in this capture before
+# any row is. The SGR reset in front of it is the paint's, and nothing else
+# writes that pair. (Measured: with the plain needle this leg passes on the
+# mode enable and sends the wheel before the snapshot has landed.)
+set +e
+timeout 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.whl" --err "$OUT.whl.err" \
+    -- "$MUX" --sock "$SOCK33" > "$OUT.whl.log" 2>&1 <<'EOF'
+expect \x1b[0m100 15000
+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 60 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 \x1b[0m100 15000
+send \x1b[<64;10;5Mwheel-and-key
+settle 600 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: wheel: ptyclient leg exited $RC (did the wheel scroll, and come back?):"
+    cat "$OUT.whl.log"; exit 1; }
+# The other half of "the wheel is the client's": the bytes are CONSUMED.
+# Seventeen mouse reports were typed at a shell that would have echoed every
+# one of them, and the session's grid must hold none.
+timeout 20 "$MUXA" capture --sock "$SOCK33" > "$OUT.whlcap" 2>&1
+grep -qF -- "[<64;" "$OUT.whlcap" && {
+    echo "e2e FAIL: wheel: a mouse report reached the pty as input:"
+    cat "$OUT.whlcap"; exit 1; }
+# ...but a keystroke that shared its read with a notch is NOT consumed. The
+# last send was one write holding both, typed at the live view: the wheel
+# moved the view and the letters belong to the shell. Swallowing them as
+# "the key that leaves scroll mode" loses input to a view the user had not
+# seen yet, which is what this needle catches.
+grep -qF -- "wheel-and-key" "$OUT.whlcap" || {
+    echo "e2e FAIL: wheel: a keystroke sharing a read with a notch never reached the pty:"
+    cat "$OUT.whlcap"; exit 1; }
+assert_stopped "$SOCK33" "$D30PID" "wheel" "$OUT.whlstop"
+D30PID=""
+ok "the wheel scrolls back and returns to live, and never reaches the pty"
+# (b) The same session with an application holding the mouse. The script
+#     asks for tracking (1000), drag (1002) and SGR reports (1006) — vim's
+#     `set mouse=a` set — before becoming cat, so every wheel byte is the
+#     application's and the client must hand them over untouched.
+#
+#     1003 is the mode that makes this leg sharp, and it is 1003 rather
+#     than 1002 because the client's own capture set is 1000+1002+1006 —
+#     a `?1002h` here would be written whether the session asked or not,
+#     and asserting on it would be asserting nothing. 1003 (report motion
+#     with no button down) is a mode the client never wants for itself, so
+#     a `?1003h` on this terminal can only be the session's, mirrored. The
+#     script asks for it on top of vim's `set mouse=a` set.
+cat > "$MOUSESH" <<'EOF'
+#!/bin/sh
+seq 1 100
+printf '\033[?1000h\033[?1002h\033[?1003h\033[?1006h'
+printf 'app-holds-the-mouse\n'
+exec /bin/cat
+EOF
+chmod +x "$MOUSESH"
+start_daemon "$SOCK34" "$OUT.mse.d" "app-mouse daemon never bound" --shell "$MOUSESH"
+D31PID=$DPID
+i=0
+until "$MUXD" dump --sock "$SOCK34" | grep -q "app-holds-the-mouse"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: app-mouse session never armed"; exit 1; }
+    sleep 0.1
+done
+# The modes are already set when this client attaches, so they arrive in
+# the attach's own term_modes and there is no race to settle for. 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 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.mse" --err "$OUT.mse.err" \
+    -- "$MUX" --sock "$SOCK34" > "$OUT.mse.log" 2>&1 <<'EOF'
+expect app-holds-the-mouse 15000
+send \x1b[<64;10;5M
+expect [<64;10;5M 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: app mouse: ptyclient leg exited $RC (did the wheel reach the app?):"
+    cat "$OUT.mse.log"; exit 1; }
+# The session's own grid, not just the client's screen: the echo is the pty
+# saying it received the bytes.
+timeout 20 "$MUXA" capture --sock "$SOCK34" > "$OUT.msecap" 2>&1
+grep -qF -- "[<64;10;5M" "$OUT.msecap" || {
+    echo "e2e FAIL: app mouse: the wheel never reached the application's pty:"
+    cat "$OUT.msecap"; exit 1; }
+# The mirror: this terminal was asked for the session's modes, not the
+# client's own set — and 1003 is outside that set, so this cannot pass on
+# the client's own behalf.
+grep -qaF "$(printf '\033[?1003h')" "$OUT.mse" || {
+    echo "e2e FAIL: app mouse: the client never mirrored the session's any-motion mode"; exit 1; }
+# And the negative that makes the pair a pair: this session has the same
+# 77 rows of history as (a), and the same wheel byte moved none of it.
+grep -qF -- "60" "$OUT.mse" && {
+    echo "e2e FAIL: app mouse: the client scrolled back on a wheel the app owned"; exit 1; }
+assert_stopped "$SOCK34" "$D31PID" "app mouse" "$OUT.msestop"
+D31PID=""
+ok "an application that asked for the mouse gets the wheel, and the client does not"
+# ---- the wheel on the alternate screen: a pager, not our scrollback ----
+#
+# The alt screen has no scrollback of ours — `historyRows` is 0 there by
+# contract — so a notch that fell through to the scroll arithmetic was
+# consumed by the mouse filter and then dropped. Measured on this very
+# scenario before the fix: four notches, grid unmoved.
+#
+# `less +G` on 200 lines: the view starts at the END, so a wheel-UP is the
+# direction with somewhere to go. Eight notches is 24 rows, one screenful,
+# which moves the top from 178 to 154 — and 178 leaves the screen entirely,
+# so the assertion has both a needle and its negative.
+#
+# LESS is cleared in the script rather than trusted: an operator with
+# `LESS=--mouse` exported would have a pager that DOES ask for the mouse,
+# which is the other leg's story, and this one would fail for a reason that
+# has nothing to do with the code.
+seq 1 200 > "$LESSDATA"
+cat > "$LESSSH" <<EOF
+#!/bin/sh
+LESS=
+export LESS
+exec less +G $LESSDATA
+EOF
+chmod +x "$LESSSH"
+start_daemon "$SOCK35" "$OUT.pgr.d" "pager daemon never bound" --shell "$LESSSH"
+D32PID=$DPID
+i=0
+until "$MUXD" dump --sock "$SOCK35" | grep -qx "200"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || {
+        echo "e2e FAIL: pager never reached the end of the file:"
+        "$MUXD" dump --sock "$SOCK35" | tail -3; exit 1; }
+    sleep 0.1
+done
+set +e
+timeout 40 "$PTYCLIENT" --cols 80 --rows 24 --out "$OUT.pgr" --err "$OUT.pgr.err" \
+    -- "$MUX" --sock "$SOCK35" > "$OUT.pgr.log" 2>&1 <<'EOF'
+expect 199 15000
+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
+settle 800 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: pager: ptyclient leg exited $RC:"; cat "$OUT.pgr.log"; exit 1; }
+# `muxd dump`, not `muxa capture`: the assertions below are WHOLE-LINE ones
+# and capture answers in JSON, where the grid is one line with escaped
+# newlines in it — a `grep -x` against that can never match. (It did not,
+# on the first run of this leg, while the grid underneath was exactly
+# right.) dump prints the grid a row per line, which is what -x needs.
+"$MUXD" dump --sock "$SOCK35" > "$OUT.pgrcap" 2>&1
+# A whole line, because the pager's status line carries the file's PATH —
+# which holds this run's pid and could spell any short number.
+grep -qx "154" "$OUT.pgrcap" || {
+    echo "e2e FAIL: pager: the wheel moved nothing on the alternate screen:"
+    cat "$OUT.pgrcap"; exit 1; }
+grep -qx "178" "$OUT.pgrcap" && {
+    echo "e2e FAIL: pager: the old top row is still on screen, so the view did not move a screenful:"
+    cat "$OUT.pgrcap"; exit 1; }
+# The pager never asked for the mouse, so it must never have SEEN a mouse
+# report: what reached it was arrow keys, which leave no text behind.
+grep -qF -- "[<64;" "$OUT.pgrcap" && {
+    echo "e2e FAIL: pager: a raw mouse report reached an application that never asked for one:"
+    cat "$OUT.pgrcap"; exit 1; }
+assert_stopped "$SOCK35" "$D32PID" "pager" "$OUT.pgrstop"
+D32PID=""
+ok "the wheel scrolls a pager on the alternate screen, as arrow keys"
+# ---- a client with no terminal filters nothing --------------------------
+#
+# The mouse filter is gated on this client having TAKEN a terminal over,
+# and that gate has to be the alt-screen flag rather than the mode bits:
+# a client whose stdin is a pipe never asked anyone for mouse reports, so
+# nothing it reads can be one. Filtering there is pure loss — the bytes are
+# whatever a script piped in, and an SGR-shaped escape in a heredoc is text
+# somebody meant to send.
+#
+# `cat` as the session, so what arrives is echoed back and the grid IS the
+# assertion: the bytes reached the pty or they did not.
+start_daemon "$SOCK36" "$OUT.pipe.d" "pipe-stdin daemon never bound" --shell /bin/cat
+D33PID=$DPID
+# The detach chord is a SEPARATE write behind a sleep, and both halves of
+# that are load-bearing. Without it the client stays attached after stdin
+# ends — a pipe closing is not a session ending — and the leg would prove
+# its point by timing out. And it cannot ride the same write as the
+# payload: a chord ENDS its chunk (PrefixFilter), so bytes ahead of it in
+# the same read are dropped, which would race the assertion away.
+{ printf 'hello \033[<64;10;5M world\n'; sleep 1; printf '\034d'; } |
+    timeout 20 "$MUX" --sock "$SOCK36" > "$OUT.pipe" 2>&1
+RC=$?
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: pipe stdin: the client exited $RC:"; cat "$OUT.pipe"; exit 1; }
+i=0
+until timeout 20 "$MUXA" capture --sock "$SOCK36" 2>&1 | grep -qF -- "world"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || {
+        echo "e2e FAIL: pipe stdin: the piped line never reached the pty:"
+        timeout 20 "$MUXA" capture --sock "$SOCK36"; exit 1; }
+    sleep 0.1
+done
+timeout 20 "$MUXA" capture --sock "$SOCK36" > "$OUT.pipecap" 2>&1
+# The whole line, escape included. `cat` echoes control bytes as `^[`, so
+# what a grid can show of `\x1b[<64;10;5M` is `[<64;10;5M` — and a client
+# that ate the report leaves `hello  world` with the middle missing.
+grep -qF -- "[<64;10;5M" "$OUT.pipecap" || {
+    echo "e2e FAIL: pipe stdin: an SGR-shaped escape was filtered out of a stream nobody was reporting on:"
+    cat "$OUT.pipecap"; exit 1; }
+assert_stopped "$SOCK36" "$D33PID" "pipe stdin" "$OUT.pipestop"
+D33PID=""
+ok "a client with no terminal of its own forwards SGR-shaped bytes untouched"
+# ---- focus skips between tiles, and the daemon never notices -----------
+#
+# Every tile's replica is hot whether or not it is the focus, so moving
+# the focus between two tiles is a local repaint. No re-dial, no attach,
+# no snapshot round trip — a claim about what did NOT happen, witnessed
+# daemon-side rather than by a stopwatch.
+#
+# One ptyclient leg, two sessions' worth of typing on two tiles:
+#
+#   type         mark a with zs-one (a is focused from the first byte)
+#   Ctrl-\ n     move the focus to tile 2 (session b)
+#   type         mark b with zs-two
+#   Ctrl-\ 1     focus tile 1 (session a)
+#   type         mark a again with zs-three
+#   Ctrl-\ d     leave
+#
+# Two claims:
+#
+#   * every marker landed in the session the focus was on, and in no
+#     other. zs-one and zs-three in a, zs-two in b, and each absent from
+#     the other session — the negatives are what prove the focus MOVED
+#     rather than the wall typing on at one connection.
+#   * the daemon accepted exactly TWO attaches for the whole run — one per
+#     tile, at wall startup. A `Ctrl-\ n` that re-dialled would be three or
+#     more, and the cumulative counter says so however briefly the extra
+#     connection lived. Focus is client-local and sends nothing on the wire.
+start_daemon "$SOCK37" "$OUT.zs.d" "focus-skip daemon never bound" --shell /bin/sh
+D34PID=$DPID
+# Both sessions exist before the wall does, each with a marker so the wall
+# has something to paint and this leg has an anchor to enter on.
+pipe_mux "$OUT.zsa" "$OUT.zsa.err" timeout 40 "$MUX" --sock "$SOCK37" --session a
+pipe_send 'printf "zsa-%%s\\n" pin\n'
+await_out "$OUT.zsa" "zsa-pin" "zsa-pin never reached the client"
+pipe_detach
+wait_grid "$SOCK37" "zsa-pin" "focus skip: session a's marker" a
+pipe_mux "$OUT.zsb" "$OUT.zsb.err" timeout 40 "$MUX" --sock "$SOCK37" --session b
+pipe_send 'printf "zsb-%%s\\n" pin\n'
+await_out "$OUT.zsb" "zsb-pin" "zsb-pin never reached the client"
+pipe_detach
+wait_grid "$SOCK37" "zsb-pin" "focus skip: session b's marker" b
+ZSATT_BEFORE=$(attaches_now "$SOCK37")
+watch_clients "$SOCK37" "$OUT.zswatch"
+set +e
+# tall: the aspect rule would cut columns at 92x30 (92 >= 60)
+timeout 90 "$PTYCLIENT" --cols 40 --rows 30 --out "$OUT.zscap" --err "$OUT.zscap.err" -- \
+    "$MUX" wall "--sock $SOCK37#a" "--sock $SOCK37#b" > "$OUT.zspc" 2>&1 <<'EOF'
+expect zsb-pin 20000
+settle 700 20000
+send printf 'zs-%s\\n' one\n
+expect zs-one 15000
+settle 400 15000
+send \x1cn
+settle 700 20000
+send printf 'zs-%s\\n' two\n
+expect zs-two 15000
+settle 400 15000
+send \x1c1
+settle 700 20000
+send printf 'zs-%s\\n' three\n
+expect zs-three 15000
+settle 400 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+unwatch_clients "$OUT.zswatch"
+ZSATT_AFTER=$(attaches_now "$SOCK37")
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: focus skip: ptyclient leg exited $RC (did \\x1cn and \\x1c1 move the focus?):"
+    cat "$OUT.zspc"; exit 1; }
+# Where each marker landed. `muxa capture` reads the session's own grid, so
+# none of this can be an echo of what this script typed at a terminal.
+timeout 20 "$MUXA" capture --sock "$SOCK37" --session a > "$OUT.zsfa" 2>&1
+timeout 20 "$MUXA" capture --sock "$SOCK37" --session b > "$OUT.zsfb" 2>&1
+#
+# The markers are numbered rather than named after their sessions, and
+# deliberately so: `zs-b` and `zs-back` were the first spelling, and `zs-b`
+# matched inside `zs-back` — a negative grep that could never fail, in the
+# leg whose whole content is negative greps. Numbered words share no
+# prefix, which is the property this needs.
+for _m in zs-one zs-three; do
+    grep -q "$_m" "$OUT.zsfa" || {
+        echo "e2e FAIL: focus skip: session a never got $_m:"
+        cat "$OUT.zsfa"; exit 1; }
+    grep -q "$_m" "$OUT.zsfb" && {
+        echo "e2e FAIL: focus skip: $_m reached session b, which the focus had left:"
+        cat "$OUT.zsfb"; exit 1; }
+done
+grep -q "zs-two" "$OUT.zsfb" || {
+    echo "e2e FAIL: focus skip: Ctrl-\\ n did not put the focus on session b:"
+    cat "$OUT.zsfb"; exit 1; }
+grep -q "zs-two" "$OUT.zsfa" && {
+    echo "e2e FAIL: focus skip: zs-two reached session a, so the focus never moved:"
+    cat "$OUT.zsfa"; exit 1; }
+# The whole point, said by the daemon: two tiles, two attaches, and never a
+# third across a focus move each way. This is the leg the counter matters
+# most in — the two moves it makes are exactly the ones a gauge could not
+# tell from a re-dial, since a connection that closes as another opens
+# never shows two at once.
+assert_attach_delta "$ZSATT_BEFORE" "$ZSATT_AFTER" 2 "focus skip"
+assert_never_two_clients "$OUT.zswatch" a "focus skip"
+assert_never_two_clients "$OUT.zswatch" b "focus skip"
+# Both tiles claimed their rect: 40 cols each (this leg's own width) and 14
+# rows each (30 terminal rows cut into two stripes of 15, minus one label
+# bar each). A focus move resizes nothing.
+for _s in a b; do
+    timeout 20 "$MUXA" status --sock "$SOCK37" --session "$_s" > "$OUT.zsst$_s" 2>&1
+    grep -q '"cols":40' "$OUT.zsst$_s" || {
+        echo "e2e FAIL: focus skip: session $_s is not at the width its tile claimed:"
+        cat "$OUT.zsst$_s"; exit 1; }
+    grep -q '"rows":14' "$OUT.zsst$_s" || {
+        echo "e2e FAIL: focus skip: session $_s is not at the height its tile claimed:"
+        cat "$OUT.zsst$_s"; exit 1; }
+done
+assert_stopped "$SOCK37" "$D34PID" "focus skip" "$OUT.zsstop"
+D34PID=""
+ok "focus skips between tiles with Ctrl-\\ n / Ctrl-\\ l, and the daemon sees no new attach"
+# ---- the wheel inside the focused tile ---------------------------------
+#
+# A tile's input goes through the same `interact.Core` a plain client's
+# does, so the wheel arrives with it: the focused tile scrolls its
+# session's history on the wheel 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.
+#
+# 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. One tile, so no label bar: the geometry is the plain
+# client's.
+cat > "$ZWHEELSH" <<'EOF'
+#!/bin/sh
+seq 1 100 | sed 's/^/wln/'
+exec /bin/cat
+EOF
+chmod +x "$ZWHEELSH"
+start_daemon "$SOCK41" "$OUT.zw.d" "wheel daemon never bound" --shell "$ZWHEELSH"
+D38PID=$DPID
+# 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: 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 \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 \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: wheel: ptyclient leg exited $RC (did the focused wheel scroll?):"
+    cat "$OUT.zwpc"; exit 1; }
+# The anchor first, and it is a POSITIVE: a keystroke typed at the focused
+# tile reached this session's pty. The silent half 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: wheel: the focus never typed into the session, so the"
+    echo "          silent half below proves nothing:"
+    cat "$OUT.zwcapg"; cat "$OUT.zwpc"; exit 1; }
+# The wheel reports were typed at a shell that echoes everything it is
+# given, and the session's grid must hold none: the wheel is the client's
+# own, never forwarded to the pty.
+grep -qF -- "[<64;" "$OUT.zwcapg" && {
+    echo "e2e FAIL: wheel: a mouse report reached the pty as input:"
+    cat "$OUT.zwcapg"; exit 1; }
+assert_stopped "$SOCK41" "$D38PID" "wheel" "$OUT.zwstop"
+D38PID=""
+ok "the focused tile scrolls its session's history on the wheel, and the pty sees none of it"
+# ---- an application in the focused tile owns the mouse -----------------
+#
+# Scenario 43 said this about a plain client; this says it about a tile.
+# 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 — 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.
+#
+# 1003 is what makes the leg sharp, and it has to be 1003: the wall claims
+# 1000+1002+1006 for itself and a focused tile claims the same set, so
+# either of those would appear on this terminal with no session involved.
+# 1003 is in nobody's own set, so a `?1003h` here can only be the session's,
+# mirrored.
+cat > "$ZMOUSESH" <<'EOF'
+#!/bin/sh
+seq 1 100 | sed 's/^/mln/'
+printf '\033[?1000h\033[?1002h\033[?1003h\033[?1006h'
+printf 'mapp-holds-the-mouse\n'
+exec /bin/cat
+EOF
+chmod +x "$ZMOUSESH"
+start_daemon "$SOCK42" "$OUT.zm2.d" "app-mouse daemon never bound" --shell "$ZMOUSESH"
+D39PID=$DPID
+i=0
+until "$MUXD" dump --sock "$SOCK42" | grep -q "mapp-holds-the-mouse"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: 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. The tile claims the terminal on its first pass, so the modes are
+# level-set before the wheel is sent.
+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 \x1b[<64;10;5M
+expect [<64;10;5M 15000
+settle 500 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: 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: 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 claim,
+# not for the tile's own set — and 1003 is outside that set.
+grep -qaF "$(printf '\033')[?1003h" "$OUT.zm2cap" || {
+    echo "e2e FAIL: app mouse: the claim never mirrored the session's any-motion 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: app mouse: the tile scrolled back on a wheel the app owned:"
+    cat "$OUT.zm2pc"; exit 1; }
+assert_stopped "$SOCK42" "$D39PID" "app mouse" "$OUT.zm2stop"
+D39PID=""
+ok "an application in the focused tile gets the wheel, and the tile does not"
+# ---- a tile whose pump has died still says something -------------------
+#
+# A dead tile keeps its rect and narrates on its label bar — the only
+# paint a pump with nobody left to answer `repaint_gen` ever does. The
+# keyboard is the only thread left, and it draws that bar so the wall
+# never silently loses a row.
+#
+# The tile here is dead by the most ordinary route: a spelling naming a
+# session that does not exist. The daemon refuses the attach and that pump
+# ends — `[refused]`, the state the wall already had a word for. Its bar
+# says so from the first paint, and the live tile beside it is unharmed:
+# the wall is still a wall, and the focus stays on the tile that can be
+# typed at.
+#
+# Deliberately NOT asserted: that a `[reconnecting]` tile gets the same
+# treatment. It must not — it still has a thread that will repaint its hot
+# replica within a poll timeout, and the keyboard drawing over that would
+# replace something true with something stale.
+start_daemon "$SOCK39" "$OUT.zd.d" "dead-tile daemon never bound" --shell /bin/sh
+D36PID=$DPID
+pipe_mux "$OUT.zda" "$OUT.zda.err" timeout 40 "$MUX" --sock "$SOCK39" --session a
+pipe_send 'printf "zdlive-%%s\\n" pin\n'
+await_out "$OUT.zda" "zdlive-pin" "zdlive-pin never reached the client"
+pipe_detach
+wait_grid "$SOCK39" "zdlive-pin" "dead tile: the live session's marker" a
+set +e
+# tall: two tiles at 90x24 trip the aspect rule (90 >= 48); 70x36 stays
+# stacked (70 < 72) and fits the bar label the assertion greps for
+timeout 90 "$PTYCLIENT" --cols 70 --rows 36 --out "$OUT.zdcap" --err "$OUT.zdcap.err" -- \
+    "$MUX" wall "--sock $SOCK39#a" "--sock $SOCK39#ghost" > "$OUT.zdpc" 2>&1 <<'EOF'
+expect zdlive-pin 20000
+settle 800 20000
+send printf 'zdagain-%s\\n' pin\n
+expect zdagain-pin 15000
+settle 400 15000
+send \x1c2
+settle 400 15000
+send \x1c:abc
+settle 400 15000
+send \x1b
+settle 400 15000
+send \x1c:zz#bad name
+settle 400 15000
+send \r
+expect [bad target 10000
+settle 600 15000
+send \x1c1
+settle 400 15000
+send \x1cd
+waitexit 10000
+EOF
+RC=$?
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: dead tile: ptyclient leg exited $RC:"
+    cat "$OUT.zdpc"; exit 1; }
+# The dead tile narrated its own refusal: the state word the bar can only
+# have if the pump reached the refusal path. Painted from the first
+# Painted from the first relayout, and never cleared.
+grep -q -- "--sock $SOCK39#ghost \[refused\]" "$OUT.zdcap" || {
+    echo "e2e FAIL: dead tile: the dead tile's bar never said [refused]"; exit 1; }
+# The live tile is unharmed and answering — the wall is still a wall.
+grep -q -- "--sock $SOCK39#a \[up\]" "$OUT.zdcap" || {
+    echo "e2e FAIL: dead tile: the live tile's bar never said [up]"; exit 1; }
+# The focus stayed on the live tile: the marker typed after the wall came
+# up landed in a, which is the tile that can be typed at. A focus that
+# landed on the dead one would have dropped these bytes.
+timeout 20 "$MUXA" capture --sock "$SOCK39" --session a > "$OUT.zdcapa" 2>&1
+grep -q "zdagain-pin" "$OUT.zdcapa" || {
+    echo "e2e FAIL: dead tile: the live session never got the focused marker:"
+    cat "$OUT.zdcapa"; exit 1; }
+# `Ctrl-\ :` is the one chord that works with the focus on a dead tile —
+# the splits go through the pump's `ask`, and a dead pump answers nothing —
+# so it is the one chord that can leave a line on a row nothing repaints.
+# The oracle, not the byte stream: a banner LEFT on the screen is in the
+# capture either way, and only the render says what the human was still
+# looking at.
+"$RENDER" --cols 70 --rows 36 < "$OUT.zdcap" > "$OUT.zdgrid" || {
+    echo "e2e FAIL: dead tile: render oracle failed"
+    cat "$OUT.zdgrid"; exit 1; }
+# The refusal reached the eyes that earned it. Nothing claims a dead tile,
+# so a notice only the claim path can show would never have been seen.
+grep -q "\[bad target" "$OUT.zdgrid" || {
+    echo "e2e FAIL: dead tile: a refused prompt never narrated on the dead tile:"
+    cat "$OUT.zdgrid"; exit 1; }
+grep -q ": zz#bad" "$OUT.zdgrid" && {
+    echo "e2e FAIL: dead tile: the refused prompt is still on the dead tile's row:"
+    cat "$OUT.zdgrid"; exit 1; }
+# And Esc leaves nothing behind either: same row, same missing claim.
+grep -q ": abc" "$OUT.zdgrid" && {
+    echo "e2e FAIL: dead tile: the cancelled prompt is still on the dead tile's row:"
+    cat "$OUT.zdgrid"; exit 1; }
+assert_stopped "$SOCK39" "$D36PID" "dead tile" "$OUT.zdstop"
+D36PID=""
+ok "a tile whose pump has died narrates on its bar and on its prompt, and the focus stays on the live one"