Merge updated OSC 133 output commands

Add pipe-selection copy mode command
Merge OSC 133 output commands with fold view
2026-09-16 18:21:58 +00:00 · 2026-09-14 06:26:06 +01:00 · 2026-09-14 06:25:40 +01:00 · 2026-09-14 05:43:59 +01:00 · 2026-09-14 05:35:34 +01:00 · 2026-09-14 05:35:00 +01:00
39 changed files with 4122 additions and 489 deletions
--- a/Makefile.am
+++ b/Makefile.am
@@ -188,6 +188,7 @@ dist_tmux_SOURCES = \
 	options-table.c \
 	options.c \
 	paste.c \
+	popup.c \
 	proc.c \
 	prompt-history.c \
 	prompt.c \
--- a/cmd-copy-mode.c
+++ b/cmd-copy-mode.c
@@ -30,8 +30,8 @@ const struct cmd_entry cmd_copy_mode_entry = {
 	.name = "copy-mode",
 	.alias = NULL,

-	.args = { "dekHMqSs:t:u", 0, 0, NULL },
-	.usage = "[-dekHMqSu] [-s src-pane] " CMD_TARGET_PANE_USAGE,
+	.args = { "UcdekHMqSs:t:u", 0, 0, NULL },
+	.usage = "[-UcdekHMqSu] [-s src-pane] " CMD_TARGET_PANE_USAGE,

 	.source =  { 's', CMD_FIND_PANE, 0 },
 	.target = { 't', CMD_FIND_PANE, 0 },
--- a/cmd-display-menu.c
+++ b/cmd-display-menu.c
@@ -54,8 +54,8 @@ const struct cmd_entry cmd_display_popup_entry = {
 	.name = "display-popup",
 	.alias = "popup",

-	.args = { "Bb:Cc:d:e:Eh:ks:S:t:T:w:x:y:", 0, -1, NULL },
-	.usage = "[-BCEk] [-b border-lines] [-c target-client] "
+	.args = { "Bb:Cc:d:e:Eh:kNs:S:t:T:w:x:y:", 0, -1, NULL },
+	.usage = "[-BCEkN] [-b border-lines] [-c target-client] "
 		 "[-d start-directory] [-e environment] [-h height] "
 		 "[-s style] [-S border-style] " CMD_TARGET_PANE_USAGE
 		 " [-T title] [-w width] [-x position] [-y position] "
@@ -91,6 +91,203 @@ cmd_display_menu_args_parse(struct args *args, u_int idx, __unused char **cause)
 	return (type);
 }

+static int
+cmd_display_menu_get_popup_pos(struct client *tc, struct cmdq_item *item,
+    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
+{
+	struct tty		*tty = &tc->tty;
+	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct key_event	*event = cmdq_get_event(item);
+	struct session		*s = tc->session;
+	struct winlink		*wl = target->wl;
+	struct window_pane	*wp = target->wp;
+	struct style_ranges	*ranges = NULL;
+	struct style_range	*sr = NULL;
+	const char		*xp, *yp;
+	char			*p;
+	int			 top;
+	u_int			 line, ox, oy, sx, sy, lines, position;
+	long			 n;
+	struct format_tree	*ft;
+
+	/*
+	 * Work out the position from the -x and -y arguments. This is the
+	 * bottom-left position.
+	 */
+
+	/* If the popup is too big, stop now. */
+	if (w > tty->sx || h > tty->sy)
+		return (0);
+
+	/* Create format with mouse position if any. */
+	ft = format_create_from_target(item);
+	if (event->m.valid) {
+		format_add(ft, "popup_mouse_x", "%u", event->m.x);
+		format_add(ft, "popup_mouse_y", "%u", event->m.y);
+	}
+
+	/* Position of the previous menu, for -x/-y L. */
+	format_add(ft, "popup_last_x", "%u", target->w->menu_last_px);
+	format_add(ft, "popup_last_y", "%u", target->w->menu_last_py + h);
+
+	/*
+	 * If there are any status lines, add this window position and the
+	 * status line position.
+	 */
+	top = status_at_line(tc);
+	if (top != -1) {
+		lines = status_line_size(tc);
+		if (top == 0)
+			top = lines;
+		else
+			top = 0;
+		position = options_get_number(s->options, "status-position");
+
+		for (line = 0; line < lines; line++) {
+			ranges = &tc->status.entries[line].ranges;
+			TAILQ_FOREACH(sr, ranges, entry) {
+				if (sr->type != STYLE_RANGE_WINDOW)
+					continue;
+				if (sr->argument == (u_int)wl->idx)
+					break;
+			}
+			if (sr != NULL)
+				break;
+		}
+
+		if (sr != NULL) {
+			format_add(ft, "popup_window_status_line_x", "%u",
+			    sr->start);
+			if (position == 0) {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", line + 1 + h);
+			} else {
+				format_add(ft, "popup_window_status_line_y",
+				    "%u", tty->sy - lines + line);
+			}
+		}
+
+		if (position == 0)
+			format_add(ft, "popup_status_line_y", "%u", lines + h);
+		else {
+			format_add(ft, "popup_status_line_y", "%u",
+			    tty->sy - lines);
+		}
+	} else
+		top = 0;
+
+	/* Popup width and height. */
+	format_add(ft, "popup_width", "%u", w);
+	format_add(ft, "popup_height", "%u", h);
+
+	/* Position so popup is in the centre. */
+	n = (long)(tty->sx - 1) / 2 - w / 2;
+	if (n < 0)
+		format_add(ft, "popup_centre_x", "%u", 0);
+	else
+		format_add(ft, "popup_centre_x", "%ld", n);
+	n = (tty->sy - 1) / 2 + h / 2;
+	if (n >= tty->sy)
+		format_add(ft, "popup_centre_y", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_centre_y", "%ld", n);
+
+	/* Position of popup relative to mouse. */
+	if (event->m.valid) {
+		n = (long)event->m.x - w / 2;
+		if (n < 0)
+			format_add(ft, "popup_mouse_centre_x", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_centre_x", "%ld", n);
+		n = event->m.y - h / 2;
+		if (n + h >= tty->sy) {
+			format_add(ft, "popup_mouse_centre_y", "%u",
+			    tty->sy - h);
+		} else
+			format_add(ft, "popup_mouse_centre_y", "%ld", n);
+		n = (long)event->m.y + h;
+		if (n >= tty->sy)
+			format_add(ft, "popup_mouse_top", "%u", tty->sy - 1);
+		else
+			format_add(ft, "popup_mouse_top", "%ld", n);
+		n = event->m.y - h;
+		if (n < 0)
+			format_add(ft, "popup_mouse_bottom", "%u", 0);
+		else
+			format_add(ft, "popup_mouse_bottom", "%ld", n);
+	}
+
+	/* Position in pane. */
+	tty_window_offset(&tc->tty, &ox, &oy, &sx, &sy);
+	n = top + wp->yoff - oy + h;
+	if (n >= tty->sy)
+		format_add(ft, "popup_pane_top", "%u", tty->sy - h);
+	else
+		format_add(ft, "popup_pane_top", "%ld", n);
+	format_add(ft, "popup_pane_bottom", "%u", top + wp->yoff + wp->sy - oy);
+	format_add(ft, "popup_pane_left", "%u", wp->xoff - ox);
+	n = (long)wp->xoff + wp->sx - ox - w;
+	if (n < 0)
+		format_add(ft, "popup_pane_right", "%u", 0);
+	else
+		format_add(ft, "popup_pane_right", "%ld", n);
+
+	/* Expand horizontal position. */
+	xp = args_get(args, 'x');
+	if (xp == NULL || strcmp(xp, "C") == 0)
+		xp = "#{popup_centre_x}";
+	else if (strcmp(xp, "R") == 0)
+		xp = "#{popup_pane_right}";
+	else if (strcmp(xp, "P") == 0)
+		xp = "#{popup_pane_left}";
+	else if (strcmp(xp, "M") == 0)
+		xp = "#{popup_mouse_centre_x}";
+	else if (strcmp(xp, "L") == 0)
+		xp = "#{popup_last_x}";
+	else if (strcmp(xp, "W") == 0)
+		xp = "#{popup_window_status_line_x}";
+	p = format_expand(ft, xp);
+	n = strtol(p, NULL, 10);
+	if (n + w >= tty->sx)
+		n = tty->sx - w;
+	else if (n < 0)
+		n = 0;
+	*px = n;
+	log_debug("%s: -x: %s = %s = %u (-w %u)", __func__, xp, p, *px, w);
+	free(p);
+
+	/* Expand vertical position  */
+	yp = args_get(args, 'y');
+	if (yp == NULL || strcmp(yp, "C") == 0)
+		yp = "#{popup_centre_y}";
+	else if (strcmp(yp, "P") == 0)
+		yp = "#{popup_pane_bottom}";
+	else if (strcmp(yp, "M") == 0)
+		yp = "#{popup_mouse_top}";
+	else if (strcmp(yp, "L") == 0)
+		yp = "#{popup_last_y}";
+	else if (strcmp(yp, "S") == 0)
+		yp = "#{popup_status_line_y}";
+	else if (strcmp(yp, "W") == 0)
+		yp = "#{popup_window_status_line_y}";
+	p = format_expand(ft, yp);
+	n = strtol(p, NULL, 10);
+	if (n < h)
+		n = 0;
+	else
+		n -= h;
+	if (n + h >= tty->sy)
+		n = tty->sy - h;
+	else if (n < 0)
+		n = 0;
+	*py = n;
+	log_debug("%s: -y: %s = %s = %u (-h %u)", __func__, yp, p, *py, h);
+	free(p);
+
+	format_free(ft);
+	return (1);
+}
+
 static int
 cmd_display_menu_get_menu_pos(struct client *tc, struct cmdq_item *item,
    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
@@ -368,22 +565,6 @@ fail:
 	return (CMD_RETURN_ERROR);
 }

-static enum pane_lines
-cmd_display_popup_get_lines(const char *value, char **cause)
-{
-	const struct options_table_entry	*oe;
-
-	if (value == NULL)
-		value = "single";
-	else if (strcmp(value, "rounded") == 0)
-		value = "single";
-	else if (strcmp(value, "padded") == 0)
-		value = "spaces";
-
-	oe = options_search("pane-border-lines");
-	return (options_find_choice(oe, value, cause));
-}
-
 static enum cmd_retval
 cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
 {
@@ -391,199 +572,148 @@ cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
 	struct cmd_find_state	*target = cmdq_get_target(item);
 	struct session		*s = target->s;
 	struct client		*tc = cmdq_get_target_client(item);
-	struct winlink		*wl = target->wl;
-	struct window		*w = wl->window;
-	struct window_pane	*wp = target->wp, *new_wp = NULL;
-	struct spawn_context	 sc = { 0 };
-	struct layout_cell	*lc = NULL;
-	struct layout_geometry	 lg;
-	struct event_payload	*ep;
-	struct cmd_find_state	 fs;
-	const char		*value, *style = args_get(args, 's');
+	struct tty		*tty = &tc->tty;
+	const char		*value, *shell, *shellcmd = NULL;
+	const char		*style = args_get(args, 's');
 	const char		*border_style = args_get(args, 'S');
-	char			*cause = NULL, *title = NULL;
-	enum pane_lines		 lines = PANE_LINES_SINGLE;
-	u_int			 px, py, sx, sy, count = args_count(args);
+	char			*cwd = NULL, *cause = NULL, **argv = NULL;
+	char			*title = NULL;
+	int			 modify = popup_present(tc);
+	int			 flags = -1, argc = 0;
+	enum box_lines		 lines = BOX_LINES_DEFAULT;
+	u_int			 px, py, w, h, count = args_count(args);
 	struct args_value	*av;
-	long long		 ll;
+	struct environ		*env = NULL;
+	struct options		*o = s->curw->window->options;
+	struct options_entry	*oe;

 	if (args_has(args, 'C')) {
-		if (w->modal != NULL)
-			server_kill_pane(w->modal);
+		server_client_clear_overlay(tc);
 		return (CMD_RETURN_NORMAL);
 	}
 	if (tc->flags & CLIENT_CONTROL)
 		return (CMD_RETURN_NORMAL);
-	if (w->modal != NULL)
+	if (!modify && tc->overlay_draw != NULL)
 		return (CMD_RETURN_NORMAL);

+	if (!modify) {
+		h = tty->sy / 2;
+		if (args_has(args, 'h')) {
+			h = args_percentage(args, 'h', 1, tty->sy, tty->sy,
+			    &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "height %s", cause);
+				goto fail;
+			}
+		}
+
+		w = tty->sx / 2;
+		if (args_has(args, 'w')) {
+			w = args_percentage(args, 'w', 1, tty->sx, tty->sx,
+			    &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "width %s", cause);
+				goto fail;
+			}
+		}
+
+		if (w > tty->sx)
+			w = tty->sx;
+		if (h > tty->sy)
+			h = tty->sy;
+		if (!cmd_display_menu_get_popup_pos(tc, item, args, &px, &py,
+		    w, h))
+			goto out;
+
+		value = args_get(args, 'd');
+		if (value != NULL)
+			cwd = format_single_from_target(item, value);
+		else
+			cwd = xstrdup(server_client_get_cwd(tc, s));
+		if (count == 0) {
+			shellcmd = options_get_string(s->options,
+			    "default-command");
+		} else if (count == 1)
+			shellcmd = args_string(args, 0);
+		if (count <= 1 && (shellcmd == NULL || *shellcmd == '\0')) {
+			shellcmd = NULL;
+			shell = options_get_string(s->options, "default-shell");
+			if (!checkshell(shell))
+				shell = _PATH_BSHELL;
+			cmd_append_argv(&argc, &argv, shell);
+		} else
+			args_to_vector(args, &argc, &argv);
+
+		if (args_has(args, 'e') >= 1) {
+			env = environ_create();
+			av = args_first_value(args, 'e');
+			while (av != NULL) {
+				environ_put(env, av->string, 0);
+				av = args_next_value(av);
+			}
+		}
+	}
+
 	value = args_get(args, 'b');
 	if (args_has(args, 'B'))
-		lines = PANE_LINES_NONE;
+		lines = BOX_LINES_NONE;
 	else if (value != NULL) {
-		lines = cmd_display_popup_get_lines(value, &cause);
+		oe = options_get(o, "popup-border-lines");
+		lines = options_find_choice(options_table_entry(oe), value,
+		    &cause);
 		if (cause != NULL) {
-			cmdq_error(item, "pane-border-lines %s", cause);
+			cmdq_error(item, "popup-border-lines %s", cause);
 			goto fail;
 		}
 	}

-	sy = w->sy / 2;
-	if (args_has(args, 'h')) {
-		ll = args_percentage(args, 'h', 1, w->sy, w->sy, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "height %s", cause);
-			goto fail;
-		}
-		sy = ll;
-	}
-
-	sx = w->sx / 2;
-	if (args_has(args, 'w')) {
-		ll = args_percentage(args, 'w', 1, w->sx, w->sx, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "width %s", cause);
-			goto fail;
-		}
-		sx = ll;
-	}
-
-	if (sx > w->sx)
-		sx = w->sx;
-	if (sy > w->sy)
-		sy = w->sy;
-	if ((lines == PANE_LINES_NONE && (sx < 1 || sy < 1)) ||
-	    (lines != PANE_LINES_NONE && (sx < 3 || sy < 3)))
-		goto out;
-	if (!cmd_display_menu_get_menu_pos(tc, item, args, &px, &py, sx, sy))
-		goto out;
-
-	lg.sx = sx;
-	lg.sy = sy;
-	lg.xoff = px;
-	lg.yoff = py;
-	if (lines != PANE_LINES_NONE) {
-		lg.sx -= 2;
-		lg.sy -= 2;
-		lg.xoff++;
-		lg.yoff++;
-	}
-
-	window_push_zoom(w, 0, 1);
-	lc = layout_floating_pane(w, wp, &lg);
-	if (lc == NULL) {
-		window_pop_zoom(w);
-		goto out;
-	}
-
-	sc.item = item;
-	sc.s = s;
-	sc.wl = wl;
-	sc.tc = tc;
-	sc.wp0 = wp;
-	sc.lc = lc;
-	sc.idx = -1;
-	sc.cwd = args_get(args, 'd');
-	sc.flags = (SPAWN_FLOATING|SPAWN_MODAL|SPAWN_FLOATOVERZOOM);
-
-	if (count != 1 || *args_string(args, 0) != '\0')
-		args_to_vector(args, &sc.argc, &sc.argv);
-	sc.environ = environ_create();
-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(sc.environ, av->string, 0);
-		av = args_next_value(av);
-	}
-
-	new_wp = spawn_pane(&sc, &cause);
-	if (new_wp == NULL) {
-		cmdq_error(item, "create pane failed: %s", cause);
-		free(cause);
-		cause = NULL;
-		window_pop_zoom(w);
-		goto fail;
-	}
-	window_pop_zoom(w);
-	new_wp->flags |= PANE_CAPTUREALLKEYS;
-	if (!args_has(args, 'E'))
-		new_wp->flags |= PANE_CLOSEONCANCEL;
-
-	options_set_number(new_wp->options, "pane-border-lines", lines);
-	if (args_has(args, 'E') > 1) {
-		if (args_has(args, 'k'))
-			options_set_number(new_wp->options, "remain-on-exit", 4);
-		else
-			options_set_number(new_wp->options, "remain-on-exit", 2);
-	} else if (args_has(args, 'E'))
-		options_set_number(new_wp->options, "remain-on-exit", 0);
-	else if (args_has(args, 'k'))
-		options_set_number(new_wp->options, "remain-on-exit", 3);
-	else
-		options_set_number(new_wp->options, "remain-on-exit", 1);
-	options_set_string(new_wp->options, "remain-on-exit-format", 0, "%s", "");
-
-	if (style != NULL) {
-		if (options_set_string(new_wp->options, "window-style", 0,
-		    "%s", style) == NULL) {
-			cmdq_error(item, "bad style: %s", style);
-			goto fail;
-		}
-		options_set_string(new_wp->options, "window-active-style", 0,
-		    "%s", style);
-		new_wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|
-		    PANE_THEMECHANGED);
-	}
-	if (border_style != NULL) {
-		if (options_set_string(new_wp->options, "pane-border-style", 0,
-		    "%s", border_style) == NULL) {
-			cmdq_error(item, "bad border style: %s", border_style);
-			goto fail;
-		}
-		options_set_string(new_wp->options, "pane-active-border-style",
-		    0, "%s", border_style);
-	}
 	if (args_has(args, 'T'))
 		title = format_single_from_target(item, args_get(args, 'T'));
-	if (title != NULL) {
-		options_set_number(new_wp->options, "pane-border-status",
-		    PANE_STATUS_TOP);
-		options_set_string(new_wp->options, "pane-border-format", 0,
-		    "%s", "#{pane_title}");
-		screen_set_title(&new_wp->base, title, 0);
-		ep = event_payload_create();
-		cmd_find_from_pane(&fs, new_wp, 0);
-		event_payload_set_target(ep, &fs);
-		event_payload_set_pane(ep, "pane", new_wp);
-		event_payload_set_window(ep, "window", new_wp->window);
-		event_payload_set_string(ep, "new_title", "%s", title);
-		events_fire("pane-title-changed", ep);
+	else
+		title = xstrdup("");
+
+	if (args_has(args, 'N') || !modify)
+		flags = 0;
+	if (args_has(args, 'E') > 1) {
+		if (flags == -1)
+			flags = 0;
+		flags |= POPUP_CLOSEEXITZERO;
+	} else if (args_has(args, 'E')) {
+		if (flags == -1)
+			flags = 0;
+		flags |= POPUP_CLOSEEXIT;
+	}
+	if (args_has(args, 'k')) {
+		if (flags == -1)
+			flags = 0;
+		flags |= POPUP_CLOSEANYKEY;
 	}

-	new_wp->wait_item = item;
-	server_redraw_session(s);
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
-	environ_free(sc.environ);
+	if (modify) {
+		popup_modify(tc, title, style, border_style, lines, flags);
+		goto out;
+	}
+	if (popup_display(flags, lines, item, px, py, w, h, env, shellcmd, argc,
+	    argv, cwd, title, tc, s, style, border_style, NULL, NULL) != 0)
+		goto out;
+	environ_free(env);
+	free(cwd);
 	free(title);
+	cmd_free_argv(argc, argv);
 	return (CMD_RETURN_WAIT);

 out:
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
-	environ_free(sc.environ);
+	cmd_free_argv(argc, argv);
+	environ_free(env);
+	free(cwd);
 	free(title);
 	return (CMD_RETURN_NORMAL);

 fail:
 	free(cause);
-	if (new_wp != NULL) {
-		server_client_remove_pane(new_wp);
-		layout_close_pane(new_wp);
-		window_remove_pane(new_wp->window, new_wp);
-	}
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
-	environ_free(sc.environ);
+	cmd_free_argv(argc, argv);
+	environ_free(env);
+	free(cwd);
 	free(title);
 	return (CMD_RETURN_ERROR);
 }
--- a/fuzz/input-fuzzer.c
+++ b/fuzz/input-fuzzer.c
@@ -44,7 +44,7 @@ LLVMFuzzerTestOneInput(const u_char *data, size_t size)
 	w = window_create(PANE_WIDTH, PANE_HEIGHT, 0, 0);
 	wp = window_add_pane(w, NULL, 0, 0);
 	bufferevent_pair_new(libevent, BEV_OPT_CLOSE_ON_FREE, vpty);
-	wp->ictx = input_init(wp, vpty[0], NULL);
+	wp->ictx = input_init(wp, vpty[0], NULL, NULL);
 	window_add_ref(w, __func__);

 	wp->fd = open("/dev/null", O_WRONLY);
--- a/grid.c
+++ b/grid.c
@@ -1760,6 +1760,8 @@ grid_line_flags_string(int flags)
 		strlcat(s, "START_OUTPUT,", sizeof s);
 	if (flags & GRID_LINE_END_OUTPUT)
 		strlcat(s, "END_OUTPUT,", sizeof s);
+	if (flags & GRID_LINE_END_OUTPUT_STATUS)
+		strlcat(s, "END_OUTPUT_STATUS,", sizeof s);
 	if (flags & GRID_LINE_HYPERLINK)
 		strlcat(s, "HYPERLINK,", sizeof s);
 	if (*s == '\0')
--- a/input.c
+++ b/input.c
@@ -101,6 +101,7 @@ struct input_ctx {
 	struct bufferevent	       *event;
 	struct screen_write_ctx		ctx;
 	struct colour_palette	       *palette;
+	struct client		       *c;

 	struct input_cell		cell;
 	struct input_cell		old_cell;
@@ -873,7 +874,7 @@ input_restore_state(struct input_ctx *ictx)
 /* Initialise input parser. */
 struct input_ctx *
 input_init(struct window_pane *wp, struct bufferevent *bev,
-    struct colour_palette *palette)
+    struct colour_palette *palette, struct client *c)
 {
 	struct input_ctx	*ictx;

@@ -881,6 +882,7 @@ input_init(struct window_pane *wp, struct bufferevent *bev,
 	ictx->wp = wp;
 	ictx->event = bev;
 	ictx->palette = palette;
+	ictx->c = c;

 	ictx->input_space = INPUT_BUF_START;
 	ictx->input_buf = xmalloc(INPUT_BUF_START);
@@ -3192,13 +3194,14 @@ input_osc_112(struct input_ctx *ictx, const char *p)

 /* Parse the OSC 133 D exit status. */
 static int
-input_osc_133_exit_status(const char *p)
+input_osc_133_exit_status(const char *p, int *present)
 {
 	const char	*end;
 	char		*copy;
-	const char	*errstr;
+	char		*endptr;
 	long long	 status;

+	*present = 0;
 	if (p[1] != ';' || p[2] == '\0' || strchr(p + 2, '=') == p + 2)
 		return (0);
 	end = strchr(p + 2, ';');
@@ -3212,9 +3215,11 @@ input_osc_133_exit_status(const char *p)
 		free(copy);
 		return (0);
 	}
-	status = strtonum(copy, 0, 255, &errstr);
+	*present = 1;
+	errno = 0;
+	status = (int)strtol(copy, &endptr, 10);
 	free(copy);
-	if (errstr != NULL)
+	if (errno != 0 || endptr == copy || status < 0 || status > 255)
 		return (255);
 	return (status);
 }
@@ -3259,6 +3264,22 @@ input_fire_command_event(struct window_pane *wp, const char *name)
 	events_fire(name, ep);
 }

+/* Check if an OSC 133 prompt is secondary or a continuation. */
+static int
+input_osc_133_secondary_prompt(const char *p)
+{
+	const char	*cp;
+
+	while ((cp = strstr(p, ";k=")) != NULL) {
+		cp += 3;
+		if ((*cp == 's' || *cp == 'c') &&
+		    (cp[1] == '\0' || cp[1] == ';'))
+			return (1);
+		p = cp;
+	}
+	return (0);
+}
+
 /* Handle the OSC 133 sequence. */
 static void
 input_osc_133(struct input_ctx *ictx, const char *p)
@@ -3268,8 +3289,7 @@ input_osc_133(struct input_ctx *ictx, const char *p)
 	struct grid		*gd = s->grid;
 	u_int			 line = s->cy + gd->hsize;
 	struct grid_line	*gl = NULL;
-	const char		*cp;
-	int			 status;
+	int			 status, status_present;

 	if (line < gd->hsize + gd->sy)
 		gl = grid_get_line(gd, line);
@@ -3278,9 +3298,14 @@ input_osc_133(struct input_ctx *ictx, const char *p)
 	case 'A':
 	case 'N':
 		if (gl != NULL) {
-			memset(&gl->osc133_data, 0, sizeof gl->osc133_data);
-			gl->osc133_data.prompt_col = s->cx;
-			gl->flags |= GRID_LINE_START_PROMPT;
+			if (!(gl->flags & (GRID_LINE_START_PROMPT|
+			    GRID_LINE_SECOND_PROMPT))) {
+				gl->osc133_data.prompt_col = s->cx;
+				if (input_osc_133_secondary_prompt(p))
+					gl->flags |= GRID_LINE_SECOND_PROMPT;
+				else
+					gl->flags |= GRID_LINE_START_PROMPT;
+			}
 		}
 		if (wp != NULL) {
 			wp->last_prompt_time = time(NULL);
@@ -3289,23 +3314,25 @@ input_osc_133(struct input_ctx *ictx, const char *p)
 		break;
 	case 'P':
 		if (gl != NULL) {
-			cp = strstr(p, ";k=s");
-			if (cp != NULL && (cp[4] == ';' || cp[4] == '\0'))
-				gl->flags |= GRID_LINE_SECOND_PROMPT;
-			else
-				gl->flags |= GRID_LINE_START_PROMPT;
-			gl->osc133_data.prompt_col = s->cx;
+			if (!(gl->flags & (GRID_LINE_START_PROMPT|
+			    GRID_LINE_SECOND_PROMPT))) {
+				gl->osc133_data.prompt_col = s->cx;
+				if (input_osc_133_secondary_prompt(p))
+					gl->flags |= GRID_LINE_SECOND_PROMPT;
+				else
+					gl->flags |= GRID_LINE_START_PROMPT;
+			}
 		}
 		break;
 	case 'B':
 	case 'I':
-		if (gl != NULL) {
+		if (gl != NULL && !(gl->flags & GRID_LINE_START_COMMAND)) {
 			gl->flags |= GRID_LINE_START_COMMAND;
 			gl->osc133_data.cmd_col = s->cx;
 		}
 		break;
 	case 'C':
-		if (gl != NULL) {
+		if (gl != NULL && !(gl->flags & GRID_LINE_START_OUTPUT)) {
 			gl->flags |= GRID_LINE_START_OUTPUT;
 			gl->osc133_data.out_start_col = s->cx;
 		}
@@ -3318,7 +3345,7 @@ input_osc_133(struct input_ctx *ictx, const char *p)
 		}
 		break;
 	case 'D':
-		status = input_osc_133_exit_status(p);
+		status = input_osc_133_exit_status(p, &status_present);
 		if (wp != NULL) {
 			wp->cmd_end_time = time(NULL);
 			wp->flags &= ~PANE_CMDRUNNING;
@@ -3327,6 +3354,8 @@ input_osc_133(struct input_ctx *ictx, const char *p)
 		}
 		if (gl != NULL) {
 			gl->flags |= GRID_LINE_END_OUTPUT;
+			if (status_present)
+				gl->flags |= GRID_LINE_END_OUTPUT_STATUS;
 			gl->osc133_data.out_end_col = s->cx;
 			gl->osc133_data.exit_status = status;
 		}
@@ -3423,9 +3452,15 @@ input_osc_52(struct input_ctx *ictx, const char *p)
 		return;

 	if (wp == NULL) {
-		free(out);
-		return;
+		/* Popup window. */
+		if (ictx->c == NULL) {
+			free(out);
+			return;
+		}
+		tty_set_selection(&ictx->c->tty, clip, out, outlen);
+		paste_add(NULL, out, outlen);
 	} else {
+		/* Normal window. */
 		screen_write_start_pane(&ctx, wp, NULL);
 		screen_write_setselection(&ctx, clip, out, outlen);
 		screen_write_stop(&ctx);
--- a/key-bindings.c
+++ b/key-bindings.c
@@ -52,7 +52,9 @@
 	" '#{?#{m/r:(copy|view)-mode,#{pane_mode}},Go To Top,}' '<' {send -X history-top}" \
 	" '#{?#{m/r:(copy|view)-mode,#{pane_mode}},Go To Bottom,}' '>' {send -X history-bottom}" \
 	" ''" \
-	" '#{?#{==:#{pane_mode},copy-mode},#{?copy_line_numbers,Hide Line Numbers,Show Line Numbers},}' 'L' {send -X line-numbers-toggle}" \
+	" '#{?#{==:#{pane_mode},copy-mode},#{?copy_line_numbers,Line Numbers Off,Line Numbers On},}' 'L' {send -X line-numbers-toggle}" \
+	" '#{?#{==:#{pane_mode},copy-mode},#{?copy_fold_view,Fold View Off,Fold View On},}' 'O' {send -X fold-view-toggle}" \
+	" '#{?#{==:#{pane_mode},copy-mode},Edit,}' 'e' {if -F '#{selection_present}' {send -X open-selection} {send -X open-output}}" \
 	" '#{?#{==:#{pane_mode},copy-mode},#{?refresh_active,Refresh Off,Refresh On},}' 'r' {send -X refresh-toggle}" \
 	" ''" \
 	" '#{?#{&&:#{buffer_size},#{!:#{pane_in_mode}}},Paste #[underscore]#{=/9/...:buffer_sample},}' 'p' {paste-buffer}" \
@@ -575,6 +577,7 @@ key_bindings_init(void)
 		"bind -Tcopy-mode C-l { send -X recentre-top-bottom }",
 		"bind -Tcopy-mode M-l { send -X cursor-centre-horizontal }",
 		"bind -Tcopy-mode C-n { send -X cursor-down }",
+		"bind -Tcopy-mode C-o { send -X select-output }",
 		"bind -Tcopy-mode C-p { send -X cursor-up }",
 		"bind -Tcopy-mode C-r { command-prompt -P -T search -ip'(search up)' -I'#{pane_search_string}' { send -X search-backward-incremental -- '%%' } }",
 		"bind -Tcopy-mode C-s { command-prompt -P -T search -ip'(search down)' -I'#{pane_search_string}' { send -X search-forward-incremental -- '%%' } }",
@@ -583,15 +586,19 @@ key_bindings_init(void)
 		"bind -Tcopy-mode Escape { send -X cancel }",
 		"bind -Tcopy-mode C-[ { send -X cancel }",
 		"bind -Tcopy-mode Space { send -X page-down }",
+		"bind -Tcopy-mode Tab { send -X toggle-output }",
+"bind -Tcopy-mode BTab { send -X toggle-output -a }",
 		"bind -Tcopy-mode , { send -X jump-reverse }",
 		"bind -Tcopy-mode \\; { send -X jump-again }",
 		"bind -Tcopy-mode F { command-prompt -P -1p'(jump backward)' { send -X jump-backward -- '%%' } }",
 		"bind -Tcopy-mode L { send -X line-numbers-toggle }",
 		"bind -Tcopy-mode N { send -X search-reverse }",
+		"bind -Tcopy-mode O { send -X fold-view-toggle }",
 		"bind -Tcopy-mode P { send -X toggle-position }",
 		"bind -Tcopy-mode R { send -X rectangle-toggle }",
 		"bind -Tcopy-mode T { command-prompt -P -1p'(jump to backward)' { send -X jump-to-backward -- '%%' } }",
 		"bind -Tcopy-mode X { send -X set-mark }",
+		"bind -Tcopy-mode e { if -F '#{selection_present}' { send -X open-selection } { send -X open-output } }",
 		"bind -Tcopy-mode f { command-prompt -P -1p'(jump forward)' { send -X jump-forward -- '%%' } }",
 		"bind -Tcopy-mode g { command-prompt -P -p'(goto line)' { send -X goto-line -- '%%' } }",
 		"bind -Tcopy-mode n { send -X search-again }",
@@ -600,7 +607,7 @@ key_bindings_init(void)
 		"bind -Tcopy-mode t { command-prompt -P -1p'(jump to forward)' { send -X jump-to-forward -- '%%' } }",
 		"bind -Tcopy-mode Home { send -X start-of-line }",
 		"bind -Tcopy-mode End { send -X end-of-line }",
-		"bind -Tcopy-mode MouseDown1Pane select-pane",
+		"bind -Tcopy-mode MouseDown1Pane { select-pane; send -X toggle-output -m }",
 		"bind -Tcopy-mode MouseDrag1Pane { select-pane; send -X begin-selection }",
 		"bind -Tcopy-mode MouseDragEnd1Pane { send -X copy-pipe-and-cancel }",
 		"bind -Tcopy-mode WheelUpPane { select-pane; send -N5 -X scroll-up }",
@@ -660,6 +667,8 @@ key_bindings_init(void)
 		"bind -Tcopy-mode-vi Escape { send -X clear-selection }",
 		"bind -Tcopy-mode-vi C-[ { send -X clear-selection }",
 		"bind -Tcopy-mode-vi Space { send -X begin-selection }",
+		"bind -Tcopy-mode-vi Tab { send -X toggle-output }",
+"bind -Tcopy-mode-vi BTab { send -X toggle-output -a }",
 		"bind -Tcopy-mode-vi '$' { send -X end-of-line }",
 		"bind -Tcopy-mode-vi , { send -X jump-reverse }",
 		"bind -Tcopy-mode-vi / { command-prompt -P -T search -p'(search down)' { send -X search-forward -- '%%' } }",
@@ -687,7 +696,10 @@ key_bindings_init(void)
 		"bind -Tcopy-mode-vi K { send -X scroll-up }",
 		"bind -Tcopy-mode-vi L { send -X bottom-line }",
 		"bind -Tcopy-mode-vi M { send -X middle-line }",
+		"bind -Tcopy-mode-vi M-e { if -F '#{selection_present}' { send -X open-selection } { send -X open-output } }",
+		"bind -Tcopy-mode-vi M-o { send -X select-output }",
 		"bind -Tcopy-mode-vi N { send -X search-reverse }",
+		"bind -Tcopy-mode-vi O { send -X fold-view-toggle }",
 		"bind -Tcopy-mode-vi P { send -X toggle-position }",
 		"bind -Tcopy-mode-vi T { command-prompt -P -1p'(jump to backward)' { send -X jump-to-backward -- '%%' } }",
 		"bind -Tcopy-mode-vi V { send -X select-line }",
@@ -715,7 +727,7 @@ key_bindings_init(void)
 		"bind -Tcopy-mode-vi % { send -X next-matching-bracket }",
 		"bind -Tcopy-mode-vi Home { send -X start-of-line }",
 		"bind -Tcopy-mode-vi End { send -X end-of-line }",
-		"bind -Tcopy-mode-vi MouseDown1Pane { select-pane }",
+		"bind -Tcopy-mode-vi MouseDown1Pane { select-pane; send -X toggle-output -m }",
 		"bind -Tcopy-mode-vi MouseDrag1Pane { select-pane; send -X begin-selection }",
 		"bind -Tcopy-mode-vi MouseDragEnd1Pane { send -X copy-pipe-and-cancel }",
 		"bind -Tcopy-mode-vi WheelUpPane { select-pane; send -N5 -X scroll-up }",
--- a/layout.c
+++ b/layout.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: layout.c,v 1.99 2026/09/09 07:03:39 nicm Exp $ */
+/* $OpenBSD: layout.c,v 1.100 2026/09/11 08:16:14 nicm Exp $ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -768,6 +768,49 @@ layout_free(struct window *w, int only_nodes)
 	layout_free_cell(w->layout_root, only_nodes);
 }

+/* Move and resize floating panes so they stay inside the window. */
+static void
+layout_clamp_floating_panes(struct window *w, u_int sx, u_int sy)
+{
+	struct window_pane	*wp;
+	struct layout_cell	*lc;
+	u_int			 pad, avail, csx, csy;
+
+	TAILQ_FOREACH(wp, &w->z_index, zentry) {
+		lc = wp->layout_cell;
+		if (lc == NULL || (~lc->flags & LAYOUT_CELL_FLOATING))
+			continue;
+		if (window_pane_get_pane_lines(wp) == PANE_LINES_NONE)
+			pad = 0;
+		else
+			pad = 1;
+
+		csx = lc->g.sx;
+		avail = (sx > 2 * pad) ? sx - 2 * pad : 0;
+		if (csx > avail)
+			csx = (avail > PANE_MINIMUM) ? avail : PANE_MINIMUM;
+		csy = lc->g.sy;
+		avail = (sy > 2 * pad) ? sy - 2 * pad : 0;
+		if (csy > avail)
+			csy = (avail > PANE_MINIMUM) ? avail : PANE_MINIMUM;
+		if (csx != lc->g.sx || csy != lc->g.sy)
+			layout_set_size(lc, csx, csy, lc->g.xoff, lc->g.yoff);
+
+		if (lc->g.xoff + lc->g.sx + pad > sx) {
+			if (lc->g.sx + 2 * pad >= sx)
+				lc->g.xoff = pad;
+			else
+				lc->g.xoff = sx - lc->g.sx - pad;
+		}
+		if (lc->g.yoff + lc->g.sy + pad > sy) {
+			if (lc->g.sy + 2 * pad >= sy)
+				lc->g.yoff = pad;
+			else
+				lc->g.yoff = sy - lc->g.sy - pad;
+		}
+	}
+}
+
 /* Resize the entire layout after window resize. */
 void
 layout_resize(struct window *w, u_int sx, u_int sy)
@@ -788,8 +831,11 @@ layout_resize(struct window *w, u_int sx, u_int sy)
 	 * out proportionately - this should leave the layout fitting the new
 	 * window size.
 	 */
-	if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING))
+	if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING)) {
+		layout_clamp_floating_panes(w, sx, sy);
+		layout_fix_panes(w, NULL);
 		return;
+	}
 	xchange = sx - lc->g.sx;
 	xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT);
 	if (xchange < 0 && xchange < -xlimit)
@@ -819,6 +865,7 @@ layout_resize(struct window *w, u_int sx, u_int sy)

 	/* Fix cell offsets. */
 	layout_fix_offsets(w);
+	layout_clamp_floating_panes(w, sx, sy);
 	layout_fix_panes(w, NULL);
 }

--- a/options-table.c
+++ b/options-table.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: options-table.c,v 1.245 2026/09/10 11:02:18 nicm Exp $ */
+/* $OpenBSD: options-table.c,v 1.246 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -76,9 +76,10 @@ static const char *options_table_pane_border_indicators_list[] = {
 	"off", "colour", "arrows", "both", NULL
 };
 static const char *options_table_pane_border_lines_list[] = {
-	"single", "double", "heavy", "simple", "number", "spaces", "none", NULL
+	"single", "double", "heavy", "simple", "number", "spaces", "none",
+	"rounded", NULL
 };
-static const char *options_table_box_lines_list[] = {
+static const char *options_table_popup_border_lines_list[] = {
 	"single", "double", "heavy", "simple", "rounded", "padded", "none", NULL
 };
 static const char *options_table_set_clipboard_list[] = {
@@ -114,7 +115,6 @@ static const char *options_table_theme_list[] = {
 static const char *options_table_copy_mode_line_numbers_list[] = {
 	"off", "default", "absolute", "relative", "hybrid", NULL
 };
-
 /* Status line format. */
 #define OPTIONS_TABLE_STATUS_FORMAT1 \
 	"#[align=left range=left #{E:status-left-style}]" \
@@ -492,7 +492,7 @@ const struct options_table_entry options_table[] = {
 	{ .name = "menu-border-lines",
 	  .type = OPTIONS_TABLE_CHOICE,
 	  .scope = OPTIONS_TABLE_WINDOW,
-	  .choices = options_table_box_lines_list,
+	  .choices = options_table_popup_border_lines_list,
 	  .default_num = BOX_LINES_SINGLE,
 	  .text = "Type of characters used to draw menu border lines. Some of "
 		  "these are only supported on terminals with UTF-8 support."
@@ -1384,6 +1384,13 @@ const struct options_table_entry options_table[] = {
 	  .text = "Style of search matches in copy mode."
 	},

+	{ .name = "copy-mode-exit-status-format",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE,
+	  .default_str = "#{?exit_status,#[fg=themered]!, }",
+	  .text = "Format of OSC 133 exit status indicator in copy mode."
+	},
+
 	{ .name = "copy-mode-current-match-style",
 	  .type = OPTIONS_TABLE_STRING,
 	  .scope = OPTIONS_TABLE_WINDOW,
@@ -1665,6 +1672,33 @@ const struct options_table_entry options_table[] = {
 	  .text = "Pane scrollbar position."
 	},

+	{ .name = "popup-style",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_WINDOW,
+	  .default_str = "bg=themedarkgrey,fg=themewhite",
+	  .flags = OPTIONS_TABLE_IS_STYLE,
+	  .separator = ",",
+	  .text = "Default style of popups."
+	},
+
+	{ .name = "popup-border-style",
+	  .type = OPTIONS_TABLE_STRING,
+	  .scope = OPTIONS_TABLE_WINDOW,
+	  .default_str = "bg=themedarkgrey,fg=themelightgrey",
+	  .flags = OPTIONS_TABLE_IS_STYLE,
+	  .separator = ",",
+	  .text = "Default style of popup borders."
+	},
+
+	{ .name = "popup-border-lines",
+	  .type = OPTIONS_TABLE_CHOICE,
+	  .scope = OPTIONS_TABLE_WINDOW,
+	  .choices = options_table_popup_border_lines_list,
+	  .default_num = BOX_LINES_SINGLE,
+	  .text = "Type of characters used to draw popup border lines. Some of "
+		  "these are only supported on terminals with UTF-8 support."
+	},
+
 	{ .name = "remain-on-exit",
 	  .type = OPTIONS_TABLE_CHOICE,
 	  .scope = OPTIONS_TABLE_WINDOW|OPTIONS_TABLE_PANE,
--- a/popup.c
+++ b/popup.c
@@ -0,0 +1,661 @@
+/* $OpenBSD: popup.c,v 1.77 2026/08/28 08:02:16 nicm Exp $ */
+
+/*
+ * Copyright (c) 2020 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "tmux.h"
+
+struct popup_data {
+	struct client		 *c;
+	struct cmdq_item	 *item;
+	int			  flags;
+	char			 *title;
+
+	char			 *style;
+	char			 *border_style;
+	struct grid_cell	  border_cell;
+	enum box_lines		  border_lines;
+
+	struct screen		  s;
+	struct grid_cell	  defaults;
+	struct colour_palette	  palette;
+
+	struct visible_ranges	  r;
+
+	struct job		 *job;
+	struct input_ctx	 *ictx;
+	int			  status;
+	popup_close_cb		  cb;
+	void			 *arg;
+
+	int			  close;
+
+	/* Current position and size. */
+	u_int			  px;
+	u_int			  py;
+	u_int			  sx;
+	u_int			  sy;
+
+	/* Preferred position and size. */
+	u_int			  ppx;
+	u_int			  ppy;
+	u_int			  psx;
+	u_int			  psy;
+
+	enum { OFF, MOVE, SIZE }  dragging;
+	u_int			  dx;
+	u_int			  dy;
+
+	u_int			  lx;
+	u_int			  ly;
+	u_int			  lb;
+};
+
+static void
+popup_free(struct popup_data *pd)
+{
+	server_client_unref(pd->c);
+
+	if (pd->job != NULL)
+		job_free(pd->job);
+	if (pd->ictx != NULL)
+		input_free(pd->ictx);
+
+	free(pd->r.ranges);
+	screen_free(&pd->s);
+	colour_palette_free(&pd->palette);
+
+	free(pd->title);
+	free(pd->style);
+	free(pd->border_style);
+	free(pd);
+}
+
+static void
+popup_reapply_styles(struct popup_data *pd)
+{
+	struct client		*c = pd->c;
+	struct session		*s = c->session;
+	struct options		*o;
+	struct format_tree	*ft;
+	struct style		 sytmp;
+
+	if (s == NULL)
+		return;
+	o = s->curw->window->options;
+
+	ft = format_create_defaults(NULL, c, s, s->curw, NULL);
+
+	/* Reapply popup style from options. */
+	memcpy(&pd->defaults, &grid_default_cell, sizeof pd->defaults);
+	style_apply(&pd->defaults, o, "popup-style", ft);
+	if (pd->style != NULL) {
+		style_set(&sytmp, &grid_default_cell);
+		if (style_parse(&sytmp, &pd->defaults, pd->style) == 0) {
+			pd->defaults.fg = sytmp.gc.fg;
+			pd->defaults.bg = sytmp.gc.bg;
+		}
+	}
+	pd->defaults.attr = 0;
+
+	/* Reapply border style from options. */
+	memcpy(&pd->border_cell, &grid_default_cell, sizeof pd->border_cell);
+	style_apply(&pd->border_cell, o, "popup-border-style", ft);
+	if (pd->border_style != NULL) {
+		style_set(&sytmp, &grid_default_cell);
+		if (style_parse(&sytmp, &pd->border_cell,
+		    pd->border_style) == 0) {
+			pd->border_cell.fg = sytmp.gc.fg;
+			pd->border_cell.bg = sytmp.gc.bg;
+		}
+	}
+	pd->border_cell.attr = 0;
+
+	format_free(ft);
+}
+
+static void
+popup_redraw_cb(const struct tty_ctx *ttyctx)
+{
+	struct popup_data	*pd = ttyctx->arg;
+
+	pd->c->flags |= CLIENT_REDRAWOVERLAY;
+}
+
+static int
+popup_set_client_cb(struct tty_ctx *ttyctx, struct client *c)
+{
+	struct popup_data	*pd = ttyctx->arg;
+
+	if (c != pd->c)
+		return (0);
+	if (pd->c->flags & CLIENT_REDRAWOVERLAY)
+		return (0);
+
+	ttyctx->wox = 0;
+	ttyctx->woy = 0;
+	ttyctx->wsx = c->tty.sx;
+	ttyctx->wsy = c->tty.sy;
+
+	if (pd->border_lines == BOX_LINES_NONE) {
+		ttyctx->xoff = ttyctx->rxoff = pd->px;
+		ttyctx->yoff = ttyctx->ryoff = pd->py;
+	} else {
+		ttyctx->xoff = ttyctx->rxoff = pd->px + 1;
+		ttyctx->yoff = ttyctx->ryoff = pd->py + 1;
+	}
+
+	return (1);
+}
+
+static void
+popup_init_ctx_cb(struct screen_write_ctx *ctx, struct tty_ctx *ttyctx)
+{
+	struct popup_data	*pd = ctx->arg;
+
+	memcpy(&ttyctx->defaults, &pd->defaults, sizeof ttyctx->defaults);
+	ttyctx->flags &= ~TTY_CTX_WINDOW_BIGGER;
+	ttyctx->style_ctx.defaults = &ttyctx->defaults;
+	ttyctx->style_ctx.palette = &pd->palette;
+	ttyctx->redraw_cb = popup_redraw_cb;
+	ttyctx->set_client_cb = popup_set_client_cb;
+	ttyctx->arg = pd;
+}
+
+static struct screen *
+popup_mode_cb(__unused struct client *c, void *data, u_int *cx, u_int *cy)
+{
+	struct popup_data	*pd = data;
+
+	if (pd->border_lines == BOX_LINES_NONE) {
+		*cx = pd->px + pd->s.cx;
+		*cy = pd->py + pd->s.cy;
+	} else {
+		*cx = pd->px + 1 + pd->s.cx;
+		*cy = pd->py + 1 + pd->s.cy;
+	}
+	return (&pd->s);
+}
+
+/* Return parts of the input range which are not obstructed by the popup. */
+static struct visible_ranges *
+popup_check_cb(__unused struct client* c, void *data, u_int px, u_int py,
+    u_int nx)
+{
+	struct popup_data	*pd = data;
+	struct visible_ranges	*r = &pd->r;
+
+	server_client_overlay_range(pd->px, pd->py, pd->sx, pd->sy, px, py, nx,
+	    r);
+	return (r);
+}
+
+static void
+popup_draw_cb(struct client *c, void *data)
+{
+	struct popup_data	*pd = data;
+	struct tty		*tty = &c->tty;
+	struct screen		 s;
+	struct screen_write_ctx	 ctx;
+	u_int			 i, px = pd->px, py = pd->py;
+	struct grid_cell	 defaults;
+	struct tty_style_ctx	 style_ctx;
+
+	popup_reapply_styles(pd);
+
+	screen_init(&s, pd->sx, pd->sy, 0);
+	if (pd->s.hyperlinks != NULL) {
+		hyperlinks_free(s.hyperlinks);
+		s.hyperlinks = hyperlinks_copy(pd->s.hyperlinks);
+	}
+	screen_write_start(&ctx, &s);
+	screen_write_clearscreen(&ctx, 8);
+
+	if (pd->border_lines == BOX_LINES_NONE) {
+		screen_write_cursormove(&ctx, 0, 0, 0);
+		screen_write_fast_copy(&ctx, &pd->s, 0, 0, pd->sx, pd->sy);
+	} else if (pd->sx > 2 && pd->sy > 2) {
+		screen_write_box(&ctx, pd->sx, pd->sy, pd->border_lines,
+		    &pd->border_cell, pd->title);
+		screen_write_cursormove(&ctx, 1, 1, 0);
+		screen_write_fast_copy(&ctx, &pd->s, 0, 0, pd->sx - 2,
+		    pd->sy - 2);
+	}
+	screen_write_stop(&ctx);
+
+	memcpy(&defaults, &pd->defaults, sizeof defaults);
+	if (defaults.fg == 8)
+		defaults.fg = pd->palette.fg;
+	if (defaults.bg == 8)
+		defaults.bg = pd->palette.bg;
+	style_ctx.defaults = &defaults;
+	style_ctx.palette = &pd->palette;
+	style_ctx.dim = 0;
+	style_ctx.hyperlinks = s.hyperlinks;
+
+	c->overlay_check = NULL;
+	c->overlay_data = NULL;
+	for (i = 0; i < pd->sy; i++)
+		tty_draw_line(tty, &s, 0, i, pd->sx, px, py + i, &style_ctx);
+	screen_free(&s);
+	c->overlay_check = popup_check_cb;
+	c->overlay_data = pd;
+}
+
+static void
+popup_free_cb(__unused struct client *c, void *data)
+{
+	struct popup_data	*pd = data;
+	struct cmdq_item	*item = pd->item;
+
+	if (pd->cb != NULL)
+		pd->cb(pd->status, pd->arg);
+
+	if (item != NULL) {
+		if (cmdq_get_client(item) != NULL &&
+		    cmdq_get_client(item)->session == NULL)
+			cmdq_get_client(item)->retval = pd->status;
+		cmdq_continue(item);
+	}
+
+	popup_free(pd);
+}
+
+static void
+popup_resize_cb(__unused struct client *c, void *data)
+{
+	struct popup_data	*pd = data;
+	struct tty		*tty = &c->tty;
+
+	if (pd == NULL)
+		return;
+
+	/* Adjust position and size. */
+	if (pd->psy > tty->sy)
+		pd->sy = tty->sy;
+	else
+		pd->sy = pd->psy;
+	if (pd->psx > tty->sx)
+		pd->sx = tty->sx;
+	else
+		pd->sx = pd->psx;
+	if (pd->ppy + pd->sy > tty->sy)
+		pd->py = tty->sy - pd->sy;
+	else
+		pd->py = pd->ppy;
+	if (pd->ppx + pd->sx > tty->sx)
+		pd->px = tty->sx - pd->sx;
+	else
+		pd->px = pd->ppx;
+
+	/* Avoid zero size screens. */
+	if (pd->border_lines == BOX_LINES_NONE) {
+		screen_resize(&pd->s, pd->sx, pd->sy, 0);
+		if (pd->job != NULL)
+			job_resize(pd->job, pd->sx, pd->sy );
+	} else if (pd->sx > 2 && pd->sy > 2) {
+		screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
+		if (pd->job != NULL)
+			job_resize(pd->job, pd->sx - 2, pd->sy - 2);
+	}
+}
+
+static void
+popup_handle_drag(struct client *c, struct popup_data *pd,
+    struct mouse_event *m)
+{
+	u_int	px, py;
+
+	if (!MOUSE_DRAG(m->b))
+		pd->dragging = OFF;
+	else if (pd->dragging == MOVE) {
+		if (m->x < pd->dx)
+			px = 0;
+		else if (m->x - pd->dx + pd->sx > c->tty.sx)
+			px = c->tty.sx - pd->sx;
+		else
+			px = m->x - pd->dx;
+		if (m->y < pd->dy)
+			py = 0;
+		else if (m->y - pd->dy + pd->sy > c->tty.sy)
+			py = c->tty.sy - pd->sy;
+		else
+			py = m->y - pd->dy;
+		pd->px = px;
+		pd->py = py;
+		pd->dx = m->x - pd->px;
+		pd->dy = m->y - pd->py;
+		pd->ppx = px;
+		pd->ppy = py;
+		server_redraw_client(c);
+	} else if (pd->dragging == SIZE) {
+		if (pd->border_lines == BOX_LINES_NONE) {
+			if (m->x < pd->px + 1)
+				return;
+			if (m->y < pd->py + 1)
+				return;
+		} else {
+			if (m->x < pd->px + 3)
+				return;
+			if (m->y < pd->py + 3)
+				return;
+		}
+		pd->sx = m->x - pd->px;
+		pd->sy = m->y - pd->py;
+		pd->psx = pd->sx;
+		pd->psy = pd->sy;
+
+		if (pd->border_lines == BOX_LINES_NONE) {
+			screen_resize(&pd->s, pd->sx, pd->sy, 0);
+			if (pd->job != NULL)
+				job_resize(pd->job, pd->sx, pd->sy);
+		} else {
+			screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 0);
+			if (pd->job != NULL)
+				job_resize(pd->job, pd->sx - 2, pd->sy - 2);
+		}
+		server_redraw_client(c);
+	}
+}
+
+static int
+popup_key_cb(struct client *c, void *data, struct key_event *event)
+{
+	struct popup_data	*pd = data;
+	struct mouse_event	*m = &event->m;
+	const char		*buf;
+	size_t			 len;
+	u_int			 px, py;
+	enum { NONE, LEFT, RIGHT, TOP, BOTTOM } border = NONE;
+
+	if (KEYC_IS_MOUSE(event->key)) {
+		if (pd->dragging != OFF) {
+			popup_handle_drag(c, pd, m);
+			goto out;
+		}
+		if (m->x < pd->px ||
+		    m->x > pd->px + pd->sx - 1 ||
+		    m->y < pd->py ||
+		    m->y > pd->py + pd->sy - 1) {
+			return (0);
+		}
+		if (pd->border_lines != BOX_LINES_NONE) {
+			if (m->x == pd->px)
+				border = LEFT;
+			else if (m->x == pd->px + pd->sx - 1)
+				border = RIGHT;
+			else if (m->y == pd->py)
+				border = TOP;
+			else if (m->y == pd->py + pd->sy - 1)
+				border = BOTTOM;
+		}
+		if ((m->b & MOUSE_MASK_MODIFIERS) == 0 &&
+		    MOUSE_BUTTONS(m->b) == MOUSE_BUTTON_3 &&
+		    (border == LEFT || border == TOP))
+			goto out;
+		if (((m->b & MOUSE_MASK_MODIFIERS) == MOUSE_MASK_META) ||
+		    (border != NONE && !MOUSE_DRAG(m->lb))) {
+			if (!MOUSE_DRAG(m->b))
+				goto out;
+			if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_1)
+				pd->dragging = MOVE;
+			else if (MOUSE_BUTTONS(m->lb) == MOUSE_BUTTON_3)
+				pd->dragging = SIZE;
+			pd->dx = m->lx - pd->px;
+			pd->dy = m->ly - pd->py;
+			goto out;
+		}
+	}
+	if ((((pd->flags & (POPUP_CLOSEEXIT|POPUP_CLOSEEXITZERO)) == 0) ||
+	    pd->job == NULL) &&
+	    (event->key == '\033' || event->key == ('c'|KEYC_CTRL)))
+		return (1);
+	if (pd->job == NULL && (pd->flags & POPUP_CLOSEANYKEY) &&
+	    !KEYC_IS_MOUSE(event->key) && !KEYC_IS_PASTE(event->key))
+		return (1);
+	if (pd->job != NULL) {
+		if (KEYC_IS_MOUSE(event->key)) {
+			/* Must be inside, checked already. */
+			if (pd->border_lines == BOX_LINES_NONE) {
+				px = m->x - pd->px;
+				py = m->y - pd->py;
+			} else {
+				px = m->x - pd->px - 1;
+				py = m->y - pd->py - 1;
+			}
+			if (!input_key_get_mouse(&pd->s, m, px, py, &buf, &len))
+				return (0);
+			bufferevent_write(job_get_event(pd->job), buf, len);
+			return (0);
+		}
+		input_key(&pd->s, job_get_event(pd->job), event->key);
+	}
+	return (0);
+
+out:
+	pd->lx = m->x;
+	pd->ly = m->y;
+	pd->lb = m->b;
+	return (0);
+}
+
+static void
+popup_job_update_cb(struct job *job)
+{
+	struct popup_data	*pd = job_get_data(job);
+	struct evbuffer		*evb = job_get_event(job)->input;
+	struct client		*c = pd->c;
+	struct screen		*s = &pd->s;
+	void			*data = EVBUFFER_DATA(evb);
+	size_t			 size = EVBUFFER_LENGTH(evb);
+
+	if (size == 0)
+		return;
+
+	c->overlay_check = NULL;
+	c->overlay_data = NULL;
+	input_parse_screen(pd->ictx, s, popup_init_ctx_cb, pd, data, size);
+	c->overlay_check = popup_check_cb;
+	c->overlay_data = pd;
+
+	evbuffer_drain(evb, size);
+}
+
+static void
+popup_job_complete_cb(struct job *job)
+{
+	struct popup_data	*pd = job_get_data(job);
+	int			 status;
+
+	status = job_get_status(pd->job);
+	if (WIFEXITED(status))
+		pd->status = WEXITSTATUS(status);
+	else if (WIFSIGNALED(status))
+		pd->status = WTERMSIG(status);
+	else
+		pd->status = 0;
+	pd->job = NULL;
+
+	if ((pd->flags & POPUP_CLOSEEXIT) ||
+	    ((pd->flags & POPUP_CLOSEEXITZERO) && pd->status == 0))
+		server_client_clear_overlay(pd->c);
+}
+
+int
+popup_present(struct client *c)
+{
+	return (c->overlay_draw == popup_draw_cb);
+}
+
+int
+popup_modify(struct client *c, const char *title, const char *style,
+	const char *border_style, enum box_lines lines, int flags)
+{
+	struct popup_data		*pd = c->overlay_data;
+	struct style		sytmp;
+
+	if (title != NULL) {
+		if (pd->title != NULL)
+			free(pd->title);
+		pd->title = xstrdup(title);
+	}
+	if (border_style != NULL) {
+		free(pd->border_style);
+		pd->border_style = xstrdup(border_style);
+		style_set(&sytmp, &pd->border_cell);
+		if (style_parse(&sytmp, &pd->border_cell, border_style) == 0) {
+			pd->border_cell.fg = sytmp.gc.fg;
+			pd->border_cell.bg = sytmp.gc.bg;
+		}
+	}
+	if (style != NULL) {
+		free(pd->style);
+		pd->style = xstrdup(style);
+		style_set(&sytmp, &pd->defaults);
+		if (style_parse(&sytmp, &pd->defaults, style) == 0) {
+			pd->defaults.fg = sytmp.gc.fg;
+			pd->defaults.bg = sytmp.gc.bg;
+		}
+	}
+	if (lines != BOX_LINES_DEFAULT) {
+		if (lines == BOX_LINES_NONE && pd->border_lines != lines) {
+			screen_resize(&pd->s, pd->sx, pd->sy, 1);
+			job_resize(pd->job, pd->sx, pd->sy);
+		} else if (pd->border_lines == BOX_LINES_NONE &&
+		    pd->border_lines != lines) {
+			screen_resize(&pd->s, pd->sx - 2, pd->sy - 2, 1);
+			job_resize(pd->job, pd->sx - 2, pd->sy - 2);
+		}
+		pd->border_lines = lines;
+		tty_resize(&c->tty);
+	}
+	if (flags != -1)
+		pd->flags = flags;
+
+	server_redraw_client(c);
+	return (0);
+}
+
+int
+popup_display(int flags, enum box_lines lines, struct cmdq_item *item, u_int px,
+    u_int py, u_int sx, u_int sy, struct environ *env, const char *shellcmd,
+    int argc, char **argv, const char *cwd, const char *title, struct client *c,
+    struct session *s, const char *style, const char *border_style,
+    popup_close_cb cb, void *arg)
+{
+	struct popup_data	*pd;
+	u_int			 jx, jy;
+	struct options		*o;
+	struct style		 sytmp;
+
+	if (s != NULL)
+		o = s->curw->window->options;
+	else
+		o = c->session->curw->window->options;
+
+	if (lines == BOX_LINES_DEFAULT)
+		lines = options_get_number(o, "popup-border-lines");
+	if (lines == BOX_LINES_NONE) {
+		if (sx < 1 || sy < 1)
+			return (-1);
+		jx = sx;
+		jy = sy;
+	} else {
+		if (sx < 3 || sy < 3)
+			return (-1);
+		jx = sx - 2;
+		jy = sy - 2;
+	}
+	if (c->tty.sx < sx || c->tty.sy < sy)
+		return (-1);
+
+	pd = xcalloc(1, sizeof *pd);
+	pd->item = item;
+	pd->flags = flags;
+
+	if (title != NULL)
+		pd->title = xstrdup(title);
+	if (style != NULL)
+		pd->style = xstrdup(style);
+	if (border_style != NULL)
+		pd->border_style = xstrdup(border_style);
+
+	pd->c = c;
+	pd->c->references++;
+
+	pd->cb = cb;
+	pd->arg = arg;
+	pd->status = 128 + SIGHUP;
+
+	pd->border_lines = lines;
+	memcpy(&pd->border_cell, &grid_default_cell, sizeof pd->border_cell);
+	style_apply(&pd->border_cell, o, "popup-border-style", NULL);
+	if (border_style != NULL) {
+		style_set(&sytmp, &grid_default_cell);
+		if (style_parse(&sytmp, &pd->border_cell, border_style) == 0) {
+			pd->border_cell.fg = sytmp.gc.fg;
+			pd->border_cell.bg = sytmp.gc.bg;
+		}
+	}
+	pd->border_cell.attr = 0;
+
+	screen_init(&pd->s, jx, jy, 0);
+	screen_set_default_cursor(&pd->s, global_w_options);
+	colour_palette_init(&pd->palette);
+	colour_palette_from_option(&pd->palette, global_w_options);
+
+	memcpy(&pd->defaults, &grid_default_cell, sizeof pd->defaults);
+	style_apply(&pd->defaults, o, "popup-style", NULL);
+	if (style != NULL) {
+		style_set(&sytmp, &grid_default_cell);
+		if (style_parse(&sytmp, &pd->defaults, style) == 0) {
+			pd->defaults.fg = sytmp.gc.fg;
+			pd->defaults.bg = sytmp.gc.bg;
+		}
+	}
+	pd->defaults.attr = 0;
+
+	pd->px = px;
+	pd->py = py;
+	pd->sx = sx;
+	pd->sy = sy;
+
+	pd->ppx = px;
+	pd->ppy = py;
+	pd->psx = sx;
+	pd->psy = sy;
+
+	pd->job = job_run(shellcmd, argc, argv, env, s, cwd,
+	    popup_job_update_cb, popup_job_complete_cb, NULL, pd,
+	    JOB_NOWAIT|JOB_PTY|JOB_KEEPWRITE|JOB_DEFAULTSHELL, jx, jy);
+	if (pd->job == NULL) {
+		popup_free(pd);
+		return (-1);
+	}
+	pd->ictx = input_init(NULL, job_get_event(pd->job), &pd->palette, c);
+
+	server_client_set_overlay(c, 0, popup_check_cb, popup_mode_cb,
+	    popup_draw_cb, popup_key_cb, popup_free_cb, popup_resize_cb, pd);
+	return (0);
+}
--- a/regress/collapse-output.sh
+++ b/regress/collapse-output.sh
@@ -0,0 +1,81 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+
+$TMUX kill-server 2>/dev/null
+$TMUX new-session -d -x80 -y20 "sh -c 'printf \"\\033]133;A\\007p\\$ \\033]133;B\\007echo hi\\n\\033]133;C\\007hello\\n\\033]133;D;0\\007separator\\n\\033]133;A\\007p\\$ \\033]133;B\\007\"; exec sleep 100'" || exit 1
+sleep 1
+
+$TMUX copy-mode -c || exit 1
+$TMUX send-keys -X search-backward hello || exit 1
+hidden=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$hidden" != hello ] || exit 1
+$TMUX send-keys -X search-backward separator || exit 1
+hidden=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$hidden" != separator ] || exit 1
+
+$TMUX send-keys BTab || exit 1
+$TMUX send-keys -X search-backward hello || exit 1
+shown=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$shown" = hello ] || exit 1
+$TMUX send-keys -X select-line || exit 1
+$TMUX send-keys -X copy-selection || exit 1
+selected=$($TMUX show-buffer)
+[ "$selected" = hello ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX kill-server
+$TMUX new-session -d -x80 -y20 "sh -c 'printf \"first\\n\\033]133;D;0\\007separator\\n\\033]133;A\\007p\\$ \\033]133;B\\007\"; exec sleep 100'" || exit 1
+sleep 1
+
+$TMUX copy-mode -c || exit 1
+$TMUX send-keys -X search-backward separator || exit 1
+hidden=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$hidden" != separator ] || exit 1
+$TMUX send-keys BTab || exit 1
+$TMUX send-keys -X search-backward separator || exit 1
+shown=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$shown" = separator ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX kill-server
+$TMUX new-session -d -x80 -y20 "sh -c 'printf \"\\033]133;A\\007P> \\033]133;B\\007for i in 1 2 3; do\\n\\033]133;A;k=s\\007> \\033]133;B\\007echo \\$i\\n\\033]133;P;k=s\\007> \\033]133;B\\007done\\033]133;C\\007\\nRESULT\\n\\033]133;D;0\\007separator\\n\\033]133;A\\007P> \\033]133;B\\007\"; exec sleep 100'" || exit 1
+sleep 1
+
+$TMUX copy-mode -c || exit 1
+$TMUX send-keys -X search-backward RESULT || exit 1
+hidden=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$hidden" != RESULT ] || exit 1
+$TMUX send-keys -X search-backward 'echo $i' || exit 1
+shown=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$shown" = 'echo $i' ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX copy-mode -U || exit 1
+$TMUX send-keys -X search-backward RESULT || exit 1
+$TMUX send-keys Tab || exit 1
+cursor=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$cursor" = done ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX kill-server
+$TMUX new-session -d -x80 -y20 "sh -c 'printf \"\\033]133;A\\007P0> \\033]133;B\\007\\r\\n\\033]133;D;0\\007empty-separator\\n\\033]133;A\\007P1> \\033]133;B\\007\"; exec sleep 100'" || exit 1
+sleep 1
+
+$TMUX copy-mode -c || exit 1
+collapsed=$($TMUX capture-pane -p)
+case "$collapsed" in
+*"+ P0>"*) ;;
+*) exit 1 ;;
+esac
+$TMUX send-keys -X search-backward empty-separator || exit 1
+hidden=$($TMUX display-message -p '#{copy_cursor_line}')
+[ "$hidden" != empty-separator ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX kill-server 2>/dev/null
+exit 0
--- a/regress/control-client-popup.sh
+++ b/regress/control-client-popup.sh
@@ -1,7 +1,6 @@
 #!/bin/sh

-# Popups require an attached terminal and cannot be displayed by a control
-# client.
+# Popups require a tty overlay and cannot be displayed by a control client.
 # A popup command from control mode must be ignored cleanly, leaving the
 # client command queue and server usable.

--- a/regress/copy-mode-exit-status.sh
+++ b/regress/copy-mode-exit-status.sh
@@ -0,0 +1,102 @@
+#!/bin/sh
+
+# Check OSC 133 exit status indicators in copy mode using a real client.
+
+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"
+
+fail() {
+	echo "$*" >&2
+	exit 1
+}
+
+capture() {
+	$TMUX capture-pane -pS0 -E- >$TMP || exit 1
+}
+
+check_grep() {
+	grep -Fq "$1" $TMP || fail "missing pattern: $1"
+}
+
+check_no_grep() {
+	grep -Fq "$1" $TMP && fail "unexpected pattern: $1"
+}
+
+$TMUX kill-server 2>/dev/null
+$TMUX2 kill-server 2>/dev/null
+
+TMP=$(mktemp)
+trap "rm -f $TMP; $TMUX kill-server 2>/dev/null; $TMUX2 kill-server 2>/dev/null" 0 1 15
+
+$TMUX2 new-session -d -x80 -y10 \
+	"printf '\033]133;A\007p\$ \033]133;B\007one\n\033]133;C\007out1\n\033]133;D;0\007\033]133;A\007p\$ \033]133;B\007two\n\033]133;C\007out2\n\033]133;D;123\007\033]133;A\007p\$ \033]133;B\007silent\n\033]133;C\007\033]133;D;7\007\033]133;A\007p\$ \033]133;B\007three\n\033]133;C\007out3\n\033]133;D\007\033]133;A\007p\$ \033]133;B\007'; exec sleep 100" || \
+	exit 1
+$TMUX2 set -g status off || exit 1
+$TMUX2 set -g copy-mode-position-format '#[align=left]POS' || exit 1
+$TMUX2 list-keys -Tcopy-mode O | grep -Fq 'fold-view-toggle' || exit 1
+$TMUX2 list-keys -Tcopy-mode-vi O | grep -Fq 'fold-view-toggle' || exit 1
+
+$TMUX new-session -d -x80 -y10 || exit 1
+$TMUX set -g status off || exit 1
+$TMUX send -l "$TMUX2 attach" || exit 1
+$TMUX send Enter || exit 1
+sleep 1
+
+$TMUX2 copy-mode -U || exit 1
+$TMUX2 send -X history-top || exit 1
+sleep 1
+capture
+check_grep "!- p\$ two"
+check_grep "!  p\$ silent"
+check_no_grep "!+ p\$ silent"
+check_grep "POS"
+
+# Rebuilding with collapsed output must not expand copy-mode formats before
+# the viewport has been restored for the shorter backing grid.
+$TMUX2 send -X collapse-output -a || exit 1
+sleep 1
+capture
+check_grep "!+ p\$ two"
+check_grep "!  p\$ silent"
+check_no_grep "!+ p\$ silent"
+$TMUX2 send -X line-numbers-on || exit 1
+sleep 1
+capture
+check_grep "  3 !+ p\$ two"
+$TMUX2 send -X fold-view-toggle || exit 1
+[ "$($TMUX2 display -p '#{copy_fold_view}')" = 0 ] || exit 1
+sleep 1
+capture
+check_grep "out2"
+check_no_grep "!+ p\$ two"
+check_grep "  3 p\$ two"
+$TMUX2 send -X fold-view-toggle || exit 1
+[ "$($TMUX2 display -p '#{copy_fold_view}')" = 1 ] || exit 1
+sleep 1
+capture
+check_grep "  3 !- p\$ two"
+
+# A format wider than the standard three-column gutter is not truncated.
+$TMUX2 send -X cancel || exit 1
+$TMUX2 set -g copy-mode-exit-status-format \
+	'#[align=right]#{?exit_status,!#{exit_status}, }' || exit 1
+$TMUX2 copy-mode -c || exit 1
+$TMUX2 send -X history-top || exit 1
+sleep 1
+capture
+check_grep "!123+ p\$ two"
+
+$TMUX2 send -X select-line || exit 1
+$TMUX2 send -X copy-selection || exit 1
+selection=$($TMUX2 show-buffer)
+case $selection in
+*RC=*) fail "exit status was copied" ;;
+esac
+
+exit 0
--- a/regress/floating-pane-geometry.sh
+++ b/regress/floating-pane-geometry.sh
@@ -268,5 +268,149 @@ $TMUX kill-pane -t "$floating" || exit 1
 $TMUX kill-pane -t "$right" || exit 1
 $TMUX kill-pane -t "$lower" || exit 1

+# --- Floating panes clamped when the window shrinks (issue #5581, PR #5582) ---
+#
+# layout_resize clamps floating panes back inside the window when it shrinks:
+# move them and, only if they cannot fit, shrink them (never below
+# PANE_MINIMUM). A floating cell is the pane's content, so with the default
+# single-line border the clamp counts 1 cell of border per side, exactly as
+# layout_floating_args_parse does on creation; with no border it counts 0.
+# Each case below gets its own window, since resize-window fixes a window at
+# a manual size for the rest of its life.
+
+# Case 1: a lone floating pane -- break-pane -W on a window's only pane --
+# takes the early-return path in layout_resize, added during PR #5582's
+# review round, since there is no tiled tree to walk.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for lone float failed"
+
+# -x 20 -y 6 -> pane 18x4; -X 60 -Y 18 -> pane_left 61, pane_top 19: with the
+# border, the footprint is columns 60-79, rows 18-23, flush with the 80x24
+# window's right and bottom edges, so the float fits before it is shrunk.
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for lone float failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   61
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    19
+
+# Shrink to 40x16. The float still fits at its own size (18 <= 40-2, 4 <=
+# 16-2) so only its position moves, flush to the new right/bottom edges:
+# xoff = 40 - 18 - 1 = 21; yoff = 16 - 4 - 1 = 11.
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (lone float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+
+# Case 5: grow the window back. The clamp must not chase the window back
+# outward -- it only ever pulls a float in, never restores where it was.
+$TMUX resize-window -t "$win" -x 80 -y 24 ||
+	fail "resize-window grow (lone float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 2: the same float, but with a tiled sibling surviving alongside it, so
+# the window's root cell stays tiled and layout_resize takes the normal path
+# (the clamp call after layout_fix_offsets) instead of the early return
+# above. Same geometry as case 1, so the same numbers should come out.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for tiled sibling failed"
+$TMUX split-window -t "$win" 'sleep 100' ||
+	fail "split-window for tiled sibling failed"
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for tiled sibling failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   61
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    19
+
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (tiled sibling) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   21
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 3: new-pane float, the original repro from issue #5581 and the PR
+# body -- also the normal path, via the tiled base pane new-window creates.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for new-pane repro failed"
+$TMUX resize-window -t "$win" -x 120 -y 40 ||
+	fail "resize-window to 120x40 failed"
+
+# -x 30 -y 10 -> pane 28x8; -X 85 -Y 25 -> pane_left 86, pane_top 26.
+floating=$($TMUX new-pane -t "$win" -dPF '#{pane_id}' \
+	-x 30 -y 10 -X 85 -Y 25 'sleep 100') ||
+	fail "new-pane for new-pane repro failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  28
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 8
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   86
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    26
+
+# Shrink to 60x20: xoff = 60 - 28 - 1 = 31; yoff = 20 - 8 - 1 = 11.
+$TMUX resize-window -t "$win" -x 60 -y 20 ||
+	fail "resize-window (new-pane repro) failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  28
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 8
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   31
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    11
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 4: a float that already fits inside the shrunk window is left alone --
+# assert position and size are both unchanged, not just one of them.
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for untouched float failed"
+
+# -x 20 -y 6 -> pane 18x4; -X 8 -Y 3 -> pane_left 9, pane_top 4 (as at the top
+# of this file). Footprint columns 8-27, rows 3-8: well inside 60x20 too.
+floating=$($TMUX new-pane -t "$win" -dPF '#{pane_id}' \
+	-x 20 -y 6 -X 8 -Y 3 'sleep 100') ||
+	fail "new-pane for untouched float failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   9
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    4
+
+$TMUX resize-window -t "$win" -x 60 -y 20 ||
+	fail "resize-window (untouched float) failed"
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_width}')"  18
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_height}')" 4
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_left}')"   9
+must_equal "$($TMUX display-message -p -t "$floating" '#{pane_top}')"    4
+$TMUX kill-window -t "$win" || exit 1
+
+# Case 6: pad = 0, via the pane-border-lines window option set to none. The
+# border arithmetic differs here (no -2/+1 adjustment either on creation or
+# in the clamp).
+win=$($TMUX new-window -dPF '#{window_id}') ||
+	fail "new-window for pad=0 float failed"
+$TMUX set-option -w -t "$win" pane-border-lines none ||
+	fail "set pane-border-lines none failed"
+
+# No border: -x 20 -y 6 -> pane 20x6 directly; -X 60 -Y 18 -> pane_left 60,
+# pane_top 18 directly. Footprint (== content, no border) is columns 60-79,
+# rows 18-23: flush right/bottom of the 80x24 window, same as case 1.
+$TMUX break-pane -W -s "$win" -x 20 -y 6 -X 60 -Y 18 ||
+	fail "break-pane -W for pad=0 float failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 6
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   60
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    18
+
+# Shrink to 40x16 with pad=0: xoff = 40 - 20 - 0 = 20; yoff = 16 - 6 - 0 = 10.
+$TMUX resize-window -t "$win" -x 40 -y 16 ||
+	fail "resize-window (pad=0 float) failed"
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_width}')"  20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_height}')" 6
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_left}')"   20
+must_equal "$($TMUX display-message -p -t "$win" '#{pane_top}')"    10
+$TMUX kill-window -t "$win" || exit 1
+
 $TMUX kill-server 2>/dev/null
 exit 0
--- a/regress/input-modes.sh
+++ b/regress/input-modes.sh
@@ -5,9 +5,12 @@
 start_pane alternate 10 3 'MAIN\033[?1049hALT\033[?1049lZ\n'
 check_capture alternate 'MAINZ'

-start_pane osc133 20 8 'xx\033]133;A\007p>\033]133;B\007cmd\nxy\033]133;P;k=s\007more\nzz\033]133;C\007out\033]133;D;7\007\nq\033]133;C\007bad\033]133;D;-1\007\nqq\033]133;C\007big\033]133;D;300\007\nzzz\033]133;C\007ok\033]133;D\007\n'
+start_pane osc133 20 12 'xx\033]133;A\007p>\033]133;B\007cmd\nxy\033]133;P;k=s\007more\nxz\033]133;A;k=s\007more\nxw\033]133;P;k=c\007more\nxv\033]133;A;k=c\007more\nzz\033]133;C\007out\033]133;D;7\007\nq\033]133;C\007bad\033]133;D;-1\007\nqq\033]133;C\007big\033]133;D;300\007\nzzz\033]133;C\007ok\033]133;D\007\n'
 check_capture osc133 'xxp>cmd
 xymore
+xzmore
+xwmore
+xvmore
 zzout
 qbad
 qqbig
@@ -15,10 +18,13 @@ zzzok'
 check_raw_matches osc133 \
 	'L 0 \(0\) flags=START_PROMPT,START_COMMAND\[[0-9a-f]+\].* osc133=2,4,0,0,0' \
 	'L 1 \(1\) flags=SECOND_PROMPT\[[0-9a-f]+\].* osc133=2,0,0,0,0' \
-	'L 2 \(2\) flags=START_OUTPUT,END_OUTPUT\[[0-9a-f]+\].* osc133=0,0,2,5,7' \
-	'L 3 \(3\) flags=START_OUTPUT,END_OUTPUT\[[0-9a-f]+\].* osc133=0,0,1,4,255' \
-	'L 4 \(4\) flags=START_OUTPUT,END_OUTPUT\[[0-9a-f]+\].* osc133=0,0,2,5,255' \
-	'L 5 \(5\) flags=START_OUTPUT,END_OUTPUT\[[0-9a-f]+\].* osc133=0,0,3,5,0'
+	'L 2 \(2\) flags=SECOND_PROMPT\[[0-9a-f]+\].* osc133=2,0,0,0,0' \
+	'L 3 \(3\) flags=SECOND_PROMPT\[[0-9a-f]+\].* osc133=2,0,0,0,0' \
+	'L 4 \(4\) flags=SECOND_PROMPT\[[0-9a-f]+\].* osc133=2,0,0,0,0' \
+	'L 5 \(5\) flags=START_OUTPUT,END_OUTPUT,END_OUTPUT_STATUS\[[0-9a-f]+\].* osc133=0,0,2,5,7' \
+	'L 6 \(6\) flags=START_OUTPUT,END_OUTPUT,END_OUTPUT_STATUS\[[0-9a-f]+\].* osc133=0,0,1,4,255' \
+	'L 7 \(7\) flags=START_OUTPUT,END_OUTPUT,END_OUTPUT_STATUS\[[0-9a-f]+\].* osc133=0,0,2,5,255' \
+	'L 8 \(8\) flags=START_OUTPUT,END_OUTPUT\[[0-9a-f]+\].* osc133=0,0,3,5,0'

 $TMUX kill-server 2>/dev/null
 exit $exit_status
--- a/regress/modal-pane.sh
+++ b/regress/modal-pane.sh
@@ -400,107 +400,6 @@ $TMUX2 send-keys -t "$OUTER" a
 sleep 1
 must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''

-$TMUX bind P display-popup -E -t "$p0" -w 20 -h 5 -T popup-title 'cat'
-$TMUX2 send-keys -t "$OUTER" C-b P
-sleep 1
-modal=$(fmt modal:0 '#{window_modal_pane}')
-[ -n "$modal" ] || fail "display-popup did not create a modal pane"
-must_equal "$(fmt "$modal" '#{pane_title}')" popup-title
-must_equal "$($TMUX show-options -pv -t "$modal" pane-border-status)" top
-must_equal "$($TMUX show-options -pv -t "$modal" pane-border-format)" \
-	'#{pane_title}'
-$TMUX2 send-keys -t "$OUTER" C-b x z Enter
-sleep 1
-must_equal "$($TMUX show -gv @modal-prefix)" no
-must_equal "$($TMUX show -gv @modal-root)" no
-case "$($TMUX capture-pane -pt "$modal")" in
-*xz*) ;;
-*) fail "keys did not reach display-popup pane" ;;
-esac
-$TMUX2 send-keys -t "$OUTER" Escape
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" "$modal"
-$TMUX2 send-keys -t "$OUTER" C-c
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
-# Creating a popup pane must not fire the split-window hook.
-check_ok set-hook -t modal after-split-window \
-	"set-option -g @popup-after-split yes"
-check_ok set-option -g @popup-after-split no
-check_ok display-popup -E -t "$p0" true
-must_equal "$($TMUX show-option -gv @popup-after-split)" no
-check_ok set-hook -u -t modal after-split-window
-
-# A borderless popup must not create a zero-sized pane in a tiny window.
-check_ok new-window -d -t modal: -n popup-small 'cat'
-check_ok set-option -w -t modal:popup-small window-size manual
-check_ok resize-window -t modal:popup-small -x 1 -y 1
-small=$(fmt modal:popup-small '#{pane_id}')
-check_ok bind Z display-popup -B -t "$small" 'cat'
-$TMUX2 send-keys -t "$OUTER" C-b Z
-sleep 1
-must_equal "$(fmt modal:popup-small '#{window_panes}')" 1
-must_equal "$(fmt modal:popup-small '#{window_modal_pane}')" ''
-
-$TMUX bind D display-popup -t "$p0" -w 20 -h 5 'printf done'
-$TMUX2 send-keys -t "$OUTER" C-b D
-sleep 2
-modal=$(fmt modal:0 '#{window_modal_pane}')
-[ -n "$modal" ] || fail "retained display-popup was not created"
-must_equal "$(fmt "$modal" '#{pane_dead}')" 1
-case "$($TMUX capture-pane -pt "$modal")" in
-*'Pane is dead'*) fail "display-popup showed remain-on-exit message" ;;
-esac
-$TMUX2 send-keys -t "$OUTER" a
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" "$modal"
-$TMUX2 send-keys -t "$OUTER" Escape
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
-$TMUX bind K display-popup -k -t "$p0" -w 20 -h 5 'printf done'
-$TMUX2 send-keys -t "$OUTER" C-b K
-sleep 2
-modal=$(fmt modal:0 '#{window_modal_pane}')
-[ -n "$modal" ] || fail "display-popup -k was not created"
-must_equal "$(fmt "$modal" '#{pane_dead}')" 1
-$TMUX2 send-keys -t "$OUTER" a
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
-$TMUX bind F display-popup -EE -t "$p0" -w 20 -h 5 'exit 1'
-$TMUX2 send-keys -t "$OUTER" C-b F
-sleep 2
-modal=$(fmt modal:0 '#{window_modal_pane}')
-[ -n "$modal" ] || fail "failed display-popup -EE did not remain"
-must_equal "$(fmt "$modal" '#{pane_dead}')" 1
-$TMUX2 send-keys -t "$OUTER" a
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" "$modal"
-$TMUX2 send-keys -t "$OUTER" Escape
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" "$modal"
-check_ok kill-pane -t "$modal"
-sleep 1
-
-check_ok display-popup -EE -t "$p0" true
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
-$TMUX bind G display-popup -EE -k -t "$p0" -w 20 -h 5 'exit 1'
-$TMUX2 send-keys -t "$OUTER" C-b G
-sleep 2
-modal=$(fmt modal:0 '#{window_modal_pane}')
-[ -n "$modal" ] || fail "failed display-popup -EE -k did not remain"
-must_equal "$(fmt "$modal" '#{pane_dead}')" 1
-must_equal "$($TMUX show-options -pv -t "$modal" remain-on-exit)" failed-key
-$TMUX2 send-keys -t "$OUTER" a
-sleep 1
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
-check_ok display-popup -EE -k -t "$p0" true
-must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
-
 # A nonmodal floating pane may remain above zoom, and switching between it and
 # the zoomed tiled pane must not unzoom the window.
 check_ok new-window -d -t modal: -n float-over-zoom 'cat'
--- a/regress/options-values.sh
+++ b/regress/options-values.sh
@@ -86,6 +86,11 @@ check_value "-gv status-keys" "vi"
 check_fail "unknown value: bogus" set -g status-keys bogus
 check_value "-gv status-keys" "vi"

+# pane-border-lines accepts rounded as a pane border style.
+check_ok set -gw pane-border-lines rounded
+check_value "-gwv pane-border-lines" "rounded"
+check_ok set -gw pane-border-lines single
+
 # --- flag options ---------------------------------------------------------
 #
 # focus-events is an on/off flag.  Setting with no value toggles it; explicit
--- a/regress/output-commands.sh
+++ b/regress/output-commands.sh
@@ -0,0 +1,131 @@
+#!/bin/sh
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -L${TEST_SOCKET:-testO$$} -f/dev/null"
+OUT=/tmp/tmux-output-commands-$$
+EXPECTED=$(printf 'one\ntwo')
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -f "$OUT"
+}
+trap cleanup EXIT HUP INT TERM
+
+$TMUX kill-server 2>/dev/null
+$TMUX new-session -d -x80 -y20 "sh -c 'printf \"\\033]133;A\\007p\\$ \\033]133;B\\007echo\\n\\033]133;C\\007one\\ntwo\\n\\033]133;D;0\\007separator\\n\\033]133;A\\007p\\$ \\033]133;B\\007broken\\n\\033]133;C\\007unfinished\"; exec sleep 100'" || exit 1
+sleep 1
+
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X copy-output || exit 1
+[ "$($TMUX show-buffer)" = unfinished ] || exit 1
+
+$TMUX send-keys -X pipe-output "wc -c >$OUT" || exit 1
+sleep 1
+[ "$(cat "$OUT")" = 10 ] || exit 1
+
+$TMUX send-keys -X copy-pipe-output "wc -c >$OUT" output || exit 1
+sleep 1
+[ "$(cat "$OUT")" = 10 ] || exit 1
+[ "$($TMUX show-buffer)" = unfinished ] || exit 1
+
+$TMUX send-keys -X select-output || exit 1
+$TMUX send-keys -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = unfinished ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X select-output || exit 1
+$TMUX send-keys -X pipe-selection "wc -c >$OUT" || exit 1
+sleep 1
+[ "$(cat "$OUT")" = 10 ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X search-backward separator || exit 1
+$TMUX send-keys -X copy-output || exit 1
+[ "$($TMUX show-buffer)" = "$EXPECTED" ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX copy-mode -c || exit 1
+$TMUX send-keys -X search-backward echo || exit 1
+$TMUX send-keys -X select-output || exit 1
+$TMUX send-keys -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = "$EXPECTED" ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X search-backward one || exit 1
+$TMUX send-keys -X copy-output || exit 1
+[ "$($TMUX show-buffer)" = "$EXPECTED" ] || exit 1
+$TMUX send-keys -X cancel || exit 1
+
+$TMUX new-window -d -n plain "printf 'alpha\\nbeta\\n'; exec sleep 100" || exit 1
+sleep 1
+$TMUX copy-mode -t :plain || exit 1
+$TMUX send-keys -t :plain.0 -X copy-output -a || exit 1
+all=$($TMUX show-buffer)
+case "$all" in
+*alpha*beta*) ;;
+*) exit 1 ;;
+esac
+$TMUX send-keys -t :plain.0 -X cancel || exit 1
+
+$TMUX set-buffer -b keep unchanged || exit 1
+$TMUX copy-mode -t :plain || exit 1
+$TMUX send-keys -t :plain.0 -X copy-output || exit 1
+[ "$($TMUX show-buffer -b keep)" = unchanged ] || exit 1
+$TMUX send-keys -t :plain.0 -X cancel || exit 1
+
+$TMUX new-window -d -n empty "printf '\\033]133;A\\007p\\$ \\033]133;B\\007echo\\033]133;C\\007one\\n\\033]133;D;0\\007\\033]133;A\\007p\\$ \\033]133;B\\007true\\033]133;C\\033]133;D;0\\007'; exec sleep 100" || exit 1
+sleep 1
+$TMUX copy-mode -t :empty || exit 1
+$TMUX send-keys -t :empty.0 -X copy-output || exit 1
+[ "$($TMUX show-buffer)" = one ] || exit 1
+$TMUX send-keys -t :empty.0 -X cancel || exit 1
+
+$TMUX new-window -d -n prompt "printf '\\033]133;A\\007p\\$ \\033]133;B\\007echo\\033]133;C\\007one\\n\\033]133;D;0\\007\\033]133;A\\007p\\$ \\033]133;B\\007'; exec sleep 100" || exit 1
+sleep 1
+$TMUX copy-mode -t :prompt || exit 1
+$TMUX send-keys -t :prompt.0 -X copy-output || exit 1
+[ "$($TMUX show-buffer)" = one ] || exit 1
+$TMUX send-keys -t :prompt.0 -X cancel || exit 1
+
+$TMUX copy-mode -c -t :prompt || exit 1
+$TMUX send-keys -t :prompt.0 -X expand-output || exit 1
+$TMUX send-keys -t :prompt.0 -X -N 100 cursor-down || exit 1
+$TMUX send-keys -t :prompt.0 -X select-output || exit 1
+[ "$($TMUX display-message -p -t :prompt.0 '#{selection_present}')" = 1 ] || exit 1
+$TMUX send-keys -t :prompt.0 -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = one ] || exit 1
+$TMUX send-keys -t :prompt.0 -X cancel || exit 1
+
+$TMUX copy-mode -t :prompt || exit 1
+$TMUX send-keys -t :prompt.0 -X -N 100 cursor-down || exit 1
+$TMUX send-keys -t :prompt.0 C-o || exit 1
+[ "$($TMUX display-message -p -t :prompt.0 '#{selection_present}')" = 1 ] || exit 1
+$TMUX send-keys -t :prompt.0 -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = one ] || exit 1
+$TMUX send-keys -t :prompt.0 -X cancel || exit 1
+
+$TMUX new-window -d -n same "printf '\\033]133;A\\007p\\$ \\033]133;B\\007echo\\n\\033]133;C\\007one\\033]133;D;0\\007\\033]133;A\\007p\\$ \\033]133;B\\007'; exec sleep 100" || exit 1
+sleep 1
+$TMUX copy-mode -t :same || exit 1
+$TMUX send-keys -t :same.0 -X search-backward one || exit 1
+$TMUX send-keys -t :same.0 -X select-output || exit 1
+$TMUX send-keys -t :same.0 -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = one ] || exit 1
+$TMUX send-keys -t :same.0 -X cancel || exit 1
+
+$TMUX new-window -d -n clear "printf 'old1\\nold2\\nold3\\nold4\\nold5\\nold6\\n\\033]133;A\\007p\\$ \\033]133;B\\007echo 1; clear; ps\\n\\033]133;C\\0071\\n\\033[H\\033[2JPID TTY\\n1 pts/0\\n\\033]133;D;0\\007separator\\n\\033]133;A\\007p\\$ \\033]133;B\\007'; exec sleep 100" || exit 1
+sleep 1
+$TMUX copy-mode -t :clear || exit 1
+$TMUX send-keys -t :clear.0 C-o || exit 1
+$TMUX send-keys -t :clear.0 -X copy-selection || exit 1
+[ "$($TMUX show-buffer)" = "$(printf 'PID TTY\n1 pts/0')" ] || exit 1
+$TMUX send-keys -t :clear.0 -X cancel || exit 1
+
+exit 0
--- a/regress/screen-redraw-floating.sh
+++ b/regress/screen-redraw-floating.sh
@@ -107,6 +107,12 @@ $TMUX2 new-pane -x28 -y8 -X4 -Y1 -B double \
 	"sh -c 'printf FLOAT; exec sleep 100'" || exit 1
 compare floating-border-double

+# Larger floating pane with rounded border lines.
+new_scene 40 12
+$TMUX2 new-pane -x28 -y8 -X4 -Y1 -B rounded \
+	"sh -c 'printf FLOAT; exec sleep 100'" || exit 1
+compare floating-border-rounded
+
 # Floating pane with no border lines: redraw_mark_pane_borders returns early so
 # the float has no border at all, only its (clipped) content over the base pane.
 new_scene 40 12
--- a/regress/screen-redraw-popups.sh
+++ b/regress/screen-redraw-popups.sh
@@ -0,0 +1,101 @@
+#!/bin/sh
+
+# Exercise drawing of popups (display-popup) over the window scene. A popup is an
+# overlay drawn on top of the redraw scene (the overlay_draw path in
+# screen-redraw.c), so this guards against regressions in how popups appear.
+#
+# A popup is modal and stays open until its command exits, so each scene fully
+# re-creates the servers and re-attaches; the popup is opened in the background
+# (display-popup blocks the client that runs it) and the outer pane is captured
+# while it is open.
+#
+# Run with GENERATE=1 to (re)create the golden files.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX=
+TMUX2=
+SETUP=0
+RESULTS=screen-redraw-results
+
+TMP=$(mktemp)
+
+cleanup() {
+	rm -f "$TMP"
+	[ -n "$TMUX" ] && $TMUX kill-server 2>/dev/null
+	[ -n "$TMUX2" ] && $TMUX2 kill-server 2>/dev/null
+}
+trap cleanup 0 1 15
+
+fail() {
+	echo "$*" >&2
+	exit 1
+}
+
+compare() {
+	sleep 1
+	$TMUX capturep -p >$TMP || exit 1
+	if [ -n "$GENERATE" ]; then
+		cp $TMP "$RESULTS/$1.result" || exit 1
+		echo "generated $1"
+	else
+		cmp -s $TMP "$RESULTS/$1.result" || \
+			fail "scene $1 differs from $RESULTS/$1.result"
+	fi
+}
+
+C="sh -c 'i=0; while [ \$i -lt 13 ]; do printf \"POP%02d abcdefghij\n\" \$i; i=\$((i + 1)); done; exec sleep 100'"
+
+# setup: fresh inner window attached inside a fresh outer pane, 40x14.
+setup() {
+	[ -n "$TMUX" ] && $TMUX kill-server 2>/dev/null
+	[ -n "$TMUX2" ] && $TMUX2 kill-server 2>/dev/null
+	SETUP=$((SETUP + 1))
+	TMUX="$TEST_TMUX -LtestA$$-$SETUP -f/dev/null"
+	TMUX2="$TEST_TMUX -LtestB$$-$SETUP -f/dev/null"
+	$TMUX2 new -d -x40 -y14 "$C" || exit 1
+	$TMUX2 set -g status off || exit 1
+	$TMUX2 set -g window-size manual || exit 1
+	$TMUX2 resizew -x40 -y14 || exit 1
+	$TMUX new -d -x40 -y14 || exit 1
+	$TMUX set -g status off || exit 1
+	$TMUX set -g window-size manual || exit 1
+	$TMUX set -g default-terminal "tmux-256color" || exit 1
+	$TMUX send -l "$TMUX2 attach" || exit 1
+	$TMUX send Enter || exit 1
+	sleep 1
+}
+
+# popup <args>: open a popup running a fixed command, in the background (it stays
+# open because the command sleeps; the servers are killed at the next setup).
+popup() {
+	$TMUX2 display-popup "$@" -E "sh -c 'printf POPUP; exec sleep 100'" &
+	sleep 1
+}
+
+# Basic popup over a single pane.
+setup
+popup -w20 -h6 -x6 -y3
+compare popup-basic
+
+# Popup over a split: drawn on top of the pane border.
+setup
+$TMUX2 splitw -h "$C" || exit 1
+popup -w24 -h8 -x8 -y3
+compare popup-over-split
+
+# Popup with no border lines (-B).
+setup
+popup -B -w20 -h6 -x6 -y3
+compare popup-noborder
+
+# Popup with double border lines.
+setup
+popup -b double -w20 -h6 -x6 -y3
+compare popup-double
+
+exit 0
--- a/regress/screen-redraw-results/floating-border-rounded.result
+++ b/regress/screen-redraw-results/floating-border-rounded.result
@@ -0,0 +1,12 @@
+base
+    ╭──────────────────────────╮
+    │FLOAT                     │
+    │                          │
+    │                          │
+    │                          │
+    │                          │
+    │                          │
+    ╰──────────────────────────╯
+
+
+
--- a/regress/screen-redraw-results/popup-basic.result
+++ b/regress/screen-redraw-results/popup-basic.result
@@ -0,0 +1,14 @@
+POP00 ┌──────────────────┐
+POP01 │POPUP             │
+POP02 │                  │
+POP03 │                  │
+POP04 │                  │
+POP05 └──────────────────┘
+POP06 abcdefghij
+POP07 abcdefghij
+POP08 abcdefghij
+POP09 abcdefghij
+POP10 abcdefghij
+POP11 abcdefghij
+POP12 abcdefghij
+
--- a/regress/screen-redraw-results/popup-double.result
+++ b/regress/screen-redraw-results/popup-double.result
@@ -0,0 +1,14 @@
+POP00 ╔══════════════════╗
+POP01 ║POPUP             ║
+POP02 ║                  ║
+POP03 ║                  ║
+POP04 ║                  ║
+POP05 ╚══════════════════╝
+POP06 abcdefghij
+POP07 abcdefghij
+POP08 abcdefghij
+POP09 abcdefghij
+POP10 abcdefghij
+POP11 abcdefghij
+POP12 abcdefghij
+
--- a/regress/screen-redraw-results/popup-noborder.result
+++ b/regress/screen-redraw-results/popup-noborder.result
@@ -0,0 +1,14 @@
+POP00 POPUP
+POP01
+POP02
+POP03
+POP04
+POP05
+POP06 abcdefghij
+POP07 abcdefghij
+POP08 abcdefghij
+POP09 abcdefghij
+POP10 abcdefghij
+POP11 abcdefghij
+POP12 abcdefghij
+
--- a/regress/screen-redraw-results/popup-over-split.result
+++ b/regress/screen-redraw-results/popup-over-split.result
@@ -0,0 +1,14 @@
+POP00 ab┌──────────────────────┐fghij
+POP01 ab│POPUP                 │fghij
+POP02 ab│                      │fghij
+POP03 ab│                      │fghij
+POP04 ab│                      │fghij
+POP05 ab│                      │fghij
+POP06 ab│                      │fghij
+POP07 ab└──────────────────────┘fghij
+POP08 abcdefghij    │POP08 abcdefghij
+POP09 abcdefghij    │POP09 abcdefghij
+POP10 abcdefghij    │POP10 abcdefghij
+POP11 abcdefghij    │POP11 abcdefghij
+POP12 abcdefghij    │POP12 abcdefghij
+                    │
--- a/screen-redraw.c
+++ b/screen-redraw.c
@@ -33,7 +33,7 @@
 * this is done at various points, such as when a pane is moved or resized. The
 * scene only includes the part of the client used for the window: panes, pane
 * status lines, borders, scrollbars, and any area outside the window. The
- * client status line is not included.
+ * client status line and overlay are not included.
 *
 * A scene is made from spans. A span is a horizontal run of cells on one
 * visible line that can be drawn in the same way. Each span has a type, for
@@ -93,6 +93,7 @@ enum redraw_span_type {
 #define REDRAW_PANE_SCROLLBAR 0x20
 #define REDRAW_STATUS 0x40
 #define REDRAW_MENU 0x80
+#define REDRAW_OVERLAY 0x100

 /* Draw everything. */
 #define REDRAW_ALL 0x7fffffff
@@ -263,6 +264,8 @@ redraw_flags_to_string(int flags)
 		strlcat(s, "scrollbar ", sizeof s);
 	if (flags & REDRAW_MENU)
 		strlcat(s, "menu ", sizeof s);
+	if (flags & REDRAW_OVERLAY)
+		strlcat(s, "overlay ", sizeof s);
 	if (REDRAW_IS_ALL(flags))
 		strlcat(s, "all ", sizeof s);
 	if (*s != '\0')
@@ -1378,30 +1381,45 @@ static void
 redraw_draw_span(struct redraw_draw_ctx *dctx, struct redraw_span *span,
    u_int y)
 {
+	struct redraw_scene	*scene = dctx->scene;
 	struct redraw_span_data	*data = &span->data;
 	enum redraw_span_type	 type = data->type;
+	struct client		*c = scene->c;
+	struct tty		*tty = &c->tty;
+	struct visible_ranges	*r;
+	struct visible_range	*rr;
+	u_int			 i, x, n;

 	if (type == REDRAW_SPAN_STATUS && ~data->st.wp->flags & PANE_NEWSTATUS)
 		return;

-	switch (span->data.type) {
-	case REDRAW_SPAN_PANE:
-		redraw_draw_pane_span(dctx, span, span->x, y, span->width);
-		break;
-	case REDRAW_SPAN_BORDER:
-	case REDRAW_SPAN_EMPTY:
-	case REDRAW_SPAN_OUTSIDE:
-		redraw_draw_border_span(dctx, span, span->x, y, span->width);
-		break;
-	case REDRAW_SPAN_STATUS:
-		redraw_draw_status_span(dctx, span, span->x, y, span->width);
-		break;
-	case REDRAW_SPAN_SCROLLBAR:
-		redraw_draw_scrollbar_span(dctx, span, span->x, y, span->width);
-		break;
-	case REDRAW_SPAN_MENU:
-		redraw_draw_menu_span(dctx, span, span->x, y, span->width);
-		break;
+	r = tty_check_overlay_range(tty, span->x, y, span->width);
+	for (i = 0; i < r->used; i++) {
+		rr = &r->ranges[i];
+		if (rr->nx == 0)
+			continue;
+		x = rr->px;
+		n = rr->nx;
+
+		switch (span->data.type) {
+		case REDRAW_SPAN_PANE:
+			redraw_draw_pane_span(dctx, span, x, y, n);
+			break;
+		case REDRAW_SPAN_BORDER:
+		case REDRAW_SPAN_EMPTY:
+		case REDRAW_SPAN_OUTSIDE:
+			redraw_draw_border_span(dctx, span, x, y, n);
+			break;
+		case REDRAW_SPAN_STATUS:
+			redraw_draw_status_span(dctx, span, x, y, n);
+			break;
+		case REDRAW_SPAN_SCROLLBAR:
+			redraw_draw_scrollbar_span(dctx, span, x, y, n);
+			break;
+		case REDRAW_SPAN_MENU:
+			redraw_draw_menu_span(dctx, span, x, y, n);
+			break;
+		}
 	}
 }

@@ -1670,8 +1688,10 @@ redraw_draw(struct client *c, struct window_pane *wp, int flags)
 	struct screen		*sl;
 	struct redraw_scene	*scene;
 	struct window_pane	*loop;
-	u_int			 width, i, y, lines;
+	u_int			 width, i, y, lines, j;
 	struct redraw_span	*first;
+	struct visible_ranges	*r;
+	struct visible_range	*rr;
 	int			 redraw;

 	if (c->flags & CLIENT_SUSPENDED)
@@ -1779,9 +1799,19 @@ redraw_draw(struct client *c, struct window_pane *wp, int flags)
 		else
 			y = c->tty.sy - lines;
 		sl = c->status.active;
-		for (i = 0; i < lines; i++)
-			tty_draw_line(tty, sl, 0, i, tty->sx, 0, y + i, NULL);
+		for (i = 0; i < lines; i++) {
+			r = tty_check_overlay_range(tty, 0, y + i, tty->sx);
+			for (j = 0; j < r->used; j++) {
+				rr = &r->ranges[j];
+				if (rr->nx == 0)
+					continue;
+				tty_draw_line(tty, sl, rr->px, i, rr->nx,
+				    rr->px, y + i, NULL);
+			}
+		}
 	}
+	if (c->overlay_draw != NULL && (flags & REDRAW_OVERLAY))
+		c->overlay_draw(c, c->overlay_data);

 	tty_reset(tty);

@@ -1837,13 +1867,18 @@ redraw_screen(struct client *c)
 {
 	int	flags = 0;

-	if (c->flags & CLIENT_REDRAWWINDOW)
-		redraw_draw(c, NULL, REDRAW_ALL);
-	else {
+	if (c->flags & CLIENT_REDRAWWINDOW) {
+		if (c->flags & CLIENT_REDRAWOVERLAY)
+			redraw_draw(c, NULL, REDRAW_ALL);
+		else
+			redraw_draw(c, NULL, REDRAW_ALL & ~REDRAW_OVERLAY);
+	} else {
 		if (c->flags & CLIENT_REDRAWBORDERS)
 			flags |= (REDRAW_PANE_BORDER|REDRAW_PANE_STATUS);
 		if (c->flags & CLIENT_REDRAWSTATUS)
 			flags |= (REDRAW_STATUS|REDRAW_PANE_STATUS);
+		if (c->flags & CLIENT_REDRAWOVERLAY)
+			flags |= REDRAW_OVERLAY;
 		if (c->flags & CLIENT_REDRAWMENU)
 			flags |= REDRAW_MENU;
 		if (c->session->curw->window->menu != NULL)
--- a/screen-write.c
+++ b/screen-write.c
@@ -305,16 +305,21 @@ screen_write_initctx(struct screen_write_ctx *ctx, struct tty_ctx *ttyctx,

 	if (~ctx->flags & SCREEN_WRITE_SYNC) {
 		/*
-		 * For the active pane showing its base screen, only use
-		 * synchronized updates if requested (commands that move the
-		 * cursor); for other panes or a pane in a mode, always use it,
-		 * since the cursor will have to move.
+		 * For the active pane showing its base screen or for an
+		 * overlay (no pane), only use synchronized updates if
+		 * requested (commands that move the cursor); for other panes
+		 * or a pane in a mode, always use it, since the cursor will
+		 * have to move.
 		 */
 		if (ctx->wp != NULL && (ctx->wp != ctx->wp->window->active ||
 		    ctx->wp->screen != &ctx->wp->base))
 			ttyctx->flags |= TTY_CTX_SYNC;
-		else if (is_sync)
-			ttyctx->flags |= TTY_CTX_SYNC;
+		else {
+			if (ctx->wp == NULL)
+				ttyctx->flags |= TTY_CTX_OVERLAY_SYNC;
+			if (is_sync)
+				ttyctx->flags |= TTY_CTX_SYNC;
+		}
 		tty_write(tty_cmd_syncstart, ttyctx);
 		ctx->flags |= SCREEN_WRITE_SYNC;
 	}
@@ -709,7 +714,7 @@ screen_write_fast_copy(struct screen_write_ctx *ctx, struct screen *src,
 			if (!window_position_is_visible(r, xoff + s->cx))
 				break;
 			ttyctx.cell = &gc;
-			ttyctx.flags &= TTY_CTX_SYNC;
+			ttyctx.flags &= (TTY_CTX_OVERLAY_SYNC|TTY_CTX_SYNC);
 			tty_write(tty_cmd_cell, &ttyctx);
 			ttyctx.ocx++;

--- a/server-client.c
+++ b/server-client.c
@@ -67,6 +67,77 @@ server_client_how_many(void)
 	return (n);
 }

+/* Overlay timer callback. */
+static void
+server_client_overlay_timer(__unused int fd, __unused short events, void *data)
+{
+	server_client_clear_overlay(data);
+}
+
+/* Set an overlay on client. */
+void
+server_client_set_overlay(struct client *c, u_int delay,
+    overlay_check_cb checkcb, overlay_mode_cb modecb,
+    overlay_draw_cb drawcb, overlay_key_cb keycb, overlay_free_cb freecb,
+    overlay_resize_cb resizecb, void *data)
+{
+	struct timeval	tv;
+
+	if (c->overlay_draw != NULL)
+		server_client_clear_overlay(c);
+
+	tv.tv_sec = delay / 1000;
+	tv.tv_usec = (delay % 1000) * 1000L;
+
+	if (event_initialized(&c->overlay_timer))
+		evtimer_del(&c->overlay_timer);
+	evtimer_set(&c->overlay_timer, server_client_overlay_timer, c);
+	if (delay != 0)
+		evtimer_add(&c->overlay_timer, &tv);
+
+	c->overlay_check = checkcb;
+	c->overlay_mode = modecb;
+	c->overlay_draw = drawcb;
+	c->overlay_key = keycb;
+	c->overlay_free = freecb;
+	c->overlay_resize = resizecb;
+	c->overlay_data = data;
+
+	if (c->overlay_check == NULL)
+		c->tty.flags |= TTY_FREEZE;
+	if (c->overlay_mode == NULL)
+		c->tty.flags |= TTY_NOCURSOR;
+	window_update_focus(c->session->curw->window);
+	server_redraw_client(c);
+}
+
+/* Clear overlay mode on client. */
+void
+server_client_clear_overlay(struct client *c)
+{
+	if (c->overlay_draw == NULL)
+		return;
+
+	if (event_initialized(&c->overlay_timer))
+		evtimer_del(&c->overlay_timer);
+
+	if (c->overlay_free != NULL)
+		c->overlay_free(c, c->overlay_data);
+
+	c->overlay_check = NULL;
+	c->overlay_mode = NULL;
+	c->overlay_draw = NULL;
+	c->overlay_key = NULL;
+	c->overlay_free = NULL;
+	c->overlay_resize = NULL;
+	c->overlay_data = NULL;
+
+	c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR);
+	if (c->session != NULL)
+		window_update_focus(c->session->curw->window);
+	server_redraw_client(c);
+}
+
 /* Are these ranges empty? That is, nothing is visible. */
 int
 server_client_ranges_is_empty(struct visible_ranges *r)
@@ -90,6 +161,52 @@ server_client_ensure_ranges(struct visible_ranges *r, u_int n)
 	r->size = n;
 }

+/*
+ * Given overlay position and dimensions, return parts of the input range which
+ * are visible.
+ */
+void
+server_client_overlay_range(u_int x, u_int y, u_int sx, u_int sy, u_int px,
+    u_int py, u_int nx, struct visible_ranges *r)
+{
+	u_int	ox, onx;
+
+	/* Trivial case of no overlap in the y direction. */
+	if (py < y || py > y + sy - 1) {
+		server_client_ensure_ranges(r, 1);
+		r->ranges[0].px = px;
+		r->ranges[0].nx = nx;
+		r->used = 1;
+		return;
+	}
+	server_client_ensure_ranges(r, 2);
+
+	/* Visible bit to the left of the popup. */
+	if (px < x) {
+		r->ranges[0].px = px;
+		r->ranges[0].nx = x - px;
+		if (r->ranges[0].nx > nx)
+			r->ranges[0].nx = nx;
+	} else {
+		r->ranges[0].px = 0;
+		r->ranges[0].nx = 0;
+	}
+
+	/* Visible bit to the right of the popup. */
+	ox = x + sx;
+	if (px > ox)
+		ox = px;
+	onx = px + nx;
+	if (onx > ox) {
+		r->ranges[1].px = ox;
+		r->ranges[1].nx = onx - ox;
+	} else {
+		r->ranges[1].px = 0;
+		r->ranges[1].nx = 0;
+	}
+	r->used = 2;
+}
+
 /* Check if this client is inside this server. */
 int
 server_client_check_nested(struct client *c)
@@ -373,6 +490,7 @@ server_client_lost(struct client *c)
 		cfg_client = NULL;
 	c->flags |= CLIENT_DEAD;

+	server_client_clear_overlay(c);
 	status_prompt_clear(c);
 	status_message_clear(c);

@@ -1628,6 +1746,10 @@ server_client_handle_key0(struct client *c, struct key_event *event,
 	if (s == NULL || (c->flags & CLIENT_UNATTACHEDFLAGS))
 		return (0);

+	/*
+	 * Handle theme reporting keys before overlays so they work even when a
+	 * popup is open.
+	 */
 	if (event->key == KEYC_REPORT_LIGHT_THEME) {
 		server_client_report_theme(c, THEME_LIGHT);
 		return (0);
@@ -1638,9 +1760,10 @@ server_client_handle_key0(struct client *c, struct key_event *event,
 	}

 	/*
-	 * Dead panes waiting for a key, modal cancel keys, panes capturing all keys
-	 * and the command prompt are special cases. The queue might be blocked so
-	 * they need to be processed immediately rather than queued.
+	 * Key presses in overlay mode, dead panes waiting for a key, modal cancel
+	 * keys, panes capturing all keys and the command prompt are special cases.
+	 * The queue might be blocked so they need to be processed immediately
+	 * rather than queued.
 	 */
 	if (~c->flags & CLIENT_READONLY) {
 		if (c->message_string != NULL) {
@@ -1649,11 +1772,22 @@ server_client_handle_key0(struct client *c, struct key_event *event,
 			status_message_clear(c);
 		}

+		if (c->overlay_key != NULL) {
+			switch (c->overlay_key(c, c->overlay_data, event)) {
+			case 0:
+				return (0);
+			case 1:
+				server_client_clear_overlay(c);
+				return (0);
+			}
+		}
+
+		server_client_clear_overlay(c);
+
 		wp = s->curw->window->active;
 		if (server_client_handle_dead_key(wp, event->key))
 			return (0);
-		if (wp != NULL &&
-		    wp == wp->window->modal &&
+		if (wp != NULL && wp == wp->window->modal &&
 		    (wp->flags & PANE_CLOSEONCANCEL) &&
 		    (event->key == '\033' || event->key == ('c'|KEYC_CTRL))) {
 			server_kill_pane(wp);
@@ -2043,8 +2177,11 @@ server_client_reset_state(struct client *c)
 	flags = (tty->flags & TTY_BLOCK);
 	tty->flags &= ~TTY_BLOCK;

-	/* Get mode from the menu if any, else from the screen. */
-	if (w->menu != NULL) {
+	/* Get mode from overlay if any, else from screen. */
+	if (c->overlay_draw != NULL) {
+		if (c->overlay_mode != NULL)
+			s = c->overlay_mode(c, c->overlay_data, &cx, &cy);
+	} else if (w->menu != NULL) {
 		menu_get_cursor(w->menu, &cx, &cy);
 		s = menu_screen(w->menu);
 	} else if (wp != NULL && c->prompt == NULL)
@@ -2066,7 +2203,7 @@ server_client_reset_state(struct client *c)
 	if (c->prompt != NULL) {
 		prompt = 1;
 		status_prompt_cursor(c, &cx, &cy);
-	} else if (wp != NULL) {
+	} else if (wp != NULL && c->overlay_draw == NULL) {
 		if (w->menu != NULL) {
 			tty_window_offset(tty, &ox, &oy, &sx, &sy);
 			if (cx < ox || cx >= ox + sx ||
@@ -2121,7 +2258,7 @@ server_client_reset_state(struct client *c)
 			if (!cursor)
 				mode &= ~MODE_CURSOR;
 		}
-	} else if (s == NULL)
+	} else if (c->overlay_mode == NULL || s == NULL)
 		mode &= ~MODE_CURSOR;
 	if (~pane_mode & MODE_SYNC) {
 		log_debug("%s: cursor to %u,%u", __func__, cx, cy);
@@ -2138,7 +2275,7 @@ server_client_reset_state(struct client *c)
 	 * movement events.
 	 */
 	if (options_get_number(oo, "mouse")) {
-		if (w->menu == NULL) {
+		if (c->overlay_draw == NULL && w->menu == NULL) {
 			mode &= ~ALL_MOUSE_MODES;
 			TAILQ_FOREACH(loop, &w->panes, entry) {
 				if (loop->screen->mode & MODE_MOUSE_ALL)
@@ -2154,7 +2291,7 @@ server_client_reset_state(struct client *c)
 	}

 	/* Clear bracketed paste mode if at the prompt. */
-	if (prompt)
+	if (c->overlay_draw == NULL && prompt)
 		mode &= ~MODE_BRACKETPASTE;

 	/* Set the terminal mode and reset attributes. */
@@ -2356,10 +2493,11 @@ server_client_check_redraw(struct client *c)
 	if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED))
 		return;
 	if (c->flags & CLIENT_ALLREDRAWFLAGS) {
-		log_debug("%s: redraw%s%s%s%s", c->name,
+		log_debug("%s: redraw%s%s%s%s%s", c->name,
 		    (c->flags & CLIENT_REDRAWWINDOW) ? " window" : "",
 		    (c->flags & CLIENT_REDRAWSTATUS) ? " status" : "",
 		    (c->flags & CLIENT_REDRAWBORDERS) ? " borders" : "",
+		    (c->flags & CLIENT_REDRAWOVERLAY) ? " overlay" : "",
 		    (c->flags & CLIENT_REDRAWMENU) ? " menu" : "");
 	}

@@ -2567,6 +2705,10 @@ server_client_dispatch(struct imsg *imsg, void *arg)
 		tty_resize(&c->tty);
 		tty_repeat_requests(&c->tty, 0);
 		recalculate_sizes();
+		if (c->overlay_resize == NULL)
+			server_client_clear_overlay(c);
+		else
+			c->overlay_resize(c, c->overlay_data);
 		server_redraw_client(c);
 		if (c->session != NULL)
 			server_client_fire_resized(c, old_sx, old_sy);
--- a/spawn.c
+++ b/spawn.c
@@ -701,7 +701,7 @@ spawn_editor_finish(struct window_pane *wp)

 struct spawn_editor_state *
 spawn_editor(struct client *c, const char *buf, size_t len,
-    spawn_finish_edit_cb cb, void *arg)
+    const char *editor, spawn_finish_edit_cb cb, void *arg)
 {
 	struct spawn_editor_state	*es;
 	struct spawn_context		 sc = { 0 };
@@ -715,13 +715,13 @@ spawn_editor(struct client *c, const char *buf, size_t len,
 	FILE				*f;
 	char				*cmd, *cause = NULL;
 	char				 path[] = _PATH_TMP "tmux.XXXXXXXX";
-	const char			*editor;
 	int				 fd;

 	if (w->modal != NULL)
 		return (NULL);

-	editor = options_get_string(global_options, "editor");
+	if (editor == NULL)
+		editor = options_get_string(global_options, "editor");
 	fd = mkstemp(path);
 	if (fd == -1)
 		return (NULL);
--- a/status.c
+++ b/status.c
@@ -577,6 +577,8 @@ status_prompt_set(struct client *c, struct cmd_find_state *fs,
 	struct prompt_create_data	pd;
 	struct status_prompt_data	*spd;

+	server_client_clear_overlay(c);
+
 	status_message_clear(c);
 	status_prompt_clear(c);
 	status_push_screen(c);
--- a/tmux.1
+++ b/tmux.1
@@ -1,4 +1,4 @@
-.\" $OpenBSD: tmux.1,v 1.1169 2026/09/10 11:02:18 nicm Exp $
+.\" $OpenBSD: tmux.1,v 1.1170 2026/09/11 10:17:16 nicm Exp $
 .\"
 .\" Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 .\"
@@ -14,7 +14,7 @@
 .\" IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 .\" OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 .\"
-.Dd $Mdocdate: September 10 2026 $
+.Dd $Mdocdate: September 11 2026 $
 .Dt TMUX 1
 .Os
 .Sh NAME
@@ -2006,6 +2006,25 @@ Same as
 .Ic copy\-pipe
 but also exit copy mode.
 .It Xo
+.Ic copy\-pipe\-output
+.Op Fl aCP
+.Op Ar command
+.Op Ar prefix
+.Xc
+Copy the current OSC 133 command output, pipe it to
+.Ar command ,
+and clear the selection.
+.Ar prefix
+is used to name the new paste buffer.
+.It Xo
+.Ic copy\-output
+.Op Fl aCP
+.Op Ar prefix
+.Xc
+Copy the current OSC 133 command output and clear the selection.
+.Ar prefix
+is used to name the new paste buffer.
+.It Xo
 .Ic copy\-selection
 .Op Fl CP
 .Op Ar prefix
@@ -2171,6 +2190,27 @@ Hide line numbers in copy mode.
 .Xc
 Toggle line numbers in copy mode.
 .It Xo
+.Ic collapse\-output
+.Op Fl a
+.Xc
+Collapse the output for the command on the cursor line.
+With
+.Fl a ,
+collapse all command output in the copy-mode buffer.
+Text before the first OSC 133 prompt is treated as an initial command output
+region.
+.It Xo
+.Ic expand\-output
+.Op Fl a
+.Xc
+Expand the output for the command on the cursor line.
+With
+.Fl a ,
+expand all command output in the copy-mode buffer.
+.Pp
+The Tab key toggles output for the command on the cursor line and S-Tab
+toggles all command output.
+.It Xo
 .Ic middle\-line
 (vi: M)
 (emacs: M\-r)
@@ -2224,6 +2264,32 @@ but treat all non-whitespace characters as part of a word.
 .Xc
 Switch at which end of the selection the cursor sits.
 .It Xo
+.Ic open\-output
+.Op Fl a
+.Op Ar command
+.Xc
+Open the current OSC 133 command output in an editor.
+If
+.Ar command
+is given, it is used as the editor command; otherwise, the
+.Ic editor
+option is used.
+.It Xo
+.Ic open\-selection
+.Op Ar command
+.Xc
+Open the current selection in an editor.
+If
+.Ar command
+is given, it is used as the editor command; otherwise, the
+.Ic editor
+option is used.
+In emacs mode,
+.Ql e ,
+and in vi mode,
+.Ql M\-e ,
+opens the selection if one is present, otherwise the command output.
+.It Xo
 .Ic page\-down
 (vi: C\-f)
 (emacs: PageDown)
@@ -2264,6 +2330,21 @@ Same as
 .Ic pipe
 but also exit copy mode.
 .It Xo
+.Ic pipe\-output
+.Op Fl a
+.Op Ar command
+.Xc
+Pipe the current OSC 133 command output to
+.Ar command
+and clear the selection.
+.It Xo
+.Ic pipe\-selection
+.Op Ar command
+.Xc
+Pipe the selected text to
+.Ar command
+and clear the selection.
+.It Xo
 .Ic previous\-matching\-bracket
 (emacs: M\-C\-b)
 .Xc
@@ -2453,6 +2534,15 @@ Search forward for the specified plain text.
 Repeat the last search in the reverse direction (forward becomes backward and
 backward becomes forward).
 .It Xo
+.Ic select\-output
+.Op Fl a
+.Xc
+Select the current OSC 133 command output.
+The default emacs binding is
+.Ql C\-o
+and the default vi binding is
+.Ql M\-o .
+.It Xo
 .Ic select\-line
 (vi: V)
 .Xc
@@ -2496,6 +2586,20 @@ Toggle the visibility of the position indicator in the top right.
 Move to the top line.
 .El
 .Pp
+The output commands use OSC 133 output text from the
+.Ql C
+marker up to its matching
+.Ql D
+marker.
+If there is no
+.Ql D
+marker, the output ends at the end of the copy-mode buffer.
+At the following prompt or below it, they use the most recent nonempty output.
+With
+.Fl a ,
+they use the entire copy-mode buffer instead.
+If no output range can be found, they do nothing.
+.Pp
 The search commands come in several varieties:
 .Ql search\-forward
 and
@@ -2603,12 +2707,19 @@ The synopsis for the
 command is:
 .Bl -tag -width Ds
 .It Xo Ic copy\-mode
-.Op Fl dekHMqSu
+.Op Fl UcdekHMqSu
 .Op Fl s Ar src\-pane
 .Op Fl t Ar target\-pane
 .Xc
 Enter copy mode.
 .Pp
+.Fl c
+enters copy mode with OSC 133 command output collapsed.
+.Fl U
+enters copy mode with OSC 133 output controls shown and all output expanded.
+When output is collapsed, the prompt and entered command are shown and text
+from the output start marker to the next primary prompt marker is hidden.
+.Pp
 .Fl u
 enters copy mode and scrolls one page up and
 .Fl d
@@ -5353,16 +5464,10 @@ section on how to specify
 .Ar style .
 .It Ic menu\-border\-lines Ar type
 Set the type of characters used for drawing menu borders.
-.Ar type
-may be one of
-.Ic single ,
-.Ic rounded ,
-.Ic double ,
-.Ic heavy ,
-.Ic simple ,
-.Ic padded ,
-or
-.Ic none .
+See
+.Ic popup\-border\-lines
+for possible values for
+.Ar border\-lines .
 .It Ic message\-command\-style Ar style
 Set status line message command style.
 This is used for the command prompt with
@@ -5815,6 +5920,20 @@ section.
 .It Ic copy\-mode\-position\-format Ar format
 Format of the position indicator in copy mode.
 .Pp
+.It Ic copy\-mode\-exit\-status\-format Ar format
+Format of the OSC 133 exit status indicator in the copy-mode gutter.
+The default displays a theme red
+.Ql !
+for a nonzero status and a space otherwise.
+The gutter grows to fit the expanded format.
+The format is drawn to the left of the collapse control, and its alignment
+applies within that area.
+The format is expanded with
+.Ql exit_status
+and
+.Ql exit_status_present ,
+which is set only when the OSC 133 end-of-output marker includes a status.
+.Pp
 .It Ic copy\-mode\-position\-style Ar style
 Set the style of the position indicator in copy mode.
 For how to specify
@@ -5986,6 +6105,8 @@ single lines using ACS or UTF\-8 characters
 double lines using UTF\-8 characters
 .It heavy
 heavy lines using UTF\-8 characters
+.It rounded
+single lines with rounded corners using UTF\-8 characters
 .It simple
 simple ASCII characters
 .It number
@@ -6020,6 +6141,48 @@ see the
 section.
 Attributes are ignored.
 .Pp
+.It Ic popup\-style Ar style
+Set the popup style.
+See the
+.Sx STYLES
+section on how to specify
+.Ar style .
+Attributes are ignored.
+.Pp
+.It Ic popup\-border\-style Ar style
+Set the popup border style.
+See the
+.Sx STYLES
+section on how to specify
+.Ar style .
+Attributes are ignored.
+.Pp
+.It Ic popup\-border\-lines Ar type
+Set the type of characters used for drawing popup borders.
+.Ar type
+may be one of:
+.Bl -tag -width Ds
+.It single
+single lines using ACS or UTF\-8 characters (default)
+.It rounded
+variation of single with rounded corners using UTF\-8 characters
+.It double
+double lines using UTF\-8 characters
+.It heavy
+heavy lines using UTF\-8 characters
+.It simple
+simple ASCII characters
+.It padded
+simple ASCII space character
+.It none
+no border
+.El
+.Pp
+.Ql double
+and
+.Ql heavy
+will fall back to standard ACS line drawing when UTF\-8 is not supported.
+.Pp
 .It Xo Ic pane\-scrollbars
 .Op Ic off | modal | on | auto\-hide
 .Xc
@@ -8166,16 +8329,10 @@ command should be omitted.
 .Pp
 .Fl b
 sets the type of characters used for drawing menu borders.
-.Ar border\-lines
-may be one of
-.Ic single ,
-.Ic rounded ,
-.Ic double ,
-.Ic heavy ,
-.Ic simple ,
-.Ic padded ,
-or
-.Ic none .
+See
+.Ic popup\-border\-lines
+for possible values for
+.Ar border\-lines .
 .Pp
 .Fl H
 sets the style for the selected menu item (see
@@ -8211,18 +8368,15 @@ Both may be a row or column number, or one of the following special values:
 .It Li "S" Ta Fl y Ta "The line above or below the status line"
 .El
 .Pp
-Or a format, which is expanded with the following additional variables.
-The
-.Ql popup_
-prefix is retained for compatibility:
+Or a format, which is expanded including the following additional variables:
 .Bl -column "XXXXXXXXXXXXXXXXXXXXXXXXXX" -offset indent
 .It Sy "Variable name" Ta Sy "Replaced with"
-.It Li "popup_centre_x" Ta "Centered in the window"
-.It Li "popup_centre_y" Ta "Centered in the window"
-.It Li "popup_height" Ta "Height of the menu"
+.It Li "popup_centre_x" Ta "Centered in the client"
+.It Li "popup_centre_y" Ta "Centered in the client"
+.It Li "popup_height" Ta "Height of menu or popup"
 .It Li "popup_last_x" Ta "Left of the last menu"
 .It Li "popup_last_y" Ta "Bottom of the last menu"
-.It Li "popup_mouse_bottom" Ta "Bottom at the mouse"
+.It Li "popup_mouse_bottom" Ta "Bottom of at the mouse"
 .It Li "popup_mouse_centre_x" Ta "Horizontal centre at the mouse"
 .It Li "popup_mouse_centre_y" Ta "Vertical centre at the mouse"
 .It Li "popup_mouse_top" Ta "Top at the mouse"
@@ -8233,7 +8387,7 @@ prefix is retained for compatibility:
 .It Li "popup_pane_right" Ta "Right of the pane"
 .It Li "popup_pane_top" Ta "Top of the pane"
 .It Li "popup_status_line_y" Ta "Above or below the status line"
-.It Li "popup_width" Ta "Width of the menu"
+.It Li "popup_width" Ta "Width of menu or popup"
 .It Li "popup_window_status_line_x" Ta "At the window position in status line"
 .It Li "popup_window_status_line_y" Ta "At the status line showing the window"
 .El
@@ -8319,6 +8473,116 @@ lists the format variables and their values.
 .Fl I
 forwards any input read from stdin to the empty pane given by
 .Ar target\-pane .
+.Tg popup
+.It Xo Ic display\-popup
+.Op Fl BCEkN
+.Op Fl b Ar border\-lines
+.Op Fl c Ar target\-client
+.Op Fl d Ar start\-directory
+.Op Fl e Ar environment
+.Op Fl h Ar height
+.Op Fl s Ar style
+.Op Fl S Ar border\-style
+.Op Fl t Ar target\-pane
+.Op Fl T Ar title
+.Op Fl w Ar width
+.Op Fl x Ar position
+.Op Fl y Ar position
+.Op Ar shell\-command Op Ar argument ...
+.Xc
+.D1 Pq alias: Ic popup
+Display a popup running
+.Ar shell\-command
+(or
+.Ar default\-command
+when omitted) on
+.Ar target\-client .
+A popup is a rectangular box drawn over the top of any panes.
+If the command is run inside an existing popup, that popup is modified.
+Only the
+.Fl b ,
+.Fl B ,
+.Fl C ,
+.Fl E ,
+.Fl EE ,
+.Fl K ,
+.Fl N ,
+.Fl s ,
+and
+.Fl S
+options are accepted in this case;
+all others are ignored.
+.Pp
+.Fl E
+closes the popup automatically when
+.Ar shell\-command
+exits.
+Two
+.Fl E
+closes the popup only if
+.Ar shell\-command
+exited with success.
+.Fl k
+allows any key to dismiss the popup instead of only
+.Ql Escape
+or
+.Ql C\-c .
+.Pp
+.Fl x
+and
+.Fl y
+give the position of the popup, they have the same meaning as for the
+.Ic display\-menu
+command.
+.Fl w
+and
+.Fl h
+give the width and height - both may be a percentage (followed by
+.Ql % ) .
+If omitted, half of the terminal size is used.
+.Pp
+.Fl B
+does not surround the popup by a border.
+.Pp
+.Fl b
+sets the type of characters used for drawing popup borders.
+When
+.Fl B
+is specified, the
+.Fl b
+option is ignored.
+See
+.Ic popup\-border\-lines
+for possible values for
+.Ar border\-lines .
+.Pp
+.Fl s
+sets the style for the popup and
+.Fl S
+sets the style for the popup border (see
+.Sx STYLES ) .
+.Pp
+.Fl e
+takes the form
+.Ql VARIABLE=value
+and sets an environment variable for the popup; it may be specified multiple
+times.
+.Pp
+.Fl T
+is a format for the popup title (see
+.Sx FORMATS ) .
+.Pp
+The
+.Fl C
+flag closes any popup on the client.
+.Pp
+.Fl N
+disables any previously specified
+.Fl E ,
+.Fl EE ,
+or
+.Fl k
+option.
 .Tg showphist
 .It Xo Ic show\-prompt\-history
 .Op Fl T Ar prompt\-type
--- a/tmux.h
+++ b/tmux.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: tmux.h,v 1.1439 2026/09/10 11:02:18 nicm Exp $ */
+/* $OpenBSD: tmux.h,v 1.1440 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -816,6 +816,7 @@ struct colour_palette {
 #define GRID_LINE_START_OUTPUT 0x40
 #define GRID_LINE_END_OUTPUT 0x80
 #define GRID_LINE_HYPERLINK 0x100
+#define GRID_LINE_END_OUTPUT_STATUS 0x200

 /* All OSC 133 flags. */
 #define GRID_LINE_OSC133_FLAGS \
@@ -823,7 +824,8 @@ struct colour_palette {
 	 GRID_LINE_SECOND_PROMPT| \
 	 GRID_LINE_START_COMMAND| \
 	 GRID_LINE_START_OUTPUT| \
-	 GRID_LINE_END_OUTPUT)
+	 GRID_LINE_END_OUTPUT| \
+	 GRID_LINE_END_OUTPUT_STATUS)

 /* Grid string flags. */
 #define GRID_STRING_WITH_SEQUENCES 0x1
@@ -1150,7 +1152,8 @@ enum pane_lines {
 	PANE_LINES_SIMPLE,
 	PANE_LINES_NUMBER,
 	PANE_LINES_SPACES,
-	PANE_LINES_NONE
+	PANE_LINES_NONE,
+	PANE_LINES_ROUNDED
 };

 /* Pane border indicator option. */
@@ -1796,6 +1799,7 @@ struct tty {
 	size_t		 discarded;

 	struct termios	 tio;
+	struct visible_ranges r;

 	struct grid_cell cell;
 	struct grid_cell last_cell;
@@ -1857,6 +1861,7 @@ struct tty_ctx {
 #define TTY_CTX_INVISIBLE_PANES 0x2
 #define TTY_CTX_WINDOW_BIGGER 0x4
 #define TTY_CTX_SYNC 0x8
+#define TTY_CTX_OVERLAY_SYNC 0x10
 #define TTY_CTX_CELL_INVALIDATE 0x20
 #define TTY_CTX_PANE_OBSCURED 0x40

@@ -2191,6 +2196,16 @@ struct prompt_draw_data {
 	u_int			 prompt_line;
 };

+/* Overlay callbacks */
+typedef struct visible_ranges *(*overlay_check_cb)(struct client *, void *,
+    u_int, u_int, u_int);
+typedef struct screen *(*overlay_mode_cb)(struct client *, void *, u_int *,
+    u_int *);
+typedef void (*overlay_draw_cb)(struct client *, void *);
+typedef int (*overlay_key_cb)(struct client *, void *, struct key_event *);
+typedef void (*overlay_free_cb)(struct client *, void *);
+typedef void (*overlay_resize_cb)(struct client *, void *);
+
 /* Client connection. */
 struct client {
 	const char		*name;
@@ -2276,7 +2291,7 @@ struct client {
 #define CLIENT_SIZECHANGED 0x400000
 #define CLIENT_STATUSOFF 0x800000
 #define CLIENT_REDRAWSTATUSALWAYS 0x1000000
-/* 0x2000000 unused */
+#define CLIENT_REDRAWOVERLAY 0x2000000
 #define CLIENT_CONTROL_NOOUTPUT 0x4000000
 #define CLIENT_DEFAULTSOCKET 0x8000000
 #define CLIENT_STARTSERVER 0x10000000
@@ -2297,6 +2312,7 @@ struct client {
 	 CLIENT_REDRAWSTATUS|		\
 	 CLIENT_REDRAWSTATUSALWAYS|	\
 	 CLIENT_REDRAWBORDERS|		\
+	 CLIENT_REDRAWOVERLAY|		\
 	 CLIENT_REDRAWMENU)
 #define CLIENT_UNATTACHEDFLAGS	\
 	(CLIENT_DEAD|		\
@@ -2342,6 +2358,15 @@ struct client {
 	u_int			 pan_ox;
 	u_int			 pan_oy;

+	overlay_check_cb	 overlay_check;
+	overlay_mode_cb		 overlay_mode;
+	overlay_draw_cb		 overlay_draw;
+	overlay_key_cb		 overlay_key;
+	overlay_free_cb		 overlay_free;
+	overlay_resize_cb	 overlay_resize;
+	void			*overlay_data;
+	struct event		 overlay_timer;
+
 	struct client_files	 files;
 	u_int			 source_file_depth;

@@ -2943,6 +2968,8 @@ void	tty_default_attributes(struct tty *, u_int,
 void	tty_update_mode(struct tty *, int, struct screen *);
 const struct grid_cell *tty_check_codeset(struct tty *,
 	    const struct grid_cell *);
+struct visible_ranges *tty_check_overlay_range(struct tty *, u_int, u_int,
+	    u_int);
 void	tty_sync_start(struct tty *);
 void	tty_sync_end(struct tty *);
 int	tty_open(struct tty *, char **);
@@ -3293,8 +3320,14 @@ int	 server_create_socket(uint64_t, char **);

 /* server-client.c */
 u_int	 server_client_how_many(void);
+void	 server_client_set_overlay(struct client *, u_int, overlay_check_cb,
+	     overlay_mode_cb, overlay_draw_cb, overlay_key_cb,
+	     overlay_free_cb, overlay_resize_cb, void *);
+void	 server_client_clear_overlay(struct client *);
 void	 server_client_ensure_ranges(struct visible_ranges *, u_int);
 int	 server_client_ranges_is_empty(struct visible_ranges *);
+void	 server_client_overlay_range(u_int, u_int, u_int, u_int, u_int, u_int,
+	     u_int, struct visible_ranges *);
 void	 server_client_set_key_table(struct client *, const char *);
 const char *server_client_get_key_table(struct client *);
 int	 server_client_check_nested(struct client *);
@@ -3403,7 +3436,7 @@ void	 recalculate_sizes_now(int);
 /* input.c */
 #define INPUT_BUF_DEFAULT_SIZE 1048576
 struct input_ctx *input_init(struct window_pane *, struct bufferevent *,
-	     struct colour_palette *);
+	     struct colour_palette *, struct client *);
 void	 input_free(struct input_ctx *);
 void	 input_reset(struct input_ctx *, int);
 struct evbuffer *input_pending(struct input_ctx *);
@@ -4158,6 +4191,20 @@ void		 menu_get_cursor(struct menu_data *, u_int *, u_int *);
 void		 menu_resize(struct menu_data *, struct window *);
 int		 menu_key(struct client *, struct menu_data *, struct key_event *);

+/* popup.c */
+#define POPUP_CLOSEEXIT 0x1
+#define POPUP_CLOSEEXITZERO 0x2
+#define POPUP_CLOSEANYKEY 0x4
+typedef void (*popup_close_cb)(int, void *);
+int		 popup_display(int, enum box_lines, struct cmdq_item *, u_int,
+                    u_int, u_int, u_int, struct environ *, const char *, int,
+                    char **, const char *, const char *, struct client *,
+                    struct session *, const char *, const char *,
+                    popup_close_cb, void *);
+int		 popup_present(struct client *);
+int		 popup_modify(struct client *, const char *, const char *,
+		    const char *, enum box_lines, int);
+
 /* style.c */
 int		 style_parse(struct style *,const struct grid_cell *,
 		     const char *);
@@ -4182,7 +4229,7 @@ struct winlink	*spawn_window(struct spawn_context *, char **);
 struct window_pane *spawn_pane(struct spawn_context *, char **);
 typedef void (*spawn_finish_edit_cb)(char *, size_t, void *);
 struct spawn_editor_state *spawn_editor(struct client *, const char *, size_t,
-		     spawn_finish_edit_cb, void *);
+		     const char *, spawn_finish_edit_cb, void *);
 void		 spawn_cancel_editor(struct spawn_editor_state *);
 pid_t		 spawn_get_editor_pid(struct spawn_editor_state *);
 void		 spawn_editor_finish(struct window_pane *);
--- a/tty-draw.c
+++ b/tty-draw.c
@@ -52,7 +52,8 @@ tty_draw_line_clear(struct tty *tty, u_int px, u_int py, u_int nx,
 		return;

 	/* If genuine BCE is available, can try escape sequences. */
-	if (!wrapped &&
+	if (tty->client->overlay_check == NULL &&
+	    !wrapped &&
 	    nx >= 10 &&
 	    !tty_fake_bce(tty, defaults, bg)) {
 		/* Off the end of the line, use EL if available. */
--- a/tty.c
+++ b/tty.c
@@ -66,6 +66,7 @@ static void	tty_redraw_region(struct tty *, const struct tty_ctx *);
 static void	tty_emulate_repeat(struct tty *, enum tty_code_code,
 		    enum tty_code_code, u_int);
 static void	tty_draw_pane(struct tty *, const struct tty_ctx *, u_int);
+static int	tty_check_overlay(struct tty *, u_int, u_int);

 #ifdef ENABLE_SIXEL
 static void	tty_write_one(void (*)(struct tty *, const struct tty_ctx *),
@@ -544,6 +545,8 @@ void
 tty_free(struct tty *tty)
 {
 	tty_close(tty);
+
+	free(tty->r.ranges);
 }

 void
@@ -1198,6 +1201,9 @@ tty_clear_line(struct tty *tty, const struct grid_cell *defaults, u_int py,
    u_int px, u_int nx, u_int bg)
 {
 	struct client		*c = tty->client;
+	struct visible_ranges	*r;
+	struct visible_range	*rr;
+	u_int			 i;

 	log_debug("%s: %s, %u at %u,%u", __func__, c->name, nx, px, py);

@@ -1206,7 +1212,7 @@ tty_clear_line(struct tty *tty, const struct grid_cell *defaults, u_int py,
 		return;

 	/* If genuine BCE is available, can try escape sequences. */
-	if (!tty_fake_bce(tty, defaults, bg)) {
+	if (c->overlay_check == NULL && !tty_fake_bce(tty, defaults, bg)) {
 		/* Off the end of the line, use EL if available. */
 		if (px + nx >= tty->sx && tty_term_has(tty->term, TTYC_EL)) {
 			tty_cursor(tty, px, py);
@@ -1229,9 +1235,18 @@ tty_clear_line(struct tty *tty, const struct grid_cell *defaults, u_int py,
 		}
 	}

-	/* Couldn't use an escape sequence, use spaces. */
-	tty_cursor(tty, px, py);
-	tty_repeat_space(tty, nx);
+	/*
+	 * Couldn't use an escape sequence, use spaces. Clear only the visible
+	 * bit if there is an overlay.
+	 */
+	r = tty_check_overlay_range(tty, px, py, nx);
+	for (i = 0; i < r->used; i++) {
+		rr = &r->ranges[i];
+		if (rr->nx != 0) {
+			tty_cursor(tty, rr->px, py);
+			tty_repeat_space(tty, rr->nx);
+		}
+	}
 }

 /* Clear a line, adjusting to visible part of pane. */
@@ -1240,12 +1255,22 @@ tty_clear_pane_line(struct tty *tty, const struct tty_ctx *ctx, u_int py,
    u_int px, u_int nx, u_int bg)
 {
 	struct client		*c = tty->client;
-	u_int			 l, x, rx, ry;
+	struct visible_ranges	*r;
+	struct visible_range	*ri;
+	u_int			 i, l, x, rx, ry;

 	log_debug("%s: %s, %u at %u,%u", __func__, c->name, nx, px, py);

-	if (tty_clamp_line(tty, ctx, px, py, nx, &l, &x, &rx, &ry))
-		tty_clear_line(tty, &ctx->defaults, ry, x, rx, bg);
+	if (tty_clamp_line(tty, ctx, px, py, nx, &l, &x, &rx, &ry)) {
+		r = tty_check_overlay_range(tty, x, ry, rx);
+		for (i = 0; i < r->used; i++) {
+			ri = &r->ranges[i];
+			if (ri->nx == 0)
+				continue;
+			tty_clear_line(tty, &ctx->defaults, ry, ri->px, ri->nx,
+			    bg);
+		}
+	}
 }

 /* Clamp area position to visible part of pane. */
@@ -1326,8 +1351,11 @@ tty_clear_area(struct tty *tty, const struct tty_ctx *ctx, u_int py,
 	if (nx == 0 || ny == 0)
 		return;

-	/* If BCE is available, can try to clear as a region. */
-	if (!tty_fake_bce(tty, defaults, bg)) {
+	/*
+	 * If there is an overlay or BCE is not available, cannot clear as a
+	 * region.
+	 */
+	if (c->overlay_check == NULL && !tty_fake_bce(tty, defaults, bg)) {
 		/* Use ED if clearing off the bottom of the terminal. */
 		if (px == 0 &&
 		    px + nx >= tty->sx &&
@@ -1399,28 +1427,53 @@ static void
 tty_draw_pane(struct tty *tty, const struct tty_ctx *ctx, u_int py)
 {
 	struct screen		*s = ctx->s;
-	u_int			 nx = ctx->sx, i, x, rx, ry;
+	u_int			 nx = ctx->sx, i, x, rx, ry, j;
+	struct visible_ranges	*r;
+	struct visible_range	*rr;

 	log_debug("%s: %s %u", __func__, tty->client->name, py);

 	if (~ctx->flags & TTY_CTX_WINDOW_BIGGER) {
-		tty_draw_line(tty, s, 0, py, nx, ctx->xoff, ctx->yoff + py,
-		    &ctx->style_ctx);
+		r = tty_check_overlay_range(tty, ctx->xoff, ctx->yoff + py, nx);
+		for (j = 0; j < r->used; j++) {
+			rr = &r->ranges[j];
+			if (rr->nx == 0)
+				continue;
+			tty_draw_line(tty, s, rr->px - ctx->xoff, py, rr->nx,
+			    rr->px, ctx->yoff + py, &ctx->style_ctx);
+		}
 		return;
 	}
-	if (tty_clamp_line(tty, ctx, 0, py, nx, &i, &x, &rx, &ry))
-		tty_draw_line(tty, s, i, py, rx, x, ry, &ctx->style_ctx);
+	if (tty_clamp_line(tty, ctx, 0, py, nx, &i, &x, &rx, &ry)) {
+		r = tty_check_overlay_range(tty, x, ry, rx);
+		for (j = 0; j < r->used; j++) {
+			rr = &r->ranges[j];
+			if (rr->nx == 0)
+				continue;
+			tty_draw_line(tty, s, i + rr->px - x, py, rr->nx,
+			    rr->px, ry, &ctx->style_ctx);
+		}
+	}
 }

 void
 tty_cmd_redrawline(struct tty *tty, const struct tty_ctx *ctx)
 {
-	u_int			 i, x, rx, ry;
+	u_int			 i, x, rx, ry, j;
+	struct visible_ranges	*r;
+	struct visible_range	*rr;

 	if (tty_clamp_line(tty, ctx, ctx->ocx, ctx->ocy, ctx->n,
-	    &i, &x, &rx, &ry))
-		tty_draw_line(tty, ctx->s, ctx->ocx + i, ctx->ocy, rx, x, ry,
-		    &ctx->style_ctx);
+	    &i, &x, &rx, &ry)) {
+		r = tty_check_overlay_range(tty, x, ry, rx);
+		for (j = 0; j < r->used; j++) {
+			rr = &r->ranges[j];
+			if (rr->nx == 0)
+				continue;
+			tty_draw_line(tty, ctx->s, ctx->ocx + i + rr->px - x,
+			    ctx->ocy, rr->nx, rr->px, ry, &ctx->style_ctx);
+		}
+	}
 }

 /* Check if character needs to be mapped for codeset. */
@@ -1457,6 +1510,36 @@ tty_check_codeset(struct tty *tty, const struct grid_cell *gc)
 	return (&new);
 }

+/* Check if a single character is covered by the overlay. */
+static int
+tty_check_overlay(struct tty *tty, u_int px, u_int py)
+{
+	struct visible_ranges	*r;
+
+	/*
+	 * With a single character, if there is anything visible (that is, the
+	 * range is not empty), it must be that character.
+	 */
+	r = tty_check_overlay_range(tty, px, py, 1);
+	return (!server_client_ranges_is_empty(r));
+}
+
+/* Return parts of the input range which are visible. */
+struct visible_ranges *
+tty_check_overlay_range(struct tty *tty, u_int px, u_int py, u_int nx)
+{
+	struct client	*c = tty->client;
+
+	if (c->overlay_check == NULL) {
+		server_client_ensure_ranges(&tty->r, 1);
+		tty->r.ranges[0].px = px;
+		tty->r.ranges[0].nx = nx;
+		tty->r.used = 1;
+		return (&tty->r);
+	}
+	return (c->overlay_check(c, c->overlay_data, px, py, nx));
+}
+
 #ifdef ENABLE_SIXEL
 /* Update context for client. */
 static int
@@ -1600,11 +1683,14 @@ tty_write_one(void (*cmdfn)(struct tty *, const struct tty_ctx *),
 void
 tty_cmd_insertcharacter(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
 	    !tty_full_width(tty, ctx) ||
 	    tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
 	    (!tty_term_has(tty->term, TTYC_ICH) &&
-	    !tty_term_has(tty->term, TTYC_ICH1))) {
+	    !tty_term_has(tty->term, TTYC_ICH1)) ||
+	    c->overlay_check != NULL) {
 		tty_draw_pane(tty, ctx, ctx->ocy);
 		return;
 	}
@@ -1619,11 +1705,14 @@ tty_cmd_insertcharacter(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_deletecharacter(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
 	    !tty_full_width(tty, ctx) ||
 	    tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
 	    (!tty_term_has(tty->term, TTYC_DCH) &&
-	    !tty_term_has(tty->term, TTYC_DCH1))) {
+	    !tty_term_has(tty->term, TTYC_DCH1)) ||
+	    c->overlay_check != NULL) {
 		tty_draw_pane(tty, ctx, ctx->ocy);
 		return;
 	}
@@ -1646,13 +1735,16 @@ tty_cmd_clearcharacter(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_insertline(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
 	    !tty_full_width(tty, ctx) ||
 	    tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
 	    !tty_term_has(tty->term, TTYC_CSR) ||
 	    !tty_term_has(tty->term, TTYC_IL1) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1670,13 +1762,16 @@ tty_cmd_insertline(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_deleteline(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
 	    !tty_full_width(tty, ctx) ||
 	    tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
 	    !tty_term_has(tty->term, TTYC_CSR) ||
 	    !tty_term_has(tty->term, TTYC_DL1) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1720,6 +1815,8 @@ tty_cmd_clearstartofline(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_reverseindex(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if (ctx->ocy != ctx->orupper)
 		return;

@@ -1730,7 +1827,8 @@ tty_cmd_reverseindex(struct tty *tty, const struct tty_ctx *ctx)
 	    (!tty_term_has(tty->term, TTYC_RI) &&
 	    !tty_term_has(tty->term, TTYC_RIN)) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1750,6 +1848,8 @@ tty_cmd_reverseindex(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_linefeed(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
+
 	if (ctx->ocy != ctx->orlower)
 		return;

@@ -1758,7 +1858,8 @@ tty_cmd_linefeed(struct tty *tty, const struct tty_ctx *ctx)
 	    tty_fake_bce(tty, &ctx->defaults, 8) ||
 	    !tty_term_has(tty->term, TTYC_CSR) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1789,6 +1890,7 @@ tty_cmd_linefeed(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_scrollup(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client		*c = tty->client;
 	u_int			 i;

 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
@@ -1796,7 +1898,8 @@ tty_cmd_scrollup(struct tty *tty, const struct tty_ctx *ctx)
 	    tty_fake_bce(tty, &ctx->defaults, 8) ||
 	    !tty_term_has(tty->term, TTYC_CSR) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1826,6 +1929,7 @@ void
 tty_cmd_scrolldown(struct tty *tty, const struct tty_ctx *ctx)
 {
 	u_int		 i;
+	struct client	*c = tty->client;

 	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
 	    (!tty_full_width(tty, ctx) && !tty_use_margin(tty)) ||
@@ -1834,7 +1938,8 @@ tty_cmd_scrolldown(struct tty *tty, const struct tty_ctx *ctx)
 	    (!tty_term_has(tty->term, TTYC_RI) &&
 	    !tty_term_has(tty->term, TTYC_RIN)) ||
 	    ctx->sx == 1 ||
-	    ctx->sy == 1) {
+	    ctx->sy == 1 ||
+	    c->overlay_check != NULL) {
 		tty_redraw_region(tty, ctx);
 		return;
 	}
@@ -1922,9 +2027,11 @@ tty_cmd_clearscreen(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_alignmenttest(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct client	*c = tty->client;
 	u_int		 i, j;

-	if (ctx->flags & TTY_CTX_WINDOW_BIGGER) {
+	if ((ctx->flags & TTY_CTX_WINDOW_BIGGER) ||
+	    c->overlay_check != NULL) {
 		ctx->redraw_cb(ctx);
 		return;
 	}
@@ -1944,9 +2051,29 @@ tty_cmd_alignmenttest(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_cell(struct tty *tty, const struct tty_ctx *ctx)
 {
+	const struct grid_cell	*gcp = ctx->cell;
+	struct screen		*s = ctx->s;
+	struct visible_ranges	*r;
+	u_int			 px, py, i, vis = 0;
+
+	px = ctx->xoff + ctx->ocx - ctx->wox;
+	py = ctx->yoff + ctx->ocy - ctx->woy;
 	if (!tty_is_visible(tty, ctx, ctx->ocx, ctx->ocy, 1, 1))
 		return;

+	if (gcp->data.width == 1 && !tty_check_overlay(tty, px, py))
+		return;
+	if (gcp->data.width > 1) { /* could be partially obscured */
+		r = tty_check_overlay_range(tty, px, py, gcp->data.width);
+		for (i = 0; i < r->used; i++)
+			vis += r->ranges[i].nx;
+		if (vis < gcp->data.width) {
+			tty_draw_line(tty, s, s->cx, s->cy, gcp->data.width,
+			    px, py, &ctx->style_ctx);
+			return;
+		}
+	}
+
 	if (ctx->xoff + ctx->ocx - ctx->wox > tty->sx - 1 &&
 	    ctx->ocy == ctx->orlower &&
 	    tty_full_width(tty, ctx))
@@ -1966,6 +2093,9 @@ tty_cmd_cell(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_cells(struct tty *tty, const struct tty_ctx *ctx)
 {
+	struct visible_ranges	*r;
+	struct visible_range	*ri;
+	u_int			 i, px, py, cx;
 	const char		*cp = ctx->data.data;
 	size_t			 n = ctx->data.size;

@@ -1991,7 +2121,20 @@ tty_cmd_cells(struct tty *tty, const struct tty_ctx *ctx)
 	tty_margin_off(tty);
 	tty_cursor_pane_unless_wrap(tty, ctx, ctx->ocx, ctx->ocy);
 	tty_attributes(tty, ctx->cell, &ctx->style_ctx);
-	tty_putn(tty, cp, n, n);
+
+	/* Get tty position from pane position for overlay check. */
+	px = ctx->xoff + ctx->ocx - ctx->wox;
+	py = ctx->yoff + ctx->ocy - ctx->woy;
+
+	r = tty_check_overlay_range(tty, px, py, n);
+	for (i = 0; i < r->used; i++) {
+		ri = &r->ranges[i];
+		if (ri->nx != 0) {
+			cx = ri->px - ctx->xoff + ctx->wox;
+			tty_cursor_pane_unless_wrap(tty, ctx, cx, ctx->ocy);
+			tty_putn(tty, cp + ri->px - px, ri->nx, ri->nx);
+		}
+	}
 }

 void
@@ -2085,8 +2228,23 @@ tty_cmd_sixelimage(struct tty *tty, const struct tty_ctx *ctx)
 void
 tty_cmd_syncstart(struct tty *tty, const struct tty_ctx *ctx)
 {
-	if (ctx->flags & TTY_CTX_SYNC)
+	struct client	*c = tty->client;
+
+	if ((ctx->flags & TTY_CTX_OVERLAY_SYNC) &&
+	    (ctx->flags & TTY_CTX_SYNC)) {
+		/*
+		 * This is an overlay and a command that moves the cursor so
+		 * start synchronized updates.
+		 */
 		tty_sync_start(tty);
+	} else if (~ctx->flags & TTY_CTX_OVERLAY_SYNC) {
+		/*
+		 * This is a pane. If there is an overlay, always start;
+		 * otherwise, only if requested.
+		 */
+		if ((ctx->flags & TTY_CTX_SYNC) || c->overlay_draw != NULL)
+			tty_sync_start(tty);
+	}
 }

 void
@@ -2105,6 +2263,10 @@ tty_cell(struct tty *tty, const struct grid_cell *gc,
 	if (gc->flags & GRID_FLAG_PADDING)
 		return;

+	/* Check if character is covered by overlay or floating pane. */
+	if (!tty_check_overlay(tty, tty->cx, tty->cy))
+		return;
+
 	/* Check the output codeset and apply attributes. */
 	gcp = tty_check_codeset(tty, gc);
 	tty_attributes(tty, gcp, style_ctx);
--- a/window-border.c
+++ b/window-border.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: window-border.c,v 1.3 2026/07/23 09:38:27 nicm Exp $ */
+/* $OpenBSD: window-border.c,v 1.4 2026/09/11 10:17:16 nicm Exp $ */

 /*
 * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -120,6 +120,10 @@ window_get_border_cell(struct window_pane *wp, enum pane_lines pane_lines,
 		gc->attr &= ~GRID_ATTR_CHARSET;
 		utf8_copy(&gc->data, tty_acs_heavy_borders(cell_type));
 		break;
+	case PANE_LINES_ROUNDED:
+		gc->attr &= ~GRID_ATTR_CHARSET;
+		utf8_copy(&gc->data, tty_acs_rounded_borders(cell_type));
+		break;
 	case PANE_LINES_SIMPLE:
 		gc->attr &= ~GRID_ATTR_CHARSET;
 		utf8_set(&gc->data, SIMPLE_BORDERS[cell_type]);
--- a/window-buffer.c
+++ b/window-buffer.c
@@ -606,7 +606,8 @@ window_buffer_start_edit(struct window_buffer_modedata *data,
 	ed->name = xstrdup(paste_buffer_name(pb));
 	ed->pb = pb;

-	ed->editor = spawn_editor(c, buf, len, window_buffer_edit_close_cb, ed);
+	ed->editor = spawn_editor(c, buf, len, NULL, window_buffer_edit_close_cb,
+	    ed);
 	if (ed->editor == NULL)
 		window_buffer_finish_edit(ed);
 	else {
--- a/window-copy.c
+++ b/window-copy.c
--- a/window-customize.c
+++ b/window-customize.c
@@ -2104,8 +2104,8 @@ window_customize_start_edit(struct window_customize_modedata *data,
 		buf = "\n";
 		len = 1;
 	}
-	ed->editor = spawn_editor(c, buf, len, window_customize_edit_close_cb,
-	    ed);
+	ed->editor = spawn_editor(c, buf, len, NULL,
+	    window_customize_edit_close_cb, ed);
 	free(value);
 	if (ed->editor == NULL)
 		window_customize_finish_edit(ed);
--- a/window.c
+++ b/window.c
@@ -683,6 +683,7 @@ window_pane_update_focus(struct window_pane *wp)
 				    c->session->attached != 0 &&
 				    (c->flags & CLIENT_FOCUSED) &&
 				    c->session->curw->window == wp->window &&
+				    c->overlay_draw == NULL &&
 				    wp->window->menu == NULL) {
 					focused = 1;
 					break;
@@ -1624,7 +1625,7 @@ window_pane_set_event(struct window_pane *wp)
 	    NULL, window_pane_error_callback, wp);
 	if (wp->event == NULL)
 		fatalx("out of memory");
-	wp->ictx = input_init(wp, wp->event, &wp->palette);
+	wp->ictx = input_init(wp, wp->event, &wp->palette, NULL);

 	bufferevent_enable(wp->event, EV_READ|EV_WRITE);
 }
Author	SHA1	Message	Date
Michael Grant	df134f38bd	Merge updated OSC 133 output commands	2026-09-14 06:26:06 +01:00
Michael Grant	a8b05dd7d7	Add pipe-selection copy mode command	2026-09-14 06:25:40 +01:00
Michael Grant	676ad44c96	Merge OSC 133 output commands with fold view	2026-09-14 05:43:59 +01:00
Michael Grant	71865a58d1	Add OSC 133 copy mode output commands	2026-09-14 05:35:34 +01:00
Michael Grant	9837766857	Allow callers to override editor command	2026-09-14 05:35:00 +01:00
tmux update bot	e880cf63e0	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Add rounded borders option for panes like popups.	2026-09-11 17:00:20 +00:00
nicm	325b40e8c4	Add rounded borders option for panes like popups.	2026-09-11 17:00:18 +00:00
tmux update bot	f95363aa83	Merge remote-tracking branch 'refs/remotes/tmux-openbsd/master' * refs/remotes/tmux-openbsd/master: Rather than allowing floating panes to remain outside the window and invisible after resize, move them and resize them so they are fully inside the window. GitHub issue 5582 from Noam Stolero.	2026-09-11 12:58:31 +00:00
nicm	f8fc53b6f8	Rather than allowing floating panes to remain outside the window and invisible after resize, move them and resize them so they are fully inside the window. GitHub issue 5582 from Noam Stolero.	2026-09-11 12:58:29 +00:00
Nicholas Marriott	d215280b00	Add rounded border tests.	2026-09-11 11:17:35 +01:00
Nicholas Marriott	d859a0f410	Test for resizing floating panes, from Noam Stolero.	2026-09-11 09:16:55 +01:00
Michael Grant	6294be4986	Merge branch 'master' into osc133_line_collapsible	2026-09-05 15:15:29 +01:00
Michael Grant	c5a5b99788	Rename output to fold in places for consistency.	2026-08-01 11:59:18 +01:00
Michael Grant	e23219ec04	Add comments during my review including one fix, separator text after D also expandable.	2026-08-01 11:47:25 +01:00
Michael Grant	0f29c47278	Cleanup. Rename things for consistency. Fix indenting.	2026-08-01 08:26:05 +01:00
Michael Grant	7c9fdcb770	Add k=c and a helper function to check for secondary prompt.	2026-07-31 10:39:09 +01:00
Michael Grant	0330d8ac57	Change line-numbers menu to On/Off.	2026-07-29 23:35:11 +01:00
Michael Grant	0a7788b66f	Add Fold View menu item and O key to toggle fold view.	2026-07-29 23:25:36 +01:00
Michael Grant	458d045bd2	With collapsible output active, line-numbers-on now shows each visible line’s original buffer line number, so hidden lines remain counted.	2026-07-29 22:10:19 +01:00
Michael Grant	a81154d6d9	Fix missing ! before commands with no output and non-zero exit status.	2026-07-22 23:40:01 +01:00
Michael Grant	cffc86dae5	Merge branch 'osc133_line_collapsible' of github.com:tmux/tmux into osc133_line_collapsible	2026-07-22 11:39:04 +01:00
Michael Grant	4cfd155ffc	Add copy-mode collapse output regression test.	2026-07-22 11:38:07 +01:00
Michael Grant	670ea5d083	Add regression test for copy-mode-exit-status.	2026-07-22 11:35:59 +01:00
Michael Grant	eaeb234dd4	Remove code to put exit-code on right and go for just simple ! on left of +.	2026-07-22 11:35:59 +01:00
Michael Grant	5948722d5a	Add highlighting to the current line.	2026-07-22 11:35:59 +01:00
Michael Grant	d8ad7cd9c5	Add exit status on right.	2026-07-22 11:35:59 +01:00
Michael Grant	b49cc2d936	Fix stray L on empty commands.	2026-07-22 11:35:59 +01:00
Michael Grant	abb7108e25	Add vertical bar next to expanded lines.	2026-07-22 11:35:59 +01:00
Michael Grant	d080378464	Add collapsible lines.	2026-07-22 11:35:59 +01:00
Michael Grant	473eca949a	Add regression test for copy-mode-exit-status.	2026-07-22 11:35:28 +01:00
Michael Grant	f0eaa5e9d6	Remove code to put exit-code on right and go for just simple ! on left of +.	2026-07-22 11:33:46 +01:00
Michael Grant	f44246c764	Add highlighting to the current line.	2026-07-21 19:19:31 +01:00
Michael Grant	5d4d41da57	Add exit status on right.	2026-07-21 18:48:16 +01:00
Michael Grant	bacbb4d9d8	Fix stray L on empty commands.	2026-07-21 15:03:52 +01:00
Michael Grant	07a3a16ae7	Add vertical bar next to expanded lines.	2026-07-21 07:42:20 +01:00
Michael Grant	f41288ee27	Add collapsible lines.	2026-07-20 16:26:02 +01:00
Nicholas Marriott	457b6cbefd	Put OSC 133 data into grid_line.	2026-07-20 11:24:33 +01:00