Update CHANGES.

* refs/remotes/tmux-openbsd/master:
  As well as tracking modified (dirty) lines during a synchronized update, also track scrolled lines. This means they can be scrolled as one instead of forcing each line to be redrawn - much less expensive for a very common operation. From Ben Maurer in GitHub issue 5611.

CHANGES

@@ -10,8 +10,8 @@ CHANGES FROM 3.7c TO 3.8
   - modal panes may be created with new-pane -O; a window can have one modal
     pane and it prevents interaction with the other panes while it is active.
     -C closes the pane when the mouse is clicked outside it and -K sends all
-    keys, including the prefix key, to the pane. A modal pane is now used for
-    the editor in buffer mode;
+    keys, including the prefix key, to the pane. -D closes the modal pane with
+    Escape or C-c. A modal pane is now used for the editor in buffer mode;
 
   - new-pane -A creates a floating pane which remains above a zoomed pane;
     modal panes do this by default;
@@ -39,6 +39,9 @@ CHANGES FROM 3.7c TO 3.8
   The old format is still accepted; control mode clients receive old layouts
   unless they set the new-layouts flag.
 
+* Add remain-on-exit failed-key to keep a pane open after a failed command
+  until a key is pressed.
+
 * Add support for themes and improve default colours:
 
   - tmux now has builtin light and dark colour themes for terminals with 256 or
@@ -115,6 +118,12 @@ CHANGES FROM 3.7c TO 3.8
   in terminal-features, and add a utf8 feature for terminals which support
   UTF-8 output.
 
+* Add an appesc terminal feature for mintty's application escape key mode,
+  avoiding unsupported sequences on other terminals (Pete Dietl, issue 5626).
+
+* Preserve existing Ss and Se terminfo capabilities for cursor styles and
+  restoring the default cursor (issue 5476).
+
 * Add a #{A/count:frames} modifier to show a series of frames as an animation
   in the status line (issue 5412 from Fernando Daciuk).
 
@@ -189,10 +198,23 @@ CHANGES FROM 3.7c TO 3.8
   sent inside %begin/%end (issue 5458), do not let a stuck client prevent the
   server from exiting (issue 5444), and reset control mode offsets when a pane
   is respawned (issue 5498). Bound buffered command replies so a control mode
-  client that stops reading cannot consume unlimited memory (issue 5565).
+  client that stops reading cannot consume unlimited memory (issue 5565), and
+  fix a collision between the output discard and bracketed paste flags (issue
+  5622).
 
 * Fix grouped sessions sometimes being left as unusable command targets while
-  they are being killed (Bryce Miller, issue 5180).
+  they are being killed (Bryce Miller, issue 5180), and prevent reuse of a
+  session with no windows while detaching (Heon Jeong, issue 5620).
+
+* Free wait-for clients when they disconnect and do not run their remaining
+  queued commands (issue 5614).
+
+* Expand formats in run-shell -c like other start-directory flags (reported by
+  Saul Nogueras).
+
+* Fix session alert flag formats to check all windows (issue 5599).
+
+* Do not clear the marked pane when clicking on a pane border.
 
 * Fix choose mode filtering when more than one pane exists (issue 5326), and
   fix an infinite loop in customize mode when a filter does not match.
@@ -203,11 +225,18 @@ CHANGES FROM 3.7c TO 3.8
   status lines, menus, popups, wide characters and floating panes. This
   includes fixes for flicker with alternate screen applications and scrollbars
   (Michael Grant, issue 5351; Noam Stolero, issue 5350; Aung Myo Kyaw, issue
-  5098).
+  5098), and misplaced wrapped lines during partial redraws (Ben Maurer, issue
+  5625).
 
 * Do not crash looking for the next or previous session (issue 5344), or when
   no client is available.
 
+* Fix crashes when destroying a zoomed pane (Romain Francoise, issue 5591),
+  copying from a blank source pane (Kaixuan Li), or opening a mode prompt when
+  the client is offset into the window.
+
+* Avoid an infinite loop when assigning a width to WCHAR_MAX (issue 5602).
+
 CHANGES FROM 3.7b TO 3.7c
 
 * Build with jemalloc on macOS to avoid what appears to be a bug in calloc

cmd-attach-session.c

@@ -91,10 +91,8 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 	wp = target.wp;
 
 	if (wl != NULL) {
-		if (wp != NULL) {
-			window_redraw_active_switch(wp->window, wp);
+		if (wp != NULL)
 			window_set_active_pane(wp->window, wp, 1);
-		}
 		session_set_current(s, wl);
 		if (wp != NULL)
 			cmd_find_from_winlink_pane(current, wl, wp, 0);

cmd-join-pane.c

@@ -307,7 +307,7 @@ cmd_join_pane_mouse_move(struct client *c, struct mouse_event *m)
 	struct window		*w;
 	struct window_pane	*wp;
 	struct layout_cell	*lc;
-	int			 y, ly, x, lx, oxoff, oyoff, osx, osy;
+	int			 y, ly, x, lx;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -329,16 +329,10 @@ cmd_join_pane_mouse_move(struct client *c, struct mouse_event *m)
 		ly = m->statusat - 1;
 
 	if (x != lx || y != ly) {
-		oxoff = wp->xoff;
-		oyoff = wp->yoff;
-		osx = wp->sx;
-		osy = wp->sy;
-
 		lc->g.xoff += x - lx;
 		lc->g.yoff += y - ly;
 		layout_fix_panes(w, NULL);
-
-		window_redraw_floating_pane(wp, oxoff, oyoff, osx, osy);
+		server_redraw_window(w);
 		server_redraw_window_borders(w);
 	}
 }

cmd-resize-pane.c

@@ -237,8 +237,8 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	struct window_pane	*wp;
 	struct layout_cell	*lc;
 	int			 y, ly, x, lx, sx, sy, new_sx, new_sy;
-	int			 left, right, resizes = 0;
-	int			 new_xoff, new_yoff, old_xoff, old_yoff;
+	int			 left, right;
+	int			 new_xoff, new_yoff, resizes = 0;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -249,8 +249,6 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	lc = wp->layout_cell;
 	sx = wp->sx;
 	sy = wp->sy;
-	old_xoff = wp->xoff;
-	old_yoff = wp->yoff;
 	left = wp->xoff - 1;
 	right = wp->xoff + sx;
 	if (window_pane_scrollbar_reserve(wp) &&
@@ -350,7 +348,7 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	}
 	if (resizes != 0) {
 		layout_fix_panes(w, NULL);
-		window_redraw_floating_pane(wp, old_xoff, old_yoff, sx, sy);
+		server_redraw_window(w);
 		server_redraw_window_borders(w);
 	}
 }

cmd-split-window.c

@@ -362,7 +362,6 @@ cmd_split_window_mouse_resize(struct client *c, struct mouse_event *m)
 	enum pane_lines		 lines;
 	u_int			 sx, sy;
 	int			 x, y, xoff, yoff, border;
-	int			 oxoff, oyoff, osx, osy;
 
 	if (c->tty.mouse_last_pane == -1)
 		return;
@@ -418,14 +417,8 @@ cmd_split_window_mouse_resize(struct client *c, struct mouse_event *m)
 	if (sy < PANE_MINIMUM)
 		sy = PANE_MINIMUM;
 
-	oxoff = wp->xoff;
-	oyoff = wp->yoff;
-	osx = wp->sx;
-	osy = wp->sy;
-
 	layout_set_size(lc, sx, sy, xoff, yoff);
 	layout_fix_panes(w, NULL);
-
-	window_redraw_floating_pane(wp, oxoff, oyoff, osx, osy);
+	server_redraw_window(w);
 	server_redraw_window_borders(w);
 }

layout.c

@@ -469,6 +469,7 @@ layout_fix_panes(struct window *w, struct window_pane *skip)
 					sx = PANE_MINIMUM;
 				else
 					sx = sx - sb_w - sb_pad;
+			wp->flags |= PANE_REDRAWSCROLLBAR;
 		}
 
 		window_pane_resize(wp, sx, sy);
@@ -476,11 +477,8 @@ layout_fix_panes(struct window *w, struct window_pane *skip)
 		if (wp->xoff != old_xoff ||
 		    wp->yoff != old_yoff ||
 		    wp->sx != old_sx ||
-		    wp->sy != old_sy) {
-			if (window_pane_scrollbar_reserve(wp))
-				wp->flags |= PANE_REDRAWSCROLLBAR;
+		    wp->sy != old_sy)
 			changed = 1;
-		}
 	}
 	if (changed)
 		redraw_invalidate_scene(w);

regress/attach-session-redraw.sh

@@ -1,79 +0,0 @@
-#!/bin/sh
-
-# Selecting a pane with attach-session from an already attached client must
-# redraw pane contents when window-style and window-active-style differ.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lattach-redraw-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lattach-redraw-outer-$$ -f/dev/null"
-BEFORE=$DIR/before
-AFTER=$DIR/after
-
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-LEFT=$($INNER new-session -dPF '#{pane_id}' -s inner -x 40 -y 8 \
-    "printf 'LEFT'; exec sleep 100") || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g default-terminal screen || exit 1
-$INNER split-window -h -t "$LEFT" "printf 'RIGHT'; exec sleep 100" || exit 1
-$INNER set-option -w -t "$LEFT" window-style bg=red || exit 1
-$INNER set-option -w -t "$LEFT" window-active-style bg=blue || exit 1
-$INNER bind-key -n x attach-session -t "$LEFT" || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 8 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lattach-redraw-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-sleep 1
-$OUTER send-keys -t outer:0.0 x || exit 1
-sleep 1
-[ "$($INNER display-message -p -t inner '#{pane_id}')" = "$LEFT" ] ||
-    fail "attach-session did not select the target pane"
-$OUTER capture-pane -pe -t outer:0.0 >"$BEFORE" || exit 1
-
-# A forced redraw produces the correct scene. It must be identical to the
-# scene drawn immediately by attach-session.
-$INNER refresh-client -t "$CLIENT" || exit 1
-sleep 1
-$OUTER capture-pane -pe -t outer:0.0 >"$AFTER" || exit 1
-cmp -s "$BEFORE" "$AFTER" ||
-    fail "attach-session left stale active/inactive pane styles"
-
-exit 0

regress/check-names.sh

@@ -5,15 +5,6 @@
 PATH=/bin:/usr/bin
 TERM=screen
 
-# The pane's shell must not be the user's own interactive shell: a custom
-# PS1/PROMPT_COMMAND that sets the terminal title (as many do, for tmux/xterm
-# TERM types) would redraw over the titles this test sets and checks on
-# every prompt, regardless of how long it waits first.
-shell=
-if command -v bash >/dev/null 2>&1; then
-	shell='bash --noprofile --norc +o history'
-fi
-
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
 TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
 $TMUX kill-server 2>/dev/null
@@ -39,7 +30,7 @@ must_equal()
 	[ "$got" = "$want" ] || fail "got '$got', expected '$want'"
 }
 
-$TMUX new-session -d -x 80 -y 24 -- $shell || exit 1
+$TMUX new-session -d -x 80 -y 24 || exit 1
 $TMUX set-option -qg allow-set-title on || exit 1
 $TMUX set-option -qg allow-rename on || exit 1
 $TMUX set-option -qg automatic-rename off || exit 1

regress/floating-pane-border-style-cross-client.sh

@@ -1,135 +0,0 @@
-#!/bin/sh
-
-# Damage-only redraws must evaluate both active and inactive border styles
-# for each client, even though the cached border cells belong to the pane.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lborder-style-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lborder-style-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_clients()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		count=$($INNER list-clients 2>/dev/null | wc -l)
-		[ "$count" -eq 2 ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "two inner clients did not attach"
-}
-
-wait_for_marker()
-{
-	target=$1
-	marker=$2
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t "$target" >"$CAPTURE" || exit 1
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "client in $target did not receive $marker"
-}
-
-cat >"$DIR/emitter.pl" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-for my $phase (1 .. 2) {
-	while (!-e "$ENV{TRIGGER}-$phase") {
-		select undef, undef, undef, 0.01;
-	}
-	# Change an unused palette entry and acknowledge it in the pane body.
-	print "\e]4;200;rgb:11/22/0$phase\a\e[1;1HDAMAGE$phase";
-}
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 60 -y 20 \
-    "TRIGGER='$DIR/trigger' perl '$DIR/emitter.pl'" || exit 1
-$INNER set -g status off || exit 1
-$INNER set -g window-size manual || exit 1
-$INNER set -g automatic-rename off || exit 1
-$INNER set -g status-interval 0 || exit 1
-$INNER set -g pane-border-lines simple || exit 1
-$INNER set -g pane-border-status top || exit 1
-$INNER set -g pane-border-format 'CLIENT=#{client_name}' || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 35 -y 6 -X 5 -Y 5 \
-    'sleep 100') || exit 1
-
-$OUTER new-session -d -s outer -x 121 -y 20 'sleep 100' || exit 1
-$OUTER set -g status off || exit 1
-$OUTER set -g window-size manual || exit 1
-$OUTER set -g default-terminal screen || exit 1
-LEFT=$($OUTER display-message -p -t outer:0.0 '#{pane_id}') || exit 1
-RIGHT=$($OUTER split-window -h -PF '#{pane_id}' 'sleep 100') || exit 1
-for target in "$LEFT" "$RIGHT"; do
-	$OUTER respawn-pane -k -t "$target" "$INNER attach-session -t inner" ||
-	    exit 1
-done
-wait_for_clients
-
-NAME1=$($OUTER display-message -p -t "$LEFT" '#{pane_tty}') || exit 1
-NAME2=$($OUTER display-message -p -t "$RIGHT" '#{pane_tty}') || exit 1
-STYLE="fg=#{?#{==:#{client_name},$NAME1},red,blue}"
-$INNER set -g pane-border-style "$STYLE" || exit 1
-$INNER set -g pane-active-border-style "$STYLE" || exit 1
-
-# Capture just the floating pane's rows, excluding the acknowledgement in
-# the tiled pane. Exercise each cache by changing the floating pane's focus.
-phase=1
-while [ "$phase" -le 2 ]; do
-	if [ "$phase" -eq 2 ]; then
-		$INNER select-pane -t "$FLOAT" || exit 1
-	fi
-	$INNER refresh-client -t "$NAME1" || exit 1
-	$INNER refresh-client -t "$NAME2" || exit 1
-	sleep 0.5
-	for target in "$LEFT" "$RIGHT"; do
-		$OUTER capture-pane -pe -S 5 -E 10 -t "$target" \
-		    >"$DIR/before-$target" || exit 1
-	done
-	RED=$(printf '\033[31m')
-	BLUE=$(printf '\033[34m')
-	grep -Fq "$RED" "$DIR/before-$LEFT" || fail "missing red border"
-	grep -Fq "$BLUE" "$DIR/before-$RIGHT" || fail "missing blue border"
-
-	: >"$DIR/trigger-$phase"
-	wait_for_marker "$LEFT" "DAMAGE$phase"
-	wait_for_marker "$RIGHT" "DAMAGE$phase"
-	sleep 0.2
-	for target in "$LEFT" "$RIGHT"; do
-		$OUTER capture-pane -pe -S 5 -E 10 -t "$target" \
-		    >"$CAPTURE" || exit 1
-		diff -u "$DIR/before-$target" "$CAPTURE" ||
-		    fail "phase $phase changed $target's border style"
-	done
-	phase=$((phase + 1))
-done
-
-exit 0

regress/floating-pane-drag-ghost.sh

@@ -1,108 +0,0 @@
-#!/bin/sh
-
-# Regression test for a floating-pane drag bug: cmd_resize_pane_redraw_floating()
-# (cmd-resize-pane.c) reported damage for just a dragged floating pane's
-# content rectangle, not the one-cell border frame drawn around it (see the
-# "floating" case in screen-redraw.c, which draws that frame at
-# xoff-1/yoff-1 through xoff+sx/yoff+sy - one cell outside the pane's own
-# content area). Damage scoped to only the content area left the frame's
-# previous position undrawn as the pane moved, so dragging it left a trail
-# of un-erased border frames behind - visible as several "corners" stacked
-# up rather than just the pane's current one.
-#
-# This bug has nothing to do with images - it reproduces with a plain
-# floating pane and no image support required.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
-TMUX2="$TEST_TMUX -LtestB$$ -f/dev/null"
-
-cleanup()
-{
-	$TMUX kill-server >/dev/null 2>&1
-	$TMUX2 kill-server >/dev/null 2>&1
-}
-fail()
-{
-	echo "$*" >&2
-	cleanup
-	exit 1
-}
-
-# drag STARTCOL STARTROW ENDCOL ENDROW
-#
-# Write a plain (unmodified) SGR button-1 press, drag update and release at
-# 1-based positions to the outer pane holding the inner client - this
-# matches the default MouseDown1Border/MouseDrag1Border bindings used to
-# move or resize a floating pane by its border.
-drag()
-{
-	scol="$1"
-	srow="$2"
-	ecol="$3"
-	erow="$4"
-
-	seq=$(printf '\033[<0;%s;%sM' "$scol" "$srow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 0.2
-	seq=$(printf '\033[<32;%s;%sM' "$ecol" "$erow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 0.2
-	seq=$(printf '\033[<0;%s;%sm' "$ecol" "$erow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 1
-}
-
-cleanup
-
-TMP=$(mktemp)
-trap "cleanup; rm -f $TMP" 0 1 15
-
-$TMUX new-session -d -s inner -x 60 -y 20 'sh -c "sleep 100"' || exit 1
-$TMUX set -g mouse on
-$TMUX set -g default-command 'sh -c "sleep 100"'
-
-FLOAT=$($TMUX new-pane -d -PF '#{pane_id}' -x 16 -y 5 -X 5 -Y 5) ||
-	fail "new-pane -X -Y failed"
-FTOP=$($TMUX display-message -p -t "$FLOAT" '#{pane_top}')
-FLEFT=$($TMUX display-message -p -t "$FLOAT" '#{pane_left}')
-FWIDTH=$($TMUX display-message -p -t "$FLOAT" '#{pane_width}')
-
-$TMUX2 new-session -d -x 60 -y 20 "$TMUX attach -t inner" || exit 1
-sleep 1
-OUTER=$($TMUX2 list-panes -F '#{pane_id}' | head -1)
-[ -n "$OUTER" ] || fail "No outer pane."
-
-# Sanity check: exactly one floating pane, so exactly one top-left corner,
-# before dragging anything.
-$TMUX2 capturep -p -t "$OUTER" >$TMP || fail "capture failed"
-n=$(grep -o '┌' $TMP | wc -l)
-[ "$n" -eq 1 ] || fail "sanity: expected 1 corner before drag, found $n"
-
-# Drag the floating pane by its top border (row FTOP-1, some column within
-# its width) down several rows in a few separate steps, then release. A
-# single drag() call already does press/motion/release, so call it several
-# times in a row to simulate a multi-step real drag.
-GRABCOL=$((FLEFT + FWIDTH / 2))
-STARTROW=$FTOP
-i=0
-while [ $i -lt 6 ]; do
-	newrow=$((STARTROW + i + 1))
-	drag $((GRABCOL + 1)) $((STARTROW + i)) $((GRABCOL + 1)) $newrow
-	i=$((i + 1))
-done
-
-$TMUX2 capturep -p -t "$OUTER" >$TMP || fail "capture failed"
-
-# Exactly one top-left corner should remain - the pane's current position.
-# This is expected to fail before the fix: multiple corners (a trail of
-# un-erased frames) would remain from the intermediate drag positions.
-n=$(grep -o '┌' $TMP | wc -l)
-[ "$n" -eq 1 ] || fail "expected exactly 1 corner after drag, found $n (ghost frames left behind)"
-
-exit 0

regress/floating-pane-drag-no-double-composite.sh

@@ -1,88 +0,0 @@
-#!/bin/sh
-
-# Each drag motion must draw the floating pane content once.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-cd "$DIR" || exit 1
-INNER="$TEST_TMUX -Ldoublecomp-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Ldoublecomp-outer-$$ -f/dev/null"
-
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	cd /
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.15
-}
-
-$INNER new-session -d -s inner -x 40 -y 15 "printf '\\033[15;1HOUTSIDE'; exec sleep 100" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g status-interval 0 || exit 1
-$INNER set-option -g automatic-rename off || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X 5 -Y 2 \
-    "printf 'DRAGMARK'; exec sleep 100") || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 15 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Ldoublecomp-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-sleep 0.5
-
-XOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-GRABCOL=$((XOFF + 3))
-BORDERROW=$YOFF
-
-# Begin capture after focus changes from the initial mouse press have settled.
-mouse 0 "$GRABCOL" "$BORDERROW" M
-$OUTER pipe-pane -O -t outer:0.0 "cat >'$DIR/output'" || exit 1
-$INNER refresh-client || exit 1
-sleep 0.5
-grep -aq DRAGMARK "$DIR/output" || fail "capture missed floating pane content"
-grep -aq OUTSIDE "$DIR/output" || fail "capture missed untouched row"
-offset=$(wc -c <"$DIR/output")
-
-i=0
-steps=6
-while [ "$i" -lt "$steps" ]; do
-	GRABCOL=$((GRABCOL + 1))
-	mouse 32 "$GRABCOL" "$BORDERROW" M
-	i=$((i + 1))
-done
-mouse 0 "$GRABCOL" "$BORDERROW" m
-sleep 0.3
-
-NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" -eq "$((XOFF + steps))" ] || fail "floating pane did not move six columns"
-tail -c +"$((offset + 1))" "$DIR/output" >"$DIR/drag-output"
-n=$(perl -0777 -ne '$n = () = /DRAGMARK/g; print "$n\n"' "$DIR/drag-output")
-[ "$n" -eq "$steps" ] ||
-	fail "$steps drag motions wrote the floating pane content $n times"
-
-exit 0

regress/floating-pane-drag-scrollbar-strip.sh

@@ -1,159 +0,0 @@
-#!/bin/sh
-
-# Regression test: dragging a floating pane across another pane's ordinary
-# content must not redraw that other pane's scrollbar, unless the drag
-# actually crosses the scrollbar's own strip.
-#
-# cmd_resize_pane_redraw_floating() (cmd-resize-pane.c) used to flag
-# PANE_REDRAWSCROLLBAR on any pane whose whole *body* intersected the
-# floating pane's old or new rectangle, rather than just its narrow
-# scrollbar strip - so dragging a floating pane back and forth over an
-# ordinary tiled pane's content (never touching its scrollbar) still
-# needlessly redrew that pane's scrollbar on every motion step. See
-# tmux-image-redraw-known-bugs.md for the full write-up.
-#
-# This is checked by giving the non-dragged pane a distinctive scrollbar
-# colour and counting how many times its SGR code appears in the client's
-# raw output while the floating pane is dragged vertically over that pane's
-# body, well clear of its scrollbar column: with the fix, it should never
-# reappear after the initial draw.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
-TMUX2="$TEST_TMUX -LtestB$$ -f/dev/null"
-
-cleanup()
-{
-	$TMUX kill-server >/dev/null 2>&1
-	$TMUX2 kill-server >/dev/null 2>&1
-}
-fail()
-{
-	echo "$*" >&2
-	cleanup
-	exit 1
-}
-
-# drag STARTCOL STARTROW ENDCOL ENDROW
-drag()
-{
-	scol="$1"
-	srow="$2"
-	ecol="$3"
-	erow="$4"
-
-	seq=$(printf '\033[<0;%s;%sM' "$scol" "$srow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 0.2
-	seq=$(printf '\033[<32;%s;%sM' "$ecol" "$erow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 0.2
-	seq=$(printf '\033[<0;%s;%sm' "$ecol" "$erow")
-	$TMUX2 send-keys -t "$OUTER" -l "$seq" 2>/dev/null
-	sleep 0.5
-}
-
-cleanup
-
-TMP=$(mktemp)
-trap "cleanup; rm -f $TMP" 0 1 15
-
-$TMUX new-session -d -s inner -x 60 -y 20 'sh -c "sleep 100"' || exit 1
-$TMUX set -g mouse on || fail "set mouse failed"
-$TMUX set -g default-command 'sh -c "sleep 100"' || fail "set default-command failed"
-$TMUX set -g pane-scrollbars on || fail "set pane-scrollbars failed"
-
-$TMUX split-window -h -t inner 'sh -c "sleep 100"' || fail "split-window failed"
-
-PANES=$($TMUX list-panes -t inner -F '#{pane_id} #{pane_left}')
-LEFT=$(echo "$PANES" | sort -k2 -n | head -1 | cut -d' ' -f1)
-[ -n "$LEFT" ] || fail "could not identify left pane"
-
-# A distinctive scrollbar colour for the non-dragged (left) pane only.
-$TMUX set -p -t "$LEFT" pane-scrollbars-style 'fg=colour201,bg=colour17' ||
-	fail "set pane-scrollbars-style failed"
-
-ALEFT=$($TMUX display-message -p -t "$LEFT" '#{pane_left}')
-ATOP=$($TMUX display-message -p -t "$LEFT" '#{pane_top}')
-AWIDTH=$($TMUX display-message -p -t "$LEFT" '#{pane_width}')
-AHEIGHT=$($TMUX display-message -p -t "$LEFT" '#{pane_height}')
-[ "$AWIDTH" -gt 15 ] || fail "left pane too narrow for this test ($AWIDTH)"
-
-# A small floating pane placed well inside the left pane's content area,
-# clear of its (right-hand) scrollbar column by several columns.
-FLOAT=$($TMUX new-pane -d -PF '#{pane_id}' -x 8 -y 5 \
-    -X $((ALEFT + 2)) -Y $((ATOP + 2))) || fail "new-pane -X -Y failed"
-FTOP=$($TMUX display-message -p -t "$FLOAT" '#{pane_top}')
-FLEFT=$($TMUX display-message -p -t "$FLOAT" '#{pane_left}')
-FWIDTH=$($TMUX display-message -p -t "$FLOAT" '#{pane_width}')
-[ $((FLEFT + FWIDTH + 3)) -lt $((ALEFT + AWIDTH)) ] ||
-	fail "sanity: floating pane too close to the scrollbar column"
-
-# Start the outer session with a plain shell, then start capturing before
-# triggering the attach - starting the attach as the outer pane's initial
-# command would mean pipe-pane only starts after the attach-driven initial
-# redraw (which draws the scrollbars) has already happened, missing it.
-$TMUX2 new-session -d -x 60 -y 20 || exit 1
-OUTER=$($TMUX2 list-panes -F '#{pane_id}' | head -1)
-[ -n "$OUTER" ] || fail "No outer pane."
-$TMUX2 pipe-pane -t "$OUTER" -O "cat >$TMP" || fail "pipe-pane failed"
-$TMUX2 send-keys -t "$OUTER" -l "$TMUX attach -t inner" || fail "send attach failed"
-$TMUX2 send-keys -t "$OUTER" Enter || fail "send enter failed"
-sleep 1
-
-# Sanity check: the distinctive scrollbar colour reaches the client at all.
-grep -qa '48;5;201' $TMP || fail "sanity: scrollbar colour never reached the client"
-: >$TMP
-
-# Drag the floating pane straight up and down by its top border, staying at
-# a fixed column the whole time - this never crosses the left pane's
-# scrollbar strip, only its ordinary content.
-GRABCOL=$((FLEFT + FWIDTH / 2))
-row=$FTOP
-i=0
-while [ $i -lt 6 ]; do
-	newrow=$((row + 1))
-	drag $GRABCOL $row $GRABCOL $newrow
-	row=$newrow
-	i=$((i + 1))
-done
-i=0
-while [ $i -lt 6 ]; do
-	newrow=$((row - 1))
-	drag $GRABCOL $row $GRABCOL $newrow
-	row=$newrow
-	i=$((i + 1))
-done
-
-# The scrollbar colour should never reappear - its geometry never changed,
-# and the drag never crossed its column. This is expected to fail before
-# the fix - see the header comment.
-n=$(grep -ac '48;5;201' $TMP)
-[ "$n" -eq 0 ] ||
-	fail "left pane's scrollbar was redrawn $n times while dragging over its body only"
-
-# Cross the scrollbar and return, comparing each damaged redraw with a full
-# refresh to check that covering and uncovering its cells leaves no artifacts.
-offset=$((ALEFT + AWIDTH - FLEFT - FWIDTH / 2))
-for delta in "$offset" "$((-offset))"; do
-	oldleft=$($TMUX display-message -p -t "$FLOAT" '#{pane_left}')
-	newcol=$((GRABCOL + delta))
-	drag "$GRABCOL" "$row" "$newcol" "$row"
-	GRABCOL=$newcol
-	newleft=$($TMUX display-message -p -t "$FLOAT" '#{pane_left}')
-	[ "$newleft" -eq "$((oldleft + delta))" ] ||
-		fail "floating pane did not move across the scrollbar as expected"
-	before=$($TMUX2 capture-pane -pe -t "$OUTER" -S 0 -E "$((AHEIGHT - 1))")
-	$TMUX refresh-client || fail "refresh-client failed"
-	sleep 0.5
-	after=$($TMUX2 capture-pane -pe -t "$OUTER" -S 0 -E "$((AHEIGHT - 1))")
-	[ "$before" = "$after" ] ||
-		fail "scrollbar crossing differs from a full redraw"
-done
-
-exit 0

regress/floating-pane-drag-sync-no-self-defer.sh

@@ -1,93 +0,0 @@
-#!/bin/sh
-
-# Synchronized drag output must not cause a full redraw of untouched rows.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-cd "$DIR" || exit 1
-INNER="$TEST_TMUX -Lsyncdefer-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lsyncdefer-outer-$$ -f/dev/null"
-
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	cd /
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.15
-}
-
-$INNER new-session -d -s inner -x 40 -y 15 "printf '\\033[15;1HOUTSIDE'; exec sleep 100" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g status-interval 0 || exit 1
-$INNER set-option -g automatic-rename off || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X 5 -Y 2 \
-    "printf 'DRAGMARK'; exec sleep 100") || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 15 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$INNER set-option -as terminal-features ',screen-256color:sync' || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lsyncdefer-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-sleep 0.5
-
-XOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-GRABCOL=$((XOFF + 3))
-BORDERROW=$YOFF
-
-# Begin capture after focus changes from the initial mouse press have settled.
-mouse 0 "$GRABCOL" "$BORDERROW" M
-$OUTER pipe-pane -O -t outer:0.0 "cat >'$DIR/output'" || exit 1
-$INNER refresh-client || exit 1
-sleep 0.5
-grep -aq DRAGMARK "$DIR/output" || fail "capture missed floating pane content"
-grep -aq OUTSIDE "$DIR/output" || fail "capture missed untouched row"
-offset=$(wc -c <"$DIR/output")
-
-i=0
-steps=6
-while [ "$i" -lt "$steps" ]; do
-	GRABCOL=$((GRABCOL + 1))
-	mouse 32 "$GRABCOL" "$BORDERROW" M
-	i=$((i + 1))
-done
-mouse 0 "$GRABCOL" "$BORDERROW" m
-sleep 0.3
-
-NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" -eq "$((XOFF + steps))" ] || fail "floating pane did not move six columns"
-tail -c +"$((offset + 1))" "$DIR/output" >"$DIR/drag-output"
-n=$(perl -0777 -ne '$n = () = /DRAGMARK/g; print "$n\n"' "$DIR/drag-output")
-[ "$n" -ge "$steps" ] || fail "drag output did not reach the client"
-perl -0777 -ne 'exit(/\e\[\?2026h/ ? 0 : 1)' "$DIR/drag-output" ||
-    fail "drag did not use synchronized output"
-if grep -aq OUTSIDE "$DIR/drag-output"; then
-	fail "synchronized drag redrew an untouched row"
-fi
-
-exit 0

regress/floating-pane-drag-wide-character-right.sh

@@ -1,206 +0,0 @@
-#!/bin/sh
-
-# Mirror of floating-pane-drag-wide-character.sh for the *right* edge of a
-# damage rectangle. redraw_damage_grow_span_clip() (screen-redraw.c) widens
-# a damage rectangle's right edge by one cell whenever it isn't already at
-# the span's own edge, to pull in a wide character's base half when the
-# edge lands on its padding half - but it did this unconditionally, with no
-# check of which half it was actually touching. When the edge instead
-# already lands cleanly on a fresh character's base cell (a character fully
-# outside the range), growing right pulls in just that base cell -
-# tty_draw_line() sees it can't fit that character's full width in the
-# remaining range (tty_draw_line_get_empty()'s gc->data.width > nx check)
-# and clears it, exactly as the left-edge bug cleared a neighbouring
-# character's padding half.
-#
-# As with the left-edge test, the exact column parity needs to be
-# deterministic to actually catch it. This constructs it by creating the
-# floating pane, checking its real position, and recreating it one column
-# over if necessary until the vacated rectangle's right edge lands on a
-# base cell.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lwidecharr-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lwidecharr-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-BASE=$DIR/base
-CAPTURE=$DIR/capture
-FLOAT=
-PANEWIDTH=12
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-slice_columns()
-{
-	# Extract terminal columns [COL1, COL2) from lines [ROW1, ROW2] of
-	# $1, decoding UTF-8 - the pane's own new position (well clear of
-	# this range) must not affect the comparison, so this only looks at
-	# the narrow strip actually vacated, not the whole line. capture-pane
-	# text has one decoded character per double-width cell pair (every
-	# character here is width 2), so terminal columns are converted to
-	# character indices by halving before slicing.
-	perl -CSD -e '
-		my ($row1, $row2, $col1, $col2, $file) = @ARGV;
-		open my $fh, "<:encoding(UTF-8)", $file or die $!;
-		my @lines = <$fh>;
-		my $c1 = int($col1 / 2);
-		my $c2 = int(($col2 + 1) / 2);
-		for my $n ($row1 .. $row2) {
-			my $line = $lines[$n - 1];
-			$line =~ s/\R\z//;
-			print substr($line, $c1, $c2 - $c1), "\n";
-		}
-	' "$ROW1" "$ROW2" "$COL1" "$COL2" "$1"
-}
-
-wait_old_rows_restored()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		slice_columns "$BASE" >"$DIR/want"
-		slice_columns "$CAPTURE" >"$DIR/got"
-		cmp -s "$DIR/want" "$DIR/got" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "wide characters under the floating pane's vacated right edge were not restored"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-binmode STDOUT, ':encoding(UTF-8)';
-$| = 1;
-for my $row (1 .. 10) {
-	print "\e[$row;1H", chr(0x754c) x 20;
-}
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 40 -y 10 "perl '$EMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g pane-scrollbars off || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lwidecharr-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-wait_outer_has '界界界'
-$OUTER capture-pane -p -t outer:0.0 >"$BASE" || exit 1
-
-# Create the floating pane, then check its actual resulting position. Try
-# adjacent starting columns until the vacated rectangle's right edge
-# (xoff + PANEWIDTH + 1, the border-grown exclusive end - see
-# window_pane_damage_floating(), window.c) lands on an even (base-cell)
-# column.
-startx=5
-tries=0
-while [ "$tries" -lt 2 ]; do
-	[ -n "$FLOAT" ] && $INNER kill-pane -t "$FLOAT" 2>/dev/null
-	FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x "$PANEWIDTH" -y 3 \
-	    -X "$startx" -Y 5 \
-	    'sh -c "printf FLOATMARK; exec sleep 100"') || exit 1
-	sleep 0.2
-	XOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-	YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-	oldright=$((XOFF + PANEWIDTH + 1))
-	if [ $((oldright % 2)) -eq 0 ]; then
-		break
-	fi
-	startx=$((startx + 1))
-	tries=$((tries + 1))
-done
-[ $(((XOFF + PANEWIDTH + 1) % 2)) -eq 0 ] ||
-	fail "could not find bad-parity starting column"
-
-wait_outer_has FLOATMARK
-
-ROW1=$((YOFF + 1))
-ROW2=$((YOFF + 3))
-COL1=$((XOFF + PANEWIDTH - 2))
-COL2=$((XOFF + PANEWIDTH + 2))
-
-# Grab the pane's top border a couple of columns in (avoiding the corner
-# cells) and drag it well clear of its old rectangle - far enough right
-# that its new position starts past the checked columns above (which sit
-# just past the pane's *original* right edge).
-GRABCOL=$((XOFF + 3))
-BORDERROW=$((YOFF))
-
-seq=$(printf '\033[<0;%s;%sM' "$GRABCOL" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-seq=$(printf '\033[<32;%s;%sM' "$((GRABCOL + 20))" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-seq=$(printf '\033[<0;%s;%sm' "$((GRABCOL + 20))" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-
-NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" != "$XOFF" ] || fail "sanity: floating pane did not move (still at $XOFF)"
-
-wait_old_rows_restored
-
-exit 0

regress/floating-pane-drag-wide-character.sh

@@ -1,200 +0,0 @@
-#!/bin/sh
-
-# Damage at a floating pane's vacated edge must always redraw a complete
-# grid character. redraw_damage_grow_span_clip() (screen-redraw.c) widens a
-# damage rectangle's left edge by one cell whenever it isn't already at the
-# span's own edge, to pull in a wide character's base half when the edge
-# lands on its padding half - but it did this unconditionally, with no
-# check of which half it was actually touching. When the edge instead
-# already lands cleanly on a fresh character's base cell, growing left
-# walks into the *previous*, unrelated character's padding cell and blanks
-# it (tty_draw_line() treats any leading padding cell as proof its own
-# range starts mid-character).
-#
-# This is a general damage-composition bug, not specific to any one kind of
-# pane, but the exact column parity needs to be deterministic to actually
-# catch it (a lucky parity draws fine). This constructs it by creating the
-# floating pane, checking its real position (the border-framing offset
-# added to -X is not something to hand-compute), and recreating it one
-# column over if necessary until the vacated rectangle's left edge lands on
-# a base cell.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lwidechar-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lwidechar-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-BASE=$DIR/base
-CAPTURE=$DIR/capture
-FLOAT=
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-slice_columns()
-{
-	# Extract terminal columns [COL1, COL2) from lines [ROW1, ROW2] of
-	# $1, decoding UTF-8 - the pane's own new position (well clear of
-	# this range) must not affect the comparison, so this only looks at
-	# the narrow strip actually vacated, not the whole line. capture-pane
-	# text has one decoded character per double-width cell pair (every
-	# character here is width 2), so terminal columns are converted to
-	# character indices by halving before slicing.
-	perl -CSD -e '
-		my ($row1, $row2, $col1, $col2, $file) = @ARGV;
-		open my $fh, "<:encoding(UTF-8)", $file or die $!;
-		my @lines = <$fh>;
-		my $c1 = int($col1 / 2);
-		my $c2 = int(($col2 + 1) / 2);
-		for my $n ($row1 .. $row2) {
-			my $line = $lines[$n - 1];
-			$line =~ s/\R\z//;
-			print substr($line, $c1, $c2 - $c1), "\n";
-		}
-	' "$ROW1" "$ROW2" "$COL1" "$COL2" "$1"
-}
-
-wait_old_rows_restored()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		slice_columns "$BASE" >"$DIR/want"
-		slice_columns "$CAPTURE" >"$DIR/got"
-		cmp -s "$DIR/want" "$DIR/got" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "wide characters under the floating pane's vacated edge were not restored"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-binmode STDOUT, ':encoding(UTF-8)';
-$| = 1;
-for my $row (1 .. 10) {
-	print "\e[$row;1H", chr(0x754c) x 20;
-}
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 40 -y 10 "perl '$EMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g pane-scrollbars off || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lwidechar-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-wait_outer_has '界界界'
-$OUTER capture-pane -p -t outer:0.0 >"$BASE" || exit 1
-
-# Create the floating pane, then check its actual resulting position. Try
-# adjacent starting columns until the vacated rectangle's left edge
-# (xoff - 1) lands on an even (base-cell) column - the odd case is the one
-# every earlier manual test happened to land on by chance.
-startx=5
-tries=0
-while [ "$tries" -lt 2 ]; do
-	[ -n "$FLOAT" ] && $INNER kill-pane -t "$FLOAT" 2>/dev/null
-	FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 12 -y 3 -X "$startx" \
-	    -Y 5 'sh -c "printf FLOATMARK; exec sleep 100"') || exit 1
-	sleep 0.2
-	XOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-	YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-	oldleft=$((XOFF - 1))
-	if [ $((oldleft % 2)) -eq 0 ]; then
-		break
-	fi
-	startx=$((startx + 1))
-	tries=$((tries + 1))
-done
-[ $(((XOFF - 1) % 2)) -eq 0 ] || fail "could not find bad-parity starting column"
-
-wait_outer_has FLOATMARK
-
-ROW1=$((YOFF + 1))
-ROW2=$((YOFF + 3))
-COL1=$((XOFF - 4))
-COL2=$((XOFF + 4))
-
-# Grab the pane's top border a couple of columns in (avoiding the corner
-# cells) and drag it well clear of its old rectangle.
-GRABCOL=$((XOFF + 3))
-BORDERROW=$((YOFF))
-
-seq=$(printf '\033[<0;%s;%sM' "$GRABCOL" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-seq=$(printf '\033[<32;%s;%sM' "$((GRABCOL + 15))" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-seq=$(printf '\033[<0;%s;%sm' "$((GRABCOL + 15))" "$BORDERROW")
-$OUTER send-keys -t outer:0.0 -l "$seq" || exit 1
-sleep 0.1
-
-NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" != "$XOFF" ] || fail "sanity: floating pane did not move (still at $XOFF)"
-
-wait_old_rows_restored
-
-exit 0

regress/floating-pane-offscreen-alternate-redraw.sh

@@ -1,102 +0,0 @@
-#!/bin/sh
-
-# Returning from the alternate screen must redraw the visible part of a
-# floating pane clipped at the left edge, the top edge, or both.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Loffscreen-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Loffscreen-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-for my $row (1 .. 5) {
-	print "\e[$row;1H", 'A' x 15;
-}
-while (!-e "$ENV{TRIGGER}-alternate") {
-	select undef, undef, undef, 0.01;
-}
-print "\e[?1049h";
-for my $row (1 .. 5) {
-	print "\e[$row;1H", 'B' x 15;
-}
-while (!-e "$ENV{TRIGGER}-restore") {
-	select undef, undef, undef, 0.01;
-}
-print "\e[?1049l";
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 40 -y 10 'sleep 100' || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Loffscreen-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-for position in left top both; do
-	case "$position" in
-	left) x=-5; y=2 ;;
-	top) x=5; y=-2 ;;
-	both) x=-5; y=-2 ;;
-	esac
-	FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X "$x" -Y "$y" \
-	    "TRIGGER='$DIR/$position' perl '$EMITTER'") || exit 1
-	[ "$($INNER display-message -p -t "$FLOAT" '#{pane_left},#{pane_top}')" = "$((x + 1)),$((y + 1))" ] ||
-	    fail "$position: floating pane has unexpected position"
-	wait_outer_has AAAAA
-	cp "$CAPTURE" "$DIR/primary"
-	: >"$DIR/$position-alternate"
-	wait_outer_has BBBBB
-	: >"$DIR/$position-restore"
-	wait_outer_has AAAAA
-	cmp -s "$DIR/primary" "$CAPTURE" ||
-	    fail "$position: primary screen was not completely restored"
-	$INNER kill-pane -t "$FLOAT" || exit 1
-done
-
-exit 0

regress/floating-pane-prompt-wide-character.sh

@@ -1,179 +0,0 @@
-#!/bin/sh
-
-# A damage rectangle's clip range is grown to avoid splitting a wide
-# character, but redraw_damage_grow_span_clip() (screen-redraw.c) only ever
-# checks the span's own pane *content* grid (wp->screen) for that. For a
-# REDRAW_SPAN_PANE span, that same range is then also handed to
-# redraw_damage_draw_pane_prompt() to recompose the pane's separately
-# rendered prompt (wp->prompt, e.g. from "command-prompt -P") over the
-# damaged sub-range - but the prompt is drawn into its own, freshly
-# allocated one-line screen, unrelated to the pane's content grid, so a
-# range grown (or left ungrown) against the content is not necessarily
-# grown correctly for the prompt's own wide characters.
-#
-# This is invisible when the pane's own content is plain ASCII (as here):
-# redraw_damage_grow_span_clip() never finds anything to grow against, so
-# the raw, ungrown geometric range is passed straight through to the
-# prompt - and if that range's edge lands mid-character in the *prompt's*
-# grid, tty_draw_line() clears the character it cuts through
-# (tty_draw_line_get_empty()'s gc->data.width > nx check, for a trailing
-# base cell with no room left for its padding half).
-#
-# The trigger is a palette change (OSC 4) in a tiled pane that is one half
-# of a vertical split running the full height of the window - occluded
-# under the floating pane, but still geometrically triggering a redraw of
-# its own rectangle. Positioned so the split boundary falls inside the
-# floating pane's own CJK prompt, this reproduces exactly Codex's report:
-# "a floating pane containing a CJK prompt across a tiled-pane boundary -
-# a palette update in the tiled pane blanks a prompt character."
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-cd "$DIR" || exit 1
-INNER="$TEST_TMUX -Lpromptwide-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lpromptwide-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-CAPTURE=$DIR/capture
-FLOAT=
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	cd /
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-wait_prompt_row_intact()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		line=$(sed -n "${PROMPTROW}p" "$CAPTURE")
-		case $line in
-		*"$PROMPTTEXT"*) return 0 ;;
-		esac
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "the CJK prompt was not intact after the palette-triggered damage - got: $line"
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-my $line = <STDIN>;
-print "\e]4;1;rgb:11/22/33\e\\";
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 60 -y 12 "perl '$EMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-LEFT=$($INNER list-panes -t inner -F '#{pane_id}') || exit 1
-
-# Split so the boundary between the two tiled panes falls at column 17 -
-# used below to pick a floating-pane column that lands the boundary
-# mid-character inside the prompt.
-RIGHT=$($INNER split-window -t inner -h -l 43 -PF '#{pane_id}' \
-    'sleep 100') || exit 1
-RX=$($INNER display-message -p -t "$RIGHT" '#{pane_left}') || exit 1
-
-# Create the floating pane, then check its actual resulting position (the
-# border-framing offset added to -X is not something to hand-compute). Try
-# adjacent starting columns until the split boundary lands on an odd
-# (padding-half) column of the prompt's own numbering, and within the
-# prompt's 12-column width.
-startx=10
-tries=0
-while [ "$tries" -lt 4 ]; do
-	[ -n "$FLOAT" ] && $INNER kill-pane -t "$FLOAT" 2>/dev/null
-	FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 24 -y 5 -X "$startx" \
-	    -Y 2 "sh -c 'i=0; while [ \$i -lt 10 ]; do \
-printf AAAAAAAAAAAAAAAAAAAAAA\\\\n; i=\$((i+1)); done; sleep 100'") ||
-	    exit 1
-	sleep 0.2
-	X1=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-	Y1=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-	H1=$($INNER display-message -p -t "$FLOAT" '#{pane_height}')
-	local=$((RX - X1 - 1))
-	if [ "$local" -ge 1 ] && [ "$local" -le 11 ] &&
-	    [ $((local % 2)) -eq 1 ]; then
-		break
-	fi
-	startx=$((startx + 1))
-	tries=$((tries + 1))
-done
-local=$((RX - X1 - 1))
-[ "$local" -ge 1 ] && [ "$local" -le 11 ] && [ $((local % 2)) -eq 1 ] ||
-	fail "could not find bad-parity starting column"
-
-$OUTER new-session -d -s outer -x 60 -y 12 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lpromptwide-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-wait_outer_has AAAAAAAAAAAAAAAAAAAAAA
-CLIENT=$($INNER list-clients -F '#{client_name}') || exit 1
-
-$INNER select-pane -t "$FLOAT" || exit 1
-PROMPTTEXT=$(printf '\344\270\255' | perl -CSD -ne 'print $_ x 6')
-$INNER command-prompt -b -P -t "$CLIENT" -p "$PROMPTTEXT" \
-    'display-message -- %1' || exit 1
-wait_outer_has "$PROMPTTEXT"
-
-PROMPTROW=$((Y1 + H1))
-
-# Trigger the damage: unblock the emitter so it fires the palette change in
-# the left tiled pane, which is occluded under (but geometrically overlaps)
-# the floating pane's prompt row.
-$INNER send-keys -t "$LEFT" Enter || exit 1
-
-wait_prompt_row_intact
-
-exit 0

regress/floating-pane-status-cross-client.sh

@@ -1,151 +0,0 @@
-#!/bin/sh
-
-# Damage redraws must show each client's own pane status, even though the
-# cached status screen is shared between clients.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lstatuscc-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lstatuscc-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_clients()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		count=$($INNER list-clients 2>/dev/null | wc -l)
-		[ "$count" -eq 2 ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "two inner clients did not attach"
-}
-
-wait_for_marker()
-{
-	target=$1
-	marker=$2
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t "$target" >"$CAPTURE" || exit 1
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "client in $target did not receive $marker"
-}
-
-cat >"$DIR/emitter.pl" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-for my $phase (1 .. 4) {
-	while (!-e "$ENV{TRIGGER}-$phase") {
-		select undef, undef, undef, 0.01;
-	}
-	# Change an unused palette entry and acknowledge it in the pane body.
-	print "\e]4;200;rgb:11/22/0$phase\a\e[1;1HDAMAGE$phase";
-}
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 60 -y 20 \
-    "TRIGGER='$DIR/trigger' perl '$DIR/emitter.pl'" || exit 1
-$INNER set -g status off || exit 1
-$INNER set -g window-size manual || exit 1
-$INNER set -g automatic-rename off || exit 1
-$INNER set -g status-interval 0 || exit 1
-$INNER set -g pane-border-lines simple || exit 1
-$INNER set -g pane-border-status top || exit 1
-$INNER set -g pane-border-format 'CLIENT=<#{client_name}>' || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 35 -y 6 -X 5 -Y 5 \
-    'sleep 100') || exit 1
-
-$OUTER new-session -d -s outer -x 121 -y 20 'sleep 100' || exit 1
-$OUTER set -g status off || exit 1
-$OUTER set -g window-size manual || exit 1
-$OUTER set -g default-terminal screen || exit 1
-LEFT=$($OUTER display-message -p -t outer:0.0 '#{pane_id}') || exit 1
-RIGHT=$($OUTER split-window -h -PF '#{pane_id}' 'sleep 100') || exit 1
-for target in "$LEFT" "$RIGHT"; do
-	$OUTER respawn-pane -k -t "$target" "$INNER attach-session -t inner" ||
-	    exit 1
-done
-wait_for_clients
-
-NAME1=$($OUTER display-message -p -t "$LEFT" '#{pane_tty}') || exit 1
-NAME2=$($OUTER display-message -p -t "$RIGHT" '#{pane_tty}') || exit 1
-
-# Disable periodic status updates above and trigger damage without a command
-# that also requests a status redraw. Each client must keep its own title.
-$INNER refresh-client -t "$NAME1" || exit 1
-$INNER refresh-client -t "$NAME2" || exit 1
-sleep 0.5
-for phase in 0 1 2; do
-	if [ "$phase" -ne 0 ]; then
-		: >"$DIR/trigger-$phase"
-		wait_for_marker "$LEFT" "DAMAGE$phase"
-		wait_for_marker "$RIGHT" "DAMAGE$phase"
-		sleep 0.2
-	fi
-	for target in "$LEFT" "$RIGHT"; do
-		if [ "$target" = "$LEFT" ]; then
-			name=$NAME1
-			other=$NAME2
-		else
-			name=$NAME2
-			other=$NAME1
-		fi
-		$OUTER capture-pane -p -S 5 -E 10 -t "$target" \
-		    >"$CAPTURE" || exit 1
-		grep -Fq "CLIENT=<$name>" "$CAPTURE" ||
-		    fail "phase $phase: missing $name's pane status"
-		if grep -Fq "CLIENT=<$other>" "$CAPTURE"; then
-			fail "phase $phase: $name received $other's pane status"
-		fi
-	done
-done
-
-# Leave just one client so a cache keyed only by client would remain stale.
-$OUTER respawn-pane -k -t "$RIGHT" 'sleep 100' || exit 1
-i=0
-while [ "$($INNER list-clients | wc -l)" -ne 1 ]; do
-	[ "$i" -lt 50 ] || fail "second client did not detach"
-	sleep 0.1
-	i=$((i + 1))
-done
-$INNER set-environment -g TEST_STATUS_VALUE initial || exit 1
-$INNER set -g pane-border-format 'VALUE=#{TEST_STATUS_VALUE}' || exit 1
-$INNER refresh-client -t "$NAME1" || exit 1
-wait_for_marker "$LEFT" VALUE=initial
-for phase in 3 4; do
-	# Changing the environment does not itself request a status redraw.
-	$INNER set-environment -g TEST_STATUS_VALUE "phase$phase" || exit 1
-	: >"$DIR/trigger-$phase"
-	wait_for_marker "$LEFT" "DAMAGE$phase"
-	wait_for_marker "$LEFT" "VALUE=phase$phase"
-done
-
-exit 0

regress/floating-pane-status-format.sh

@@ -1,102 +0,0 @@
-#!/bin/sh
-
-# Resizing a floating pane must refresh session status formats which depend on
-# its geometry, not only the pane scene and borders.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lfloating-status-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lfloating-status-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has_status()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		tail -1 "$CAPTURE" | grep -q "$marker" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client status did not show $marker"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-$INNER new-session -d -s inner -x 50 -y 12 'sleep 100' || exit 1
-FLOAT=$($INNER new-pane -PF '#{pane_id}' -x 10 -y 5 -X 5 -Y 3 \
-    'sleep 100') || fail "could not create floating pane"
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g status on || exit 1
-$INNER set-option -g status-position bottom || exit 1
-$INNER set-option -g status-left 'WIDTH=#{pane_width}' || exit 1
-$INNER set-option -g status-right '' || exit 1
-$INNER set-option -g status-interval 0 || exit 1
-
-$OUTER new-session -d -s outer -x 50 -y 12 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lfloating-status-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-OLD_WIDTH=$($INNER display-message -p -t "$FLOAT" '#{pane_width}')
-wait_outer_has_status "WIDTH=$OLD_WIDTH"
-
-RIGHT=$($INNER display-message -p -t "$FLOAT" '#{pane_right}')
-TOP=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-X=$((RIGHT + 2))
-Y=$((TOP + 2))
-
-# Grab the right frame and enlarge the floating pane.
-mouse 0 "$X" "$Y" M
-mouse 32 "$((X + 1))" "$Y" M
-mouse 32 "$((X + 8))" "$Y" M
-mouse 0 "$((X + 8))" "$Y" m
-
-NEW_WIDTH=$($INNER display-message -p -t "$FLOAT" '#{pane_width}')
-[ "$NEW_WIDTH" -ne "$OLD_WIDTH" ] || fail "floating pane was not resized"
-wait_outer_has_status "WIDTH=$NEW_WIDTH"
-
-exit 0

regress/mode-tree-scroll.sh

@@ -0,0 +1,168 @@
+#!/bin/sh
+
+# Tests that the scroll position of a mode tree list (mode-tree.c) is kept
+# when the list is rebuilt, using choose-buffer. Buffer mode rebuilds its list
+# every time the status line is redrawn, which used to move the view so the
+# selected line was on the bottom row (or the list jumped back to the top)
+# even if the selected line was already visible. Also checks that when the
+# list shrinks the view does not leave empty lines at the bottom.
+#
+# The list is drawn on a mode screen which capture-pane does not show, so - as
+# in choose-buffer.sh - a second server provides a client: an inner "tmux
+# attach" runs inside a pane of the second server, and that pane is captured
+# to read what the inner client rendered.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMP=$(mktemp -d) || exit 1
+TMUX_TMPDIR="$TMP"
+export TMUX_TMPDIR
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+TMUX2="$TEST_TMUX -LtestB$$ -f/dev/null"
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	$TMUX2 kill-server 2>/dev/null
+	rm -rf "$TMP"
+}
+trap cleanup EXIT
+
+fail()
+{
+	echo "$1" >&2
+	exit 1
+}
+
+# capture the screen rendered by the inner client
+capture()
+{
+	$TMUX2 capture-pane -p -t out:0 2>/dev/null
+}
+
+# wait_for $marker
+#
+# Wait (up to ~10s) until the rendered screen contains $marker. The matching
+# capture is left in CAPTURED.
+wait_for()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		CAPTURED=$(capture)
+		if printf '%s\n' "$CAPTURED" | grep -F -q "$1"; then
+			return 0
+		fi
+		sleep 0.2
+		i=$((i + 1))
+	done
+	fail "timed out waiting for '$1'"
+}
+
+# wait_gone $marker
+#
+# Wait (up to ~10s) until the rendered screen no longer contains $marker. The
+# matching capture is left in CAPTURED.
+wait_gone()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		CAPTURED=$(capture)
+		if ! printf '%s\n' "$CAPTURED" | grep -F -q "$1"; then
+			return 0
+		fi
+		sleep 0.2
+		i=$((i + 1))
+	done
+	fail "timed out waiting for '$1' to disappear"
+}
+
+# wait_clients $n
+#
+# Wait (up to ~10s) until the test server has exactly $n clients attached.
+wait_clients()
+{
+	i=0
+	while [ "$i" -lt 10 ]; do
+		c=$($TMUX list-clients -F x 2>/dev/null | grep -c x)
+		[ "$c" -eq "$1" ] && return 0
+		sleep 1
+		i=$((i + 1))
+	done
+	return 1
+}
+
+# first_line
+#
+# Print the name of the first buffer shown in CAPTURED.
+first_line()
+{
+	printf '%s\n' "$CAPTURED" | grep -F ': S1' | head -1 | \
+	    sed 's/.*\(buf[0-9a-z]*\): S1.*/\1/'
+}
+
+$TMUX new-session -d -s aaa -x 80 -y 24 'cat' || exit 1
+
+$TMUX2 new-session -d -s out -x 80 -y 24 "$TMUX attach -t aaa" || exit 1
+wait_clients 1 || fail "no client attached to test server"
+
+# Forty buffers, more than fit on the screen.
+n=0
+while [ "$n" -lt 40 ]; do
+	$TMUX set-buffer -b "$(printf 'buf%02d' "$n")" "buffer $n" || exit 1
+	n=$((n + 1))
+done
+
+# Without a preview the list has the whole pane (23 lines with the status
+# line), so buf00 to buf22 are visible.
+$TMUX choose-buffer -t aaa:0 -N -O name -F 'S1' || exit 1
+wait_for 'buf00: S1'
+
+# --- scrolling down moves the view -------------------------------------------
+#
+# Selecting buf30 scrolls so it is on the bottom row: buf08 is at the top.
+$TMUX send-keys -t aaa:0 -N 30 Down || exit 1
+wait_for 'buf30: S1'
+top=$(first_line)
+[ "$top" = "buf08" ] || fail "top line after scrolling is $top, not buf08"
+
+# Moving up to buf20 stays inside the visible lines so the view does not move.
+$TMUX send-keys -t aaa:0 -N 10 Up || exit 1
+
+# --- a rebuild keeps the view where it is ------------------------------------
+#
+# Add a buffer that sorts into the visible part of the list and redraw the
+# status line so the list is rebuilt. Once buf15a appears the rebuild has
+# happened; buf08 must still be the top line. It used to jump back to buf00.
+$TMUX set-buffer -b buf15a "new buffer" || exit 1
+$TMUX refresh-client -S || exit 1
+wait_for 'buf15a: S1'
+top=$(first_line)
+[ "$top" = "buf08" ] || fail "top line after rebuild is $top, not buf08"
+
+# --- a shrinking list does not leave empty lines -----------------------------
+#
+# Go to the end of the list (buf39 is on the bottom row) and delete all but
+# the last ten buffers. They now all fit, so the view goes to the top.
+$TMUX send-keys -t aaa:0 End || exit 1
+wait_for 'buf39: S1'
+for b in $($TMUX list-buffers -F '#{buffer_name}'); do
+	case "$b" in
+	buf3?)
+		;;
+	*)
+		$TMUX delete-buffer -b "$b" || exit 1
+		;;
+	esac
+done
+$TMUX refresh-client -S || exit 1
+wait_gone 'buf29: S1'
+top=$(first_line)
+[ "$top" = "buf30" ] || fail "top line after shrinking is $top, not buf30"
+[ "$(printf '%s\n' "$CAPTURED" | grep -F -c ': S1')" -eq 10 ] || \
+	fail "expected 10 buffers after shrinking"
+
+$TMUX send-keys -t aaa:0 q
+
+exit 0

regress/popup-drag-wide-character.sh

@@ -1,126 +0,0 @@
-#!/bin/sh
-
-# Damage at a popup edge must redraw complete grid characters. Drawing only a
-# wide character's base or padding cell leaves a two-cell hole behind.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lpopup-wide-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lpopup-wide-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-BASE=$DIR/base
-CAPTURE=$DIR/capture
-POPUP_PID=
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	[ -n "$POPUP_PID" ] && kill "$POPUP_PID" 2>/dev/null
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-wait_old_rows_restored()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		sed -n '3,5p' "$BASE" >"$DIR/want"
-		sed -n '3,5p' "$CAPTURE" >"$DIR/got"
-		cmp -s "$DIR/want" "$DIR/got" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "wide characters under the old popup edge were not restored"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-binmode STDOUT, ':encoding(UTF-8)';
-$| = 1;
-for my $row (1 .. 10) {
-	print "\e[$row;1H", chr(0x754c) x 20;
-}
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 40 -y 10 "perl '$EMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lpopup-wide-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-wait_outer_has '界界界'
-$OUTER capture-pane -p -t outer:0.0 >"$BASE" || exit 1
-
-$INNER display-popup -t "$CLIENT" -x 5 -y 5 -w 10 -h 3 -E \
-    "sh -c 'printf POPUP; exec sleep 100'" &
-POPUP_PID=$!
-wait_outer_has POPUP
-
-# The first motion starts the drag; the second moves the popup away from its
-# old rectangle. Its odd x coordinate bisects the underlying double-width
-# cells at both edges.
-mouse 0 10 3 M
-mouse 32 11 3 M
-mouse 32 28 7 M
-mouse 0 28 7 m
-wait_old_rows_restored
-
-exit 0

regress/prompt-words-history.sh

@@ -131,14 +131,6 @@ printf '%s\n' "$captured" | grep -Fq 'show-buffer' ||
 printf '%s\n' "$captured" | grep -Fq 'show-environment' ||
 	fail "ambiguous completion list was incomplete"
 $OUTER send-keys Escape || exit 1
-# Wait until Escape has closed the prompt before sending another Meta key.
-# Otherwise the two can be parsed together as a single escape sequence.
-i=0
-while capture | grep -Fq '(word)'; do
-	[ "$i" -lt 50 ] || fail "completion prompt did not close"
-	sleep 0.1
-	i=$((i + 1))
-done
 
 # Add entries to both history rings through real prompts.
 bind_prompt 'history-command'

regress/redraw-damage-accumulate.sh

@@ -1,113 +0,0 @@
-#!/bin/sh
-
-# Many wrapped rows crossing a panned viewport produce disjoint damage.
-# Every row must survive the rectangle-count limit and subsequent merging.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Laccumulate-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Laccumulate-outer-$$ -f/dev/null"
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-wait_marker()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$DIR/capture" || exit 1
-		grep -q "$1" "$DIR/capture" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "client did not receive $1"
-}
-cat >"$DIR/emitter.pl" <<'PERL'
-use strict;
-use warnings;
-$| = 1;
-for my $row (1 .. 80) {
-	printf "\e[%d;1HROW%02d-%s", $row, $row, 'abcdefghij' x 6;
-}
-print "\e[1;1H";
-while (!-e $ENV{TRIGGER}) {
-	select undef, undef, undef, 0.01;
-}
-my $output = '';
-# Each wrapped second row needs a separate damage rectangle. Keep the
-# batch below the PTY read size so all 18 arrive in the same input pass.
-for my $region (0 .. 17) {
-	my $top = 1 + $region * 4;
-	$output .= "\e[$top;1H" . ('A' x 80) . ('B' x 24) .
-	    sprintf('DAMAGE%02d', $region) . ('B' x 48);
-}
-$output .= "\e[80;21HDONE";
-syswrite STDOUT, $output;
-while (!-e "$ENV{TRIGGER}-merge") {
-	select undef, undef, undef, 0.01;
-}
-# Returning from the alternate screen requests a full-pane rectangle. A
-# later wrapped-row rectangle overlaps it and must not shrink that damage.
-$output = "\e[?1049h\e[40;21HALT-VISIBLE\e[?1049l";
-$output .= "\e[1;1H" . ('C' x 80) . ('D' x 24) . 'MERGE00' . ('D' x 49);
-$output .= "\e[80;21HMERGED";
-syswrite STDOUT, $output;
-sleep 100;
-PERL
-$INNER new-session -d -s inner -x 80 -y 80 \
-    "TRIGGER='$DIR/trigger' perl '$DIR/emitter.pl'" || exit 1
-$INNER set -g status off || exit 1
-$INNER set -g window-size manual || exit 1
-$INNER set -g automatic-rename off || exit 1
-$INNER set -g status-interval 0 || exit 1
-$INNER set -as terminal-features ',screen:sync' || exit 1
-$INNER set -g pane-border-lines simple || exit 1
-$OUTER new-session -d -s outer -x 40 -y 80 'sleep 100' || exit 1
-$OUTER set -g status off || exit 1
-$OUTER set -g window-size manual || exit 1
-$OUTER set -g default-terminal screen || exit 1
-$OUTER respawn-pane -k -t outer:0.0 "$INNER attach -t inner" || exit 1
-wait_marker ROW80
-CLIENT=$($OUTER display -p -t outer:0.0 '#{pane_tty}') || exit 1
-$INNER refresh-client -t "$CLIENT" -R 20 || exit 1
-# Keep the emitter inactive so its writes use a synchronized frame. Otherwise
-# its own queued output can force a full redraw and hide lost rectangles.
-$INNER new-pane -x 6 -y 3 -X 65 -Y 74 'sleep 100' || exit 1
-sleep 0.2
-: >"$DIR/trigger"
-wait_marker DONE
-sleep 0.2
-$OUTER capture-pane -p -t outer:0.0 >"$DIR/before" || exit 1
-region=0
-while [ "$region" -lt 18 ]; do
-	marker=$(printf 'DAMAGE%02d' "$region")
-	sed -n "$((2 + region * 4))p" "$DIR/before" | grep -q "$marker" ||
-	    fail "missing damage for region $region"
-	region=$((region + 1))
-done
-$INNER refresh-client -t "$CLIENT" || exit 1
-sleep 0.2
-$OUTER capture-pane -p -t outer:0.0 >"$DIR/after" || exit 1
-diff -u "$DIR/before" "$DIR/after" || fail "accumulated redraw differs from full redraw"
-: >"$DIR/trigger-merge"
-wait_marker MERGED
-sleep 0.2
-$OUTER capture-pane -p -t outer:0.0 >"$DIR/before" || exit 1
-sed -n '2p' "$DIR/before" | grep -q MERGE00 || fail "merged damage lost the wrapped row"
-$INNER refresh-client -t "$CLIENT" || exit 1
-sleep 0.2
-$OUTER capture-pane -p -t outer:0.0 >"$DIR/after" || exit 1
-diff -u "$DIR/before" "$DIR/after" || fail "merged redraw differs from full redraw"
-exit 0

regress/redraw-damage-blocked-client.sh

@@ -1,140 +0,0 @@
-#!/bin/sh
-
-# One terminal stops reading while another consumes floating-pane damage.
-# The slow client must catch up after the window's shared damage is cleared.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lblocked-inner-$$ -f/dev/null"
-FAST="$TEST_TMUX -Lblocked-fast-$$ -f/dev/null"
-SLOW="$TEST_TMUX -Lblocked-slow-$$ -f/dev/null"
-STOPPED=
-cleanup()
-{
-	[ -n "$STOPPED" ] && kill -CONT "$STOPPED" 2>/dev/null
-	$FAST kill-server 2>/dev/null
-	$SLOW kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-wait_marker()
-{
-	terminal=$1
-	marker=$2
-	i=0
-	while [ "$i" -lt 100 ]; do
-		$terminal capture-pane -p >"$DIR/capture" || exit 1
-		grep -q "$marker" "$DIR/capture" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "client did not receive $marker"
-}
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$FAST send-keys -l "$sequence" || exit 1
-	sleep 0.2
-}
-cat >"$DIR/emitter.pl" <<'PERL'
-use strict;
-use warnings;
-$| = 1;
-print 'READY';
-while (!-e "$ENV{TRIGGER}-flood") {
-	select undef, undef, undef, 0.01;
-}
-my $frame = 0;
-while (!-e "$ENV{TRIGGER}-stop") {
-	my $output = '';
-	for my $row (1 .. 20) {
-		$output .= "\e[$row;1H" . join('', map { chr(33 + ($_ + $frame) % 80) } 0 .. 77);
-	}
-	print $output;
-	$frame++;
-	select undef, undef, undef, 0.01;
-}
-for my $row (1 .. 20) {
-	printf "\e[%d;1HFINAL%02d-%s", $row, $row, '0123456789' x 7;
-}
-print "\e[20;1HDONE";
-sleep 100;
-PERL
-$INNER new-session -d -s inner -x 160 -y 80 \
-    "TRIGGER='$DIR/trigger' perl '$DIR/emitter.pl'" || exit 1
-$INNER set -g status off || exit 1
-$INNER set -g window-size manual || exit 1
-$INNER set -g automatic-rename off || exit 1
-$INNER set -g status-interval 0 || exit 1
-$INNER set -g mouse on || exit 1
-$INNER set -g pane-border-lines simple || exit 1
-FLOAT=$($INNER new-pane -PF '#{pane_id}' -x 16 -y 5 -X 5 -Y 5 \
-    'printf FLOAT; exec sleep 100') || exit 1
-for terminal in "$FAST" "$SLOW"; do
-	$terminal new-session -d -x 160 -y 80 'sleep 100' || exit 1
-	$terminal set -g status off || exit 1
-	$terminal set -g window-size manual || exit 1
-	$terminal set -g default-terminal screen || exit 1
-	$terminal respawn-pane -k "$INNER attach -t inner" || exit 1
-	wait_marker "$terminal" READY
-done
-FASTCLIENT=$($FAST display -p '#{pane_tty}') || exit 1
-SLOWCLIENT=$($SLOW display -p '#{pane_tty}') || exit 1
-SLOWPID=$($SLOW display -p '#{pid}') || exit 1
-before=$($INNER display -p -c "$FASTCLIENT" '#{client_written}') || exit 1
-slowbefore=$($INNER display -p -c "$SLOWCLIENT" '#{client_written}') || exit 1
-# The large terminal keeps this backlog below the discard threshold, so
-# automatic recovery from discarded output cannot mask lost damage.
-# Stop only our outer server, leaving its inner client attached to a PTY
-# whose master is no longer read. This creates real terminal backpressure.
-STOPPED=$SLOWPID
-kill -STOP "$SLOWPID" || exit 1
-: >"$DIR/trigger-flood"
-i=0
-while :; do
-	written=$($INNER display -p -c "$SLOWCLIENT" '#{client_written}') || exit 1
-	fastwritten=$($INNER display -p -c "$FASTCLIENT" '#{client_written}') || exit 1
-	# More than a PTY can buffer has been queued for the stopped terminal,
-	# while the other terminal is still receiving the same output.
-	[ "$written" -gt "$((slowbefore + 65536))" ] &&
-	    [ "$fastwritten" -gt "$((before + 65536))" ] && break
-	[ "$i" -lt 100 ] || fail "slow client did not become blocked"
-	sleep 0.1
-	i=$((i + 1))
-done
-: >"$DIR/trigger-stop"
-wait_marker "$FAST" DONE
-[ "$($INNER display -p -c "$FASTCLIENT" '#{client_discarded}')" -eq 0 ] ||
-    fail "fast client also became blocked"
-mouse 0 12 6 M
-mouse 32 42 6 M
-mouse 0 42 6 m
-[ "$($INNER display -p -t "$FLOAT" '#{pane_left}')" -eq 36 ] || fail "pane did not move"
-$FAST capture-pane -p >"$DIR/fast-before" || exit 1
-# Ensure the fast client already restored the vacated frame.
-sed -n '6p' "$DIR/fast-before" | grep -q '^FINAL06-0123456789' ||
-    fail "fast client did not restore old footprint"
-kill -CONT "$SLOWPID" || exit 1
-STOPPED=
-wait_marker "$SLOW" DONE
-# Allow queued terminal output and deferred redraws to drain.
-sleep 0.5
-[ "$($INNER display -p -c "$SLOWCLIENT" '#{client_discarded}')" -eq 0 ] ||
-    fail "discard recovery could mask lost deferred damage"
-$SLOW capture-pane -p >"$DIR/slow-before" || exit 1
-diff -u "$DIR/fast-before" "$DIR/slow-before" || fail "slow client did not catch up"
-$INNER refresh-client -t "$FASTCLIENT" || exit 1
-sleep 0.2
-$FAST capture-pane -p >"$DIR/after" || exit 1
-diff -u "$DIR/fast-before" "$DIR/after" || fail "damage redraw differed from full redraw"
-exit 0

regress/redraw-damage-only.sh

@@ -1,112 +0,0 @@
-#!/bin/sh
-
-# Check a redraw callback which has no accompanying client redraw flags. A
-# wrapped row crossing a panned viewport cannot use the direct tty path.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Ldamage-only-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Ldamage-only-outer-$$ -f/dev/null"
-EMITTER=$DIR/emitter.pl
-TRIGGER=$DIR/trigger
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-wait_inner_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$INNER capture-pane -p -t inner:0.0 2>/dev/null |
-		    grep -q "$marker" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner pane did not contain $marker"
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-for my $row (1 .. 12) {
-	print "\e[$row;1H", 'o' x 79;
-}
-print "\e[1;1H";
-while (!-e $ENV{TRIGGER}) {
-	select undef, undef, undef, 0.01;
-}
-
-my $second = ('B' x 24) . 'DAMAGE-ONLY' . ('B' x 45);
-print "\e[5;1H", ('A' x 80), $second;
-sleep 100;
-PERL
-
-$INNER new-session -d -s inner -x 80 -y 12 \
-    "TRIGGER='$TRIGGER' perl '$EMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 12 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Ldamage-only-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_client
-$INNER refresh-client -t "$CLIENT" -R 20 || exit 1
-wait_outer_has oooooooooo
-
-: >"$TRIGGER"
-wait_inner_has DAMAGE-ONLY
-wait_outer_has DAMAGE-ONLY
-
-exit 0

regress/redraw-damage-viewports.sh

@@ -1,112 +0,0 @@
-#!/bin/sh
-
-# Moving and interactively resizing floating panes must restore both clients,
-# including a smaller client panned horizontally and vertically.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lviewports-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lviewports-outer-$$ -f/dev/null"
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t wide:0.0 -l "$sequence" || exit 1
-	sleep 0.2
-}
-assert_scene()
-{
-	# Compare what each terminal actually received with a fresh full redraw.
-	# Capture both first: refreshing one client must not repair the other.
-	for target in wide small; do
-		$OUTER capture-pane -p -t "$target:0.0" >"$DIR/$target-before" || exit 1
-	done
-	$INNER refresh-client -t "$WIDE" || exit 1
-	$INNER refresh-client -t "$SMALL" || exit 1
-	sleep 0.2
-	for target in wide small; do
-		$OUTER capture-pane -p -t "$target:0.0" >"$DIR/$target-after" || exit 1
-		diff -u "$DIR/$target-before" "$DIR/$target-after" ||
-		    fail "$1: $target client differed from a full redraw"
-	done
-}
-
-cat >"$DIR/background.pl" <<'PERL'
-$| = 1;
-for my $row (1 .. 24) {
-	printf "\e[%d;1HROW%02d-", $row, $row;
-	print '0123456789' x 7;
-}
-sleep 100;
-PERL
-$INNER new-session -d -s inner -x 80 -y 24 "perl '$DIR/background.pl'" || exit 1
-$INNER set -g status off || exit 1
-$INNER set -g window-size manual || exit 1
-$INNER set -g automatic-rename off || exit 1
-$INNER set -g status-interval 0 || exit 1
-$INNER set -g mouse on || exit 1
-$INNER set -g default-command 'sleep 100' || exit 1
-$INNER set -g pane-border-lines simple || exit 1
-$OUTER new-session -d -s wide -x 80 -y 24 'sleep 100' || exit 1
-$OUTER set -g status off || exit 1
-$OUTER set -g window-size manual || exit 1
-$OUTER set -g default-terminal screen || exit 1
-$OUTER new-session -d -s small -x 40 -y 12 'sleep 100' || exit 1
-for target in wide small; do
-	$OUTER respawn-pane -k -t "$target:0.0" "$INNER attach -t inner" || exit 1
-done
-i=0
-while [ "$($INNER list-clients | wc -l)" -ne 2 ]; do
-	[ "$i" -lt 50 ] || fail "two clients did not attach"
-	sleep 0.1
-	i=$((i + 1))
-done
-WIDE=$($OUTER display -p -t wide:0.0 '#{pane_tty}') || exit 1
-SMALL=$($OUTER display -p -t small:0.0 '#{pane_tty}') || exit 1
-$INNER refresh-client -t "$SMALL" -R 20 || exit 1
-$INNER refresh-client -t "$SMALL" -D 6 || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 16 -y 6 -X 25 -Y 9) || exit 1
-sleep 0.3
-assert_scene initial
-# Confirm that the two clients really have different viewports.
-[ "$(head -1 "$DIR/wide-before" | cut -c1-6)" = ROW01- ] || fail "wrong wide viewport"
-[ "$(head -1 "$DIR/small-before" | cut -c1-6)" != ROW01- ] || fail "small client was not panned"
-
-# Meta-drag the body using move-pane -M, including a partially clipped position.
-mouse 8 30 12 M
-mouse 40 48 15 M
-[ "$($INNER display -p -t "$FLOAT" '#{pane_left}')" -eq 44 ] || fail "Meta-drag did not move pane"
-assert_scene move-right
-mouse 40 28 10 M
-assert_scene move-back
-mouse 8 28 10 m
-
-# Ctrl-drag creates a new floating pane, then changes its size while held.
-mouse 16 52 14 M
-mouse 48 75 23 M
-NEW=$($INNER display -p '#{pane_id}') || exit 1
-[ "$NEW" != "$FLOAT" ] || fail "Ctrl-drag did not create a pane"
-[ "$($INNER display -p -t "$NEW" '#{pane_floating_flag}')" -eq 1 ] || fail "new pane is not floating"
-assert_scene create
-mouse 48 64 19 M
-[ "$($INNER display -p -t "$NEW" '#{pane_width}')" -eq 11 ] || fail "Ctrl-drag did not shrink pane"
-assert_scene shrink
-mouse 16 64 19 m
-assert_scene release
-exit 0

regress/redraw-multiclient.sh

@@ -1,186 +0,0 @@
-#!/bin/sh
-
-# Redraw a moved floating pane on both attached clients viewing the same
-# window. Window redraw work must not be consumed by only one client.
-#
-# Uses ASCII pane borders (rather than the default UTF-8 box-drawing) because
-# this test nests a real tmux client inside another tmux's pane to get a
-# genuine terminal to capture from; that nested-tmux relay has been observed
-# to mis-render a cell that previously held a multi-byte UTF-8 border
-# character being overwritten later by plain content, on the outer instance's
-# own interpretation, independent of anything the inner tmux sends. That is a
-# nested-test-harness artifact, not a real tmux bug - confirmed by replaying
-# the exact same drag sequence against a real terminal (xterm), where it
-# never reproduces. ASCII borders avoid the artifact entirely.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lredraw-multi-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lredraw-multi-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_clients()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		count=$($INNER list-clients 2>/dev/null | wc -l)
-		[ "$count" -eq 2 ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "two inner clients did not attach"
-}
-
-wait_outer_has()
-{
-	target=$1
-	marker=$2
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t "$target" >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer pane $target did not show $marker"
-}
-
-wait_float_left()
-{
-	comparison=$1
-	limit=$2
-	i=0
-	while [ "$i" -lt 50 ]; do
-		left=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-		if [ "$comparison" = gt ] && [ "$left" -gt "$limit" ]; then
-			return 0
-		fi
-		if [ "$comparison" = lt ] && [ "$left" -lt "$limit" ]; then
-			return 0
-		fi
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "floating pane did not move"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$2" "$3" "$4" "$5")
-	$OUTER send-keys -t "$1" -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-drag_float()
-{
-	target=$1
-	startcol=$2
-	startrow=$3
-	endcol=$4
-	mouse "$target" 0 "$startcol" "$startrow" M
-	mouse "$target" 32 "$endcol" "$startrow" M
-	mouse "$target" 0 "$endcol" "$startrow" m
-}
-
-assert_scene()
-{
-	target=$1
-	base=$2
-	firstcol=$3
-	lastcol=$4
-
-	$OUTER capture-pane -p -t "$target" >"$CAPTURE" || exit 1
-
-	# With ASCII (simple) borders every corner and junction is the same
-	# '+', so one rectangular floating pane always draws exactly 4 of
-	# them; more means a stale frame was left behind somewhere.
-	corners=$(grep -o '+' "$CAPTURE" | wc -l)
-	[ "$corners" -eq 4 ] ||
-	    fail "outer pane $target had $corners floating frames"
-
-	sed -n '6,11p' "$base" | cut -c"$firstcol-$lastcol" >"$DIR/want"
-	sed -n '6,11p' "$CAPTURE" | cut -c"$firstcol-$lastcol" >"$DIR/got"
-	cmp -s "$DIR/want" "$DIR/got" ||
-	    fail "outer pane $target did not restore the old floating area"
-}
-
-C="sh -c 'i=0; while [ \$i -lt 20 ]; do printf \"\\033[%d;1HBG-ROW-%02d-abcdefghijklmnopqrstuvwxyz0123456789\" \$((i + 1)) \$i; i=\$((i + 1)); done; exec sleep 100'"
-
-$INNER new-session -d -s inner -x 60 -y 20 "$C" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g default-command 'sleep 100' || exit 1
-$INNER set-option -g pane-border-lines simple || exit 1
-
-$OUTER new-session -d -s outer -x 121 -y 20 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen || exit 1
-$OUTER split-window -h -t outer:0.0 'sleep 100' || exit 1
-
-PANES=$($OUTER list-panes -t outer:0 -F '#{pane_id} #{pane_left}')
-LEFT=$(echo "$PANES" | sort -k2 -n | head -1 | cut -d' ' -f1)
-RIGHT=$(echo "$PANES" | sort -k2 -n | tail -1 | cut -d' ' -f1)
-[ -n "$LEFT" ] && [ -n "$RIGHT" ] || fail "could not find outer panes"
-
-$OUTER respawn-pane -k -t "$LEFT" \
-    "$TEST_TMUX -Lredraw-multi-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-$OUTER respawn-pane -k -t "$RIGHT" \
-    "$TEST_TMUX -Lredraw-multi-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_for_clients
-wait_outer_has "$LEFT" BG-ROW-19
-wait_outer_has "$RIGHT" BG-ROW-19
-$OUTER capture-pane -p -t "$LEFT" >"$DIR/base-left" || exit 1
-$OUTER capture-pane -p -t "$RIGHT" >"$DIR/base-right" || exit 1
-
-FLOAT=$($INNER new-pane -dPF '#{pane_id}' -x 16 -y 5 -X 5 -Y 5) ||
-    fail "could not create floating pane"
-wait_outer_has "$LEFT" '+'
-wait_outer_has "$RIGHT" '+'
-
-FTOP=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-FLEFT=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-FWIDTH=$($INNER display-message -p -t "$FLOAT" '#{pane_width}')
-GRABCOL=$((FLEFT + FWIDTH / 2 + 1))
-
-# Move right through one client and require both clients to restore the old
-# left-hand footprint.
-drag_float "$LEFT" "$GRABCOL" "$FTOP" $((GRABCOL + 30))
-wait_float_left gt 30
-assert_scene "$LEFT" "$DIR/base-left" 1 20
-assert_scene "$RIGHT" "$DIR/base-right" 1 20
-
-# Move back through the other client and check the old right-hand footprint.
-FLEFT=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-GRABCOL=$((FLEFT + FWIDTH / 2 + 1))
-drag_float "$RIGHT" "$GRABCOL" "$FTOP" $((GRABCOL - 30))
-wait_float_left lt 10
-assert_scene "$LEFT" "$DIR/base-left" 35 60
-assert_scene "$RIGHT" "$DIR/base-right" 35 60
-
-exit 0

regress/redraw-screen-write.sh

@@ -1,208 +0,0 @@
-#!/bin/sh
-
-# Check that full and region screen-write fallbacks update an attached client,
-# not only tmux's internal pane grid.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-EMITTER=$DIR/emitter.pl
-CAPTURE=$DIR/capture
-INNER=
-OUTER=
-N=0
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	[ -n "$OUTER" ] && $OUTER kill-server 2>/dev/null
-	[ -n "$INNER" ] && $INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-wait_outer_lacks()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" || return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client still showed $marker"
-}
-
-wait_inner_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$INNER capture-pane -p -t inner:0.0 2>/dev/null |
-		    grep -q "$marker" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner pane did not contain $marker"
-}
-
-wait_inner_lacks()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$INNER capture-pane -p -t inner:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" || return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner pane still contained $marker"
-}
-
-setup()
-{
-	mode=$1
-	[ -n "$OUTER" ] && $OUTER kill-server 2>/dev/null
-	[ -n "$INNER" ] && $INNER kill-server 2>/dev/null
-	N=$((N + 1))
-	INNER="$TEST_TMUX -Lredraw-write-inner-$$-$N -f/dev/null"
-	OUTER="$TEST_TMUX -Lredraw-write-outer-$$-$N -f/dev/null"
-
-	$INNER new-session -d -s inner -x 40 -y 12 \
-	    "MODE=$mode READY='$DIR/ready-$N' TRIGGER='$DIR/trigger-$N' perl '$EMITTER'" ||
-	    exit 1
-	$INNER set-option -g status off || exit 1
-	$INNER set-option -g window-size manual || exit 1
-
-	$OUTER new-session -d -s outer -x 40 -y 12 'sleep 100' || exit 1
-	$OUTER set-option -g status off || exit 1
-	$OUTER set-option -g window-size manual || exit 1
-	$OUTER set-option -g default-terminal screen || exit 1
-	$OUTER respawn-pane -k -t outer:0.0 \
-	    "$TEST_TMUX -Lredraw-write-inner-$$-$N -f/dev/null attach-session -t inner" ||
-	    exit 1
-}
-
-trigger()
-{
-	: >"$DIR/trigger-$N-${1:-1}"
-}
-
-cat >"$EMITTER" <<'PERL'
-use strict;
-use warnings;
-
-$| = 1;
-my $mode = $ENV{MODE};
-my $ready = $ENV{READY};
-my $trigger = $ENV{TRIGGER};
-
-sub fill_screen {
-	my ($prefix) = @_;
-	print "\e[2J\e[H";
-	for my $row (0 .. 11) {
-		printf "\e[%d;1H%s-ROW-%02d", $row + 1, $prefix, $row;
-	}
-}
-
-if ($mode eq 'ris') {
-	fill_screen('RIS');
-} elsif ($mode eq 'alternate') {
-	fill_screen('BASE');
-} elsif ($mode eq 'scroll') {
-	fill_screen('SCROLL');
-} else {
-	die "unknown mode $mode\n";
-}
-
-open my $fh, '>', $ready or die "$ready: $!\n";
-close $fh;
-while (!-e "$trigger-1") {
-	select undef, undef, undef, 0.01;
-}
-
-if ($mode eq 'ris') {
-	print "\ec";
-} elsif ($mode eq 'alternate') {
-	print "\e[?1049h";
-	fill_screen('ALT');
-	while (!-e "$trigger-2") {
-		select undef, undef, undef, 0.01;
-	}
-	print "\e[?1049l";
-} else {
-	print "\e[12;1H\r\nSCROLL-NEW";
-}
-sleep 100;
-PERL
-
-# RIS clears the complete screen. The source pane and attached client must both
-# lose every old row.
-setup ris
-wait_outer_has RIS-ROW-11
-trigger
-wait_inner_lacks RIS-ROW
-wait_outer_lacks RIS-ROW
-
-# Leaving the alternate screen restores every row of the base screen.
-setup alternate
-wait_outer_has BASE-ROW-11
-trigger
-wait_inner_has ALT-ROW-11
-wait_outer_has ALT-ROW-11
-wait_outer_lacks BASE-ROW
-trigger 2
-wait_inner_has BASE-ROW-11
-wait_outer_has BASE-ROW-11
-wait_outer_lacks ALT-ROW
-
-# Scrolling a pane which is narrower than the terminal redraws its complete
-# region. Check the physical client row by row after the source grid shifts.
-setup scroll
-$INNER split-window -h -t inner:0 'sleep 100' || exit 1
-wait_outer_has SCROLL-ROW-11
-trigger
-wait_inner_has SCROLL-NEW
-wait_outer_has SCROLL-NEW
-row=1
-while [ "$row" -le 11 ]; do
-	expected=$(printf 'SCROLL-ROW-%02d' "$row")
-	actual=$(sed -n "${row}p" "$CAPTURE")
-	case "$actual" in
-	"$expected"*) ;;
-	*) fail "outer row $row was not redrawn as $expected" ;;
-	esac
-	row=$((row + 1))
-done
-actual=$(sed -n '12p' "$CAPTURE")
-case "$actual" in
-SCROLL-NEW*) ;;
-*) fail "outer bottom row was not redrawn as SCROLL-NEW" ;;
-esac
-
-exit 0

regress/switch-client-redraw.sh

@@ -1,81 +0,0 @@
-#!/bin/sh
-
-# Switching windows in the same session must redraw the attached client. The
-# session object is shared, so its current winlink cannot be compared after it
-# has already been changed.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lswitch-redraw-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lswitch-redraw-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-wait_for_client()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		CLIENT=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
-		[ -n "$CLIENT" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "inner client did not attach"
-}
-
-wait_outer_has()
-{
-	marker=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		grep -q "$marker" "$CAPTURE" && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "outer client did not show $marker"
-}
-
-$INNER new-session -d -s inner -x 40 -y 8 \
-    "printf '\033[2J\033[HA-WINDOW'; exec sleep 100" || exit 1
-$INNER new-window -d -t inner:1 \
-    "printf '\033[2J\033[HB-WINDOW'; exec sleep 100" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 8 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lswitch-redraw-inner-$$ -f/dev/null attach-session -t inner:0" ||
-    exit 1
-
-wait_for_client
-wait_outer_has A-WINDOW
-
-$INNER switch-client -c "$CLIENT" -t inner:1.0 || exit 1
-[ "$($INNER display-message -p -t inner '#{window_index}')" -eq 1 ] ||
-    fail "server did not select window 1"
-wait_outer_has B-WINDOW
-
-exit 0

regress/sync-output-scroll-clients.sh

@@ -0,0 +1,123 @@
+#!/bin/sh
+
+# A scroll held back by a synchronized update may be sent to all clients while
+# a later client is being redrawn. An earlier client which cannot scroll the
+# pane itself must still end up with the right contents.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+
+INNER="$TEST_TMUX -Li$$ -f/dev/null"
+OUTER="$TEST_TMUX -Lo$$ -f/dev/null"
+CONTROL=$DIR/control
+EMITTER=$DIR/emitter.pl
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+wait_for_file()
+{
+	i=0
+	while [ "$i" -lt 50 ] && [ ! -e "$1" ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ -e "$1" ] || fail "$2"
+}
+
+wait_for_clients()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		n=$($INNER list-clients 2>/dev/null | wc -l)
+		[ "$n" -eq "$1" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "client $1 did not attach"
+}
+
+cat >"$EMITTER" <<'PERL'
+use strict;
+use warnings;
+
+my $control = $ENV{CONTROL};
+(my $dir = $control) =~ s{/[^/]+$}{};
+
+my @rows;
+for my $row (1 .. 24) {
+	push @rows, sprintf("INIT_ROW_%02d_", $row) . ('X' x 16);
+}
+syswrite STDOUT, "\e[H" . join("\r\n", @rows);
+
+open my $painted, '>', "$dir/painted" or die "$dir/painted: $!\n";
+close $painted;
+while (!-e $control) {
+	select undef, undef, undef, 0.01;
+}
+
+# Start a synchronized update and scroll, but do not end it.
+syswrite STDOUT, "\e[?2026h\e[24;1H\r\nSCROLLED_LINE_";
+open my $scrolled, '>', "$dir/scrolled" or die "$dir/scrolled: $!\n";
+close $scrolled;
+select undef, undef, undef, 3;
+PERL
+
+$INNER new-session -d -s inner -x 80 -y 24 \
+    "CONTROL='$CONTROL' perl '$EMITTER'" || exit 1
+$INNER set-option -g status off || exit 1
+$INNER set-option -g window-size manual || exit 1
+$INNER set-option -as terminal-features '*:sync' || exit 1
+
+# The pane is not full width, so clients cannot scroll it.
+$INNER split-window -h -d -t inner:0.0 'sleep 30' || exit 1
+
+for name in a b; do
+	$OUTER new-session -d -s $name -x 80 -y 24 \
+	    "$TEST_TMUX -Li$$ -f/dev/null attach-session -t inner" || exit 1
+	$OUTER set-option -t $name status off || exit 1
+	if [ "$name" = a ]; then
+		wait_for_clients 1
+	fi
+done
+$OUTER set-option -g window-size manual || exit 1
+wait_for_clients 2
+B=$($OUTER display-message -p -t b: '#{pane_tty}') || exit 1
+
+wait_for_file "$DIR/painted" "application did not paint"
+sleep 1
+: >"$CONTROL"
+wait_for_file "$DIR/scrolled" "application did not scroll"
+sleep 0.2
+
+# Redraw only the second client while the update is still in progress.
+$INNER refresh-client -t "$B" || exit 1
+sleep 1
+
+$OUTER capture-pane -p -t a: >"$DIR/a" || exit 1
+$OUTER capture-pane -p -t b: >"$DIR/b" || exit 1
+sed -n 1p "$DIR/b" | grep -q '^INIT_ROW_02_' ||
+    fail "second client not scrolled"
+sed -n 24p "$DIR/b" | grep -q '^SCROLLED_LINE_' ||
+    fail "second client missing scrolled line"
+cmp -s "$DIR/a" "$DIR/b" || fail "first client differs from second client"
+exit 0

regress/sync-output-scroll.sh

@@ -0,0 +1,150 @@
+#!/bin/sh
+
+# Check that synchronized scrolling does not redraw unchanged lines.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+
+INNER="$TEST_TMUX -Li$$ -f/dev/null"
+OUTER="$TEST_TMUX -Lo$$ -f/dev/null"
+CLIENT_BYTES=$DIR/client-bytes
+CONTROL=$DIR/control
+EMITTER=$DIR/emitter.pl
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+wait_for_file()
+{
+	i=0
+	while [ "$i" -lt 50 ] && [ ! -e "$1" ]; do
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ -e "$1" ] || fail "$2"
+}
+
+wait_for_client()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		$INNER list-clients -F '#{client_termfeatures}' 2>/dev/null |
+		    grep -q 'sync' && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "sync-capable client did not attach"
+}
+
+wait_for_stable_bytes()
+{
+	previous=-1
+	stable=0
+	i=0
+	while [ "$i" -lt 50 ]; do
+		current=$(wc -c <"$CLIENT_BYTES" 2>/dev/null) || current=0
+		if [ "$current" -gt 0 ] && [ "$current" -eq "$previous" ]; then
+			stable=$((stable + 1))
+			[ "$stable" -eq 5 ] && return 0
+		else
+			stable=0
+		fi
+		previous=$current
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "client byte stream did not become stable"
+}
+
+cat >"$EMITTER" <<'PERL'
+use strict;
+use warnings;
+
+my $control = $ENV{CONTROL};
+(my $dir = $control) =~ s{/[^/]+$}{};
+
+# Fill the screen outside a synchronized update.
+my @rows;
+for my $row (1 .. 24) {
+	push @rows, substr(sprintf("INIT_ROW_%02d_", $row) . ('X' x 79), 0, 79);
+}
+syswrite STDOUT, "\e[H" . join("\r\n", @rows);
+
+open my $painted, '>', "$dir/painted" or die "$dir/painted: $!\n";
+close $painted;
+while (!-e $control) {
+	select undef, undef, undef, 0.01;
+}
+
+# Scroll one line and overwrite text in a synchronized update.
+my $frame = "\e[?2026h" .
+    "\e[24;1H\r\nSCROLLED_LINE_" .
+    "\e[23;60HCHANGED_" .
+    "\e[?2026l";
+my $written = syswrite STDOUT, $frame;
+die "short synchronized frame write\n"
+    unless defined $written && $written == length $frame;
+select undef, undef, undef, 3;
+PERL
+
+$INNER new-session -d -s inner -x 80 -y 24 \
+    "CONTROL='$CONTROL' perl '$EMITTER'" || exit 1
+$INNER set-option -g status off || exit 1
+$INNER set-option -g window-size manual || exit 1
+$INNER set-option -as terminal-features '*:sync' || exit 1
+
+$OUTER new-session -d -s outer -x 80 -y 24 \
+    "$TEST_TMUX -Li$$ -f/dev/null attach-session -t inner" ||
+    exit 1
+$OUTER set-option -g status off || exit 1
+$OUTER set-option -g window-size manual || exit 1
+wait_for_client
+
+wait_for_file "$DIR/painted" "application did not paint"
+sleep 1
+$OUTER pipe-pane -O -t outer:0.0 "cat >'$CLIENT_BYTES'" || exit 1
+: >"$CONTROL"
+i=0
+while [ "$i" -lt 50 ]; do
+	grep -q 'SCROLLED_LINE_' "$CLIENT_BYTES" 2>/dev/null && break
+	sleep 0.1
+	i=$((i + 1))
+done
+grep -q 'SCROLLED_LINE_' "$CLIENT_BYTES" || fail "scrolled line not sent"
+wait_for_stable_bytes
+$OUTER pipe-pane -t outer:0.0 || exit 1
+
+# Check that only changed lines are redrawn.
+grep -q 'CHANGED_' "$CLIENT_BYTES" || fail "changed cell not sent"
+if grep -q 'INIT_ROW_05_' "$CLIENT_BYTES"; then
+	fail "unchanged line redrawn after synchronized scroll"
+fi
+
+# The client must show the scrolled screen.
+$OUTER capture-pane -p -t outer:0.0 >"$DIR/screen" || exit 1
+sed -n 1p "$DIR/screen" | grep -q '^INIT_ROW_02_' ||
+    fail "first line not scrolled"
+sed -n 23p "$DIR/screen" | grep -q 'INIT_ROW_24_.*CHANGED_' ||
+    fail "changed cell not on screen"
+sed -n 24p "$DIR/screen" | grep -q '^SCROLLED_LINE_' ||
+    fail "scrolled line not on screen"
+exit 0

regress/tty-margins-scrollbar.sh

@@ -1,93 +0,0 @@
-#!/bin/sh
-
-# With left/right margins, a pane narrowed by a scrollbar can scroll without
-# retransmitting its existing rows. Both paths must produce the same screen.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lmarginsscrollbar-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lmarginsscrollbar-outer-$$ -f/dev/null"
-
-fail()
-{
-	echo "$*" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-cat >"$DIR/emitter.pl" <<'PERL'
-use strict;
-use warnings;
-$| = 1;
-print join("\r\n", map { "KEEP0$_" } 1 .. 6);
-while (!-e $ENV{TRIGGER}) {
-	select undef, undef, undef, 0.01;
-}
-print "\r\nNEWROW";
-sleep 100;
-PERL
-
-for margins in on off; do
-	$INNER new-session -d -s inner -x 40 -y 6 \
-	    "TRIGGER='$DIR/trigger-$margins' perl '$DIR/emitter.pl'" || exit 1
-	$INNER set -g status off || exit 1
-	$INNER set -g status-interval 0 || exit 1
-	$INNER set -g automatic-rename off || exit 1
-	$INNER set -g window-size manual || exit 1
-	$INNER set -g pane-scrollbars on || exit 1
-	if [ "$margins" = on ]; then
-		$INNER set -as terminal-features ',screen-256color:margins' || exit 1
-	fi
-
-	$OUTER new-session -d -s outer -x 40 -y 6 'sleep 100' || exit 1
-	$OUTER set -g status off || exit 1
-	$OUTER set -g window-size manual || exit 1
-	$OUTER set -g default-terminal screen-256color || exit 1
-	$OUTER respawn-pane -k -t outer:0.0 "$INNER attach -t inner" || exit 1
-	sleep 0.5
-	$OUTER pipe-pane -O -t outer:0.0 "cat >'$DIR/output-$margins'" || exit 1
-	$INNER refresh-client || exit 1
-	sleep 0.5
-	grep -aq KEEP02 "$DIR/output-$margins" || fail "initial rows not captured"
-	offset=$(wc -c <"$DIR/output-$margins")
-	: >"$DIR/trigger-$margins"
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$DIR/screen-$margins" || exit 1
-		grep -q NEWROW "$DIR/screen-$margins" && break
-		sleep 0.1
-		i=$((i + 1))
-	done
-	[ "$i" -lt 50 ] || fail "$margins: scroll did not reach the terminal"
-	sleep 0.2
-	tail -c +"$((offset + 1))" "$DIR/output-$margins" >"$DIR/scroll-$margins"
-	grep -aq NEWROW "$DIR/scroll-$margins" || fail "scroll output not captured"
-	if [ "$margins" = on ]; then
-		if grep -aq KEEP02 "$DIR/scroll-$margins"; then
-			fail "scroll with margins retransmitted an existing row"
-		fi
-	else
-		grep -aq KEEP02 "$DIR/scroll-$margins" ||
-		    fail "scroll without margins did not exercise the redraw fallback"
-	fi
-	printf 'KEEP02\nKEEP03\nKEEP04\nKEEP05\nKEEP06\nNEWROW\n' >"$DIR/expected"
-	cmp -s "$DIR/expected" "$DIR/screen-$margins" ||
-	    fail "$margins: terminal did not contain the expected scrolled rows"
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-done
-
-exit 0

regress/window-copy-scrollbar-drag-focus-style.sh

@@ -1,123 +0,0 @@
-#!/bin/sh
-
-# Dragging an inactive pane's scrollbar slider changes which pane is
-# active (window_copy_scroll(), window-copy.c). Every other place in the
-# codebase that changes the active pane pairs it with
-# window_redraw_active_switch() (or falls back to a full window redraw) so
-# the old/new active panes' window-active-style/window-style colours get
-# repainted - window_copy_scroll() was the one caller that did neither, so
-# a scrollbar-slider drag changed focus but left both panes' body colours
-# stale. This used to be masked by window_set_active_pane() itself doing
-# an unconditional full redraw on every active-pane change, until that was
-# narrowed to borders/status-only for the common case.
-#
-# This creates two tiled panes with clearly distinguishable
-# window-active-style/window-style backgrounds, puts the *inactive* one in
-# copy mode, drags its scrollbar slider, and checks - via an attached
-# client's own received bytes, since window-style is applied during
-# redraw composition rather than stored in the grid, so capture-pane
-# alone would not reflect it - that the newly active pane's marker text
-# immediately shows the active-style colour, not the stale one.
-
-PATH=/bin:/usr/bin
-TERM=screen
-LC_ALL=C.UTF-8
-export PATH TERM LC_ALL
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-
-DIR=$(mktemp -d) || exit 1
-INNER="$TEST_TMUX -Lsbfocus-inner-$$ -f/dev/null"
-OUTER="$TEST_TMUX -Lsbfocus-outer-$$ -f/dev/null"
-CAPTURE=$DIR/capture
-ESC=$(printf '\033')
-
-fail()
-{
-	echo "$*" >&2
-	[ -s "$CAPTURE" ] && cat -A "$CAPTURE" >&2
-	exit 1
-}
-
-cleanup()
-{
-	$OUTER kill-server 2>/dev/null
-	$INNER kill-server 2>/dev/null
-	rm -rf "$DIR"
-}
-trap cleanup 0 1 15
-
-get_mark_color()
-{
-	$OUTER capture-pane -e -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-	LC_ALL=C grep -a "MARK1" "$CAPTURE" |
-	    LC_ALL=C grep -aoE "${ESC}\[4[12]m" | tail -1
-}
-
-wait_mark_color()
-{
-	want=$1
-	i=0
-	while [ "$i" -lt 50 ]; do
-		[ "$(get_mark_color)" = "$want" ] && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "MARK1's pane never showed the expected background (wanted '$want', got '$(get_mark_color)')"
-}
-
-mouse()
-{
-	sequence=$(printf '\033[<%s;%s;%s%s' "$1" "$2" "$3" "$4")
-	$OUTER send-keys -t outer:0.0 -l "$sequence" || exit 1
-	sleep 0.1
-}
-
-$INNER new-session -d -s inner -x 40 -y 10 'sleep 100' || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g mouse on || exit 1
-$INNER set-option -g pane-scrollbars on || exit 1
-$INNER setw pane-scrollbars-position right || exit 1
-$INNER setw pane-scrollbars-style 'width=1,pad=0' || exit 1
-$INNER set-option -g window-active-style 'bg=red' || exit 1
-$INNER set-option -g window-style 'bg=green' || exit 1
-$INNER split-window -h -t inner -d 'printf MARK1; sleep 100' || exit 1
-
-PANE1=$($INNER list-panes -t inner -F '#{pane_id}' | sed -n 2p)
-[ "$($INNER display-message -p -t "$PANE1" '#{pane_active}')" = 0 ] ||
-	fail "sanity: MARK1's pane is already active before the drag"
-
-# Put the inactive pane in copy mode without switching focus (copy-mode -t
-# targets a pane without making it active).
-$INNER copy-mode -t "$PANE1" || exit 1
-
-$OUTER new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER set-option -g status off || exit 1
-$OUTER set-option -g window-size manual || exit 1
-$OUTER set-option -g default-terminal screen-256color || exit 1
-$OUTER respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lsbfocus-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-
-wait_mark_color "${ESC}[42m"
-
-XOFF=$($INNER display-message -p -t "$PANE1" '#{pane_left}')
-YOFF=$($INNER display-message -p -t "$PANE1" '#{pane_top}')
-SX=$($INNER display-message -p -t "$PANE1" '#{pane_width}')
-SBCOL=$((XOFF + SX + 1))
-SBROW=$((YOFF + 1))
-
-# With no scrollback beyond the pane's own content, the slider fills the
-# whole scrollbar track, so any point on it (here, its very first row) is
-# on the slider.
-mouse 0 "$SBCOL" "$SBROW" M
-mouse 32 "$SBCOL" "$((SBROW + 1))" M
-mouse 0 "$SBCOL" "$((SBROW + 1))" m
-
-[ "$($INNER display-message -p -t "$PANE1" '#{pane_active}')" = 1 ] ||
-	fail "sanity: dragging the scrollbar slider did not change focus"
-
-wait_mark_color "${ESC}[41m"
-
-exit 0

screen-redraw.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: screen-redraw.c,v 1.161 2026/09/22 16:56:07 nicm Exp $ */
+/* $OpenBSD: screen-redraw.c,v 1.162 2026/09/24 11:19:39 nicm Exp $ */
 
 /*
  * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -204,36 +204,14 @@ struct redraw_scene {
 	u_int			 oy;
 };
 
-/* A damaged rectangle in a window. */
-struct redraw_damage {
-	u_int				 x;
-	u_int				 y;
-	u_int				 sx;
-	u_int				 sy;
-
-	TAILQ_ENTRY(redraw_damage)	entry;
-};
-
-/*
- * If there are more damage rectangles than this, they are collapsed into
- * one.
- */
-#define REDRAW_DAMAGE_MAX 16
-
 /* Cell for building the scene. */
 struct redraw_build_cell {
 	struct redraw_span_data	 data;
 };
+
 static struct redraw_build_cell	*redraw_cells;
 static size_t			 redraw_ncells;
 
-/*
- * We can reuse the same pane status lines during one damage redraw, but when
- * we enter a new one, the client or format variables may have changed, so we
- * need to make them again. The generation is increased so this happens.
- */
-static u_int	redraw_status_generation;
-
 /* Context for building the scene. */
 struct redraw_build_ctx {
 	struct client				*c;
@@ -1076,13 +1054,6 @@ redraw_free_scene(struct redraw_scene *scene)
 	free(scene);
 }
 
-/* Does a client's cached scene show this window? */
-int
-redraw_client_has_window(struct client *c, struct window *w)
-{
-	return (c->redraw_scene != NULL && c->redraw_scene->w == w);
-}
-
 /* Mark a window's cached redraw scenes as out of date. */
 void
 redraw_invalidate_scene(struct window *w)
@@ -1090,104 +1061,6 @@ redraw_invalidate_scene(struct window *w)
 	w->redraw_scene_generation++;
 }
 
-/* Free all pending damage for a window. */
-void
-redraw_free_damage(struct window *w)
-{
-	struct redraw_damage	*rd, *rd1;
-
-	TAILQ_FOREACH_SAFE(rd, &w->damage, entry, rd1) {
-		TAILQ_REMOVE(&w->damage, rd, entry);
-		free(rd);
-	}
-	w->damage_count = 0;
-}
-
-/* Collapse all pending damage for a window into one rectangle. */
-static void
-redraw_collapse_damage(struct window *w)
-{
-	struct redraw_damage	*rd, *rd1, *first;
-	u_int			 x0, y0, x1, y1;
-
-	first = TAILQ_FIRST(&w->damage);
-	if (first == NULL)
-		return;
-	x0 = first->x;
-	y0 = first->y;
-	x1 = first->x + first->sx;
-	y1 = first->y + first->sy;
-
-	TAILQ_FOREACH_SAFE(rd, &w->damage, entry, rd1) {
-		if (rd->x < x0)
-			x0 = rd->x;
-		if (rd->y < y0)
-			y0 = rd->y;
-		if (rd->x + rd->sx > x1)
-			x1 = rd->x + rd->sx;
-		if (rd->y + rd->sy > y1)
-			y1 = rd->y + rd->sy;
-		if (rd != first) {
-			TAILQ_REMOVE(&w->damage, rd, entry);
-			free(rd);
-		}
-	}
-
-	first->x = x0;
-	first->y = y0;
-	first->sx = x1 - x0;
-	first->sy = y1 - y0;
-	w->damage_count = 1;
-}
-
-/* Record window damage, merging nearby rectangles and limiting the count. */
-void
-redraw_damage_window(struct window *w, u_int x, u_int y, u_int sx, u_int sy)
-{
-	struct redraw_damage	*rd;
-	u_int			 x0, y0, x1, y1, area, union_area;
-
-	if (x >= w->sx || y >= w->sy)
-		return;
-	if (x + sx > w->sx)
-		sx = w->sx - x;
-	if (y + sy > w->sy)
-		sy = w->sy - y;
-	if (sx == 0 || sy == 0)
-		return;
-
-	TAILQ_FOREACH(rd, &w->damage, entry) {
-		if (x > rd->x + rd->sx || rd->x > x + sx ||
-		    y > rd->y + rd->sy || rd->y > y + sy)
-			continue;
-
-		x0 = (x < rd->x) ? x : rd->x;
-		y0 = (y < rd->y) ? y : rd->y;
-		x1 = (x + sx > rd->x + rd->sx) ? x + sx : rd->x + rd->sx;
-		y1 = (y + sy > rd->y + rd->sy) ? y + sy : rd->y + rd->sy;
-
-		area = sx * sy + rd->sx * rd->sy;
-		union_area = (x1 - x0) * (y1 - y0);
-		if (union_area > 2 * area)
-			continue;
-
-		rd->x = x0;
-		rd->y = y0;
-		rd->sx = x1 - x0;
-		rd->sy = y1 - y0;
-		return;
-	}
-
-	rd = xcalloc(1, sizeof *rd);
-	rd->x = x;
-	rd->y = y;
-	rd->sx = sx;
-	rd->sy = sy;
-	TAILQ_INSERT_TAIL(&w->damage, rd, entry);
-	if (++w->damage_count > REDRAW_DAMAGE_MAX)
-		redraw_collapse_damage(w);
-}
-
 /* Mark all cached redraw scenes as out of date. */
 void
 redraw_invalidate_all_scenes(void)
@@ -1730,24 +1603,6 @@ redraw_set_draw_context(struct redraw_draw_ctx *dctx,
 		dctx->flags |= REDRAW_ISOLATES;
 }
 
-/* Build a pane prompt. */
-static void
-redraw_make_pane_prompt(struct window_pane *wp, struct screen *screen)
-{
-	struct screen_write_ctx	 ctx;
-	struct prompt_draw_data	 pdd;
-
-	screen_init(screen, wp->sx, 1, 0);
-	screen_write_start(&ctx, screen);
-	pdd.ctx = &ctx;
-	pdd.cursor_x = &wp->prompt_cx;
-	pdd.area_x = 0;
-	pdd.area_width = wp->sx;
-	pdd.prompt_line = 0;
-	prompt_draw(wp->prompt, &pdd);
-	screen_write_stop(&ctx);
-}
-
 /* Draw a pane's prompt over its content. */
 static void
 redraw_draw_pane_prompt(struct redraw_draw_ctx *dctx, struct window_pane *wp)
@@ -1756,6 +1611,8 @@ redraw_draw_pane_prompt(struct redraw_draw_ctx *dctx, struct window_pane *wp)
 	struct client		*c = scene->c;
 	struct tty		*tty = &c->tty;
 	struct screen		 screen;
+	struct screen_write_ctx	 ctx;
+	struct prompt_draw_data	 pdd;
 	int			 ox = scene->ox, oy = scene->oy;
 	int			 sx = scene->sx, sy = scene->sy;
 	int			 line, cy, px, offset, width, wy;
@@ -1788,7 +1645,16 @@ redraw_draw_pane_prompt(struct redraw_draw_ctx *dctx, struct window_pane *wp)
 	if (px + width > sx)
 		width = sx - px;
 
-	redraw_make_pane_prompt(wp, &screen);
+	screen_init(&screen, wp->sx, 1, 0);
+	screen_write_start(&ctx, &screen);
+	pdd.ctx = &ctx;
+	pdd.cursor_x = &wp->prompt_cx;
+	pdd.area_x = 0;
+	pdd.area_width = wp->sx;
+	pdd.prompt_line = 0;
+	prompt_draw(wp->prompt, &pdd);
+	screen_write_stop(&ctx);
+
 	tty_draw_line(tty, &screen, offset, 0, width, px, cy, NULL);
 	screen_free(&screen);
 }
@@ -1818,9 +1684,7 @@ redraw_draw(struct client *c, struct window_pane *wp, int flags)
 			redraw = status_prompt_redraw(c);
 		else
 			redraw = status_redraw(c);
-		if (!redraw &&
-		    (~c->flags & CLIENT_REDRAWSTATUSALWAYS) &&
-		    !REDRAW_IS_ALL(flags)) {
+		if (!redraw && !REDRAW_IS_ALL(flags)) {
 			flags &= ~REDRAW_STATUS;
 			if (flags == 0)
 				return;
@@ -1874,14 +1738,14 @@ redraw_draw(struct client *c, struct window_pane *wp, int flags)
 		if (wp != NULL) {
 			if (wp->base.mode & MODE_SYNC)
 				screen_write_stop_sync(wp);
-			screen_write_clear_dirty(wp);
+			screen_write_sync_clear_dirty(wp);
 		} else {
 			TAILQ_FOREACH(loop, &scene->w->panes, entry) {
 				if (!window_pane_is_visible(loop))
 					continue;
 				if (loop->base.mode & MODE_SYNC)
 					screen_write_stop_sync(loop);
-				screen_write_clear_dirty(loop);
+				screen_write_sync_clear_dirty(loop);
 			}
 		}
 	}
@@ -1978,7 +1842,7 @@ redraw_screen(struct client *c)
 	else {
 		if (c->flags & CLIENT_REDRAWBORDERS)
 			flags |= (REDRAW_PANE_BORDER|REDRAW_PANE_STATUS);
-		if (c->flags & (CLIENT_REDRAWSTATUS|CLIENT_REDRAWSTATUSALWAYS))
+		if (c->flags & CLIENT_REDRAWSTATUS)
 			flags |= (REDRAW_STATUS|REDRAW_PANE_STATUS);
 		if (c->flags & CLIENT_REDRAWMENU)
 			flags |= REDRAW_MENU;
@@ -2004,138 +1868,3 @@ redraw_pane_scrollbar(struct client *c, struct window_pane *wp)
 {
 	redraw_draw(c, wp, REDRAW_PANE_SCROLLBAR);
 }
-
-/* Rebuild damaged pane status. */
-static void
-redraw_damage_refresh_status(struct redraw_draw_ctx *dctx,
-    struct window_pane *wp)
-{
-	struct redraw_span	*first;
-	u_int			 g = wp->status_generation, width;
-
-	if ((wp->flags & PANE_NEWSTATUS) && g == redraw_status_generation)
-		return;
-	width = redraw_pane_status_width(dctx, wp, &first);
-	if (width != 0) {
-		window_make_pane_status(wp, dctx->scene->c, width, first);
-		wp->flags |= PANE_NEWSTATUS;
-		wp->status_generation = redraw_status_generation;
-	}
-}
-
-/* Draw a pane's prompt over a damaged span. */
-static void
-redraw_damage_draw_pane_prompt(struct redraw_draw_ctx *dctx,
-    struct redraw_span *span, u_int y)
-{
-	struct redraw_scene	*scene = dctx->scene;
-	struct window_pane	*wp = span->data.p.wp;
-	struct tty		*tty = &scene->c->tty;
-	struct screen		 screen;
-	u_int			 px = span->data.p.px, width, prompt_y;
-
-	if (wp->prompt == NULL || wp->sx == 0 || wp->sy == 0)
-		return;
-	if (dctx->flags & REDRAW_STATUS_TOP)
-		prompt_y = 0;
-	else
-		prompt_y = wp->sy - 1;
-	if (span->data.p.py != prompt_y)
-		return;
-	redraw_make_pane_prompt(wp, &screen);
-	if (px < screen_size_x(&screen)) {
-		width = span->width;
-		if (width > screen_size_x(&screen) - px)
-			width = screen_size_x(&screen) - px;
-		tty_draw_line(tty, &screen, px, 0, width, span->x, y, NULL);
-	}
-	screen_free(&screen);
-}
-
-/* Draw the spans intersecting a damaged rectangle. */
-static void
-redraw_draw_damage_rectangle(struct redraw_draw_ctx *dctx, u_int x, u_int y,
-    u_int sx, u_int sy)
-{
-	struct redraw_scene	*scene = dctx->scene;
-	struct redraw_line	*line;
-	struct redraw_spans	*spans;
-	struct redraw_span	*span;
-	u_int			 cy, yy, type;
-
-	if (x >= scene->sx || y >= scene->sy)
-		return;
-	if (x + sx > scene->sx)
-		sx = scene->sx - x;
-	if (y + sy > scene->sy)
-		sy = scene->sy - y;
-	if (sx == 0 || sy == 0)
-		return;
-
-	for (yy = y; yy < y + sy; yy++) {
-		line = &scene->lines[yy];
-		if (dctx->flags & REDRAW_STATUS_TOP)
-			cy = dctx->status_lines + yy;
-		else
-			cy = yy;
-		for (type = 0; type < REDRAW_SPAN_TYPES; type++) {
-			spans = &line->spans[type];
-			TAILQ_FOREACH(span, spans, entry) {
-				if (span->x >= x + sx)
-					continue;
-				if (span->x + span->width <= x)
-					continue;
-				if (type == REDRAW_SPAN_STATUS) {
-					redraw_damage_refresh_status(dctx,
-					    span->data.st.wp);
-				}
-				redraw_draw_span(dctx, span, cy);
-				if (type == REDRAW_SPAN_PANE) {
-					redraw_damage_draw_pane_prompt(dctx,
-					    span, cy);
-				}
-			}
-		}
-	}
-}
-
-/* Draw pending window damage on this client. */
-void
-redraw_client_damage(struct client *c)
-{
-	struct window		*w = c->session->curw->window;
-	struct window_pane	*wp;
-	struct redraw_scene	*scene;
-	struct redraw_draw_ctx	 dctx;
-	struct redraw_damage	*rd;
-	u_int			 ox, oy, sx, sy, x0, y0, x1, y1;
-
-	if (TAILQ_EMPTY(&w->damage))
-		return;
-	redraw_status_generation++;
-
-	scene = redraw_get_scene(c);
-	if (scene == NULL)
-		return;
-	redraw_set_draw_context(&dctx, scene);
-	redraw_get_window_offset(c, &ox, &oy, &sx, &sy);
-
-	TAILQ_FOREACH(wp, &w->panes, entry) {
-		wp->border_gc_set = 0;
-		wp->active_border_gc_set = 0;
-	}
-
-	tty_sync_start(&c->tty);
-	tty_update_mode(&c->tty, c->tty.mode & ~CURSOR_MODES, NULL);
-
-	TAILQ_FOREACH(rd, &w->damage, entry) {
-		x0 = (rd->x > ox) ? rd->x : ox;
-		y0 = (rd->y > oy) ? rd->y : oy;
-		x1 = (rd->x + rd->sx < ox + sx) ? rd->x + rd->sx : ox + sx;
-		y1 = (rd->y + rd->sy < oy + sy) ? rd->y + rd->sy : oy + sy;
-		if (x0 < x1 && y0 < y1) {
-			redraw_draw_damage_rectangle(&dctx, x0 - ox, y0 - oy,
-			    x1 - x0, y1 - y0);
-		}
-	}
-}

screen-write.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: screen-write.c,v 1.292 2026/09/21 12:14:32 nicm Exp $ */
+/* $OpenBSD: screen-write.c,v 1.293 2026/09/24 11:19:39 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -38,7 +38,9 @@ static int	screen_write_overwrite(struct screen_write_ctx *,
 		    struct grid_cell *, u_int);
 static int	screen_write_combine(struct screen_write_ctx *,
 		    const struct grid_cell *);
-static void	screen_write_flush_dirty(struct window_pane *);
+static void	screen_write_sync_flush_dirty(struct window_pane *);
+static void	screen_write_sync_apply_scroll(struct screen_write_ctx *,
+		    struct tty_ctx *);
 
 struct screen_write_citem {
 	u_int				x;
@@ -120,26 +122,14 @@ screen_write_set_cursor(struct screen_write_ctx *ctx, int cx, int cy)
 		evtimer_add(&w->offset_timer, &tv);
 }
 
-/* Redraw lines. */
+/* Do a full redraw. */
 static void
-screen_write_redraw_cb(const struct tty_ctx *ttyctx, u_int py, u_int ny)
+screen_write_redraw_cb(const struct tty_ctx *ttyctx)
 {
 	struct window_pane	*wp = ttyctx->arg;
-	int			 x0, y0, x1, y1;
 
-	if (wp == NULL)
-		return;
-
-	x0 = wp->xoff;
-	y0 = wp->yoff + (int)py;
-	x1 = x0 + (int)wp->sx;
-	y1 = y0 + (int)ny;
-	if (x0 < 0)
-		x0 = 0;
-	if (y0 < 0)
-		y0 = 0;
-	if (x1 > x0 && y1 > y0)
-		redraw_damage_window(wp->window, x0, y0, x1 - x0, y1 - y0);
+	if (wp != NULL)
+		wp->flags |= PANE_REDRAW;
 }
 
 /* Update context for client. */
@@ -227,6 +217,27 @@ screen_write_pane_is_obscured(struct screen_write_ctx *ctx)
 	return (0);
 }
 
+/* Allocate dirty lines for this screen size. */
+static bitstr_t *
+screen_write_sync_allocate_dirty(struct window_pane *wp, u_int sy)
+{
+	bitstr_t	*bs = wp->sync_dirty;
+
+	if (bs != NULL && wp->sync_dirty_size == sy)
+		return (bs);
+
+	free(bs);
+	bs = wp->sync_dirty = bit_alloc(sy);
+	if (bs == NULL)
+		fatal("bit_alloc failed");
+	if (wp->sync_dirty_size != 0) {
+		bit_nset(bs, 0, sy - 1);
+		wp->sync_scrolled = 0;
+	}
+	wp->sync_dirty_size = sy;
+	return (bs);
+}
+
 /* Should we draw to the TTY? */
 static int
 screen_write_should_draw_lines(struct screen_write_ctx *ctx, u_int y, u_int ny)
@@ -240,21 +251,9 @@ screen_write_should_draw_lines(struct screen_write_ctx *ctx, u_int y, u_int ny)
 		return (0);
 	if (s->mode & MODE_SYNC) {
 		if (wp != NULL && y < sy && ny != 0) {
-			bs = wp->sync_dirty;
 			if (ny > sy - y)
 				ny = sy - y;
-			if (bs == NULL || wp->sync_dirty_size != sy) {
-				if (bs != NULL && wp->sync_dirty_size != sy) {
-					y = 0;
-					ny = sy;
-				}
-				free(bs);
-
-				bs = wp->sync_dirty = bit_alloc(sy);
-				if (bs == NULL)
-					fatal("bit_alloc failed");
-				wp->sync_dirty_size = sy;
-			}
+			bs = screen_write_sync_allocate_dirty(wp, sy);
 			bit_nset(bs, y, y + ny - 1);
 		}
 		return (0);
@@ -1044,7 +1043,7 @@ screen_write_sync_callback(__unused int fd, __unused short events, void *arg)
 
 	if (wp->base.mode & MODE_SYNC) {
 		wp->base.mode &= ~MODE_SYNC;
-		screen_write_flush_dirty(wp);
+		screen_write_sync_flush_dirty(wp);
 	}
 }
 
@@ -1076,7 +1075,7 @@ screen_write_stop_sync(struct window_pane *wp)
 		evtimer_del(&wp->sync_timer);
 	wp->base.mode &= ~MODE_SYNC;
 
-	screen_write_flush_dirty(wp);
+	screen_write_sync_flush_dirty(wp);
 
 	log_debug("%s: %%%u stopped sync mode", __func__, wp->id);
 }
@@ -1284,7 +1283,7 @@ screen_write_redraw_line(struct screen_write_ctx *ctx, struct tty_ctx *ttyctx,
 
 /* Redraw dirty lines. */
 static void
-screen_write_flush_dirty(struct window_pane *wp)
+screen_write_sync_flush_dirty(struct window_pane *wp)
 {
 	struct screen_write_ctx	 ctx;
 	struct tty_ctx		 ttyctx;
@@ -1297,29 +1296,143 @@ screen_write_flush_dirty(struct window_pane *wp)
 	screen_write_start_pane(&ctx, wp, s);
 	screen_write_initctx(&ctx, &ttyctx, 1, 1);
 
-	for (y = 0; y < sy; y++) {
-		if (bit_test(wp->sync_dirty, y)) {
-			screen_write_redraw_line(&ctx, &ttyctx, y);
-			lines++;
+	if (wp->sync_scrolled != 0)
+		screen_write_sync_apply_scroll(&ctx, &ttyctx);
+
+	if (~wp->flags & PANE_REDRAW) {
+		for (y = 0; y < sy; y++) {
+			if (bit_test(wp->sync_dirty, y)) {
+				screen_write_redraw_line(&ctx, &ttyctx, y);
+				lines++;
+			}
 		}
 	}
 	log_debug("%s: %%%u had %u dirty lines", __func__, wp->id, lines);
 
 	screen_write_stop(&ctx);
-	screen_write_clear_dirty(wp);
+	screen_write_sync_clear_dirty(wp);
 }
 
-/* Clear any dirty lines. */
+/* Clear pending synchronized output. */
 void
-screen_write_clear_dirty(struct window_pane *wp)
+screen_write_sync_clear_dirty(struct window_pane *wp)
 {
-	if (wp != NULL && wp->sync_dirty != NULL) {
+	if (wp != NULL) {
 		free(wp->sync_dirty);
 		wp->sync_dirty = NULL;
 		wp->sync_dirty_size = 0;
+		wp->sync_scrolled = 0;
 	}
 }
 
+/* Defer scrolling until the synchronized update ends. */
+static void
+screen_write_sync_scroll_dirty(struct screen_write_ctx *ctx)
+{
+	struct window_pane	*wp = ctx->wp;
+	struct screen		*s = ctx->s;
+	u_int			 n = ctx->scrolled, y, sy = screen_size_y(s);
+	u_int			 ry = s->rlower + 1 - s->rupper;
+	bitstr_t		*bs;
+
+	if (n > ry)
+		n = ry;
+	if (wp == NULL ||
+	    n == ry ||
+	    s->rlower >= sy ||
+	    window_pane_scrollbar_overlay_visible(wp)) {
+		screen_write_should_draw_lines(ctx, s->rupper, ry);
+		return;
+	}
+	if (wp->flags & (PANE_REDRAW|PANE_DROP))
+		return;
+	bs = screen_write_sync_allocate_dirty(wp, sy);
+
+	if (wp->sync_scrolled != 0 &&
+	    (wp->sync_rupper != s->rupper ||
+	    wp->sync_rlower != s->rlower ||
+	    wp->sync_bg != ctx->bg)) {
+		log_debug("%s: %%%u region changed, redrawing all", __func__,
+		    wp->id);
+		bit_nset(bs, 0, sy - 1);
+		wp->sync_scrolled = 0;
+		return;
+	}
+
+	/* Keep dirty lines aligned with the scrolled grid. */
+	for (y = s->rupper; y + n <= s->rlower; y++) {
+		if (bit_test(bs, y + n))
+			bit_set(bs, y);
+		else
+			bit_clear(bs, y);
+	}
+	bit_nset(bs, s->rlower + 1 - n, s->rlower);
+
+	wp->sync_rupper = s->rupper;
+	wp->sync_rlower = s->rlower;
+	wp->sync_bg = ctx->bg;
+	wp->sync_scrolled += n;
+	if (wp->sync_scrolled >= ry) {
+		bit_nset(bs, s->rupper, s->rlower);
+		wp->sync_scrolled = 0;
+	}
+	window_pane_scrollbar_redraw(wp);
+
+	log_debug("%s: %%%u deferred scroll of %u (region %u-%u)", __func__,
+	    wp->id, wp->sync_scrolled, s->rupper, s->rlower);
+}
+
+/* Redraw the scrolled lines for a client which cannot scroll them. */
+static void
+screen_write_sync_redraw_cb(const struct tty_ctx *ttyctx)
+{
+	struct window_pane	*wp = ttyctx->arg;
+
+	bit_nset(wp->sync_dirty, wp->sync_rupper, wp->sync_rlower);
+}
+
+/* Send the deferred scroll to the client. */
+static void
+screen_write_sync_apply_scroll(struct screen_write_ctx *ctx,
+    struct tty_ctx *ttyctx)
+{
+	struct window_pane	*wp = ctx->wp;
+	struct screen		*s = ctx->s;
+	u_int			 sy = screen_size_y(s), n = wp->sync_scrolled;
+	tty_ctx_redraw_cb	 redraw_cb;
+
+	wp->sync_scrolled = 0;
+	if (wp->flags & PANE_REDRAW)
+		return;
+	if (wp->sync_rlower >= sy || wp->sync_rupper > wp->sync_rlower) {
+		bit_nset(wp->sync_dirty, 0, sy - 1);
+		return;
+	}
+	if ((ttyctx->flags & TTY_CTX_PANE_OBSCURED) ||
+	    window_pane_scrollbar_overlay_visible(wp)) {
+		bit_nset(wp->sync_dirty, wp->sync_rupper, wp->sync_rlower);
+		return;
+	}
+
+	log_debug("%s: %%%u scroll of %u (region %u-%u)", __func__, wp->id, n,
+	    wp->sync_rupper, wp->sync_rlower);
+
+	ttyctx->orupper = wp->sync_rupper;
+	ttyctx->orlower = wp->sync_rlower;
+	if (wp->yoff + wp->sy > wp->window->sy)
+		ttyctx->orlower -= (wp->yoff + wp->sy - wp->window->sy);
+	ttyctx->n = n;
+	ttyctx->bg = wp->sync_bg;
+	redraw_cb = ttyctx->redraw_cb;
+	ttyctx->redraw_cb = screen_write_sync_redraw_cb;
+	tty_write(tty_cmd_scrollup, ttyctx);
+
+	ttyctx->redraw_cb = redraw_cb;
+	ttyctx->orupper = s->rupper;
+	ttyctx->orlower = s->rlower;
+	ttyctx->n = 0;
+}
+
 /* Redraw all visible cells in a pane. */
 static void
 screen_write_redraw_pane(struct screen_write_ctx *ctx, struct tty_ctx *ttyctx)
@@ -2167,7 +2280,7 @@ screen_write_fullredraw(struct screen_write_ctx *ctx)
 
 	screen_write_initctx(ctx, &ttyctx, 1, 0);
 	if (ttyctx.redraw_cb != NULL)
-		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
+		ttyctx.redraw_cb(&ttyctx);
 }
 
 /* Trim collected items. */
@@ -2439,10 +2552,8 @@ screen_write_collect_flush(struct screen_write_ctx *ctx, int scroll_only,
 	if (wp != NULL && (wp->flags & (PANE_REDRAW|PANE_DROP)))
 		goto discard;
 	if (s->mode & MODE_SYNC) {
-		if (ctx->scrolled != 0) {
-			screen_write_should_draw_lines(ctx, s->rupper,
-			    s->rlower + 1 - s->rupper);
-		}
+		if (ctx->scrolled != 0)
+			screen_write_sync_scroll_dirty(ctx);
 		for (y = 0; y < screen_size_y(s); y++) {
 			cl = &s->write_list[y];
 			if (!TAILQ_EMPTY(&cl->items))
@@ -3187,7 +3298,7 @@ screen_write_alternateon(struct screen_write_ctx *ctx, struct grid_cell *gc,
 
 	screen_write_initctx(ctx, &ttyctx, 1, 0);
 	if (ttyctx.redraw_cb != NULL)
-		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
+		ttyctx.redraw_cb(&ttyctx);
 }
 
 /* Turn alternate screen off. */
@@ -3212,5 +3323,5 @@ screen_write_alternateoff(struct screen_write_ctx *ctx, struct grid_cell *gc,
 
 	screen_write_initctx(ctx, &ttyctx, 1, 0);
 	if (ttyctx.redraw_cb != NULL)
-		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
+		ttyctx.redraw_cb(&ttyctx);
 }

server-client.c

@@ -356,13 +356,7 @@ server_client_set_session(struct client *c, struct session *s)
 		tty_update_client_offset(c);
 		status_timer_start(c);
 		server_client_fire_session_changed(c, old);
-
-		/*
-		 * Redraw if the session or displayed window changed. Use the
-		 * cached scene because the session's current window is already set.
-		 */
-		if (old != s || !redraw_client_has_window(c, s->curw->window))
-			server_redraw_client(c);
+		server_redraw_client(c);
 	}
 
 	server_check_unattached();
@@ -1355,11 +1349,10 @@ server_client_key_callback(struct cmdq_item *item, void *data)
 		m->key = key;
 
 		/*
-		 * Synchronize direct drag output with the later damage redraw
-		 * before invoking the drag callback.
+		 * Mouse drag is in progress, so fire the callback (now that
+		 * the mouse event is valid).
 		 */
 		if ((key & KEYC_MASK_KEY) == KEYC_DRAGGING) {
-			tty_sync_start(&c->tty);
 			c->tty.mouse_drag_update(c, m);
 			goto out;
 		}
@@ -1786,8 +1779,8 @@ server_client_loop(void)
 	}
 
 	/*
-	 * Clear window redraw state after processing all clients. Deferred
-	 * redraws are preserved in client flags.
+	 * Any windows will have been redrawn as part of clients, so clear
+	 * their flags now.
 	 */
 	RB_FOREACH(w, windows, &windows) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
@@ -1798,8 +1791,6 @@ server_client_loop(void)
 			wp->flags &= ~(PANE_REDRAW|PANE_REDRAWSCROLLBAR|
 			    PANE_ACTIVITY);
 		}
-		redraw_free_damage(w);
-
 		check_window_name(w);
 	}
 
@@ -2345,8 +2336,6 @@ server_client_any_pane_redraw(struct client *c)
 
 	if (c->flags & CLIENT_REDRAWWINDOW)
 		return (1);
-	if (!TAILQ_EMPTY(&w->damage))
-		return (1);
 	TAILQ_FOREACH(wp, &w->panes, entry) {
 		if (wp->flags & (PANE_REDRAW|PANE_REDRAWSCROLLBAR))
 			return (1);
@@ -2363,7 +2352,6 @@ server_client_check_redraw(struct client *c)
 	struct window		*w = s->curw->window;
 	struct window_pane	*wp;
 	int			 needed, tflags, mode = tty->mode;
-	int			 damaged = !TAILQ_EMPTY(&w->damage);
 	struct timeval		 tv = { .tv_usec = 1000 };
 	static struct event	 ev;
 	size_t			 n;
@@ -2389,12 +2377,12 @@ server_client_check_redraw(struct client *c)
 		return;
 	}
 
-	/* Ignore output queued within the current synchronized frame. */
+	/*
+	 * If there is outstanding data, defer the redraw until it has been
+	 * consumed. We can just add a timer to get out of the event loop and
+	 * end up back here.
+	 */
 	n = EVBUFFER_LENGTH(tty->out);
-	if ((tty->flags & TTY_SYNCING) && n > tty->sync_offset)
-		n = tty->sync_offset;
-
-	/* Defer until output drains, preserving damage in client flags. */
 	if (n != 0 || (tty->flags & TTY_BLOCK)) {
 		if (n != 0)
 			log_debug("%s: redraw deferred (%zu left)", c->name, n);
@@ -2406,10 +2394,6 @@ server_client_check_redraw(struct client *c)
 			log_debug("redraw timer started");
 			evtimer_add(&ev, &tv);
 		}
-		if (damaged) {
-			c->flags |= CLIENT_REDRAWWINDOW;
-			return;
-		}
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->flags & PANE_REDRAW) {
 				c->flags |= CLIENT_REDRAWWINDOW;
@@ -2443,10 +2427,6 @@ server_client_check_redraw(struct client *c)
 				redraw_pane_scrollbar(c, wp);
 			}
 		}
-
-		/* Draw damage here if no client redraw flags will handle it. */
-		if (damaged && (c->flags & CLIENT_ALLREDRAWFLAGS) == 0)
-			redraw_client_damage(c);
 	}
 
 	/*
@@ -2460,7 +2440,6 @@ server_client_check_redraw(struct client *c)
 		}
 		server_client_set_progress_bar(c);
 		redraw_screen(c);
-		redraw_client_damage(c);
 	}
 
 	/* Put the tty back how it was. */

tmux.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: tmux.h,v 1.1447 2026/09/22 14:10:26 nicm Exp $ */
+/* $OpenBSD: tmux.h,v 1.1448 2026/09/24 11:19:39 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -69,7 +69,6 @@ struct options_array_item;
 struct options_entry;
 struct prompt;
 struct window_pane_prompt;
-struct redraw_damage;
 struct redraw_scene;
 struct redraw_span;
 struct screen_write_citem;
@@ -1348,6 +1347,10 @@ struct window_pane {
 
 	bitstr_t	*sync_dirty;
 	u_int		 sync_dirty_size;
+	u_int		 sync_scrolled;
+	u_int		 sync_rupper;
+	u_int		 sync_rlower;
+	u_int		 sync_bg;
 
 	u_int		 sb_slider_y;
 	u_int		 sb_slider_h;
@@ -1403,7 +1406,6 @@ struct window_pane {
 	struct screen	 base;
 
 	struct screen	 status_screen;
-	u_int		 status_generation;
 
 	TAILQ_HEAD(, window_mode_entry) modes;
 
@@ -1434,7 +1436,6 @@ struct window_pane {
 TAILQ_HEAD(window_panes, window_pane);
 TAILQ_HEAD(window_panes_zindex, window_pane);
 RB_HEAD(window_pane_tree, window_pane);
-TAILQ_HEAD(redraw_damages, redraw_damage);
 
 /* Window structure. */
 struct window {
@@ -1478,9 +1479,6 @@ struct window {
 
 	uint64_t		 redraw_scene_generation;
 
-	struct redraw_damages	 damage;
-	u_int			 damage_count;
-
 	struct menu_data	*menu;
 	u_int			 menu_last_px;
 	u_int			 menu_last_py;
@@ -1806,8 +1804,6 @@ struct tty {
 	struct event	 timer;
 	size_t		 discarded;
 
-	size_t		 sync_offset;
-
 	struct termios	 tio;
 
 	struct grid_cell cell;
@@ -1855,7 +1851,7 @@ struct tty {
 };
 
 /* Terminal command context. */
-typedef void (*tty_ctx_redraw_cb)(const struct tty_ctx *, u_int, u_int);
+typedef void (*tty_ctx_redraw_cb)(const struct tty_ctx *);
 typedef int (*tty_ctx_set_client_cb)(struct tty_ctx *, struct client *);
 struct tty_ctx {
 	struct screen		*s;
@@ -3594,7 +3590,7 @@ void	 screen_write_mode_clear(struct screen_write_ctx *, int);
 void	 screen_write_start_sync(struct window_pane *);
 void	 screen_write_stop_sync(struct window_pane *);
 void	 screen_write_end_sync(struct screen_write_ctx *);
-void	 screen_write_clear_dirty(struct window_pane *);
+void	 screen_write_sync_clear_dirty(struct window_pane *);
 void	 screen_write_cursorup(struct screen_write_ctx *, u_int);
 void	 screen_write_cursordown(struct screen_write_ctx *, u_int);
 void	 screen_write_cursorright(struct screen_write_ctx *, u_int);
@@ -3642,12 +3638,8 @@ void	 redraw_screen(struct client *);
 void	 redraw_pane(struct client *, struct window_pane *);
 void	 redraw_pane_scrollbar(struct client *, struct window_pane *);
 void	 redraw_free_scene(struct redraw_scene *);
-int	 redraw_client_has_window(struct client *, struct window *);
 void	 redraw_invalidate_scene(struct window *);
 void	 redraw_invalidate_all_scenes(void);
-void	 redraw_damage_window(struct window *, u_int, u_int, u_int, u_int);
-void	 redraw_free_damage(struct window *);
-void	 redraw_client_damage(struct client *);
 int	 redraw_get_status_border_cell_type(struct redraw_span **, u_int);
 
 /* screen.c */
@@ -3822,8 +3814,6 @@ struct style_range *window_pane_status_get_range(struct window_pane *, u_int,
 		     u_int);
 int		 window_pane_is_floating(struct window_pane *);
 int		 window_pane_is_floating_with_hidden(struct window_pane *);
-void		 window_redraw_floating_pane(struct window_pane *, int, int,
-		     int, int);
 
 /* window-border.c */
 void		 window_set_fill_cells(struct window *);

tty.c

@@ -1115,7 +1115,7 @@ tty_redraw_region(struct tty *tty, const struct tty_ctx *ctx)
 	 */
 	if (tty_large_region(tty, ctx) || ctx->flags & TTY_CTX_PANE_OBSCURED) {
 		log_debug("%s: %s large region redraw", __func__, c->name);
-		ctx->redraw_cb(ctx, ctx->orupper, ctx->orlower - ctx->orupper + 1);
+		ctx->redraw_cb(ctx);
 		return;
 	}
 
@@ -1517,7 +1517,6 @@ tty_sync_start(struct tty *tty)
 	if (tty->flags & TTY_SYNCING)
 		return;
 	tty->flags |= TTY_SYNCING;
-	tty->sync_offset = EVBUFFER_LENGTH(tty->out);
 
 	if (tty_term_has(tty->term, TTYC_SYNC)) {
 		log_debug("%s sync start", tty->client->name);
@@ -1924,7 +1923,7 @@ tty_cmd_alignmenttest(struct tty *tty, const struct tty_ctx *ctx)
 	u_int		 i, j;
 
 	if (ctx->flags & TTY_CTX_WINDOW_BIGGER) {
-		ctx->redraw_cb(ctx, 0, ctx->sy);
+		ctx->redraw_cb(ctx);
 		return;
 	}
 
@@ -1983,7 +1982,7 @@ tty_cmd_cells(struct tty *tty, const struct tty_ctx *ctx)
 		    tty->cy == tty->rlower)
 			tty_draw_pane(tty, ctx, ctx->ocy);
 		else
-			ctx->redraw_cb(ctx, ctx->ocy, 1);
+			ctx->redraw_cb(ctx);
 		return;
 	}
 

window-copy.c

@@ -768,7 +768,6 @@ window_copy_scroll(struct window_pane *wp, int sl_mpos, u_int my,
 	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
 
 	if (wme != NULL) {
-		window_redraw_active_switch(wp->window, wp);
 		window_set_active_pane(wp->window, wp, 0);
 		window_copy_scroll1(wme, wp, sl_mpos, my, tty_oy, scroll_exit);
 	}

window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: window.c,v 1.377 2026/09/21 10:33:16 nicm Exp $ */
+/* $OpenBSD: window.c,v 1.378 2026/09/24 11:19:39 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -415,7 +415,6 @@ window_create(u_int sx, u_int sy, u_int xpixel, u_int ypixel)
 	TAILQ_INIT(&w->panes);
 	TAILQ_INIT(&w->z_index);
 	TAILQ_INIT(&w->last_panes);
-	TAILQ_INIT(&w->damage);
 	w->active = NULL;
 
 	w->lastlayout = -1;
@@ -469,7 +468,6 @@ window_destroy(struct window *w)
 
 	menu_destroy(w);
 	window_destroy_panes(w);
-	redraw_free_damage(w);
 
 	if (event_initialized(&w->name_event))
 		evtimer_del(&w->name_event);
@@ -720,7 +718,6 @@ int
 window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 {
 	struct window_pane *lastwp;
-	int		    unzoomed;
 
 	log_debug("%s: pane %%%u", __func__, wp->id);
 
@@ -728,8 +725,7 @@ window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 		return (0);
 	if (w->modal != NULL && wp != w->modal)
 		return (0);
-	unzoomed = (w->flags & WINDOW_ZOOMED) && !window_pane_is_visible(wp);
-	if (unzoomed)
+	if ((w->flags & WINDOW_ZOOMED) && !window_pane_is_visible(wp))
 		window_unzoom(w, 1);
 	lastwp = w->active;
 
@@ -746,19 +742,7 @@ window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 	}
 
 	tty_update_window_offset(w);
-
-	/*
-	 * Unzooming changes every pane's geometry and needs a full window
-	 * redraw. Otherwise, only the previous and new active pane's border
-	 * and status appearance changed, so avoid redrawing unaffected pane
-	 * content.
-	 */
-	if (unzoomed)
-		server_redraw_window(w);
-	else {
-		server_redraw_window_borders(w);
-		server_status_window(w);
-	}
+	server_redraw_window(w);
 
 	if (notify)
 		window_fire_pane_changed(w, w->active, lastwp);
@@ -1544,7 +1528,7 @@ window_pane_destroy(struct window_pane *wp)
 	window_pane_clear_prompt(wp);
 
 	window_pane_free_modes(wp);
-	screen_write_clear_dirty(wp);
+	screen_write_sync_clear_dirty(wp);
 
 	if (wp->fd != -1) {
 #ifdef HAVE_UTEMPTER
@@ -2941,40 +2925,3 @@ window_pane_is_floating_with_hidden(struct window_pane *wp)
 		return (0);
 	return (1);
 }
-
-/* Report damage for a floating pane, including its border and scrollbar. */
-static void
-window_damage_floating_pane(struct window_pane *wp, int xoff, int yoff,
-    int sx, int sy)
-{
-	struct window	*w = wp->window;
-	int		 x0, x1, y0, y1, sb_left = 0, sb_right = 0;
-	struct style	*sb_sy = &wp->scrollbar_style;
-
-	if (window_pane_scrollbar_reserve(wp)) {
-		if (w->sb_pos == PANE_SCROLLBARS_LEFT)
-			sb_left = sb_sy->width + sb_sy->pad;
-		else
-			sb_right = sb_sy->width + sb_sy->pad;
-	}
-	x0 = xoff - 1 - sb_left;
-	x1 = xoff + sx + sb_right;
-	y0 = yoff - 1;
-	y1 = yoff + sy;
-	if (x0 < 0)
-		x0 = 0;
-	if (y0 < 0)
-		y0 = 0;
-	if (x1 >= x0 && y1 >= y0)
-		redraw_damage_window(w, x0, y0, x1 - x0 + 1U, y1 - y0 + 1U);
-}
-
-/* Report damage for a floating pane's old and new areas. */
-void
-window_redraw_floating_pane(struct window_pane *wp, int oxoff, int oyoff,
-    int osx, int osy)
-{
-	window_damage_floating_pane(wp, oxoff, oyoff, osx, osy);
-	window_damage_floating_pane(wp, wp->xoff, wp->yoff, wp->sx, wp->sy);
-	server_status_window(wp->window);
-}