Update CHANGES and tests.

whinging about not supporting it, GitHub issue 5626 from Pete Dietl.

.github/workflows/regress.yml

@@ -79,7 +79,7 @@ jobs:
       - name: test
         run: |
           cd regress
-          ${{ matrix.make }}
+          ${{ matrix.make }} -j"$(getconf _NPROCESSORS_ONLN)"
 
       - name: logs
         if: failure()

CHANGES

@@ -9,7 +9,12 @@ CHANGES FROM 3.7c TO 3.8
 
   - modal panes may be created with new-pane -O; a window can have one modal
     pane and it prevents interaction with the other panes while it is active.
-    A modal pane is now used for the editor in buffer mode;
+    -C closes the pane when the mouse is clicked outside it and -K sends all
+    keys, including the prefix key, to the pane. -D closes the modal pane with
+    Escape or C-c. A modal pane is now used for the editor in buffer mode;
+
+  - new-pane -A creates a floating pane which remains above a zoomed pane;
+    modal panes do this by default;
 
   - move-pane and resize-pane can now move and resize floating panes, including
     mouse dragging;
@@ -24,10 +29,18 @@ CHANGES FROM 3.7c TO 3.8
     -k for choose commands kills the pane when the mode exits, which is useful
     for modes in floating panes;
 
-  - pane-border-status has top-floating and bottom-floating, and there are new
+  - command-prompt -P opens a prompt inside a pane rather than on the status
-    default bindings under C-b g for common move and resize operations;
+    line;
 
-  - floating panes are unzoomed before creation to avoid a crash.
+  - pane-border-status has top-floating and bottom-floating, and there are new
+    default bindings under C-b g for common move and resize operations.
+
+* Layout strings now use a JSON subset format which includes floating panes.
+  The old format is still accepted; control mode clients receive old layouts
+  unless they set the new-layouts flag.
+
+* Add remain-on-exit failed-key to keep a pane open after a failed command
+  until a key is pressed.
 
 * Add support for themes and improve default colours:
 
@@ -74,7 +87,7 @@ CHANGES FROM 3.7c TO 3.8
 
   - new hooks to cover areas including client create and destroy, pane
     activity, pane mode and prompt changes, pane movement and resizing, session
-    group changes and window creation, close and zoom;
+    group changes and window creation, close, swap and zoom;
 
   - OSC 133 escape sequences now trigger events: pane-command-started,
     pane-command-finished and pane-shell-prompt.
@@ -87,10 +100,29 @@ CHANGES FROM 3.7c TO 3.8
   while scrolling or while hovered and disappears after pane-scrollbars-timeout
   (Michael Grant).
 
-* Extend the fill-character option so both inside and outside the window can be
+* Add a clear-on-attach server option. When disabled, tmux does not enter the
-  changed.
+  alternate screen on attach and instead scrolls the existing terminal content
+  into the scrollback buffer so it remains accessible (issue 5508).
 
-* Change set-option and set-hooks to use formats and add a -F flag to each.
+* Copy mode can now automatically refresh as pane content changes with the
+  refresh-on, refresh-off and refresh-toggle commands. Automatic refresh is off
+  by default; refresh-now refreshes once and is bound to r. These replace
+  refresh-from-pane (issue 5165).
+
+* Extend the fill-character option so both inside and outside the window can be
+  changed, with a new default for unused areas inside the window.
+
+* Change show-options and show-hooks to use formats and add a -F flag to each.
+
+* Allow individual terminal features to be disabled by adding @ to their names
+  in terminal-features, and add a utf8 feature for terminals which support
+  UTF-8 output.
+
+* Add an appesc terminal feature for mintty's application escape key mode,
+  avoiding unsupported sequences on other terminals (Pete Dietl, issue 5626).
+
+* Preserve existing Ss and Se terminfo capabilities for cursor styles and
+  restoring the default cursor (issue 5476).
 
 * Add a #{A/count:frames} modifier to show a series of frames as an animation
   in the status line (issue 5412 from Fernando Daciuk).
@@ -105,6 +137,12 @@ CHANGES FROM 3.7c TO 3.8
 * Add new-window -E, respawn-pane -E and respawn-window -E as more convenient
   methods to create an empty pane (rather than using '' for the command).
 
+* Add capture-pane -I to include the time each line entered history.
+
+* Various memory leak fixes from Heon Jeong.
+
+* Add a default C-b T binding to change the current pane title.
+
 * Menus now belong to the window, so appear on all clients.
 
 * Dragging over an existing copy mode selection now adjusts it (Michael Grant).
@@ -118,6 +156,13 @@ CHANGES FROM 3.7c TO 3.8
 * Copy mode no longer exits at the bottom while a selection is in progress
   (issue 5349).
 
+* Add copy-mode-current-line-style to set the style of the line containing the
+  cursor in copy mode (issue 5391).
+
+* Copy mode word commands now recognise all Unicode whitespace characters; a
+  space in word-separators matches any Unicode whitespace character (issue
+  5562).
+
 * Add style attributes for dimming colours (dim=) and for hyperlinks (link= and
   nolink) (issues 4842 and 4280 from Moritz Angermann).
 
@@ -128,7 +173,9 @@ CHANGES FROM 3.7c TO 3.8
 
 * Add or improve format variables including client_colours,
   pane_start_command_list, window_manual_width, window_manual_height,
-  pane_last_output_time, pane_modal_flag and window_modal_pane.
+  pane_last_output_time, pane_modal_flag, window_modal_pane, pane_private_modes,
+  pane_output_generation, history_added, history_collected, history_generation,
+  hook_fire_count and hook_fire_time.
 
 * Add additional pane sort orders, and a z sort order for choose-tree so
   floating panes can be sorted by z-index.
@@ -140,15 +187,34 @@ CHANGES FROM 3.7c TO 3.8
 
 * The mouse option now defaults to on.
 
+* The active-pane client flag has been removed.
+
 * Fix send-keys -K so keys are inserted in the correct place in the input
   queue, like keys from key bindings (issue 3476).
 
 * Fix control mode clients hanging on exit if pty data was still queued (Ben
   Maurer, issue 5356), and avoid sending notifications to clients which are
-  already exiting (Ben Maurer, issue 5357).
+  already exiting (Ben Maurer, issue 5357). Queue notifications so they are not
+  sent inside %begin/%end (issue 5458), do not let a stuck client prevent the
+  server from exiting (issue 5444), and reset control mode offsets when a pane
+  is respawned (issue 5498). Bound buffered command replies so a control mode
+  client that stops reading cannot consume unlimited memory (issue 5565), and
+  fix a collision between the output discard and bracketed paste flags (issue
+  5622).
 
 * Fix grouped sessions sometimes being left as unusable command targets while
-  they are being killed (Bryce Miller, issue 5180).
+  they are being killed (Bryce Miller, issue 5180), and prevent reuse of a
+  session with no windows while detaching (Heon Jeong, issue 5620).
+
+* Free wait-for clients when they disconnect and do not run their remaining
+  queued commands (issue 5614).
+
+* Expand formats in run-shell -c like other start-directory flags (reported by
+  Saul Nogueras).
+
+* Fix session alert flag formats to check all windows (issue 5599).
+
+* Do not clear the marked pane when clicking on a pane border.
 
 * Fix choose mode filtering when more than one pane exists (issue 5326), and
   fix an infinite loop in customize mode when a filter does not match.
@@ -159,11 +225,18 @@ CHANGES FROM 3.7c TO 3.8
   status lines, menus, popups, wide characters and floating panes. This
   includes fixes for flicker with alternate screen applications and scrollbars
   (Michael Grant, issue 5351; Noam Stolero, issue 5350; Aung Myo Kyaw, issue
-  5098).
+  5098), and misplaced wrapped lines during partial redraws (Ben Maurer, issue
+  5625).
 
 * Do not crash looking for the next or previous session (issue 5344), or when
   no client is available.
 
+* Fix crashes when destroying a zoomed pane (Romain Francoise, issue 5591),
+  copying from a blank source pane (Kaixuan Li), or opening a mode prompt when
+  the client is offset into the window.
+
+* Avoid an infinite loop when assigning a width to WCHAR_MAX (issue 5602).
+
 CHANGES FROM 3.7b TO 3.7c
 
 * Build with jemalloc on macOS to avoid what appears to be a bug in calloc

Makefile.am

@@ -104,7 +104,6 @@ dist_tmux_SOURCES = \
 	cmd-find-window.c \
 	cmd-find.c \
 	cmd-if-shell.c \
-	cmd-invoke.c \
 	cmd-join-pane.c \
 	cmd-kill-pane.c \
 	cmd-kill-server.c \
@@ -175,6 +174,7 @@ dist_tmux_SOURCES = \
 	input-keys.c \
 	input.c \
 	job.c \
+	json.c \
 	key-bindings.c \
 	key-string.c \
 	layout-custom.c \

arguments.c

@@ -51,6 +51,13 @@ struct args {
 	struct args_value	*values;
 };
 
+/* Prepared command state. */
+struct args_command_state {
+	struct cmd_list		*cmdlist;
+	char			*cmd;
+	struct cmd_parse_input	 pi;
+};
+
 static struct args_entry	*args_find(struct args *, u_char);
 
 static int	args_cmp(struct args_entry *, struct args_entry *);
@@ -82,7 +89,8 @@ args_copy_value(struct args_value *to, struct args_value *from)
 	case ARGS_NONE:
 		break;
 	case ARGS_COMMANDS:
-		to->cmd = cmd_parse_add_ref(from->cmd);
+		to->cmdlist = from->cmdlist;
+		to->cmdlist->references++;
 		break;
 	case ARGS_STRING:
 		to->string = xstrdup(from->string);
@@ -115,7 +123,7 @@ args_value_as_string(struct args_value *value)
 		return ("");
 	case ARGS_COMMANDS:
 		if (value->cached == NULL)
-			value->cached = cmd_parse_print(value->cmd, 0);
+			value->cached = cmd_list_print(value->cmdlist, 0);
 		return (value->cached);
 	case ARGS_STRING:
 		return (value->string);
@@ -359,7 +367,7 @@ args_copy_copy_value(struct args_value *to, struct args_value *from, int argc,
 		to->string = expanded;
 		break;
 	case ARGS_COMMANDS:
-		to->cmd = cmd_parse_add_ref(from->cmd);
+		to->cmdlist = cmd_list_copy(from->cmdlist, argc, argv);
 		break;
 	}
 }
@@ -410,7 +418,7 @@ args_free_value(struct args_value *value)
 		free(value->string);
 		break;
 	case ARGS_COMMANDS:
-		cmd_parse_free(value->cmd);
+		cmd_list_free(value->cmdlist);
 		break;
 	}
 	free(value->cached);
@@ -469,7 +477,7 @@ args_to_vector(struct args *args, int *argc, char ***argv)
 			cmd_append_argv(argc, argv, args->values[i].string);
 			break;
 		case ARGS_COMMANDS:
-			s = cmd_parse_print(args->values[i].cmd, 0);
+			s = cmd_list_print(args->values[i].cmdlist, 0);
 			cmd_append_argv(argc, argv, s);
 			free(s);
 			break;
@@ -524,7 +532,7 @@ args_print_add_value(char **buf, size_t *len, struct args_value *value)
 	case ARGS_NONE:
 		break;
 	case ARGS_COMMANDS:
-		expanded = cmd_parse_print(value->cmd, 0);
+		expanded = cmd_list_print(value->cmdlist, 0);
 		args_print_add(buf, len, "{ %s }", expanded);
 		break;
 	case ARGS_STRING:
@@ -739,53 +747,144 @@ args_string(struct args *args, u_int idx)
 	return (args_value_as_string(&args->values[idx]));
 }
 
-/*
+/* Make a command now. */
- * Convert one command argument into a parse tree. A string value is parsed;
+struct cmd_list *
- * existing commands are referenced.
+args_make_commands_now(struct cmd *self, struct cmdq_item *item, u_int idx,
- */
+    int expand)
-struct cmd_parse_tree *
+{
-args_to_commands(struct cmd *self, struct cmdq_item *item, u_int idx,
+	struct args_command_state	*state;
-    const char *default_command, int expand, char **cause)
+	char				*error;
+	struct cmd_list			*cmdlist;
+
+	state = args_make_commands_prepare(self, item, idx, NULL, 0, expand);
+	cmdlist = args_make_commands(state, 0, NULL, &error);
+	if (cmdlist == NULL) {
+		cmdq_error(item, "%s", error);
+		free(error);
+	}
+	args_make_commands_free(state);
+	return (cmdlist);
+}
+
+/* Save bits to make a command later. */
+struct args_command_state *
+args_make_commands_prepare(struct cmd *self, struct cmdq_item *item, u_int idx,
+    const char *default_command, int wait, int expand)
 {
 	struct args			*args = cmd_get_args(self);
+	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct client			*tc = cmdq_get_target_client(item);
 	struct args_value		*value;
-	struct cmd_parse_input	 pi = { 0 };
+	struct args_command_state	*state;
-	const char		*cmd = NULL, *file;
+	const char			*cmd;
-	char			*expanded;
+	const char			*file;
-	struct cmd_parse_tree	*tree;
 
-	*cause = NULL;
+	state = xcalloc(1, sizeof *state);
 
-	if (idx >= args->count)
+	if (idx < args->count) {
-		cmd = default_command;
-	else {
 		value = &args->values[idx];
-		switch (value->type) {
+		if (value->type == ARGS_COMMANDS) {
-		case ARGS_COMMANDS:
+			state->cmdlist = value->cmdlist;
-			return (cmd_parse_add_ref(value->cmd));
+			state->cmdlist->references++;
-		case ARGS_STRING:
+			return (state);
+		}
 		cmd = value->string;
-			break;
+	} else {
-		case ARGS_NONE:
+		if (default_command == NULL)
-			break;
-		}
-	}
-	if (cmd == NULL)
 			fatalx("argument out of range");
+		cmd = default_command;
+	}
+
 
 	if (expand)
-		expanded = format_single_from_target(item, cmd);
+		state->cmd = format_single_from_target(item, cmd);
 	else
-		expanded = xstrdup(cmd);
+		state->cmd = xstrdup(cmd);
-	log_debug("%s: %s", __func__, expanded);
+	log_debug("%s: %s", __func__, state->cmd);
 
-	cmd_get_source(self, &file, &pi.line);
+	if (wait)
+		state->pi.item = item;
+	cmd_get_source(self, &file, &state->pi.line);
 	if (file != NULL)
-		pi.file = file;
+		state->pi.file = xstrdup(file);
-	pi.flags = cmd_get_parse_flags(self);
+	state->pi.c = tc;
-	tree = cmd_parse_from_string(expanded, &pi, cause);
+	if (state->pi.c != NULL)
-	free(expanded);
+		state->pi.c->references++;
-	return (tree);
+	cmd_find_copy_state(&state->pi.fs, target);
+
+	return (state);
+}
+
+/* Return argument as command. */
+struct cmd_list *
+args_make_commands(struct args_command_state *state, int argc, char **argv,
+    char **error)
+{
+	struct cmd_parse_result	*pr;
+	char			*cmd, *new_cmd;
+	int			 i;
+
+	if (state->cmdlist != NULL) {
+		if (argc == 0) {
+			state->cmdlist->references++;
+			return (state->cmdlist);
+		}
+		return (cmd_list_copy(state->cmdlist, argc, argv));
+	}
+
+	cmd = xstrdup(state->cmd);
+	log_debug("%s: %s", __func__, cmd);
+	cmd_log_argv(argc, argv, __func__);
+	for (i = 0; i < argc; i++) {
+		new_cmd = cmd_template_replace(cmd, argv[i], i + 1);
+		log_debug("%s: %%%u %s: %s", __func__, i + 1, argv[i], new_cmd);
+		free(cmd);
+		cmd = new_cmd;
+	}
+	log_debug("%s: %s", __func__, cmd);
+
+	pr = cmd_parse_from_string(cmd, &state->pi);
+	free(cmd);
+	switch (pr->status) {
+	case CMD_PARSE_ERROR:
+		*error = pr->error;
+		return (NULL);
+	case CMD_PARSE_SUCCESS:
+		return (pr->cmdlist);
+	}
+	fatalx("invalid parse return state");
+}
+
+/* Free commands state. */
+void
+args_make_commands_free(struct args_command_state *state)
+{
+	if (state->cmdlist != NULL)
+		cmd_list_free(state->cmdlist);
+	if (state->pi.c != NULL)
+		server_client_unref(state->pi.c);
+	free((void *)state->pi.file);
+	free(state->cmd);
+	free(state);
+}
+
+/* Get prepared command. */
+char *
+args_make_commands_get_command(struct args_command_state *state)
+{
+	struct cmd	*first;
+	int		 n;
+	char		*s;
+
+	if (state->cmdlist != NULL) {
+		first = cmd_list_first(state->cmdlist);
+		if (first == NULL)
+			return (xstrdup(""));
+		return (xstrdup(cmd_get_entry(first)->name));
+	}
+	n = strcspn(state->cmd, " ,");
+	xasprintf(&s, "%.*s", n, state->cmd);
+	return (s);
 }
 
 /* Get first value in argument. */

cfg.c

@@ -87,21 +87,20 @@ start_cfg(void)
 	if (cfg_quiet)
 		flags = CMD_PARSE_QUIET;
 	for (i = 0; i < cfg_nfiles; i++)
-		load_cfg(cfg_files[i], NULL, NULL, flags, NULL);
+		load_cfg(cfg_files[i], c, NULL, NULL, flags, NULL);
 
 	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }
 
 int
-load_cfg(const char *path, struct cmdq_item *item,
+load_cfg(const char *path, struct client *c, struct cmdq_item *item,
     struct cmd_find_state *current, int flags, struct cmdq_item **new_item)
 {
 	FILE			*f;
 	struct cmd_parse_input	 pi;
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
 	struct cmdq_state	*state;
-	char			*cause = NULL;
 
 	if (new_item != NULL)
 		*new_item = NULL;
@@ -118,16 +117,18 @@ load_cfg(const char *path, struct cmdq_item *item,
 	pi.flags = flags;
 	pi.file = path;
 	pi.line = 1;
-	tree = cmd_parse_from_file(f, &pi, &cause);
+	pi.item = item;
+	pi.c = c;
+
+	pr = cmd_parse_from_file(f, &pi);
 	fclose(f);
-	if (tree == NULL) {
+	if (pr->status == CMD_PARSE_ERROR) {
-		cfg_add_cause("%s", cause);
+		cfg_add_cause("%s", pr->error);
-		free(cause);
+		free(pr->error);
 		return (-1);
 	}
-	cmd_parse_log(__func__, tree);
 	if (flags & CMD_PARSE_PARSEONLY) {
-		cmd_parse_free(tree);
+		cmd_list_free(pr->cmdlist);
 		return (0);
 	}
 
@@ -137,12 +138,12 @@ load_cfg(const char *path, struct cmdq_item *item,
 		state = cmdq_new_state(NULL, NULL, 0);
 	cmdq_add_format(state, "current_file", "%s", pi.file);
 
-	new_item0 = cmd_invoke_get(tree, state, NULL);
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
-	cmd_parse_free(tree);
+	cmd_list_free(pr->cmdlist);
 	cmdq_free_state(state);
 
 	if (new_item != NULL)
@@ -152,14 +153,13 @@ load_cfg(const char *path, struct cmdq_item *item,
 
 int
 load_cfg_from_buffer(const void *buf, size_t len, const char *path,
-    struct cmdq_item *item, struct cmd_find_state *current, int flags,
+    struct client *c, struct cmdq_item *item, struct cmd_find_state *current,
-    struct cmdq_item **new_item)
+    int flags, struct cmdq_item **new_item)
 {
 	struct cmd_parse_input	 pi;
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
 	struct cmdq_state	*state;
-	char			*cause = NULL;
 
 	if (new_item != NULL)
 		*new_item = NULL;
@@ -170,15 +170,17 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 	pi.flags = flags;
 	pi.file = path;
 	pi.line = 1;
-	tree = cmd_parse_from_buffer(buf, len, &pi, &cause);
+	pi.item = item;
-	if (tree == NULL) {
+	pi.c = c;
-		cfg_add_cause("%s", cause);
+
-		free(cause);
+	pr = cmd_parse_from_buffer(buf, len, &pi);
+	if (pr->status == CMD_PARSE_ERROR) {
+		cfg_add_cause("%s", pr->error);
+		free(pr->error);
 		return (-1);
 	}
-	cmd_parse_log(__func__, tree);
 	if (flags & CMD_PARSE_PARSEONLY) {
-		cmd_parse_free(tree);
+		cmd_list_free(pr->cmdlist);
 		return (0);
 	}
 
@@ -188,12 +190,12 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 		state = cmdq_new_state(NULL, NULL, 0);
 	cmdq_add_format(state, "current_file", "%s", pi.file);
 
-	new_item0 = cmd_invoke_get(tree, state, NULL);
+	new_item0 = cmdq_get_command(pr->cmdlist, state);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
-	cmd_parse_free(tree);
+	cmd_list_free(pr->cmdlist);
 	cmdq_free_state(state);
 
 	if (new_item != NULL)

client.c

@@ -69,25 +69,6 @@ static void		 client_dispatch_attached(struct imsg *);
 static void		 client_dispatch_wait(struct imsg *);
 static const char	*client_exit_message(void);
 
-/* Does any command have a flag? */
-static int
-client_command_has_flag(int argc, char **argv, int flag)
-{
-	struct args_value	*values;
-	struct cmd_parse_tree	*tree;
-	int			 found;
-
-	values = args_from_vector(argc, argv);
-	tree = cmd_parse_from_arguments(values, argc, NULL);
-	found = cmd_parse_any_have(tree, flag);
-
-	cmd_parse_free(tree);
-	args_free_values(values, argc);
-	free(values);
-
-	return (found);
-}
-
 /*
  * Get server create lock. If already held then server start is happening in
  * another client, so block until the lock is released and return -2 to
@@ -251,6 +232,7 @@ int
 client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
     int feat)
 {
+	struct cmd_parse_result	*pr;
 	struct msg_command	*data;
 	int			 fd, i;
 	const char		*ttynam, *termname, *cwd;
@@ -260,6 +242,7 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 	size_t			 size;
 	char			**caps = NULL, *cause;
 	u_int			 ncaps = 0;
+	struct args_value	*values;
 
 	/* Set up the initial command. */
 	if (shell_command != NULL) {
@@ -270,8 +253,22 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 		flags |= CLIENT_STARTSERVER;
 	} else {
 		msg = MSG_COMMAND;
-		if (client_command_has_flag(argc, argv, CMD_STARTSERVER))
+
+		/*
+		 * It's annoying parsing the command string twice (in client
+		 * and later in server) but it is necessary to get the start
+		 * server flag.
+		 */
+		values = args_from_vector(argc, argv);
+		pr = cmd_parse_from_arguments(values, argc, NULL);
+		if (pr->status == CMD_PARSE_SUCCESS) {
+			if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
 				flags |= CLIENT_STARTSERVER;
+			cmd_list_free(pr->cmdlist);
+		} else
+			free(pr->error);
+		args_free_values(values, argc);
+		free(values);
 	}
 
 	/* Create client process structure (starts logging). */

cmd-bind-key.c

@@ -56,12 +56,11 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		 *args = cmd_get_args(self);
 	key_code		  key;
-	const char		*tablename, *note = args_get(args, 'N'), *file;
+	const char		 *tablename, *note = args_get(args, 'N');
+	struct cmd_parse_result	 *pr;
 	int			  repeat;
 	struct args_value	 *value;
 	u_int			  count = args_count(args);
-	struct cmd_parse_tree	*cmd;
-	struct cmd_parse_input	 pi;
 
 	key = key_string_lookup_string(args_string(args, 0));
 	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
@@ -84,18 +83,25 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 
 	value = args_value(args, 1);
 	if (count == 2 && value->type == ARGS_COMMANDS) {
-		cmd = cmd_parse_add_ref(value->cmd);
+		key_bindings_add(tablename, key, note, repeat, value->cmdlist);
-		key_bindings_add(tablename, key, note, repeat, cmd);
+		value->cmdlist->references++;
 		return (CMD_RETURN_NORMAL);
 	}
 
-	memset(&pi, 0, sizeof pi);
+	if (count == 2)
-	cmd_get_source(self, &file, &pi.line);
+		pr = cmd_parse_from_string(args_string(args, 1), NULL);
-	if (file != NULL)
+	else {
-		pi.file = file;
+		pr = cmd_parse_from_arguments(args_values(args) + 1, count - 1,
-	pi.flags = cmd_get_parse_flags(self);
+		    NULL);
-
+	}
-	cmd = cmd_parse_from_arguments(args_values(args) + 1, count - 1, &pi);
+	switch (pr->status) {
-	key_bindings_add(tablename, key, note, repeat, cmd);
+	case CMD_PARSE_ERROR:
+		cmdq_error(item, "%s", pr->error);
+		free(pr->error);
+		return (CMD_RETURN_ERROR);
+	case CMD_PARSE_SUCCESS:
+		break;
+	}
+	key_bindings_add(tablename, key, note, repeat, pr->cmdlist);
 	return (CMD_RETURN_NORMAL);
 }

cmd-capture-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-capture-pane.c,v 1.68 2026/07/20 11:16:33 nicm Exp $ */
+/* $OpenBSD: cmd-capture-pane.c,v 1.69 2026/09/08 07:31:59 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@@ -42,8 +42,8 @@ const struct cmd_entry cmd_capture_pane_entry = {
 	.name = "capture-pane",
 	.alias = "capturep",
 
-	.args = { "ab:CeE:FHJLMNpPqRS:Tt:", 0, 0, NULL },
+	.args = { "ab:CeE:FHIJLMNpPqRS:Tt:", 0, 0, NULL },
-	.usage = "[-aCeFHJLMNpPqRT] " CMD_BUFFER_USAGE " [-E end-line] "
+	.usage = "[-aCeFHIJLMNpPqRT] " CMD_BUFFER_USAGE " [-E end-line] "
 		 "[-S start-line] " CMD_TARGET_PANE_USAGE,
 
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -200,7 +200,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 				tmp[0] = line[i];
 				tmp[1] = '\0';
 			} else
-				xsnprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
+				snprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
 			buf = cmd_capture_pane_append(buf, len, tmp,
 			    strlen(tmp));
 		}
@@ -259,7 +259,7 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 	struct grid_cell		*gc = NULL;
 	struct window_mode_entry	*wme;
 	int				 n, join_lines, number_lines, flags = 0;
-	int				 show_flags, hyperlinks;
+	int				 show_flags, show_time, hyperlinks;
 	u_int				*links = NULL, nlinks = 0;
 	u_int				 i, sx, top, bottom, tmp;
 	char				*cause, *buf = NULL, *line, b[64], *cp;
@@ -342,6 +342,7 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 		flags |= GRID_STRING_TRIM_SPACES;
 	number_lines = args_has(args, 'L');
 	show_flags = args_has(args, 'F');
+	show_time = args_has(args, 'I');
 	hyperlinks = args_has(args, 'H');
 	if (hyperlinks)
 		links = xreallocarray(NULL, gd->sx, sizeof *links);
@@ -358,6 +359,7 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 			free(line);
 			continue;
 		}
+		gl = grid_peek_line(gd, i);
 
 		if (number_lines) {
 			if (i >= gd->hsize)
@@ -368,11 +370,16 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 			if (n >= 0)
 				buf = cmd_capture_pane_append(buf, len, b, n);
 		}
+		if (show_time) {
+			n = snprintf(b, sizeof b, "%llu ",
+			    (unsigned long long)grid_line_time(gl));
+			if (n >= 0)
+				buf = cmd_capture_pane_append(buf, len, b, n);
+		}
 		if (show_flags) {
 			cp = b;
 			*cp = '\0';
 
-			gl = grid_peek_line(gd, i);
 			if (gl->flags & GRID_LINE_DEAD)
 				*cp++ = 'D';
 			if (gl->flags & GRID_LINE_HYPERLINK)
@@ -393,7 +400,6 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 		}
 		buf = cmd_capture_pane_append(buf, len, line, linelen);
 
-		gl = grid_peek_line(gd, i);
 		if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))
 			buf[(*len)++] = '\n';
 

cmd-command-prompt.c

@@ -57,7 +57,7 @@ struct cmd_command_prompt_prompt {
 
 struct cmd_command_prompt_cdata {
 	struct cmdq_item		 *item;
-	struct cmd_parse_tree		 *tree;
+	struct args_command_state	 *state;
 
 	int				  flags;
 	enum prompt_type		  prompt_type;
@@ -85,13 +85,13 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 	struct args			*args = cmd_get_args(self);
 	struct client			*tc = cmdq_get_target_client(item);
 	struct cmd_find_state		*target = cmdq_get_target(item);
-	const char			*type, *s, *input, *cmd;
+	const char			*type, *s, *input;
 	struct cmd_command_prompt_cdata *cdata;
 	char				*tmp, *prompts, *prompt, *next_prompt;
-	char				*inputs = NULL, *next_input, *cause = NULL;
+	char				*inputs = NULL, *next_input;
 	struct window_pane		*wp = target->wp;
 	u_int				 count = args_count(args);
-	int				 wait = !args_has(args, 'b'), space = 1, n;
+	int				 wait = !args_has(args, 'b'), space = 1;
 	int				 pane = args_has(args, 'P');
 
 	if (pane) {
@@ -107,22 +107,14 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->item = item;
 	if (pane)
 		cdata->wp = wp;
-	if (count != 0) {
+	cdata->state = args_make_commands_prepare(self, item, 0, "%1", wait,
-		cdata->tree = args_to_commands(self, item, 0, NULL,
+	    args_has(args, 'F'));
-		    args_has(args, 'F'), &cause);
-		if (cdata->tree == NULL) {
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			free(cdata);
-			return (CMD_RETURN_ERROR);
-		}
-	}
 
 	if ((s = args_get(args, 'p')) == NULL) {
 		if (count != 0) {
-			cmd = args_string(args, 0);
+			tmp = args_make_commands_get_command(cdata->state);
-			n = strcspn(cmd, " ,");
+			xasprintf(&prompts, "(%s)", tmp);
-			xasprintf(&prompts, "(%.*s)", n, cmd);
+			free(tmp);
 		} else {
 			prompts = xstrdup(":");
 			space = 0;
@@ -209,11 +201,8 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
 	struct cmd_command_prompt_cdata		 *cdata = data;
 	char					 *error;
 	struct cmdq_item			 *item = cdata->item, *new_item;
-	struct cmdq_state			 *cs = NULL;
+	struct cmd_list				 *cmdlist;
 	struct cmd_command_prompt_prompt	 *prompt;
-	struct cmd_invoke_input			  ci = { 0 };
-	struct cmd_parse_tree			 *tree;
-	struct cmd_parse_input			  pi = { 0 };
 	int					  argc = 0;
 	char					**argv = NULL;
 
@@ -246,35 +235,18 @@ cmd_command_prompt_callback(struct client *c, void *data, const char *s,
 		cdata->argv = cmd_copy_argv(argc, argv);
 	}
 
-	if (item != NULL)
+	cmdlist = args_make_commands(cdata->state, argc, argv, &error);
-		cs = cmdq_get_state(item);
+	if (cmdlist == NULL) {
-
-	if (cdata->tree != NULL) {
-		/* Explicit body: prompt inputs become the template argv. */
-		ci.argc = argc;
-		ci.argv = argv;
-		new_item = cmd_invoke_get(cdata->tree, cs, &ci);
-		if (item == NULL)
-			cmdq_append(c, new_item);
-		else
-			cmdq_insert_after(item, new_item);
-	} else if (argc > 0 && argv[0] != NULL) {
-		/* No body: parse the submitted text as command language. */
-		tree = cmd_parse_from_string(argv[0], &pi, &error);
-		if (tree == NULL) {
-			if (item == NULL)
 		cmdq_append(c, cmdq_get_error(error));
-			else
-				cmdq_error(item, "%s", error);
 		free(error);
-		} else {
+	} else if (item == NULL) {
-			new_item = cmd_invoke_get(tree, cs, NULL);
+		new_item = cmdq_get_command(cmdlist, NULL);
-			cmd_parse_free(tree);
-			if (item == NULL)
 		cmdq_append(c, new_item);
-			else
+		cmd_list_free(cmdlist);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
 		cmdq_insert_after(item, new_item);
-		}
+		cmd_list_free(cmdlist);
 	}
 	cmd_free_argv(argc, argv);
 
@@ -311,6 +283,6 @@ cmd_command_prompt_free(void *data)
 	}
 	free(cdata->prompts);
 	cmd_free_argv(cdata->argc, cdata->argv);
-	cmd_parse_free(cdata->tree);
+	args_make_commands_free(cdata->state);
 	free(cdata);
 }

cmd-confirm-before.c

@@ -51,7 +51,7 @@ const struct cmd_entry cmd_confirm_before_entry = {
 
 struct cmd_confirm_before_data {
 	struct cmdq_item	*item;
-	struct cmd_parse_tree	*tree;
+	struct cmd_list		*cmdlist;
 	u_char			 confirm_key;
 	int			 default_yes;
 };
@@ -70,15 +70,13 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 	struct cmd_confirm_before_data	*cdata;
 	struct client			*tc = cmdq_get_target_client(item);
 	struct cmd_find_state		*target = cmdq_get_target(item);
-	char				*new_prompt, *cause = NULL;
+	char				*new_prompt;
 	const char			*confirm_key, *prompt, *cmd;
-	int				 wait = !args_has(args, 'b'), n;
+	int				 wait = !args_has(args, 'b');
 
 	cdata = xcalloc(1, sizeof *cdata);
-	cdata->tree = args_to_commands(self, item, 0, NULL, 1, &cause);
+	cdata->cmdlist = args_make_commands_now(self, item, 0, 1);
-	if (cdata->tree == NULL) {
+	if (cdata->cmdlist == NULL) {
-		cmdq_error(item, "%s", cause);
-		free(cause);
 		free(cdata);
 		return (CMD_RETURN_ERROR);
 	}
@@ -94,7 +92,8 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 			cdata->confirm_key = confirm_key[0];
 		else {
 			cmdq_error(item, "invalid confirm key");
-			cmd_confirm_before_free(cdata);
+			cmd_list_free(cdata->cmdlist);
+			free(cdata);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -104,9 +103,8 @@ cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
-		cmd = args_string(args, 0);
+		cmd = cmd_get_entry(cmd_list_first(cdata->cmdlist))->name;
-		n = strcspn(cmd, " ,");
+		xasprintf(&new_prompt, "Confirm '%s'? (%c/n) ", cmd,
-		xasprintf(&new_prompt, "Confirm '%.*s'? (%c/n) ", n, cmd,
 		    cdata->confirm_key);
 	}
 
@@ -126,7 +124,6 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
 {
 	struct cmd_confirm_before_data	*cdata = data;
 	struct cmdq_item		*item = cdata->item, *new_item;
-	struct cmdq_state		*cs;
 	int				 retcode = 1;
 
 	if (c->flags & CLIENT_DEAD)
@@ -139,11 +136,11 @@ cmd_confirm_before_callback(struct client *c, void *data, const char *s,
 	retcode = 0;
 
 	if (item == NULL) {
-		new_item = cmd_invoke_get(cdata->tree, NULL, NULL);
+		new_item = cmdq_get_command(cdata->cmdlist, NULL);
 		cmdq_append(c, new_item);
 	} else {
-		cs = cmdq_get_state(item);
+		new_item = cmdq_get_command(cdata->cmdlist,
-		new_item = cmd_invoke_get(cdata->tree, cs, NULL);
+		    cmdq_get_state(item));
 		cmdq_insert_after(item, new_item);
 	}
 
@@ -162,6 +159,6 @@ cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;
 
-	cmd_parse_free(cdata->tree);
+	cmd_list_free(cdata->cmdlist);
 	free(cdata);
 }

cmd-display-message.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-display-message.c,v 1.65 2026/02/23 08:46:57 nicm Exp $ */
+/* $OpenBSD: cmd-display-message.c,v 1.66 2026/09/08 08:33:10 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -39,8 +39,8 @@ const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
 	.alias = "display",
 
-	.args = { "aCc:d:lINpt:F:v", 0, 1, NULL },
+	.args = { "aCc:d:jlINpt:F:v", 0, 1, NULL },
-	.usage = "[-aCIlNpv] [-c target-client] [-d delay] [-F format] "
+	.usage = "[-aCIjlNpv] [-c target-client] [-d delay] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",
 
 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
@@ -67,14 +67,15 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	struct winlink		*wl = target->wl;
 	struct window_pane	*wp = target->wp;
 	const char		*template;
-	char			*msg, *cause;
+	char			*msg, *cause = NULL;
 	int			 delay = -1, flags, Nflag = args_has(args, 'N');
 	int			 Cflag = args_has(args, 'C');
 	struct format_tree	*ft;
 	u_int			 count = args_count(args);
 	struct evbuffer		*evb;
+	struct json_node	*jn;
 
-	if (args_has(args, 'I')) {
+	if (args_has(args, 'I') && !args_has(args, 'j')) {
 		if (wp == NULL)
 			return (CMD_RETURN_NORMAL);
 		switch (window_pane_start_input(wp, item, &cause)) {
@@ -107,7 +108,9 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 		template = args_string(args, 0);
 	else
 		template = args_get(args, 'F');
-	if (template == NULL)
+	if (args_has(args, 'j') && template == NULL)
+		template = "";
+	else if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;
 
 	/*
@@ -129,7 +132,7 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, flags);
 	format_defaults(ft, c, s, wl, wp);
 
-	if (args_has(args, 'a')) {
+	if (args_has(args, 'a') && !args_has(args, 'j')) {
 		format_each(ft, cmd_display_message_each, item);
 		format_free(ft);
 		return (CMD_RETURN_NORMAL);
@@ -139,6 +142,19 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 		msg = xstrdup(template);
 	else
 		msg = format_expand_time(ft, template);
+	if (args_has(args, 'j')) {
+		jn = json_parse(msg, &cause);
+		if (jn == NULL) {
+			cmdq_error(item, "%s", cause);
+			free(cause);
+			free(msg);
+			format_free(ft);
+			return (CMD_RETURN_ERROR);
+		}
+		free(msg);
+		msg = json_to_string(jn);
+		json_destroy_node(jn);
+	}
 
 	if (cmdq_get_client(item) == NULL)
 		cmdq_error(item, "%s", msg);

cmd-find.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-find.c,v 1.87 2026/07/17 12:42:51 nicm Exp $ */
+/* $OpenBSD: cmd-find.c,v 1.88 2026/09/07 12:05:12 nicm Exp $ */
 
 /*
  * Copyright (c) 2015 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -388,9 +388,11 @@ cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)
 
 	/* Try as an offset. */
 	if (!exact && (window[0] == '+' || window[0] == '-')) {
-		if (window[1] != '\0')
+		if (window[1] != '\0') {
-			n = strtonum(window + 1, 1, INT_MAX, NULL);
+			n = strtonum(window + 1, 1, INT_MAX, &errstr);
-		else
+			if (errstr != NULL)
+				return (-1);
+		} else
 			n = 1;
 		s = fs->s;
 		if (fs->flags & CMD_FIND_WINDOW_INDEX) {
@@ -626,9 +628,11 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 
 	/* Try as an offset. */
 	if (pane[0] == '+' || pane[0] == '-') {
-		if (pane[1] != '\0')
+		if (pane[1] != '\0') {
-			n = strtonum(pane + 1, 1, INT_MAX, NULL);
+			n = strtonum(pane + 1, 1, INT_MAX, &errstr);
-		else
+			if (errstr != NULL)
+				return (-1);
+		} else
 			n = 1;
 		wp = fs->w->active;
 		if (pane[0] == '+')

cmd-if-shell.c

@@ -53,9 +53,8 @@ const struct cmd_entry cmd_if_shell_entry = {
 };
 
 struct cmd_if_shell_data {
-	struct cmd_parse_tree	*cmd_if;
+	struct args_command_state	*cmd_if;
-	struct cmd_parse_tree	*cmd_else;
+	struct args_command_state	*cmd_else;
-
 
 	struct client			*client;
 	struct cmdq_item		*item;
@@ -77,58 +76,46 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 	struct cmd_find_state		*target = cmdq_get_target(item);
 	struct cmd_if_shell_data	*cdata;
 	struct cmdq_item		*new_item;
-	struct cmd_parse_tree		*tree;
+	char				*shellcmd;
-	char				*shellcmd, *cause = NULL;
 	struct client			*tc = cmdq_get_target_client(item);
 	struct session			*s = target->s;
-	u_int				 count = args_count(args), idx;
+	struct cmd_list			*cmdlist;
+	u_int				 count = args_count(args);
 	int				 wait = !args_has(args, 'b');
 
 	shellcmd = format_single_from_target(item, args_string(args, 0));
 	if (args_has(args, 'F')) {
 		if (*shellcmd != '0' && *shellcmd != '\0')
-			idx = 1;
+			cmdlist = args_make_commands_now(self, item, 1, 0);
 		else if (count == 3)
-			idx = 2;
+			cmdlist = args_make_commands_now(self, item, 2, 0);
 		else {
 			free(shellcmd);
 			return (CMD_RETURN_NORMAL);
 		}
 		free(shellcmd);
-
+		if (cmdlist == NULL)
-		tree = args_to_commands(self, item, idx, NULL, 0, &cause);
-		if (tree == NULL) {
-			cmdq_error(item, "%s", cause);
-			free(cause);
 			return (CMD_RETURN_ERROR);
-		}
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
-		new_item = cmd_invoke_get(tree, cmdq_get_state(item), NULL);
-		cmd_parse_free(tree);
 		cmdq_insert_after(item, new_item);
+		cmd_list_free(cmdlist);
 		return (CMD_RETURN_NORMAL);
 	}
 
 	cdata = xcalloc(1, sizeof *cdata);
-	cdata->cmd_if = args_to_commands(self, item, 1, NULL, 0, &cause);
+
-	if (cdata->cmd_if == NULL) {
+	cdata->cmd_if = args_make_commands_prepare(self, item, 1, NULL, wait,
-		cmdq_error(item, "%s", cause);
+	    0);
-		goto fail;
-	}
 	if (count == 3) {
-		cdata->cmd_else = args_to_commands(self, item, 2, NULL, 0,
+		cdata->cmd_else = args_make_commands_prepare(self, item, 2,
-		    &cause);
+		    NULL, wait, 0);
-		if (cdata->cmd_else == NULL) {
-			cmdq_error(item, "%s", cause);
-			goto fail;
-		}
 	}
 
-	if (!wait)
+	if (wait) {
-		cdata->client = tc;
-	else {
 		cdata->client = cmdq_get_client(item);
 		cdata->item = item;
-	}
+	} else
+		cdata->client = tc;
 	if (cdata->client != NULL)
 		cdata->client->references++;
 
@@ -137,19 +124,15 @@ cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1,
 	    -1) == NULL) {
 		cmdq_error(item, "failed to run command: %s", shellcmd);
-		goto fail;
+		free(shellcmd);
+		cmd_if_shell_free(cdata);
+		return (CMD_RETURN_ERROR);
 	}
 	free(shellcmd);
 
 	if (!wait)
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
-
-fail:
-	free(cause);
-	free(shellcmd);
-	cmd_if_shell_free(cdata);
-	return (CMD_RETURN_ERROR);
 }
 
 static void
@@ -158,23 +141,35 @@ cmd_if_shell_callback(struct job *job)
 	struct cmd_if_shell_data	*cdata = job_get_data(job);
 	struct client			*c = cdata->client;
 	struct cmdq_item		*item = cdata->item, *new_item;
-	struct cmd_parse_tree		*tree;
+	struct args_command_state	*state;
+	struct cmd_list			*cmdlist;
+	char				*error;
 	int				 status;
 
 	status = job_get_status(job);
 	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
-		tree = cdata->cmd_else;
+		state = cdata->cmd_else;
 	else
-		tree = cdata->cmd_if;
+		state = cdata->cmd_if;
-	if (tree == NULL)
+	if (state == NULL)
 		goto out;
 
-	if (item == NULL) {
+	cmdlist = args_make_commands(state, 0, NULL, &error);
-		new_item = cmd_invoke_get(tree, NULL, NULL);
+	if (cmdlist == NULL) {
+		if (cdata->item == NULL) {
+			*error = toupper((u_char)*error);
+			status_message_set(c, -1, 1, 0, 0, "%s", error);
+		} else
+			cmdq_error(cdata->item, "%s", error);
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
 		cmdq_append(c, new_item);
+		cmd_list_free(cmdlist);
 	} else {
-		new_item = cmd_invoke_get(tree, cmdq_get_state(item), NULL);
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
 		cmdq_insert_after(item, new_item);
+		cmd_list_free(cmdlist);
 	}
 
 out:
@@ -191,8 +186,8 @@ cmd_if_shell_free(void *data)
 		server_client_unref(cdata->client);
 
 	if (cdata->cmd_else != NULL)
-		cmd_parse_free(cdata->cmd_else);
+		args_make_commands_free(cdata->cmd_else);
-	if (cdata->cmd_if != NULL)
+	args_make_commands_free(cdata->cmd_if);
-		cmd_parse_free(cdata->cmd_if);
+
 	free(cdata);
 }

cmd-invoke.c

@@ -1,594 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2026 Nicholas Marriott <nicm@users.sourceforge.net>
- *
- * 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 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 <pwd.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-#include "tmux-parser.h"
-
-/* One frame in the parse tree stack. */
-struct cmd_invoke_frame {
-	struct cmd_parse_tree	*tree;
-	struct cmd_parse_node	*node;
-	struct cmd_parse_node	*next;
-	struct cmd_parse_node	*end;
-};
-
-/* Shared state for a parsed command tree invocation. */
-struct cmd_invoke_state {
-	u_int			 references;
-	struct cmd_parse_tree	*tree;
-	struct cmd_parse_tree	*current_tree;
-
-	struct cmd_invoke_frame	*stack;
-	u_int			 nstack;
-
-	enum cmd_retval		 last;
-	int			 have_last;
-
-	int			 argc;
-	char		       **argv;
-};
-
-static void	cmd_invoke_push(struct cmd_invoke_state *,
-		    struct cmd_parse_tree *, struct cmd_parse_node *,
-		    struct cmd_parse_node *, struct cmd_parse_node *);
-static struct cmd_parse_tree *cmd_invoke_tree(struct cmd_invoke_state *);
-static struct cmd_parse_node *cmd_invoke_next(struct cmd_invoke_state *);
-static void	cmd_invoke_skip_sequence(struct cmd_invoke_state *);
-static int	cmd_invoke_expand_string(struct cmdq_item *,
-		    struct cmd_invoke_state *, struct cmd_parse_node *,
-		    char **);
-static int	cmd_invoke_assignment(struct cmdq_item *,
-		    struct cmd_invoke_state *, struct cmd_parse_node *);
-static int	cmd_invoke_if(struct cmdq_item *, struct cmd_invoke_state *,
-		    struct cmd_parse_node *);
-static struct cmd *cmd_invoke_build_command(struct cmdq_item *,
-		    struct cmd_invoke_state *, struct cmd_parse_node *);
-static int	cmd_invoke_read_only(struct cmdq_item *, struct cmd *);
-
-/* Push a node's child range onto the traversal stack. */
-static void
-cmd_invoke_push(struct cmd_invoke_state *is, struct cmd_parse_tree *tree,
-    struct cmd_parse_node *node, struct cmd_parse_node *first,
-    struct cmd_parse_node *end)
-{
-	u_int	n = is->nstack + 1;
-
-	is->stack = xreallocarray(is->stack, n, sizeof *is->stack);
-	is->stack[is->nstack].tree = cmd_parse_add_ref(tree);
-	is->stack[is->nstack].node = node;
-	is->stack[is->nstack].next = first;
-	is->stack[is->nstack].end = end;
-	is->nstack = n;
-}
-
-static struct cmd_parse_tree *
-cmd_invoke_tree(struct cmd_invoke_state *is)
-{
-	if (is->current_tree != NULL)
-		return (is->current_tree);
-	return (is->tree);
-}
-
-/* Return the next node to execute from the traversal stack. */
-static struct cmd_parse_node *
-cmd_invoke_next(struct cmd_invoke_state *is)
-{
-	struct cmd_invoke_frame	*frame;
-	struct cmd_parse_node	*node;
-
-	for (;;) {
-		if (is->nstack == 0)
-			return (NULL);
-		frame = &is->stack[is->nstack - 1];
-		if (frame->next != NULL && frame->next != frame->end)
-			break;
-		cmd_parse_free(frame->tree);
-		is->nstack--;
-	}
-
-	node = frame->next;
-	frame->next = cmd_parse_node_next(node);
-	is->current_tree = frame->tree;
-	return (node);
-}
-
-/*
- * Skip the rest of the active sequence after a command failure. Failure scope
- * is the active CMD_PARSE_SEQUENCE. Discard nested frames and advance only as
- * far as the end of that sequence.
- */
-static void
-cmd_invoke_skip_sequence(struct cmd_invoke_state *is)
-{
-	enum cmd_parse_node_type	type;
-	u_int				i;
-
-	for (i = is->nstack; i > 0; i--) {
-		type = cmd_parse_node_type(is->stack[i - 1].node);
-		if (type == CMD_PARSE_SEQUENCE) {
-			is->stack[i - 1].next = is->stack[i - 1].end;
-			while (is->nstack > i)
-				cmd_parse_free(is->stack[--is->nstack].tree);
-			is->nstack = i;
-			break;
-		}
-	}
-	is->have_last = 0;
-}
-
-/* Append a string to a dynamically allocated buffer. */
-static void
-cmd_invoke_append(char **buf, size_t *len, const char *s)
-{
-	size_t	slen;
-
-	if (s != NULL) {
-		slen = strlen(s);
-		*buf = xrealloc(*buf, *len + slen + 1);
-		memcpy(*buf + *len, s, slen + 1);
-		*len += slen;
-	}
-}
-
-/* Look up an environment variable. */
-static const char *
-cmd_invoke_getenv(struct cmdq_item *item, const char *name)
-{
-	struct client		*c = cmdq_get_client(item);
-	struct environ_entry	*envent;
-
-	if (c != NULL && c->environ != NULL) {
-		envent = environ_find(c->environ, name);
-		if (envent != NULL && envent->value != NULL)
-			return (envent->value);
-	}
-	envent = environ_find(global_environ, name);
-	if (envent != NULL && envent->value != NULL)
-		return (envent->value);
-	return ("");
-}
-
-/* Resolve a tilde expansion to a home directory. */
-static const char *
-cmd_invoke_tilde(const char *name)
-{
-	struct passwd	*pw;
-
-	if (name == NULL || *name == '\0')
-		return (find_home());
-	if ((pw = getpwnam(name)) == NULL)
-		return ("");
-	return (pw->pw_dir);
-}
-
-/* Expand a parsed string node into an argv string. */
-static int
-cmd_invoke_expand_string(struct cmdq_item *item, struct cmd_invoke_state *is,
-    struct cmd_parse_node *node, char **out)
-{
-	struct cmd_parse_node	*child;
-	const char		*s, *value;
-	char			*buf = NULL, *new;
-	size_t			 len = 0;
-	int			 i;
-
-	child = cmd_parse_node_first_child(node);
-	while (child != NULL) {
-		value = cmd_parse_node_value(child);
-		switch (cmd_parse_node_type(child)) {
-		case CMD_PARSE_TEXT:
-			s = value;
-			break;
-		case CMD_PARSE_ENVIRONMENT:
-			s = cmd_invoke_getenv(item, value);
-			break;
-		case CMD_PARSE_TILDE:
-			s = cmd_invoke_tilde(value);
-			break;
-		default:
-			fatalx("unexpected node type in string");
-		}
-		cmd_invoke_append(&buf, &len, s);
-		child = cmd_parse_node_next(child);
-	}
-	if (buf == NULL)
-		buf = xstrdup("");
-	for (i = 0; i < is->argc; i++) {
-		new = cmd_template_replace(buf, is->argv[i], i + 1);
-		free(buf);
-		buf = new;
-	}
-	*out = buf;
-	return (0);
-}
-
-/* Execute an assignment node by updating the environment. */
-static int
-cmd_invoke_assignment(struct cmdq_item *item, struct cmd_invoke_state *is,
-    struct cmd_parse_node *node)
-{
-	struct cmd_parse_node	*value;
-	const char		*name;
-	char			*expanded;
-	int			 flags = 0;
-
-	value = cmd_parse_node_first_child(node);
-	if (value == NULL)
-		return (-1);
-	if (cmd_invoke_expand_string(item, is, value, &expanded) != 0)
-		return (-1);
-
-	name = cmd_parse_node_value(node);
-	if (cmd_parse_node_type(node) == CMD_PARSE_HIDDEN_ASSIGN)
-		flags |= ENVIRON_HIDDEN;
-	environ_set(global_environ, name, flags, "%s", expanded);
-	free(expanded);
-	return (0);
-}
-
-/* Expand and evaluate a conditional expression. */
-static int
-cmd_invoke_is_true(struct cmdq_item *item,
-    struct cmd_invoke_state *is, struct cmd_parse_node *node, int *result)
-{
-	struct format_tree	*ft;
-	char			*s, *expanded;
-
-	if (cmd_invoke_expand_string(item, is, node, &s) != 0)
-		return (-1);
-	ft = format_create_from_target(item);
-
-	expanded = format_expand(ft, s);
-	*result = format_true(expanded);
-	free(expanded);
-
-	format_free(ft);
-	free(s);
-	return (0);
-}
-
-/* Skip else branches. */
-static struct cmd_parse_node *
-cmd_invoke_if_branch_end(struct cmd_parse_node *first)
-{
-	struct cmd_parse_node	*node;
-
-	for (node = first; node != NULL; node = cmd_parse_node_next(node)) {
-		switch (cmd_parse_node_type(node)) {
-		case CMD_PARSE_ELIF:
-		case CMD_PARSE_ELSE:
-			return (node);
-		default:
-			break;
-		}
-	}
-	return (NULL);
-}
-
-/* Select and queue the branch for a conditional node. */
-static int
-cmd_invoke_if(struct cmdq_item *item, struct cmd_invoke_state *is,
-    struct cmd_parse_node *node)
-{
-	struct cmd_parse_tree	*tree = cmd_invoke_tree(is);
-	struct cmd_parse_node	*child, *first, *next;
-	int			 r;
-
-	next = cmd_parse_node_first_child(node);
-	if (next == NULL)
-		return (0);
-	first = cmd_parse_node_next(next);
-	if (cmd_invoke_is_true(item, is, next, &r) != 0)
-		return (-1);
-	if (r) {
-		next = cmd_invoke_if_branch_end(first);
-		cmd_invoke_push(is, tree, node, first, next);
-		return (0);
-	}
-
-	for (child = first; child != NULL; child = cmd_parse_node_next(child)) {
-		switch (cmd_parse_node_type(child)) {
-		case CMD_PARSE_ELIF:
-			next = cmd_parse_node_first_child(child);
-			if (next == NULL)
-				break;
-			if (cmd_invoke_is_true(item, is, next, &r) != 0)
-				return (-1);
-			if (r) {
-				next = cmd_parse_node_next(next);
-				cmd_invoke_push(is, tree, child, next, NULL);
-				return (0);
-			}
-			break;
-		case CMD_PARSE_ELSE:
-			next = cmd_parse_node_first_child(child);
-			cmd_invoke_push(is, tree, child, next, NULL);
-			return (0);
-		default:
-			break;
-		}
-	}
-	return (0);
-}
-
-/* Report an error from an invoke item. */
-static void
-cmd_invoke_error(struct cmdq_item *item, struct cmd_invoke_state *is,
-    struct cmd_parse_node *node, const char *cause)
-{
-	struct client		*c = cmdq_get_client(item);
-	struct cmd_parse_tree	*tree = cmd_invoke_tree(is);
-	const char		*file = cmd_parse_file(tree);
-	u_int			 line = cmd_parse_node_line(node);
-
-	if (c != NULL && (~c->flags & CLIENT_CONTROL || file == NULL)) {
-		cmdq_error(item, "%s", cause);
-		return;
-	}
-
-	if (file != NULL)
-		cfg_add_cause("%s:%u: %s", file, line, cause);
-	else
-		cfg_add_cause("%s", cause);
-}
-
-/* Build one command from a parsed command node. */
-static struct cmd *
-cmd_invoke_build_command(struct cmdq_item *item, struct cmd_invoke_state *is,
-    struct cmd_parse_node *node)
-{
-	struct cmd_parse_tree	*tree = cmd_invoke_tree(is);
-	struct cmd_parse_node	*child;
-	struct args_value	*values = NULL;
-	struct cmd		*cmd;
-	const char		*file = cmd_parse_file(tree);
-	u_int			 line = cmd_parse_node_line(node);
-	int			 flags = cmd_parse_flags(tree);
-	char			*cause = NULL;
-	u_int			 count = 0;
-
-	child = cmd_parse_node_first_child(node);
-	while (child != NULL) {
-		values = xreallocarray(values, count + 1, sizeof *values);
-		memset(&values[count], 0, sizeof values[count]);
-		switch (cmd_parse_node_type(child)) {
-		case CMD_PARSE_STRING:
-			values[count].type = ARGS_STRING;
-			if (cmd_invoke_expand_string(item, is, child,
-			    &values[count].string) != 0)
-				goto fail;
-			break;
-		case CMD_PARSE_COMMANDS:
-			values[count].type = ARGS_COMMANDS;
-			values[count].cmd = cmd_parse_from_node(tree, child);
-			break;
-		default:
-			fatalx("unexpected node type in command");
-		}
-		count++;
-		child = cmd_parse_node_next(child);
-	}
-
-	cmd = cmd_parse(values, count, file, line, flags, &cause);
-	if (cmd == NULL) {
-		cmd_invoke_error(item, is, node, cause);
-		free(cause);
-		goto fail;
-	}
-	args_free_values(values, count);
-	free(values);
-	return (cmd);
-
-fail:
-	args_free_values(values, count);
-	free(values);
-	return (NULL);
-}
-
-static int
-cmd_invoke_read_only(struct cmdq_item *item, struct cmd *cmd)
-{
-	struct client		*c = cmdq_get_client(item);
-	const struct cmd_entry	*entry = cmd_get_entry(cmd);
-
-	if (c == NULL || (~c->flags & CLIENT_READONLY))
-		return (0);
-	if (entry->flags & CMD_READONLY)
-		return (0);
-	cmdq_error(item, "client is read-only");
-	return (-1);
-}
-
-/* Create the first invoke queue item for a parsed tree. */
-struct cmdq_item *
-cmd_invoke_get(struct cmd_parse_tree *tree, struct cmdq_state *state,
-    const struct cmd_invoke_input *input)
-{
-	struct cmd_invoke_state	*is;
-	struct cmd_parse_node	*root = cmd_parse_root(tree), *first;
-	struct cmdq_item	*item;
-	struct cmd_invoke_input	 new_input = { 0 };
-	int			 i;
-
-	if (input == NULL)
-		input = &new_input;
-
-	is = xcalloc(1, sizeof *is);
-	is->references = 1;
-	is->tree = cmd_parse_add_ref(tree);
-
-	is->argc = input->argc;
-	if (input->argc != 0) {
-		is->argv = xreallocarray(NULL, input->argc, sizeof *is->argv);
-		for (i = 0; i < input->argc; i++)
-			is->argv[i] = xstrdup(input->argv[i]);
-	}
-
-	first = cmd_parse_node_first_child(root);
-	cmd_invoke_push(is, tree, root, first, NULL);
-
-	item = cmdq_get_invoke(is, state);
-	cmd_invoke_state_free(is);
-	return (item);
-}
-
-/* Add a reference to shared invoke state. */
-struct cmd_invoke_state *
-cmd_invoke_state_add_ref(struct cmd_invoke_state *is)
-{
-	is->references++;
-	return (is);
-}
-
-/* Release a reference to shared invoke state. */
-void
-cmd_invoke_state_free(struct cmd_invoke_state *is)
-{
-	int	i;
-	u_int	j;
-
-	if (is == NULL)
-		return;
-	if (--is->references != 0)
-		return;
-
-	for (i = 0; i < is->argc; i++)
-		free(is->argv[i]);
-	free(is->argv);
-	for (j = 0; j < is->nstack; j++)
-		cmd_parse_free(is->stack[j].tree);
-
-	cmd_parse_free(is->tree);
-	free(is->stack);
-	free(is);
-}
-
-/* Record the result from the last command item. */
-void
-cmd_invoke_result(struct cmd_invoke_state *is, enum cmd_retval retval)
-{
-	is->last = retval;
-	is->have_last = 1;
-}
-
-/* Fire an invoke item and queue the next command plus continuation. */
-enum cmd_retval
-cmd_invoke_fire(struct cmdq_item *item, struct cmd_invoke_state *is)
-{
-	struct cmd_parse_node	*node, *first;
-	struct cmd_parse_tree	*tree, *alias;
-	struct cmdq_item	*new_item, *next;
-	struct cmdq_state	*state;
-	struct client		*c;
-	struct cmd		*cmd;
-	const char		*file;
-	char			*cause;
-	int			 r;
-
-	if (is->have_last && is->last == CMD_RETURN_ERROR)
-		cmd_invoke_skip_sequence(is);
-	else
-		is->have_last = 0;
-
-	for (;;) {
-		node = cmd_invoke_next(is);
-		if (node == NULL)
-			return (CMD_RETURN_NORMAL);
-		cmd_parse_log_node(__func__, node);
-
-		tree = cmd_invoke_tree(is);
-		switch (cmd_parse_node_type(node)) {
-		case CMD_PARSE_ROOT:
-		case CMD_PARSE_SEQUENCE:
-			first = cmd_parse_node_first_child(node);
-			cmd_invoke_push(is, tree, node, first, NULL);
-			break;
-		case CMD_PARSE_ASSIGN:
-		case CMD_PARSE_HIDDEN_ASSIGN:
-			if (cmd_invoke_assignment(item, is, node) == 0)
-				break;
-			cmd_invoke_error(item, is, node, "bad assignment");
-			cmd_invoke_skip_sequence(is);
-			break;
-		case CMD_PARSE_IF:
-			if (cmd_invoke_if(item, is, node) == 0)
-				break;
-			cmd_invoke_error(item, is, node, "bad condition");
-			cmd_invoke_skip_sequence(is);
-			break;
-		case CMD_PARSE_ELIF:
-		case CMD_PARSE_ELSE:
-			break;
-		case CMD_PARSE_COMMAND:
-			r = cmd_parse_expand_alias(tree, node, &alias, &cause);
-			if (r == 1) {
-				node = cmd_parse_root(alias);
-				first = cmd_parse_node_first_child(node);
-				cmd_invoke_push(is, alias, node, first, NULL);
-				cmd_parse_free(alias);
-				break;
-			}
-			if (r == -1) {
-				c = cmdq_get_client(item);
-				file = cmd_parse_file(tree);
-				if (c != NULL &&
-				    (~c->flags & CLIENT_CONTROL || file == NULL))
-					cmdq_error(item, "%s", cause);
-				else
-					cfg_add_cause("%s", cause);
-				free(cause);
-				cmd_invoke_skip_sequence(is);
-				break;
-			}
-
-			cmd = cmd_invoke_build_command(item, is, node);
-			if (cmd == NULL) {
-				cmd_invoke_skip_sequence(is);
-				break;
-			}
-			if (cmd_invoke_read_only(item, cmd) != 0) {
-				cmd_free(cmd);
-				cmd_invoke_skip_sequence(is);
-				break;
-			}
-
-			/*
-			 * Queue one command followed by this walker. WAIT and
-			 * command-inserted items therefore run before resume.
-			 */
-			state = cmdq_get_state(item);
-			new_item = cmdq_get_one_command(cmd, state, is);
-			next = cmdq_get_invoke(is, state);
-			cmdq_insert_after(item, next);
-			cmdq_insert_after(item, new_item);
-			return (CMD_RETURN_NORMAL);
-		case CMD_PARSE_STRING:
-		case CMD_PARSE_COMMANDS:
-		case CMD_PARSE_TEXT:
-		case CMD_PARSE_ENVIRONMENT:
-		case CMD_PARSE_TILDE:
-			fatalx("unexpected node type");
-		}
-	}
-}

cmd-join-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-join-pane.c,v 1.74 2026/08/03 20:29:52 nicm Exp $ */
+/* $OpenBSD: cmd-join-pane.c,v 1.75 2026/09/21 10:33:16 nicm Exp $ */
 
 /*
  * Copyright (c) 2011 George Nachman <tmux@georgester.com>
@@ -133,7 +133,7 @@ cmd_join_pane_place(struct cmdq_item *item, struct winlink *wl,
 	} else if (strcmp(position, "back") == 0) {
 		TAILQ_REMOVE(&w->z_index, wp, zentry);
 		TAILQ_FOREACH(owp, &w->z_index, zentry) {
-			if (!window_pane_is_floating(owp))
+			if (!window_pane_is_floating_with_hidden(owp))
 				break;
 		}
 		if (owp != NULL)
@@ -142,24 +142,30 @@ cmd_join_pane_place(struct cmdq_item *item, struct winlink *wl,
 			TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
 	} else if (strcmp(position, "forward") == 0) {
 		owp = TAILQ_PREV(wp, window_panes_zindex, zentry);
+		while (owp != NULL && owp->layout_cell == NULL)
+			owp = TAILQ_PREV(owp, window_panes_zindex, zentry);
 		if (owp != NULL) {
 			TAILQ_REMOVE(&w->z_index, wp, zentry);
 			TAILQ_INSERT_BEFORE(owp, wp, zentry);
 		}
 	} else if (strcmp(position, "backward") == 0) {
 		owp = TAILQ_NEXT(wp, zentry);
+		while (owp != NULL && owp->layout_cell == NULL)
+			owp = TAILQ_NEXT(owp, zentry);
 		if (owp != NULL && window_pane_is_floating(owp)) {
 			TAILQ_REMOVE(&w->z_index, wp, zentry);
 			TAILQ_INSERT_AFTER(&w->z_index, owp, wp, zentry);
 		}
 	} else if (strcmp(position, "forward-loop") == 0) {
 		owp = TAILQ_PREV(wp, window_panes_zindex, zentry);
+		while (owp != NULL && owp->layout_cell == NULL)
+			owp = TAILQ_PREV(owp, window_panes_zindex, zentry);
 		TAILQ_REMOVE(&w->z_index, wp, zentry);
 		if (owp != NULL)
 			TAILQ_INSERT_BEFORE(owp, wp, zentry);
 		else {
 			TAILQ_FOREACH(owp, &w->z_index, zentry) {
-				if (!window_pane_is_floating(owp))
+				if (!window_pane_is_floating_with_hidden(owp))
 					break;
 			}
 			if (owp != NULL)
@@ -169,6 +175,8 @@ cmd_join_pane_place(struct cmdq_item *item, struct winlink *wl,
 		}
 	} else if (strcmp(position, "backward-loop") == 0) {
 		owp = TAILQ_NEXT(wp, zentry);
+		while (owp != NULL && owp->layout_cell == NULL)
+			owp = TAILQ_NEXT(owp, zentry);
 		if (owp != NULL && window_pane_is_floating(owp)) {
 			TAILQ_REMOVE(&w->z_index, wp, zentry);
 			TAILQ_INSERT_AFTER(&w->z_index, owp, wp, zentry);
@@ -347,8 +355,10 @@ cmd_join_pane_zindex(struct cmdq_item *item, struct winlink *wl,
 
 	n = 0;
 	TAILQ_FOREACH(owp, &w->z_index, zentry) {
-		if (!window_pane_is_floating(owp))
+		if (!window_pane_is_floating_with_hidden(owp))
 			break;
+		if (owp->layout_cell == NULL)
+			continue;
 		if (n >= z)
 			break;
 		n++;
@@ -443,7 +453,6 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 				cmdq_error(item, "pane is not floating");
 				return (CMD_RETURN_ERROR);
 			}
-			server_unzoom_window(dst_w);
 			if ((s = args_get(args, 'P')) != NULL)
 				return (cmd_join_pane_place(item, dst_wl, dst_wp, s));
 			if ((s = args_get(args, 'z')) != NULL)

cmd-list-keys.c

@@ -37,16 +37,6 @@
 	"-T #{p|#{key_table_width}:key_table} "			\
 	"#{p|#{key_string_width}:#{q|a:key_string}} "		\
 	"#{key_command}}"
-#define LIST_KEYS_TEMPLATE_PRETTY				\
-	"#{?notes_only,"					\
-	"#{key_prefix} "					\
-	"#{key_string} "					\
-	"#{?key_note,#{key_note},#{key_command}}"		\
-	","							\
-	"bind-key #{?key_repeat,-r ,}"				\
-	"-T #{key_table} "					\
-	"#{q|a:key_string} "					\
-	"#{key_command}}"
 
 static enum cmd_retval cmd_list_keys_exec(struct cmd *, struct cmdq_item *);
 
@@ -54,8 +44,8 @@ const struct cmd_entry cmd_list_keys_entry = {
 	.name = "list-keys",
 	.alias = "lsk",
 
-	.args = { "1aF:NO:P:prT:", 0, 1, NULL },
+	.args = { "1aF:NO:P:rT:", 0, 1, NULL },
-	.usage = "[-1aNpr] [-F format] [-O order] [-P prefix-string]"
+	.usage = "[-1aNr] [-F format] [-O order] [-P prefix-string]"
 		 "[-T key-table] [key]",
 
 	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
@@ -129,7 +119,7 @@ cmd_list_keys_get_root_and_prefix(u_int *n, struct sort_criteria *sort_crit)
 }
 
 static void
-cmd_list_keys_do_filter(int filter_notes, int filter_key, key_code only,
+cmd_list_keys_filter_key_list(int filter_notes, int filter_key, key_code only,
     struct key_binding **l, u_int *n)
 {
 	key_code	key;
@@ -147,8 +137,8 @@ cmd_list_keys_do_filter(int filter_notes, int filter_key, key_code only,
 }
 
 static void
-cmd_list_keys_format_key_binding(struct format_tree *ft,
+cmd_list_keys_format_add_key_binding(struct format_tree *ft,
-    const struct key_binding *bd, const char *prefix, int flags)
+    const struct key_binding *bd, const char *prefix)
 {
 	char	*s;
 
@@ -167,7 +157,8 @@ cmd_list_keys_format_key_binding(struct format_tree *ft,
 
 	format_add(ft, "key_string", "%s", key_string_lookup_key(bd->key, 0));
 
-	s = cmd_parse_print(bd->cmd, flags);
+	s = cmd_list_print(bd->cmdlist, CMD_LIST_PRINT_ESCAPED|
+	    CMD_LIST_PRINT_NO_GROUPS);
 	format_add(ft, "key_command", "%s", s);
 	free(s);
 }
@@ -186,7 +177,6 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 	char			*prefix = NULL;
 	u_int			 i, n;
 	int			 single, notes_only, filter_notes, filter_key;
-	int			 print_flags = 0;
 	struct sort_criteria	 sort_crit;
 
 	if ((keystr = args_string(args, 0)) != NULL) {
@@ -216,15 +206,9 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 	prefix = cmd_list_keys_get_prefix(args);
 	single = args_has(args, '1');
 	notes_only = args_has(args, 'N');
-	if (args_has(args, 'p'))
-		print_flags |= CMD_PARSE_PRINT_MULTILINE;
 
-	if ((template = args_get(args, 'F')) == NULL) {
+	if ((template = args_get(args, 'F')) == NULL)
-		if (print_flags & CMD_PARSE_PRINT_MULTILINE)
-			template = LIST_KEYS_TEMPLATE_PRETTY;
-		else
 		template = LIST_KEYS_TEMPLATE;
-	}
 
 	if (table)
 		l = sort_get_key_bindings_table(table, &n, &sort_crit);
@@ -235,8 +219,10 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 
 	filter_notes = notes_only && !args_has(args, 'a');
 	filter_key = only != KEYC_UNKNOWN;
-	if (filter_notes || filter_key)
+	if (filter_notes || filter_key) {
-		cmd_list_keys_do_filter(filter_notes, filter_key, only, l, &n);
+		cmd_list_keys_filter_key_list(filter_notes, filter_key, only, l,
+		    &n);
+	}
 	if (filter_key && n == 0) {
 		cmdq_error(item, "unknown key: %s", keystr);
 		free(prefix);
@@ -253,7 +239,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 	format_add(ft, "key_table_width", "%u",
 	    cmd_list_keys_get_table_width(l, n));
 	for (i = 0; i < n; i++) {
-		cmd_list_keys_format_key_binding(ft, l[i], prefix, print_flags);
+		cmd_list_keys_format_add_key_binding(ft, l[i], prefix);
 
 		line = format_expand(ft, template);
 		if (single && tc != NULL && (~tc->flags & CLIENT_CONTROL))

cmd-list-panes.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-panes.c,v 1.40 2026/06/01 14:01:09 nicm Exp $ */
+/* $OpenBSD: cmd-list-panes.c,v 1.41 2026/09/08 10:20:08 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -97,6 +97,7 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
     struct cmdq_item *item, int type)
 {
 	struct args		*args = cmd_get_args(self);
+	struct client		*c = cmdq_get_client(item);
 	struct window_pane	*wp, **l;
 	u_int			 i, n;
 	struct format_tree	*ft;
@@ -147,7 +148,7 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
 		wp = l[i];
 		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_defaults(ft, NULL, s, wl, wp);
+		format_defaults(ft, c, s, wl, wp);
 
 		if (filter != NULL) {
 			expanded = format_expand(ft, filter);

cmd-list-sessions.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-sessions.c,v 1.36 2026/02/27 08:25:12 nicm Exp $ */
+/* $OpenBSD: cmd-list-sessions.c,v 1.37 2026/09/08 10:20:08 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -53,6 +53,7 @@ static enum cmd_retval
 cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		 *args = cmd_get_args(self);
+	struct client		 *c = cmdq_get_client(item);
 	struct session		**l;
 	u_int		 	  n, i;
 	struct format_tree	 *ft;
@@ -76,7 +77,7 @@ cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 	for (i = 0; i < n; i++) {
 		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", i);
-		format_defaults(ft, NULL, l[i], NULL, NULL);
+		format_defaults(ft, c, l[i], NULL, NULL);
 
 		if (filter != NULL) {
 			expanded = format_expand(ft, filter);

cmd-list-windows.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-windows.c,v 1.50 2026/02/27 08:25:12 nicm Exp $ */
+/* $OpenBSD: cmd-list-windows.c,v 1.51 2026/09/08 10:20:08 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -60,6 +60,7 @@ cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = cmd_get_args(self);
 	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_client(item);
 	struct winlink		*wl, **l;
 	struct session		*s;
 	u_int			 i, n;
@@ -94,7 +95,7 @@ cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 		s = wl->session;
 		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_defaults(ft, NULL, s, wl, NULL);
+		format_defaults(ft, c, s, wl, NULL);
 
 		if (filter != NULL) {
 			expanded = format_expand(ft, filter);

cmd-new-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-new-window.c,v 1.103 2026/07/08 08:07:42 nicm Exp $ */
+/* $OpenBSD: cmd-new-window.c,v 1.104 2026/09/03 21:04:11 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -60,7 +60,8 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	struct client		*tc = cmdq_get_target_client(item);
 	struct session		*s = target->s;
 	struct winlink		*wl = target->wl, *new_wl = NULL;
-	int			 idx = target->idx, before, count = args_count(args);
+	int			 idx = target->idx, before;
+	int			 count = args_count(args);
 	char			*cause = NULL, *cp, *expanded, *wname = NULL;
 	const char		*template, *name;
 	struct cmd_find_state	 fs;
@@ -74,8 +75,10 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	}
 
 	/*
-	 * If -S and -n are given and -t is not and a single window with this
+	 * If -S is given, select an existing window instead of creating a
-	 * name already exists, select it.
+	 * new one: preferring -t if it already points at a window, or
+	 * otherwise -n if one exists with that name. If neither matches,
+	 * fall through and create a window as normal.
 	 */
 	name = args_get(args, 'n');
 	if (name != NULL) {
@@ -88,7 +91,10 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 		wname = clean_name(expanded, 0);
 		free(expanded);
 	}
-	if (args_has(args, 'S') && wname != NULL && target->idx == -1) {
+	if (args_has(args, 'S')) {
+		if (idx != -1)
+			new_wl = winlink_find_by_index(&s->windows, idx);
+		else if (wname != NULL) {
 			expanded = format_single(item, wname, c, s, NULL, NULL);
 			RB_FOREACH(wl, winlinks, &s->windows) {
 				if (strcmp(wl->window->name, expanded) != 0)
@@ -97,12 +103,17 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 					new_wl = wl;
 					continue;
 				}
-			cmdq_error(item, "multiple windows named %s", wname);
+				cmdq_error(item, "multiple windows named %s",
+				    wname);
 				free(wname);
 				free(expanded);
 				return (CMD_RETURN_ERROR);
 			}
 			free(expanded);
+		}
+	}
+
+	/* Found an existing window to select instead of creating a new one. */
 	if (new_wl != NULL) {
 		free(wname);
 		if (args_has(args, 'd'))
@@ -114,7 +125,6 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 		recalculate_sizes();
 		return (CMD_RETURN_NORMAL);
 	}
-	}
 
 	before = args_has(args, 'b');
 	if (args_has(args, 'a') || before) {

cmd-queue.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-queue.c,v 1.123 2026/08/24 20:34:26 nicm Exp $ */
+/* $OpenBSD: cmd-queue.c,v 1.124 2026/09/22 06:46:50 nicm Exp $ */
 
 /*
  * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -35,7 +35,6 @@
 enum cmdq_type {
 	CMDQ_COMMAND,
 	CMDQ_CALLBACK,
-	CMDQ_INVOKE,
 };
 
 /* Command queue item. */
@@ -48,6 +47,7 @@ struct cmdq_item {
 	struct client		*target_client;
 
 	enum cmdq_type		 type;
+	u_int			 group;
 
 	u_int			 number;
 	time_t			 time;
@@ -58,8 +58,8 @@ struct cmdq_item {
 	struct cmd_find_state	 source;
 	struct cmd_find_state	 target;
 
+	struct cmd_list		*cmdlist;
 	struct cmd		*cmd;
-	struct cmd_invoke_state	*invoke_state;
 
 	cmdq_cb			 cb;
 	void			*data;
@@ -428,10 +428,8 @@ cmdq_remove(struct cmdq_item *item)
 {
 	if (item->client != NULL)
 		server_client_unref(item->client);
-	if (item->cmd != NULL)
+	if (item->cmdlist != NULL)
-		cmd_free(item->cmd);
+		cmd_list_free(item->cmdlist);
-	if (item->invoke_state != NULL)
-		cmd_invoke_state_free(item->invoke_state);
 	cmdq_free_state(item->state);
 
 	TAILQ_REMOVE(&item->queue->list, item, entry);
@@ -440,46 +438,75 @@ cmdq_remove(struct cmdq_item *item)
 	free(item);
 }
 
-/* Get a single command for command queue with invoke state. */
+/* Remove all subsequent items that match this item's group. */
-struct cmdq_item *
+static void
-cmdq_get_one_command(struct cmd *cmd, struct cmdq_state *state,
+cmdq_remove_group(struct cmdq_item *item)
-    struct cmd_invoke_state *invoke_state)
 {
-	struct cmdq_item	*item;
+	struct cmdq_item	*this, *next;
-	const struct cmd_entry	*entry = cmd_get_entry(cmd);
+
+	if (item->group == 0)
+		return;
+	this = TAILQ_NEXT(item, entry);
+	while (this != NULL) {
+		next = TAILQ_NEXT(this, entry);
+		if (this->group == item->group)
+			cmdq_remove(this);
+		this = next;
+	}
+}
+
+/* Empty command callback. */
+static enum cmd_retval
+cmdq_empty_command(__unused struct cmdq_item *item, __unused void *data)
+{
+	return (CMD_RETURN_NORMAL);
+}
+
+/* Get a command for the command queue. */
+struct cmdq_item *
+cmdq_get_command(struct cmd_list *cmdlist, struct cmdq_state *state)
+{
+	struct cmdq_item	*item, *first = NULL, *last = NULL;
+	struct cmd		*cmd;
+	const struct cmd_entry	*entry;
+	int			 created = 0;
+
+	if ((cmd = cmd_list_first(cmdlist)) == NULL)
+		return (cmdq_get_callback(cmdq_empty_command, NULL));
+
+	if (state == NULL) {
+		state = cmdq_new_state(NULL, NULL, 0);
+		created = 1;
+	}
+
+	while (cmd != NULL) {
+		entry = cmd_get_entry(cmd);
 
 		item = xcalloc(1, sizeof *item);
 		xasprintf(&item->name, "[%s/%p]", entry->name, item);
 		item->type = CMDQ_COMMAND;
+
+		item->group = cmd_get_group(cmd);
+		item->state = cmdq_link_state(state);
+
+		item->cmdlist = cmdlist;
 		item->cmd = cmd;
 
-	if (state == NULL)
+		cmdlist->references++;
-		item->state = cmdq_new_state(NULL, NULL, 0);
+		log_debug("%s: %s group %u", __func__, item->name, item->group);
-	else
-		item->state = cmdq_link_state(state);
 
-	if (invoke_state != NULL)
+		if (first == NULL)
-		item->invoke_state = cmd_invoke_state_add_ref(invoke_state);
+			first = item;
+		if (last != NULL)
+			last->next = item;
+		last = item;
 
-	log_debug("%s: %s", __func__, item->name);
+		cmd = cmd_list_next(cmd);
-	return (item);
 	}
 
-/* Get an invoke continuation for command queue. */
+	if (created)
-struct cmdq_item *
+		cmdq_free_state(state);
-cmdq_get_invoke(struct cmd_invoke_state *invoke_state, struct cmdq_state *state)
+	return (first);
-{
-	struct cmdq_item	*item;
-
-	item = xcalloc(1, sizeof *item);
-	xasprintf(&item->name, "[invoke/%p]", item);
-	item->type = CMDQ_INVOKE;
-	if (state == NULL)
-		item->state = cmdq_new_state(NULL, NULL, 0);
-	else
-		item->state = cmdq_link_state(state);
-	item->invoke_state = cmd_invoke_state_add_ref(invoke_state);
-	return (item);
 }
 
 /* Fill in flag for a command. */
@@ -553,11 +580,14 @@ cmdq_fire_command(struct cmdq_item *item)
 	int			 flags, quiet = 0;
 	char			*tmp;
 
+	if (item->client != NULL && (item->client->flags & CLIENT_DEAD))
+		return (CMD_RETURN_ERROR);
+
 	if (cfg_finished)
 		cmdq_add_message(item);
 	if (log_get_level() > 1) {
 		tmp = cmd_print(cmd);
-		log_debug("%s %s: %s", __func__, name, tmp);
+		log_debug("%s %s: (%u) %s", __func__, name, item->group, tmp);
 		free(tmp);
 	}
 
@@ -636,6 +666,7 @@ cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
 	xasprintf(&item->name, "[%s/%p]", name, item);
 	item->type = CMDQ_CALLBACK;
 
+	item->group = 0;
 	item->state = cmdq_new_state(NULL, NULL, 0);
 
 	item->cb = cb;
@@ -717,16 +748,17 @@ cmdq_next(struct client *c)
 			switch (item->type) {
 			case CMDQ_COMMAND:
 				retval = cmdq_fire_command(item);
-				if (item->invoke_state != NULL)
-					cmd_invoke_result(item->invoke_state, retval);
 
+				/*
+				 * If a command returns an error, remove any
+				 * subsequent commands in the same group.
+				 */
+				if (retval == CMD_RETURN_ERROR)
+					cmdq_remove_group(item);
 				break;
 			case CMDQ_CALLBACK:
 				retval = cmdq_fire_callback(item);
 				break;
-			case CMDQ_INVOKE:
-				retval = cmd_invoke_fire(item, item->invoke_state);
-				break;
 			default:
 				retval = CMD_RETURN_ERROR;
 				break;

cmd-resize-pane.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-resize-pane.c,v 1.68 2026/08/31 07:44:39 nicm Exp $ */
+/* $OpenBSD: cmd-resize-pane.c,v 1.69 2026/09/21 10:33:16 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -91,6 +91,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 		server_redraw_window(w);
 		return (CMD_RETURN_NORMAL);
 	}
+	if (!window_pane_is_floating(wp))
 		server_unzoom_window(w);
 	lc = wp->layout_cell; /* may have been replaced by unzoom */
 

cmd-run-shell.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-run-shell.c,v 1.94 2026/08/25 06:04:33 nicm Exp $ */
+/* $OpenBSD: cmd-run-shell.c,v 1.95 2026/09/20 07:59:55 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -57,7 +57,7 @@ const struct cmd_entry cmd_run_shell_entry = {
 struct cmd_run_shell_data {
 	struct client			*client;
 	char				*cmd;
-	struct cmd_parse_tree	*tree;
+	struct args_command_state	*state;
 	char				*cwd;
 	struct cmdq_item		*item;
 	struct session			*s;
@@ -119,7 +119,7 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 	struct format_tree		*ft;
 	double				 d;
 	struct timeval			 tv;
-	char				*end, key[16], *cause = NULL;
+	char				*end, key[16];
 	u_int				 i;
 	int				 wait = !args_has(args, 'b');
 
@@ -129,10 +129,8 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "invalid delay time: %s", delay);
 			return (CMD_RETURN_ERROR);
 		}
-	} else {
+	} else if (args_count(args) == 0)
-		if (args_count(args) == 0)
 		return (CMD_RETURN_NORMAL);
-	}
 
 	cdata = xcalloc(1, sizeof *cdata);
 	if (!args_has(args, 'C')) {
@@ -147,13 +145,8 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 			format_free(ft);
 		}
 	} else {
-		cdata->tree = args_to_commands(self, item, 0, NULL, 1, &cause);
+		cdata->state = args_make_commands_prepare(self, item, 0, NULL,
-		if (cdata->tree == NULL) {
+		    wait, 1);
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			cmd_run_shell_free(cdata);
-			return (CMD_RETURN_ERROR);
-		}
 	}
 
 	if (args_has(args, 't') && wp != NULL)
@@ -170,29 +163,26 @@ cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	if (cdata->client != NULL)
 		cdata->client->references++;
-
 	if (args_has(args, 'c'))
-		cdata->cwd = xstrdup(args_get(args, 'c'));
+		cdata->cwd = format_single_from_target(item, args_get(args, 'c'));
 	else
 		cdata->cwd = xstrdup(server_client_get_cwd(c, s));
 
 	if (args_has(args, 'E'))
 		cdata->flags |= JOB_SHOWSTDERR;
 
-	if (s != NULL) {
 	cdata->s = s;
+	if (s != NULL)
 		session_add_ref(s, __func__);
-	}
 
 	evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata);
-	if (delay == NULL)
+	if (delay != NULL) {
-		event_active(&cdata->timer, EV_TIMEOUT, 1);
-	else {
 		timerclear(&tv);
 		tv.tv_sec = (time_t)d;
 		tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U;
 		evtimer_add(&cdata->timer, &tv);
-	}
+	} else
+		event_active(&cdata->timer, EV_TIMEOUT, 1);
 
 	if (!wait)
 		return (CMD_RETURN_NORMAL);
@@ -206,9 +196,10 @@ cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
 	struct client			*c = cdata->client;
 	const char			*cmd = cdata->cmd;
 	struct cmdq_item		*item = cdata->item, *new_item;
-	struct cmdq_state		*cs = NULL;
+	struct cmd_list			*cmdlist;
+	char				*error;
 
-	if (cdata->tree == NULL) {
+	if (cdata->state == NULL) {
 		if (cmd == NULL) {
 			if (cdata->item != NULL)
 				cmdq_continue(cdata->item);
@@ -231,13 +222,23 @@ cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
 		return;
 	}
 
-	if (item != NULL)
+	cmdlist = args_make_commands(cdata->state, 0, NULL, &error);
-		cs = cmdq_get_state(item);
+	if (cmdlist == NULL) {
-	new_item = cmd_invoke_get(cdata->tree, cs, NULL);
+		if (cdata->item == NULL) {
-	if (item == NULL)
+			*error = toupper((u_char)*error);
+			status_message_set(c, -1, 1, 0, 0, "%s", error);
+		} else
+			cmdq_error(cdata->item, "%s", error);
+		free(error);
+	} else if (item == NULL) {
+		new_item = cmdq_get_command(cmdlist, NULL);
 		cmdq_append(c, new_item);
-	else
+		cmd_list_free(cmdlist);
+	} else {
+		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
 		cmdq_insert_after(item, new_item);
+		cmd_list_free(cmdlist);
+	}
 
 	if (cdata->item != NULL)
 		cmdq_continue(cdata->item);
@@ -305,7 +306,8 @@ cmd_run_shell_free(void *data)
 		session_remove_ref(cdata->s, __func__);
 	if (cdata->client != NULL)
 		server_client_unref(cdata->client);
-	cmd_parse_free(cdata->tree);
+	if (cdata->state != NULL)
+		args_make_commands_free(cdata->state);
 	free(cdata->cwd);
 	free(cdata->cmd);
 	free(cdata);

cmd-select-layout.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-select-layout.c,v 1.43 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD: cmd-select-layout.c,v 1.45 2026/09/09 07:03:39 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -73,12 +73,13 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = cmd_get_args(self);
 	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct client		*c = cmdq_get_target_client(item);
 	struct winlink		*wl = target->wl;
 	struct window		*w = wl->window;
 	struct window_pane	*wp = target->wp;
 	const char		*layoutname;
-	char			*oldlayout, *cause;
+	char			*oldlayout, *cause = NULL;
-	int			 next, previous, layout;
+	int			 next, previous, layout, flags = 0;
 
 	server_unzoom_window(w);
 
@@ -89,8 +90,12 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'p'))
 		previous = 1;
 
+	if (c != NULL &&
+	    (c->flags & CLIENT_CONTROL) &&
+	    (~c->flags & CLIENT_CONTROL_NEWLAYOUTS))
+		flags |= LAYOUT_CUSTOM_OLD_FORMAT;
 	oldlayout = w->old_layout;
-	w->old_layout = layout_dump(w, w->layout_root);
+	w->old_layout = layout_dump(w, w->layout_root, flags);
 
 	if (next || previous) {
 		if (next)

cmd-source-file.c

@@ -131,7 +131,7 @@ cmd_source_file_done(__unused struct client *oc, const char *path,
 	if (error != 0)
 		cmdq_error(item, "%s: %s", strerror(error), path);
 	else if (bsize != 0) {
-		if (load_cfg_from_buffer(bdata, bsize, path, cdata->after,
+		if (load_cfg_from_buffer(bdata, bsize, path, c, cdata->after,
 		    target, cdata->flags, &new_item) < 0)
 			cdata->retval = CMD_RETURN_ERROR;
 		else if (new_item != NULL)

cmd-split-window.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-split-window.c,v 1.150 2026/08/20 09:19:24 nicm Exp $ */
+/* $OpenBSD: cmd-split-window.c,v 1.151 2026/09/10 11:02:18 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -40,8 +40,8 @@ const struct cmd_entry cmd_new_pane_entry = {
 	.name = "new-pane",
 	.alias = "newp",
 
-	.args = { "AbB:Cc:de:EfF:hIkl:KLMm:Op:PR:s:S:t:T:vWx:X:y:Y:Z", 0, -1, NULL },
+	.args = { "AbB:Cc:Dde:EfF:hIkl:KLMm:Op:PR:s:S:t:T:vWx:X:y:Y:Z", 0, -1, NULL },
-	.usage = "[-AbCdefhIkKLMOPvWZ] [-B border-lines] "
+	.usage = "[-AbCDefhIkKLMOPvWZ] [-B border-lines] "
 		 "[-c start-directory] [-e environment] "
 		 "[-F format] [-l size] [-m message] [-p percentage] "
 		 "[-s style] [-S active-border-style] "
@@ -219,6 +219,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 		new_wp->flags |= PANE_CAPTUREALLKEYS;
 	if (args_has(args, 'C') && args_has(args, 'O'))
 		new_wp->flags |= PANE_CLOSEONCLICK;
+	if (args_has(args, 'D') && args_has(args, 'O'))
+		new_wp->flags |= PANE_CLOSEONCANCEL;
 
 	style = args_get(args, 's');
 	if (style != NULL) {

cmd-wait-for.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-wait-for.c,v 1.23 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD: cmd-wait-for.c,v 1.24 2026/09/22 06:46:50 nicm Exp $ */
 
 /*
  * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -480,6 +480,40 @@ cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
 	return (CMD_RETURN_NORMAL);
 }
 
+void
+cmd_wait_for_client_lost(struct client *c)
+{
+	struct wait_channel	*wc, *wc1;
+	struct wait_item	*wi, *wi1;
+	struct wait_event_item	*wei, *wei1;
+
+	TAILQ_FOREACH_SAFE(wei, &wait_event_items, entry, wei1) {
+		if (cmdq_get_client(wei->item) == c) {
+			TAILQ_REMOVE(&wait_event_items, wei, entry);
+			cmdq_continue(wei->item);
+			cmd_wait_for_event_free(wei);
+		}
+	}
+
+	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
+		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+			if (cmdq_get_client(wi->item) == c) {
+				cmdq_continue(wi->item);
+				TAILQ_REMOVE(&wc->waiters, wi, entry);
+				free(wi);
+			}
+		}
+		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
+			if (cmdq_get_client(wi->item) == c) {
+				cmdq_continue(wi->item);
+				TAILQ_REMOVE(&wc->lockers, wi, entry);
+				free(wi);
+			}
+		}
+		cmd_wait_for_remove_empty(wc);
+	}
+}
+
 void
 cmd_wait_for_flush(void)
 {

cmd.c

@@ -220,11 +220,18 @@ const struct cmd_entry *cmd_table[] = {
 struct cmd {
 	const struct cmd_entry	 *entry;
 	struct args		 *args;
+	u_int			  group;
 
 	char			 *file;
 	u_int			  line;
 	int			  parse_flags;
+
+	TAILQ_ENTRY(cmd)	  qentry;
 };
+TAILQ_HEAD(cmds, cmd);
+
+/* Next group number for new command list. */
+static u_int cmd_list_next_group = 1;
 
 /* Log an argument vector. */
 void printflike(3, 4)
@@ -395,6 +402,13 @@ cmd_get_args(struct cmd *cmd)
 	return (cmd->args);
 }
 
+/* Get group for command. */
+u_int
+cmd_get_group(struct cmd *cmd)
+{
+	return (cmd->group);
+}
+
 /* Get file and line for command. */
 void
 cmd_get_source(struct cmd *cmd, const char **file, u_int *line)
@@ -544,6 +558,23 @@ cmd_free(struct cmd *cmd)
 	free(cmd);
 }
 
+/* Copy a command. */
+struct cmd *
+cmd_copy(struct cmd *cmd, int argc, char **argv)
+{
+	struct cmd	*new_cmd;
+
+	new_cmd = xcalloc(1, sizeof *new_cmd);
+	new_cmd->entry = cmd->entry;
+	new_cmd->args = args_copy(cmd->args, argc, argv);
+
+	if (cmd->file != NULL)
+		new_cmd->file = xstrdup(cmd->file);
+	new_cmd->line = cmd->line;
+
+	return (new_cmd);
+}
+
 /* Get a command as a string. */
 char *
 cmd_print(struct cmd *cmd)
@@ -560,6 +591,174 @@ cmd_print(struct cmd *cmd)
 	return (out);
 }
 
+/* Create a new command list. */
+struct cmd_list *
+cmd_list_new(void)
+{
+	struct cmd_list	*cmdlist;
+
+	cmdlist = xcalloc(1, sizeof *cmdlist);
+	cmdlist->references = 1;
+	cmdlist->group = cmd_list_next_group++;
+	cmdlist->list = xcalloc(1, sizeof *cmdlist->list);
+	TAILQ_INIT(cmdlist->list);
+	return (cmdlist);
+}
+
+/* Append a command to a command list. */
+void
+cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
+{
+	cmd->group = cmdlist->group;
+	TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
+}
+
+/* Append all commands from one list to another.  */
+void
+cmd_list_append_all(struct cmd_list *cmdlist, struct cmd_list *from)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, from->list, qentry)
+		cmd->group = cmdlist->group;
+	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
+}
+
+/* Move all commands from one command list to another. */
+void
+cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
+{
+	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
+	cmdlist->group = cmd_list_next_group++;
+}
+
+/* Free a command list. */
+void
+cmd_list_free(struct cmd_list *cmdlist)
+{
+	struct cmd	*cmd, *cmd1;
+
+	if (--cmdlist->references != 0)
+		return;
+
+	TAILQ_FOREACH_SAFE(cmd, cmdlist->list, qentry, cmd1) {
+		TAILQ_REMOVE(cmdlist->list, cmd, qentry);
+		cmd_free(cmd);
+	}
+	free(cmdlist->list);
+	free(cmdlist);
+}
+
+/* Copy a command list, expanding %s in arguments. */
+struct cmd_list *
+cmd_list_copy(const struct cmd_list *cmdlist, int argc, char **argv)
+{
+	struct cmd	*cmd;
+	struct cmd_list	*new_cmdlist;
+	struct cmd	*new_cmd;
+	u_int		 group = cmdlist->group;
+	char		*s;
+
+	s = cmd_list_print(cmdlist, 0);
+	log_debug("%s: %s", __func__, s);
+	free(s);
+
+	new_cmdlist = cmd_list_new();
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (cmd->group != group) {
+			new_cmdlist->group = cmd_list_next_group++;
+			group = cmd->group;
+		}
+		new_cmd = cmd_copy(cmd, argc, argv);
+		cmd_list_append(new_cmdlist, new_cmd);
+	}
+
+	s = cmd_list_print(new_cmdlist, 0);
+	log_debug("%s: %s", __func__, s);
+	free(s);
+
+	return (new_cmdlist);
+}
+
+/* Get a command list as a string. */
+char *
+cmd_list_print(const struct cmd_list *cmdlist, int flags)
+{
+	struct cmd	*cmd, *next;
+	char		*buf, *this;
+	size_t		 len;
+	const char	*separator;
+	int		 escaped = flags & CMD_LIST_PRINT_ESCAPED;
+	int		 no_groups = flags & CMD_LIST_PRINT_NO_GROUPS;
+	const char	*single_separator = escaped ? " \\; " : " ; ";
+	const char	*double_separator = escaped ? " \\;\\; " : " ;; ";
+
+	len = 1;
+	buf = xcalloc(1, len);
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		this = cmd_print(cmd);
+
+		len += strlen(this) + 6;
+		buf = xrealloc(buf, len);
+
+		strlcat(buf, this, len);
+
+		next = TAILQ_NEXT(cmd, qentry);
+		if (next != NULL) {
+			if (!no_groups && cmd->group != next->group)
+				separator = double_separator;
+			else
+				separator = single_separator;
+			strlcat(buf, separator, len);
+		}
+
+		free(this);
+	}
+
+	return (buf);
+}
+
+/* Get first command in list. */
+struct cmd *
+cmd_list_first(struct cmd_list *cmdlist)
+{
+	return (TAILQ_FIRST(cmdlist->list));
+}
+
+/* Get next command in list. */
+struct cmd *
+cmd_list_next(struct cmd *cmd)
+{
+	return (TAILQ_NEXT(cmd, qentry));
+}
+
+/* Do all of the commands in this command list have this flag? */
+int
+cmd_list_all_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (~cmd->entry->flags & flag)
+			return (0);
+	}
+	return (1);
+}
+
+/* Do any of the commands in this command list have this flag? */
+int
+cmd_list_any_have(struct cmd_list *cmdlist, int flag)
+{
+	struct cmd	*cmd;
+
+	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+		if (cmd->entry->flags & flag)
+			return (1);
+	}
+	return (0);
+}
+
 /* Adjust current mouse position for a pane. */
 int
 cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,

configure.ac

@@ -1,6 +1,6 @@
 # configure.ac
 
-AC_INIT([tmux], next-3.8)
+AC_INIT([tmux], 3.8-rc2)
 AC_PREREQ([2.60])
 
 AC_CONFIG_AUX_DIR(etc)

control-notify.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: control-notify.c,v 1.38 2026/08/03 13:38:42 nicm Exp $ */
+/* $OpenBSD: control-notify.c,v 1.39 2026/09/08 10:20:08 nicm Exp $ */
 
 /*
  * Copyright (c) 2012 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -70,6 +70,7 @@ control_window_layout_changed_cb(__unused const char *name,
 	struct session		*s;
 	struct winlink		*wl;
 	struct window		*w = event_payload_get_window(ep, "window");
+	struct format_tree	*ft;
 	const char		*template;
 	char			*cp;
 
@@ -84,20 +85,26 @@ control_window_layout_changed_cb(__unused const char *name,
 	 * and we don't need to inform the client about the layout change
 	 * because the whole window will go away soon.
 	 */
-	wl = TAILQ_FIRST(&w->winlinks);
+	if (TAILQ_FIRST(&w->winlinks) == NULL || w->layout_root == NULL)
-	if (wl == NULL || w->layout_root == NULL)
 		return;
-	cp = format_single(NULL, template, NULL, NULL, wl, NULL);
 
 	TAILQ_FOREACH(c, &clients, entry) {
 		if (!CONTROL_SHOULD_NOTIFY_CLIENT(c) || c->session == NULL)
 			continue;
 		s = c->session;
-		if (winlink_find_by_window_id(&s->windows, w->id) != NULL)
+		wl = winlink_find_by_window_id(&s->windows, w->id);
+		if (wl == NULL)
+			continue;
+
+		ft = format_create(c, NULL, FORMAT_NONE, 0);
+		format_defaults(ft, c, s, wl, NULL);
+		cp = format_expand(ft, template);
+		format_free(ft);
+
 		control_notify_write(c, "%s", cp);
-	}
 		free(cp);
 	}
+}
 
 /* Notify control clients that window pane changed. */
 static void

control.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: control.c,v 1.66 2026/08/18 07:43:44 nicm Exp $ */
+/* $OpenBSD: control.c,v 1.68 2026/09/09 08:30:05 nicm Exp $ */
 
 /*
  * Copyright (c) 2012 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -108,6 +108,7 @@ struct control_state {
 	u_int				 pending_count;
 
 	TAILQ_HEAD(, control_block)	 all_blocks;
+	size_t				 queued_reply_bytes;
 
 	struct bufferevent		*read_event;
 	struct bufferevent		*write_event;
@@ -132,6 +133,9 @@ struct control_state {
 /* Maximum age for clients that are not using pause mode. */
 #define CONTROL_MAXIMUM_AGE 300000
 
+/* Maximum buffered command replies for a client that is not reading. */
+#define CONTROL_MAXIMUM_REPLY_BUFFER (64 * 1024 * 1024)
+
 /* Flags to ignore client. */
 #define CONTROL_IGNORE_FLAGS \
 	(CLIENT_CONTROL_NOOUTPUT| \
@@ -165,6 +169,15 @@ RB_GENERATE_STATIC(control_windows, control_window, entry, control_window_cmp);
 static void
 control_free_block(struct control_state *cs, struct control_block *cb)
 {
+	size_t	 size;
+
+	if (cb->size == 0 && cb->line != NULL) {
+		size = strlen(cb->line) + 1;
+		if (cs->queued_reply_bytes > size)
+			cs->queued_reply_bytes -= size;
+		else
+			cs->queued_reply_bytes = 0;
+	}
 	free(cb->line);
 	TAILQ_REMOVE(&cs->all_blocks, cb, all_entry);
 	free(cb);
@@ -407,16 +420,52 @@ control_reset_pane(struct client *c, struct window_pane *wp)
 	memcpy(&cp->queued, &wp->offset, sizeof cp->queued);
 }
 
+/*
+ * Check if the replies buffered for a client, including one about to be
+ * added, have grown too large and kill it if so. Returns 1 if further output
+ * for the client should be dropped.
+ */
+static int
+control_check_reply_buffer(struct client *c, size_t added)
+{
+	struct control_state	*cs = c->control_state;
+	size_t			 size;
+
+	if (c->flags & CLIENT_CONTROL_DISCARD)
+		return (1);
+	size = EVBUFFER_LENGTH(cs->write_event->output);
+	size += cs->queued_reply_bytes;
+	size += added;
+	if (size < CONTROL_MAXIMUM_REPLY_BUFFER)
+		return (0);
+
+	log_debug("%s: %s: %zu bytes of replies buffered", __func__, c->name,
+	    size);
+	if (~c->flags & CLIENT_EXIT) {
+		c->exit_message = xstrdup("too far behind");
+		c->flags |= CLIENT_EXIT;
+		control_discard(c);
+	}
+	c->flags |= CLIENT_CONTROL_DISCARD;
+	return (1);
+}
+
 /* Write an already-formatted line, queueing it behind %output if needed. */
 static void
 control_write_line(struct client *c, char *line)
 {
 	struct control_state	*cs = c->control_state;
 	struct control_block	*cb;
+	size_t			 size = strlen(line) + 1;
+
+	if (control_check_reply_buffer(c, size)) {
+		free(line);
+		return;
+	}
 
 	if (TAILQ_EMPTY(&cs->all_blocks)) {
 		log_debug("%s: %s: writing line: %s", __func__, c->name, line);
-		bufferevent_write(cs->write_event, line, strlen(line));
+		bufferevent_write(cs->write_event, line, size - 1);
 		bufferevent_write(cs->write_event, "\n", 1);
 		bufferevent_enable(cs->write_event, EV_WRITE);
 		free(line);
@@ -426,6 +475,7 @@ control_write_line(struct client *c, char *line)
 	cb = xcalloc(1, sizeof *cb);
 	cb->line = line;
 	TAILQ_INSERT_TAIL(&cs->all_blocks, cb, all_entry);
+	cs->queued_reply_bytes += size;
 	cb->t = get_timer();
 
 	log_debug("%s: %s: storing line: %s", __func__, c->name, cb->line);
@@ -455,8 +505,12 @@ control_flush_deferred(struct client *c)
 void
 control_write(struct client *c, const char *fmt, ...)
 {
-	va_list	 ap;
+	struct control_state	*cs = c->control_state;
 	char			*line;
+	va_list			 ap;
+
+	if (cs == NULL)
+		return;
 
 	va_start(ap, fmt);
 	xvasprintf(&line, fmt, ap);
@@ -479,6 +533,9 @@ control_write_guard(struct client *c, const char *guard, long t, u_int number,
 	struct control_state	*cs = c->control_state;
 	char			*line;
 
+	if (cs == NULL)
+		return;
+
 	if (strcmp(guard, "begin") == 0)
 		cs->guard_depth++;
 
@@ -503,6 +560,9 @@ control_notify_write(struct client *c, const char *fmt, ...)
 	va_list			 ap;
 	char			*line;
 
+	if (cs == NULL)
+		return;
+
 	va_start(ap, fmt);
 	xvasprintf(&line, fmt, ap);
 	va_end(ap);
@@ -641,9 +701,8 @@ control_read_callback(__unused struct bufferevent *bufev, void *data)
 	struct control_state	*cs = c->control_state;
 	struct evbuffer		*buffer = cs->read_event->input;
 	char			*line, *error;
-	struct cmd_parse_tree	*tree;
-	struct cmdq_item	*new_item;
 	struct cmdq_state	*state;
+	enum cmd_parse_status	 status;
 
 	for (;;) {
 		line = evbuffer_readln(buffer, NULL, EVBUFFER_EOL_LF);
@@ -657,14 +716,9 @@ control_read_callback(__unused struct bufferevent *bufev, void *data)
 		}
 
 		state = cmdq_new_state(NULL, NULL, CMDQ_STATE_CONTROL);
-		tree = cmd_parse_from_string(line, NULL, &error);
+		status = cmd_parse_and_append(line, NULL, c, state, &error);
-		if (tree == NULL)
+		if (status == CMD_PARSE_ERROR)
 			cmdq_append(c, cmdq_get_callback(control_error, error));
-		else {
-			new_item = cmd_invoke_get(tree, state, NULL);
-			cmdq_append(c, new_item);
-			cmd_parse_free(tree);
-		}
 		cmdq_free_state(state);
 
 		free(line);
@@ -1003,6 +1057,7 @@ control_discard_all(struct client *c)
 	control_discard(c);
 	TAILQ_FOREACH_SAFE(cb, &cs->all_blocks, all_entry, cb1)
 		control_free_block(cs, cb);
+	cs->queued_reply_bytes = 0;
 	bufferevent_disable(cs->write_event, EV_WRITE);
 }
 

format.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: format.c,v 1.415 2026/08/31 19:34:09 nicm Exp $ */
+/* $OpenBSD: format.c,v 1.418 2026/09/20 08:19:31 nicm Exp $ */
 
 /*
  * Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -855,26 +855,42 @@ format_cb_window_active_clients_list(struct format_tree *ft)
 static void *
 format_cb_window_layout(struct format_tree *ft)
 {
+	struct client		*c = ft->client;
 	struct window		*w = ft->w;
+	struct layout_cell	*lcroot;
+	int			 flags = 0;
 
 	if (w == NULL)
 		return (NULL);
 
 	if (w->saved_layout_root != NULL)
-		return (layout_dump(w, w->saved_layout_root));
+		lcroot = w->saved_layout_root;
-	return (layout_dump(w, w->layout_root));
+	else
+		lcroot = w->layout_root;
+
+	if (c != NULL &&
+	    (c->flags & CLIENT_CONTROL) &&
+	    (~c->flags & CLIENT_CONTROL_NEWLAYOUTS))
+		flags |= LAYOUT_CUSTOM_OLD_FORMAT;
+	return (layout_dump(w, lcroot, flags));
 }
 
 /* Callback for window_visible_layout. */
 static void *
 format_cb_window_visible_layout(struct format_tree *ft)
 {
+	struct client	*c = ft->client;
 	struct window	*w = ft->w;
+	int		 flags = 0;
 
 	if (w == NULL)
 		return (NULL);
 
-	return (layout_dump(w, w->layout_root));
+	if (c != NULL &&
+	    (c->flags & CLIENT_CONTROL) &&
+	    (~c->flags & CLIENT_CONTROL_NEWLAYOUTS))
+		flags |= LAYOUT_CUSTOM_OLD_FORMAT;
+	return (layout_dump(w, w->layout_root, flags));
 }
 
 /* Callback for pane_start_command. */
@@ -2860,10 +2876,10 @@ format_cb_session_activity_flag(struct format_tree *ft)
 
 	if (ft->s != NULL) {
 		RB_FOREACH(wl, winlinks, &ft->s->windows) {
-			if (ft->wl->flags & WINLINK_ACTIVITY)
+			if (wl->flags & WINLINK_ACTIVITY)
 				return (xstrdup("1"));
-			return (xstrdup("0"));
 		}
+		return (xstrdup("0"));
 	}
 	return (NULL);
 }
@@ -2878,8 +2894,8 @@ format_cb_session_bell_flag(struct format_tree *ft)
 		RB_FOREACH(wl, winlinks, &ft->s->windows) {
 			if (wl->flags & WINLINK_BELL)
 				return (xstrdup("1"));
-			return (xstrdup("0"));
 		}
+		return (xstrdup("0"));
 	}
 	return (NULL);
 }
@@ -2892,10 +2908,10 @@ format_cb_session_silence_flag(struct format_tree *ft)
 
 	if (ft->s != NULL) {
 		RB_FOREACH(wl, winlinks, &ft->s->windows) {
-			if (ft->wl->flags & WINLINK_SILENCE)
+			if (wl->flags & WINLINK_SILENCE)
 				return (xstrdup("1"));
-			return (xstrdup("0"));
 		}
+		return (xstrdup("0"));
 	}
 	return (NULL);
 }
@@ -5234,6 +5250,7 @@ format_loop_sessions(struct format_expand_state *es, const char *fmt)
 		format_log(es, "session loop: $%u", s->id);
 		if (active != NULL &&
 		    ft->c != NULL &&
+		    ft->c->session != NULL &&
 		    s->id == ft->c->session->id)
 			use = active;
 		else

fuzz/cmd-parse-fuzzer.c

@@ -36,8 +36,7 @@ int
 LLVMFuzzerTestOneInput(const u_char *data, size_t size)
 {
 	struct cmd_parse_input	 pi;
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
-	char			*cause = NULL;
 
 	if (size > 2048 || size == 0)
 		return 0;
@@ -45,10 +44,17 @@ LLVMFuzzerTestOneInput(const u_char *data, size_t size)
 	memset(&pi, 0, sizeof pi);
 	pi.flags = CMD_PARSE_QUIET;
 
-	tree = cmd_parse_from_buffer(data, size, &pi, &cause);
+	pr = cmd_parse_from_buffer(data, size, &pi);
-	if (tree != NULL)
+	switch (pr->status) {
-		cmd_parse_free(tree);
+	case CMD_PARSE_SUCCESS:
-	free(cause);
+		cmd_list_free(pr->cmdlist);
+		break;
+	case CMD_PARSE_ERROR:
+		free(pr->error);
+		break;
+	default:
+		break;
+	}
 
 	return 0;
 }

hooks.c

@@ -59,35 +59,35 @@ static struct hooks_events hooks_events = TAILQ_HEAD_INITIALIZER(hooks_events);
 /* Insert one hook command list. */
 static struct cmdq_item *
 hooks_insert_one(struct cmdq_item *item, struct hooks_data *hd,
-    struct cmd_parse_tree *tree, struct cmdq_state *state)
+    struct cmd_list *cmdlist, struct cmdq_state *state)
 {
 	struct cmdq_item	*new_item;
 	char			*s;
 
-	if (tree == NULL)
+	if (cmdlist == NULL)
 		return (item);
 	if (log_get_level() != 0) {
-		s = cmd_parse_print(tree, 0);
+		s = cmd_list_print(cmdlist, 0);
 		log_debug("%s: hook %s is: %s", __func__, hd->name, s);
 		free(s);
 	}
-	new_item = cmd_invoke_get(tree, state, NULL);
+	new_item = cmdq_get_command(cmdlist, state);
 	if (item != NULL)
 		return (cmdq_insert_after(item, new_item));
 	return (cmdq_append(NULL, new_item));
 }
 
 /* Parse a hook command. */
-static struct cmd_parse_tree *
+static struct cmd_parse_result *
 hooks_parse(struct hooks_data *hd, struct cmd_find_state *fs,
-    const char *value, char **cause)
+    const char *value)
 {
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
 	struct format_tree	*ft;
 	char			*expanded;
 
 	if (!hd->expand)
-		return (cmd_parse_from_string(value, NULL, cause));
+		return (cmd_parse_from_string(value, NULL));
 
 	ft = format_create_defaults(NULL, hd->client, fs->s, fs->wl, fs->wp);
 	if (hd->formats != NULL)
@@ -95,9 +95,9 @@ hooks_parse(struct hooks_data *hd, struct cmd_find_state *fs,
 	expanded = format_expand(ft, value);
 	format_free(ft);
 
-	tree = cmd_parse_from_string(expanded, NULL, cause);
+	pr = cmd_parse_from_string(expanded, NULL);
 	free(expanded);
-	return (tree);
+	return (pr);
 }
 
 /* Insert commands for a hook. */
@@ -109,9 +109,9 @@ hooks_insert(struct cmdq_item *item, struct hooks_data *hd)
 	struct cmdq_state		*state;
 	struct options_entry		*o;
 	struct options_array_item	*a;
-	struct cmd_parse_tree		*tree;
+	struct cmd_list			*cmdlist;
 	const char			*value;
-	char				*cause = NULL;
+	struct cmd_parse_result		*pr;
 
 	log_debug("%s: inserting hook %s", __func__, hd->name);
 
@@ -155,35 +155,38 @@ hooks_insert(struct cmdq_item *item, struct hooks_data *hd)
 
 	if (*hd->name == '@') {
 		value = options_get_string(oo, hd->name);
-		cause = NULL;
+		pr = hooks_parse(hd, &fs, value);
-		tree = hooks_parse(hd, &fs, value, &cause);
+		switch (pr->status) {
-		if (tree == NULL) {
+		case CMD_PARSE_ERROR:
 			log_debug("%s: can't parse hook %s: %s", __func__,
-			    hd->name, cause);
+			    hd->name, pr->error);
-			free(cause);
+			free(pr->error);
-		} else {
+			break;
-			hooks_insert_one(item, hd, tree, state);
+		case CMD_PARSE_SUCCESS:
-			cmd_parse_free(tree);
+			hooks_insert_one(item, hd, pr->cmdlist, state);
+			break;
 		}
 	} else {
 		a = options_array_first(o);
 		while (a != NULL) {
 			if (hd->expand) {
 				value = options_array_item_value(a)->string;
-				cause = NULL;
+				pr = hooks_parse(hd, &fs, value);
-				tree = hooks_parse(hd, &fs, value, &cause);
+				switch (pr->status) {
-				if (tree == NULL) {
+				case CMD_PARSE_ERROR:
-					if (cause != NULL)
+					if (pr->error != NULL) {
-						cmdq_error(item, "%s", cause);
+						cmdq_error(item, "%s",
-					free(cause);
+						    pr->error);
-				} else {
+					}
-					item = hooks_insert_one(item, hd, tree,
+					break;
-					    state);
+				case CMD_PARSE_SUCCESS:
-					cmd_parse_free(tree);
+					item = hooks_insert_one(item, hd,
+					    pr->cmdlist, state);
+					break;
 				}
 			} else {
-				tree = options_array_item_value(a)->cmd;
+				cmdlist = options_array_item_value(a)->cmdlist;
-				item = hooks_insert_one(item, hd, tree,
+				item = hooks_insert_one(item, hd, cmdlist,
 				    state);
 			}
 			a = options_array_next(a);

key-bindings.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: key-bindings.c,v 1.192 2026/08/06 09:05:04 nicm Exp $ */
+/* $OpenBSD: key-bindings.c,v 1.193 2026/09/21 20:45:48 nicm Exp $ */
 
 /*
  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -130,7 +130,7 @@ key_bindings_cmp(struct key_binding *bd1, struct key_binding *bd2)
 static void
 key_bindings_free(struct key_binding *bd)
 {
-	cmd_parse_free(bd->cmd);
+	cmd_list_free(bd->cmdlist);
 	free((void *)bd->note);
 	free(bd);
 }
@@ -222,15 +222,16 @@ key_bindings_next(__unused struct key_table *table, struct key_binding *bd)
 
 void
 key_bindings_add(const char *name, key_code key, const char *note, int repeat,
-    struct cmd_parse_tree *cmd)
+    struct cmd_list *cmdlist)
 {
-	struct key_table	*table = key_bindings_get_table(name, 1);
+	struct key_table	*table;
 	struct key_binding	*bd;
-	const char		*k;
 	char			*s;
 
+	table = key_bindings_get_table(name, 1);
+
 	bd = key_bindings_get(table, key & ~KEYC_MASK_FLAGS);
-	if (cmd == NULL) {
+	if (cmdlist == NULL) {
 		if (bd != NULL) {
 			if (note != NULL) {
 				free((void *)bd->note);
@@ -255,11 +256,11 @@ key_bindings_add(const char *name, key_code key, const char *note, int repeat,
 
 	if (repeat)
 		bd->flags |= KEY_BINDING_REPEAT;
-	bd->cmd = cmd;
+	bd->cmdlist = cmdlist;
 
-	k = key_string_lookup_key(bd->key, 1);
+	s = cmd_list_print(bd->cmdlist, 0);
-	s = cmd_parse_print(bd->cmd, 0);
+	log_debug("%s: %#llx %s = %s", __func__, bd->key,
-	log_debug("%s: %#llx %s = %s", __func__, bd->key, k, s);
+	    key_string_lookup_key(bd->key, 1), s);
 	free(s);
 }
 
@@ -268,7 +269,6 @@ key_bindings_remove(const char *name, key_code key)
 {
 	struct key_table	*table;
 	struct key_binding	*bd;
-	const char		*k;
 
 	table = key_bindings_get_table(name, 0);
 	if (table == NULL)
@@ -278,8 +278,8 @@ key_bindings_remove(const char *name, key_code key)
 	if (bd == NULL)
 		return;
 
-	k = key_string_lookup_key(bd->key, 1);
+	log_debug("%s: %#llx %s", __func__, bd->key,
-	log_debug("%s: %#llx %s", __func__, bd->key, k);
+	    key_string_lookup_key(bd->key, 1));
 
 	RB_REMOVE(key_bindings, &table->key_bindings, bd);
 	key_bindings_free(bd);
@@ -311,8 +311,9 @@ key_bindings_reset(const char *name, key_code key)
 		return;
 	}
 
-	cmd_parse_free(bd->cmd);
+	cmd_list_free(bd->cmdlist);
-	bd->cmd = cmd_parse_add_ref(dd->cmd);
+	bd->cmdlist = dd->cmdlist;
+	bd->cmdlist->references++;
 
 	free((void *)bd->note);
 	if (dd->note != NULL)
@@ -369,7 +370,8 @@ key_bindings_init_done(__unused struct cmdq_item *item, __unused void *data)
 			if (bd->note != NULL)
 				new_bd->note = xstrdup(bd->note);
 			new_bd->flags = bd->flags;
-			new_bd->cmd = cmd_parse_add_ref(bd->cmd);
+			new_bd->cmdlist = bd->cmdlist;
+			new_bd->cmdlist->references++;
 			RB_INSERT(key_bindings, &table->default_key_bindings,
 			    new_bd);
 		}
@@ -521,7 +523,7 @@ key_bindings_init(void)
 		"bind -n TripleClick1Pane { select-pane -t=; if -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' { send -M } { copy-mode -H; send -X select-line; run -d0.3; send -X copy-pipe-and-cancel } }",
 
 		/* Mouse button 1 on border. */
-		"bind -n MouseDown1Border { select-pane -M }",
+		"bind -n MouseDown1Border { select-pane -t= }",
 
 		/* Mouse button 1 drag on border. */
 		"bind -n MouseDrag1Border { resize-pane -M }",
@@ -731,39 +733,50 @@ key_bindings_init(void)
 		"bind -Tcopy-mode-vi C-Up { send -X scroll-up }",
 		"bind -Tcopy-mode-vi C-Down { send -X scroll-down }",
 	};
-
 	u_int			 i;
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
-	struct cmdq_item	*new_item;
-	char			*cause = NULL;
 
 	for (i = 0; i < nitems(defaults); i++) {
-		tree = cmd_parse_from_string(defaults[i], NULL, &cause);
+		pr = cmd_parse_from_string(defaults[i], NULL);
-		if (tree == NULL)
+		if (pr->status != CMD_PARSE_SUCCESS) {
+			log_debug("%s", pr->error);
 			fatalx("bad default key: %s", defaults[i]);
-
+		}
-		new_item = cmd_invoke_get(tree, NULL, NULL);
+		cmdq_append(NULL, cmdq_get_command(pr->cmdlist, NULL));
-		cmdq_append(NULL, new_item);
+		cmd_list_free(pr->cmdlist);
-		cmd_parse_free(tree);
 	}
 	cmdq_append(NULL, cmdq_get_callback(key_bindings_init_done, NULL));
 }
 
+static enum cmd_retval
+key_bindings_read_only(struct cmdq_item *item, __unused void *data)
+{
+	cmdq_error(item, "client is read-only");
+	return (CMD_RETURN_ERROR);
+}
+
 struct cmdq_item *
 key_bindings_dispatch(struct key_binding *bd, struct cmdq_item *item,
     struct client *c, struct key_event *event, struct cmd_find_state *fs)
 {
 	struct cmdq_item	*new_item;
 	struct cmdq_state	*new_state;
-	int			 flags = 0;
+	int			 readonly, flags = 0;
 
+	if (c == NULL || (~c->flags & CLIENT_READONLY))
+		readonly = 1;
+	else
+		readonly = cmd_list_all_have(bd->cmdlist, CMD_READONLY);
+
+	if (!readonly)
+		new_item = cmdq_get_callback(key_bindings_read_only, NULL);
+	else {
 		if (bd->flags & KEY_BINDING_REPEAT)
 			flags |= CMDQ_STATE_REPEAT;
 		new_state = cmdq_new_state(fs, event, flags);
-
+		new_item = cmdq_get_command(bd->cmdlist, new_state);
-	new_item = cmd_invoke_get(bd->cmd, new_state, NULL);
 		cmdq_free_state(new_state);
-
+	}
 	if (item != NULL)
 		new_item = cmdq_insert_after(item, new_item);
 	else

layout.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: layout.c,v 1.98 2026/08/25 18:38:05 nicm Exp $ */
+/* $OpenBSD: layout.c,v 1.101 2026/09/20 08:42:46 nicm Exp $ */
 
 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -106,7 +106,7 @@ layout_free_cell(struct layout_cell *lc, int only_nodes)
 		}
 		break;
 	case LAYOUT_WINDOWPANE:
-		if (lc->wp != NULL) {
+		if (lc->wp != NULL && lc->wp->layout_cell != NULL) {
 			lc->wp->layout_cell->parent = NULL;
 			lc->wp->layout_cell = NULL;
 		}
@@ -233,29 +233,6 @@ layout_make_node(struct layout_cell *lc, enum layout_type type)
 	lc->wp = NULL;
 }
 
-/* Fix z-indexes. */
-void
-layout_fix_zindexes(struct window *w, struct layout_cell *lc)
-{
-	struct layout_cell	*lcchild;
-
-	if (lc == NULL)
-		return;
-
-	switch (lc->type) {
-	case LAYOUT_WINDOWPANE:
-		TAILQ_INSERT_TAIL(&w->z_index, lc->wp, zentry);
-		break;
-	case LAYOUT_LEFTRIGHT:
-	case LAYOUT_TOPBOTTOM:
-		TAILQ_FOREACH(lcchild, &lc->cells, entry)
-			layout_fix_zindexes(w, lcchild);
-		return;
-	default:
-		fatalx("bad layout type");
-	}
-}
-
 int
 layout_cell_is_tiled(struct layout_cell *lc)
 {
@@ -265,7 +242,7 @@ layout_cell_is_tiled(struct layout_cell *lc)
 	return is_leaf && !is_floating;
 }
 
-static int
+int
 layout_cell_has_tiled_child(struct layout_cell *lc)
 {
 	struct layout_cell      *lcchild;
@@ -509,18 +486,20 @@ layout_fix_panes(struct window *w, struct window_pane *skip)
 
 /* Count the number of available cells in a layout. */
 u_int
-layout_count_cells(struct layout_cell *lc)
+layout_count_cells(struct layout_cell *lc, int with_floating)
 {
 	struct layout_cell	*lcchild;
 	u_int			 count = 0;
 
 	switch (lc->type) {
 	case LAYOUT_WINDOWPANE:
+		if (lc->flags & LAYOUT_CELL_FLOATING && !with_floating)
+			return 0;
 		return (1);
 	case LAYOUT_LEFTRIGHT:
 	case LAYOUT_TOPBOTTOM:
 		TAILQ_FOREACH(lcchild, &lc->cells, entry)
-			count += layout_count_cells(lcchild);
+			count += layout_count_cells(lcchild, with_floating);
 		return (count);
 	default:
 		fatalx("bad layout type");
@@ -721,7 +700,7 @@ layout_destroy_cell(struct window *w, struct layout_cell *lc,
 	/* If no parent, this is the last pane in a window. */
 	lcparent = lc->parent;
 	if (lcparent == NULL) {
-		if (lc->wp != NULL)
+		if (*lcroot == lc)
 			*lcroot = NULL;
 		layout_free_cell(lc, 0);
 		return;
@@ -789,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)
@@ -809,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)
@@ -840,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);
 }
 
@@ -1702,7 +1728,7 @@ layout_floating_args_parse(struct cmdq_item *item, struct args *args,
     enum pane_lines lines, struct window *w, struct layout_geometry *lg,
     char **cause)
 {
-	int	 sx, sy, ox, oy;
+	int	 sx, sy, ox, oy, pad;
 	char	*error = NULL;
 
 	sx = lg->sx == UINT_MAX ? w->sx / 2 : lg->sx;
@@ -1751,12 +1777,20 @@ layout_floating_args_parse(struct cmdq_item *item, struct args *args,
 		}
 	}
 
+	if (!window_has_floating_panes(w)) {
+		w->last_new_pane_x = 0;
+		w->last_new_pane_y = 0;
+	}
 	if (ox == INT_MAX) {
 		if (w->last_new_pane_x == 0)
 			ox = 4;
 		else {
+			if (lines != PANE_LINES_NONE)
+				pad = 1;
+			else
+				pad = 0;
 			ox = w->last_new_pane_x + 4;
-			if (w->last_new_pane_x > w->sx)
+			if (ox + sx + pad > (int)w->sx)
 				ox = 4;
 		}
 		w->last_new_pane_x = ox;
@@ -1767,8 +1801,12 @@ layout_floating_args_parse(struct cmdq_item *item, struct args *args,
 		if (w->last_new_pane_y == 0)
 			oy = 2;
 		else {
+			if (lines != PANE_LINES_NONE)
+				pad = 1;
+			else
+				pad = 0;
 			oy = w->last_new_pane_y + 2;
-			if (w->last_new_pane_y > w->sy)
+			if (oy + sy + pad > (int)w->sy)
 				oy = 2;
 		}
 		w->last_new_pane_y = oy;

menu.c

@@ -333,10 +333,9 @@ menu_key(struct client *c, struct menu_data *md, struct key_event *event)
 	int				 move;
 	const char			*name = NULL;
 	const struct menu_item		*item;
-	struct cmd_parse_tree		*tree;
-	struct cmdq_item		*new_item;
 	struct key_event		 saved_event;
 	struct cmdq_state		*state;
+	enum cmd_parse_status		 status;
 	char				*error;
 	key_code			 key;
 
@@ -529,14 +528,11 @@ chosen:
 	} else
 		event = NULL;
 	state = cmdq_new_state(&md->fs, event, 0);
-	tree = cmd_parse_from_string(item->command, NULL, &error);
+
-	if (tree == NULL) {
+	status = cmd_parse_and_append(item->command, NULL, c, state, &error);
+	if (status == CMD_PARSE_ERROR) {
 		cmdq_append(c, cmdq_get_error(error));
 		free(error);
-	} else {
-		new_item = cmd_invoke_get(tree, state, NULL);
-		cmdq_append(c, new_item);
-		cmd_parse_free(tree);
 	}
 	cmdq_free_state(state);
 

mode-tree.c

@@ -1815,25 +1815,20 @@ void
 mode_tree_run_command(struct client *c, struct cmd_find_state *fs,
     const char *template, const char *name)
 {
-	struct cmd_parse_tree	*tree;
-	struct cmdq_item	*new_item;
 	struct cmdq_state	*state;
 	char			*command, *error;
+	enum cmd_parse_status	 status;
 
 	command = cmd_template_replace(template, name, 1);
 	if (command != NULL && *command != '\0') {
 		state = cmdq_new_state(fs, NULL, 0);
-		tree = cmd_parse_from_string(command, NULL, &error);
+		status = cmd_parse_and_append(command, NULL, c, state, &error);
-		if (tree == NULL) {
+		if (status == CMD_PARSE_ERROR) {
 			if (c != NULL) {
 				*error = toupper((u_char)*error);
 				status_message_set(c, -1, 1, 0, 0, "%s", error);
 			}
 			free(error);
-		} else {
-			new_item = cmd_invoke_get(tree, state, NULL);
-			cmdq_append(c, new_item);
-			cmd_parse_free(tree);
 		}
 		cmdq_free_state(state);
 	}

monitor.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: monitor.c,v 1.7 2026/07/27 19:15:58 nicm Exp $ */
+/* $OpenBSD: monitor.c,v 1.8 2026/09/07 10:15:25 nicm Exp $ */
 
 /*
  * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -614,8 +614,10 @@ monitor_parse(const char *value, char **name, enum monitor_type *type, int *id,
 		*type = MONITOR_ALL_WINDOWS;
 	else if (sscanf(what, "@%d", id) == 1 && *id >= 0)
 		*type = MONITOR_WINDOW;
-	else
+	else if (*what == '\0')
 		*type = MONITOR_SESSION;
+	else
+		goto fail;
 	*name = xstrdup(copy);
 	*format = xstrdup(split);
 

options-table.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: options-table.c,v 1.244 2026/09/01 12:49:49 nicm Exp $ */
+/* $OpenBSD: options-table.c,v 1.245 2026/09/10 11:02:18 nicm Exp $ */
 
 /*
  * Copyright (c) 2011 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -91,7 +91,7 @@ static const char *options_table_window_size_list[] = {
 	"largest", "smallest", "manual", "latest", NULL
 };
 static const char *options_table_remain_on_exit_list[] = {
-	"off", "on", "failed", "key", NULL
+	"off", "on", "failed", "key", "failed-key", NULL
 };
 static const char *options_table_destroy_unattached_list[] = {
 	"off", "on", "keep-last", "keep-group", NULL
@@ -1698,7 +1698,8 @@ const struct options_table_entry options_table[] = {
 	  .choices = options_table_remain_on_exit_list,
 	  .default_num = 0,
 	  .text = "Whether panes should remain ('on'), remain until a key is "
-		  "pressed ('key') or be automatically killed ('off' or "
+		  "pressed after any exit ('key') or after a failure "
+		  "('failed-key'), or be automatically killed ('off' or "
 		  "'failed') when the program inside exits."
 	},
 

options.c

@@ -180,8 +180,8 @@ options_value_free(struct options_entry *o, union options_value *ov)
 {
 	if (OPTIONS_IS_STRING(o))
 		free(ov->string);
-	if (OPTIONS_IS_COMMAND(o))
+	if (OPTIONS_IS_COMMAND(o) && ov->cmdlist != NULL)
-		cmd_parse_free(ov->cmd);
+		cmd_list_free(ov->cmdlist);
 }
 
 static char *
@@ -191,7 +191,7 @@ options_value_to_string(struct options_entry *o, union options_value *ov,
 	char	*s;
 
 	if (OPTIONS_IS_COMMAND(o))
-		return (cmd_parse_print(ov->cmd, 0));
+		return (cmd_list_print(ov->cmdlist, 0));
 	if (OPTIONS_IS_NUMBER(o)) {
 		switch (o->tableentry->type) {
 		case OPTIONS_TABLE_NUMBER:
@@ -315,8 +315,8 @@ options_default(struct options *oo, const struct options_table_entry *oe)
 	struct options_entry	*o;
 	union options_value	*ov;
 	char			 key[32];
-	char			*error = NULL;
 	u_int			 i;
+	struct cmd_parse_result	*pr;
 
 	o = options_empty(oo, oe);
 	ov = &o->value;
@@ -338,9 +338,15 @@ options_default(struct options *oo, const struct options_table_entry *oe)
 		ov->string = xstrdup(oe->default_str);
 		break;
 	case OPTIONS_TABLE_COMMAND:
-		ov->cmd = cmd_parse_from_string(oe->default_str, NULL, &error);
+		pr = cmd_parse_from_string(oe->default_str, NULL);
-		if (ov->cmd == NULL)
+		switch (pr->status) {
-			fatalx("bad default option %s", oe->name);
+		case CMD_PARSE_ERROR:
+			free(pr->error);
+			break;
+		case CMD_PARSE_SUCCESS:
+			ov->cmdlist = pr->cmdlist;
+			break;
+		}
 		break;
 	default:
 		ov->number = oe->default_num;
@@ -543,9 +549,8 @@ options_array_set(struct options_entry *o, const char *key, const char *value,
 {
 	struct options_array_item	*a;
 	char				*new, *new_key;
+	struct cmd_parse_result		*pr;
 	long long		 	 number;
-	struct cmd_parse_tree		*tree;
-	char				*error = NULL;
 
 	if (!OPTIONS_IS_ARRAY(o)) {
 		if (cause != NULL)
@@ -569,14 +574,17 @@ options_array_set(struct options_entry *o, const char *key, const char *value,
 	}
 
 	if (OPTIONS_IS_COMMAND(o)) {
-		tree = cmd_parse_from_string(value, NULL, &error);
+		pr = cmd_parse_from_string(value, NULL);
-		if (tree == NULL) {
+		switch (pr->status) {
+		case CMD_PARSE_ERROR:
 			if (cause != NULL)
-				*cause = error;
+				*cause = pr->error;
 			else
-				free(error);
+				free(pr->error);
 			free(new_key);
 			return (-1);
+		case CMD_PARSE_SUCCESS:
+			break;
 		}
 
 		a = options_array_item(o, new_key);
@@ -584,7 +592,7 @@ options_array_set(struct options_entry *o, const char *key, const char *value,
 			a = options_array_new(o, new_key);
 		else
 			options_value_free(o, &a->value);
-		a->value.cmd = tree;
+		a->value.cmdlist = pr->cmdlist;
 		free(new_key);
 		return (0);
 	}
@@ -904,7 +912,7 @@ options_get_number(struct options *oo, const char *name)
 	return (o->value.number);
 }
 
-struct cmd_parse_tree *
+struct cmd_list *
 options_get_command(struct options *oo, const char *name)
 {
 	struct options_entry	*o;
@@ -914,7 +922,7 @@ options_get_command(struct options *oo, const char *name)
 		fatalx("missing option %s", name);
 	if (!OPTIONS_IS_COMMAND(o))
 		fatalx("option %s is not a command", name);
-	return (o->value.cmd);
+	return (o->value.cmdlist);
 }
 
 struct options_entry *
@@ -980,7 +988,7 @@ options_set_number(struct options *oo, const char *name, long long value)
 
 struct options_entry *
 options_set_command(struct options *oo, const char *name,
-    struct cmd_parse_tree *value)
+    struct cmd_list *value)
 {
 	struct options_entry	*o;
 
@@ -996,8 +1004,9 @@ options_set_command(struct options *oo, const char *name,
 
 	if (!OPTIONS_IS_COMMAND(o))
 		fatalx("option %s is not a command", name);
-	cmd_parse_free(o->value.cmd);
+	if (o->value.cmdlist != NULL)
-	o->value.cmd = cmd_parse_add_ref(value);
+		cmd_list_free(o->value.cmdlist);
+	o->value.cmdlist = value;
 	return (o);
 }
 
@@ -1273,8 +1282,7 @@ options_from_string(struct options *oo, const struct options_table_entry *oe,
 	const char		*errstr, *new;
 	char			*old;
 	key_code		 key;
-	struct cmd_parse_tree	*tree;
+	struct cmd_parse_result	*pr;
-	struct cmd_parse_input	 pi = { 0 };
 
 	if (oe != NULL) {
 		if (value == NULL &&
@@ -1332,14 +1340,17 @@ options_from_string(struct options *oo, const struct options_table_entry *oe,
 		return (options_from_string_flag(oo, name, value, cause));
 	case OPTIONS_TABLE_CHOICE:
 		return (options_from_string_choice(oe, oo, name, value, cause));
-	case OPTIONS_TABLE_COMMAND: {
+	case OPTIONS_TABLE_COMMAND:
-		tree = cmd_parse_from_string(value, &pi, cause);
+		pr = cmd_parse_from_string(value, NULL);
-		if (tree == NULL)
+		switch (pr->status) {
+		case CMD_PARSE_ERROR:
+			*cause = pr->error;
 			return (-1);
-		options_set_command(oo, name, tree);
+		case CMD_PARSE_SUCCESS:
-		cmd_parse_free(tree);
+			options_set_command(oo, name, pr->cmdlist);
 			return (0);
 		}
+		break;
 	}
 	return (-1);
 }

prompt.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: prompt.c,v 1.6 2026/08/17 06:45:16 nicm Exp $ */
+/* $OpenBSD: prompt.c,v 1.7 2026/09/09 07:53:03 nicm Exp $ */
 
 /*
  * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -1493,9 +1493,11 @@ append_key:
 		utf8_set(&tmp, key);
 		if (key <= 0x1f || key == 0x7f)
 			tmp.width = 2;
-	} else if (KEYC_IS_UNICODE(key))
+	} else if (KEYC_IS_UNICODE(key)) {
 		utf8_to_data(key, &tmp);
-	else
+		if (tmp.size == 0)
+			return (PROMPT_KEY_HANDLED);
+	} else
 		return (PROMPT_KEY_HANDLED);
 
 	pr->buffer = xreallocarray(pr->buffer, size + 2,

regress/Makefile

@@ -1,33 +1,17 @@
 TESTS!= echo *.sh
 LOGDIR=logs
 
-.PHONY: all
+.PHONY: all prepare $(TESTS)
-.NOTPARALLEL: all
 
-all:
+all: prepare $(TESTS)
-	@mkdir -p "$(LOGDIR)"; \
+	@failed=0; failures=; \
-	rm -f "$(LOGDIR)"/*.log; \
-	failed=0; failures=; \
 	for test in $(TESTS); do \
 		base=$${test##*/}; \
 		log="$(LOGDIR)/$${base%.sh}.log"; \
-		rm -f "$$log"; \
+		if [ -f "$$log" ]; then \
-		printf '%-40s ' "$$test"; \
-		start=$$(date +%s); \
-		env -i LC_CTYPE=C.UTF-8 MallocNanoZone=0 \
-		    sh -x "$$test" >"$$log" 2>&1; \
-		if [ $$? -eq 0 ]; then \
-			end=$$(date +%s); \
-			rm -f "$$log"; \
-			echo "PASS ($$((end - start))s)"; \
-		else \
-			end=$$(date +%s); \
-			echo "FAIL ($$((end - start))s)"; \
-			echo " log: $$log"; \
 			failed=1; \
 			failures="$$failures $$test"; \
 		fi; \
-		sleep 1; \
 	done; \
 	if [ "$$failed" -ne 0 ]; then \
 		echo; \
@@ -39,3 +23,22 @@ all:
 		rmdir "$(LOGDIR)" 2>/dev/null || true; \
 	fi; \
 	exit $$failed
+
+prepare:
+	@mkdir -p "$(LOGDIR)"
+	@rm -f "$(LOGDIR)"/*.log
+
+$(TESTS): prepare
+	@base="$@"; base=$${base##*/}; \
+	log="$(LOGDIR)/$${base%.sh}.log"; \
+	start=$$(date +%s); \
+	if env -i LC_CTYPE=C.UTF-8 MallocNanoZone=0 \
+	    sh -x "$@" >"$$log" 2>&1; then \
+		end=$$(date +%s); \
+		rm -f "$$log"; \
+		printf '%-40s PASS (%ss)\n' "$@" "$$((end - start))"; \
+	else \
+		end=$$(date +%s); \
+		printf '%-40s FAIL (%ss)\n log: %s\n' \
+		    "$@" "$$((end - start))" "$$log"; \
+	fi

regress/alerts.sh

@@ -2,8 +2,9 @@
 
 # monitor-activity, monitor-bell and monitor-silence: both the
 # alert-activity, alert-bell and alert-silence hooks and the winlink alert
-# flags (window_activity_flag, window_bell_flag, window_silence_flag and
+# flags (window_activity_flag, window_bell_flag, window_silence_flag,
-# the #, !, ~ characters in window_flags). The sessions are detached so
+# their session equivalents and the #, !, ~ characters in window_flags).
+# The sessions are detached so
 # alert flags are set even on the current window; the *-action options
 # still decide whether the hooks fire. Panes run cat: activity is
 # generated by the tty echo of send-keys and a bell by sending a BEL and
@@ -111,6 +112,24 @@ flags_have()
 	esac
 }
 
+assert_session_flag()
+{
+	flag="#{session_${1}_flag}"
+	expected=$2
+
+	# Only mon exists here. Check both window contexts and list-sessions.
+	for target in mon:w0 "mon:$3"; do
+		value=$($TMUX display -pt "$target" "$flag") ||
+			fail "display $flag failed"
+		[ "$value" = "$expected" ] ||
+			fail "expected $flag for $target to be '$expected' but got '$value'"
+	done
+	value=$($TMUX list-sessions -F "$flag") ||
+		fail "list-sessions $flag failed"
+	[ "$value" = "$expected" ] ||
+		fail "expected list-sessions $flag to be '$expected' but got '$value'"
+}
+
 flags_lack()
 {
 	target=$1
@@ -150,10 +169,12 @@ $TMUX set-hook -g alert-silence \
 # alert-bell and sets the bell flag, shown as ! in window_flags.
 $TMUX neww -d -t mon: -n bellw cat || fail "new-window bellw failed"
 assert_fmt_unchanged mon:bellw '#{window_bell_flag}' 0
+assert_session_flag bell 0 bellw
 flags_lack mon:bellw '!'
 bell mon:bellw
 wait_for @log '|alert-bell:mon:bellw'
 wait_for_fmt mon:bellw '#{window_bell_flag}' 1
+assert_session_flag bell 1 bellw
 flags_have mon:bellw '!'
 
 # Bells are not deduplicated: a second bell fires the hook again even
@@ -164,6 +185,7 @@ wait_for @log '|alert-bell:mon:bellw|alert-bell:mon:bellw'
 # Selecting the window clears the alert flags.
 $TMUX selectw -t mon:bellw || fail "select-window bellw failed"
 wait_for_fmt mon:bellw '#{window_bell_flag}' 0
+assert_session_flag bell 0 bellw
 flags_lack mon:bellw '!'
 $TMUX selectw -t mon:w0 || fail "select-window w0 failed"
 
@@ -173,6 +195,7 @@ $TMUX set -g @log '' || fail "reset @log failed"
 bell mon:w0
 wait_for @log '|alert-bell:mon:w0'
 wait_for_fmt mon:w0 '#{window_bell_flag}' 1
+assert_session_flag bell 1 bellw
 $TMUX selectw -t mon:bellw || fail "select-window bellw failed"
 $TMUX selectw -t mon:w0 || fail "select-window w0 failed"
 wait_for_fmt mon:w0 '#{window_bell_flag}' 0
@@ -199,6 +222,7 @@ $TMUX neww -d -t mon: -n actw cat || fail "new-window actw failed"
 $TMUX set -g @log '' || fail "reset @log failed"
 activity mon:actw
 assert_fmt_unchanged mon:actw '#{window_activity_flag}' 0
+assert_session_flag activity 0 actw
 assert_unchanged @log ''
 
 # With monitor-activity on, output fires alert-activity and sets the
@@ -208,6 +232,7 @@ $TMUX set -wt mon:actw monitor-activity on ||
 activity mon:actw
 wait_for @log '|alert-activity:mon:actw'
 wait_for_fmt mon:actw '#{window_activity_flag}' 1
+assert_session_flag activity 1 actw
 flags_have mon:actw '#'
 
 # While the flag is set further activity does not fire the hook again.
@@ -234,6 +259,7 @@ exec 3>"$OUT/fifo"
 wait_for_fmt mon: '#{session_attached}' 1
 $TMUX selectw -t mon:actw || fail "select-window actw failed"
 wait_for_fmt mon:actw '#{window_activity_flag}' 0
+assert_session_flag activity 0 actw
 flags_lack mon:actw '#'
 $TMUX selectw -t mon:w0 || fail "select-window w0 failed"
 exec 3>&-
@@ -250,6 +276,7 @@ $TMUX set -wt mon:w0 monitor-activity on ||
 $TMUX set -g @log '' || fail "reset @log failed"
 activity mon:w0
 wait_for_fmt mon:w0 '#{window_activity_flag}' 1
+assert_session_flag activity 1 actw
 assert_unchanged @log ''
 $TMUX set -wut mon:w0 monitor-activity ||
 	fail "unset monitor-activity w0 failed"
@@ -273,16 +300,19 @@ $TMUX selectw -t mon:w0 || fail "select-window w0 failed"
 # running.
 $TMUX neww -d -t mon: -n silw cat || fail "new-window silw failed"
 assert_fmt_unchanged mon:silw '#{window_silence_flag}' 0
+assert_session_flag silence 0 silw
 $TMUX set -g @log '' || fail "reset @log failed"
 $TMUX set -wt mon:silw monitor-silence 1 || fail "set monitor-silence failed"
 wait_for @log '|alert-silence:mon:silw'
 wait_for_fmt mon:silw '#{window_silence_flag}' 1
+assert_session_flag silence 1 silw
 flags_have mon:silw '~'
 assert_unchanged @log '|alert-silence:mon:silw'
 $TMUX set -wt mon:silw monitor-silence 0 ||
 	fail "reset monitor-silence failed"
 $TMUX selectw -t mon:silw || fail "select-window silw failed"
 wait_for_fmt mon:silw '#{window_silence_flag}' 0
+assert_session_flag silence 0 silw
 flags_lack mon:silw '~'
 $TMUX selectw -t mon:w0 || fail "select-window w0 failed"
 

regress/capture-pane-time.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# capture-pane -I line timestamps
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+TMP=$(mktemp)
+trap '$TMUX kill-server 2>/dev/null; rm -f "$TMP"' 0 1 15
+$TMUX kill-server 2>/dev/null
+
+before=$(date +%s)
+$TMUX new-session -d -x 40 -y 5 'seq 1 12; sleep 10' || exit 1
+sleep 1
+after=$(date +%s)
+
+$TMUX capture-pane -pILF -S - -E - >"$TMP" || exit 1
+awk -v before="$before" -v after="$after" '
+	$1 !~ /^-?[0-9]+$/ || $2 !~ /^[0-9]+$/ { exit 1 }
+	$4 == "1" {
+		if ($2 < before || $2 > after)
+			exit 1
+		history = 1
+	}
+	$4 == "9" {
+		if ($2 != 0)
+			exit 1
+		visible = 1
+	}
+	END { if (!history || !visible) exit 1 }
+' "$TMP" || {
+	cat "$TMP"
+	exit 1
+}
+
+exit 0

regress/choose-tree.sh

@@ -290,4 +290,92 @@ wait_count ': G4' 7
 	fail "window 1 of zzz not killed"
 exit_mode q
 
+# --- help and information preview --------------------------------------------
+# The complete tree help is taller than the 24-line test terminal, where the
+# help renderer deliberately leaves the tree unchanged.
+$TMUX2 resize-window -t out:0 -x 80 -y 50 || exit 1
+i=0
+while [ "$i" -lt 50 ]; do
+	# The inner session has a one-line status, leaving a 49-line window.
+	[ "$($TMUX display-message -p -t aaa:0 '#{window_height}')" -ge 49 ] &&
+		break
+	sleep 0.2
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "attached client did not resize for tree help"
+$TMUX choose-tree -t aaa:0 -F 'G5' -O index || exit 1
+wait_count ': G5' 7
+$TMUX2 send-keys -t out:0 F1 || fail "send-keys F1 failed"
+wait_for 'Swap current and previous window'
+# The first key closes help; the second exits the tree.
+$TMUX send-keys -t aaa:0 q q || fail "send-keys help exit failed"
+wait_mode aaa:0 0
+
+$TMUX choose-tree -t aaa:0 -F 'G6' -O index || exit 1
+wait_count ': G6' 7
+$TMUX send-keys -t aaa:0 i || fail "send-keys info failed"
+wait_for 'Session'
+$TMUX send-keys -t aaa:0 i || fail "send-keys preview failed"
+exit_mode q
+
+# --- window swapping and command prompt for current/tagged items -------------
+# Restrict a window-only tree to two disposable windows in aaa. J (the
+# Shift-Down equivalent) swaps their window objects while leaving their indexes
+# in place.
+$TMUX new-window -d -t aaa: -n swap-a 'cat' || exit 1
+$TMUX new-window -d -t aaa: -n swap-b 'cat' || exit 1
+aidx=$($TMUX list-windows -t aaa -F '#{window_index}:#{window_name}' | \
+    awk -F: '$2 == "swap-a" {print $1}')
+bidx=$($TMUX list-windows -t aaa -F '#{window_index}:#{window_name}' | \
+    awk -F: '$2 == "swap-b" {print $1}')
+$TMUX choose-tree -w -t aaa:0 -O index -F 'WT #{window_name}' \
+	-f '#{m:swap-*,#{window_name}}' || exit 1
+wait_count 'WT swap-' 2
+$TMUX send-keys -t aaa:0 g j J || fail "window tree swap failed"
+i=0
+while [ "$i" -lt 50 ]; do
+	aname=$($TMUX display-message -p -t "aaa:$aidx" '#{window_name}')
+	bname=$($TMUX display-message -p -t "aaa:$bidx" '#{window_name}')
+	[ "$aname:$bname" = 'swap-b:swap-a' ] && break
+	sleep 0.2
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "window tree did not swap the two windows"
+
+# ':' runs an entered command for the current item and rebuilds the tree when
+# its queued command completes.
+$TMUX set-option -g @tree-command '' || exit 1
+$TMUX send-keys -t aaa:0 : || fail "window tree command prompt failed"
+wait_for '(current)'
+$TMUX send-keys -t aaa:0 -l "set-option -g @tree-command '%%'" || exit 1
+$TMUX send-keys -t aaa:0 Enter || exit 1
+i=0
+while [ "$i" -lt 50 ]; do
+	value=$($TMUX show-option -gqv @tree-command)
+	[ -n "$value" ] && break
+	sleep 0.2
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "window tree entered command did not run"
+case "$value" in
+=aaa:*.) ;;
+*) fail "window tree command target was '$value'" ;;
+esac
+
+# Tag both disposable windows and kill them through the tagged confirmation
+# callback. The mode-hosting window is outside the filter and survives.
+$TMUX send-keys -t aaa:0 g j t j t X || fail "tagged kill keys failed"
+wait_for 'Kill 2 tagged?'
+$TMUX send-keys -t aaa:0 y || fail "tagged kill confirmation failed"
+i=0
+while [ "$i" -lt 50 ]; do
+	left=$($TMUX list-windows -t aaa -F '#{window_name}' | \
+	    grep -c '^swap-' || true)
+	[ "$left" -eq 0 ] && break
+	sleep 0.2
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "tagged windows were not killed"
+exit_mode q
+
 exit 0

regress/clear-on-attach.sh

@@ -0,0 +1,96 @@
+#!/bin/sh
+
+# With clear-on-attach disabled tmux must preserve the terminal contents by
+# scrolling them away, rather than entering and clearing the alternate screen.
+# Capture the bytes written by a real attached client for both settings.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+INNER_ON="$TEST_TMUX -LtestIon$$ -f/dev/null"
+OUTER_ON="$TEST_TMUX -LtestOon$$ -f/dev/null"
+INNER_OFF="$TEST_TMUX -LtestIoff$$ -f/dev/null"
+OUTER_OFF="$TEST_TMUX -LtestOoff$$ -f/dev/null"
+DIR=$(mktemp -d) || exit 1
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER_ON kill-server 2>/dev/null
+	$INNER_ON kill-server 2>/dev/null
+	$OUTER_OFF kill-server 2>/dev/null
+	$INNER_OFF kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+wait_for_client()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		$current_inner list-clients 2>/dev/null | grep -q . && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "inner client did not attach"
+}
+
+capture_attach()
+{
+	setting=$1
+	output=$2
+	go=$DIR/go-$setting
+	if [ "$setting" = on ]; then
+		current_inner=$INNER_ON
+		current_outer=$OUTER_ON
+	else
+		current_inner=$INNER_OFF
+		current_outer=$OUTER_OFF
+	fi
+
+	$current_inner new-session -d -s inner -x40 -y10 \
+	    'exec sleep 100' || exit 1
+	$current_inner set-option -g status off || exit 1
+	$current_inner set-option -g clear-on-attach "$setting" || exit 1
+	$current_outer new-session -d -s outer -x40 -y10 \
+	    "while [ ! -e '$go' ]; do sleep 0.01; done; exec $current_inner attach-session -t inner" || exit 1
+	$current_outer set-option -g status off || exit 1
+	$current_outer pipe-pane -O "cat >'$output'" || exit 1
+	touch "$go"
+	wait_for_client
+	sleep 0.5
+	$current_outer pipe-pane -O || exit 1
+}
+
+on=$DIR/on
+off=$DIR/off
+capture_attach on "$on"
+capture_attach off "$off"
+
+smcup=$(printf '\033[?1049h')
+grep -Fq "$smcup" "$on" || fail "clear-on-attach on did not use smcup"
+if grep -Fq "$smcup" "$off"; then
+	fail "clear-on-attach off used smcup"
+fi
+
+# Some screen terminfo entries have indn (CSI Ps S), while older ones only
+# have ind (newline). The preserving path uses indn once or repeats ind once
+# for every line in the terminal plus one.
+escape=$(printf '\033')
+if ! LC_ALL=C grep -Eq "${escape}\\[[0-9]+S" "$off"; then
+	hex=$(od -An -tx1 -v "$off" | tr -d ' \n')
+	case "$hex" in
+	*0a0a0a0a0a0a0a0a0a0a0a*) ;;
+	*) fail "clear-on-attach off did not scroll the old contents away" ;;
+	esac
+fi
+
+exit 0

regress/client-key-order-focus.sh

@@ -0,0 +1,82 @@
+#!/bin/sh
+
+# send-keys -K injects a key into a client. Commands produced by that key must
+# be inserted immediately after send-keys, before later commands in the same
+# command list. Focus events arriving between a prefix and its following key
+# must be forwarded without cancelling the prefix table.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+INNER="$TEST_TMUX -LtestI$$ -f/dev/null"
+OUTER="$TEST_TMUX -LtestO$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+}
+trap cleanup 0 1 15
+
+wait_for_client()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		client=$($INNER list-clients -F '#{client_name}' 2>/dev/null)
+		[ -n "$client" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "inner client did not attach"
+}
+
+wait_for_option()
+{
+	option=$1
+	expected=$2
+	i=0
+	while [ "$i" -lt 50 ]; do
+		actual=$($INNER show-option -gv "$option" 2>/dev/null)
+		[ "$actual" = "$expected" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "$option is '$actual', expected '$expected'"
+}
+
+cleanup
+$INNER new-session -d -s inner -x40 -y10 'exec sleep 100' || exit 1
+$INNER set-option -g status off || exit 1
+$INNER set-option -g focus-events on || exit 1
+$OUTER new-session -d -s outer -x40 -y10 "$INNER attach -t inner" || exit 1
+$OUTER set-option -g status off || exit 1
+wait_for_client
+
+# The binding generated by send-keys -K must run before the command which
+# follows send-keys in this command list. Before the queue-ordering fix this
+# produces AB rather than BA.
+$INNER set-option -g @order '' || exit 1
+$INNER bind-key -n a set-option -gF @order '#{@order}B' || exit 1
+$INNER send-keys -K -c "$client" a \; \
+	set-option -gF @order '#{@order}A' || exit 1
+wait_for_option @order BA
+
+# Put the real attached client in the prefix table, deliver FocusIn, then the
+# bound key. FocusIn is not bindable and must not reset the prefix table.
+$INNER bind-key x set-option -g @focus-prefix yes || exit 1
+$OUTER send-keys C-b || exit 1
+focus_in=$(printf '\033[I')
+$OUTER send-keys -l "$focus_in" || exit 1
+$OUTER send-keys x || exit 1
+wait_for_option @focus-prefix yes
+
+exit 0

regress/clock-mode.sh

@@ -0,0 +1,101 @@
+#!/bin/sh
+
+# Exercise clock-mode initialization, all four styles, its one-second timer,
+# resize into the compact renderer, arbitrary-key exit, and cleanup.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+INNER="$TEST_TMUX -LtestI$$ -f/dev/null"
+OUTER="$TEST_TMUX -LtestO$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+capture()
+{
+	$OUTER capture-pane -p -t outer:0.0 2>/dev/null
+}
+
+wait_mode()
+{
+	want=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		got=$($INNER display-message -p -t clock:0 '#{pane_mode}' 2>/dev/null)
+		[ "$got" = "$want" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "pane mode is '$got', expected '$want'"
+}
+
+wait_hashes()
+{
+	i=0
+	while [ "$i" -lt 50 ]; do
+		captured=$(capture)
+		printf '%s\n' "$captured" | grep -q '#' && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "large clock did not render"
+}
+
+$INNER new-session -d -s clock -x80 -y24 'exec sleep 100' || exit 1
+$INNER set-option -g status off || exit 1
+$INNER set-option -g window-size manual || exit 1
+$INNER set-option -w clock-mode-colour red || exit 1
+$OUTER new-session -d -s outer -x80 -y24 "$INNER attach -t clock" || exit 1
+$OUTER set-option -g status off || exit 1
+$OUTER set-option -g window-size manual || exit 1
+sleep 1
+
+for style in 12 24 12-with-seconds 24-with-seconds; do
+	$INNER set-option -w -t clock:0 clock-mode-style "$style" || exit 1
+	$INNER clock-mode -t clock:0 || exit 1
+	wait_mode clock-mode
+	wait_hashes
+	# Let at least one timer callback observe a new second.
+	[ "$style" != 12-with-seconds ] || sleep 1.2
+	$INNER send-keys -t clock:0 x || exit 1
+	wait_mode ''
+done
+
+# Resizing an active mode below the large-glyph threshold selects the compact
+# renderer. A visible time contains a colon and no block-clock hash.
+$INNER clock-mode -t clock:0 || exit 1
+wait_mode clock-mode
+$INNER resize-window -t clock:0 -x20 -y5 || exit 1
+i=0
+while [ "$i" -lt 50 ]; do
+	captured=$(capture)
+	printf '%s\n' "$captured" | grep -Eq '[0-9][0-9]?:[0-9][0-9]' && break
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "compact clock did not render after resize"
+printf '%s\n' "$captured" | grep -q '#' &&
+	fail "compact clock still used large glyphs"
+$INNER send-keys -t clock:0 Enter || exit 1
+wait_mode ''
+
+$INNER has-session -t clock || fail "server died during clock-mode tests"
+exit 0

regress/cmd-client-argv.sh

@@ -1,50 +0,0 @@
-#!/bin/sh
-
-# Client argv parsing and the start-server boundary.
-#
-# The command line given to the client is parsed and invoked as one sequence.
-# This checks: a multi-command argv runs every command and starts the server
-# (new-session carries CMD_STARTSERVER); a command without start-server fails
-# cleanly against no server; and a parse error leaves no stray server behind.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-# Multi-command argv: starts the server and runs all commands in order.
-$TMUX new-session -d -swork -nbase \; set -g @a one \; new-window -dn W2 \; \
-	set -g @b two || exit 1
-[ "$($TMUX show -gv @a)" = one ] || { echo "argv cmd 2 did not run" >&2; exit 1; }
-[ "$($TMUX show -gv @b)" = two ] || { echo "argv cmd 4 did not run" >&2; exit 1; }
-got=$($TMUX list-windows -t work -F '#{window_name}' | tr '\n' ',')
-[ "$got" = "base,W2," ] || { echo "argv windows: got [$got]" >&2; exit 1; }
-# kill-server is asynchronous; wait for the server to actually exit before the
-# checks below that require no server to be running.
-$TMUX kill-server 2>/dev/null
-i=0
-while $TMUX has-session 2>/dev/null; do
-	sleep 0.05
-	i=$((i + 1))
-	[ $i -gt 100 ] && break
-done
-
-# A command without start-server fails cleanly when no server is running and
-# does not fork one.
-$TMUX new-window -dn ZZ 2>/dev/null && { echo "new-window unexpectedly succeeded" >&2; exit 1; }
-if $TMUX has-session 2>/dev/null; then
-	echo "non-start-server command left a stray server" >&2
-	exit 1
-fi
-
-# A parse error with no server running starts no server.
-$TMUX 'if-shell true {' 2>/dev/null && { echo "parse error did not fail" >&2; exit 1; }
-if $TMUX has-session 2>/dev/null; then
-	echo "parse error left a stray server" >&2
-	exit 1
-fi
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-command-alias.sh

@@ -1,87 +0,0 @@
-#!/bin/sh
-
-# command-alias expansion, against a running server and at server start.
-#
-# An alias replaces a command name with parsed command text; arguments after the
-# alias name are appended to the last command of the expansion. This covers a
-# single-command alias, a multi-command alias, argument appending, a built-in
-# default alias, and aliases that are defined and used as the server starts
-# (both from the startup config and from the client command line that starts
-# the server).
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-CONF=$(mktemp)
-trap "rm -f $CONF" 0 1 15
-
-wait_gone() {
-	i=0
-	while $TMUX has-session 2>/dev/null; do
-		sleep 0.05
-		i=$((i + 1))
-		[ $i -gt 100 ] && break
-	done
-}
-
-# --- Against a running server. ---------------------------------------------
-$TMUX -f/dev/null start \; new-session -d -swork -nbase 2>/dev/null || exit 1
-
-# Single-command alias.
-$TMUX split-window -dt work || exit 1
-$TMUX set -s command-alias[200] 'zoomit=resize-pane -Z' || exit 1
-$TMUX zoomit -t work:.0 || exit 1
-[ "$($TMUX display-message -p -t work '#{window_zoomed_flag}')" = 1 ] || {
-	echo "single-command alias did not zoom" >&2; exit 1; }
-
-# Multi-command alias: both commands run.
-$TMUX set -s command-alias[201] 'twowin=new-window -dn AA ; new-window -dn BB' || exit 1
-$TMUX run-shell -C 'twowin' || exit 1
-got=$($TMUX list-windows -t work -F '#{window_name}' | tr '\n' ',')
-[ "$got" = "base,AA,BB," ] || { echo "multi-command alias: got [$got]" >&2; exit 1; }
-
-# Arguments after the alias name are appended to the expansion.
-$TMUX set -s command-alias[202] 'namewin=new-window -d -n' || exit 1
-$TMUX run-shell -C 'namewin CC' || exit 1
-$TMUX list-windows -t work -F '#{window_name}' | grep -qx CC || {
-	echo "alias argument append did not create window CC" >&2; exit 1; }
-
-# A built-in default alias (splitp -> split-window).
-before=$($TMUX list-panes -t work | wc -l)
-$TMUX run-shell -C 'splitp -d -t work' || exit 1
-after=$($TMUX list-panes -t work | wc -l)
-[ "$after" -gt "$before" ] || { echo "built-in alias splitp did not split" >&2; exit 1; }
-
-$TMUX kill-server 2>/dev/null
-wait_gone
-
-# --- At server start: alias defined and used in the startup config. --------
-cat <<'EOF' >$CONF
-set -s command-alias[100] greet='set -g @g started'
-set -s command-alias[101] mkwins='new-window -dn SW1 ; new-window -dn SW2'
-new-session -d -swork -nbase
-greet
-mkwins
-EOF
-$TMUX -f$CONF start 2>/dev/null || exit 1
-[ "$($TMUX show -gv @g)" = started ] || { echo "startup-config alias did not run" >&2; exit 1; }
-got=$($TMUX list-windows -t work -F '#{window_name}' | tr '\n' ',')
-[ "$got" = "base,SW1,SW2," ] || { echo "startup-config multi alias: got [$got]" >&2; exit 1; }
-
-$TMUX kill-server 2>/dev/null
-wait_gone
-
-# --- At server start: alias from config, used on the command line that starts
-#     the server. ---------------------------------------------------------
-cat <<'EOF' >$CONF
-set -s command-alias[100] greet='set -g @g argv'
-EOF
-$TMUX -f$CONF new-session -d -swork \; greet 2>/dev/null || exit 1
-[ "$($TMUX show -gv @g)" = argv ] || { echo "argv-start alias did not run" >&2; exit 1; }
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-invoke-deferred.sh

@@ -1,102 +0,0 @@
-#!/bin/sh
-
-# Deferred command callbacks.
-#
-# Several commands store a parsed tree and invoke it later through
-# cmd_invoke_get: if-shell (then/else, sync and background), run-shell -C, and -
-# once a key is pressed by an attached client - a key binding, confirm-before and
-# command-prompt. The headless cases run directly on the inner server; the
-# client cases use the nested-tmux pattern from prompt-mechanics.sh: an outer
-# server hosts the inner client in a pane and keys are injected with send-keys.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-OUT="$TEST_TMUX -Ltest -f/dev/null"
-IN="$TEST_TMUX -Ltest2 -f/dev/null"
-
-$OUT kill-server 2>/dev/null
-$IN kill-server 2>/dev/null
-trap "$OUT kill-server 2>/dev/null; $IN kill-server 2>/dev/null" 0 1 15
-
-fail() { echo "[FAIL] $1" >&2; exit 1; }
-settle() { sleep 0.5; }
-
-CONF=$(mktemp)
-trap "rm -f $CONF; $OUT kill-server 2>/dev/null; $IN kill-server 2>/dev/null" 0 1 15
-
-# --- Headless deferred callbacks: no client needed. ------------------------
-$IN new -d -x80 -y23 -nbase "sh -c 'exec sleep 1000'" || exit 1
-$IN set -g status on || exit 1
-$IN set -g status-keys emacs || exit 1
-$IN set -g window-size manual || exit 1
-
-$IN if-shell true 'set -g @t then' 'set -g @t else' || exit 1
-[ "$($IN show -gv @t)" = then ] || fail "if-shell true ran wrong branch"
-$IN if-shell false 'set -g @f then' 'set -g @f else' || exit 1
-[ "$($IN show -gv @f)" = else ] || fail "if-shell false ran wrong branch"
-
-# Background (-b) if-shell evaluates its condition in a shell asynchronously.
-$IN if-shell -b 'true' 'set -g @b yes' 'set -g @b no' || exit 1
-settle
-[ "$($IN show -gv @b)" = yes ] || fail "background if-shell ran wrong branch"
-
-# A multi-command then-body runs both commands.
-$IN if-shell true 'new-window -dn IF1 ; new-window -dn IF2' '' || exit 1
-$IN list-windows -F '#{window_name}' | grep -qx IF1 || fail "if-shell body cmd1 missing"
-$IN list-windows -F '#{window_name}' | grep -qx IF2 || fail "if-shell body cmd2 missing"
-
-# run-shell -C invokes its argument as tmux commands.
-$IN run-shell -C 'set -g @rc ran' || exit 1
-[ "$($IN show -gv @rc)" = ran ] || fail "run-shell -C did not run command"
-
-# --- Client deferred callbacks: key binding, confirm-before, command-prompt. -
-$IN bind -n M-c confirm-before -p '(ok) ' 'set -g @cb confirmed' || exit 1
-$IN bind -n M-d command-prompt -I pre -p '(cmd) ' 'set -g @cp %%' || exit 1
-# A brace body must come through the lexer, so bind it from a config.
-cat <<'EOF' >$CONF
-bind -n M-k { new-window -dn K1 ; new-window -dn K2 }
-EOF
-$IN source-file $CONF || exit 1
-
-$OUT new -d -x80 -y24 || exit 1
-$OUT set -g status off || exit 1
-$OUT set -g window-size manual || exit 1
-$OUT send-keys -l "$IN attach" || exit 1
-$OUT send-keys Enter || exit 1
-sleep 1
-
-# Key binding with a stored multi-command body fires on keypress.
-$OUT send-keys M-k || exit 1
-settle
-$IN list-windows -F '#{window_name}' | grep -qx K1 || fail "key binding body cmd1 missing"
-$IN list-windows -F '#{window_name}' | grep -qx K2 || fail "key binding body cmd2 missing"
-
-# confirm-before runs its command only when confirmed.
-$IN set -g @cb none || exit 1
-$OUT send-keys M-c || exit 1
-settle
-$OUT capture-pane -p | tail -1 | grep -qF '(ok)' || fail "confirm-before prompt not shown"
-$OUT send-keys n || exit 1
-settle
-[ "$($IN show -gv @cb)" = none ] || fail "confirm-before ran command after 'n'"
-$OUT send-keys M-c || exit 1
-settle
-$OUT send-keys y || exit 1
-settle
-[ "$($IN show -gv @cb)" = confirmed ] || fail "confirm-before did not run command after 'y'"
-
-# command-prompt feeds the typed line (with -I prefill) into its template.
-$IN set -g @cp none || exit 1
-$OUT send-keys M-d || exit 1
-settle
-$OUT capture-pane -p | tail -1 | grep -qF '(cmd)' || fail "command-prompt not shown"
-$OUT send-keys -l X || exit 1
-$OUT send-keys Enter || exit 1
-settle
-[ "$($IN show -gv @cp)" = preX ] || fail "command-prompt recovered '$($IN show -gv @cp)'"
-
-$OUT kill-server 2>/dev/null
-$IN kill-server 2>/dev/null
-exit 0

regress/cmd-invoke-expand.sh

@@ -1,75 +0,0 @@
-#!/bin/sh
-
-# Invoke-time expansion and conditionals.
-#
-# The parser builds syntax only; environment/tilde expansion, assignments and
-# %if/%elif/%else are all evaluated when the tree is invoked. This drives every
-# one of those through a single config and checks the resulting option values:
-#   - FOO=bar assignments set the environment, read back with ${FOO} and $FOO
-#   - %hidden assignments behave the same
-#   - ~ expands to the home directory
-#   - %if / %elif / %else selects the correct branch
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-CONF=$(mktemp)
-trap "rm -f $CONF" 0 1 15
-
-cat <<'EOF' >$CONF
-FOO=hello
-set -g @assign "${FOO}"
-set -g @dollar "$FOO"
-%hidden BAR=secret
-set -g @hidden "${BAR}"
-set -g @undef "x${NOSUCHVAR_ZZZ}y"
-set -g @tilde ~
-set -g @baduser ~nosuchuser_zzz9
-%if 1
-set -g @iftrue then
-%else
-set -g @iftrue else
-%endif
-%if 0
-set -g @iffalse then
-%else
-set -g @iffalse else
-%endif
-%if 0
-set -g @elif a
-%elif 1
-set -g @elif b
-%else
-set -g @elif c
-%endif
-EOF
-
-$TMUX -f/dev/null start \; new-session -d 2>/dev/null || exit 1
-$TMUX source-file $CONF || exit 1
-
-check() {
-	got=$($TMUX show -gv "$1")
-	[ "$got" = "$2" ] || { echo "$1: got [$got] expected [$2]" >&2; exit 1; }
-}
-check @assign hello
-check @dollar hello
-check @hidden secret
-check @undef xy			# undefined environment variable expands to nothing
-check @baduser ""		# unknown user in ~user expands to nothing
-check @iftrue then
-check @iffalse else
-check @elif b
-
-# ~ expands to an absolute home directory (value is machine dependent).
-tilde=$($TMUX show -gv @tilde)
-case "$tilde" in
-/*) ;;
-*) echo "@tilde did not expand to an absolute path: [$tilde]" >&2; exit 1;;
-esac
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-invoke-failure-scope.sh

@@ -1,72 +0,0 @@
-#!/bin/sh
-
-# Command failure scope.
-#
-# Failure scope is the active sequence (CMD_PARSE_SEQUENCE): commands joined by
-# ';' share one scope, so a failure skips the rest of that sequence; commands on
-# separate lines are independent sequences and are not skipped. After a failed
-# inner brace the enclosing sequence still resumes.
-#
-# Each case below creates windows around a deliberately invalid command and the
-# resulting window list shows exactly which commands ran.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-TMP=$(mktemp)
-CONF=$(mktemp)
-trap "rm -f $TMP $CONF" 0 1 15
-
-# kill-server is asynchronous, so wait for the old server to actually exit
-# before starting a fresh one (otherwise the next start races a dying server).
-fresh_server() {
-	$TMUX kill-server 2>/dev/null
-	i=0
-	while $TMUX list-sessions >/dev/null 2>&1; do
-		sleep 0.05
-		i=$((i + 1))
-		[ $i -gt 100 ] && break
-	done
-	$TMUX -f/dev/null start \; new-session -d -swork -nbase || exit 1
-}
-
-# $1 label, $2 config body, $3 expected comma-separated window list.
-run() {
-	fresh_server
-	printf '%s\n' "$2" >$CONF
-	$TMUX source-file $CONF >/dev/null 2>&1
-	got=$($TMUX list-windows -t work -F '#{window_name}' | tr '\n' ',')
-	if [ "$got" != "$3" ]; then
-		echo "$1: got [$got] expected [$3]" >&2
-		exit 1
-	fi
-}
-
-# ';' sequence in a brace body: A runs, the bad command skips B (same sequence),
-# the outer sequence resumes so C runs.
-run "semicolon body" 'if-shell true { new-window -dn A ; nonexistent_cmd ; new-window -dn B }
-new-window -dn C' 'base,A,C,'
-
-# Newlines are independent sequences: the bad command skips only itself, so both
-# B and C still run.
-run "newline body" 'if-shell true {
-  new-window -dn A
-  nonexistent_cmd
-  new-window -dn B
-}
-new-window -dn C' 'base,A,B,C,'
-
-# Top-level ';' sequence: failure skips the rest of the line.
-run "top-level semicolon" 'new-window -dn A ; nonexistent_cmd ; new-window -dn B' 'base,A,'
-
-# Top-level newlines: independent, both run.
-run "top-level newline" 'new-window -dn A
-nonexistent_cmd
-new-window -dn B' 'base,A,B,'
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-invoke-hooks.sh

@@ -1,46 +0,0 @@
-#!/bin/sh
-
-# Hooks run stored command trees.
-#
-# A hook stores a parsed command tree that is invoked through cmd_invoke_get when
-# the hook fires. Covers a single-command hook, a multi-entry hook array (every
-# entry fires), and that show-hooks prints the stored commands back.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-$TMUX -f/dev/null start \; new-session -d -sfirst -nbase 2>/dev/null || exit 1
-
-# Single-command hook fires on session creation.
-$TMUX set-hook -g session-created 'set -g @hook done' || exit 1
-$TMUX new-session -d -ssecond || exit 1
-[ "$($TMUX show -gv @hook)" = done ] || {
-	echo "single-command hook did not fire" >&2
-	exit 1
-}
-
-# A hook array fires every entry.
-$TMUX set-hook -g session-created[10] 'new-window -dn H1' || exit 1
-$TMUX set-hook -g session-created[11] 'set -g @hook2 two' || exit 1
-$TMUX new-session -d -sthird || exit 1
-[ "$($TMUX show -gv @hook2)" = two ] || {
-	echo "hook array entry 11 did not fire" >&2
-	exit 1
-}
-echo "$($TMUX list-windows -t third -F '#{window_name}')" | grep -qx H1 || {
-	echo "hook array entry 10 did not create window" >&2
-	exit 1
-}
-
-# show-hooks prints the stored hook commands.
-$TMUX show-hooks -g | grep -q 'session-created.* set -g @hook done' || {
-	echo "show-hooks did not print stored hook command" >&2
-	exit 1
-}
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-invoke-readonly.sh

@@ -1,56 +0,0 @@
-#!/bin/sh
-
-# Read-only client enforcement.
-#
-# When the invoking client is read-only, cmd_invoke builds each command and
-# rejects it (without running it) unless the command entry is marked read-only.
-# A read-only client is created by attaching with -r; the nested-tmux pattern
-# from cmd-invoke-deferred.sh is used so a real read-only client presses a key.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-OUT="$TEST_TMUX -Ltest -f/dev/null"
-IN="$TEST_TMUX -Ltest2 -f/dev/null"
-
-$OUT kill-server 2>/dev/null
-$IN kill-server 2>/dev/null
-trap "$OUT kill-server 2>/dev/null; $IN kill-server 2>/dev/null" 0 1 15
-
-fail() { echo "[FAIL] $1" >&2; exit 1; }
-settle() { sleep 0.5; }
-
-# Inner session: a key bound to a non-read-only command.
-$IN new -d -x80 -y23 -nbase "sh -c 'exec sleep 1000'" || exit 1
-$IN set -g status on || exit 1
-$IN set -g status-keys emacs || exit 1
-$IN set -g window-size manual || exit 1
-$IN bind -n M-w new-window -dn ROTRY || exit 1
-
-# Outer session hosts the inner client, attached read-only with -r.
-$OUT new -d -x80 -y24 || exit 1
-$OUT set -g status off || exit 1
-$OUT set -g window-size manual || exit 1
-$OUT send-keys -l "$IN attach -r" || exit 1
-$OUT send-keys Enter || exit 1
-sleep 1
-
-[ "$($IN list-clients -F '#{client_readonly}')" = 1 ] || fail "client is not read-only"
-
-# Pressing the key runs new-window through the read-only client: it must be
-# rejected, leave no window, and report the error.
-$OUT send-keys M-w || exit 1
-settle
-$IN list-windows -F '#{window_name}' | grep -qx ROTRY && \
-	fail "read-only client was allowed to create a window"
-$OUT capture-pane -p | grep -qi 'read-only' || fail "no read-only error was shown"
-
-# Positive control: the same command with no client is not read-only and runs,
-# proving the command itself is valid and only the read-only client blocked it.
-$IN new-window -dn OKWIN || exit 1
-$IN list-windows -F '#{window_name}' | grep -qx OKWIN || fail "control new-window did not run"
-
-$OUT kill-server 2>/dev/null
-$IN kill-server 2>/dev/null
-exit 0

regress/cmd-parse-errors.sh

@@ -1,51 +0,0 @@
-#!/bin/sh
-
-# Malformed input rejection and crash/leak canary.
-#
-# Each input below is a syntax error. For every one we require that:
-#   - parsing reports failure (non-zero exit), and
-#   - the server is still alive afterwards (a follow-up command succeeds).
-# The second check is the important one: a parser that crashes or corrupts state
-# on bad input would take the server down here.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest -f/dev/null"
-$TMUX kill-server 2>/dev/null
-
-$TMUX -f/dev/null start \; new-session -d 2>/dev/null || exit 1
-
-n=0
-check() {
-	n=$((n + 1))
-	# Expect a parse failure.
-	if $TMUX run-shell -C "$1" >/dev/null 2>&1; then
-		echo "case $n: expected failure but succeeded: $1" >&2
-		exit 1
-	fi
-	# Expect the server to still be responsive.
-	if ! $TMUX list-sessions >/dev/null 2>&1; then
-		echo "case $n: server died after: $1" >&2
-		exit 1
-	fi
-}
-
-check 'if-shell true {'			# unterminated brace body
-check 'display-message a }'		# stray close brace
-check 'if-shell true { display-message a'	# unclosed nested brace
-check 'if-shell true { ; }'		# empty sequence in body
-check '%elif 1'				# %elif with no %if
-check '%endif'				# %endif with no %if
-check '%zzz'				# unknown % directive
-check '; display-message a'		# leading separator
-input='%if 1
-display-message a'
-check "$input"				# unterminated %if
-input='%if 1
-%endif'
-check "$input"				# empty %if body
-
-$TMUX kill-server 2>/dev/null
-exit 0

regress/cmd-parse-print.sh

@@ -1,120 +0,0 @@
-#!/bin/sh
-
-# Parse/print golden suite for the command parser.
-#
-# Binds a spread of command syntax forms into a dedicated key table, then prints
-# them back with list-keys (which calls cmd_parse_print on the stored tree). A
-# command-valued option is printed too. Three things are checked:
-#   - the default (single line) form is byte-for-byte as expected: quoting,
-#     escaped \; separators, inline braces, and preservation of unexpanded
-#     ${env}, ~ and #{format} inside stored bodies;
-#   - the -p (multiline) form is as expected;
-#   - the default form round-trips: sourcing it again reproduces the same keys.
-
-PATH=/bin:/usr/bin
-TERM=screen
-
-[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-SOCKET=$(mktemp -u testXXXXXX)
-TMUX="$TEST_TMUX -L$SOCKET -f/dev/null"
-TMUX2=
-$TMUX kill-server 2>/dev/null
-
-TMP=$(mktemp)
-CONF=$(mktemp)
-EXP=$(mktemp)
-RT1=$(mktemp)
-RT2=$(mktemp)
-trap "[ -n \"\$TMUX\" ] && \$TMUX kill-server 2>/dev/null; [ -n \"\$TMUX2\" ] && \$TMUX2 kill-server 2>/dev/null; rm -f $TMP $CONF $EXP $RT1 $RT2" 0 1 15
-
-cat <<'EOF' >$CONF
-bind -T parsetest a display-message hello
-bind -T parsetest b display-message "hello world"
-bind -T parsetest c display-message 'literal $HOME #{p} ~'
-bind -T parsetest d display-message ""
-bind -T parsetest e display-message "#{pane_id}"
-bind -T parsetest f display-message a \; display-message b
-bind -T parsetest g {
-  display-message one
-  display-message two
-}
-bind -T parsetest h if-shell true { display-message yes } { display-message no }
-bind -T parsetest m if-shell true { display-message "${HOME}" "~" "~root" "#{pane_id}" }
-bind -T parsetest n if-shell true { display-message "a\nb" "x;y" '#literal' }
-EOF
-
-# Expected output. The default form is single line (round-trippable); the -p
-# form is multiline, with lines inside braced bodies indented by a single tab.
-cat <<'EOF' >$EXP
-bind-key  -T parsetest a display-message hello
-bind-key  -T parsetest b display-message 'hello world'
-bind-key  -T parsetest c display-message 'literal $HOME #{p} ~'
-bind-key  -T parsetest d display-message ''
-bind-key  -T parsetest e display-message '#{pane_id}'
-bind-key  -T parsetest f display-message a \; display-message b
-bind-key  -T parsetest g display-message one \; display-message two
-bind-key  -T parsetest h if-shell true { display-message yes } { display-message no }
-bind-key  -T parsetest m if-shell true { display-message ${HOME} ~ ~root '#{pane_id}' }
-bind-key  -T parsetest n if-shell true { display-message a\nb 'x;y' '#literal' }
---- options ---
-display-message 'hi there'
---- multiline ---
-bind-key -T parsetest a display-message hello
-bind-key -T parsetest b display-message 'hello world'
-bind-key -T parsetest c display-message 'literal $HOME #{p} ~'
-bind-key -T parsetest d display-message ''
-bind-key -T parsetest e display-message '#{pane_id}'
-bind-key -T parsetest f display-message a \; display-message b
-bind-key -T parsetest g display-message one
-display-message two
-bind-key -T parsetest h if-shell true {
-	display-message yes
-} {
-	display-message no
-}
-bind-key -T parsetest m if-shell true {
-	display-message ${HOME} ~ ~root '#{pane_id}'
-}
-bind-key -T parsetest n if-shell true {
-	display-message a\nb 'x;y' '#literal'
-}
-EOF
-
-$TMUX -f/dev/null start \; new-session -d 2>/dev/null || exit 1
-$TMUX source-file $CONF || exit 1
-$TMUX set -g default-client-command 'display-message "hi there"' || exit 1
-
-set +x
-{
-	$TMUX list-keys -T parsetest
-	echo "--- options ---"
-	$TMUX show -gv default-client-command
-	echo "--- multiline ---"
-	$TMUX list-keys -p -T parsetest
-} >$TMP 2>&1 || exit 1
-set -x
-
-cmp -s $TMP $EXP || {
-	echo "cmd-parse-print: output differs from expected" >&2
-	diff -u $EXP $TMP >&2
-	exit 1
-}
-
-# Round-trip: the default form re-sourced into a fresh server must reproduce the
-# identical key list.
-$TMUX list-keys -T parsetest >$RT1 || exit 1
-$TMUX kill-server 2>/dev/null
-SOCKET2=$(mktemp -u testXXXXXX)
-TMUX2="$TEST_TMUX -L$SOCKET2 -f/dev/null"
-$TMUX2 -f/dev/null start \; new-session -d 2>/dev/null || exit 1
-$TMUX2 source-file $RT1 || exit 1
-$TMUX2 list-keys -T parsetest >$RT2 || exit 1
-$TMUX2 kill-server 2>/dev/null
-
-cmp -s $RT1 $RT2 || {
-	echo "cmd-parse-print: default form does not round-trip" >&2
-	diff -u $RT1 $RT2 >&2
-	exit 1
-}
-
-exit 0

regress/codepoint-widths.sh

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# Width cache ranges must include their endpoint without overflowing wchar_t.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+SERVER=
+WATCHDOG=
+
+cleanup()
+{
+	if [ -n "$WATCHDOG" ]; then
+		kill "$WATCHDOG" 2>/dev/null
+		wait "$WATCHDOG" 2>/dev/null
+	fi
+	[ -n "$SERVER" ] && kill -9 "$SERVER" 2>/dev/null
+}
+trap cleanup 0
+trap 'exit 1' 1 2 15
+
+$TMUX new-session -d 'exec sleep 60' || exit 1
+SERVER=$($TMUX display-message -p '#{pid}') || exit 1
+
+# kill-server cannot stop a server stuck rebuilding the width cache.
+(
+	sleep 5
+	kill -9 "$SERVER" 2>/dev/null
+) &
+WATCHDOG=$!
+
+$TMUX set -g codepoint-widths 'U+1F600=2' || exit 1
+
+# Cover both signed and unsigned 32-bit wchar_t. Values above WCHAR_MAX
+# are ignored by the parser on platforms where they cannot be represented.
+for value in U+7FFFFFFF=1 U+7FFFFFFE-U+7FFFFFFF=2 \
+    U+FFFFFFFF=1 U+FFFFFFFE-U+FFFFFFFF=2; do
+	$TMUX set -g codepoint-widths "$value" || exit 1
+	[ "$($TMUX display-message -p alive)" = alive ] || exit 1
+done
+
+# Check that an ordinary range still includes both endpoints and stops there.
+$TMUX set -g codepoint-widths 'U+03B1-U+03B3=2' || exit 1
+$TMUX set -g @text 'αβγδ' || exit 1
+[ "$($TMUX display-message -p '#{w:@text}')" = 7 ] || exit 1
+$TMUX set -gu codepoint-widths || exit 1
+[ "$($TMUX display-message -p '#{w:@text}')" = 4 ] || exit 1
+
+$TMUX kill-server || exit 1
+SERVER=
+exit 0

regress/confirm-before-lock.sh

@@ -0,0 +1,150 @@
+#!/bin/sh
+
+# Exercise confirm-before's waiting and background callbacks, custom keys and
+# prompts, default-yes handling and errors. Also cover all three lock command
+# entry points with a harmless lock-command which leaves a marker.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+INNER="$TEST_TMUX -LtestI$$ -f/dev/null"
+OUTER="$TEST_TMUX -LtestO$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+capture()
+{
+	$OUTER capture-pane -p -t outer:0.0 2>/dev/null
+}
+
+wait_capture()
+{
+	marker=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		captured=$(capture)
+		printf '%s\n' "$captured" | grep -Fq "$marker" && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "timed out waiting for '$marker'"
+}
+
+wait_option()
+{
+	want=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		got=$($INNER show-option -gqv @confirmed 2>/dev/null)
+		[ "$got" = "$want" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "@confirmed is '$got', expected '$want'"
+}
+
+wait_file()
+{
+	marker=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		[ -f "$marker" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "lock command did not create $marker"
+}
+
+$INNER new-session -d -s test -x80 -y24 'exec sleep 100' || exit 1
+$INNER set-option -g status on || exit 1
+$INNER set-option -g status-position bottom || exit 1
+$INNER set-option -g window-size manual || exit 1
+$OUTER new-session -d -s outer -x80 -y24 "$INNER attach -t test" || exit 1
+$OUTER set-option -g status off || exit 1
+$OUTER set-option -g window-size manual || exit 1
+sleep 1
+
+client=$($INNER list-clients -F '#{client_name}')
+[ -n "$client" ] || fail "inner client did not attach"
+
+$INNER bind-key -n M-a confirm-before \
+	'set-option -g @confirmed accepted' || exit 1
+$INNER bind-key -n M-b confirm-before -b -p 'Background?' \
+	'set-option -g @confirmed background' || exit 1
+$INNER bind-key -n M-c confirm-before -c x -p 'Custom?' \
+	'set-option -g @confirmed custom' || exit 1
+$INNER bind-key -n M-y confirm-before -y -p 'Default?' \
+	'set-option -g @confirmed default' || exit 1
+
+# A non-confirming response closes the waiting prompt without running its
+# command; reopening and accepting inserts the command after the waiting item.
+$INNER set-option -g @confirmed sentinel || exit 1
+$OUTER send-keys M-a || exit 1
+wait_capture "Confirm 'set-option'? (y/n)"
+$OUTER send-keys n || exit 1
+sleep 0.2
+wait_option sentinel
+$OUTER send-keys M-a || exit 1
+wait_capture "Confirm 'set-option'? (y/n)"
+$OUTER send-keys y || exit 1
+wait_option accepted
+
+# -b has no waiting queue item and appends its command to the client queue.
+$OUTER send-keys M-b || exit 1
+wait_capture 'Background?'
+$OUTER send-keys y || exit 1
+wait_option background
+
+# A custom printable key is accepted, and -y makes Enter affirmative.
+$OUTER send-keys M-c || exit 1
+wait_capture 'Custom?'
+$OUTER send-keys x || exit 1
+wait_option custom
+$OUTER send-keys M-y || exit 1
+wait_capture 'Default?'
+$OUTER send-keys Enter || exit 1
+wait_option default
+
+# Reject invalid multi-character and control confirmation keys.
+if $INNER confirm-before -b -t "$client" -c xx 'display-message x' \
+    >/dev/null 2>&1; then
+	fail "multi-character confirm key was accepted"
+fi
+if $INNER confirm-before -b -t "$client" -c "$(printf '\001')" \
+    'display-message x' >/dev/null 2>&1; then
+	fail "control confirm key was accepted"
+fi
+
+# lock-client, lock-session and lock-server all send lock-command to the real
+# attached client. The command returns immediately and unlocks the client.
+for kind in client session server; do
+	marker="$DIR/locked-$kind"
+	$INNER set-option -t test lock-command "printf locked >$marker" || exit 1
+	case "$kind" in
+	client) $INNER lock-client -t "$client" || exit 1 ;;
+	session) $INNER lock-session -t test || exit 1 ;;
+	server) $INNER lock-server || exit 1 ;;
+	esac
+	wait_file "$marker"
+done
+
+$INNER has-session -t test || fail "server died during prompt or lock tests"
+exit 0

regress/control-client-exit-stalled.sh

@@ -17,7 +17,7 @@ PATH=/bin:/usr/bin
 TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest"
+TMUX="$TEST_TMUX -Ltest$$"
 $TMUX kill-server 2>/dev/null
 
 DIR=$(mktemp -d)

regress/control-client-exit.sh

@@ -19,8 +19,7 @@ PATH=/bin:/usr/bin
 TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-SOCKET=$(mktemp -u testXXXXXX)
+TMUX="$TEST_TMUX -Ltest$$"
-TMUX="$TEST_TMUX -L$SOCKET"
 $TMUX kill-server 2>/dev/null
 
 DIR=$(mktemp -d)

regress/control-client-new-layouts.sh

@@ -0,0 +1,123 @@
+#!/bin/sh
+
+# Check that control client flags are available in every format expansion path
+# used to produce layouts. The layout strings themselves are tested separately.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+LANG=C.UTF-8
+export PATH TERM LC_ALL LANG
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+
+DIR=$(mktemp -d) || exit 1
+FIFO=$DIR/input
+OUT=$DIR/output
+CFG=$DIR/flags.conf
+PID=
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	exec 3>&-
+	[ -n "$PID" ] && kill "$PID" 2>/dev/null
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup EXIT
+
+wait_for()
+{
+	pattern=$1
+	i=0
+
+	while [ "$i" -lt 50 ]; do
+		grep -F -- "$pattern" "$OUT" >/dev/null 2>&1 && return 0
+		if [ -n "$PID" ] && ! kill -0 "$PID" 2>/dev/null; then
+			fail "control client exited waiting for: $pattern"
+		fi
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "missing: $pattern"
+}
+
+send()
+{
+	printf '%s\n' "$*" >&3
+}
+
+check_commands()
+{
+	name=$1
+	expected=$2
+	match='#{m:*new-layouts*,#{client_flags}}'
+
+	send "display-message -p 'DISPLAY-$name $match'"
+	wait_for "DISPLAY-$name $expected"
+	send "list-panes -F 'PANES-$name $match'"
+	wait_for "PANES-$name $expected"
+	send "list-windows -F 'WINDOWS-$name $match'"
+	wait_for "WINDOWS-$name $expected"
+	send "list-sessions -F 'SESSIONS-$name $match'"
+	wait_for "SESSIONS-$name $expected"
+	send "list-clients -F 'CLIENTS-$name $match'"
+	wait_for "CLIENTS-$name $expected"
+}
+
+check_config()
+{
+	name=$1
+	expected=$2
+
+	send "source-file '$CFG'"
+	send "display-message -p 'CONFIG-$name #{@config-new-layouts}'"
+	wait_for "CONFIG-$name $expected"
+}
+
+cat >"$CFG" <<'EOF'
+%if #{m:*new-layouts*,#{client_flags}}
+set-option -g @config-new-layouts 1
+%else
+set-option -g @config-new-layouts 0
+%endif
+EOF
+
+$TMUX kill-server 2>/dev/null
+$TMUX new-session -d -s layouts -x 80 -y 24 || exit 1
+$TMUX split-window -h -t layouts: || exit 1
+
+mkfifo "$FIFO" || exit 1
+: >"$OUT"
+$TMUX -C attach-session -t layouts <"$FIFO" >"$OUT" 2>&1 &
+PID=$!
+exec 3>"$FIFO"
+
+send 'display-message -p READY'
+wait_for READY
+
+check_commands OFF 0
+check_config OFF 0
+
+send 'refresh-client -f new-layouts'
+check_commands ON 1
+check_config ON 1
+
+send 'refresh-client -f !new-layouts'
+check_commands OFF-AGAIN 0
+check_config OFF-AGAIN 0
+
+# The list commands also run for unattached command clients. Supplying that
+# client to formats must not make the session loop dereference a NULL session.
+$TMUX list-sessions -F '#{S:all,active}' >/dev/null ||
+	fail "session loop failed for unattached command client"
+$TMUX has-session -t layouts || fail "server exited"
+
+exit 0

regress/control-client-popup.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+
+# 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.
+
+PATH=/bin:/usr/bin
+TERM=screen
+export PATH TERM
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+DIR=$(mktemp -d) || exit 1
+FIFO=$DIR/input
+OUT=$DIR/output
+RAN=$DIR/popup-ran
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	exec 3>&-
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+mkfifo "$FIFO" || exit 1
+$TMUX new-session -d -s control -x40 -y10 'exec sleep 100' || exit 1
+$TMUX -C attach-session -t control <"$FIFO" >"$OUT" 2>&1 &
+control_pid=$!
+exec 3>"$FIFO"
+
+i=0
+while [ "$i" -lt 50 ]; do
+	$TMUX list-clients -F '#{client_flags}' 2>/dev/null |
+	    grep -q 'control-mode' && break
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "control client did not attach"
+
+printf '%s\n' "display-popup -E 'touch $RAN'" >&3
+printf '%s\n' "display-message -p CONTROL-POPUP-ALIVE" >&3
+
+i=0
+while [ "$i" -lt 50 ]; do
+	grep -q 'CONTROL-POPUP-ALIVE' "$OUT" 2>/dev/null && break
+	if ! kill -0 "$control_pid" 2>/dev/null; then
+		fail "control client exited after display-popup"
+	fi
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "command after control-client popup did not run"
+$TMUX has-session -t control || fail "server exited after control-client popup"
+[ ! -e "$RAN" ] || fail "control client started a popup command"
+
+exit 0

regress/control-client-run-shell-exit.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# A waited run-shell command can complete after a control client has closed its
+# input and exited. The command queue still references the client until the job
+# callback runs, but control_stop has already destroyed c->control_state. Late
+# command output must be discarded instead of dereferencing the stopped control
+# state and killing the server.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -Ltest$$"
+$TMUX kill-server 2>/dev/null
+
+OUT=$(mktemp)
+trap "$TMUX kill-server 2>/dev/null; rm -f $OUT" 0 1 15
+
+$TMUX -f/dev/null new-session -d -s main || exit 1
+
+printf '%s\n' 'run-shell "sleep 0.2; echo TEST"' |
+	$TMUX -f/dev/null -C >"$OUT" 2>&1
+
+sleep 1
+
+$TMUX has-session -t main 2>/dev/null || {
+	echo "server exited after late run-shell output"
+	cat "$OUT"
+	exit 1
+}
+
+grep -q '^%exit' "$OUT" || {
+	echo "control client did not exit"
+	cat "$OUT"
+	exit 1
+}
+
+exit 0

regress/control-client-sanity.sh

@@ -30,8 +30,11 @@ killw
 EOF
 sleep 1
 $TMUX has || exit 1
-$TMUX lsp -aF '#{pane_id} #{window_layout}' >$TMP || exit 1
+# Use a control client to request legacy layouts, keeping only pane lines
-cat <<EOF|cmp -s $TMP - || exit 1
+# from the control protocol output.
+$TMUX -C lsp -aF '#{pane_id} #{window_layout}' |
+	grep '^%[0-9]' >$TMP || exit 1
+cat <<EOF|cmp $TMP - || exit 1
 %0 f5ab,200x200,0,0[200x50,0,0,0,200x149,0,51,3]
 %3 f5ab,200x200,0,0[200x50,0,0,0,200x149,0,51,3]
 %2 dcbd,200x200,0,0[200x100,0,0,2,200x99,0,101,4]

regress/control-client-wait-exit.sh

@@ -10,7 +10,7 @@ PATH=/bin:/usr/bin
 TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-TMUX="$TEST_TMUX -Ltest"
+TMUX="$TEST_TMUX -Ltest$$"
 $TMUX kill-server 2>/dev/null
 
 FIFO=$(mktemp -u)

regress/copy-mode-commands.sh

@@ -0,0 +1,253 @@
+#!/bin/sh
+
+# Exercise the broad non-mouse copy-mode command surface: navigation, search,
+# jumps, state toggles, line/end-of-line copies, append, and pipe variants.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+TMUX="$TEST_TMUX -Ltest$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+x()
+{
+	$TMUX send-keys -t copy:0 -X "$@" || fail "copy command failed: $*"
+}
+
+wait_mode()
+{
+	want=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		got=$($TMUX display-message -p -t copy:0 '#{pane_in_mode}' 2>/dev/null)
+		[ "$got" = "$want" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "pane_in_mode is '$got', expected '$want'"
+}
+
+fresh()
+{
+	$TMUX copy-mode -t copy:0 || exit 1
+	wait_mode 1
+	x history-top
+	x start-of-line
+}
+
+select_text()
+{
+	fresh
+	x begin-selection
+	x cursor-right
+	x cursor-right
+}
+
+$TMUX new-session -d -s copy -x40 -y8 \
+    "sh -c 'i=0; while [ \$i -lt 40 ]; do printf \"  line-%02d needle (a[b]c) end\\n\" \$i; i=\$((i + 1)); done; printf \"\\nparagraph two needle\\n\\nparagraph three\\n\"; printf \"\\033]133;A\\007prompt-one\\n\\033]133;C\\007output-one\\n\\033]133;A\\007prompt-two\\n\\033]133;C\\007output-two\\n\"; exec sleep 100'" ||
+	exit 1
+$TMUX set-option -g status off || exit 1
+$TMUX set-option -g history-limit 200 || exit 1
+
+i=0
+while [ "$i" -lt 50 ]; do
+	history=$($TMUX display-message -p -t copy:0 '#{history_size}')
+	[ "$history" -ge 30 ] && break
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "history did not fill"
+
+fresh
+
+# Copy-mode-specific format callbacks expose the word, line, hyperlink and
+# active search match at the cursor.
+formats=$($TMUX display-message -p -t copy:0 \
+    '#{copy_cursor_word}|#{copy_cursor_line}|#{copy_cursor_hyperlink}|#{search_match}') ||
+	exit 1
+[ -n "$formats" ] || fail "copy-mode cursor formats were empty"
+
+# Cursor, viewport and paragraph commands. Each is asserted by successful
+# dispatch and the final mode-liveness check; detailed word/selection geometry
+# is covered by the existing copy-mode tests.
+for command in back-to-indentation bottom-line top-line middle-line \
+    cursor-centre-vertical cursor-centre-horizontal end-of-line history-bottom \
+    history-top halfpage-down halfpage-up page-down page-up next-paragraph \
+    previous-paragraph next-matching-bracket previous-matching-bracket; do
+	x "$command"
+done
+x goto-line 15
+x set-mark
+x cursor-down
+x jump-to-mark
+
+# OSC 133 prompt and output markers support shell-integration navigation.
+x history-top
+x next-prompt
+case "$($TMUX display-message -p -t copy:0 '#{copy_cursor_line}')" in
+*prompt-one*) ;;
+*) fail "next-prompt did not find prompt-one" ;;
+esac
+x next-prompt
+x previous-prompt
+case "$($TMUX display-message -p -t copy:0 '#{copy_cursor_line}')" in
+*prompt-one*) ;;
+*) fail "previous-prompt did not return to prompt-one" ;;
+esac
+x next-prompt -o
+case "$($TMUX display-message -p -t copy:0 '#{copy_cursor_line}')" in
+*output-one*) ;;
+*) fail "next-prompt -o did not find output-one" ;;
+esac
+
+# Character jumps remember their direction and character for repeat/reverse.
+x jump-forward e
+x jump-again
+x jump-reverse
+x jump-backward e
+x jump-to-forward e
+x jump-to-backward e
+
+# Direct, text and incremental searches cover both directions and the saved
+# search used by again/reverse.
+x search-forward needle
+x search-again
+x search-reverse
+x search-backward needle
+x search-forward-text needle
+x search-backward-text needle
+x search-forward-incremental '=needle'
+x search-forward-incremental '+needle'
+x search-backward-incremental '=needle'
+x search-backward-incremental '-needle'
+
+# Stateful display and behaviour toggles.
+for command in rectangle-on rectangle-off rectangle-toggle \
+    line-numbers-on line-numbers-off line-numbers-toggle \
+    refresh-on refresh-now refresh-off refresh-toggle \
+    scroll-exit-on scroll-exit-off scroll-exit-toggle toggle-position; do
+	x "$command"
+done
+wait_mode 1
+x cancel
+wait_mode 0
+
+# Line and end-of-line copy commands work without an explicit selection.
+fresh
+x select-line
+x copy-selection-and-cancel
+case "$($TMUX show-buffer)" in
+*line-00*) ;;
+*) fail "select-line did not select the current line" ;;
+esac
+
+fresh
+x copy-line
+[ -n "$($TMUX show-buffer)" ] || fail "copy-line produced an empty buffer"
+x cancel
+
+fresh
+x copy-end-of-line
+[ -n "$($TMUX show-buffer)" ] || fail "copy-end-of-line produced an empty buffer"
+x cancel
+
+# Append variants retain or close the mode as advertised.
+$TMUX set-buffer -b append-buffer prefix || exit 1
+select_text
+x append-selection
+appended=$($TMUX show-buffer -b append-buffer)
+case "$appended" in
+prefix*) ;;
+*) fail "append-selection produced '$appended'" ;;
+esac
+x cancel
+
+$TMUX set-buffer -b append-cancel-buffer prefix || exit 1
+select_text
+x append-selection-and-cancel
+wait_mode 0
+appended=$($TMUX show-buffer -b append-cancel-buffer)
+case "$appended" in
+prefix*) ;;
+*) fail "append-selection-and-cancel produced '$appended'" ;;
+esac
+
+# The explicit cancel variants close copy mode.
+fresh
+x copy-line-and-cancel
+wait_mode 0
+fresh
+x copy-end-of-line-and-cancel
+wait_mode 0
+select_text
+x copy-selection-and-cancel
+wait_mode 0
+
+# Pipe wrappers have distinct command handlers. /dev/null keeps the test
+# deterministic while exercising asynchronous pipe job creation and cleanup.
+fresh
+x copy-pipe-line 'cat >/dev/null'
+x cancel
+fresh
+x copy-pipe-line-and-cancel 'cat >/dev/null'
+wait_mode 0
+fresh
+x copy-pipe-end-of-line 'cat >/dev/null'
+x cancel
+fresh
+x copy-pipe-end-of-line-and-cancel 'cat >/dev/null'
+wait_mode 0
+
+select_text
+x copy-pipe-no-clear 'cat >/dev/null'
+x pipe-no-clear 'cat >/dev/null'
+x copy-pipe 'cat >/dev/null'
+x pipe 'cat >/dev/null'
+x cancel
+select_text
+x copy-pipe-and-cancel 'cat >/dev/null'
+wait_mode 0
+select_text
+x pipe-and-cancel 'cat >/dev/null'
+wait_mode 0
+
+# Commands which cancel on downward movement have separate handlers.
+fresh
+x history-bottom
+x bottom-line
+x cursor-down-and-cancel
+wait_mode 0
+fresh
+x history-bottom
+x halfpage-down-and-cancel
+wait_mode 0
+fresh
+x history-bottom
+x page-down-and-cancel
+wait_mode 0
+fresh
+x history-bottom
+x bottom-line
+x scroll-down-and-cancel
+wait_mode 0
+
+$TMUX has-session -t copy || fail "server died during copy-mode commands"
+exit 0

regress/copy-mode-selection-mode.sh

@@ -0,0 +1,81 @@
+#!/bin/sh
+
+# Changing an existing character selection to line mode must reset both ends
+# to complete lines, including when the cursor subsequently crosses the fixed
+# end. An invalid regular-expression search must also discard marks left by a
+# previous successful search.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+}
+trap cleanup 0 1 15
+
+$TMUX new-session -d -x30 -y6 \
+	"printf 'alpha\nbeta\ngamma\ndelta\n'; exec sleep 100" || exit 1
+$TMUX set-option -g window-size manual || exit 1
+sleep 1
+
+# A valid regular-expression search creates marks. Replacing it with an
+# invalid expression, growing the mode, and scrolling must not leave an old
+# mark array indexed with the new geometry (the original bug was an ASan heap
+# overflow in this sequence).
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X history-top || exit 1
+$TMUX send-keys -X search-forward beta || exit 1
+[ "$($TMUX display-message -p '#{search_present}')" = 1 ] ||
+	fail "successful search did not create marks"
+$TMUX send-keys -X search-forward '[' || exit 1
+$TMUX resize-window -x40 -y8 || exit 1
+$TMUX send-keys -X scroll-down || exit 1
+[ "$($TMUX display-message -p '#{search_present}')" = 0 ] ||
+	fail "invalid regular expression left stale marks after resize"
+$TMUX send-keys -X cancel || exit 1
+
+# Select part of alpha through part of beta, then change the existing
+# selection to line mode. Both lines, and no partial columns, must be copied.
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X history-top || exit 1
+$TMUX send-keys -N2 -X cursor-right || exit 1
+$TMUX send-keys -X begin-selection || exit 1
+$TMUX send-keys -X cursor-down || exit 1
+$TMUX send-keys -N2 -X cursor-right || exit 1
+$TMUX send-keys -X selection-mode line || exit 1
+[ "$($TMUX display-message -p '#{selection_mode}')" = line ] ||
+	fail "selection did not change to line mode"
+$TMUX send-keys -X copy-selection || exit 1
+expected=$(printf 'alpha\nbeta')
+[ "$($TMUX show-buffer)" = "$expected" ] ||
+	fail "line-mode selection did not expand to complete lines"
+
+# Start with the cursor above the fixed end so selection-mode itself takes the
+# reverse-direction path, then extend it through another line.
+$TMUX copy-mode || exit 1
+$TMUX send-keys -X history-top || exit 1
+$TMUX send-keys -N2 -X cursor-down || exit 1
+$TMUX send-keys -N2 -X cursor-right || exit 1
+$TMUX send-keys -X begin-selection || exit 1
+$TMUX send-keys -X cursor-up || exit 1
+$TMUX send-keys -N2 -X cursor-right || exit 1
+$TMUX send-keys -X selection-mode line || exit 1
+$TMUX send-keys -X cursor-up || exit 1
+$TMUX send-keys -X copy-selection || exit 1
+expected=$(printf 'alpha\nbeta\ngamma')
+[ "$($TMUX show-buffer)" = "$expected" ] ||
+	fail "reversed line-mode selection did not keep complete lines"
+
+exit 0

regress/display-panes.sh

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

regress/find-window.sh

@@ -0,0 +1,118 @@
+#!/bin/sh
+
+# Exercise find-window's content, name and title filters in every combination,
+# glob/regex and case-insensitive suffixes, plus zoom restoration.
+
+PATH=/bin:/usr/bin
+TERM=screen
+LC_ALL=C.UTF-8
+export PATH TERM LC_ALL
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+INNER="$TEST_TMUX -LtestI$$ -f/dev/null"
+OUTER="$TEST_TMUX -LtestO$$ -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$OUTER kill-server 2>/dev/null
+	$INNER kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+capture()
+{
+	$OUTER capture-pane -p -t outer:0.0 2>/dev/null
+}
+
+wait_mode()
+{
+	want=$1
+	i=0
+	while [ "$i" -lt 50 ]; do
+		got=$($INNER display-message -p -t find:base.0 '#{pane_mode}' 2>/dev/null)
+		[ "$got" = "$want" ] && return 0
+		sleep 0.1
+		i=$((i + 1))
+	done
+	fail "pane mode is '$got', expected '$want'"
+}
+
+run_find()
+{
+	label=$1
+	expected=$2
+	shift 2
+	$INNER find-window -t find:base.0 "$@" || fail "$label failed"
+	wait_mode tree-mode
+	i=0
+	while [ "$i" -lt 50 ]; do
+		captured=$(capture)
+		printf '%s\n' "$captured" | grep -Fq "$expected" && break
+		sleep 0.1
+		i=$((i + 1))
+	done
+	[ "$i" -lt 50 ] || fail "$label did not show '$expected'"
+	$INNER send-keys -t find:base.0 q || exit 1
+	wait_mode ''
+}
+
+$INNER new-session -d -s find -n base -x80 -y24 \
+	"sh -c 'printf \"BaseBody\\n\"; exec sleep 100'" || exit 1
+$INNER split-window -d -h -t find:base \
+	"sh -c 'printf \"OtherBody\\n\"; exec sleep 100'" || exit 1
+$INNER new-window -d -t find: -n NameNeedle 'exec sleep 100' || exit 1
+$INNER new-window -d -t find: -n body \
+	"sh -c 'printf \"BodyNeedle\\n\"; exec sleep 100'" || exit 1
+$INNER new-window -d -t find: -n titled 'exec sleep 100' || exit 1
+$INNER select-pane -t find:titled.0 -T TitleNeedle || exit 1
+$INNER set-option -g status off || exit 1
+$INNER set-option -g window-size manual || exit 1
+$OUTER new-session -d -s outer -x80 -y24 "$INNER attach -t find:base" || exit 1
+$OUTER set-option -g status off || exit 1
+$OUTER set-option -g window-size manual || exit 1
+sleep 1
+
+# Wait until the body text is in the pane history before searching it.
+i=0
+while [ "$i" -lt 50 ]; do
+	$INNER capture-pane -p -t find:body.0 | grep -Fq BodyNeedle && break
+	sleep 0.1
+	i=$((i + 1))
+done
+[ "$i" -lt 50 ] || fail "pane content was not ready"
+
+# No flags means C+N+T. Then cover all three pairs and all three singletons.
+run_find default NameNeedle NameNeedle
+run_find content-name NameNeedle -C -N NameNeedle
+run_find content-title titled -C -T TitleNeedle
+run_find name-title titled -N -T TitleNeedle
+run_find content-only body -C BodyNeedle
+run_find name-only NameNeedle -N NameNeedle
+run_find title-only titled -T TitleNeedle
+
+# Glob case folding and all regular-expression suffix variants.
+run_find insensitive NameNeedle -N -i nameneedle
+run_find regex NameNeedle -N -r '^NameNeedle$'
+run_find regex-insensitive NameNeedle -N -r -i '^nameneedle$'
+
+# -Z temporarily zooms the target window and restores its prior state on exit.
+$INNER find-window -Z -t find:base.0 -N NameNeedle || exit 1
+wait_mode tree-mode
+[ "$($INNER display-message -p -t find:base '#{window_zoomed_flag}')" = 1 ] ||
+	fail "find-window -Z did not zoom"
+$INNER send-keys -t find:base.0 q || exit 1
+wait_mode ''
+[ "$($INNER display-message -p -t find:base '#{window_zoomed_flag}')" = 0 ] ||
+	fail "find-window -Z did not restore zoom"
+
+exit 0

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

regress/floating-pane-zoom.sh

@@ -0,0 +1,158 @@
+#!/bin/sh
+
+# Moving, resizing and reordering an over-zoom float must leave the tiled
+# pane zoomed, and the changes must survive an explicit unzoom.
+
+PATH=/bin:/usr/bin
+TERM=screen
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+trap '$TMUX kill-server 2>/dev/null' 0
+trap 'exit 1' 1 2 15
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+run()
+{
+	$TMUX "$@" || fail "failed: $*"
+}
+
+check()
+{
+	got=$(run display-message -p -t "$1" "$2") || exit 1
+	[ "$got" = "$3" ] || fail "$1 $2: got '$got', expected '$3'"
+}
+
+check_zoom()
+{
+	check "$base" '#{window_zoomed_flag}:#{pane_zoomed_flag}' '1:1'
+	check "$float" '#{pane_floating_flag}:#{pane_active}' "1:$active"
+	check "$base" '#{@unzoomed}' ''
+}
+
+run new-session -d -x 80 -y 24
+base=$(run display-message -p '#{pane_id}') || exit 1
+other=$(run split-window -dPF '#{pane_id}') || exit 1
+layout=$(run display-message -p '#{window_layout}') || exit 1
+run set-hook -g window-unzoomed 'set -g @unzoomed 1'
+
+# Cover creation before and after zoom, with both the float and the tiled
+# pane active. Modal panes use the same over-zoom flag.
+for mode in before after detached modal; do
+	if [ "$mode" != before ]; then
+		run resize-pane -Z -t "$base"
+	fi
+	case "$mode" in
+	detached) flags=-Ad; active=0 ;;
+	modal) flags=-O; active=1 ;;
+	*) flags=-A; active=1 ;;
+	esac
+	float=$(run new-pane "$flags" -PF '#{pane_id}' -t "$base" \
+	    -x 20 -y 8 -X 8 -Y 3 '') || exit 1
+	if [ "$mode" = before ]; then
+		run resize-pane -Z -t "$base"
+	fi
+	run set -gu @unzoomed
+	check_zoom
+
+	run move-pane -t "$float" -D
+	check "$float" '#{pane_top}' 5
+	check_zoom
+	run move-pane -t "$float" -U 2 -R 3 -L 1
+	check "$float" '#{pane_left}:#{pane_top}' '11:3'
+	check_zoom
+	run move-pane -t "$float" -X 25% -Y 25%
+	check "$float" '#{pane_left}:#{pane_top}' '21:7'
+	check_zoom
+	run move-pane -t "$float" -P bottom-right
+	check "$float" '#{pane_left}:#{pane_top}' '61:17'
+	check_zoom
+	run resize-pane -t "$float" -x 30 -y 10
+	check "$float" '#{pane_width}:#{pane_height}' '28:8'
+	check_zoom
+	run resize-pane -t "$float" -U 1 -L 2
+	check "$float" '#{pane_left}:#{pane_top}:#{pane_width}:#{pane_height}' \
+	    '59:16:30:9'
+	check_zoom
+	run move-pane -t "$float" -P centre
+	check "$float" '#{pane_left}:#{pane_top}' '25:7'
+	check_zoom
+
+	# Failed commands must not change zoom either.
+	for command in 'move-pane -D invalid' 'move-pane -P invalid' \
+	    'move-pane -z invalid' 'resize-pane -x invalid' \
+	    'resize-pane -D invalid'; do
+		$TMUX $command -t "$float" 2>/dev/null &&
+		    fail "unexpected success: $command"
+		check_zoom
+	done
+
+	run resize-pane -Z -t "$base"
+	check "$float" '#{pane_left}:#{pane_top}:#{pane_width}:#{pane_height}' \
+	    '25:7:30:9'
+	run kill-pane -t "$float"
+	check "$base" '#{window_layout}' "$layout"
+done
+
+# Put an ordinary (hidden while zoomed) float between two over-zoom floats
+# in the stacking order. Reordering must skip it when counting visible
+# positions, but keep all floats ahead of the tiled panes after unzoom.
+back=$(run new-pane -AdPF '#{pane_id}' -t "$base" '') || exit 1
+hidden=$(run new-pane -dPF '#{pane_id}' -t "$base" '') || exit 1
+float=$(run new-pane -AdPF '#{pane_id}' -t "$base" '') || exit 1
+active=0
+run resize-pane -Z -t "$base"
+run set -gu @unzoomed
+
+for position in backward back forward-loop; do
+	run move-pane -t "$float" -P front
+	run move-pane -t "$float" -P "$position"
+	check "$float" '#{pane_z}' 1
+	check "$back" '#{pane_z}' 0
+	check_zoom
+done
+for position in forward front backward-loop; do
+	run move-pane -t "$float" -P back
+	run move-pane -t "$float" -P "$position"
+	check "$float" '#{pane_z}' 0
+	check "$back" '#{pane_z}' 1
+	check_zoom
+done
+for z in 1 0 99; do
+	run move-pane -t "$float" -z "$z"
+	want=$z
+	[ "$z" = 99 ] && want=1
+	check "$float" '#{pane_z}' "$want"
+	check_zoom
+done
+run resize-pane -Z -t "$base"
+check "$float" '#{pane_z}' 2
+check "$base" '#{pane_z}' 4
+run kill-pane -t "$hidden"
+run kill-pane -t "$back"
+
+# Explicit zoom toggling and operations on tiled panes retain their
+# existing behaviour. The over-zoom flag alone does not make a pane a float:
+# zooming the float itself gives it a tiled cell until unzoom.
+run resize-pane -Z -t "$float"
+check "$float" '#{pane_zoomed_flag}:#{pane_floating_flag}' '1:0'
+run resize-pane -t "$float" -x 25
+check "$float" '#{window_zoomed_flag}:#{pane_floating_flag}:#{pane_width}' \
+    '0:1:23'
+run resize-pane -Z -t "$base"
+run resize-pane -t "$other" -D 1
+check "$base" '#{window_zoomed_flag}' 0
+
+# A hidden ordinary float must still be unzoomed before resizing it.
+hidden=$(run new-pane -dPF '#{pane_id}' -t "$base" '') || exit 1
+run resize-pane -Z -t "$base"
+run resize-pane -t "$hidden" -x 25
+check "$hidden" '#{window_zoomed_flag}:#{pane_floating_flag}:#{pane_width}' \
+    '0:1:23'
+
+exit 0

regress/format-fuzzy.sh

@@ -7,6 +7,8 @@ TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
 TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+trap '$TMUX kill-server 2>/dev/null' 0
+trap 'exit 1' 1 2 15
 
 # test_format $format $expected_result
 test_format()

regress/format-modifiers.sh

@@ -18,6 +18,24 @@ export TZ LANG LC_ALL
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
 TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+FIFO1="${TMPDIR:-/tmp}/fmt-l-$$-1"
+FIFO2="${TMPDIR:-/tmp}/fmt-l-$$-2"
+HOLD1=
+HOLD2=
+CC1=
+CC2=
+
+cleanup()
+{
+	for pid in $HOLD1 $HOLD2 $CC1 $CC2; do
+		kill "$pid" 2>/dev/null
+		wait "$pid" 2>/dev/null
+	done
+	$TMUX kill-server 2>/dev/null
+	rm -f "$FIFO1" "$FIFO2"
+}
+trap cleanup 0
+trap 'exit 1' 1 2 15
 
 ESC=$(printf '\033')
 
@@ -579,8 +597,6 @@ assert_alive "verbose loop expansion"
 
 # L loops over attached clients.  Attach two control-mode clients, each held
 # open by a background process keeping a FIFO's write end open.
-FIFO1="${TMPDIR:-/tmp}/fmt-l-$$-1"
-FIFO2="${TMPDIR:-/tmp}/fmt-l-$$-2"
 rm -f "$FIFO1" "$FIFO2"
 mkfifo "$FIFO1" "$FIFO2" || exit 1
 # Hold the write ends open so the control clients stay attached.
@@ -605,9 +621,9 @@ test_format "#{L/nr:x}" "xx"
 test_format "#{L/r:x}" "xx"
 # Now detach one and confirm the count drops to one.
 kill $HOLD2 2>/dev/null
+wait $HOLD2 2>/dev/null
+HOLD2=
 sleep 1
 test_format "#{L:x}" "x"
-kill $HOLD1 $CC1 $CC2 2>/dev/null
-rm -f "$FIFO1" "$FIFO2"
 
 exit 0

regress/format-strings.sh

@@ -7,6 +7,8 @@ TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
 TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
+trap '$TMUX kill-server 2>/dev/null' 0
+trap 'exit 1' 1 2 15
 
 # test_format $format $expected_result
 test_format()

regress/format-variables.sh

@@ -71,7 +71,10 @@ cursor_very_visible
 cursor_x
 cursor_y
 history_all_bytes
+history_added
 history_bytes
+history_collected
+history_generation
 history_limit
 history_size
 host
@@ -103,6 +106,11 @@ pane_at_right
 pane_at_top
 pane_bg
 pane_bottom
+pane_command_duration
+pane_command_end_time
+pane_command_running
+pane_command_start_time
+pane_command_status
 pane_current_command
 pane_current_path
 pane_dead
@@ -120,16 +128,21 @@ pane_index
 pane_input_off
 pane_key_mode
 pane_last
+pane_last_output_time
+pane_last_prompt_time
 pane_left
 pane_marked
 pane_marked_set
+pane_modal_flag
 pane_mode
+pane_output_generation
 pane_path
 pane_pb_progress
 pane_pb_state
 pane_pid
 pane_pipe
 pane_pipe_pid
+pane_private_modes
 pane_right
 pane_search_string
 pane_start_command
@@ -141,6 +154,8 @@ pane_title
 pane_top
 pane_tty
 pane_unseen_changes
+pane_unzoomed_height
+pane_unzoomed_width
 pane_width
 pane_x
 pane_y
@@ -206,7 +221,10 @@ window_layout
 window_linked
 window_linked_sessions
 window_linked_sessions_list
+window_manual_height
+window_manual_width
 window_marked_flag
+window_modal_pane
 window_name
 window_offset_x
 window_offset_y

regress/hooks-lifecycle.sh

@@ -76,14 +76,14 @@ $TMUX set-hook -g session-closed \
 	fail "set-hook session-closed failed"
 
 # The only pane of the only window of a session exits: pane-exited, then
-# window-unlinked, then session-closed, each seeing the dead object in the
+# session-closed, then window-unlinked, each seeing the dead object in the
 # hook formats.
 pane=$($TMUX new -d -s doomed -n dwin -P -F '#{pane_id}' 'true') ||
 	fail "new-session doomed failed"
 wait_for @log \
-	"|pane-exited:$pane|window-unlinked:doomed:dwin|session-closed:doomed"
+	"|pane-exited:$pane|session-closed:doomed|window-unlinked:doomed:dwin"
 assert_unchanged @log \
-	"|pane-exited:$pane|window-unlinked:doomed:dwin|session-closed:doomed"
+	"|pane-exited:$pane|session-closed:doomed|window-unlinked:doomed:dwin"
 
 # The dead pane, window and session cannot be used as targets but the
 # server survives.
@@ -110,14 +110,14 @@ $TMUX set-hook -g pane-exited \
 	'set -gF @log "#{@log}|pane-exited:#{hook_pane}"' ||
 	fail "restore pane-exited hook failed"
 
-# kill-window on the last window: window-unlinked then session-closed but
+# kill-window on the last window: session-closed then window-unlinked but
 # no pane-exited for the panes in the killed window.
 $TMUX set -g @log '' || fail "reset @log failed"
 $TMUX new -d -s doomed2 -n dwin2 || fail "new-session doomed2 failed"
 $TMUX splitw -d -t doomed2:0 || fail "split-window doomed2 failed"
 $TMUX kill-window -t doomed2:0 || fail "kill-window failed"
-wait_for @log '|window-unlinked:doomed2:dwin2|session-closed:doomed2'
+wait_for @log '|session-closed:doomed2|window-unlinked:doomed2:dwin2'
-assert_unchanged @log '|window-unlinked:doomed2:dwin2|session-closed:doomed2'
+assert_unchanged @log '|session-closed:doomed2|window-unlinked:doomed2:dwin2'
 $TMUX has -t main || fail "server died after kill-window chain"
 
 # kill-session: session-closed fires first, then window-unlinked for its

regress/hooks-notify.sh

@@ -218,11 +218,13 @@ $TMUX set-hook -gu pane-mode-changed || fail "unset pane-mode-changed failed"
 
 # pane-exited when a pane's command exits with remain-on-exit off.
 $TMUX set -g @x 0 || fail "set @x failed"
-$TMUX set-hook -g pane-exited 'set -gF @x "#{hook}:#{hook_pane}"' ||
+$TMUX set-hook -g pane-exited \
+	'set -gF @x "#{hook}:#{hook_pane}:#{hook_exit_status}:#{hook_exit_success}"' ||
 	fail "set-hook pane-exited failed"
-pane=$($TMUX splitw -d -t main:0 -P -F '#{pane_id}' 'true') ||
+pane=$($TMUX splitw -d -t main:0 -P -F '#{pane_id}' \
-	fail "split-window true failed"
+	'trap "" HUP; exec </dev/null >/dev/null 2>&1; sleep 1; exit 42') ||
-wait_for @x "pane-exited:$pane"
+	fail "split-window exit 42 failed"
+wait_for @x "pane-exited:$pane:42:0"
 $TMUX set-hook -gu pane-exited || fail "unset pane-exited failed"
 
 # pane-died when a pane's command exits with remain-on-exit on.

regress/if-shell-error.sh

@@ -7,35 +7,25 @@ PATH=/bin:/usr/bin
 TERM=screen
 
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
-SOCKET=$(mktemp -u testAXXXXXX)
+TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
-TMUX="$TEST_TMUX -L$SOCKET -f/dev/null"
 $TMUX kill-server 2>/dev/null
 
 TMP=$(mktemp)
 OUT=$(mktemp)
-cleanup() {
+trap 'rm -f "$TMP" "$OUT"; $TMUX kill-server 2>/dev/null' 0
-	$TMUX kill-server 2>/dev/null
+trap 'exit 1' 1 2 15
-	rm -f "$TMP" "$OUT"
-}
-trap cleanup 0 1 15
 
-cat <<EOF >"$TMP"
+cat <<EOF >$TMP
 if 'true' 'wibble wobble'
 EOF
 
-$TMUX -f"$TMP" -C new <<EOF >"$OUT"
+$TMUX -f$TMP -C new <<EOF >$OUT
 EOF
-if ! grep -q "^%config-error $TMP:1: unknown command: wibble$" "$OUT"; then
+grep -q "^%config-error $TMP:1: $TMP:1: unknown command: wibble$" $OUT
-	cat "$OUT" >&2
-	exit 1
-fi
 
-cat <<EOF >"$TMP"
+cat <<EOF >$TMP
 wibble wobble
 EOF
 
-echo "source $TMP" | $TMUX -C new  >"$OUT"
+echo "source $TMP" | $TMUX -C new  >$OUT
-if ! grep -q "^%config-error $TMP:1: unknown command: wibble$" "$OUT"; then
+grep -q "^%config-error $TMP:1: unknown command: wibble$" $OUT
-	cat "$OUT" >&2
-	exit 1
-fi

regress/input-common.inc

@@ -4,6 +4,9 @@ TERM=screen
 [ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
 TMUX="$TEST_TMUX -LtestA$$ -f/dev/null"
 
+# Keep panes alive until the next case or cleanup, without reading replies.
+INPUT_HOLD='while :; do sleep 3600; done'
+
 TMP=$(mktemp)
 EXP=$(mktemp)
 trap 'rm -f "$TMP" "$EXP"; $TMUX kill-server 2>/dev/null' 0 1 15
@@ -37,10 +40,10 @@ start_pane_hlimit()
 
 	$TMUX kill-server 2>/dev/null
 	sleep 0.1
-	$TMUX new-session -d -x 1 -y 1 -s test-setup "sleep 2" || exit 1
+	$TMUX new-session -d -x 1 -y 1 -s test-setup "$INPUT_HOLD" || exit 1
 	$TMUX set-option -g history-limit "$hlimit" || exit 1
 	$TMUX new-session -d -x "$sx" -y "$sy" -s "$name" \
-	    "printf '$seq'; sleep 2" || exit 1
+	    "printf '$seq'; $INPUT_HOLD" || exit 1
 	$TMUX kill-session -t test-setup
 	sleep 0.3
 }

regress/input-keys.sh

@@ -22,7 +22,19 @@ assert_key () {
 	      clear-history -t$W \; \
 	      send-keys -t$W "$key" 'EOL' || exit 1
 
-	actual_code=$($TMUX capturep -pt$W | \
+	# cat echoes the keys back asynchronously, so wait for the EOL marker
+	# to reach the pane instead of capturing straight away.
+	i=0
+	while [ $i -lt 50 ]; do
+		screen=$($TMUX capturep -pt$W)
+		case "$screen" in
+		*EOL*) break ;;
+		esac
+		i=$((i + 1))
+		sleep 0.1
+	done
+
+	actual_code=$(printf '%s\n' "$screen" | \
 			      head -1 | \
 			      sed -e 's/EOL.*$//')
 

regress/input-malformed.sh

@@ -2,6 +2,38 @@
 
 . ./input-common.inc
 
+# Wait for the terminator and following text to reach the parser.
+check_discard()
+{
+	name=$1
+	printf 'OK\n' >"$EXP"
+	i=0
+	while [ "$i" -lt 300 ]; do
+		capture_grid "$name" >"$TMP"
+		cmp -s "$TMP" "$EXP" && return 0
+		sleep 0.05
+		i=$((i + 1))
+	done
+	fail "$name (timed out waiting for discard)"
+}
+
+# The missing-terminator timer may expire before the string limit is reached
+# on a slow build. Clear any payload printed after the timeout, then check
+# that the string did not change the title and normal output has resumed.
+test_discard()
+{
+	name=$1
+	prefix=$2
+	start_cmd "$name" 8 3 "$INPUT_HOLD"
+	$TMUX select-pane -T discard-test || exit 1
+	$TMUX respawn-pane -k \
+	    "perl -e 'print qq{$prefix}, q{x} x 1100000, qq{\e\\\\\e[H\e[2JOK}'; $INPUT_HOLD" || exit 1
+	check_discard "$name"
+	$TMUX display-message -p -t "$name:" '#{pane_title}' >"$TMP" || exit 1
+	printf 'discard-test\n' >"$EXP"
+	cmp "$TMP" "$EXP" || fail "$name title"
+}
+
 start_cmd csi-param-discard 8 3 \
     "perl -e 'print qq{\e[}, q{1} x 80, qq{\030OK}'; sleep 2"
 check_capture csi-param-discard 'OK'
@@ -10,13 +42,8 @@ start_cmd csi-interm-discard 8 3 \
     "perl -e 'print qq{\e[    \030OK}'; sleep 2"
 check_capture csi-interm-discard 'OK'
 
-start_cmd osc-discard 8 3 \
+test_discard osc-discard '\e]2;'
-    "perl -e 'print qq{\e]2;}, q{x} x 1100000, qq{\e\\\\OK}'; sleep 2"
+test_discard apc-discard '\e_'
-check_capture osc-discard 'OK'
-
-start_cmd apc-discard 8 3 \
-    "perl -e 'print qq{\e_}, q{x} x 1100000, qq{\e\\\\OK}'; sleep 2"
-check_capture apc-discard 'OK'
 
 start_pane unknown-csi 8 3 '\033[?9999zOK'
 check_capture unknown-csi 'OK'

regress/input-scroll.sh

@@ -51,7 +51,7 @@ $TMUX kill-server 2>/dev/null
 sleep 0.1
 $TMUX new-session -d -x 5 -y 3 -s history \; \
     set-option -g history-limit 3 \; \
-    respawn-pane -k "printf '01\n02\n03\n04\n05\n06'; sleep 2" || exit 1
+    respawn-pane -k "printf '01\n02\n03\n04\n05\n06'; $INPUT_HOLD" || exit 1
 sleep 0.3
 $TMUX capture-pane -pN -t history: -S - -E - | normalize_capture >"$TMP"
 printf "%s\n" '01

regress/json.sh

@@ -0,0 +1,137 @@
+#!/bin/sh
+
+# Test parsing and printing JSON with display-message -j.
+
+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
+
+fail()
+{
+	echo "$1"
+	$TMUX kill-server 2>/dev/null
+	exit 1
+}
+
+check()
+{
+	actual=$($TMUX display-message -plj "$1" 2>&1) ||
+	    fail "JSON was rejected: $1: $actual"
+	[ "$actual" = "$2" ] ||
+	    fail "JSON output mismatch: $1: expected $2, got $actual"
+}
+
+check_fail()
+{
+	if $TMUX display-message -plj "$1" >/dev/null 2>&1; then
+		fail "invalid JSON was accepted: $1"
+	fi
+}
+
+$TMUX new-session -d || exit 1
+
+check '{}' '{}'
+check ' { "z":true, "a":-9223372036854775808, "m":[{}, {"x":false}] } ' \
+    '{"a":-9223372036854775808,"m":[{},{"x":false}],"z":true}'
+check '{"max":9223372036854775807,"min":-9223372036854775808}' \
+    '{"max":9223372036854775807,"min":-9223372036854775808}'
+check '{" key":" value","{key":"[value"}' \
+    '{" key":" value","{key":"[value"}'
+check '{"brace":"{value","bracket":"[value","colon":":value",'\
+'"comma":",value","space":" value"}' \
+    '{"brace":"{value","bracket":"[value","colon":":value",'\
+'"comma":",value","space":" value"}'
+check '{"esc":"\"\\\/\b\f\n\r\t\u0041"}' \
+    '{"esc":"\"\\\/\b\f\n\r\t\u0041"}'
+check '{"unicode":"\u0123\uabcd\uABCD"}' \
+    '{"unicode":"\u0123\uabcd\uABCD"}'
+
+actual=$($TMUX display-message -palj '{}' 2>&1) ||
+    fail "display-message -aj rejected JSON: $actual"
+[ "$actual" = '{}' ] ||
+    fail "display-message -aj did not ignore -a: got $actual"
+actual=$($TMUX display-message -pIlj '{}' 2>&1) ||
+    fail "display-message -Ij rejected JSON: $actual"
+[ "$actual" = '{}' ] ||
+    fail "display-message -Ij did not ignore -I: got $actual"
+
+check_fail ''
+check_fail '   '
+check_fail '[]'
+check_fail 'true'
+check_fail '1'
+check_fail '"string"'
+check_fail '{}{}'
+
+check_fail '{'
+check_fail '{x:1}'
+check_fail '{"":1}'
+check_fail '{"x" 1}'
+check_fail '{"x",1}'
+check_fail '{"x":}'
+check_fail '{"x":,}'
+check_fail '{"x":1'
+check_fail '{"x":1 "y":2}'
+check_fail '{"x":1,,"y":2}'
+check_fail '{"x":1,}'
+check_fail '{"x":1,"x":2}'
+check_fail '{"x":{}}{}'
+check_fail '{"x":{}} trailing'
+check_fail '{"x":{'
+check_fail '{"x":{}'
+
+check_fail '{"x":['
+check_fail '{"x":[}'
+check_fail '{"x":[{}'
+check_fail '{"x":[{},}'
+check_fail '{"x":[{},]}'
+check_fail '{"x":[{}{}]}'
+check_fail '{"x":[{},,{}]}'
+check_fail '{"x":[{"y":}]}'
+check_fail '{"x":""}'
+check_fail '{"x":null}'
+check_fail '{"x":[null]}'
+check_fail '{"x":[true]}'
+check_fail '{"x":["string"]}'
+check_fail '{"x":[[]]}'
+check_fail '{"x":1.0}'
+check_fail '{"x":1e2}'
+check_fail '{"x":+1}'
+check_fail '{"x":-}'
+check_fail '{"x":0x10}'
+check_fail '{"x":01}'
+check_fail '{"x":-01}'
+check_fail '{"x":[1]}'
+check_fail '{"x":9223372036854775808}'
+check_fail '{"x":-9223372036854775809}'
+check_fail '{"x":tru}'
+check_fail '{"x":True}'
+check_fail '{"x":falsee}'
+check_fail '{"x":"bad\q"}'
+check_fail '{"x":"bad\x20"}'
+check_fail '{"x":"bad\u123"}'
+check_fail '{"x":"bad\u12x4"}'
+check_fail '{"x":"unterminated}'
+check_fail '{"x":"escaped quote\"}'
+check_fail '{"x":"line
+break"}'
+
+# The maximum object nesting depth is 200.
+json='{}'
+n=1
+while [ "$n" -lt 200 ]; do
+	json='{"x":'"$json"'}'
+	n=$((n + 1))
+done
+check "$json" "$json"
+check_fail '{"x":'"$json"'}'
+
+if $TMUX display-message -pj >/dev/null 2>&1; then
+	fail "display-message -j accepted a missing message"
+fi
+
+$TMUX kill-server 2>/dev/null
+exit 0

regress/kill-session-zoomed.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+# Killing a session whose window is zoomed must not crash the server:
+# window_destroy used to unzoom the window, which resized the panes and
+# fired pane-resized with the window in the payload, and releasing that
+# reference destroyed the window a second time.
+
+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 -f/dev/null new -d -sfoo || exit 1
+$TMUX split-window -d -h -tfoo:0 || exit 1
+$TMUX resize-pane -Z -tfoo:0 || exit 1
+$TMUX new -d -sbar || exit 1
+$TMUX kill-session -tfoo || exit 1
+$TMUX has-session -tbar || exit 1
+
+# The same with the zoomed window in a session killed by kill-server.
+$TMUX new -d -sbaz || exit 1
+$TMUX split-window -d -v -tbaz:0 || exit 1
+$TMUX resize-pane -Z -tbaz:0 || exit 1
+$TMUX kill-server || exit 1
+
+exit 0

regress/layout-nesting-limit.sh

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+# Version 1 layouts must reject excessive nesting without losing the session or
+# changing its layout. Check both split types and the depth limit boundary.
+
+PATH=/bin:/usr/bin
+TERM=screen
+export PATH TERM
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX="$TEST_TMUX -S$DIR/socket -f/dev/null"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0
+trap 'exit 1' 1 2 15
+
+# Generate a checksum-valid v1 layout with one child in every nested group.
+layout()
+{
+	awk -v depth="$1" -v open="$2" 'BEGIN {
+		closing = (open == "{" ? "}" : "]")
+		body = ""
+		for (i = 0; i < depth; i++)
+			body = body "1x1,0,0" open
+		body = body "1x1,0,0"
+		for (i = 0; i < depth; i++)
+			body = body closing
+
+		ord["0"] = 48; ord["1"] = 49; ord["x"] = 120
+		ord[","] = 44; ord["{"] = 123; ord["}"] = 125
+		ord["["] = 91; ord["]"] = 93
+		csum = 0
+		for (i = 1; i <= length(body); i++) {
+			c = substr(body, i, 1)
+			bit = csum % 2
+			csum = int(csum / 2) + bit * 32768
+			csum = (csum + ord[c]) % 65536
+		}
+		printf "%04x,%s", csum, body
+	}'
+}
+
+$TMUX new-session -d -s deep -x80 -y24 'exec sleep 100' || exit 1
+
+for open in '{' '['; do
+	# A valid checksum and nesting up to the limit must still be accepted.
+	value=$(layout 1000 "$open") || fail "could not generate layout"
+	$TMUX select-layout -t deep "$value" ||
+		fail "layout at the depth limit was rejected ($open)"
+	before=$($TMUX display-message -p -t deep \
+	    '#{pane_id} #{pane_width} #{pane_height} #{window_layout}') || exit 1
+
+	for depth in 1001 1500; do
+		value=$(layout "$depth" "$open") || fail "could not generate layout"
+		$TMUX select-layout -t deep "$value" >/dev/null 2>&1 &&
+			fail "excessive nesting was accepted ($open, $depth)"
+		$TMUX has-session -t deep ||
+			fail "server died on excessive nesting ($open, $depth)"
+		after=$($TMUX display-message -p -t deep \
+		    '#{pane_id} #{pane_width} #{pane_height} #{window_layout}') || exit 1
+		[ "$before" = "$after" ] ||
+			fail "pane or layout changed after rejection ($open, $depth)"
+	done
+done
+
+exit 0

regress/layout-set.sh

@@ -0,0 +1,126 @@
+#!/bin/sh
+
+# Exercise every predefined layout, next/previous cycling, lookup and restore
+# paths, one-pane early returns, minimum-size handling and floating panes.
+
+PATH=/bin:/usr/bin
+TERM=screen
+export PATH TERM
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+TMUX="$TEST_TMUX -Ltest$$ -f/dev/null"
+SEEN="$DIR/layouts"
+
+fail()
+{
+	echo "$*" >&2
+	exit 1
+}
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+layout()
+{
+	$TMUX display-message -p -t layouts:many '#{window_layout}'
+}
+
+check_layout()
+{
+	name=$1
+	$TMUX select-layout -t layouts:many "$name" ||
+		fail "select-layout $name failed"
+	value=$(layout)
+	[ -n "$value" ] || fail "$name produced an empty layout"
+	if grep -Fxq "$value" "$SEEN"; then
+		fail "$name produced the same layout as an earlier preset"
+	fi
+	printf '%s\n' "$value" >>"$SEEN"
+	[ "$($TMUX list-panes -t layouts:many -F x | wc -l)" -eq 5 ] ||
+		fail "$name lost a pane"
+	[ "$($TMUX list-panes -t layouts:many -F '#{pane_floating_flag}' | \
+	    grep -c '^1$')" -eq 1 ] || fail "$name did not preserve the floating pane"
+}
+
+$TMUX new-session -d -s layouts -n many -x100 -y40 'exec sleep 100' || exit 1
+$TMUX set-option -g window-size manual || exit 1
+$TMUX split-window -d -h -t layouts:many 'exec sleep 100' || exit 1
+$TMUX split-window -d -v -t layouts:many 'exec sleep 100' || exit 1
+$TMUX split-window -d -h -t layouts:many 'exec sleep 100' || exit 1
+floating=$($TMUX new-pane -dP -F '#{pane_id}' -t layouts:many \
+    -x20 -y8 -X10 -Y5 'exec sleep 100') || exit 1
+: >"$SEEN"
+
+# Options exercise percentage and explicit secondary-size calculations.
+$TMUX set-option -w -t layouts:many main-pane-height 30% || exit 1
+$TMUX set-option -w -t layouts:many other-pane-height 12 || exit 1
+$TMUX set-option -w -t layouts:many main-pane-width 35% || exit 1
+$TMUX set-option -w -t layouts:many other-pane-width 20 || exit 1
+
+for name in even-horizontal even-vertical main-horizontal \
+    main-horizontal-mirrored main-vertical main-vertical-mirrored tiled; do
+	check_layout "$name"
+done
+
+# Exact and unique-prefix lookup work; ambiguous and invalid names fail.
+$TMUX select-layout -t layouts:many even-h || fail "unique layout prefix failed"
+$TMUX select-layout -t layouts:many main >/dev/null 2>&1 &&
+	fail "ambiguous layout prefix succeeded"
+$TMUX select-layout -t layouts:many no-such-layout >/dev/null 2>&1 &&
+	fail "invalid layout name succeeded"
+
+# Cycle through all layouts in both directions, including wraparound. The
+# aliases and select-layout flags share layout_set_next/previous.
+first=$(layout)
+i=0
+while [ "$i" -lt 7 ]; do
+	$TMUX next-layout -t layouts:many || exit 1
+	i=$((i + 1))
+done
+[ "$(layout)" = "$first" ] || fail "next-layout did not wrap"
+i=0
+while [ "$i" -lt 7 ]; do
+	$TMUX previous-layout -t layouts:many || exit 1
+	i=$((i + 1))
+done
+[ "$(layout)" = "$first" ] || fail "previous-layout did not wrap"
+$TMUX select-layout -t layouts:many -n || exit 1
+$TMUX select-layout -t layouts:many -p || exit 1
+
+# No argument reapplies the last preset; -o restores the previous layout; -E
+# spreads the current cell without changing the pane set.
+$TMUX kill-pane -t "$floating" || exit 1
+$TMUX select-layout -t layouts:many tiled || exit 1
+tiled=$(layout)
+$TMUX select-layout -t layouts:many even-horizontal || exit 1
+$TMUX select-layout -t layouts:many -o || exit 1
+[ "$(layout)" = "$tiled" ] || fail "select-layout -o did not restore layout"
+$TMUX select-layout -t layouts:many || exit 1
+$TMUX select-layout -t layouts:many -E || exit 1
+
+# Each arranger has a deliberate one-pane early return.
+$TMUX new-window -d -t layouts: -n one 'exec sleep 100' || exit 1
+one=$($TMUX display-message -p -t layouts:one '#{window_layout}')
+for name in even-horizontal even-vertical main-horizontal \
+    main-horizontal-mirrored main-vertical main-vertical-mirrored tiled; do
+	$TMUX select-layout -t layouts:one "$name" || exit 1
+	[ "$($TMUX display-message -p -t layouts:one '#{window_layout}')" = "$one" ] ||
+		fail "$name changed a one-pane layout"
+done
+
+# Force the minimum-size paths without requiring a terminal client.
+$TMUX resize-window -t layouts:many -x10 -y6 || exit 1
+for name in even-horizontal even-vertical main-horizontal \
+    main-horizontal-mirrored main-vertical main-vertical-mirrored tiled; do
+	$TMUX select-layout -t layouts:many "$name" || exit 1
+done
+
+$TMUX has-session -t layouts || fail "server died during layout tests"
+exit 0

regress/list-commands.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# Exercise list-commands for the full table, a single command, aliases, custom
+# and empty formats, and lookup errors.
+
+PATH=/bin:/usr/bin
+TERM=screen
+export PATH TERM
+
+[ -z "$TEST_TMUX" ] && TEST_TMUX=$(readlink -f ../tmux)
+DIR=$(mktemp -d) || exit 1
+TMUX_TMPDIR=$DIR
+export TMUX_TMPDIR
+TMUX="$TEST_TMUX -Ltest$$ -f/dev/null"
+
+cleanup()
+{
+	$TMUX kill-server 2>/dev/null
+	rm -rf "$DIR"
+}
+trap cleanup 0 1 15
+
+# Keep a server alive across commands. Otherwise a STARTSERVER-only command
+# may exit between invocations and leave a short socket-cleanup race.
+$TMUX new-session -d -s list-commands 'exec sleep 100' || exit 1
+
+all=$($TMUX list-commands) || exit 1
+printf '%s\n' "$all" | grep -q '^attach-session (attach)' || exit 1
+printf '%s\n' "$all" | grep -q '^list-commands (lscm)' || exit 1
+
+one=$($TMUX list-commands -F \
+    '#{command_list_name}|#{command_list_alias}|#{command_list_usage}' \
+    list-commands) || exit 1
+case "$one" in
+'list-commands|lscm|'*) ;;
+*) exit 1 ;;
+esac
+
+# Aliases resolve to their command, while an empty expansion prints no line.
+[ "$($TMUX list-commands -F '#{command_list_name}' lscm)" = list-commands ] ||
+	exit 1
+[ -z "$($TMUX list-commands -F '' list-commands)" ] || exit 1
+
+$TMUX list-commands tmux-no-command-$$ >/dev/null 2>&1 && exit 1
+$TMUX list-commands list >/dev/null 2>&1 && exit 1
+exit 0

regress/modal-pane.sh

@@ -337,9 +337,9 @@ $TMUX set -g @modal-prefix no
 $TMUX set -g @modal-root no
 $TMUX bind -n z set -g @modal-root yes
 
-modal=$($TMUX new-pane -OKPF '#{pane_id}' -t "$p0" \
+modal=$($TMUX new-pane -ODKPF '#{pane_id}' -t "$p0" \
     -x 20 -y 5 -X 20 -Y 10 'cat') ||
-	fail "new-pane -OK failed"
+	fail "new-pane -ODK failed"
 sleep 1
 $TMUX2 send-keys -t "$OUTER" C-b x z Enter
 sleep 1
@@ -356,9 +356,50 @@ new_left=$(fmt "$modal" '#{pane_left}')
 new_top=$(fmt "$modal" '#{pane_top}')
 [ "$new_left" -gt "$left" ] || [ "$new_top" -gt "$top" ] ||
 	fail "key-capturing modal pane did not move"
+$TMUX2 send-keys -t "$OUTER" Escape
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+modal=$($TMUX new-pane -ODKPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'trap "" INT; exec cat') ||
+	fail "new-pane -ODK failed"
+sleep 1
+$TMUX2 send-keys -t "$OUTER" C-c
+sleep 1
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+# A dead modal does not close on Escape or C-c without -D.
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit on
+sleep 2
+must_equal "$(fmt "$modal" '#{pane_dead}:#{pane_modal_flag}')" 1:1
+$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
 
+# failed-key closes successful panes and retains failed panes until a key.
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit failed-key
+sleep 2
+must_equal "$(fmt modal:0 '#{window_modal_pane}')" ''
+
+modal=$($TMUX new-pane -OPF '#{pane_id}' -t "$p0" \
+    -x 20 -y 5 -X 20 -Y 10 'sleep 1; exit 1') ||
+	fail "new-pane -O failed"
+check_ok set-option -p -t "$modal" remain-on-exit failed-key
+sleep 2
+must_equal "$(fmt "$modal" '#{pane_dead}:#{pane_modal_flag}')" 1: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}')" ''
+
 # 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'

regress/pane-ops.sh

@@ -104,6 +104,25 @@ assert_alive()
 	fi
 }
 
+# Compare layout geometry and pane ordering, ignoring the active pane and
+# last-pane history in the JSON layout. Selection is checked separately.
+pane_layout()
+{
+	$TMUX display-message -p -t "$1" '#{window_layout}' |
+		sed 's/,"a":true//g; s/,"l":[0-9][0-9]*//g'
+}
+
+check_layout()
+{
+	out=$(pane_layout "$1")
+	if [ "$out" != "$2" ]; then
+		echo "Layout for '$1' wrong."
+		echo "Expected: '$2'"
+		echo "But got:  '$out'"
+		exit 1
+	fi
+}
+
 # ---------------------------------------------------------------------------
 # split-window geometry.
 
@@ -309,12 +328,12 @@ check_ok kill-pane -t "$p6"
 
 # Zoom and unzoom preserve the exact tiled layout. Selecting another pane
 # without -Z unzooms, while -Z transfers zoom to the selected pane.
-layout=$($TMUX display-message -p -t P:0 '#{window_layout}')
+layout=$(pane_layout P:0)
 check_ok select-pane -t "$p0"
 check_ok resize-pane -Z -t "$p0"
 check_ok select-pane -t "$p2"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_active}' '0:1'
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"
 
 check_ok select-pane -t "$p0"
 check_ok resize-pane -Z -t "$p0"
@@ -322,7 +341,7 @@ check_ok select-pane -Z -t "$p2"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p2"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"
 
 # Directional selection temporarily restores the full layout to find its
 # neighbour, then follows the same unzoom or -Z transfer rules.
@@ -340,7 +359,7 @@ check_ok select-pane -D -Z -t "$p0"
 check_fmt "$p2" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p2"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"
 
 # The last-pane path has separate zoom handling, both with and without -Z.
 check_ok select-pane -t "$p0"
@@ -357,7 +376,7 @@ check_ok select-pane -l -Z -t P:0
 check_fmt "$p0" '#{window_zoomed_flag}:#{pane_zoomed_flag}:#{pane_active}' \
 	'1:1:1'
 check_ok resize-pane -Z -t "$p0"
-check_fmt P:0 '#{window_layout}' "$layout"
+check_layout P:0 "$layout"
 
 # Killing either a hidden ordinary pane or the zoom target unzooms.
 check_ok new-window -d -t P:12 -n zoom-kill 'cat'

regress/prompt-keys.sh

@@ -217,7 +217,36 @@ $OUT send-keys M-r || exit 1
 settle
 status_line | grep -q '>' || fail "status-line prompt not drawn on the status line"
 
-# --- 11. emacs cursor-marker edit, accept recovers the exact buffer. ---
+# --- 11. Invalid UTF-8 input must not desynchronize the prompt buffer. ---
+$OUT send-keys -H e6 85 5f || exit 1	# invalid UTF-8, then "_"
+settle
+$IN display-message -p '#{version}' >/dev/null 2>&1 || \
+	fail "invalid UTF-8 append killed inner tmux"
+status_line | grep -qF "> _" || \
+	fail "invalid UTF-8 append did not keep prompt usable (got '$(status_line)')"
+$OUT send-keys Enter || exit 1
+settle
+[ "$($IN show -gv @r)" = "_" ] || \
+	fail "invalid UTF-8 append recovered '$($IN show -gv @r)', wanted '_'"
+
+$IN set -g @r "SENTINEL" || exit 1
+$OUT send-keys M-r || exit 1
+settle
+$OUT send-keys -H e6 85 04 || exit 1	# invalid UTF-8, then C-d
+settle
+$IN display-message -p '#{version}' >/dev/null 2>&1 || \
+	fail "invalid UTF-8 delete killed inner tmux"
+status_line | grep -q '>' || \
+	fail "invalid UTF-8 delete closed the prompt (got '$(status_line)')"
+$OUT send-keys Escape || exit 1
+settle
+[ "$($IN show -gv @r)" = "SENTINEL" ] || \
+	fail "invalid UTF-8 delete accepted the prompt"
+
+# --- 12. emacs cursor-marker edit, accept recovers the exact buffer. ---
+$IN set -g @r "" || exit 1
+$OUT send-keys M-r || exit 1
+settle
 $OUT send-keys -l "abc" || exit 1
 $OUT send-keys Home || exit 1
 $OUT send-keys -l "X" || exit 1
@@ -229,7 +258,7 @@ settle
 [ "$($IN show -gv @r)" = "Xabc" ] || \
 	fail "status-line accept recovered '$($IN show -gv @r)', wanted 'Xabc'"
 
-# --- 12. Unicode on the status line: insert, move, delete wide char. ---
+# --- 13. Unicode on the status line: insert, move, delete wide char. ---
 $IN set -g @r "" || exit 1
 $OUT send-keys M-r || exit 1
 settle
@@ -249,7 +278,7 @@ settle
 [ "$($IN show -gv @r)" = "Za" ] || \
 	fail "status-line wide edit recovered '$($IN show -gv @r)', wanted 'Za'"
 
-# --- 13. Overflow: more text than fits stays within the line and is kept. ---
+# --- 14. Overflow: more text than fits stays within the line and is kept. ---
 big="0123456789012345678901234567890123456789012345678901234567890123456789ABCDEFGHIJ"
 $IN set -g @r "" || exit 1
 $OUT send-keys M-r || exit 1
@@ -264,7 +293,7 @@ settle
 # The whole buffer was kept despite only part being visible.
 [ "$($IN show -gv @r)" = "$big" ] || fail "overflowing prompt lost buffer content"
 
-# --- 14. Escape closes the status-line prompt cleanly. ---
+# --- 15. Escape closes the status-line prompt cleanly. ---
 $IN set -g @r "SENTINEL" || exit 1
 $OUT send-keys M-r || exit 1
 settle