Merge branch 'margins-terminal-detection' into redraw-damage-rectangles

Brings in the WezTerm/ghostty/Windows Terminal DECSLRM (margins) coverage
from margins-terminal-detection (PR #5630), plus whatever independent
upstream progress that branch's master base had accumulated since this
branch last merged from master.

Conflict in screen-redraw.c's redraw_draw_pane_prompt(): this branch's own
earlier refactor (extracting redraw_make_pane_prompt(), reused by both the
normal redraw path and the Finding-2 damage-composition fix) collided with
an independent upstream fix on master (nicm, "Get x and y the right way
round, fixes crash when opening a mode prompt when the client is offset
into the window") that swapped tty_draw_line()'s px/py argument order in
this same function - this branch had diverged before that fix landed and
still had the pre-fix (buggy) order. Resolved by keeping this branch's
own refactor with the corrected argument order, verified against
tty_draw_line()'s signature (px, py - the prompt's screen is always
exactly one row, so py must be 0 and px must be the horizontal offset;
the pre-fix order passed the offset as the row instead, matching the
described crash). The other, structurally identical call site added this
session for Finding 2 (redraw_damage_draw_pane_prompt()) already had the
correct order and needed no change.

Verified: build clean; the new tty-margins-wt-session.sh and this
session's existing wide-character/prompt/cross-client tests all pass
(3x each); full regress suite passes clean twice, with only the same
pre-existing, unrelated failures already characterized this session
(prompt-words-history.sh, and untracked image-*-noflash scratch tests
from unrelated work, absent from this branch's own tracked suite).

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

cmd-attach-session.c

@@ -91,8 +91,10 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 	wp = target.wp;
 
 	if (wl != NULL) {
-		if (wp != NULL)
+		if (wp != NULL) {
+			window_redraw_active_switch(wp->window, wp);
 			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

@@ -308,6 +308,7 @@ cmd_join_pane_mouse_move(struct client *c, struct mouse_event *m)
 	struct window_pane	*wp;
 	struct layout_cell	*lc;
 	int			 y, ly, x, lx;
+	int			 old_xoff, old_yoff, old_sx, old_sy;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -329,10 +330,17 @@ 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;
+
 		lc->g.xoff += x - lx;
 		lc->g.yoff += y - ly;
 		layout_fix_panes(w, NULL);
-		server_redraw_window(w);
+
+		window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
+		    old_sy);
 		server_redraw_window_borders(w);
 	}
 }

cmd-resize-pane.c

@@ -239,6 +239,7 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	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;
 
 	wp = cmd_mouse_pane(m, NULL, &wl);
 	if (wp == NULL) {
@@ -249,6 +250,10 @@ 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;
+	old_sx = (int)wp->sx;
+	old_sy = (int)wp->sy;
 	left = wp->xoff - 1;
 	right = wp->xoff + sx;
 	if (window_pane_scrollbar_reserve(wp) &&
@@ -348,7 +353,8 @@ cmd_resize_pane_mouse_resize_move_floating(struct client *c,
 	}
 	if (resizes != 0) {
 		layout_fix_panes(w, NULL);
-		server_redraw_window(w);
+		window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
+		    old_sy);
 		server_redraw_window_borders(w);
 	}
 }

cmd-split-window.c

@@ -362,6 +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;
 
 	if (c->tty.mouse_last_pane == -1)
 		return;
@@ -417,8 +418,15 @@ 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;
+
 	layout_set_size(lc, sx, sy, xoff, yoff);
 	layout_fix_panes(w, NULL);
-	server_redraw_window(w);
+
+	window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
+	    old_sy);
 	server_redraw_window_borders(w);
 }

layout.c

@@ -469,7 +469,6 @@ 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);
@@ -477,8 +476,11 @@ 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)
+		    wp->sy != old_sy) {
 			changed = 1;
+			if (window_pane_scrollbar_reserve(wp))
+				wp->flags |= PANE_REDRAWSCROLLBAR;
+		}
 	}
 	if (changed)
 		redraw_invalidate_scene(w);

regress/attach-session-redraw.sh

@@ -0,0 +1,79 @@
+#!/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,6 +5,15 @@
 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
@@ -30,7 +39,7 @@ must_equal()
 	[ "$got" = "$want" ] || fail "got '$got', expected '$want'"
 }
 
-$TMUX new-session -d -x 80 -y 24 || exit 1
+$TMUX new-session -d -x 80 -y 24 -- $shell || 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-drag-ghost.sh

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

@@ -0,0 +1,100 @@
+#!/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.
+
+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 -vv -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 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
+FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X 5 -Y 2 \
+    'sleep 100') || 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 -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
+
+# 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.
+mouse 0 "$GRABCOL" "$BORDERROW" M
+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" != "$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"
+
+exit 0

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

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

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

@@ -0,0 +1,95 @@
+#!/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.
+
+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 -vv -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 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
+FLOAT=$($INNER new-pane -d -PF '#{pane_id}' -x 15 -y 5 -X 5 -Y 2 \
+    'sleep 100') || 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 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
+
+# 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.
+mouse 0 "$GRABCOL" "$BORDERROW" M
+i=0
+while [ $i -lt 6 ]; 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" != "$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)"
+
+exit 0

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

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

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

@@ -0,0 +1,111 @@
+#!/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.
+
+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"
+}
+
+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;
+print "\e[?1049h";
+print "\e[1;1H", 'B' x 15;
+sleep 2;
+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
+
+# 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
+$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
+
+wait_outer_has AAAAA
+wait_outer_has BBBBB
+wait_visible_restored
+
+exit 0

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

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

@@ -0,0 +1,117 @@
+#!/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.
+
+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 -vv -Lstatuscc-inner-$$ -f/dev/null"
+OUTER1="$TEST_TMUX -Lstatuscc-outer1-$$ -f/dev/null"
+OUTER2="$TEST_TMUX -Lstatuscc-outer2-$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER1 kill-server 2>/dev/null
+	$OUTER2 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'
+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 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 \
+    '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
+sleep 0.5
+NAME1=$($INNER list-clients -F '#{client_name}') || exit 1
+
+$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"
+
+exit 0

regress/floating-pane-status-format.sh

@@ -0,0 +1,102 @@
+#!/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/popup-drag-wide-character.sh

@@ -0,0 +1,126 @@
+#!/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/redraw-damage-only.sh

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

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

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

@@ -0,0 +1,81 @@
+#!/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/window-copy-scrollbar-drag-focus-style.sh

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

@@ -204,6 +204,22 @@ struct redraw_scene {
 	u_int			 oy;
 };
 
+/* A single damaged window-coordinate rectangle. */
+struct redraw_damage {
+	u_int			 x;
+	u_int			 y;
+	u_int			 sx;
+	u_int			 sy;
+
+	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.
+ */
+#define REDRAW_DAMAGE_MAX 16
+
 /* Cell for building the scene. */
 struct redraw_build_cell {
 	struct redraw_span_data	 data;
@@ -212,6 +228,12 @@ struct redraw_build_cell {
 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().
+ */
+static u_int			 redraw_status_serial;
+
 /* Context for building the scene. */
 struct redraw_build_ctx {
 	struct client				*c;
@@ -1054,6 +1076,13 @@ 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)
@@ -1061,6 +1090,114 @@ 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 - its union. */
+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 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.
+ */
+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) {
+		/* 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;
+
+		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);
+	w->damage_count++;
+
+	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)
@@ -1373,10 +1510,14 @@ 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. */
+/*
+ * 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.
+ */
 static void
 redraw_draw_span(struct redraw_draw_ctx *dctx, struct redraw_span *span,
-    u_int y)
+    u_int y, u_int clip_x, u_int clip_n)
 {
 	struct redraw_span_data	*data = &span->data;
 	enum redraw_span_type	 type = data->type;
@@ -1386,21 +1527,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, span->x, y, span->width);
+		redraw_draw_pane_span(dctx, span, clip_x, y, clip_n);
 		break;
 	case REDRAW_SPAN_BORDER:
 	case REDRAW_SPAN_EMPTY:
 	case REDRAW_SPAN_OUTSIDE:
-		redraw_draw_border_span(dctx, span, span->x, y, span->width);
+		redraw_draw_border_span(dctx, span, clip_x, y, clip_n);
 		break;
 	case REDRAW_SPAN_STATUS:
-		redraw_draw_status_span(dctx, span, span->x, y, span->width);
+		redraw_draw_status_span(dctx, span, clip_x, y, clip_n);
 		break;
 	case REDRAW_SPAN_SCROLLBAR:
-		redraw_draw_scrollbar_span(dctx, span, span->x, y, span->width);
+		redraw_draw_scrollbar_span(dctx, span, clip_x, y, clip_n);
 		break;
 	case REDRAW_SPAN_MENU:
-		redraw_draw_menu_span(dctx, span, span->x, y, span->width);
+		redraw_draw_menu_span(dctx, span, clip_x, y, clip_n);
 		break;
 	}
 }
@@ -1435,15 +1576,19 @@ 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);
+				if (span->data.p.wp == wp) {
+					redraw_draw_span(dctx, span, cy,
+					    span->x, span->width);
+				}
 			}
 		}
 		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);
+				if (span->data.sb.wp == wp) {
+					redraw_draw_span(dctx, span, cy,
+					    span->x, span->width);
+				}
 			}
 		}
 	}
@@ -1501,8 +1646,10 @@ 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);
+			TAILQ_FOREACH(span, spans, entry) {
+				redraw_draw_span(dctx, span, cy, span->x,
+				    span->width);
+			}
 		}
 	}
 }
@@ -1522,8 +1669,10 @@ 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);
+		TAILQ_FOREACH(span, &line->spans[REDRAW_SPAN_MENU], entry) {
+			redraw_draw_span(dctx, span, cy, span->x,
+			    span->width);
+		}
 	}
 }
 
@@ -1603,6 +1752,24 @@ redraw_set_draw_context(struct redraw_draw_ctx *dctx,
 		dctx->flags |= REDRAW_ISOLATES;
 }
 
+/* Build a pane prompt into a one-line screen. */
+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)
@@ -1611,8 +1778,6 @@ 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;
@@ -1645,16 +1810,7 @@ redraw_draw_pane_prompt(struct redraw_draw_ctx *dctx, struct window_pane *wp)
 	if (px + width > sx)
 		width = sx - px;
 
-	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);
-
+	redraw_make_pane_prompt(wp, &screen);
 	tty_draw_line(tty, &screen, offset, 0, width, px, cy, NULL);
 	screen_free(&screen);
 }
@@ -1684,7 +1840,8 @@ redraw_draw(struct client *c, struct window_pane *wp, int flags)
 			redraw = status_prompt_redraw(c);
 		else
 			redraw = status_redraw(c);
-		if (!redraw && !REDRAW_IS_ALL(flags)) {
+		if (!redraw && (~c->flags & CLIENT_REDRAWSTATUSALWAYS) &&
+		    !REDRAW_IS_ALL(flags)) {
 			flags &= ~REDRAW_STATUS;
 			if (flags == 0)
 				return;
@@ -1842,7 +1999,7 @@ redraw_screen(struct client *c)
 	else {
 		if (c->flags & CLIENT_REDRAWBORDERS)
 			flags |= (REDRAW_PANE_BORDER|REDRAW_PANE_STATUS);
-		if (c->flags & CLIENT_REDRAWSTATUS)
+		if (c->flags & (CLIENT_REDRAWSTATUS|CLIENT_REDRAWSTATUSALWAYS))
 			flags |= (REDRAW_STATUS|REDRAW_PANE_STATUS);
 		if (c->flags & CLIENT_REDRAWMENU)
 			flags |= REDRAW_MENU;
@@ -1868,3 +2025,295 @@ 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.
+ */
+static void
+redraw_damage_refresh_status(struct redraw_draw_ctx *dctx,
+    struct window_pane *wp)
+{
+	struct redraw_span	*first;
+	u_int			 width;
+
+	if ((wp->flags & PANE_NEWSTATUS) &&
+	    wp->status_serial == redraw_status_serial)
+		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);
+	}
+	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. */
+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_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;
+
+	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);
+
+	/*
+	 * 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;
+		if (width > screen_size_x(&screen) - px)
+			width = screen_size_x(&screen) - px;
+		tty_draw_line(tty, &screen, px, 0, width, x0, 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.
+ */
+static void
+redraw_draw_damage_rect(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;
+
+	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) {
+				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)
+					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);
+				if (type == REDRAW_SPAN_PANE) {
+					redraw_damage_draw_pane_prompt(dctx,
+					    span, cy, clip_x,
+					    clip_end - clip_x);
+				}
+			}
+		}
+	}
+}
+
+/*
+ * 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().
+ */
+void
+redraw_client_damage(struct client *c)
+{
+	struct window		*w = c->session->curw->window;
+	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_serial++;
+
+	scene = redraw_get_scene(c);
+	if (scene == NULL)
+		return;
+	redraw_set_draw_context(&dctx, scene);
+	redraw_get_window_offset(c, &ox, &oy, &sx, &sy);
+
+	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)
+			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);
+	}
+}

screen-write.c

@@ -120,14 +120,39 @@ screen_write_set_cursor(struct screen_write_ctx *ctx, int cx, int cy)
 		evtimer_add(&w->offset_timer, &tv);
 }
 
-/* Do a full redraw. */
+/*
+ * 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.
+ */
 static void
-screen_write_redraw_cb(const struct tty_ctx *ttyctx)
+screen_write_redraw_cb(const struct tty_ctx *ttyctx, u_int py, u_int ny)
 {
 	struct window_pane	*wp = ttyctx->arg;
+	int			 x0, y0, x1, y1;
 
-	if (wp != NULL)
-		wp->flags |= PANE_REDRAW;
+	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)
+		return;
+	redraw_damage_window(wp->window, (u_int)x0, (u_int)y0,
+	    (u_int)(x1 - x0), (u_int)(y1 - y0));
 }
 
 /* Update context for client. */
@@ -2155,7 +2180,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);
+		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
 }
 
 /* Trim collected items. */
@@ -3175,7 +3200,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);
+		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
 }
 
 /* Turn alternate screen off. */
@@ -3200,5 +3225,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);
+		ttyctx.redraw_cb(&ttyctx, 0, ttyctx.sy);
 }

server-client.c

@@ -356,7 +356,33 @@ 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);
-		server_redraw_client(c);
+
+		/*
+		 * 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.
+		 */
+		if (old == NULL || old != s ||
+		    !redraw_client_has_window(c, s->curw->window))
+			server_redraw_client(c);
 	}
 
 	server_check_unattached();
@@ -1351,8 +1377,19 @@ server_client_key_callback(struct cmdq_item *item, void *data)
 		/*
 		 * 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.
 		 */
 		if ((key & KEYC_MASK_KEY) == KEYC_DRAGGING) {
+			tty_sync_start(&c->tty);
 			c->tty.mouse_drag_update(c, m);
 			goto out;
 		}
@@ -1780,7 +1817,12 @@ server_client_loop(void)
 
 	/*
 	 * Any windows will have been redrawn as part of clients, so clear
-	 * their flags now.
+	 * 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.
 	 */
 	RB_FOREACH(w, windows, &windows) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
@@ -1791,6 +1833,8 @@ server_client_loop(void)
 			wp->flags &= ~(PANE_REDRAW|PANE_REDRAWSCROLLBAR|
 			    PANE_ACTIVITY);
 		}
+		redraw_free_damage(w);
+
 		check_window_name(w);
 	}
 
@@ -2336,6 +2380,8 @@ 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);
@@ -2380,9 +2426,25 @@ server_client_check_redraw(struct client *c)
 	/*
 	 * 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.
+	 * 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.
 	 */
 	n = EVBUFFER_LENGTH(tty->out);
+	if ((tty->flags & TTY_SYNCING) && n > tty->sync_offset)
+		n = tty->sync_offset;
 	if (n != 0 || (tty->flags & TTY_BLOCK)) {
 		if (n != 0)
 			log_debug("%s: redraw deferred (%zu left)", c->name, n);
@@ -2394,6 +2456,8 @@ server_client_check_redraw(struct client *c)
 			log_debug("redraw timer started");
 			evtimer_add(&ev, &tv);
 		}
+		if (!TAILQ_EMPTY(&w->damage))
+			c->flags |= CLIENT_REDRAWWINDOW;
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->flags & PANE_REDRAW) {
 				c->flags |= CLIENT_REDRAWWINDOW;
@@ -2427,6 +2491,20 @@ server_client_check_redraw(struct client *c)
 				redraw_pane_scrollbar(c, wp);
 			}
 		}
+
+		/*
+		 * 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)
+			redraw_client_damage(c);
 	}
 
 	/*
@@ -2440,6 +2518,7 @@ 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

@@ -69,6 +69,7 @@ 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;
@@ -1402,6 +1403,7 @@ struct window_pane {
 	struct screen	 base;
 
 	struct screen	 status_screen;
+	u_int		 status_serial;
 
 	TAILQ_HEAD(, window_mode_entry) modes;
 
@@ -1432,6 +1434,7 @@ 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 {
@@ -1475,6 +1478,9 @@ 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;
@@ -1800,6 +1806,14 @@ 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;
 
 	struct grid_cell cell;
@@ -1847,7 +1861,7 @@ struct tty {
 };
 
 /* Terminal command context. */
-typedef void (*tty_ctx_redraw_cb)(const struct tty_ctx *);
+typedef void (*tty_ctx_redraw_cb)(const struct tty_ctx *, u_int, u_int);
 typedef int (*tty_ctx_set_client_cb)(struct tty_ctx *, struct client *);
 struct tty_ctx {
 	struct screen		*s;
@@ -3634,8 +3648,12 @@ 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 */
@@ -3809,6 +3827,8 @@ 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 *);
 
 /* window-border.c */

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->redraw_cb(ctx, ctx->orupper, ctx->orlower - ctx->orupper + 1);
 		return;
 	}
 
@@ -1517,6 +1517,7 @@ 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);
@@ -1923,7 +1924,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);
+		ctx->redraw_cb(ctx, 0, ctx->sy);
 		return;
 	}
 
@@ -1982,7 +1983,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->redraw_cb(ctx, ctx->ocy, 1);
 		return;
 	}
 

window-copy.c

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

@@ -415,6 +415,7 @@ 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;
@@ -468,6 +469,7 @@ 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);
@@ -718,6 +720,7 @@ 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);
 
@@ -725,7 +728,8 @@ window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 		return (0);
 	if (w->modal != NULL && wp != w->modal)
 		return (0);
-	if ((w->flags & WINDOW_ZOOMED) && !window_pane_is_visible(wp))
+	unzoomed = (w->flags & WINDOW_ZOOMED) && !window_pane_is_visible(wp);
+	if (unzoomed)
 		window_unzoom(w, 1);
 	lastwp = w->active;
 
@@ -742,7 +746,19 @@ window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
 	}
 
 	tty_update_window_offset(w);
-	server_redraw_window(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);
+	}
 
 	if (notify)
 		window_fire_pane_changed(w, w->active, lastwp);
@@ -2925,3 +2941,109 @@ window_pane_is_floating_with_hidden(struct window_pane *wp)
 		return (0);
 	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.
+ */
+static void
+window_pane_damage_floating(struct window *w, struct window_pane *wp,
+    int xoff, int yoff, int sx, int sy)
+{
+	int	x0, x1, y0, y1, sb_left = 0, sb_right = 0;
+
+	if (window_pane_scrollbar_reserve(wp)) {
+		if (w->sb_pos == PANE_SCROLLBARS_LEFT)
+			sb_left = wp->scrollbar_style.width +
+			    wp->scrollbar_style.pad;
+		else
+			sb_right = wp->scrollbar_style.width +
+			    wp->scrollbar_style.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)
+		return;
+	redraw_damage_window(w, (u_int)x0, (u_int)y0, (u_int)(x1 - x0) + 1,
+	    (u_int)(y1 - y0) + 1);
+}
+
+/*
+ * 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).
+ */
+void
+window_pane_redraw_floating(struct window *w, struct window_pane *wp,
+    int old_xoff, int old_yoff, int old_sx, int old_sy)
+{
+	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);
+}