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.

Add zoom/geometry tracing and pane-size fixes

RoversXdda8ea446aa0
diff --git a/mux/src/geometrytrace.rs b/mux/src/geometrytrace.rs
new file mode 100644
index 00000000..73894efe
--- /dev/null
+++ b/mux/src/geometrytrace.rs
@@ -0,0 +1,147 @@
+//! Opt-in, one-record-per-transition tracing for the pane zoom / frontend
+//! viewport geometry path.
+//!
+//! Zoom is the only geometry transition that is not atomic across the mux
+//! boundary: the GUI sends `SetPaneZoomed` and `SetClientViewport` from two
+//! independent detached tasks, and the server keeps its own split tree whose
+//! root is back-derived from pane dimensions. Reasoning about that from unit
+//! tests alone has repeatedly proved insufficient, so this module exists to
+//! record the *real* order and the *real* numbers on both processes.
+//!
+//! Enable it on the GUI and on the mux server with:
+//!
+//! ```text
+//! WEZTERM_LOG=info,zoomtrace=debug
+//! ```
+//!
+//! Everything here is inert unless that filter is active: each record is
+//! wrapped in [`trace_enabled`] so a disabled build performs no pane-tree
+//! walks, takes no extra locks, and formats no strings.
+
+use crate::pane::{Pane, PaneId};
+use crate::tab::{PositionedPane, PositionedSplit, SplitDirection};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use wezterm_term::TerminalSize;
+
+/// Log target for every record emitted by [`zoom_trace!`].
+pub const TARGET: &str = "zoomtrace";
+
+/// True when the `zoomtrace` target is enabled at debug level.
+///
+/// Callers must check this before gathering trace data; the `log::debug!`
+/// macro only consults the global max level, not the per-target filter, so
+/// an unguarded record would still walk the pane tree on any debug-enabled
+/// run.
+pub fn trace_enabled() -> bool {
+ log::log_enabled!(target: TARGET, log::Level::Debug)
+}
+
+static SEQ: AtomicU64 = AtomicU64::new(1);
+
+/// Process-local monotonic record number.
+///
+/// Log timestamps are millisecond resolution and several of these records are
+/// emitted back-to-back, so the sequence number is what makes the ordering
+/// within one process unambiguous.
+pub fn next_seq() -> u64 {
+ SEQ.fetch_add(1, Ordering::Relaxed)
+}
+
+/// Emit one `zoomtrace` record, doing no work when the target is disabled.
+#[macro_export]
+macro_rules! zoom_trace {
+ ($($arg:tt)*) => {
+ if $crate::geometrytrace::trace_enabled() {
+ ::log::debug!(
+ target: $crate::geometrytrace::TARGET,
+ "#{} {}",
+ $crate::geometrytrace::next_seq(),
+ format_args!($($arg)*)
+ );
+ }
+ };
+}
+
+/// `COLSxROWS/PXxPY`
+pub fn size(size: &TerminalSize) -> String {
+ format!(
+ "{}x{}/{}x{}",
+ size.cols, size.rows, size.pixel_width, size.pixel_height
+ )
+}
+
+/// The pane's own view of its grid, in the same shape as [`size`].
+pub fn dims(pane: &Arc<dyn Pane>) -> String {
+ let dims = pane.get_dimensions();
+ format!(
+ "{}x{}/{}x{}",
+ dims.cols, dims.viewport_rows, dims.pixel_width, dims.pixel_height
+ )
+}
+
+/// `mirror=.. root=.. zoom=.. splits=[..] panes=[id r=<rect> d=<grid> ..]`
+///
+/// `r` is the rectangle the split tree assigns to the pane and `d` is the
+/// dimensions the pane itself reports. On the mux server those two must
+/// agree once a transition has settled; on a GUI mirror (`mirror=true`) `d`
+/// sits below `r` by the per-pane nav bar, so compare the pixel heights
+/// rather than expecting equality.
+///
+/// `panes` deliberately ignores zoom so the preserved split rectangles stay
+/// visible across the transition; `splits` does not, so a zoomed tab always
+/// reports `splits=[]`.
+pub fn geometry(
+ mirror: bool,
+ root: &TerminalSize,
+ zoomed: Option<PaneId>,
+ splits: &[PositionedSplit],
+ panes: &[PositionedPane],
+) -> String {
+ let splits = splits
+ .iter()
+ .map(|split| {
+ format!(
+ "{}:{}@{},{}+{}",
+ split.index,
+ match split.direction {
+ SplitDirection::Horizontal => "H",
+ SplitDirection::Vertical => "V",
+ },
+ split.left,
+ split.top,
+ split.size
+ )
+ })
+ .collect::<Vec<_>>()
+ .join(" ");
+ let panes = panes
+ .iter()
+ .map(|pos| {
+ format!(
+ "{} r={}x{}/{}x{}@{},{} d={}",
+ pos.pane.pane_id(),
+ pos.width,
+ pos.height,
+ pos.pixel_width,
+ pos.pixel_height,
+ pos.left,
+ pos.top,
+ dims(&pos.pane),
+ )
+ })
+ .collect::<Vec<_>>()
+ .join("; ");
+ let zoom = match zoomed {
+ Some(pane_id) => pane_id.to_string(),
+ None => "-".to_string(),
+ };
+ format!(
+ "mirror={} root={} zoom={} splits=[{}] panes=[{}]",
+ mirror,
+ size(root),
+ zoom,
+ splits,
+ panes
+ )
+}
diff --git a/mux/src/lib.rs b/mux/src/lib.rs
index 4e057cfd..3841194d 100644
--- a/mux/src/lib.rs
+++ b/mux/src/lib.rs
@@ -40,6 +40,7 @@ pub mod activity;
pub mod client;
pub mod connui;
pub mod domain;
+pub mod geometrytrace;
pub mod localpane;
pub mod pane;
pub mod renderable;
@@ -1428,6 +1429,33 @@ impl Mux {
let tab = self
.get_tab(tab_id)
.ok_or_else(|| anyhow!("no such tab {tab_id}"))?;
+ if crate::geometrytrace::trace_enabled() {
+ let incoming = match viewport {
+ FrontendViewport::CellGrid { size } => {
+ format!("kind=cellgrid in={}", crate::geometrytrace::size(size))
+ }
+ FrontendViewport::Native { size, panes } => format!(
+ "kind=native in={} covers_all={} in_panes=[{}]",
+ crate::geometrytrace::size(size),
+ tab.viewport_covers_all_panes(
+ &panes.iter().map(|pane| pane.pane_id).collect::<Vec<_>>()
+ ),
+ panes
+ .iter()
+ .map(|pane| format!(
+ "{}:{}",
+ pane.pane_id,
+ crate::geometrytrace::size(&pane.size)
+ ))
+ .collect::<Vec<_>>()
+ .join(" ")
+ ),
+ };
+ crate::zoom_trace!(
+ "srv.viewport.recv tab={tab_id} {incoming} | {}",
+ tab.geometry_trace()
+ );
+ }
let mut transaction = self.begin_tab_geometry_transaction(tab_id);
let result = (|| {
let size = viewport.size();
@@ -1435,6 +1463,8 @@ impl Mux {
tab.resize(size);
if let FrontendViewport::Native { panes, .. } = viewport {
+ let pane_ids = panes.iter().map(|pane| pane.pane_id).collect::<Vec<_>>();
+ let viewport_covers_all_panes = tab.viewport_covers_all_panes(&pane_ids);
for pane_viewport in panes {
let pane = self
.get_pane(pane_viewport.pane_id)
@@ -1445,7 +1475,7 @@ impl Mux {
self.frontend_geometry_step("resizing a native pane")?;
pane.resize(pane_viewport.size)?;
}
- if !panes.is_empty() {
+ if !panes.is_empty() && viewport_covers_all_panes {
tab.rebuild_splits_sizes_from_contained_panes();
}
return Ok(());
@@ -1461,6 +1491,11 @@ impl Mux {
if result.is_ok() {
transaction.commit();
}
+ crate::zoom_trace!(
+ "srv.viewport.done tab={tab_id} ok={} | {}",
+ result.is_ok(),
+ tab.geometry_trace()
+ );
result
}
diff --git a/mux/src/tab.rs b/mux/src/tab.rs
index 128eb9a5..1217005c 100644
--- a/mux/src/tab.rs
+++ b/mux/src/tab.rs
@@ -788,27 +788,52 @@ fn copy_split_geometry_if_topology_matches(old: &Tree, new: &mut Tree) -> bool {
/// Recompute split node sizes bottom-up from the contained panes'
/// current dimensions, returning the aggregate size of the tree.
-fn compute_tree_size_from_panes(node: &mut Tree) -> Option<TerminalSize> {
+///
+/// `tab_cell` carries the tab's own cell size, as produced by
+/// [`cell_dimensions`]. The split tree is denominated in tab cells, but a
+/// pane with its own font scale measures the same rectangle in a different
+/// number of *its* cells. Taking `dims.cols` straight from such a pane and
+/// adding it to a sibling's sums two different units: a 1708px pane of
+/// 14px cells reports 122 columns next to a 475px sibling of 19px cells
+/// reporting 25, and `SplitDirectionAndSize::size` then calls the parent
+/// 148 columns wide when the tab is really 116. Convert through pixels,
+/// which are the one unit every pane in the tab agrees on.
+fn compute_tree_size_from_panes(node: &mut Tree, tab_cell: &TerminalSize) -> Option<TerminalSize> {
match node {
Tree::Empty => None,
Tree::Leaf(stack) => {
let pane = stack.active_pane()?;
let dims = pane.get_dimensions();
+ let cell_width = tab_cell.pixel_width;
+ let cell_height = tab_cell.pixel_height;
+ // Fall back to the pane's own counts when it cannot describe
+ // itself in pixels; that is the pre-conversion behaviour and is
+ // still correct for a pane whose cells match the tab's.
+ let cols = if cell_width > 0 && dims.pixel_width > 0 {
+ (dims.pixel_width / cell_width).max(1)
+ } else {
+ dims.cols
+ };
+ let rows = if cell_height > 0 && dims.pixel_height > 0 {
+ (dims.pixel_height / cell_height).max(1)
+ } else {
+ dims.viewport_rows
+ };
let size = TerminalSize {
- cols: dims.cols,
- rows: dims.viewport_rows,
- pixel_height: dims.pixel_height,
- pixel_width: dims.pixel_width,
+ cols,
+ rows,
+ pixel_width: cols * cell_width.max(1),
+ pixel_height: rows * cell_height.max(1),
dpi: dims.dpi,
};
Some(size)
}
Tree::Node { left, right, data } => {
if let Some(data) = data {
- if let Some(first) = compute_tree_size_from_panes(left) {
+ if let Some(first) = compute_tree_size_from_panes(left, tab_cell) {
data.first = first;
}
- if let Some(second) = compute_tree_size_from_panes(right) {
+ if let Some(second) = compute_tree_size_from_panes(right, tab_cell) {
data.second = second;
}
Some(data.size())
@@ -896,6 +921,25 @@ impl Tab {
self.inner.lock().contains_pane(pane)
}
+ /// Whether a native frontend viewport describes every split leaf in this
+ /// tab. Zoomed frontends intentionally report just the pane that fills
+ /// the root, and that viewport can race ahead of the separate zoom RPC.
+ /// Such a partial report must not be used to rebuild the full split tree.
+ /// One-line geometry snapshot for the `zoomtrace` log target. Takes the
+ /// tab lock once so the splits and the pane dimensions in one record
+ /// describe the same instant. See [`crate::geometrytrace`].
+ pub fn geometry_trace(&self) -> String {
+ self.inner.lock().geometry_trace()
+ }
+
+ pub(crate) fn viewport_covers_all_panes(&self, pane_ids: &[PaneId]) -> bool {
+ let panes = self.inner.lock().iter_panes_ignoring_zoom();
+ panes.len() == pane_ids.len()
+ && panes
+ .iter()
+ .all(|pane| pane_ids.contains(&pane.pane.pane_id()))
+ }
+
pub fn iter_panes(&self) -> Vec<PositionedPane> {
self.inner.lock().iter_panes()
}
@@ -1301,8 +1345,16 @@ impl TabInner {
// the geometry) was preserved above, skip the recompute so the
// resize sees agreeing sizes and no-ops without a TabResized.
if !geometry_preserved {
+ // Measure the wire's panes against the cells of the size we are
+ // about to impose; a pane carrying its own font scale counts a
+ // different number of its own cells across the same pixels.
+ let cell = cell_dimensions(if size.rows > 0 && size.cols > 0 {
+ &size
+ } else {
+ &self.size
+ });
if let Some(root) = self.pane.as_mut() {
- if let Some(tree_size) = compute_tree_size_from_panes(root) {
+ if let Some(tree_size) = compute_tree_size_from_panes(root, &cell) {
self.size = tree_size;
}
}
@@ -1377,6 +1429,17 @@ impl TabInner {
}
}
+ fn geometry_trace(&mut self) -> String {
+ let root = self.size;
+ let zoomed = self.zoomed.as_ref().map(|pane| pane.pane_id());
+ let splits = self.iter_splits();
+ let panes = self.iter_panes_ignoring_zoom();
+ let mirror = panes
+ .first()
+ .is_some_and(|positioned| positioned.pane.is_remote_mirror());
+ crate::geometrytrace::geometry(mirror, &root, zoomed, &splits, &panes)
+ }
+
/// Sets the zoom state, returns the prior state
fn set_zoomed(&mut self, zoomed: bool) -> bool {
if self.zoomed.is_some() == zoomed {
@@ -1390,14 +1453,33 @@ impl TabInner {
fn toggle_zoom(&mut self) {
let size = self.size;
- if self.zoomed.take().is_some() {
+ let zooming = self.zoomed.is_none();
+ let action = if zooming { "zoom" } else { "unzoom" };
+ if crate::geometrytrace::trace_enabled() {
+ let head = format!(
+ "tab.zoom.begin tab={} action={action} before_zoom={}",
+ self.id,
+ crate::geometrytrace::size(&self.size_before_zoom)
+ );
+ let geometry = self.geometry_trace();
+ crate::zoom_trace!("{head} | {geometry}");
+ }
+ // Only the unzoom branch consults Tab::resize; `n/a` distinguishes
+ // "the zoom branch never asked" from "the resize was a no-op".
+ let mut resize_applied = "n/a".to_string();
+ if let Some(zoomed) = self.zoomed.take() {
// We were zoomed, but now we are not.
- // Re-apply the size to the panes
- if let Some(pane) = self.get_active_pane() {
- pane.set_zoomed(false);
- }
+ // Clear the flag on the pane that actually holds the zoom rather
+ // than on whatever is active now. Pane-nav selects its target
+ // index before toggling, and unzoom_on_switch_pane unzooms from
+ // inside a focus change, so the active pane is routinely some
+ // other pane by this point. A mux client that names the wrong
+ // pane makes the server's SetPaneZoomed handler compare against a
+ // pane that was never zoomed, conclude nothing needs to change,
+ // and stay zoomed while this frontend has already unzoomed.
+ zoomed.set_zoomed(false);
self.size = self.size_before_zoom;
- self.resize(size);
+ resize_applied = self.resize(size).to_string();
} else {
// We weren't zoomed, but now we want to zoom.
// Locate the active pane
@@ -1418,6 +1500,16 @@ impl TabInner {
self.zoomed.replace(pane);
}
}
+ if crate::geometrytrace::trace_enabled() {
+ let head = format!(
+ "tab.zoom.end tab={} action={action} resize_applied={resize_applied} \
+ before_zoom={}",
+ self.id,
+ crate::geometrytrace::size(&self.size_before_zoom)
+ );
+ let geometry = self.geometry_trace();
+ crate::zoom_trace!("{head} | {geometry}");
+ }
Mux::try_get().map(|mux| mux.notify(MuxNotification::TabResized(self.id)));
}
@@ -1802,6 +1894,7 @@ impl TabInner {
// Ignore "impossible" resize requests
return false;
}
+ let current = self.size;
// No-op resizes must not emit TabResized: for mux client tabs the
// notification round-trips through the server and triggers a resync
@@ -1809,6 +1902,11 @@ impl TabInner {
// transient client/server size disagreement into an endless
// resize/resync storm that visibly flickers the window contents.
if size == self.size {
+ crate::zoom_trace!(
+ "tab.resize.noop tab={} reason=unchanged want={}",
+ self.id,
+ crate::geometrytrace::size(&size)
+ );
return false;
}
@@ -1841,6 +1939,11 @@ impl TabInner {
// this second check, a GUI recovery pass can emit TabResized on
// every frame even though no geometry can change.
if size == self.size {
+ crate::zoom_trace!(
+ "tab.resize.noop tab={} reason=clamped_to_min want={} min={min_x}x{min_y}",
+ self.id,
+ crate::geometrytrace::size(&size)
+ );
return false;
}
@@ -1864,6 +1967,16 @@ impl TabInner {
}
}
+ if crate::geometrytrace::trace_enabled() {
+ let head = format!(
+ "tab.resize tab={} {} -> {}",
+ self.id,
+ crate::geometrytrace::size(&current),
+ crate::geometrytrace::size(&self.size)
+ );
+ let geometry = self.geometry_trace();
+ crate::zoom_trace!("{head} | {geometry}");
+ }
Mux::try_get().map(|mux| mux.notify(MuxNotification::TabResized(self.id)));
true
}
@@ -1909,14 +2022,52 @@ impl TabInner {
fn rebuild_splits_sizes_from_contained_panes(&mut self) {
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;
}
+ // 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) {
- self.size = size;
+ 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,
+ );
}
}
+ if crate::geometrytrace::trace_enabled() {
+ let head = format!(
+ "tab.rebuild tab={} root={} derived={} (root kept)",
+ self.id,
+ crate::geometrytrace::size(&root_size),
+ derived
+ .map(|size| crate::geometrytrace::size(&size))
+ .unwrap_or_else(|| "-".to_string())
+ );
+ let geometry = self.geometry_trace();
+ crate::zoom_trace!("{head} | {geometry}");
+ }
Mux::try_get().map(|mux| mux.notify(MuxNotification::TabResized(self.id)));
}
@@ -3532,6 +3683,7 @@ impl Into<String> for SerdeUrl {
mod test {
use super::*;
use crate::renderable::*;
+ use crate::{FrontendPaneViewport, FrontendViewport};
use parking_lot::{MappedMutexGuard, Mutex};
use rangeset::RangeSet;
use std::ops::Range;
@@ -3544,6 +3696,9 @@ mod test {
id: PaneId,
size: Mutex<TerminalSize>,
remote_mirror: bool,
+ /// The most recent Pane::set_zoomed argument, so tests can assert
+ /// which pane a zoom transition actually addressed.
+ last_set_zoomed: Mutex<Option<bool>>,
}
impl FakePane {
@@ -3552,6 +3707,7 @@ mod test {
id,
size: Mutex::new(size),
remote_mirror: false,
+ last_set_zoomed: Mutex::new(None),
})
}
@@ -3560,10 +3716,19 @@ mod test {
id,
size: Mutex::new(size),
remote_mirror: true,
+ last_set_zoomed: Mutex::new(None),
})
}
}
+ fn last_set_zoomed(pane: &Arc<dyn Pane>) -> Option<bool> {
+ *pane
+ .downcast_ref::<FakePane>()
+ .expect("test panes are FakePane")
+ .last_set_zoomed
+ .lock()
+ }
+
impl Pane for FakePane {
fn pane_id(&self) -> PaneId {
self.id
@@ -3641,6 +3806,10 @@ mod test {
Ok(())
}
+ fn set_zoomed(&self, zoomed: bool) {
+ self.last_set_zoomed.lock().replace(zoomed);
+ }
+
fn key_down(&self, _key: KeyCode, _mods: KeyModifiers) -> anyhow::Result<()> {
unimplemented!()
}
@@ -3966,6 +4135,287 @@ mod test {
assert_eq!(tab.iter_panes()[0].height, tab_size.rows);
}
+ #[test]
+ fn unzoom_preserves_the_divider_and_leaves_pty_sizing_to_the_frontend() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let tab = Tab::new(&tab_size);
+ let first = FakePane::new(1, tab_size);
+ tab.assign_pane(&first);
+
+ let split_size = tab
+ .compute_split_size(
+ 0,
+ SplitRequest {
+ direction: SplitDirection::Horizontal,
+ ..Default::default()
+ },
+ )
+ .expect("initial tab can split");
+ let second = FakePane::new(2, split_size.second);
+ tab.split_and_insert(
+ 0,
+ SplitRequest {
+ direction: SplitDirection::Horizontal,
+ ..Default::default()
+ },
+ Arc::clone(&second),
+ )
+ .expect("split succeeds");
+
+ // Reproduce the GUI sequence: establish a non-default divider,
+ // zoom the active pane without changing the tab root, then unzoom.
+ tab.resize_split_by(0, 7);
+ let before_zoom = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ tab.toggle_zoom();
+ assert_eq!(second.get_dimensions().cols, tab_size.cols);
+ tab.toggle_zoom();
+
+ let after_unzoom = tab.iter_panes();
+ assert_eq!(
+ after_unzoom
+ .iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before_zoom,
+ "unzoom must preserve the divider position"
+ );
+
+ // The tab deliberately does NOT push its split rectangles back onto
+ // the PTYs here. Those rectangles are denominated in tab cells, and
+ // a pane carrying its own font scale needs a different column count
+ // for the very same pixels, so re-applying them would overwrite a
+ // correct size with a wrong one. Sizing is the frontend's job: both
+ // the mux (Native viewport) and local (sync_positioned_pane_font_size)
+ // paths follow every zoom transition with a font-scale-aware resize
+ // of each visible pane.
+ assert_eq!(
+ second.get_dimensions().cols,
+ tab_size.cols,
+ "the formerly zoomed PTY keeps its zoom size until the frontend resizes it"
+ );
+ }
+
+ #[test]
+ fn partial_zoom_viewport_does_not_rebuild_split_tree_before_zoom_rpc() {
+ 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 split_size = tab
+ .compute_split_size(
+ 0,
+ SplitRequest {
+ direction: SplitDirection::Horizontal,
+ ..Default::default()
+ },
+ )
+ .expect("initial tab can split");
+ let second = FakePane::new(2, split_size.second);
+ tab.split_and_insert(
+ 0,
+ SplitRequest {
+ direction: SplitDirection::Horizontal,
+ ..Default::default()
+ },
+ Arc::clone(&second),
+ )
+ .expect("split succeeds");
+ mux.add_pane(&second).unwrap();
+
+ tab.resize_split_by(0, 7);
+ let before_zoom = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+
+ assert!(tab.viewport_covers_all_panes(&[1, 2]));
+ assert!(
+ !tab.viewport_covers_all_panes(&[2]),
+ "a zoom viewport can race ahead of SetPaneZoomed and must remain partial"
+ );
+
+ // The GUI's zoom viewport can arrive before SetPaneZoomed. It only
+ // contains the active pane at the full root size. Applying that pane
+ // size is harmless, but rebuilding the whole split tree here would
+ // add the full-width pane to its sibling and permanently enlarge the
+ // tab root before the zoom RPC arrives.
+ mux.apply_frontend_viewport(
+ tab.tab_id(),
+ &FrontendViewport::Native {
+ size: tab_size,
+ panes: vec![FrontendPaneViewport {
+ pane_id: second.pane_id(),
+ size: tab_size,
+ }],
+ },
+ )
+ .unwrap();
+ assert_eq!(tab.get_size(), tab_size);
+
+ // Complete the actual out-of-order sequence and verify that unzoom
+ // returns the divider to its original position. The PTY dimensions
+ // are the frontend's to restore; see
+ // unzoom_preserves_the_divider_and_leaves_pty_sizing_to_the_frontend.
+ tab.toggle_zoom();
+ tab.toggle_zoom();
+ assert_eq!(
+ tab.iter_panes()
+ .iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ before_zoom
+ );
+ }
+
+ /// Build a two-pane horizontally split tab registered with the mux.
+ fn split_tab_for_viewport(tab_size: TerminalSize) -> (Arc<Tab>, Arc<dyn Pane>, Arc<dyn Pane>) {
+ 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::Horizontal,
+ ..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();
+ (tab, first, second)
+ }
+
+ #[test]
+ fn a_font_scaled_pane_must_not_redefine_the_tab_root() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let mux = Mux::get();
+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);
+
+ // The frontend renders the left pane with half-width cells: the same
+ // pixel rectangle, twice the columns. Adding that column count to a
+ // sibling measured in the tab's own cells is adding two different
+ // units, and it is what made a 116-column tab report itself as 148.
+ let viewport_panes = tab
+ .iter_panes()
+ .into_iter()
+ .map(|positioned| {
+ let scaled = positioned.pane.pane_id() == 1;
+ let divisor = if scaled { 2 } else { 1 };
+ FrontendPaneViewport {
+ pane_id: positioned.pane.pane_id(),
+ size: TerminalSize {
+ cols: positioned.width * divisor,
+ rows: positioned.height,
+ pixel_width: positioned.pixel_width,
+ pixel_height: positioned.pixel_height,
+ dpi: tab_size.dpi,
+ },
+ }
+ })
+ .collect::<Vec<_>>();
+ let viewport = FrontendViewport::Native {
+ size: tab_size,
+ panes: viewport_panes,
+ };
+
+ let before = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ mux.apply_frontend_viewport(tab.tab_id(), &viewport).unwrap();
+ assert_eq!(
+ tab.get_size(),
+ tab_size,
+ "the frontend's reported root is authoritative; a font-scaled \
+ pane's column count must not redefine it"
+ );
+ let settled = tab
+ .iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>();
+ assert_eq!(
+ settled, before,
+ "the viewport describes the layout the tab already has, so \
+ applying it must leave the divider alone; counting the scaled \
+ pane's own columns instead makes the tree look far too wide and \
+ the correcting shrink drags the divider across the tab"
+ );
+
+ // Re-reporting the identical viewport has to be inert too. When the
+ // 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();
+ assert_eq!(tab.get_size(), tab_size);
+ assert_eq!(
+ tab.iter_panes()
+ .into_iter()
+ .map(|pane| (pane.pane.pane_id(), pane.width, pane.height))
+ .collect::<Vec<_>>(),
+ settled,
+ "repeating an unchanged viewport must not move the dividers"
+ );
+ }
+ }
+
+ #[test]
+ fn unzoom_clears_the_zoom_flag_on_the_pane_that_holds_it() {
+ let _mux = install_mux();
+ let tab_size = test_size();
+ let (tab, first, second) = split_tab_for_viewport(tab_size);
+
+ let index_of = |pane_id: PaneId| {
+ tab.iter_panes_ignoring_zoom()
+ .into_iter()
+ .find(|positioned| positioned.pane.pane_id() == pane_id)
+ .map(|positioned| positioned.index)
+ .expect("pane is in the tab")
+ };
+
+ tab.set_active_idx(index_of(2));
+ tab.toggle_zoom();
+ assert_eq!(last_set_zoomed(&second), Some(true));
+
+ // Pane-nav selects the pane it is acting on before toggling, and
+ // unzoom_on_switch_pane unzooms from inside a focus change, so the
+ // active pane is routinely not the zoomed one by the time unzoom
+ // runs. Addressing the active pane here made a mux client send
+ // SetPaneZoomed for a pane the server never had zoomed, whose
+ // handler then concluded nothing had to change and stayed zoomed.
+ tab.set_active_idx(index_of(1));
+ tab.toggle_zoom();
+
+ assert_eq!(
+ last_set_zoomed(&second),
+ Some(false),
+ "unzoom must clear the flag on the pane that was zoomed"
+ );
+ assert_eq!(
+ last_set_zoomed(&first),
+ None,
+ "the merely-active pane was never zoomed and must not be told to unzoom"
+ );
+ }
+
#[test]
fn pane_stack_add_switch_and_remove() {
let _mux = install_mux();
diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rs
index a6b294b5..54969c31 100644
--- a/wezterm-client/src/domain.rs
+++ b/wezterm-client/src/domain.rs
@@ -2064,6 +2064,37 @@ impl ClientDomain {
})
}
+ /// Summarize an outgoing viewport for the `zoomtrace` log target, using
+ /// the remote pane ids so a GUI record can be lined up with the mux
+ /// server's `srv.viewport.recv` for the same PDU.
+ fn viewport_trace(viewport: &codec::ClientViewport) -> String {
+ match viewport {
+ codec::ClientViewport::CellGrid { size } => {
+ format!("kind=cellgrid out={}", mux::geometrytrace::size(size))
+ }
+ codec::ClientViewport::Native { size, panes } => format!(
+ "kind=native out={} out_panes=[{}]",
+ mux::geometrytrace::size(size),
+ panes
+ .iter()
+ .map(|pane| format!(
+ "r{}:{}",
+ pane.pane_id,
+ mux::geometrytrace::size(&pane.size)
+ ))
+ .collect::<Vec<_>>()
+ .join(" ")
+ ),
+ }
+ }
+
+ fn local_tab_geometry_trace(local_tab_id: TabId) -> String {
+ Mux::get()
+ .get_tab(local_tab_id)
+ .map(|tab| tab.geometry_trace())
+ .unwrap_or_else(|| "<no local tab>".to_string())
+ }
+
/// Report the viewport for a locally mirrored tab to the frontend mux.
pub async fn set_client_viewport(
&self,
@@ -2079,6 +2110,15 @@ impl ClientDomain {
let viewport = self.translate_client_viewport(viewport)?;
let reported = viewport.clone();
let started_at = Instant::now();
+ if mux::geometrytrace::trace_enabled() {
+ let summary = Self::viewport_trace(&viewport);
+ let geometry = Self::local_tab_geometry_trace(local_tab_id);
+ mux::zoom_trace!(
+ "gui.viewport.send rpc=set tab={local_tab_id}/r{remote_tab_id} gen={} \
+ {summary} | {geometry}",
+ inner.client.connection_generation()
+ );
+ }
let result = inner
.client
.set_client_viewport(codec::SetClientViewport {
@@ -2086,6 +2126,11 @@ impl ClientDomain {
viewport,
})
.await;
+ mux::zoom_trace!(
+ "gui.viewport.ack rpc=set tab={local_tab_id}/r{remote_tab_id} ok={} elapsed={:?}",
+ result.is_ok(),
+ started_at.elapsed()
+ );
let state = match result {
Ok(state) => {
inner
@@ -2152,6 +2197,15 @@ impl ClientDomain {
let viewport = self.translate_client_viewport(viewport)?;
let reported = viewport.clone();
let started_at = Instant::now();
+ if mux::geometrytrace::trace_enabled() {
+ let summary = Self::viewport_trace(&viewport);
+ let geometry = Self::local_tab_geometry_trace(local_tab_id);
+ mux::zoom_trace!(
+ "gui.viewport.send rpc=claim tab={local_tab_id}/r{remote_tab_id} gen={} \
+ {summary} | {geometry}",
+ inner.client.connection_generation()
+ );
+ }
let result = inner
.client
.claim_client_viewport(codec::ClaimClientViewport {
@@ -2159,6 +2213,11 @@ impl ClientDomain {
viewport,
})
.await;
+ mux::zoom_trace!(
+ "gui.viewport.ack rpc=claim tab={local_tab_id}/r{remote_tab_id} ok={} elapsed={:?}",
+ result.is_ok(),
+ started_at.elapsed()
+ );
let state = match result {
Ok(state) => {
inner
diff --git a/wezterm-client/src/pane/clientpane.rs b/wezterm-client/src/pane/clientpane.rs
index ef4e5480..a9288d23 100644
--- a/wezterm-client/src/pane/clientpane.rs
+++ b/wezterm-client/src/pane/clientpane.rs
@@ -845,26 +845,55 @@ impl Pane for ClientPane {
}
fn set_zoomed(&self, zoomed: bool) {
+ let local_pane_id = self.local_pane_id;
+ let remote_pane_id = self.remote_pane_id;
+ let remote_tab_id = self.remote_tab_id();
if self.client.remote_tab_input_is_blocked() {
+ mux::zoom_trace!(
+ "gui.zoom.skip pane={local_pane_id}/r{remote_pane_id} rtab={remote_tab_id} \
+ zoomed={zoomed} reason=input_blocked"
+ );
return;
}
let render = self.renderable.lock();
let mut inner = render.inner.borrow_mut();
let client = Arc::clone(&self.client);
- let remote_pane_id = self.remote_pane_id;
- let remote_tab_id = self.remote_tab_id();
// Invalidate any cached rows on a resize
inner.make_all_stale();
promise::spawn::spawn(async move {
- if client.prepare_remote_tab_input(remote_tab_id).await? {
- client
+ // Traced separately from the send below: this await can be a full
+ // claim round-trip (or refuse outright) while SetClientViewport
+ // has no such gate, which is the suspected source of the zoom
+ // state and the zoom geometry reaching the server out of order.
+ let prepared = client.prepare_remote_tab_input(remote_tab_id).await;
+ mux::zoom_trace!(
+ "gui.zoom.prepared pane={local_pane_id}/r{remote_pane_id} rtab={remote_tab_id} \
+ zoomed={zoomed} gen={} owns={}",
+ client.client.connection_generation(),
+ match &prepared {
+ Ok(owns) => owns.to_string(),
+ Err(err) => format!("err({err:#})"),
+ }
+ );
+ if prepared? {
+ mux::zoom_trace!(
+ "gui.zoom.send pane={local_pane_id}/r{remote_pane_id} \
+ rtab={remote_tab_id} zoomed={zoomed}"
+ );
+ let result = client
.client
.set_zoomed(SetPaneZoomed {
containing_tab_id: remote_tab_id,
pane_id: remote_pane_id,
zoomed,
})
- .await?;
+ .await;
+ mux::zoom_trace!(
+ "gui.zoom.ack pane={local_pane_id}/r{remote_pane_id} rtab={remote_tab_id} \
+ zoomed={zoomed} ok={}",
+ result.is_ok()
+ );
+ result?;
}
Ok::<(), anyhow::Error>(())
})
diff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rs
index 2269eff7..d5b601dd 100644
--- a/wezterm-gui/src/termwindow/mod.rs
+++ b/wezterm-gui/src/termwindow/mod.rs
@@ -6561,6 +6561,11 @@ impl TermWindow {
Some(tab) => tab,
None => return Ok(PerformAssignmentResult::Handled),
};
+ mux::zoom_trace!(
+ "gui.gesture site=TogglePaneZoomState tab={} zoom={}",
+ tab.tab_id(),
+ tab.get_zoomed_pane().is_some()
+ );
self.claim_frontend_viewport_for_interaction();
tab.toggle_zoom();
// Zoom changes which panes occupy the tab root. Remote
@@ -6578,6 +6583,11 @@ impl TermWindow {
Some(tab) => tab,
None => return Ok(PerformAssignmentResult::Handled),
};
+ mux::zoom_trace!(
+ "gui.gesture site=SetPaneZoomState tab={} want={zoomed} zoom={}",
+ tab.tab_id(),
+ tab.get_zoomed_pane().is_some()
+ );
self.claim_frontend_viewport_for_interaction();
tab.set_zoomed(*zoomed);
self.sync_active_tab_geometry_now();
diff --git a/wezterm-gui/src/termwindow/mouseevent.rs b/wezterm-gui/src/termwindow/mouseevent.rs
index 1985497a..c35b8ba9 100644
--- a/wezterm-gui/src/termwindow/mouseevent.rs
+++ b/wezterm-gui/src/termwindow/mouseevent.rs
@@ -6020,6 +6020,12 @@ impl super::TermWindow {
PaneNavAction::ToggleZoom => {
self.claim_frontend_viewport_for_interaction();
if let Some(tab) = mux.get_active_tab_for_window(self.mux_window_id) {
+ mux::zoom_trace!(
+ "gui.gesture site=PaneNavToggleZoom tab={} pane={pane_id} \
+ index={pane_index} zoom={}",
+ tab.tab_id(),
+ tab.get_zoomed_pane().is_some()
+ );
tab.set_active_idx(pane_index);
tab.toggle_zoom();
}
diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rs
index cf93cc19..d65951a4 100644
--- a/wezterm-gui/src/termwindow/resize.rs
+++ b/wezterm-gui/src/termwindow/resize.rs
@@ -356,7 +356,13 @@ impl super::TermWindow {
}
}
let needs_follow_up = self.frontend_geometry_resync_after_epoch.remove(&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)
+ );
if needs_follow_up && self.active_tab_is(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.
self.sync_active_tab_geometry_now();
@@ -1358,6 +1364,7 @@ impl super::TermWindow {
// releasing its divider claims and commits that final geometry.
let action = frontend_geometry_action(ownership, collaborative, previewing);
if action == FrontendGeometryAction::Passive {
+ mux::zoom_trace!("gui.sync.skip tab={tab_id} reason=passive");
self.frontend_geometry_phases.remove(&tab_id);
self.report_frontend_viewport_for_tab(&tab);
self.invalidate_window();
@@ -1369,19 +1376,45 @@ impl super::TermWindow {
.copied()
.is_some_and(super::FrontendGeometryPhase::is_in_flight)
{
+ // The post-zoom (or post-unzoom) viewport is not sent here; it is
+ // owed to complete_frontend_geometry_epoch. If a transition ends
+ // mismatched, check whether the matching gui.sync.followup ever
+ // ran.
+ mux::zoom_trace!(
+ "gui.sync.defer tab={tab_id} reason=epoch_in_flight phase={:?}",
+ self.frontend_geometry_phases.get(&tab_id)
+ );
self.frontend_geometry_resync_after_epoch.insert(tab_id);
return;
}
let takeover = action == FrontendGeometryAction::Set { takeover: true };
let claim = action == FrontendGeometryAction::Claim;
let Some(epoch) = self.begin_frontend_geometry_epoch(tab_id, takeover) else {
+ mux::zoom_trace!("gui.sync.skip tab={tab_id} reason=epoch_denied");
return;
};
let Some((domain, viewport, adopted)) = self.prepare_client_frontend_geometry(&tab) else {
+ mux::zoom_trace!("gui.sync.skip tab={tab_id} epoch={epoch} reason=prepare_failed");
self.frontend_geometry_phases.remove(&tab_id);
self.invalidate_window();
return;
};
+ mux::zoom_trace!(
+ "gui.sync.begin tab={tab_id} epoch={epoch} rpc={} takeover={takeover} \
+ local_zoom={} adopted=[{}]",
+ if claim { "claim" } else { "set" },
+ tab.get_zoomed_pane()
+ .map(|pane| pane.pane_id().to_string())
+ .unwrap_or_else(|| "-".to_string()),
+ adopted
+ .iter()
+ .map(|(pane_id, size)| format!(
+ "{pane_id}:{}",
+ mux::geometrytrace::size(size)
+ ))
+ .collect::<Vec<_>>()
+ .join(" ")
+ );
if let Some(client_domain) = domain.downcast_ref::<ClientDomain>() {
self.remember_gui_recovery_intent(client_domain, tab_id, &viewport);
}
diff --git a/wezterm-mux-server-impl/src/sessionhandler.rs b/wezterm-mux-server-impl/src/sessionhandler.rs
index 36fc730d..cda80138 100644
--- a/wezterm-mux-server-impl/src/sessionhandler.rs
+++ b/wezterm-mux-server-impl/src/sessionhandler.rs
@@ -856,6 +856,11 @@ impl SessionHandler {
.get_tab(containing_tab_id)
.ok_or_else(|| anyhow!("no such tab {}", containing_tab_id))?;
activate_client_palette(&mux, &pane, palette_session_id)?;
+ mux::zoom_trace!(
+ "srv.zoom.recv tab={containing_tab_id} pane={pane_id} \
+ want_zoomed={zoomed} | {}",
+ tab.geometry_trace()
+ );
match tab.get_zoomed_pane() {
Some(p) => {
let is_zoomed = p.pane_id() == pane_id;
@@ -874,6 +879,11 @@ impl SessionHandler {
}
}
}
+ mux::zoom_trace!(
+ "srv.zoom.done tab={containing_tab_id} pane={pane_id} \
+ want_zoomed={zoomed} | {}",
+ tab.geometry_trace()
+ );
Ok(Pdu::UnitResponse(UnitResponse {}))
},
send_response,