Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

Fix remote viewport geometry convergence

RoversX2de5706fb519
diff --git a/codec/src/lib.rs b/codec/src/lib.rs
index 4a870122..2d80187d 100644
--- a/codec/src/lib.rs
+++ b/codec/src/lib.rs
@@ -11,7 +11,7 @@
#![allow(dead_code)]
#![allow(clippy::range_plus_one)]
-use anyhow::{bail, Context as _, Error};
+use anyhow::{Context as _, Error, bail};
use config::keyassignment::{PaneDirection, ScrollbackEraseMode};
use mux::client::{ClientId, ClientInfo};
use mux::pane::PaneId;
@@ -38,8 +38,8 @@ use wezterm_term::{Alert, ClipboardSelection, StableRowIndex, TerminalSize};
pub mod thinkterm_tree;
pub use thinkterm_tree::{
- apply_op, ensure_unique_thread_names, ThinkTermTree, TreeOp, TtProject, TtProjectId, TtSpace,
- TtSpaceId, TtThread, TtThreadId,
+ ThinkTermTree, TreeOp, TtProject, TtProjectId, TtSpace, TtSpaceId, TtThread, TtThreadId,
+ apply_op, ensure_unique_thread_names,
};
#[derive(Error, Debug)]
@@ -461,7 +461,7 @@ macro_rules! pdu {
/// 56: Pane entries carry that state too, so a renderer knows it on arrival.
/// 57: Frontends publish and follow a shared per-tab scroll position.
/// 58: Connection-wide A/B access modes and atomic geometry-bearing claims.
-pub const CODEC_VERSION: usize = 58;
+pub const CODEC_VERSION: usize = 59;
// Defines the Pdu enum.
// Each struct has an explicit identifying number.
@@ -1041,7 +1041,13 @@ impl ClientViewport {
#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]
pub struct ClientPaneViewport {
pub pane_id: PaneId,
+ /// The PTY/render surface after subtracting frontend-only pane chrome and
+ /// snapping to this pane's (possibly independently scaled) cell size.
pub size: TerminalSize,
+ /// The pane's containing rectangle in the root viewport's common cell
+ /// and pixel coordinate system. Split geometry must be rebuilt from this
+ /// value rather than attempting to infer it from `size`.
+ pub frame: TerminalSize,
}
/// Advertise one renderer's desired viewport for a remote tab. Advertising
@@ -1627,8 +1633,8 @@ mod test {
}
#[test]
- fn thinkterm_session_viewport_and_landing_protocol_round_trip_at_version_58() {
- assert_eq!(CODEC_VERSION, 58);
+ fn thinkterm_session_viewport_and_landing_protocol_round_trip_at_version_59() {
+ assert_eq!(CODEC_VERSION, 59);
let size = TerminalSize {
rows: 40,
cols: 132,
@@ -1638,7 +1644,20 @@ mod test {
};
let viewport = SetClientViewport {
tab_id: 17,
- viewport: ClientViewport::CellGrid { size },
+ viewport: ClientViewport::Native {
+ size,
+ panes: vec![ClientPaneViewport {
+ pane_id: 23,
+ size: TerminalSize {
+ rows: 38,
+ cols: 129,
+ pixel_width: 1032,
+ pixel_height: 608,
+ dpi: 96,
+ },
+ frame: size,
+ }],
+ },
};
let mut encoded = Vec::new();
Pdu::SetClientViewport(viewport.clone())
diff --git a/mux/src/lib.rs b/mux/src/lib.rs
index 3841194d..b2aa37bb 100644
--- a/mux/src/lib.rs
+++ b/mux/src/lib.rs
@@ -3,13 +3,13 @@ use crate::pane::{CachePolicy, Pane, PaneId};
use crate::ssh_agent::AgentProxy;
use crate::tab::{SplitRequest, Tab, TabId};
use crate::window::{Window, WindowId, WindowUiSurfaceId};
-use anyhow::{anyhow, Context, Error};
+use anyhow::{Context, Error, anyhow};
use config::keyassignment::SpawnTabDomain;
-use config::{configuration, ExitBehavior, GuiPosition};
+use config::{ExitBehavior, GuiPosition, configuration};
use domain::{Domain, DomainId, DomainState, SplitSource};
-use filedescriptor::{poll, pollfd, socketpair, AsRawSocketDescriptor, FileDescriptor, POLLIN};
+use filedescriptor::{AsRawSocketDescriptor, FileDescriptor, POLLIN, poll, pollfd, socketpair};
#[cfg(unix)]
-use libc::{c_int, SOL_SOCKET, SO_RCVBUF, SO_SNDBUF};
+use libc::{SO_RCVBUF, SO_SNDBUF, SOL_SOCKET, c_int};
use log::error;
use metrics::histogram;
use parking_lot::{
@@ -34,7 +34,7 @@ use wezterm_term::{
Clipboard, ClipboardSelection, DownloadHandler, TerminalConfiguration, TerminalSize,
};
#[cfg(windows)]
-use winapi::um::winsock2::{SOL_SOCKET, SO_RCVBUF, SO_SNDBUF};
+use winapi::um::winsock2::{SO_RCVBUF, SO_SNDBUF, SOL_SOCKET};
pub mod activity;
pub mod client;
@@ -161,6 +161,7 @@ pub struct PaletteSelectionChange {
pub struct FrontendPaneViewport {
pub pane_id: PaneId,
pub size: wezterm_term::TerminalSize,
+ pub frame: wezterm_term::TerminalSize,
}
#[derive(Clone, Debug, PartialEq, Eq)]
@@ -1443,9 +1444,10 @@ impl Mux {
panes
.iter()
.map(|pane| format!(
- "{}:{}",
+ "{}:pty={} frame={}",
pane.pane_id,
- crate::geometrytrace::size(&pane.size)
+ crate::geometrytrace::size(&pane.size),
+ crate::geometrytrace::size(&pane.frame)
))
.collect::<Vec<_>>()
.join(" ")
@@ -1476,7 +1478,11 @@ impl Mux {
pane.resize(pane_viewport.size)?;
}
if !panes.is_empty() && viewport_covers_all_panes {
- tab.rebuild_splits_sizes_from_contained_panes();
+ let frames = panes
+ .iter()
+ .map(|pane| (pane.pane_id, pane.frame))
+ .collect::<HashMap<_, _>>();
+ tab.rebuild_splits_sizes_from_frontend_frames(&frames)?;
}
return Ok(());
}
@@ -3070,9 +3076,10 @@ mod tests {
let client = client_id(201);
mux.frontend_geometry_failures.lock().push_back(true);
- assert!(mux
- .set_client_viewport(&client, tab_id, frontend_test_viewport(120, 40))
- .is_err());
+ assert!(
+ mux.set_client_viewport(&client, tab_id, frontend_test_viewport(120, 40))
+ .is_err()
+ );
let lease = mux.frontend_lease.lock();
assert_eq!(lease.handoff_owner, None);
assert!(lease.handoff_ever_owned);
@@ -3094,9 +3101,10 @@ mod tests {
}
mux.frontend_geometry_failures.lock().push_back(true);
- assert!(mux
- .claim_frontend_viewport(&second, tab_id, frontend_test_viewport(120, 40))
- .is_err());
+ assert!(
+ mux.claim_frontend_viewport(&second, tab_id, frontend_test_viewport(120, 40))
+ .is_err()
+ );
let lease = mux.frontend_lease.lock();
assert_eq!(lease.handoff_owner, None);
assert_eq!(lease.tabs[&tab_id].owner, None);
@@ -3116,14 +3124,15 @@ mod tests {
}
mux.frontend_geometry_failures.lock().push_back(true);
- assert!(mux
- .set_frontend_access_mode(
+ assert!(
+ mux.set_frontend_access_mode(
&owner,
FrontendAccessMode::TmuxLatest,
tab_id,
frontend_test_viewport(120, 40),
)
- .is_err());
+ .is_err()
+ );
let access = mux.frontend_access_state();
assert_eq!(access.mode, FrontendAccessMode::Handoff);
assert_eq!(access.owner, None);
@@ -3527,15 +3536,16 @@ mod tests {
mux.set_registered_client_viewport(&second, second_registration, tab_id, grid.clone())
.unwrap();
- assert!(mux
- .set_registered_frontend_access_mode(
+ assert!(
+ mux.set_registered_frontend_access_mode(
&second,
second_registration,
FrontendAccessMode::TmuxLatest,
tab_id,
grid.clone(),
)
- .is_err());
+ .is_err()
+ );
mux.set_registered_frontend_access_mode(
&first,
first_registration,
@@ -3549,15 +3559,16 @@ mod tests {
// the one allowed to make itself B's global owner.
mux.claim_registered_client_viewport(&second, second_registration, tab_id, grid.clone())
.unwrap();
- assert!(mux
- .set_registered_frontend_access_mode(
+ assert!(
+ mux.set_registered_frontend_access_mode(
&first,
first_registration,
FrontendAccessMode::Handoff,
tab_id,
grid.clone(),
)
- .is_err());
+ .is_err()
+ );
let access = mux
.set_registered_frontend_access_mode(
&second,
diff --git a/mux/src/tab.rs b/mux/src/tab.rs
index 1217005c..1069df3c 100644
--- a/mux/src/tab.rs
+++ b/mux/src/tab.rs
@@ -836,6 +836,38 @@ fn compute_tree_size_from_panes(node: &mut Tree, tab_cell: &TerminalSize) -> Opt
if let Some(second) = compute_tree_size_from_panes(right, tab_cell) {
data.second = second;
}
+
+ // Only the axis that this node actually splits may differ
+ // between its children. A vertical (top/bottom) split gives
+ // both children the same width, and a horizontal (left/right)
+ // split gives both children the same height. Font-scaled
+ // panes snap their PTY pixel dimensions to a different cell
+ // width/height, so converting each leaf independently can
+ // otherwise produce (for example) 65 columns above and 64
+ // below. SplitDirectionAndSize::size observes only the first
+ // child on that cross axis, leaving the second child one cell
+ // short; the next viewport then feeds that short rectangle
+ // back in and the pane chrome visibly walks one cell at a
+ // time. Reassert the split invariant before aggregating the
+ // node so repeated viewport reports are idempotent.
+ match data.direction {
+ SplitDirection::Vertical => {
+ let cols = data.first.cols.max(data.second.cols);
+ let pixel_width = cols.saturating_mul(tab_cell.pixel_width.max(1));
+ data.first.cols = cols;
+ data.first.pixel_width = pixel_width;
+ data.second.cols = cols;
+ data.second.pixel_width = pixel_width;
+ }
+ SplitDirection::Horizontal => {
+ let rows = data.first.rows.max(data.second.rows);
+ let pixel_height = rows.saturating_mul(tab_cell.pixel_height.max(1));
+ data.first.rows = rows;
+ data.first.pixel_height = pixel_height;
+ data.second.rows = rows;
+ data.second.pixel_height = pixel_height;
+ }
+ }
Some(data.size())
} else {
None
@@ -844,6 +876,68 @@ fn compute_tree_size_from_panes(node: &mut Tree, tab_cell: &TerminalSize) -> Opt
}
}
+/// Rebuild a split tree from frontend pane *frames*. Unlike a PTY surface,
+/// every frame is measured in the root viewport's common cell grid and still
+/// includes frontend-only pane chrome. It therefore composes exactly across
+/// nested splits without guessing at font-scale rounding or nav-bar height.
+fn compute_tree_size_from_frames(
+ node: &mut Tree,
+ frames: &HashMap<PaneId, TerminalSize>,
+ tab_cell: &TerminalSize,
+) -> Option<TerminalSize> {
+ match node {
+ Tree::Empty => None,
+ Tree::Leaf(stack) => {
+ let pane_id = stack.active_pane()?.pane_id();
+ let frame = *frames.get(&pane_id)?;
+ if frame.cols == 0 || frame.rows == 0 {
+ return None;
+ }
+ Some(TerminalSize {
+ cols: frame.cols,
+ rows: frame.rows,
+ pixel_width: frame.cols.saturating_mul(tab_cell.pixel_width.max(1)),
+ pixel_height: frame.rows.saturating_mul(tab_cell.pixel_height.max(1)),
+ dpi: tab_cell.dpi,
+ })
+ }
+ Tree::Node { left, right, data } => {
+ let data = data.as_mut()?;
+ data.first = compute_tree_size_from_frames(left, frames, tab_cell)?;
+ data.second = compute_tree_size_from_frames(right, frames, tab_cell)?;
+ match data.direction {
+ SplitDirection::Vertical => {
+ let cols = data.first.cols.max(data.second.cols);
+ data.first.cols = cols;
+ data.second.cols = cols;
+ data.first.pixel_width = cols.saturating_mul(tab_cell.pixel_width.max(1));
+ data.second.pixel_width = data.first.pixel_width;
+ }
+ SplitDirection::Horizontal => {
+ let rows = data.first.rows.max(data.second.rows);
+ data.first.rows = rows;
+ data.second.rows = rows;
+ data.first.pixel_height = rows.saturating_mul(tab_cell.pixel_height.max(1));
+ data.second.pixel_height = data.first.pixel_height;
+ }
+ }
+ Some(data.size())
+ }
+ }
+}
+
+fn clone_pane_tree(tree: &Tree) -> Tree {
+ match tree {
+ Tree::Empty => Tree::Empty,
+ Tree::Leaf(stack) => Tree::Leaf(stack.clone()),
+ Tree::Node { left, right, data } => Tree::Node {
+ left: Box::new(clone_pane_tree(left)),
+ right: Box::new(clone_pane_tree(right)),
+ data: *data,
+ },
+ }
+}
+
fn cell_dimensions(size: &TerminalSize) -> TerminalSize {
TerminalSize {
rows: 1,
@@ -1011,10 +1105,13 @@ impl Tab {
/// Without this step, disconnecting and reconnecting would cause
/// the GUI to use stale size information for the window it spawns
/// to attach this tab.
- pub fn rebuild_splits_sizes_from_contained_panes(&self) {
+ pub fn rebuild_splits_sizes_from_frontend_frames(
+ &self,
+ frames: &HashMap<PaneId, TerminalSize>,
+ ) -> anyhow::Result<()> {
self.inner
.lock()
- .rebuild_splits_sizes_from_contained_panes()
+ .rebuild_splits_sizes_from_frontend_frames(frames)
}
/// Given split_index, the topological index of a split returned by
@@ -2020,55 +2117,51 @@ impl TabInner {
}
}
- fn rebuild_splits_sizes_from_contained_panes(&mut self) {
+ fn rebuild_splits_sizes_from_frontend_frames(
+ &mut self,
+ frames: &HashMap<PaneId, TerminalSize>,
+ ) -> anyhow::Result<()> {
if self.zoomed.is_some() {
if crate::geometrytrace::trace_enabled() {
let head = format!("tab.rebuild.skip tab={} reason=zoomed", self.id);
let geometry = self.geometry_trace();
crate::zoom_trace!("{head} | {geometry}");
}
- return;
+ return Ok(());
}
- // The contained panes cannot describe the tab root on their own: a
- // frontend reserves per-pane chrome, so their dimensions always sum
- // to less than the tab it is rendering. Adopting that sum makes the
- // *next* report look like a size change that never happened, and
- // Tab::resize then redistributes that phantom delta across the
- // dividers. Keep the root the frontend declared and stretch the
- // rebuilt proportions onto it, which also makes repeating an
- // unchanged report converge instead of walking the splits.
let root_size = self.size;
let cell = cell_dimensions(&root_size);
- let mut derived = None;
- if let Some(root) = self.pane.as_mut() {
- if let Some(size) = compute_tree_size_from_panes(root, &cell) {
- derived = Some(size);
- adjust_x_size(
- root,
- root_size.cols as isize - size.cols as isize,
- &cell,
- );
- adjust_y_size(
- root,
- root_size.rows as isize - size.rows as isize,
- &cell,
- );
- }
+ let tab_id = self.id;
+ let mut candidate = self
+ .pane
+ .as_ref()
+ .map(clone_pane_tree)
+ .ok_or_else(|| anyhow::anyhow!("tab {tab_id} has no pane tree"))?;
+ let derived = compute_tree_size_from_frames(&mut candidate, frames, &cell)
+ .ok_or_else(|| anyhow::anyhow!("frontend frames do not cover tab {tab_id}"))?;
+ if derived.cols != root_size.cols || derived.rows != root_size.rows {
+ anyhow::bail!(
+ "frontend frames {}x{} do not compose to tab {}x{}",
+ derived.cols,
+ derived.rows,
+ root_size.cols,
+ root_size.rows
+ );
}
+ self.pane = Some(candidate);
if crate::geometrytrace::trace_enabled() {
let head = format!(
- "tab.rebuild tab={} root={} derived={} (root kept)",
+ "tab.rebuild.frames tab={} root={} derived={}",
self.id,
crate::geometrytrace::size(&root_size),
- derived
- .map(|size| crate::geometrytrace::size(&size))
- .unwrap_or_else(|| "-".to_string())
+ crate::geometrytrace::size(&derived)
);
let geometry = self.geometry_trace();
crate::zoom_trace!("{head} | {geometry}");
}
Mux::try_get().map(|mux| mux.notify(MuxNotification::TabResized(self.id)));
+ Ok(())
}
fn resize_split_by(&mut self, split_index: usize, delta: isize) {
@@ -4257,6 +4350,7 @@ mod test {
panes: vec![FrontendPaneViewport {
pane_id: second.pane_id(),
size: tab_size,
+ frame: tab_size,
}],
},
)
@@ -4301,6 +4395,16 @@ mod test {
(tab, first, second)
}
+ fn positioned_frame(positioned: &PositionedPane, dpi: u32) -> TerminalSize {
+ TerminalSize {
+ cols: positioned.width,
+ rows: positioned.height,
+ pixel_width: positioned.pixel_width,
+ pixel_height: positioned.pixel_height,
+ dpi,
+ }
+ }
+
#[test]
fn a_font_scaled_pane_must_not_redefine_the_tab_root() {
let _mux = install_mux();
@@ -4327,6 +4431,7 @@ mod test {
pixel_height: positioned.pixel_height,
dpi: tab_size.dpi,
},
+ frame: positioned_frame(&positioned, tab_size.dpi),
}
})
.collect::<Vec<_>>();
@@ -4340,7 +4445,8 @@ mod test {
.into_iter()
.map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
.collect::<Vec<_>>();
- mux.apply_frontend_viewport(tab.tab_id(), &viewport).unwrap();
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
assert_eq!(
tab.get_size(),
tab_size,
@@ -4364,7 +4470,8 @@ mod test {
// root was re-derived from the panes, every repeat looked like a size
// change and Tab::resize walked the divider a little further.
for _ in 0..5 {
- mux.apply_frontend_viewport(tab.tab_id(), &viewport).unwrap();
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
assert_eq!(tab.get_size(), tab_size);
assert_eq!(
tab.iter_panes()
@@ -4377,6 +4484,397 @@ mod test {
}
}
+ #[test]
+ fn font_scaled_pane_cannot_shrink_a_vertical_splits_cross_axis() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let tab = Arc::new(Tab::new(&tab_size));
+ let first = FakePane::new(1, tab_size);
+ tab.assign_pane(&first);
+ mux.add_tab_no_panes(&tab);
+ mux.add_pane(&first).unwrap();
+
+ let request = SplitRequest {
+ direction: SplitDirection::Vertical,
+ ..Default::default()
+ };
+ let split_size = tab
+ .compute_split_size(0, request)
+ .expect("initial tab can split");
+ let second = FakePane::new(2, split_size.second);
+ tab.split_and_insert(0, request, Arc::clone(&second))
+ .expect("split succeeds");
+ mux.add_pane(&second).unwrap();
+
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ assert_eq!(before[0].1, before[1].1);
+
+ // Both panes occupy the same pixel-width rectangle. The lower pane
+ // uses a narrower independent font, so its PTY grid snaps to 791px
+ // (113 * 7) rather than the tab grid's 800px (80 * 10). Converting
+ // those pixels independently yields 80 and 79 tab columns even though
+ // a top/bottom split cannot have different child widths.
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: if positioned.pane.pane_id() == 2 {
+ TerminalSize {
+ cols: 113,
+ rows: positioned.height,
+ pixel_width: 791,
+ pixel_height: positioned.pixel_height,
+ dpi: tab_size.dpi,
+ }
+ } else {
+ TerminalSize {
+ cols: positioned.width,
+ rows: positioned.height,
+ pixel_width: positioned.pixel_width,
+ pixel_height: positioned.pixel_height,
+ dpi: tab_size.dpi,
+ }
+ },
+ frame: positioned_frame(&positioned, tab_size.dpi),
+ })
+ .collect(),
+ };
+
+ for _ in 0..8 {
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
+ let panes = tab.iter_panes();
+ assert_eq!(tab.get_size(), tab_size);
+ assert_eq!(
+ panes[0].width, panes[1].width,
+ "top/bottom pane chrome must share one width"
+ );
+ assert_eq!(
+ panes
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before,
+ "repeating the same mixed-font viewport must not walk the pane left"
+ );
+ }
+ }
+
+ #[test]
+ fn font_scaled_pane_cannot_shrink_a_horizontal_splits_cross_axis() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ assert_eq!(before[0].2, before[1].2);
+
+ // Symmetric case: left/right children share a height. A pane-local
+ // line height can leave one PTY just below the next tab-row boundary.
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: if positioned.pane.pane_id() == 2 {
+ TerminalSize {
+ cols: positioned.width,
+ rows: 27,
+ pixel_width: positioned.pixel_width,
+ pixel_height: 594,
+ dpi: tab_size.dpi,
+ }
+ } else {
+ TerminalSize {
+ cols: positioned.width,
+ rows: positioned.height,
+ pixel_width: positioned.pixel_width,
+ pixel_height: positioned.pixel_height,
+ dpi: tab_size.dpi,
+ }
+ },
+ frame: positioned_frame(&positioned, tab_size.dpi),
+ })
+ .collect(),
+ };
+
+ for _ in 0..8 {
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
+ let panes = tab.iter_panes();
+ assert_eq!(tab.get_size(), tab_size);
+ assert_eq!(
+ panes[0].height, panes[1].height,
+ "left/right pane chrome must share one height"
+ );
+ assert_eq!(
+ panes
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before,
+ "repeating the same mixed-font viewport must not walk the pane upward"
+ );
+ }
+ }
+
+ #[test]
+ fn font_scaled_right_pane_cannot_walk_a_vertical_divider() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+
+ // The right pane uses 7px cells while the tab grid uses 10px cells.
+ // Its terminal surface is therefore rounded down to a multiple of 7
+ // inside the pane rectangle. Rebuilding the divider from a floored
+ // tab-cell conversion assigns that harmless remainder to the left
+ // pane; the next GUI report then repeats the process against the new
+ // rectangle and walks the vertical divider left-to-right one cell at
+ // a time.
+ for _ in 0..8 {
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| {
+ let pane_cell_width = if positioned.pane.pane_id() == 2 {
+ 7
+ } else {
+ 10
+ };
+ let cols = (positioned.pixel_width / pane_cell_width).max(1);
+ FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: TerminalSize {
+ cols,
+ rows: positioned.height,
+ pixel_width: cols * pane_cell_width,
+ pixel_height: positioned.pixel_height,
+ dpi: tab_size.dpi,
+ },
+ frame: positioned_frame(&positioned, tab_size.dpi),
+ }
+ })
+ .collect(),
+ };
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
+ assert_eq!(
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before,
+ "repeating a mixed-font viewport must not walk the vertical divider"
+ );
+ }
+ }
+
+ #[test]
+ fn font_scaled_bottom_pane_cannot_walk_a_horizontal_divider() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let tab = Arc::new(Tab::new(&tab_size));
+ let first = FakePane::new(1, tab_size);
+ tab.assign_pane(&first);
+ mux.add_tab_no_panes(&tab);
+ mux.add_pane(&first).unwrap();
+
+ let request = SplitRequest {
+ direction: SplitDirection::Vertical,
+ ..Default::default()
+ };
+ let split_size = tab
+ .compute_split_size(0, request)
+ .expect("initial tab can split");
+ let second = FakePane::new(2, split_size.second);
+ tab.split_and_insert(0, request, Arc::clone(&second))
+ .expect("split succeeds");
+ mux.add_pane(&second).unwrap();
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+
+ for _ in 0..8 {
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| {
+ let pane_cell_height = if positioned.pane.pane_id() == 2 {
+ 22
+ } else {
+ 25
+ };
+ let rows = (positioned.pixel_height / pane_cell_height).max(1);
+ FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: TerminalSize {
+ cols: positioned.width,
+ rows,
+ pixel_width: positioned.pixel_width,
+ pixel_height: rows * pane_cell_height,
+ dpi: tab_size.dpi,
+ },
+ frame: positioned_frame(&positioned, tab_size.dpi),
+ }
+ })
+ .collect(),
+ };
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
+ assert_eq!(
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before,
+ "repeating a mixed-font viewport must not walk the horizontal divider"
+ );
+ }
+ }
+
+ #[test]
+ fn nested_mixed_font_frames_are_idempotent() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);
+
+ for (target, pane_id) in [(1, 3), (2, 4)] {
+ let target_index = tab.pane_index_for_pane(target).unwrap();
+ let request = SplitRequest {
+ direction: SplitDirection::Vertical,
+ ..Default::default()
+ };
+ let split = tab.compute_split_size(target_index, request).unwrap();
+ let pane = FakePane::new(pane_id, split.second);
+ tab.split_and_insert(target_index, request, Arc::clone(&pane))
+ .unwrap();
+ mux.add_pane(&pane).unwrap();
+ }
+ tab.resize_split_by(0, -7);
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+
+ // This is the shape from the real failure: a left/right root whose
+ // two columns are independently split top/bottom, with pane-local
+ // font metrics and one row of frontend-only chrome. The PTY surfaces
+ // deliberately do not compose to the root; their frames do.
+ for _ in 0..12 {
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| {
+ let pane_id = positioned.pane.pane_id();
+ let cell_width = [10, 13, 7, 19][pane_id - 1];
+ let cell_height = [25, 22, 17, 29][pane_id - 1];
+ let cols = (positioned.pixel_width / cell_width).max(1);
+ let content_height = positioned.pixel_height.saturating_sub(25);
+ let rows = (content_height / cell_height).max(1);
+ FrontendPaneViewport {
+ pane_id,
+ size: TerminalSize {
+ cols,
+ rows,
+ pixel_width: cols * cell_width,
+ pixel_height: rows * cell_height,
+ dpi: tab_size.dpi,
+ },
+ frame: positioned_frame(&positioned, tab_size.dpi),
+ }
+ })
+ .collect(),
+ };
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport)
+ .unwrap();
+ assert_eq!(
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before,
+ "nested split frames must not drift when PTY surfaces use mixed units"
+ );
+ }
+ }
+
+ #[test]
+ fn invalid_frontend_frames_do_not_mutate_the_split_tree() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ let panes = tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| {
+ let mut frame = positioned_frame(&positioned, tab_size.dpi);
+ if positioned.pane.pane_id() == 2 {
+ frame.cols += 5;
+ frame.pixel_width += 50;
+ }
+ FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: frame,
+ frame,
+ }
+ })
+ .collect();
+ assert!(
+ mux.apply_frontend_viewport(
+ tab.tab_id(),
+ &FrontendViewport::Native {
+ size: tab_size,
+ panes,
+ },
+ )
+ .is_err()
+ );
+ assert_eq!(
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before
+ );
+ }
+
#[test]
fn unzoom_clears_the_zoom_flag_on_the_pane_that_holds_it() {
let _mux = install_mux();
diff --git a/thinkterm-tui/src/lib.rs b/thinkterm-tui/src/lib.rs
index 285447a9..4b7d2385 100644
--- a/thinkterm-tui/src/lib.rs
+++ b/thinkterm-tui/src/lib.rs
@@ -22,8 +22,8 @@ use mux::domain::{Domain, DomainState, SplitSource};
use mux::pane::{Pane, PaneId, Pattern};
use mux::tab::{SplitDirection, SplitRequest, SplitSize, Tab, TabId};
use mux::{Mux, MuxNotification};
-use ratatui::backend::Backend;
use ratatui::Terminal;
+use ratatui::backend::Backend;
use settings::{TuiConfig, TuiPersistentState};
use state::{
AppMode, ConfirmationState, ConnectionItem, ConnectionStatus, ContextMenuState, CopyState,
@@ -39,7 +39,7 @@ use termwiz::caps::{Capabilities, ProbeHints};
use termwiz::input::{
InputEvent, KeyCode, KeyEvent, Modifiers, MouseButtons, MouseEvent as TermwizMouseEvent,
};
-use termwiz::terminal::{new_terminal, ScreenSize, TerminalWaker};
+use termwiz::terminal::{ScreenSize, TerminalWaker, new_terminal};
use uuid::Uuid;
use view::{HitTarget, PaneTool, TabBarControl, TreeAction, ViewLayout};
use wezterm_client::client::Client;
@@ -47,8 +47,8 @@ use wezterm_client::domain::{
ClientDomain, ClientDomainConfig, FrontendRecoverySlot, RemoteFrontendGate,
};
use wezterm_client::pane::ClientPane;
-use wezterm_term::input::{MouseButton, MouseEvent, MouseEventKind};
use wezterm_term::TerminalSize;
+use wezterm_term::input::{MouseButton, MouseEvent, MouseEventKind};
static EVENT_SENDER: OnceLock<Sender<AppEvent>> = OnceLock::new();
static TERMINAL_WAKER: OnceLock<TerminalWaker> = OnceLock::new();
@@ -1502,6 +1502,13 @@ fn prepare_active_native_viewport(
screen,
);
tab.resize(root);
+ // `compute_view` clips panes to the portion of the split tree that fits on
+ // this TTY. That clipped rectangle is the PTY/render surface, but it is
+ // not the authoritative split frame: using it as the frame makes a small
+ // TUI claim fail the server's complete-tree validation. Capture the
+ // frames from the Tab itself after resize, before adding TUI-only chrome.
+ let root = tab.get_size();
+ let frames = tui_pane_frame_sizes(&tab, screen);
let layout = view::compute_view(area, &state.model, &state.ui, Some(&tab));
let mut panes = Vec::new();
@@ -1512,6 +1519,7 @@ fn prepare_active_native_viewport(
panes.push(codec::ClientPaneViewport {
pane_id: pane.pane_id,
size,
+ frame: *frames.get(&pane.pane_id)?,
});
}
// Validate the complete pane set before mutating any surface. A topology
@@ -1531,6 +1539,18 @@ fn prepare_active_native_viewport(
Some(ClientViewport::Native { size: root, panes })
}
+fn tui_pane_frame_sizes(tab: &Tab, screen: ScreenSize) -> HashMap<PaneId, TerminalSize> {
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| {
+ (
+ pane.pane.pane_id(),
+ terminal_size(pane.width, pane.height, screen),
+ )
+ })
+ .collect()
+}
+
fn forget_native_viewport_geometry(viewport: &ClientViewport) {
let ClientViewport::Native { panes, .. } = viewport else {
return;
@@ -1594,6 +1614,7 @@ fn cancel_takeover_geometry_confirmation(
.map(|(pane_id, size)| codec::ClientPaneViewport {
pane_id: *pane_id,
size: *size,
+ frame: *size,
})
.collect(),
};
@@ -1634,14 +1655,12 @@ fn active_layout_matches_takeover(
let Some(screen) = state.screen_size else {
return false;
};
- if terminal_size(
- state.layout.content.width as usize,
- state.layout.content.height as usize,
- screen,
- ) != confirmation.root_size
- {
- return false;
- }
+ // A deeply split tab has a structural minimum. Its authoritative root can
+ // therefore be larger than the drawable TTY content while the visible
+ // pane surfaces below are intentionally clipped. Requiring the drawable
+ // rectangle itself to equal the full root leaves takeover permanently in
+ // `Syncing`; the root tree and every visible surface are the two relevant
+ // confirmations.
confirmation.panes.iter().all(|(pane_id, expected)| {
state
.layout
@@ -1712,6 +1731,7 @@ fn advance_takeover_geometry_confirmation(state: &mut TuiState) {
.map(|(pane_id, size)| codec::ClientPaneViewport {
pane_id: *pane_id,
size: *size,
+ frame: *size,
})
.collect(),
};
@@ -1775,6 +1795,11 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(
let recovery_generation =
domain.pending_frontend_recovery(FrontendRecoverySlot::Primary, local_tab_id);
let viewport = if ownership == Some(true) || recovery_generation.is_some() {
+ let Some(tab) = Mux::get().get_tab(local_tab_id) else {
+ return;
+ };
+ let frames = tui_pane_frame_sizes(&tab, screen);
+ let native_root = tab.get_size();
let panes = state
.layout
.panes
@@ -1782,17 +1807,19 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(
.filter_map(|pane| {
let handle = Mux::get().get_pane(pane.pane_id)?;
handle.downcast_ref::<ClientPane>()?;
+ let size =
+ terminal_size(pane.rect.width as usize, pane.rect.height as usize, screen);
Some(codec::ClientPaneViewport {
pane_id: pane.pane_id,
- size: terminal_size(
- pane.rect.width as usize,
- pane.rect.height as usize,
- screen,
- ),
+ size,
+ frame: *frames.get(&pane.pane_id)?,
})
})
.collect();
- ClientViewport::Native { size, panes }
+ ClientViewport::Native {
+ size: native_root,
+ panes,
+ }
} else {
ClientViewport::CellGrid { size }
};
@@ -2079,19 +2106,9 @@ fn follow_shared_view(
/// Which size this renderer's own copy of the tab should be laid out at.
///
-/// `canonical_size` is the *server's* tab size, and the server derives it back
-/// from the pane sizes it was told (`rebuild_splits_sizes_from_contained_panes`).
-/// Once a pane's rectangle loses a row to its own nav bar, that shrunken row
-/// count is what comes home in the echo — adopting it costs another row on the
-/// next layout, and another after that. The GUI never adopts it either: the
-/// only use of `canonical_size` on that side is the `VIEW 73×28` title, and
-/// `ClientDomain`'s own resync refuses the wire size for the same reason
-/// ("would shrink the tab by the chrome height on every resync").
-///
-/// So the owner lays out at the size it just reported and the server just
-/// applied. A renderer that does *not* own the viewport has nothing of its own
-/// to lay out at and still needs to draw the grid the panes really have, so it
-/// keeps taking the server's answer.
+/// `canonical_size` is the server's root tab size. The owner lays out at the
+/// size it just reported and the server applied; a passive renderer has no
+/// local geometry authority and follows the canonical answer.
fn choose_local_tab_size(
owns: Option<bool>,
reported: TerminalSize,
@@ -3453,7 +3470,9 @@ fn begin_confirmation(state: &mut TuiState, action: DestructiveAction) {
(
"Delete Thread",
if *end_sessions {
- format!("Delete this server-owned Thread and end {count} remote pane(s) for every client?")
+ format!(
+ "Delete this server-owned Thread and end {count} remote pane(s) for every client?"
+ )
} else {
"Delete this server-owned Thread on every client? Its sessions will keep running.".into()
},
@@ -3485,7 +3504,9 @@ fn begin_confirmation(state: &mut TuiState, action: DestructiveAction) {
(
"Delete Space",
if *end_sessions {
- format!("Delete this Space on the authoritative server and end {count} remote pane(s)?")
+ format!(
+ "Delete this Space on the authoritative server and end {count} remote pane(s)?"
+ )
} else {
"Delete this Space from the authoritative server on every client? Remote sessions keep running.".into()
},
diff --git a/wezterm-client/src/client.rs b/wezterm-client/src/client.rs
index d89def3f..b54072ab 100644
--- a/wezterm-client/src/client.rs
+++ b/wezterm-client/src/client.rs
@@ -276,6 +276,7 @@ macro_rules! rpc {
metrics::counter!("rpc.count", "method" => stringify!($method_name)).increment(1);
match result {
Ok(Pdu::$response_type(res)) => Ok(res),
+ Ok(Pdu::ErrorResponse(err)) => bail!(err.reason),
Ok(_) => bail!("unexpected response {:?}", result),
Err(err) => Err(err),
}
@@ -295,6 +296,7 @@ macro_rules! rpc {
metrics::counter!("rpc.count", "method" => stringify!($method_name)).increment(1);
match result {
Ok(Pdu::$response_type(res)) => Ok(res),
+ Ok(Pdu::ErrorResponse(err)) => bail!(err.reason),
Ok(_) => bail!("unexpected response {:?}", result),
Err(err) => Err(err),
}
diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rs
index 54969c31..e789b544 100644
--- a/wezterm-client/src/domain.rs
+++ b/wezterm-client/src/domain.rs
@@ -1,12 +1,12 @@
use crate::client::{Client, ClientConnectionPhase};
use crate::pane::ClientPane;
-use anyhow::{anyhow, bail, Context};
+use anyhow::{Context, anyhow, bail};
use async_trait::async_trait;
use codec::{ListPanesResponse, SpawnV2, SplitPane};
use config::keyassignment::SpawnTabDomain;
use config::{SshDomain, TlsDomainClient, UnixDomain};
use mux::connui::{ConnectionUI, ConnectionUIParams};
-use mux::domain::{alloc_domain_id, Domain, DomainId, DomainState, SplitSource};
+use mux::domain::{Domain, DomainId, DomainState, SplitSource, alloc_domain_id};
use mux::pane::{Pane, PaneId};
use mux::tab::{SplitRequest, Tab, TabId};
use mux::window::WindowId;
@@ -2054,6 +2054,7 @@ impl ClientDomain {
remote_panes.push(codec::ClientPaneViewport {
pane_id: remote,
size: pane.size,
+ frame: pane.frame,
});
}
codec::ClientViewport::Native {
@@ -2078,9 +2079,10 @@ impl ClientDomain {
panes
.iter()
.map(|pane| format!(
- "r{}:{}",
+ "r{}:pty={} frame={}",
pane.pane_id,
- mux::geometrytrace::size(&pane.size)
+ mux::geometrytrace::size(&pane.size),
+ mux::geometrytrace::size(&pane.frame)
))
.collect::<Vec<_>>()
.join(" ")
@@ -2637,11 +2639,11 @@ impl ClientDomain {
#[cfg(test)]
mod tests {
use super::{
- accepts_generation, acknowledge_recovery_target, active_remote_tabs_by_workspace,
- consistent_remote_tab_id, owns_remote_viewport_from_states,
- remote_frontend_gate_from_state, remote_move_pane_id, server_runtime_replaced,
- thread_id_for_workspace, AutomaticRemotePaneResize, FrontendRecoveryAck,
- FrontendRecoveryBarrier, FrontendRecoverySlot, RemoteFrontendGate, ViewportLatencyState,
+ AutomaticRemotePaneResize, FrontendRecoveryAck, FrontendRecoveryBarrier,
+ FrontendRecoverySlot, RemoteFrontendGate, ViewportLatencyState, accepts_generation,
+ acknowledge_recovery_target, active_remote_tabs_by_workspace, consistent_remote_tab_id,
+ owns_remote_viewport_from_states, remote_frontend_gate_from_state, remote_move_pane_id,
+ server_runtime_replaced, thread_id_for_workspace,
};
use crate::client::ClientConnectionPhase;
use std::collections::HashMap;
diff --git a/wezterm-client/src/pane/clientpane.rs b/wezterm-client/src/pane/clientpane.rs
index a9288d23..8d183688 100644
--- a/wezterm-client/src/pane/clientpane.rs
+++ b/wezterm-client/src/pane/clientpane.rs
@@ -1,6 +1,6 @@
use crate::domain::ClientInner;
use crate::pane::mousestate::MouseState;
-use crate::pane::renderable::{hydrate_lines, RenderableInner, RenderableState};
+use crate::pane::renderable::{RenderableInner, RenderableState, hydrate_lines};
use anyhow::bail;
use async_trait::async_trait;
use codec::*;
@@ -9,8 +9,8 @@ use config::keyassignment::ScrollbackEraseMode;
use futures::lock::Mutex as AsyncMutex;
use mux::domain::DomainId;
use mux::pane::{
- alloc_pane_id, CachePolicy, CloseReason, ForEachPaneLogicalLine, LogicalLine, Pane, PaneId,
- Pattern, SearchResult, WithPaneLines,
+ CachePolicy, CloseReason, ForEachPaneLogicalLine, LogicalLine, Pane, PaneId, Pattern,
+ SearchResult, WithPaneLines, alloc_pane_id,
};
use mux::renderable::{RenderableDimensions, StableCursorPosition};
use mux::tab::TabId;
@@ -21,8 +21,8 @@ use ratelim::RateLimiter;
use std::cell::RefCell;
use std::collections::{BTreeMap, HashMap};
use std::ops::Range;
-use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
use termwiz::input::KeyEvent;
use termwiz::surface::SequenceNo;
use url::Url;
@@ -703,6 +703,12 @@ impl ClientPane {
self.renderable.lock().prime_frontend_geometry(size)
}
+ /// Which geometry fields still block a takeover from settling, or None
+ /// once the server agrees. Diagnostic only; see `mux::geometrytrace`.
+ pub fn frontend_geometry_mismatch(&self, size: TerminalSize) -> Option<String> {
+ self.renderable.lock().frontend_geometry_mismatch(size)
+ }
+
/// End the remote pane and wait for the mux server to acknowledge it.
/// Destructive compound workflows use this instead of `Pane::kill`, whose
/// fire-and-forget task can lose a race with detaching the last window.
@@ -908,8 +914,8 @@ impl Pane for ClientPane {
// relayout) the advertised dims legitimately disagree with the
// GUI's still-stale layout for a moment, and re-asserting the
// stale size would revert the server's pane resize and bake a
- // corrupt geometry into its split tree via
- // rebuild_splits_sizes_from_contained_panes.
+ // stale terminal surface. Split geometry is committed only by a
+ // complete Native viewport carrying exact pane frames.
let mut requested = self.requested_size.lock();
let prior_requested = *requested;
let render = self.renderable.lock();
@@ -1406,7 +1412,7 @@ mod test {
#[cfg(test)]
mod palette_delivery_tests {
- use super::{application_palette_transition, PaletteDelivery};
+ use super::{PaletteDelivery, application_palette_transition};
use wezterm_term::color::ColorPalette;
fn palette(fg: f32) -> ColorPalette {
diff --git a/wezterm-client/src/pane/renderable.rs b/wezterm-client/src/pane/renderable.rs
index 25efef80..71df5b13 100644
--- a/wezterm-client/src/pane/renderable.rs
+++ b/wezterm-client/src/pane/renderable.rs
@@ -1049,6 +1049,42 @@ impl RenderableState {
self.inner.borrow().dimensions
}
+ /// What the server last advertised. This, not `get_dimensions`, is what
+ /// `prime_frontend_geometry` compares a takeover against, and the two can
+ /// disagree — so a takeover that never completes is only explainable from
+ /// this value.
+ pub(crate) fn server_dimensions(&self) -> RenderableDimensions {
+ self.inner.borrow().server_dimensions
+ }
+
+ /// Which fields block a takeover from settling on `size`, for zoomtrace.
+ pub(crate) fn frontend_geometry_mismatch(
+ &self,
+ size: wezterm_term::TerminalSize,
+ ) -> Option<String> {
+ let dims = self.inner.borrow().server_dimensions;
+ if render_dimensions_match_terminal_size(dims, size) {
+ return None;
+ }
+ let mut fields = Vec::new();
+ if dims.cols != size.cols {
+ fields.push(format!("cols {}!={}", dims.cols, size.cols));
+ }
+ if dims.viewport_rows != size.rows {
+ fields.push(format!("rows {}!={}", dims.viewport_rows, size.rows));
+ }
+ if dims.pixel_width != size.pixel_width {
+ fields.push(format!("px_w {}!={}", dims.pixel_width, size.pixel_width));
+ }
+ if dims.pixel_height != size.pixel_height {
+ fields.push(format!("px_h {}!={}", dims.pixel_height, size.pixel_height));
+ }
+ if dims.dpi != size.dpi {
+ fields.push(format!("dpi {}!={}", dims.dpi, size.dpi));
+ }
+ Some(fields.join(","))
+ }
+
/// Drive a render poll and populate every currently visible line while a
/// takeover overlay is still opaque. Returns true only after the server
/// has confirmed `size` and none of those rows is stale or in flight.
diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rs
index d65951a4..24cce324 100644
--- a/wezterm-gui/src/termwindow/resize.rs
+++ b/wezterm-gui/src/termwindow/resize.rs
@@ -4,10 +4,10 @@ use crate::ui::rescale_ui_usize;
use crate::utilsprites::RenderMetrics;
use ::window::{Dimensions, ResizeIncrement, Window, WindowOps, WindowState};
use config::{ConfigHandle, DimensionContext};
+use mux::Mux;
use mux::domain::Domain;
use mux::pane::{Pane, PaneId};
use mux::tab::PositionedPane;
-use mux::Mux;
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
@@ -355,13 +355,19 @@ impl super::TermWindow {
self.frontend_recovery_geometry.insert(tab_id, recovery);
}
}
- let needs_follow_up = self.frontend_geometry_resync_after_epoch.remove(&tab_id);
+ // Only consume the owed resync if we are actually about to run it.
+ // Removing it unconditionally discarded the geometry a background tab
+ // was still waiting for: the flag was cleared, the sync never ran, and
+ // nothing re-armed it, so that tab kept stale geometry until an
+ // unrelated window resize happened to push it again.
+ let needs_follow_up = self.frontend_geometry_resync_after_epoch.contains(&tab_id);
+ let active = self.active_tab_is(tab_id);
mux::zoom_trace!(
"gui.sync.complete tab={tab_id} epoch={epoch} follow_up={needs_follow_up} \
- active={}",
- self.active_tab_is(tab_id)
+ active={active}"
);
- if needs_follow_up && self.active_tab_is(tab_id) {
+ if needs_follow_up && active {
+ self.frontend_geometry_resync_after_epoch.remove(&tab_id);
mux::zoom_trace!("gui.sync.followup tab={tab_id} after_epoch={epoch}");
// Starting the follow-up synchronously keeps the tab opaque: the
// old epoch is replaced before this callback can paint.
@@ -389,6 +395,19 @@ impl super::TermWindow {
return;
};
let tab_id = tab.tab_id();
+ // A confirmation owed to a tab the user has switched away from is
+ // never advanced here, and its overlay is not painted either, so
+ // nothing schedules the frames that would settle it.
+ if mux::geometrytrace::trace_enabled() {
+ for (pending_tab, pending) in &self.frontend_geometry_confirmations {
+ if *pending_tab != tab_id {
+ mux::zoom_trace!(
+ "gui.confirm.stranded tab={pending_tab} epoch={} active_tab={tab_id}",
+ pending.epoch
+ );
+ }
+ }
+ }
let Some(confirmation) = self.frontend_geometry_confirmations.get(&tab_id).cloned() else {
return;
};
@@ -405,6 +424,7 @@ impl super::TermWindow {
let mux = Mux::get();
let mut ready = !confirmation.panes.is_empty();
+ let mut blockers = Vec::new();
for (pane_id, size) in &confirmation.panes {
let pane_ready = mux
.get_pane(*pane_id)
@@ -413,6 +433,23 @@ impl super::TermWindow {
.map(|client| client.prime_frontend_geometry(*size))
})
.unwrap_or(false);
+ if !pane_ready && mux::geometrytrace::trace_enabled() {
+ // Distinguish "the server never agreed on this size" (a
+ // permanent stall) from "rows are still being fetched" (which
+ // resolves on its own).
+ let why = mux
+ .get_pane(*pane_id)
+ .and_then(|pane| {
+ pane.downcast_ref::<ClientPane>()
+ .map(|client| client.frontend_geometry_mismatch(*size))
+ })
+ .flatten()
+ .unwrap_or_else(|| "rows_pending".to_string());
+ blockers.push(format!(
+ "{pane_id}:want={} {why}",
+ mux::geometrytrace::size(size)
+ ));
+ }
ready &= pane_ready;
}
@@ -422,6 +459,12 @@ impl super::TermWindow {
} else {
false
};
+ mux::zoom_trace!(
+ "gui.confirm.tick tab={tab_id} epoch={} ready={ready} settled={settled} \
+ blockers=[{}]",
+ confirmation.epoch,
+ blockers.join("; ")
+ );
if settled {
self.complete_frontend_geometry_epoch(tab_id, confirmation.epoch);
}
@@ -492,6 +535,7 @@ impl super::TermWindow {
panes.push(codec::ClientPaneViewport {
pane_id: positioned.pane.pane_id(),
size,
+ frame: self.frontend_frame_for_positioned_pane(&positioned),
});
adopted.push((positioned.pane.pane_id(), size));
}
@@ -1126,9 +1170,11 @@ impl super::TermWindow {
}
}
};
+ let size = self.terminal_size_for_positioned_pane(&positioned, metrics);
Some(codec::ClientPaneViewport {
pane_id: positioned.pane.pane_id(),
- size: self.terminal_size_for_positioned_pane(&positioned, metrics),
+ size,
+ frame: self.frontend_frame_for_positioned_pane(&positioned),
})
})
.collect()
@@ -1408,10 +1454,7 @@ impl super::TermWindow {
.unwrap_or_else(|| "-".to_string()),
adopted
.iter()
- .map(|(pane_id, size)| format!(
- "{pane_id}:{}",
- mux::geometrytrace::size(size)
- ))
+ .map(|(pane_id, size)| format!("{pane_id}:{}", mux::geometrytrace::size(size)))
.collect::<Vec<_>>()
.join(" ")
);
@@ -1555,9 +1598,11 @@ impl super::TermWindow {
}
}
};
+ let size = self.terminal_size_for_positioned_pane(&positioned, metrics);
Some(mux::FrontendPaneViewport {
pane_id: positioned.pane.pane_id(),
- size: self.terminal_size_for_positioned_pane(&positioned, metrics),
+ size,
+ frame: self.frontend_frame_for_positioned_pane(&positioned),
})
})
.collect()
@@ -1857,6 +1902,16 @@ impl super::TermWindow {
}
}
+ fn frontend_frame_for_positioned_pane(&self, pos: &PositionedPane) -> TerminalSize {
+ TerminalSize {
+ rows: pos.height,
+ cols: pos.width,
+ pixel_width: pos.pixel_width,
+ pixel_height: pos.pixel_height,
+ dpi: self.dimensions.dpi as u32,
+ }
+ }
+
fn sync_positioned_pane_font_size(&self, pos: &PositionedPane) -> anyhow::Result<()> {
let pane_id = pos.pane.pane_id();
let font_scale = self.pane_font_scale(pane_id);
@@ -2514,8 +2569,8 @@ pub fn effective_right_padding(config: &ConfigHandle, context: DimensionContext)
#[cfg(test)]
mod frontend_geometry_tests {
use super::{
- frontend_geometry_action, geometry_confirmation_settled, remote_divider_can_pump,
- remote_divider_target_is_owed, FrontendGeometryAction, FRONTEND_GEOMETRY_SETTLE,
+ FRONTEND_GEOMETRY_SETTLE, FrontendGeometryAction, frontend_geometry_action,
+ geometry_confirmation_settled, remote_divider_can_pump, remote_divider_target_is_owed,
};
use crate::termwindow::{FrontendGeometryPhase, RemoteDividerResizeStrategy};
use std::time::{Duration, Instant};
diff --git a/wezterm-gui/src/workspace_threads.rs b/wezterm-gui/src/workspace_threads.rs
index 0fc3a8cf..2a6be7c5 100644
--- a/wezterm-gui/src/workspace_threads.rs
+++ b/wezterm-gui/src/workspace_threads.rs
@@ -354,6 +354,7 @@ lazy_static::lazy_static! {
Mutex::new(std::collections::HashSet::new());
static ref WORK_RUNNING_LAST_SEEN: Mutex<HashMap<String, std::time::Instant>> =
Mutex::new(HashMap::new());
+ static ref WORK_SOUND_TIMING: Mutex<WorkSoundTiming> = Mutex::new(WorkSoundTiming::default());
static ref WORK_STATUS_RECHECK_PENDING: Mutex<std::collections::HashSet<String>> =
Mutex::new(std::collections::HashSet::new());
/// The sidebar tree each mux server last told us it had, keyed by domain
@@ -1448,6 +1449,63 @@ pub fn refresh_thread_work_for_pane(pane_id: PaneId) -> bool {
/// Running through short Idle observations; a deferred re-check settles the
/// state to Idle once the grace period truly elapses.
const WORK_RUNNING_FALL_DEBOUNCE: Duration = Duration::from_millis(800);
+const MIN_FINISHED_SOUND_DURATION: Duration = Duration::from_secs(5);
+
+#[derive(Debug)]
+struct WorkRunTiming {
+ started_at: std::time::Instant,
+ first_idle_at: Option<std::time::Instant>,
+}
+
+#[derive(Debug, Default)]
+struct WorkSoundTiming {
+ runs: HashMap<String, WorkRunTiming>,
+}
+
+impl WorkSoundTiming {
+ fn observe(
+ &mut self,
+ workspace: &str,
+ observed: WorkspaceThreadWorkStatus,
+ now: std::time::Instant,
+ ) {
+ match observed {
+ WorkspaceThreadWorkStatus::Running => {
+ let run = self
+ .runs
+ .entry(workspace.to_string())
+ .or_insert(WorkRunTiming {
+ started_at: now,
+ first_idle_at: None,
+ });
+ // A brief false Idle is already tolerated by the status
+ // debounce. If Running returns, that candidate was not the
+ // task's completion and must not determine its duration.
+ run.first_idle_at = None;
+ }
+ WorkspaceThreadWorkStatus::Idle | WorkspaceThreadWorkStatus::FinishedUnseen => {
+ if let Some(run) = self.runs.get_mut(workspace) {
+ run.first_idle_at.get_or_insert(now);
+ }
+ }
+ WorkspaceThreadWorkStatus::NeedsAttention => {
+ if let Some(run) = self.runs.get_mut(workspace) {
+ run.first_idle_at = None;
+ }
+ }
+ }
+ }
+
+ fn take_finished_duration(&mut self, workspace: &str) -> Option<Duration> {
+ let run = self.runs.remove(workspace)?;
+ let finished_at = run.first_idle_at.unwrap_or_else(std::time::Instant::now);
+ Some(finished_at.saturating_duration_since(run.started_at))
+ }
+
+ fn forget(&mut self, workspace: &str) {
+ self.runs.remove(workspace);
+ }
+}
fn debounce_work_status(
workspace: &str,
@@ -1509,13 +1567,28 @@ static NEEDS_INPUT_WAV: &[u8] = include_bytes!("../../assets/sounds/needs-input.
/// business making noise, and neither does a machine someone is presenting on.
const DISABLE_SOUND_ENV: &str = "THINKTERM_DISABLE_SOUND";
-fn announce_work(announcement: WorkAnnouncement) {
+fn should_play_work_sound(
+ announcement: WorkAnnouncement,
+ finished_after: Option<Duration>,
+) -> bool {
+ match announcement {
+ WorkAnnouncement::Finished => finished_after
+ .map(|duration| duration >= MIN_FINISHED_SOUND_DURATION)
+ .unwrap_or(true),
+ WorkAnnouncement::NeedsInput => true,
+ }
+}
+
+fn announce_work(announcement: WorkAnnouncement, finished_after: Option<Duration>) {
if std::env::var_os(DISABLE_SOUND_ENV).is_some() {
return;
}
if !crate::native_settings::notification_sounds_enabled() {
return;
}
+ if !should_play_work_sound(announcement, finished_after) {
+ return;
+ }
let wav = match announcement {
WorkAnnouncement::Finished => DONE_WAV,
WorkAnnouncement::NeedsInput => NEEDS_INPUT_WAV,
@@ -1531,8 +1604,8 @@ fn announce_work(announcement: WorkAnnouncement) {
}
pub fn refresh_thread_work_for_workspace(workspace: &str) -> bool {
- let observed = scan_workspace_work_status(workspace);
- let observed = debounce_work_status(workspace, observed);
+ let raw_observed = scan_workspace_work_status(workspace);
+ let observed = debounce_work_status(workspace, raw_observed);
let change = {
let mut store = THREAD_STORE.lock();
let Some(change) = store.observe_thread_work_for_workspace(workspace, observed) else {
@@ -1540,8 +1613,17 @@ pub fn refresh_thread_work_for_workspace(workspace: &str) -> bool {
};
change
};
+ let finished_after = {
+ let mut timing = WORK_SOUND_TIMING.lock();
+ timing.observe(workspace, raw_observed, std::time::Instant::now());
+ if change.announce == Some(WorkAnnouncement::Finished) {
+ timing.take_finished_duration(workspace)
+ } else {
+ None
+ }
+ };
if let Some(announcement) = change.announce {
- announce_work(announcement);
+ announce_work(announcement, finished_after);
}
if change.should_persist {
schedule_workspace_thread_store_persist();
@@ -1565,6 +1647,7 @@ pub fn refresh_all_thread_work() -> bool {
}
pub fn acknowledge_thread_work_for_workspace(workspace: &str) -> bool {
+ WORK_SOUND_TIMING.lock().forget(workspace);
let mut store = THREAD_STORE.lock();
let change = store.acknowledge_thread_work_for_workspace(workspace);
if change.should_persist {
@@ -1629,6 +1712,7 @@ pub fn hidden_statuses_cover_all(hidden: &[WorkspaceThreadWorkStatus]) -> bool {
}
pub fn acknowledge_thread_work_for_workspace_deferred(workspace: &str) -> bool {
+ WORK_SOUND_TIMING.lock().forget(workspace);
let mut store = THREAD_STORE.lock();
let change = store.acknowledge_thread_work_for_workspace(workspace);
if change.should_persist {
@@ -7120,6 +7204,75 @@ mod tests {
);
}
+ #[test]
+ fn short_finished_work_is_silent_but_five_seconds_plays() {
+ assert!(!should_play_work_sound(
+ WorkAnnouncement::Finished,
+ Some(Duration::from_millis(4_999))
+ ));
+ assert!(should_play_work_sound(
+ WorkAnnouncement::Finished,
+ Some(Duration::from_secs(5))
+ ));
+ assert!(should_play_work_sound(
+ WorkAnnouncement::NeedsInput,
+ Some(Duration::from_millis(1))
+ ));
+ }
+
+ #[test]
+ fn finished_sound_duration_excludes_the_idle_confirmation_delay() {
+ let mut timing = WorkSoundTiming::default();
+ let started_at = std::time::Instant::now();
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Running,
+ started_at,
+ );
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Idle,
+ started_at + Duration::from_millis(2_500),
+ );
+
+ assert_eq!(
+ timing.take_finished_duration("workspace-1"),
+ Some(Duration::from_millis(2_500)),
+ "the 800ms status debounce must not turn a short task into an audible one"
+ );
+ }
+
+ #[test]
+ fn transient_idle_does_not_end_the_timed_run() {
+ let mut timing = WorkSoundTiming::default();
+ let started_at = std::time::Instant::now();
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Running,
+ started_at,
+ );
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Idle,
+ started_at + Duration::from_secs(1),
+ );
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Running,
+ started_at + Duration::from_millis(1_100),
+ );
+ timing.observe(
+ "workspace-1",
+ WorkspaceThreadWorkStatus::Idle,
+ started_at + Duration::from_secs(4),
+ );
+
+ assert_eq!(
+ timing.take_finished_duration("workspace-1"),
+ Some(Duration::from_secs(4))
+ );
+ }
+
/// Going idle without ever having run is a thread that did nothing, not a
/// thread that finished something.
#[test]
diff --git a/wezterm-mux-server-impl/src/sessionhandler.rs b/wezterm-mux-server-impl/src/sessionhandler.rs
index cda80138..06ba55f2 100644
--- a/wezterm-mux-server-impl/src/sessionhandler.rs
+++ b/wezterm-mux-server-impl/src/sessionhandler.rs
@@ -1,8 +1,8 @@
use crate::PKI;
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
use codec::*;
-use config::keyassignment::SpawnTabDomain;
use config::TermConfig;
+use config::keyassignment::SpawnTabDomain;
use mux::client::ClientId;
use mux::domain::SplitSource;
use mux::pane::{CachePolicy, Pane, PaneId};
@@ -19,9 +19,9 @@ use std::sync::{Arc, Mutex};
use std::time::Instant;
use termwiz::surface::SequenceNo;
use url::Url;
+use wezterm_term::StableRowIndex;
use wezterm_term::color::ColorPalette;
use wezterm_term::terminal::Alert;
-use wezterm_term::StableRowIndex;
lazy_static::lazy_static! {
/// Serializes the authoritative tree decision with the live-workspace
@@ -312,6 +312,7 @@ fn mux_viewport(viewport: ClientViewport) -> FrontendViewport {
.map(|pane| FrontendPaneViewport {
pane_id: pane.pane_id,
size: pane.size,
+ frame: pane.frame,
})
.collect(),
},
@@ -995,7 +996,13 @@ impl SessionHandler {
anyhow::bail!("pane {pane_id} is not in tab {containing_tab_id}");
}
pane.resize(size)?;
- tab.rebuild_splits_sizes_from_contained_panes();
+ // A legacy single-pane Resize carries no pane
+ // frame. It may update the PTY surface, but it
+ // cannot safely redefine split geometry: font
+ // scaling and frontend chrome make the surface
+ // smaller than its containing rectangle. Complete
+ // Native viewports carry exact frames and are the
+ // sole source for divider reconstruction.
Ok(Pdu::UnitResponse(UnitResponse {}))
},
send_response,
@@ -1570,7 +1577,7 @@ impl SessionHandler {
return Err(anyhow!(
"Failed to retrieve tab with ID {}",
tab_id
- ))
+ ));
}
};
@@ -1912,13 +1919,13 @@ async fn move_pane(
#[cfg(test)]
mod tests {
- use super::{claim_viewport_for_pane, requires_existing_frontend_access, PerPane};
+ use super::{PerPane, claim_viewport_for_pane, requires_existing_frontend_access};
use codec::{EnsureThinkTermThread, Pdu};
- use mux::client::ClientId;
use mux::Mux;
+ use mux::client::ClientId;
use std::sync::Arc;
- use wezterm_term::color::ColorPalette;
use wezterm_term::TerminalSize;
+ use wezterm_term::color::ColorPalette;
#[test]
fn cold_thread_materialization_does_not_require_an_existing_owner() {