Damage rectanges.

* refs/remotes/tmux-openbsd/master:
  Add margins for WezTerm and ghostty, from Michael Grant.

Makefile.am

@@ -257,7 +257,8 @@ check_PROGRAMS = \
 	fuzz/input-fuzzer \
 	fuzz/cmd-parse-fuzzer \
 	fuzz/format-fuzzer \
-	fuzz/style-fuzzer
+	fuzz/style-fuzzer \
+	fuzz/layout-fuzzer
 fuzz_input_fuzzer_LDFLAGS = $(FUZZING_LIBS)
 fuzz_input_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
 fuzz_cmd_parse_fuzzer_LDFLAGS = $(FUZZING_LIBS)
@@ -266,6 +267,8 @@ fuzz_format_fuzzer_LDFLAGS = $(FUZZING_LIBS)
 fuzz_format_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
 fuzz_style_fuzzer_LDFLAGS = $(FUZZING_LIBS)
 fuzz_style_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
+fuzz_layout_fuzzer_LDFLAGS = $(FUZZING_LIBS)
+fuzz_layout_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
 endif
 
 # Install tmux.1 in the right format.

cmd-join-pane.c

@@ -307,8 +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;
-	int			 old_xoff, old_yoff, old_sx, old_sy;
+	int			 y, ly, x, lx, oxoff, oyoff, osx, osy;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -330,17 +329,16 @@ cmd_join_pane_mouse_move(struct client *c, struct mouse_event *m)
 		ly = m->statusat - 1;
 
 	if (x != lx || y != ly) {
-		old_xoff = wp->xoff;
-		old_yoff = wp->yoff;
-		old_sx = wp->sx;
-		old_sy = wp->sy;
+		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_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-		    old_sy);
+		window_redraw_floating_pane(wp, oxoff, oyoff, osx, osy);
 		server_redraw_window_borders(w);
 	}
 }

cmd-resize-pane.c

@@ -237,9 +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;
-	int			 new_xoff, new_yoff, resizes = 0;
-	int			 old_xoff, old_yoff, old_sx, old_sy;
+	int			 left, right, resizes = 0;
+	int			 new_xoff, new_yoff, old_xoff, old_yoff;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -252,8 +251,6 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	sy = wp->sy;
 	old_xoff = wp->xoff;
 	old_yoff = wp->yoff;
-	old_sx = (int)wp->sx;
-	old_sy = (int)wp->sy;
 	left = wp->xoff - 1;
 	right = wp->xoff + sx;
 	if (window_pane_scrollbar_reserve(wp) &&
@@ -353,8 +350,7 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	}
 	if (resizes != 0) {
 		layout_fix_panes(w, NULL);
-		window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-		    old_sy);
+		window_redraw_floating_pane(wp, old_xoff, old_yoff, sx, sy);
 		server_redraw_window_borders(w);
 	}
 }

cmd-split-window.c

@@ -362,7 +362,7 @@ 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			 old_xoff, old_yoff, old_sx, old_sy;
+	int			 oxoff, oyoff, osx, osy;
 
 	if (c->tty.mouse_last_pane == -1)
 		return;
@@ -418,15 +418,14 @@ cmd_split_window_mouse_resize(struct client *c, struct mouse_event *m)
 	if (sy < PANE_MINIMUM)
 		sy = PANE_MINIMUM;
 
-	old_xoff = wp->xoff;
-	old_yoff = wp->yoff;
-	old_sx = wp->sx;
-	old_sy = wp->sy;
+	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_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-	    old_sy);
+	window_redraw_floating_pane(wp, oxoff, oyoff, osx, osy);
 	server_redraw_window_borders(w);
 }

fuzz/layout-fuzzer.c

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026 Arthur Chan <arthur.chan@adalogics.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Fuzz the custom layout parser.
+ *
+ * A layout string such as "bb62,80x24,0,0{40x24,0,0,1,39x24,41,0,2}" is
+ * accepted by select-layout and is what tmux stores and restores for a
+ * window, so it is parsed from configuration and from commands. It drives
+ * layout-custom.c (the string parser and the checksum), then layout.c, which
+ * resizes and assigns the cells.
+ *
+ * layout_parse() refuses a window with no panes, and refuses a layout whose
+ * cell count is smaller than the pane count, so the window is given a fixed
+ * number of panes. The count is fixed rather than derived from the input, so
+ * a mutation always means a different layout string.
+ */
+
+#include <sys/types.h>
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+#define FUZZER_MAXLEN 1024
+#define FUZZER_PANES 4
+
+struct event_base	*libevent;
+
+int
+LLVMFuzzerTestOneInput(const u_char *data, size_t size)
+{
+	struct window		*w;
+	struct window_pane	*wp;
+	char			*buf, *cause = NULL, *dump;
+	u_int			 i;
+
+	if (size == 0 || size > FUZZER_MAXLEN)
+		return 0;
+
+	/* layout_parse() takes a C string. */
+	buf = malloc(size + 1);
+	if (buf == NULL)
+		return 0;
+	memcpy(buf, data, size);
+	buf[size] = '\0';
+
+	w = window_create(80, 24, 0, 0);
+	if (w == NULL) {
+		free(buf);
+		return 0;
+	}
+	window_add_ref(w, __func__);
+
+	for (i = 0; i < FUZZER_PANES; i++) {
+		wp = window_add_pane(w, NULL, 0, 0);
+		if (w->active == NULL)
+			w->active = wp;
+	}
+
+	if (layout_parse(w, buf, &cause) == 0) {
+		dump = layout_dump(w, w->layout_root, 1);
+		free(dump);
+	}
+	free(cause);
+
+	window_remove_ref(w, __func__);
+
+	free(buf);
+	return 0;
+}
+
+int
+LLVMFuzzerInitialize(__unused int *argc, __unused char ***argv)
+{
+	const struct options_table_entry	*oe;
+
+	global_environ = environ_create();
+	global_options = options_create(NULL);
+	global_s_options = options_create(NULL);
+	global_w_options = options_create(NULL);
+	for (oe = options_table; oe->name != NULL; oe++) {
+		if (oe->scope & OPTIONS_TABLE_SERVER)
+			options_default(global_options, oe);
+		if (oe->scope & OPTIONS_TABLE_SESSION)
+			options_default(global_s_options, oe);
+		if (oe->scope & OPTIONS_TABLE_WINDOW)
+			options_default(global_w_options, oe);
+	}
+
+	libevent = osdep_event_init();
+
+	socket_path = xstrdup("dummy");
+
+	return 0;
+}

fuzz/layout-fuzzer.dict

@@ -0,0 +1,17 @@
+# tmux custom layout strings: "<checksum>,<sx>x<sy>,<x>,<y>{...}" / "[...]"
+","
+"x"
+"{"
+"}"
+"["
+"]"
+"0"
+"1"
+"80x24,0,0"
+"40x24,0,0"
+"bb62,"
+"cafe,"
+",0,0,0"
+",0,0{"
+",0,0["
+"@"

fuzz/layout-fuzzer.options

@@ -0,0 +1,2 @@
+[libfuzzer]
+max_len = 1024

layout.c

@@ -477,9 +477,9 @@ layout_fix_panes(struct window *w, struct window_pane *skip)
 		    wp->yoff != old_yoff ||
 		    wp->sx != old_sx ||
 		    wp->sy != old_sy) {
-			changed = 1;
 			if (window_pane_scrollbar_reserve(wp))
 				wp->flags |= PANE_REDRAWSCROLLBAR;
+			changed = 1;
 		}
 	}
 	if (changed)

regress/display-panes.sh

@@ -153,11 +153,13 @@ wait_format "$p0" '#{pane_in_mode}' '0'
 wait_option @picked "$p1"
 
 # Commands after display-panes run immediately while the mode remains.
+# Record the mode in the same command queue so client startup cannot race
+# the 500ms timeout.
 $TMUX set -g @after none || fail "set @after failed"
-$TMUX display-panes -Nd 500 -t "$p0" \; set -g @after fast ||
+$TMUX display-panes -Nd 500 -t "$p0" \; \
+    set -gF -t "$p0" @after '#{pane_mode}' ||
 	fail "display-panes immediate command failed"
-wait_option @after fast
-wait_format "$p0" '#{pane_mode}' 'panes-mode'
+wait_option @after 'panes-mode'
 wait_format "$p0" '#{pane_in_mode}' '0'
 
 # Existing zoom is restored on exit.

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

@@ -0,0 +1,135 @@
+#!/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-no-double-composite.sh

@@ -1,17 +1,6 @@
 #!/bin/sh
 
-# server_client_check_redraw() had `(~c->flags & CLIENT_ALLREDRAWFLAGS)` as
-# a fallback condition guarding a call to redraw_client_damage() - for a
-# multi-bit mask, `~x & MASK` means "at least one of these bits is unset"
-# (almost always true), not "none of these bits are set" as the comment
-# and surrounding logic clearly intend. Every floating-pane drag command
-# unconditionally sets CLIENT_REDRAWBORDERS (server_redraw_window_borders()
-# in cmd-resize-pane.c/cmd-join-pane.c/cmd-split-window.c) alongside
-# reporting window damage, so this fallback fired on every single drag
-# step, composing the exact same damage rectangle a second time a few
-# lines later at the CLIENT_ALLREDRAWFLAGS block - wasted work, not a
-# correctness issue, but a clean, deterministic signal to check for via
-# the server's own -vv log.
+# Each drag motion must draw the floating pane content once.
 
 PATH=/bin:/usr/bin
 TERM=screen
@@ -22,7 +11,7 @@ export PATH TERM LC_ALL
 
 DIR=$(mktemp -d) || exit 1
 cd "$DIR" || exit 1
-INNER="$TEST_TMUX -vv -Ldoublecomp-inner-$$ -f/dev/null"
+INNER="$TEST_TMUX -Ldoublecomp-inner-$$ -f/dev/null"
 OUTER="$TEST_TMUX -Ldoublecomp-outer-$$ -f/dev/null"
 
 fail()
@@ -47,14 +36,16 @@ mouse()
 	sleep 0.15
 }
 
-$INNER new-session -d -s inner -x 40 -y 10 'sleep 100' || exit 1
+$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 \
-    'sleep 100') || exit 1
+    "printf 'DRAGMARK'; exec sleep 100") || exit 1
 
-$OUTER new-session -d -s outer -x 40 -y 10 '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
@@ -68,13 +59,18 @@ YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
 GRABCOL=$((XOFF + 3))
 BORDERROW=$YOFF
 
-# Top-border drag (a move): each step both reports window damage and sets
-# CLIENT_REDRAWBORDERS (server_redraw_window_borders() in the caller),
-# which is exactly the combination the buggy fallback misfired on.
+# 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
+while [ "$i" -lt "$steps" ]; do
 	GRABCOL=$((GRABCOL + 1))
 	mouse 32 "$GRABCOL" "$BORDERROW" M
 	i=$((i + 1))
@@ -83,18 +79,10 @@ mouse 0 "$GRABCOL" "$BORDERROW" m
 sleep 0.3
 
 NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" != "$XOFF" ] || fail "sanity: floating pane did not move (still at $XOFF)"
-
-LOG=$(ls tmux-server*.log 2>/dev/null | head -1)
-[ -n "$LOG" ] || fail "sanity: no server -vv log was produced"
-
-# Each drag step should compose its damage exactly once. If any rectangle
-# was composed twice, the same "x,y WxH" text appears on two consecutive
-# composing-damage lines - compare the position+size together, since
-# distinct steps commonly share the same size (only the position differs).
-dup=$(grep "composing damage" "$LOG" | awk '{print $(NF-1), $NF}' |
-    uniq -d | wc -l)
-[ "$dup" -eq 0 ] ||
-	fail "$dup damage rectangle(s) were composed twice in the same pass"
+[ "$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

@@ -137,4 +137,23 @@ 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,16 +1,6 @@
 #!/bin/sh
 
-# server_client_key_callback()'s mouse-drag dispatch opens a synchronized-
-# output frame (tty_sync_start()) before running the drag callback, on
-# every single drag motion event. server_client_check_redraw() then checks
-# EVBUFFER_LENGTH(tty->out) != 0 later in the same pass to decide whether
-# to defer this pass's redraw - nothing drains tty->out in between, so the
-# frame-open sequence just queued (8 bytes: "\033[?2026h") makes that check
-# see "outstanding output" and defer against itself, escalating the drag's
-# damage to a full-window redraw on every motion event on any
-# synchronized-output-capable terminal. This checks the server's own -vv
-# log for that exact self-inflicted "8 left" deferral pattern during a
-# drag, and requires it never appears.
+# Synchronized drag output must not cause a full redraw of untouched rows.
 
 PATH=/bin:/usr/bin
 TERM=screen
@@ -21,7 +11,7 @@ export PATH TERM LC_ALL
 
 DIR=$(mktemp -d) || exit 1
 cd "$DIR" || exit 1
-INNER="$TEST_TMUX -vv -Lsyncdefer-inner-$$ -f/dev/null"
+INNER="$TEST_TMUX -Lsyncdefer-inner-$$ -f/dev/null"
 OUTER="$TEST_TMUX -Lsyncdefer-outer-$$ -f/dev/null"
 
 fail()
@@ -46,18 +36,20 @@ mouse()
 	sleep 0.15
 }
 
-$INNER new-session -d -s inner -x 40 -y 10 'sleep 100' || exit 1
+$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 \
-    'sleep 100') || exit 1
+    "printf 'DRAGMARK'; exec sleep 100") || exit 1
 
-$OUTER new-session -d -s outer -x 40 -y 10 '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 set-option -as terminal-features ',screen-256color:sync' || 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
@@ -68,13 +60,18 @@ YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
 GRABCOL=$((XOFF + 3))
 BORDERROW=$YOFF
 
-# Plain (non-Alt) top-border drag: "MouseDrag1Border" -> resize-pane -M ->
-# a move, since grabbing the top border moves rather than resizes. Several
-# small steps, each its own drag-motion event and so its own pass through
-# the code under test.
+# 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
-while [ $i -lt 6 ]; do
+steps=6
+while [ "$i" -lt "$steps" ]; do
 	GRABCOL=$((GRABCOL + 1))
 	mouse 32 "$GRABCOL" "$BORDERROW" M
 	i=$((i + 1))
@@ -83,13 +80,14 @@ mouse 0 "$GRABCOL" "$BORDERROW" m
 sleep 0.3
 
 NEWXOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-[ "$NEWXOFF" != "$XOFF" ] || fail "sanity: floating pane did not move (still at $XOFF)"
-
-LOG=$(ls tmux-server*.log 2>/dev/null | head -1)
-[ -n "$LOG" ] || fail "sanity: no server -vv log was produced"
-
-n=$(grep -c "redraw deferred (8 left)" "$LOG")
-[ "$n" -eq 0 ] ||
-	fail "drag self-deferred against its own queued sync bytes $n time(s)"
+[ "$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-offscreen-alternate-redraw.sh

@@ -1,20 +1,7 @@
 #!/bin/sh
 
-# A floating pane positioned partly off the window's left/top edge (e.g.
-# created with -X -5) has a negative wp->xoff/wp->yoff. screen_write_
-# redraw_cb() (screen-write.c) used to pass these straight through as u_int
-# to redraw_damage_window(), which wraps a negative offset to a huge value
-# - redraw_damage_window()'s own bounds check then rejects the whole
-# rectangle, so nothing gets redrawn, not even the pane's visible portion.
-#
-# This fires on returning from the alternate screen (screen_write_
-# alternateoff()) among other paths. This test exercises exactly that:
-# fills the pane's primary screen, switches it to the alternate screen and
-# back, and checks the client actually receives the restored primary
-# content in the pane's visible (on-screen) columns - using an attached
-# client's own received bytes (via a nested outer client), not
-# capture-pane, which reads the grid directly and would pass regardless of
-# whether the client was ever actually told to redraw it.
+# 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
@@ -57,28 +44,24 @@ wait_outer_has()
 	fail "outer client did not show $marker"
 }
 
-wait_visible_restored()
-{
-	i=0
-	while [ "$i" -lt 50 ]; do
-		$OUTER capture-pane -p -t outer:0.0 >"$CAPTURE" 2>/dev/null || true
-		sed -n "${CONTENTROW}p" "$CAPTURE" | grep -q '^AAAAA' && return 0
-		sleep 0.1
-		i=$((i + 1))
-	done
-	fail "primary-screen content was not restored in the pane's visible columns after returning from the alternate screen"
-}
-
 cat >"$EMITTER" <<'PERL'
 use strict;
 use warnings;
 
 $| = 1;
-print "\e[1;1H", 'A' x 15;
-sleep 2;
+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";
-print "\e[1;1H", 'B' x 15;
-sleep 2;
+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
@@ -87,15 +70,6 @@ $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
 
-# Content pane spans window columns -5..9 (partly off the left edge); only
-# columns 0..9 are ever visible.
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X -5 -Y 2 \
-    "perl '$EMITTER'") || exit 1
-XOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_left}')
-YOFF=$($INNER display-message -p -t "$FLOAT" '#{pane_top}')
-[ "$XOFF" -lt 0 ] || fail "sanity: floating pane is not off-screen (xoff=$XOFF)"
-CONTENTROW=$((YOFF + 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
@@ -104,8 +78,25 @@ $OUTER respawn-pane -k -t outer:0.0 \
     "$TEST_TMUX -Loffscreen-inner-$$ -f/dev/null attach-session -t inner" ||
     exit 1
 
-wait_outer_has AAAAA
-wait_outer_has BBBBB
-wait_visible_restored
+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-status-cross-client.sh

@@ -1,31 +1,7 @@
 #!/bin/sh
 
-# redraw_damage_refresh_status() (screen-redraw.c) force-regenerates a
-# pane's border-status title when a damage rectangle touches it, guarded
-# by the per-pane PANE_NEWSTATUS flag. window_make_pane_status() formats
-# pane-border-format using the requesting client's own context (so e.g.
-# #{client_name} differs per client), but wp->status_screen/PANE_NEWSTATUS
-# are shared by every client viewing the pane. With two clients attached
-# to the same session, whichever client's damage pass runs first renders
-# its own text and sets the flag; the other client's damage pass, finding
-# the flag already set, used to skip rendering entirely and reuse
-# whatever was already there.
-#
-# This checks the actual server-side decision via the -vv log rather than
-# a visual capture: an unrelated periodic client status-refresh reliably
-# repaints each client's title correctly again within the same tick right
-# after the buggy decision is made, before anything is ever flushed to
-# either terminal, so the wrong content this bug produces is never
-# visible to any external capture - the log is the only place the actual
-# bug (or its absence) can be observed.
-#
-# A floating pane with its own pane-border-status is positioned so that a
-# damage rectangle from an *unrelated* palette change (OSC 4) in the
-# underlying tiled pane - whose own geometry spans the whole window -
-# overlaps the floating pane's title row without touching its content,
-# giving a damage-only trigger with no side effect that would otherwise
-# force a normal (non-buggy) full per-client status re-render in the same
-# pass and mask the result either way.
+# 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
@@ -35,83 +11,141 @@ 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 -vv -Lstatuscc-inner-$$ -f/dev/null"
-OUTER1="$TEST_TMUX -Lstatuscc-outer1-$$ -f/dev/null"
-OUTER2="$TEST_TMUX -Lstatuscc-outer2-$$ -f/dev/null"
+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()
 {
-	$OUTER1 kill-server 2>/dev/null
-	$OUTER2 kill-server 2>/dev/null
+	$OUTER kill-server 2>/dev/null
 	$INNER kill-server 2>/dev/null
-	cd /
 	rm -rf "$DIR"
 }
 trap cleanup 0 1 15
 
-BASEEMITTER=$DIR/base-emitter.pl
-cat >"$BASEEMITTER" <<'PERL'
+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;
-my $line = <STDIN>;
-print "\e]4;1;rgb:11/22/33\e\\";
+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 40 -y 10 "perl '$BASEEMITTER'" || exit 1
-$INNER set-option -g status off || exit 1
-$INNER set-option -g window-size manual || exit 1
-$INNER set-option -g pane-border-status top || exit 1
-$INNER set-option -g pane-border-format 'C=#{client_name}' || exit 1
-BASE=$($INNER list-panes -t inner -F '#{pane_id}') || exit 1
-FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 20 -y 3 -X 5 -Y 4 \
+$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
 
-$OUTER1 new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER1 set-option -g status off || exit 1
-$OUTER1 set-option -g window-size manual || exit 1
-$OUTER1 set-option -g default-terminal screen-256color || exit 1
-$OUTER1 respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lstatuscc-inner-$$ -f/dev/null attach-session -t inner" ||
-    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
-NAME1=$($INNER list-clients -F '#{client_name}') || exit 1
+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
 
-$OUTER2 new-session -d -s outer -x 40 -y 10 'sleep 100' || exit 1
-$OUTER2 set-option -g status off || exit 1
-$OUTER2 set-option -g window-size manual || exit 1
-$OUTER2 set-option -g default-terminal screen-256color || exit 1
-$OUTER2 respawn-pane -k -t outer:0.0 \
-    "$TEST_TMUX -Lstatuscc-inner-$$ -f/dev/null attach-session -t inner" ||
-    exit 1
-sleep 0.5
-ALLNAMES=$($INNER list-clients -F '#{client_name}') || exit 1
-NAME2=$(echo "$ALLNAMES" | grep -v "^$NAME1\$")
-[ -n "$NAME2" ] || fail "sanity: could not identify the second client"
-
-# Let any attach-driven full redraw (and its own, non-buggy, per-client
-# status render) finish completely before triggering the damage-only
-# palette update.
-sleep 1.5
-
-$INNER send-keys -t "$BASE" Enter || exit 1
-sleep 0.5
-
-LOG=$(ls tmux-server*.log 2>/dev/null | head -1)
-[ -n "$LOG" ] || fail "sanity: no server -vv log was produced"
-
-n1=$(grep -c "regenerated pane .* status for $NAME1\$" "$LOG")
-n2=$(grep -c "regenerated pane .* status for $NAME2\$" "$LOG")
-[ "$n1" -ge 1 ] || fail "damage pass never regenerated $NAME1's own status - it reused whatever the other client's render left behind"
-[ "$n2" -ge 1 ] || fail "damage pass never regenerated $NAME2's own status - it reused whatever the other client's render left behind"
+# 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/prompt-words-history.sh

@@ -131,6 +131,14 @@ 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

@@ -0,0 +1,113 @@
+#!/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

@@ -0,0 +1,140 @@
+#!/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-viewports.sh

@@ -0,0 +1,112 @@
+#!/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/tty-margins-scrollbar.sh

@@ -1,23 +1,7 @@
 #!/bin/sh
 
-# A pane that doesn't span the terminal's full width - because
-# pane-scrollbars is on (the scrollbar occupies a column) or the pane is
-# one of a side-by-side split - needs DECSLRM (left/right margin) support
-# to use the fast native-scroll path (tty_cmd_linefeed()/scrollup()/
-# scrolldown()/reverseindex(), tty.c:
-# "(!tty_full_width(tty, ctx) && !tty_use_margin(tty))"). Without it, every
-# single scroll falls back to tty_redraw_region()'s full manual repaint of
-# the whole region - a real, confirmed source of flicker (and, separately,
-# of image content not surviving a scroll in branches with image support).
-#
-# tty_default_features() (tty-features.c) grants the "margins" feature to
-# several terminals it can positively identify via XTVERSION/DA2 (mintty,
-# iTerm2, WezTerm, ghostty, XTerm-as-VT420) - this checks the actual
-# server-side scroll decision via the -vv log for the underlying mechanism
-# those table entries all rely on, using the terminal-features option
-# directly (which any of them - or a user's own terminal-overrides -
-# ultimately feed into) rather than simulating any one terminal's
-# identification handshake.
+# 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
@@ -27,8 +11,7 @@ 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 -vv -Lmarginsscrollbar-inner-$$ -f/dev/null"
+INNER="$TEST_TMUX -Lmarginsscrollbar-inner-$$ -f/dev/null"
 OUTER="$TEST_TMUX -Lmarginsscrollbar-outer-$$ -f/dev/null"
 
 fail()
@@ -41,77 +24,70 @@ 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"
+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
 
-run_scroll_phase()
-{
-	label=$1
-	margins=$2
-
-	rm -f tmux-server*.log
-
-	$INNER new-session -d -s inner -x 40 -y 6 'exec sh' || exit 1
+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 ',*:margins' || exit 1
+	if [ "$margins" = on ]; then
+		$INNER set -as terminal-features ',screen-256color:margins' || exit 1
 	fi
 
-	$OUTER new-session -d -x 40 -y 6 || exit 1
-	OUTERPANE=$($OUTER list-panes -F '#{pane_id}') || exit 1
+	$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 send-keys -t "$OUTERPANE" -l "$INNER attach -t inner" || exit 1
-	$OUTER send-keys -t "$OUTERPANE" Enter || exit 1
-	sleep 1
-
-	wait_for_client
-
+	$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 8 ]; do
-		$INNER send-keys -t inner Enter || exit 1
-		sleep 0.2
+	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
-	sleep 0.3
-
-	LOG=$(ls tmux-server*.log 2>/dev/null | head -1)
-	[ -n "$LOG" ] || fail "$label: sanity: no server -vv log was produced"
-
-	n=$(grep -c "tty_redraw_region.*large region redraw" "$LOG")
-
+	[ "$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
-
-	echo "$n"
-}
-
-# Phase 1: margins granted - must never fall back to a full region redraw.
-n_with=$(run_scroll_phase "with margins" "on")
-[ "$n_with" -eq 0 ] ||
-	fail "with margins granted, scrolling a scrollbar-enabled pane still fell back to a full region redraw ($n_with times)"
-
-# Phase 2: sanity check - without margins, the same scenario must actually
-# hit the fallback, proving phase 1 wasn't accidentally trivial.
-n_without=$(run_scroll_phase "without margins" "off")
-[ "$n_without" -gt 0 ] ||
-	fail "sanity: without margins, scrolling a scrollbar-enabled pane never fell back to a full region redraw - this scenario no longer exercises the bug this test checks for"
+done
 
 exit 0

screen-redraw.c

@@ -204,19 +204,19 @@ struct redraw_scene {
 	u_int			 oy;
 };
 
-/* A single damaged window-coordinate rectangle. */
+/* A damaged rectangle in a window. */
 struct redraw_damage {
-	u_int			 x;
-	u_int			 y;
-	u_int			 sx;
-	u_int			 sy;
+	u_int				 x;
+	u_int				 y;
+	u_int				 sx;
+	u_int				 sy;
 
-	TAILQ_ENTRY(redraw_damage) entry;
+	TAILQ_ENTRY(redraw_damage)	entry;
 };
 
 /*
- * Cap on the number of pending damage rectangles per window before they are
- * collapsed into a single rectangle covering their union.
+ * If there are more damage rectangles than this, they are collapsed into
+ * one.
  */
 #define REDRAW_DAMAGE_MAX 16
 
@@ -224,15 +224,15 @@ struct redraw_damage {
 struct redraw_build_cell {
 	struct redraw_span_data	 data;
 };
-
 static struct redraw_build_cell	*redraw_cells;
 static size_t			 redraw_ncells;
 
 /*
- * Bumped once per redraw_client_damage() call (one client's one redraw
- * pass) - see redraw_damage_refresh_status().
+ * 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_serial;
+static u_int	redraw_status_generation;
 
 /* Context for building the scene. */
 struct redraw_build_ctx {
@@ -1103,7 +1103,7 @@ redraw_free_damage(struct window *w)
 	w->damage_count = 0;
 }
 
-/* Collapse all pending damage for a window into one rectangle - its union. */
+/* Collapse all pending damage for a window into one rectangle. */
 static void
 redraw_collapse_damage(struct window *w)
 {
@@ -1140,14 +1140,7 @@ redraw_collapse_damage(struct window *w)
 	w->damage_count = 1;
 }
 
-/*
- * Record a damaged window-coordinate rectangle. Clips it to the window,
- * merges it with an existing rectangle where doing so does not make the
- * result substantially larger than the two combined, and collapses the
- * whole list to its union once it grows past a modest cap.
- *
- * This only records damage - nothing consumes it yet.
- */
+/* 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)
 {
@@ -1164,7 +1157,6 @@ redraw_damage_window(struct window *w, u_int x, u_int y, u_int sx, u_int sy)
 		return;
 
 	TAILQ_FOREACH(rd, &w->damage, entry) {
-		/* Skip unless overlapping or directly adjacent. */
 		if (x > rd->x + rd->sx || rd->x > x + sx ||
 		    y > rd->y + rd->sy || rd->y > y + sy)
 			continue;
@@ -1192,9 +1184,7 @@ redraw_damage_window(struct window *w, u_int x, u_int y, u_int sx, u_int sy)
 	rd->sx = sx;
 	rd->sy = sy;
 	TAILQ_INSERT_TAIL(&w->damage, rd, entry);
-	w->damage_count++;
-
-	if (w->damage_count > REDRAW_DAMAGE_MAX)
+	if (++w->damage_count > REDRAW_DAMAGE_MAX)
 		redraw_collapse_damage(w);
 }
 
@@ -1510,14 +1500,10 @@ redraw_draw_menu_span(struct redraw_draw_ctx *dctx,
 	tty_draw_line(tty, s, px, span->data.m.py, n, x, y, NULL);
 }
 
-/*
- * Draw a span, restricted to [clip_x, clip_x + clip_n) - a caller drawing
- * the whole span passes the span's own x/width here; a caller drawing only
- * a damaged sub-range passes that range instead.
- */
+/* Draw a span. */
 static void
 redraw_draw_span(struct redraw_draw_ctx *dctx, struct redraw_span *span,
-    u_int y, u_int clip_x, u_int clip_n)
+    u_int y)
 {
 	struct redraw_span_data	*data = &span->data;
 	enum redraw_span_type	 type = data->type;
@@ -1527,21 +1513,21 @@ redraw_draw_span(struct redraw_draw_ctx *dctx, struct redraw_span *span,
 
 	switch (span->data.type) {
 	case REDRAW_SPAN_PANE:
-		redraw_draw_pane_span(dctx, span, clip_x, y, clip_n);
+		redraw_draw_pane_span(dctx, span, span->x, y, span->width);
 		break;
 	case REDRAW_SPAN_BORDER:
 	case REDRAW_SPAN_EMPTY:
 	case REDRAW_SPAN_OUTSIDE:
-		redraw_draw_border_span(dctx, span, clip_x, y, clip_n);
+		redraw_draw_border_span(dctx, span, span->x, y, span->width);
 		break;
 	case REDRAW_SPAN_STATUS:
-		redraw_draw_status_span(dctx, span, clip_x, y, clip_n);
+		redraw_draw_status_span(dctx, span, span->x, y, span->width);
 		break;
 	case REDRAW_SPAN_SCROLLBAR:
-		redraw_draw_scrollbar_span(dctx, span, clip_x, y, clip_n);
+		redraw_draw_scrollbar_span(dctx, span, span->x, y, span->width);
 		break;
 	case REDRAW_SPAN_MENU:
-		redraw_draw_menu_span(dctx, span, clip_x, y, clip_n);
+		redraw_draw_menu_span(dctx, span, span->x, y, span->width);
 		break;
 	}
 }
@@ -1576,19 +1562,15 @@ redraw_draw_pane_lines(struct redraw_draw_ctx *dctx, struct window_pane *wp,
 		if (flags & REDRAW_PANE) {
 			spans = &line->spans[REDRAW_SPAN_PANE];
 			TAILQ_FOREACH(span, spans, entry) {
-				if (span->data.p.wp == wp) {
-					redraw_draw_span(dctx, span, cy,
-					    span->x, span->width);
-				}
+				if (span->data.p.wp == wp)
+					redraw_draw_span(dctx, span, cy);
 			}
 		}
 		if (flags & REDRAW_PANE_SCROLLBAR) {
 			spans = &line->spans[REDRAW_SPAN_SCROLLBAR];
 			TAILQ_FOREACH(span, spans, entry) {
-				if (span->data.sb.wp == wp) {
-					redraw_draw_span(dctx, span, cy,
-					    span->x, span->width);
-				}
+				if (span->data.sb.wp == wp)
+					redraw_draw_span(dctx, span, cy);
 			}
 		}
 	}
@@ -1646,10 +1628,8 @@ redraw_draw_lines(struct redraw_draw_ctx *dctx, int flags)
 				}
 			}
 			spans = &line->spans[type];
-			TAILQ_FOREACH(span, spans, entry) {
-				redraw_draw_span(dctx, span, cy, span->x,
-				    span->width);
-			}
+			TAILQ_FOREACH(span, spans, entry)
+				redraw_draw_span(dctx, span, cy);
 		}
 	}
 }
@@ -1669,10 +1649,8 @@ redraw_draw_menu_lines(struct redraw_draw_ctx *dctx)
 			cy = dctx->status_lines + y;
 		else
 			cy = y;
-		TAILQ_FOREACH(span, &line->spans[REDRAW_SPAN_MENU], entry) {
-			redraw_draw_span(dctx, span, cy, span->x,
-			    span->width);
-		}
+		TAILQ_FOREACH(span, &line->spans[REDRAW_SPAN_MENU], entry)
+			redraw_draw_span(dctx, span, cy);
 	}
 }
 
@@ -1752,7 +1730,7 @@ redraw_set_draw_context(struct redraw_draw_ctx *dctx,
 		dctx->flags |= REDRAW_ISOLATES;
 }
 
-/* Build a pane prompt into a one-line screen. */
+/* Build a pane prompt. */
 static void
 redraw_make_pane_prompt(struct window_pane *wp, struct screen *screen)
 {
@@ -1840,7 +1818,8 @@ 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) &&
+		if (!redraw &&
+		    (~c->flags & CLIENT_REDRAWSTATUSALWAYS) &&
 		    !REDRAW_IS_ALL(flags)) {
 			flags &= ~REDRAW_STATUS;
 			if (flags == 0)
@@ -2026,162 +2005,34 @@ redraw_pane_scrollbar(struct client *c, struct window_pane *wp)
 	redraw_draw(c, wp, REDRAW_PANE_SCROLLBAR);
 }
 
-/*
- * A REDRAW_SPAN_STATUS span within a damaged rectangle needs its content
- * rebuilt and force-drawn regardless of whether that content has logically
- * changed. window_make_pane_status()'s grid_compare() only tells us
- * whether the *content* changed, not whether the physical cells were
- * disturbed by something else (e.g. a floating pane sliding across this
- * row) - and being inside a damage rectangle already proves that happened.
- * Without this, redraw_draw_span() silently skips REDRAW_SPAN_STATUS spans
- * whenever PANE_NEWSTATUS is not set, leaving a pane's border-status title
- * blank until some unrelated redraw happens to touch it (e.g. a focus
- * change or window resize).
- *
- * wp->status_screen/PANE_NEWSTATUS are per-pane, but the formatted content
- * (window_make_pane_status() expands pane-border-format, which can read
- * per-client fields like #{client_name}) is per-client. Gating purely on
- * PANE_NEWSTATUS would let one client's damage pass render its own text,
- * set the flag, and leave every other client's pass - this tick or any
- * later one, since nothing else clears it here - reusing that stale,
- * wrong-client text. redraw_status_serial (bumped once per
- * redraw_client_damage() call, i.e. once per client per pass) still
- * dedupes repeat calls within that same pass, but forces a fresh,
- * correctly-client-formatted render on every distinct client/pass.
- */
+/* 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			 width;
+	u_int			 g = wp->status_generation, width;
 
-	if ((wp->flags & PANE_NEWSTATUS) &&
-	    wp->status_serial == redraw_status_serial)
+	if ((wp->flags & PANE_NEWSTATUS) && g == redraw_status_generation)
 		return;
 	width = redraw_pane_status_width(dctx, wp, &first);
-	if (width == 0)
-		return;
-	log_debug("%s: regenerated pane %%%u status for %s", __func__, wp->id,
-	    dctx->scene->c->name);
-	window_make_pane_status(wp, dctx->scene->c, width, first);
-	wp->flags |= PANE_NEWSTATUS;
-	wp->status_serial = redraw_status_serial;
-}
-
-/* Whether the cell at (px, py) in screen s is a padding cell. */
-static int
-redraw_screen_cell_is_padding(struct screen *s, u_int px, u_int py)
-{
-	struct grid_cell	gc;
-
-	if (px >= screen_size_x(s))
-		return (0);
-	grid_view_get_cell(s->grid, px, py, &gc);
-	return ((gc.flags & GRID_FLAG_PADDING) != 0);
-}
-
-/*
- * Whether the cell at scene x-coordinate x within this span is the second
- * (padding) half of a wide character - the condition under which growing a
- * damage clip's edge toward it, to pull in the rest of that character, is
- * correct. True unconditionally for span types with no real backing screen
- * (border, scrollbar) - these only ever draw single synthesized cells, so
- * growing them is always harmless. For span types with a real screen (pane
- * content, a pane's status line, a menu), only true when x is actually a
- * padding cell there - if x is instead the start of an unrelated,
- * already-complete character, growing toward it would walk into that
- * character's opposite half and corrupt it: tty_draw_line() clears a
- * leading padding cell in its draw range (proof the range starts
- * mid-character) and, via a different check (tty_draw_line_get_empty()'s
- * gc->data.width > nx test), also clears a trailing base cell that has no
- * room left for its own padding (proof the range ends mid-character) - so
- * growing either edge onto a base cell is equally destructive to whatever
- * character lies just outside the range, just through a different part of
- * tty_draw_line().
- */
-static int
-redraw_span_cell_is_padding(struct redraw_span *span, u_int x)
-{
-	struct screen		*s;
-	u_int			 px, py;
-
-	switch (span->data.type) {
-	case REDRAW_SPAN_PANE:
-		s = span->data.p.wp->screen;
-		px = span->data.p.px + (x - span->x);
-		py = span->data.p.py;
-		break;
-	case REDRAW_SPAN_STATUS:
-		s = &span->data.st.wp->status_screen;
-		px = span->data.st.offset + (x - span->x);
-		py = 0;
-		break;
-	case REDRAW_SPAN_MENU:
-		s = menu_screen(span->data.m.md);
-		px = span->data.m.px + (x - span->x);
-		py = span->data.m.py;
-		break;
-	default:
-		return (1);
+	if (width != 0) {
+		window_make_pane_status(wp, dctx->scene->c, width, first);
+		wp->flags |= PANE_NEWSTATUS;
+		wp->status_generation = redraw_status_generation;
 	}
-	return (redraw_screen_cell_is_padding(s, px, py));
 }
 
-/*
- * Grow a clipped span range by one cell on either edge that isn't already at
- * the span's own boundary. A clip edge that lands mid-character (this is a
- * damage rectangle, so its edges are geometric and have no idea what's in
- * the grid) may be sitting on the second, padding half of a wide character
- * whose other half falls just outside the requested range - growing by one
- * cell is enough to pull the whole character back in, since no grid cell is
- * ever wider than two columns, and clamping to the span's own x and width
- * keeps this from bleeding into a neighbouring span. Both edges need the
- * same padding check before growing: growing onto a cell that isn't padding
- * (an unrelated, already-complete character just outside the range) is
- * destructive on either side, not just the left - see
- * redraw_span_cell_is_padding().
- */
-static void
-redraw_damage_grow_span_clip(struct redraw_span *span, u_int *xp, u_int *endp)
-{
-	if (*xp > span->x && redraw_span_cell_is_padding(span, *xp))
-		(*xp)--;
-	if (*endp < span->x + span->width &&
-	    redraw_span_cell_is_padding(span, *endp))
-		(*endp)++;
-}
-
-/*
- * As redraw_damage_grow_span_clip(), but against an explicit screen: px0 is
- * the column in that screen corresponding to span->x, py the row. Used for
- * a span's separately rendered content (e.g. a pane's prompt) that isn't
- * span->data.p.wp->screen (or whichever grid redraw_span_cell_is_padding()
- * would otherwise consult for this span's type), and so has its own,
- * unrelated wide-character boundaries at the same columns.
- */
-static void
-redraw_damage_grow_screen_clip(struct redraw_span *span, struct screen *s,
-    u_int px0, u_int py, u_int *xp, u_int *endp)
-{
-	if (*xp > span->x &&
-	    redraw_screen_cell_is_padding(s, px0 + (*xp - span->x), py))
-		(*xp)--;
-	if (*endp < span->x + span->width &&
-	    redraw_screen_cell_is_padding(s, px0 + (*endp - span->x), py))
-		(*endp)++;
-}
-
-/* Recompose a pane's prompt over a damaged section of its display row. */
+/* 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, u_int x, u_int n)
+    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, width, prompt_y, x0, x1;
+	u_int			 px = span->data.p.px, width, prompt_y;
 
 	if (wp->prompt == NULL || wp->sx == 0 || wp->sy == 0)
 		return;
@@ -2191,46 +2042,26 @@ redraw_damage_draw_pane_prompt(struct redraw_draw_ctx *dctx,
 		prompt_y = wp->sy - 1;
 	if (span->data.p.py != prompt_y)
 		return;
-
 	redraw_make_pane_prompt(wp, &screen);
-
-	/*
-	 * x and n were clipped and grown against wp->screen, whose character
-	 * boundaries have nothing to do with the prompt's separately
-	 * rendered screen - realign the range on the prompt's own grid
-	 * instead, clamped to this span so it cannot bleed into a
-	 * neighbouring one.
-	 */
-	x0 = x;
-	x1 = x + n;
-	redraw_damage_grow_screen_clip(span, &screen, span->data.p.px, 0, &x0,
-	    &x1);
-
-	px = span->data.p.px + (x0 - span->x);
 	if (px < screen_size_x(&screen)) {
-		width = x1 - x0;
+		width = span->width;
 		if (width > screen_size_x(&screen) - px)
 			width = screen_size_x(&screen) - px;
-		tty_draw_line(tty, &screen, px, 0, width, x0, y, NULL);
+		tty_draw_line(tty, &screen, px, 0, width, span->x, y, NULL);
 	}
 	screen_free(&screen);
 }
 
-/*
- * Compose exactly the cells within a damaged rectangle (already in this
- * client's own scene coordinates), rather than a whole pane. For each row
- * in range, every span of every type whose x-range intersects the
- * rectangle is drawn restricted to just the intersected sub-range.
- */
+/* Draw the spans intersecting a damaged rectangle. */
 static void
-redraw_draw_damage_rect(struct redraw_draw_ctx *dctx, u_int x, u_int y,
+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, clip_x, clip_end, type;
+	u_int			 cy, yy, type;
 
 	if (x >= scene->sx || y >= scene->sy)
 		return;
@@ -2250,42 +2081,30 @@ redraw_draw_damage_rect(struct redraw_draw_ctx *dctx, u_int x, u_int y,
 		for (type = 0; type < REDRAW_SPAN_TYPES; type++) {
 			spans = &line->spans[type];
 			TAILQ_FOREACH(span, spans, entry) {
-				clip_x = (span->x > x) ? span->x : x;
-				clip_end = (span->x + span->width < x + sx) ?
-				    span->x + span->width : x + sx;
-				if (clip_end <= clip_x)
+				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_damage_grow_span_clip(span, &clip_x,
-				    &clip_end);
-				redraw_draw_span(dctx, span, cy, clip_x,
-				    clip_end - clip_x);
+				redraw_draw_span(dctx, span, cy);
 				if (type == REDRAW_SPAN_PANE) {
 					redraw_damage_draw_pane_prompt(dctx,
-					    span, cy, clip_x,
-					    clip_end - clip_x);
+					    span, cy);
 				}
 			}
 		}
 	}
 }
 
-/*
- * Consume a client's window's pending damage by composing exactly the
- * damaged cells, after clipping each rectangle to what this client can see
- * and translating it into this client's own scene coordinates.
- *
- * Unlike redraw_pane(), this does not redraw a whole pane's worth of cells
- * for a small disturbance - only the cells within the (clipped) rectangle
- * are touched, via redraw_draw_damage_rect().
- */
+/* 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;
@@ -2293,7 +2112,7 @@ redraw_client_damage(struct client *c)
 
 	if (TAILQ_EMPTY(&w->damage))
 		return;
-	redraw_status_serial++;
+	redraw_status_generation++;
 
 	scene = redraw_get_scene(c);
 	if (scene == NULL)
@@ -2301,6 +2120,11 @@ redraw_client_damage(struct client *c)
 	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);
 
@@ -2309,11 +2133,9 @@ redraw_client_damage(struct client *c)
 		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)
-			continue;
-		log_debug("%s: %s composing damage %u,%u %ux%u", __func__,
-		    c->name, x0 - ox, y0 - oy, x1 - x0, y1 - y0);
-		redraw_draw_damage_rect(&dctx, x0 - ox, y0 - oy, x1 - x0,
-		    y1 - y0);
+		if (x0 < x1 && y0 < y1) {
+			redraw_draw_damage_rectangle(&dctx, x0 - ox, y0 - oy,
+			    x1 - x0, y1 - y0);
+		}
 	}
 }

screen-write.c

@@ -120,18 +120,7 @@ screen_write_set_cursor(struct screen_write_ctx *ctx, int cx, int cy)
 		evtimer_add(&w->offset_timer, &tv);
 }
 
-/*
- * Called when a write could not be applied directly to the terminal and
- * needs a redraw instead. Report damage for the requested rows. wp->yoff is
- * already adjusted past any top pane-border-status row, so wp->yoff + py is
- * the correct window-coordinate row. wp->xoff/wp->yoff are signed and can be
- * negative for a floating pane positioned partly off the window's left or
- * top edge, so clip to the window's own origin here before converting to
- * the unsigned coordinates redraw_damage_window() takes - passing a
- * negative offset through unclipped wraps to a huge value that its own
- * bounds check then silently rejects, losing the pane's visible portion
- * entirely rather than just the off-screen part.
- */
+/* Redraw lines. */
 static void
 screen_write_redraw_cb(const struct tty_ctx *ttyctx, u_int py, u_int ny)
 {
@@ -149,10 +138,8 @@ screen_write_redraw_cb(const struct tty_ctx *ttyctx, u_int py, u_int ny)
 		x0 = 0;
 	if (y0 < 0)
 		y0 = 0;
-	if (x1 <= x0 || y1 <= y0)
-		return;
-	redraw_damage_window(wp->window, (u_int)x0, (u_int)y0,
-	    (u_int)(x1 - x0), (u_int)(y1 - y0));
+	if (x1 > x0 && y1 > y0)
+		redraw_damage_window(wp->window, x0, y0, x1 - x0, y1 - y0);
 }
 
 /* Update context for client. */

server-client.c

@@ -358,30 +358,10 @@ server_client_set_session(struct client *c, struct session *s)
 		server_client_fire_session_changed(c, old);
 
 		/*
-		 * A full redraw is only needed if the client's session or
-		 * current window actually changed - not if this merely
-		 * confirmed the client is still looking at the same window
-		 * (as happens when switch-client -t targets a pane in the
-		 * already-current window, e.g. clicking a pane name in a
-		 * second #{P:} status line: the default MouseDown1Status
-		 * binding resolves that click to switch-client -t=, which
-		 * reaches here regardless of whether anything besides the
-		 * active pane changed). Redrawing unconditionally here
-		 * forced a full window redraw for what should have been
-		 * just an active-pane change, already handled narrowly by
-		 * window_set_active_pane() and window_redraw_active_switch()
-		 * before this is reached.
-		 *
-		 * old and s may be the same session object, whose curw was
-		 * already updated to the new window before this function was
-		 * called - old->curw and s->curw would then read the same,
-		 * already-current value, so comparing them can never detect
-		 * a same-session window change. Compare against the client's
-		 * own cached scene instead, which only reflects what it has
-		 * actually drawn.
+		 * Redraw if the session or displayed window changed. Use the
+		 * cached scene because the session's current window is already set.
 		 */
-		if (old == NULL || old != s ||
-		    !redraw_client_has_window(c, s->curw->window))
+		if (old != s || !redraw_client_has_window(c, s->curw->window))
 			server_redraw_client(c);
 	}
 
@@ -1375,18 +1355,8 @@ server_client_key_callback(struct cmdq_item *item, void *data)
 		m->key = key;
 
 		/*
-		 * Mouse drag is in progress, so fire the callback (now that
-		 * the mouse event is valid).
-		 *
-		 * Start a synchronized-output region here rather than
-		 * leaving it to whatever redraw eventually follows: a drag
-		 * callback may write directly via the pane's fast path
-		 * immediately, with any correction only arriving later via
-		 * redraw_client_damage(), which opens its own sync region.
-		 * Since tty_sync_end() is only called once, at the very end
-		 * of this client's pass in server_client_reset_state(),
-		 * starting it here merges both into one atomic terminal
-		 * update instead of two visible frames.
+		 * Synchronize direct drag output with the later damage redraw
+		 * before invoking the drag callback.
 		 */
 		if ((key & KEYC_MASK_KEY) == KEYC_DRAGGING) {
 			tty_sync_start(&c->tty);
@@ -1816,13 +1786,8 @@ server_client_loop(void)
 	}
 
 	/*
-	 * Any windows will have been redrawn as part of clients, so clear
-	 * their flags now. A client whose redraw was deferred this pass
-	 * (waiting for outstanding tty output to drain) has already
-	 * escalated to CLIENT_REDRAWWINDOW or CLIENT_REDRAWSCROLLBARS in
-	 * server_client_check_redraw() to cover whatever it is about to
-	 * lose here, so PANE_REDRAW/PANE_REDRAWSCROLLBAR and window damage
-	 * can simply be cleared unconditionally.
+	 * Clear window redraw state after processing all clients. Deferred
+	 * redraws are preserved in client flags.
 	 */
 	RB_FOREACH(w, windows, &windows) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
@@ -2398,6 +2363,7 @@ 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;
@@ -2423,28 +2389,12 @@ server_client_check_redraw(struct client *c)
 		return;
 	}
 
-	/*
-	 * 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. server_client_loop() clears PANE_REDRAW,
-	 * PANE_REDRAWSCROLLBAR and window damage unconditionally every pass,
-	 * so escalate to a coarser, persistent client flag that survives
-	 * that clear and forces a full catch-up redraw once this client is
-	 * unblocked, rather than trying to keep the fine-grained state
-	 * around for a retry.
-	 *
-	 * If a synchronized-output frame is open, discount anything queued
-	 * since it started (down to sync_offset, the length when it opened):
-	 * those bytes are already part of the frame this pass is committed
-	 * to flushing (see tty_sync_start()), not a reason to defer this
-	 * pass's redraw - without this, a mouse-drag callback that itself
-	 * opens the frame before writing anything would see its own
-	 * just-queued bytes as "outstanding output" and defer against
-	 * itself every single motion event.
-	 */
+	/* Ignore output queued within the current synchronized frame. */
 	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);
@@ -2456,8 +2406,10 @@ server_client_check_redraw(struct client *c)
 			log_debug("redraw timer started");
 			evtimer_add(&ev, &tv);
 		}
-		if (!TAILQ_EMPTY(&w->damage))
+		if (damaged) {
 			c->flags |= CLIENT_REDRAWWINDOW;
+			return;
+		}
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->flags & PANE_REDRAW) {
 				c->flags |= CLIENT_REDRAWWINDOW;
@@ -2492,18 +2444,8 @@ server_client_check_redraw(struct client *c)
 			}
 		}
 
-		/*
-		 * Window damage is also what makes server_client_any_pane_
-		 * redraw() decide a redraw is needed at all, independently of
-		 * any CLIENT_ALLREDRAWFLAGS bit. Every current damage source
-		 * happens to set one of those flags too, so the block below
-		 * always consumes it - but consume it here too in case that
-		 * ever stops holding, since server_client_loop() clears
-		 * window damage unconditionally every pass regardless of
-		 * whether it was actually drawn.
-		 */
-		if (!TAILQ_EMPTY(&w->damage) &&
-		    (c->flags & CLIENT_ALLREDRAWFLAGS) == 0)
+		/* Draw damage here if no client redraw flags will handle it. */
+		if (damaged && (c->flags & CLIENT_ALLREDRAWFLAGS) == 0)
 			redraw_client_damage(c);
 	}
 

tmux.1

@@ -1,4 +1,4 @@
-.\" $OpenBSD: tmux.1,v 1.1172 2026/09/22 06:58:05 nicm Exp $
+.\" $OpenBSD: tmux.1,v 1.1173 2026/09/23 12:37:50 nicm Exp $
 .\"
 .\" Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 .\"
@@ -14,7 +14,7 @@
 .\" IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 .\" OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 .\"
-.Dd $Mdocdate: September 22 2026 $
+.Dd $Mdocdate: September 23 2026 $
 .Dt TMUX 1
 .Os
 .Sh NAME
@@ -994,13 +994,19 @@ Will run:
 /bin/sh \-c \[aq]vi \[ti]/.tmux.conf\[aq]
 .Ed
 .Pp
+Unless specified, tmux uses the value of
+.Ic default\-shell
+in place of
+.Pa /bin/sh .
+.Pp
 Additionally, the
 .Ic new\-window ,
 .Ic new\-session ,
 .Ic split\-window ,
-.Ic respawn\-window
-and
+.Ic respawn\-window ,
 .Ic respawn\-pane
+and
+.Ic display\-popup
 commands allow
 .Ar shell\-command
 to be given as multiple arguments and executed directly (without

tmux.h

@@ -1403,7 +1403,7 @@ struct window_pane {
 	struct screen	 base;
 
 	struct screen	 status_screen;
-	u_int		 status_serial;
+	u_int		 status_generation;
 
 	TAILQ_HEAD(, window_mode_entry) modes;
 
@@ -1806,12 +1806,6 @@ struct tty {
 	struct event	 timer;
 	size_t		 discarded;
 
-	/*
-	 * Buffer length at the instant a synchronized-output frame opened
-	 * (tty_sync_start()), so server_client_check_redraw()'s "is there
-	 * already outstanding output" check can discount whatever this
-	 * pass itself queued into that frame - see tty_sync_start().
-	 */
 	size_t		 sync_offset;
 
 	struct termios	 tio;
@@ -3827,9 +3821,9 @@ int		 window_pane_get_pane_status(struct window_pane *);
 struct style_range *window_pane_status_get_range(struct window_pane *, u_int,
 		     u_int);
 int		 window_pane_is_floating(struct window_pane *);
-void		 window_pane_redraw_floating(struct window *,
-		     struct window_pane *, int, int, int, int);
 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-features.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: tty-features.c,v 1.45 2026/09/22 14:10:26 nicm Exp $ */
+/* $OpenBSD: tty-features.c,v 1.46 2026/09/24 08:16:13 nicm Exp $ */
 
 /*
  * Copyright (c) 2020 Nicholas Marriott <nicholas.marriott@gmail.com>

window.c

@@ -2942,31 +2942,21 @@ window_pane_is_floating_with_hidden(struct window_pane *wp)
 	return (1);
 }
 
-/*
- * Report damage for a floating pane's rectangle, grown by one cell on every
- * side - a floating pane draws its border frame at xoff-1/yoff-1 through
- * xoff+sx/yoff+sy (see the "floating" case in screen-redraw.c), one cell
- * outside its own content area, so damage for just the content area leaves
- * the frame's previous position undrawn as the pane moves. If a scrollbar
- * is reserved, its side of the frame is pushed out further still by its
- * width and padding (also matched in screen-redraw.c), so grow that side
- * to match.
- */
+/* Report damage for a floating pane, including its border and scrollbar. */
 static void
-window_pane_damage_floating(struct window *w, struct window_pane *wp,
-    int xoff, int yoff, int sx, int sy)
+window_damage_floating_pane(struct window_pane *wp, int xoff, int yoff,
+    int sx, int sy)
 {
-	int	x0, x1, y0, y1, sb_left = 0, sb_right = 0;
+	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 = wp->scrollbar_style.width +
-			    wp->scrollbar_style.pad;
+			sb_left = sb_sy->width + sb_sy->pad;
 		else
-			sb_right = wp->scrollbar_style.width +
-			    wp->scrollbar_style.pad;
+			sb_right = sb_sy->width + sb_sy->pad;
 	}
-
 	x0 = xoff - 1 - sb_left;
 	x1 = xoff + sx + sb_right;
 	y0 = yoff - 1;
@@ -2975,75 +2965,16 @@ window_pane_damage_floating(struct window *w, struct window_pane *wp,
 		x0 = 0;
 	if (y0 < 0)
 		y0 = 0;
-	if (x1 < x0 || y1 < y0)
-		return;
-	redraw_damage_window(w, (u_int)x0, (u_int)y0, (u_int)(x1 - x0) + 1,
-	    (u_int)(y1 - y0) + 1);
+	if (x1 >= x0 && y1 >= y0)
+		redraw_damage_window(w, x0, y0, x1 - x0 + 1U, y1 - y0 + 1U);
 }
 
-/*
- * Whether a pane's scrollbar strip - not its whole body - intersects a
- * window-coordinate rectangle. A reserved scrollbar occupies a strip of
- * scrollbar_style.width+pad columns just outside the pane's own content
- * area (see the scrollbar-reserve case in layout_fix_panes(), layout.c),
- * on whichever side w->sb_pos points to.
- */
-static int
-window_pane_scrollbar_intersects(struct window *w, struct window_pane *wp,
-    u_int x, u_int y, u_int sx, u_int sy)
-{
-	int	sb_x, sb_w, ix = (int)x, iy = (int)y, isx = (int)sx;
-	int	isy = (int)sy;
-
-	if (!window_pane_scrollbar_reserve(wp))
-		return (0);
-	sb_w = wp->scrollbar_style.width + wp->scrollbar_style.pad;
-	if (w->sb_pos == PANE_SCROLLBARS_LEFT)
-		sb_x = (int)wp->xoff - sb_w;
-	else
-		sb_x = (int)wp->xoff + (int)wp->sx;
-
-	return (sb_x < ix + isx && sb_x + sb_w > ix &&
-	    (int)wp->yoff < iy + isy && (int)wp->yoff + (int)wp->sy > iy);
-}
-
-/*
- * Report damage for only a floating pane's old and new area, rather than
- * the whole window - a floating pane move or resize only disturbs what it
- * was covering and what it now covers. Scrollbars aren't covered by the
- * damage system, so a pane whose *scrollbar strip* (not its whole body)
- * intersects either area is still flagged directly for a scrollbar redraw.
- * Checking the whole pane body here, rather than just its narrow scrollbar
- * strip, meant merely dragging over a pane's ordinary content set
- * PANE_REDRAWSCROLLBAR on every such pane on every motion event, triggering
- * a needless scrollbar redraw (and the redraw pass it forces) each time
- * even though the scrollbar itself never moved.
- *
- * Shared by every command that drags a floating pane around by the mouse:
- * resize-pane's own border drag (cmd-resize-pane.c), move-pane -M's
- * alternate Alt-drag (cmd-join-pane.c), and split-window/new-pane's
- * interactive resize of a newly-created floating pane (cmd-split-window.c).
- */
+/* Report damage for a floating pane's old and new areas. */
 void
-window_pane_redraw_floating(struct window *w, struct window_pane *wp,
-    int old_xoff, int old_yoff, int old_sx, int old_sy)
+window_redraw_floating_pane(struct window_pane *wp, int oxoff, int oyoff,
+    int osx, int osy)
 {
-	struct window_pane	*loop;
-
-	window_pane_damage_floating(w, wp, old_xoff, old_yoff, old_sx,
-	    old_sy);
-	window_pane_damage_floating(w, wp, wp->xoff, wp->yoff, wp->sx,
-	    wp->sy);
-
-	TAILQ_FOREACH(loop, &w->panes, entry) {
-		if (window_pane_scrollbar_intersects(w, loop,
-		    (u_int)old_xoff, (u_int)old_yoff, (u_int)old_sx,
-		    (u_int)old_sy) ||
-		    window_pane_scrollbar_intersects(w, loop, wp->xoff,
-		    wp->yoff, wp->sx, wp->sy))
-			loop->flags |= PANE_REDRAWSCROLLBAR;
-	}
-
-	/* Session status formats may depend on the pane's new geometry. */
-	server_status_window(w);
+	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);
 }