583b36c0

test: tp1 — reconnect while scrolled restores the view and prediction

a73x 2026-08-10 12:29

Commit message

test: tp1 — reconnect while scrolled restores the view and prediction

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

test/e2e.sh

@@ @@ -68,6 +68,13 @@ GPID="" @@
+# wrapper, so neither can share the long-lived /bin/sh daemon.
+SOCK12="${TMPDIR:-/tmp}/muxd-e2e-tp2-$$.sock"
+D12PID=""
+SOCK13="${TMPDIR:-/tmp}/muxd-e2e-tp1-$$.sock"
+D13PID=""
+# tp1's session: a wrapper that fills the scrollback and then becomes cat.
+TP1SH="${TMPDIR:-/tmp}/mux-e2e-tp1-$$.sh"
+# tp1 runs its fixture in the BACKGROUND — the tear has to happen while the
+# script is mid-flight — so its pid is tracked and killed like a daemon's.
+TP1PID=""
+# One counter out of a MUX_PREDICT_STATS line. The client prints exactly one
+# such line on exit; every field is a key=value pair, so a rename or reorder
@@ @@ -237,6 +244,12 @@ cleanup() { @@
+    [ -n "$D9PID" ] && kill "$D9PID" 2>/dev/null || true
+    [ -n "$D10PID" ] && kill "$D10PID" 2>/dev/null || true
+    [ -n "$D12PID" ] && kill "$D12PID" 2>/dev/null || true
+    [ -n "$D13PID" ] && kill "$D13PID" 2>/dev/null || true
+    # The fixture, by the pid the suite holds. Killing it closes the pty
+    # master, and that SIGHUPs the client on the slave — the same guarantee
+    # a real terminal gives, which is why the fixture never reaps its own
+    # child and this trap does not chase one.
+    [ -n "$TP1PID" ] && kill "$TP1PID" 2>/dev/null || true
+    # Detached daemons: killed by the pid their own up-line reported.
+    [ -n "$SPID" ] && kill "$SPID" 2>/dev/null || true
+    [ -n "$TPID" ] && kill "$TPID" 2>/dev/null || true
@@ @@ -266,6 +279,14 @@ cleanup() { @@
+    rm -f "$SOCK12" "$OUT.tp2.d" \
+        "$OUT.tp2a" "$OUT.tp2a.err" "$OUT.tp2a.log" \
+        "$OUT.tp2b" "$OUT.tp2b.err" "$OUT.tp2b.log"
+    # tp1, including the doctored copy and the convergence residue its
+    # cannot-fail control leaves behind BY DESIGN: that check passes when
+    # converged_quiet fails, and a failing converged_quiet keeps its files.
+    rm -f "$SOCK13" "$TP1SH" "$OUT.tp1.d" \
+        "$OUT.tp1" "$OUT.tp1.err" "$OUT.tp1.log" \
+        "$OUT.tp1.doc" "$OUT.tp1.doc.render" "$OUT.tp1.doc.dump" \
+        "$OUT.tp1.doc.render.n" "$OUT.tp1.doc.dump.n" "$OUT.tp1.doc.diff" \
+        "$OUT.tp1.doc.rvt" "$OUT.tp1.doc.dvt"
+    # The convergence files a FAILING assert_converged leaves behind
+    # (.render/.dump/.rvt/.dvt/.diff for that capture) are deliberately not
+    # chased here: on a failing run they are the evidence.
+rm -f "$OUT.tp2a" "$OUT.tp2a.err" "$OUT.tp2a.log" \
+      "$OUT.tp2b" "$OUT.tp2b.err" "$OUT.tp2b.log" "$OUT.tp2.d"
+# Closed here like every other per-scenario daemon, not left to the trap:
+# tp1 runs below and would otherwise share the box with a daemon nobody is
+# watching, holding a session whose shell is still alive.
+kill "$D12PID" 2>/dev/null || true
+D12PID=""
+ok "a pty client resizes: snapshot prefix applied, winch follows the tty"
+# ---- M12 tp1: reconnect while scrolled (row 18 + the 412f38f pin) ------
+# The session fills its scrollback BY ITSELF and then execs cat: no
+# pre-tear typing means no pre-tear predictions, so the predict counters at
+# exit belong entirely to the one post-resync keystroke — which is what
+# lets them isolate the 412f38f fix. cat leaves the pty canonical and
+# echoing, the `.always` tier, so a real keystroke predicts.
+cat > "$TP1SH" <<'EOF'
+#!/bin/sh
+seq 1 100
+exec /bin/cat
+EOF
+chmod +x "$TP1SH"
+"$MUXD" run --sock "$SOCK13" --shell "$TP1SH" > "$OUT.tp1.d" 2>&1 &
+D13PID=$!
+i=0
+while [ ! -S "$SOCK13" ] && [ "$i" -lt 50 ]; do sleep 0.1; i=$((i+1)); done
+[ -S "$SOCK13" ] || { echo "e2e FAIL: tp1 daemon never bound"; cat "$OUT.tp1.d"; exit 1; }
+# Attach only after seq finished: the client must be served a snapshot of
+# the TAIL, so the scrollback page it fetches later is content it has never
+# been sent. Observed at 80x24: the attach snapshot carries rows 78..100 and
+# the session goes quiet there (cat prints no prompt), history_rows is 77,
+# and page 1 is rows 54..77. Every needle below is chosen against those
+# numbers, which is why this wait is part of the scenario and not a nicety.
+i=0
+until "$MUXD" dump --sock "$SOCK13" | grep -q "100"; do
+    i=$((i+1)); [ "$i" -lt 100 ] || { echo "e2e FAIL: tp1 session never finished seq"; exit 1; }
+    sleep 0.1
+done
+# MUX_PREDICT_STATS is exported into the FIXTURE's environment, not spelled
+# as a `VAR=x cmd` prefix on the client: the fixture execve()s its child
+# with an absolute path and no PATH search (src/pty.zig), so `env` would
+# have to be an absolute path too, and the child inherits this environment
+# anyway. Getting that wrong costs a client that exits 127 before the first
+# verb, which the fixture reports as "closed the pty before ... matched".
+#
+# EXACTLY ONE keystroke, and that is the load-bearing choice in this script.
+# offerKeystroke refuses any stdin chunk that is not one byte — an escape
+# sequence, a multi-byte character, or a paste — and counts it suppressed.
+# Consecutive `send`s have no barrier between them, so the client's next
+# read can pick up two of them at once and predict neither: measured at
+# idle, a three-keystroke version of this leg scored made=3 on one run and
+# made=2/suppressed=1 on the next. Under load all three could coalesce,
+# which would read as made=0 — the mutation's own signature. One send
+# cannot coalesce with anything, so the counters below are exact.
+set +e
+MUX_PREDICT_STATS=1 timeout 60 "$PTYCLIENT" --cols 80 --rows 24 \
+    --out "$OUT.tp1" --err "$OUT.tp1.err" -- \
+    "$MUX" --via "$MUXD proxy --sock $SOCK13" > "$OUT.tp1.log" 2>&1 <<'EOF' &
+expect 100 10000
+send \x1b[5;2~
+expect 60 10000
+expect reconnecting 20000
+expect 100 20000
+send t
+expect \x1b[2K\x1b[0mt 20000
+settle 500 15000
+send \x1c
+waitexit 15000
+EOF
+TP1PID=$!
+set -e
+# The tear goes between verb 3 (the scroll view is on screen) and verb 4;
+# the fixture's "done 3" line is the barrier. Every needle above is unique
+# to its phase, which is what makes each expect sound under the no-counting
+# rule:
+#   the first "100" is the attach snapshot's last row;
+#   "60" is in the history page (54..77) and in NOTHING before it — the
+#   snapshot's rows are 78..100 and the client's own paints address rows
+#   and column 1 only, so no cursor escape can spell it;
+#   "reconnecting" is the banner, painted once, on the tear;
+#   the SECOND "100" can only be the post-resync repaint: the scroll view
+#   holds 54..77, and the banner carries no digits but its own position;
+#   the last needle is STRUCTURAL, and it has to be. In canonical mode the
+#   only thing a single keystroke produces is the line discipline's echo of
+#   the very glyph the prediction just painted, so no content needle can
+#   tell the daemon's answer from the client's own guess. `\x1b[2K` can:
+#   it is emitted by exactly one paint path in the client, the one that
+#   paints a DELTA (client.zig, paintDeltaClipped), so its arrival means a
+#   frame came back. The prediction paints the same glyph underlined and
+#   without an erase ("\x1b[24;1H\x1b[4mt\x1b[0m"), and the resync repaint
+#   erases the whole screen with \x1b[2J instead — neither can forge this.
+# The two post-tear deadlines are 20000 because a reconnect is allowed to
+# retry: the daemon may not have reaped the dead client's slot yet, and the
+# client tolerates that for reconnect_grace_ms (5s) with a backoff that
+# reaches 2s. That is a budget for a documented retry loop, not a deadline
+# tuned until a flake stopped.
+wait_for "$OUT.tp1.log" "done 3" 20 || {
+    echo "e2e FAIL: tp1 never reached the scroll view:"; cat "$OUT.tp1.log"; exit 1; }
+TP1PROXY=$(proxy_pid "$SOCK13")
+[ -n "$TP1PROXY" ] || { echo "e2e FAIL: tp1: no proxy to tear"; exit 1; }
+kill -9 "$TP1PROXY"
+kill -0 "$D13PID" || { echo "e2e FAIL: tp1 tear killed the daemon, not the proxy"; exit 1; }
+set +e
+wait "$TP1PID"
+RC=$?
+TP1PID=""
+set -e
+[ "$RC" -eq 0 ] || {
+    echo "e2e FAIL: tp1 ptyclient exited $RC:"; cat "$OUT.tp1.log"
+    cat -v "$OUT.tp1.err" 2>/dev/null; exit 1; }
+# Verb 5 is row 18's catch: a resync that fails to leave the scroll view
+# suppresses every live paint, so the second "100" never arrives.
+#
+# The counters are the 412f38f pin, and they are EXACT rather than floors.
+# One keystroke in the whole scenario, typed after the resync onto a blank
+# cell at a live cursor, in a session whose termios never moves: nothing
+# here is timing-dependent, so every number is a fact.
+#   made=1, suppressed=0 is the fix working. With it reverted the overlay
+#   still believes it is scrolled and predictAt refuses on that bit alone —
+#   made=0, suppressed=1, with nothing else in the run to hide it.
+#   displayed=1 says the glyph reached the SCREEN, which `made` does not:
+#   the overlay queues while unconfident and paints nothing, so a client
+#   that lost the `.always` tier would still count the prediction.
+#   confirmed=1 and contradicted=0 say the daemon's own echo agreed with
+#   the guess, which is what makes the prediction a speedup and not a lie.
+want_stat "$OUT.tp1.err" made 1 "pty scroll reconnect"
+want_stat "$OUT.tp1.err" displayed 1 "pty scroll reconnect"
+want_stat "$OUT.tp1.err" confirmed 1 "pty scroll reconnect"
+want_stat "$OUT.tp1.err" contradicted 0 "pty scroll reconnect"
+want_stat "$OUT.tp1.err" suppressed 0 "pty scroll reconnect"
+assert_converged "$OUT.tp1" "$SOCK13" "pty scroll reconnect"
+# The doctored control, extended to a pty capture: this capture's byte shape
+# (alt screen, banner paints, a history page) exists nowhere else in the
+# corpus, so it earns its own cannot-fail check.
+#
+# It CANNOT be the plain append the non-pty control uses. render replays
+# only up to the LAST alt-screen exit, and a tty client's capture ends with
+# one — so appended bytes land after the grid under test and change nothing.
+# Measured: the doctored capture rendered byte-identical to the original,
+# i.e. a control that could never fire. Dropping that trailing 8-byte exit
+# puts the append back INSIDE the alt screen (a stream with no alt-exit is
+# replayed whole), which corrupts exactly one row of the real grid — row 10,
+# "87" in this session. The tail is asserted rather than assumed, because if
+# the client's teardown ever stops ending there, the truncation would silently
+# go back to being a no-op appended after the grid.
+[ "$(tail -c 8 "$OUT.tp1" | od -An -tx1 | tr -d ' \n')" = "1b5b3f313034396c" ] || {
+    echo "e2e FAIL: tp1 capture does not end with the alt-screen exit;"
+    echo "          the doctored control below would not be doctoring the grid"
+    tail -c 16 "$OUT.tp1" | cat -v; exit 1; }
+head -c "$(( $(wc -c < "$OUT.tp1") - 8 ))" "$OUT.tp1" > "$OUT.tp1.doc"
+printf '\033[10;1Hpty-doctor-glyphs' >> "$OUT.tp1.doc"
+if converged_quiet "$OUT.tp1.doc" "$SOCK13"; then
+    echo "e2e FAIL: convergence control did not fire on a doctored pty capture"; exit 1
+fi
+rm -f "$OUT.tp1.doc" "$OUT.tp1.doc.render" "$OUT.tp1.doc.dump" \
+    "$OUT.tp1.doc.render.n" "$OUT.tp1.doc.dump.n" "$OUT.tp1.doc.diff" \
+    "$OUT.tp1.doc.rvt" "$OUT.tp1.doc.dvt"
+kill "$D13PID" 2>/dev/null || true
+D13PID=""
+rm -f "$OUT.tp1" "$OUT.tp1.err" "$OUT.tp1.log" "$OUT.tp1.d" "$TP1SH"
+ok "reconnect while scrolled: view restored, prediction resumed"
+# The pins. Literals, not variables set from counting something else —
+# "assert the literal, never the constant the code under test reads"
+# (decisions.md, M10). 13 scenario checkpoints; 25 convergence points.
+# Anyone adding a scenario updates these by hand, on purpose.
+[ "$OK_COUNT" = "13" ] || {
+    echo "e2e FAIL: $OK_COUNT scenario checkpoints ran, the pin says 13 —"
+    echo "          a scenario was added (update the pin) or silently lost"
+    exit 1
+[ "$CONV_COUNT" = "25" ] || {
+    echo "e2e FAIL: $CONV_COUNT convergence points ran, the pin says 25"
+    exit 1
+echo "e2e OK (13 scenarios, 25 convergence points)"