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.
Rust agentagent-orchestrationaiai-agentsclaude-codecodexcoding-agentlinuxmacosmultiplayermultiplexerrustterminalterminal-emulatorterminal-multiplexertmuxtuiweztermwindows
Fix stacked pane geometry synchronization
RoversXa2eef303d4a1
diff --git a/codec/src/lib.rs b/codec/src/lib.rsindex 2d80187d..5a4ce206 100644--- a/codec/src/lib.rs+++ b/codec/src/lib.rs@@ -1018,7 +1018,11 @@ pub struct EnsureThinkTermThreadResponse {/// A complete renderer viewport. Native GUI clients include their per-pane/// targets so that font scaling and pane chrome are restored when ownership-/// changes; cell-grid clients have a single canonical grid.+/// changes; cell-grid clients have a single canonical grid. Native clients+/// may include every member of a level-2 pane stack: those entries share one+/// `frame` but retain independently scaled `size` values. The wire shape is+/// unchanged; older servers safely treat the extra members as a partial frame+/// set and skip split-tree reconstruction.#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone)]pub enum ClientViewport {CellGrid {diff --git a/mux/src/lib.rs b/mux/src/lib.rsindex 2d5c13da..185c2b15 100644--- a/mux/src/lib.rs+++ b/mux/src/lib.rs@@ -1435,6 +1435,17 @@ impl Mux {let tab = self.get_tab(tab_id).ok_or_else(|| anyhow!("no such tab {tab_id}"))?;+ let native_frames = match viewport {+ FrontendViewport::Native { panes, .. } => {+ let frames = panes+ .iter()+ .map(|pane| (pane.pane_id, pane.frame))+ .collect::<Vec<_>>();+ let covers_all_stacks = tab.frontend_frames_cover_all_stacks(&frames)?;+ Some((frames, covers_all_stacks))+ }+ FrontendViewport::CellGrid { .. } => None,+ };if crate::geometrytrace::trace_enabled() {let incoming = match viewport {FrontendViewport::CellGrid { size } => {@@ -1443,9 +1454,9 @@ impl Mux {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<_>>()- ),+ native_frames+ .as_ref()+ .is_some_and(|(_, covers_all)| *covers_all),panes.iter().map(|pane| format!(@@ -1470,8 +1481,6 @@ 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)@@ -1482,12 +1491,8 @@ impl Mux {self.frontend_geometry_step("resizing a native pane")?;pane.resize(pane_viewport.size)?;}- if !panes.is_empty() && viewport_covers_all_panes {- let frames = panes- .iter()- .map(|pane| (pane.pane_id, pane.frame))- .collect::<HashMap<_, _>>();- tab.rebuild_splits_sizes_from_frontend_frames(&frames)?;+ if let Some((frames, true)) = native_frames.as_ref() {+ tab.rebuild_splits_sizes_from_frontend_frames(frames)?;}return Ok(());}diff --git a/mux/src/tab.rs b/mux/src/tab.rsindex 6d7362be..cab0ddd5 100644--- a/mux/src/tab.rs+++ b/mux/src/tab.rs@@ -786,6 +786,56 @@ fn copy_split_geometry_if_topology_matches(old: &Tree, new: &mut Tree) -> bool {}}+/// Restore the invariant that only the axis a node actually splits may differ+/// between its two children: a vertical (top/bottom) split gives both children+/// the same width, a horizontal (left/right) split the same height.+///+/// Both bottom-up rebuilds below can violate it. Measuring leaves+/// independently rounds font-scaled panes to different cell counts, and a+/// frontend's per-pane chrome costs a *column* of stacked panes more rows than+/// a column holding one pane, so two sides of the same split disagree by the+/// number of panes between them.+///+/// Writing the agreed size into `data.first`/`data.second` is only enough when+/// that child is a leaf, because then the parent's record *is* the child's+/// size. When the child is itself a split, its own children still hold the+/// short size and `SplitDirectionAndSize::size` re-derives the child from+/// them, so the parent's record becomes a lie: the tab claims 38 rows, the+/// column beneath it distributes 36, and the two rows in between belong to no+/// pane. Nothing later repairs that — `resize` only ever applies a delta to+/// the short column, and a rebuild from the frames it reports re-derives the+/// same disagreement — so grow the short subtree here, where the difference is+/// still known.+fn reassert_cross_axis(+ data: &mut SplitDirectionAndSize,+ left: &mut Tree,+ right: &mut Tree,+ tab_cell: &TerminalSize,+) {+ match data.direction {+ SplitDirection::Vertical => {+ let cols = data.first.cols.max(data.second.cols);+ adjust_x_size(left, cols as isize - data.first.cols as isize, tab_cell);+ adjust_x_size(right, cols as isize - data.second.cols as isize, tab_cell);+ 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);+ adjust_y_size(left, rows as isize - data.first.rows as isize, tab_cell);+ adjust_y_size(right, rows as isize - data.second.rows as isize, tab_cell);+ 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;+ }+ }+}+/// Recompute split node sizes bottom-up from the contained panes'/// current dimensions, returning the aggregate size of the tree.///@@ -837,37 +887,7 @@ fn compute_tree_size_from_panes(node: &mut Tree, tab_cell: &TerminalSize) -> Optdata.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;- }- }+ reassert_cross_axis(data, left, right, tab_cell);Some(data.size())} else {None@@ -882,14 +902,13 @@ fn compute_tree_size_from_panes(node: &mut Tree, tab_cell: &TerminalSize) -> Opt/// 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>,+ frames: &HashMap<PaneStackId, 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)?;+ let frame = *frames.get(&stack.id())?;if frame.cols == 0 || frame.rows == 0 {return None;}@@ -905,23 +924,53 @@ fn compute_tree_size_from_frames(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;+ reassert_cross_axis(data, left, right, tab_cell);+ Some(data.size())+ }+ }+}++/// Resolve the per-pane frames in a native frontend viewport into one common+/// frame per pane stack. A stack's panes occupy the same rectangle even when+/// their independently scaled terminal surfaces have different row/column+/// counts. Accepting any member also makes frame composition independent of a+/// concurrently delivered level-2 tab activation; when multiple members are+/// present they must all describe that same rectangle.+fn collect_frontend_stack_frames(+ node: &Tree,+ pane_frames: &HashMap<PaneId, TerminalSize>,+ stack_frames: &mut HashMap<PaneStackId, TerminalSize>,+) -> anyhow::Result<bool> {+ match node {+ Tree::Empty => Ok(false),+ Tree::Leaf(stack) => {+ let mut stack_frame = None;+ for pane in &stack.panes {+ let Some(frame) = pane_frames.get(&pane.pane_id()).copied() else {+ continue;+ };+ if let Some(prior) = stack_frame {+ if prior != frame {+ anyhow::bail!(+ "frontend panes in stack {} disagree on their frame",+ stack.id()+ );+ }+ } else {+ stack_frame = Some(frame);}}- Some(data.size())+ if let Some(frame) = stack_frame {+ stack_frames.insert(stack.id(), frame);+ Ok(true)+ } else {+ Ok(false)+ }+ }+ Tree::Node { left, right, .. } => {+ let left_complete = collect_frontend_stack_frames(left, pane_frames, stack_frames)?;+ let right_complete = collect_frontend_stack_frames(right, pane_frames, stack_frames)?;+ Ok(left_complete && right_complete)}}}@@ -1026,12 +1075,11 @@ impl Tab {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(crate) fn frontend_frames_cover_all_stacks(+ &self,+ frames: &[(PaneId, TerminalSize)],+ ) -> anyhow::Result<bool> {+ Ok(self.inner.lock().frontend_stack_frames(frames)?.is_some())}pub fn iter_panes(&self) -> Vec<PositionedPane> {@@ -1107,7 +1155,7 @@ impl Tab {/// to attach this tab.pub fn rebuild_splits_sizes_from_frontend_frames(&self,- frames: &HashMap<PaneId, TerminalSize>,+ frames: &[(PaneId, TerminalSize)],) -> anyhow::Result<()> {self.inner.lock()@@ -2133,7 +2181,7 @@ impl TabInner {fn rebuild_splits_sizes_from_frontend_frames(&mut self,- frames: &HashMap<PaneId, TerminalSize>,+ frames: &[(PaneId, TerminalSize)],) -> anyhow::Result<()> {if self.zoomed.is_some() {if crate::geometrytrace::trace_enabled() {@@ -2144,6 +2192,9 @@ impl TabInner {return Ok(());}+ let stack_frames = self+ .frontend_stack_frames(frames)?+ .ok_or_else(|| anyhow::anyhow!("frontend frames do not cover tab {}", self.id))?;let root_size = self.size;let cell = cell_dimensions(&root_size);let tab_id = self.id;@@ -2152,7 +2203,7 @@ impl TabInner {.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)+ let derived = compute_tree_size_from_frames(&mut candidate, &stack_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!(@@ -2187,19 +2238,13 @@ impl TabInner {return Ok(());}- let panes = self.iter_panes_ignoring_zoom();- if panes.len() != frames.len()- || !panes- .iter()- .all(|pane| frames.iter().any(|(id, _)| *id == pane.pane.pane_id()))- {+ let Some(stack_frames) = self.frontend_stack_frames(frames)? else {// A partial viewport can race with the separate zoom/topology RPC.// apply_frontend_viewport deliberately resizes those surfaces but// does not rebuild the complete split tree.return Ok(());- }+ };- let frames = frames.iter().copied().collect::<HashMap<_, _>>();let tab_id = self.id;let mut candidate = self.pane@@ -2223,7 +2268,7 @@ impl TabInner {}};let cell = cell_dimensions(&root_size);- let derived = compute_tree_size_from_frames(&mut candidate, &frames, &cell)+ let derived = compute_tree_size_from_frames(&mut candidate, &stack_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!(@@ -2237,6 +2282,24 @@ impl TabInner {Ok(())}+ fn frontend_stack_frames(+ &self,+ frames: &[(PaneId, TerminalSize)],+ ) -> anyhow::Result<Option<HashMap<PaneStackId, TerminalSize>>> {+ let mut pane_frames = HashMap::with_capacity(frames.len());+ for (pane_id, frame) in frames {+ if pane_frames.insert(*pane_id, *frame).is_some() {+ anyhow::bail!("frontend viewport contains pane {pane_id} more than once");+ }+ }+ let Some(tree) = self.pane.as_ref() else {+ anyhow::bail!("tab {} has no pane tree", self.id);+ };+ let mut stack_frames = HashMap::new();+ let complete = collect_frontend_stack_frames(tree, &pane_frames, &mut stack_frames)?;+ Ok(complete.then_some(stack_frames))+ }+fn resize_split_by(&mut self, split_index: usize, delta: isize) {if self.zoomed.is_some() {return;@@ -4405,9 +4468,17 @@ mod test {.map(|pane| (pane.pane.pane_id(), pane.width, pane.height)).collect::<Vec<_>>();- assert!(tab.viewport_covers_all_panes(&[1, 2]));+ let complete_frames = tab+ .iter_panes_ignoring_zoom()+ .into_iter()+ .map(|pane| (pane.pane.pane_id(), positioned_frame(&pane, tab_size.dpi)))+ .collect::<Vec<_>>();+ assert!(tab+ .frontend_frames_cover_all_stacks(&complete_frames)+ .unwrap());assert!(- !tab.viewport_covers_all_panes(&[2]),+ !tab.frontend_frames_cover_all_stacks(&complete_frames[1..])+ .unwrap(),"a zoom viewport can race ahead of SetPaneZoomed and must remain partial");@@ -4531,6 +4602,77 @@ mod test {assert!(!mux.client_owns_frontend_lease(&client, tab.tab_id()));}+ /// A frontend spends its per-pane chrome once per *pane*, so a column of+ /// two stacked panes reports one row less of PTY than the single pane+ /// beside it. Rebuilding the tree from those dimensions must widen the+ /// short column itself, not merely record it as taller: everything+ /// downstream (`resize`, and the frames the frontend then reports) only+ /// ever applies deltas, so a gap left here is permanent and shows up as a+ /// pane whose bottom rows belong to nobody.+ #[test]+ fn rebuilding_from_pane_dimensions_keeps_a_stacked_column_full_height() {+ let _mux = install_mux();+ let tab_size = test_size();+ let (tab, _first, _second) = split_tab_for_viewport(tab_size);+ let request = SplitRequest {+ direction: SplitDirection::Vertical,+ ..Default::default()+ };+ let split_size = tab+ .compute_split_size(0, request)+ .expect("the left column can split");+ let third = FakePane::new(3, split_size.second);+ tab.split_and_insert(0, request, Arc::clone(&third))+ .expect("split succeeds");+ Mux::get().add_pane(&third).unwrap();++ // Charge every pane one row and two columns of frontend chrome, the+ // way a TUI pane spends rows on its nav bar and columns on its border.+ for positioned in tab.iter_panes() {+ let cell_width = tab_size.pixel_width / tab_size.cols;+ let cell_height = tab_size.pixel_height / tab_size.rows;+ let cols = positioned.width - 2;+ let rows = positioned.height - 1;+ positioned+ .pane+ .resize(TerminalSize {+ cols,+ rows,+ pixel_width: cols * cell_width,+ pixel_height: rows * cell_height,+ dpi: tab_size.dpi,+ })+ .unwrap();+ }++ // What sync_with_pane_tree does for a tab whose topology arrived from+ // the wire: re-derive the root from the panes, then re-impose the+ // size this frontend actually has.+ {+ let mut inner = tab.inner.lock();+ let cell = cell_dimensions(&tab_size);+ let derived = compute_tree_size_from_panes(inner.pane.as_mut().unwrap(), &cell)+ .expect("the tree measures");+ inner.size = derived;+ }+ tab.resize(tab_size);++ let panes = tab.iter_panes();+ let bottom = panes+ .iter()+ .find(|pane| pane.pane.pane_id() == 3)+ .expect("the stacked column's lower pane");+ assert_eq!(+ bottom.top + bottom.height,+ tab_size.rows,+ "the stacked column must reach the bottom of the tab: {:?}",+ panes+ .iter()+ .map(|pane| (pane.pane.pane_id(), pane.top, pane.height))+ .collect::<Vec<_>>()+ );+ }+#[test]fn frontend_frame_preflight_uses_the_split_minimum_root() {let _mux = install_mux();@@ -4547,6 +4689,104 @@ mod test {.expect("two one-cell leaves plus their divider compose to the clamped 3x1 root");}+ #[test]+ fn native_viewport_sizes_all_stack_members_without_mixing_font_units() {+ let _mux = install_mux();+ let tab_size = test_size();+ let mux = Mux::get();+ let (tab, first, second) = split_tab_for_viewport(tab_size);+ let third = FakePane::new(3, tab_size);+ tab.add_pane_to_stack(first.pane_id(), Arc::clone(&third))+ .unwrap();+ mux.add_pane(&third).unwrap();++ let positioned = tab.iter_panes_ignoring_zoom();+ let first_stack = positioned+ .iter()+ .find(|pane| pane.pane_stack_id == tab.pane_stack_id(first.pane_id()).unwrap())+ .unwrap();+ let second_stack = positioned+ .iter()+ .find(|pane| pane.pane.pane_id() == second.pane_id())+ .unwrap();+ let shared_frame = positioned_frame(first_stack, tab_size.dpi);+ let ordinary_size = TerminalSize {+ cols: first_stack.width,+ rows: first_stack.height,+ pixel_width: first_stack.pixel_width,+ pixel_height: first_stack.pixel_height,+ dpi: tab_size.dpi,+ };+ let scaled_size = TerminalSize {+ cols: first_stack.width * 2,+ rows: first_stack.height,+ pixel_width: first_stack.pixel_width,+ pixel_height: first_stack.pixel_height,+ dpi: tab_size.dpi,+ };+ let mut panes = vec![+ FrontendPaneViewport {+ pane_id: first.pane_id(),+ size: scaled_size,+ frame: shared_frame,+ },+ FrontendPaneViewport {+ pane_id: third.pane_id(),+ size: ordinary_size,+ frame: shared_frame,+ },+ FrontendPaneViewport {+ pane_id: second.pane_id(),+ size: TerminalSize {+ cols: second_stack.width,+ rows: second_stack.height,+ pixel_width: second_stack.pixel_width,+ pixel_height: second_stack.pixel_height,+ dpi: tab_size.dpi,+ },+ frame: positioned_frame(second_stack, tab_size.dpi),+ },+ ];++ mux.apply_frontend_viewport(+ tab.tab_id(),+ &FrontendViewport::Native {+ size: tab_size,+ panes: panes.clone(),+ },+ )+ .unwrap();+ assert_eq!(first.get_dimensions().cols, scaled_size.cols);+ assert_eq!(third.get_dimensions().cols, ordinary_size.cols);+ assert_eq!(tab.get_size(), tab_size);++ let before = (+ first.get_dimensions(),+ second.get_dimensions(),+ third.get_dimensions(),+ );+ panes[1].frame.cols += 1;+ let err = mux+ .apply_frontend_viewport(+ tab.tab_id(),+ &FrontendViewport::Native {+ size: tab_size,+ panes,+ },+ )+ .expect_err("members of one stack cannot describe different frames");+ assert!(err.to_string().contains("disagree on their frame"));+ assert_eq!(+ before,+ (+ first.get_dimensions(),+ second.get_dimensions(),+ third.get_dimensions(),+ ),+ "frame validation must happen before any live PTY is resized"+ );+ }+#[test]fn a_font_scaled_pane_must_not_redefine_the_tab_root() {let _mux = install_mux();diff --git a/thinkterm-tui/src/lib.rs b/thinkterm-tui/src/lib.rsindex 38f3c735..adf4b919 100644--- a/thinkterm-tui/src/lib.rs+++ b/thinkterm-tui/src/lib.rs@@ -12,7 +12,7 @@ use anyhow::{Context, Result};use async_channel::{Receiver, Sender};use backend::TermwizBackend;use clipboard::{ClipboardProvider, SystemClipboard};-use codec::{ClientViewport, ThinkTermSessionState};+use codec::{ClientViewport, FrontendAccessMode, ThinkTermSessionState};use config::keyassignment::{PaneDirection, SpawnTabDomain};use config::{ConfigHandle, SshMultiplexing};use model::{AppModel, ThreadKey, TreeNodeKey};@@ -194,7 +194,13 @@ struct TakeoverGeometryConfirmation {epoch: u64,screen_size: ScreenSize,root_size: TerminalSize,+ /// Visible panes whose rendered rows must be fetched before the handoff+ /// mask can lift.panes: Vec<(PaneId, TerminalSize)>,+ /// Every stack member carried by the acknowledged viewport. Hidden+ /// members do not block the mask, but their previews can finish+ /// successfully once the server has accepted their individual targets.+ acknowledged_panes: Vec<(PaneId, TerminalSize)>,access_generation: u64,ready_since: Option<Instant>,}@@ -764,9 +770,14 @@ struct TuiState {/// on the next frame; the key has to outlive that, because taking control/// of a tab requires the server to already hold a viewport for us./// Also carries whether this renderer owned the viewport when it last said- /// so: a handover changes what the server does with the same numbers, so it- /// has to count as something new to say.- last_viewports: HashMap<(String, TabId), Option<(ClientViewport, bool)>>,+ /// so, and under which access mode: a handover changes what the server does+ /// with the same numbers, so it has to count as something new to say. The+ /// mode is in here for the same reason — a non-owner keeps its own geometry+ /// under Handoff and mirrors the owner's under a shared view, so the same+ /// viewport and the same `owns` mean two different local tab sizes, and a+ /// mode flip has to reach `adopt_local_tab_size` rather than dedupe away.+ last_viewports:+ HashMap<(String, TabId), Option<(ClientViewport, bool, Option<FrontendAccessMode>)>>,/// B grants visibility for the whole mux, but geometry is still installed/// one top-level tab at a time. A tab is safe to reveal only after this TUI/// has acknowledged a complete viewport in the current access generation.@@ -807,6 +818,13 @@ struct TuiState {/// Deadline until which to keep drawing regardless of whether anything/// asked for it, so a pane whose refetch was throttled away still recovers.redraw_until: Option<Instant>,+ /// When the last frame was drawn, so the unconditional redraw above happens+ /// at a frame rate rather than as fast as the loop can spin. Every frame+ /// re-primes the pane previews, whose own mux notifications wake the loop+ /// again immediately; left ungoverned that ran ~3000 frames a second for+ /// the whole window. Only the forced redraw consults this — a frame that+ /// something actually asked for still draws at once.+ last_draw: Instant,/// Current transport generation accepted for each domain. Session pushes/// from any other generation are stale even when the restarted server has/// the same runtime id and a numerically newer snapshot generation.@@ -900,6 +918,7 @@ impl TuiState {screen_size: None,resize_settles_at: None,redraw_until: None,+ last_draw: Instant::now(),connection_generations,refresh_sessions: HashSet::new(),actions: VecDeque::new(),@@ -1167,7 +1186,15 @@ async fn run_terminal(// renderer that draws on demand sits on the pre-resize picture until// the next keystroke. Drawing for a moment longer lets it retry.match state.redraw_until {- Some(until) if Instant::now() < until => state.dirty = true,+ Some(until) if Instant::now() < until => {+ // At a frame rate, not at loop speed: the poll below already+ // wakes within RESIZE_REDRAW_INTERVAL, and drawing faster only+ // repeats the pane-preview pass that woke this loop in the+ // first place.+ if state.last_draw.elapsed() >= RESIZE_REDRAW_INTERVAL {+ state.dirty = true;+ }+ }Some(_) => state.redraw_until = None,None => {}}@@ -1245,6 +1272,7 @@ async fn run_terminal();})?;state.layout = next_layout;+ state.last_draw = Instant::now();// Cleared before the trip to the server, never after — the same// rule the wake flag follows, and for the same reason. Adopting the// owner's scroll position happens in there, and clearing afterwards@@ -1587,11 +1615,13 @@ fn prepare_active_native_viewport(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);- panes.push(codec::ClientPaneViewport {- pane_id: pane.pane_id,+ append_tui_stack_viewports(+ &tab,+ pane.pane_id,size,- frame: *frames.get(&pane.pane_id)?,- });+ *frames.get(&pane.pane_id)?,+ &mut panes,+ )?;}// Validate the complete pane set before mutating any surface. A topology// notification can remove one pane between the two layout passes; applying@@ -1628,6 +1658,39 @@ fn tui_pane_frame_sizes(tab: &Tab, screen: ScreenSize) -> HashMap<PaneId, Termin.collect()}+/// A TUI uses one cell grid for every member of a level-2 pane stack. Carry+/// each member as an independently resizeable PTY target while keeping the+/// common split frame. This keeps hidden panes current across a resize without+/// turning them into extra split-tree leaves.+fn append_tui_stack_viewports(+ tab: &Tab,+ visible_pane_id: PaneId,+ size: TerminalSize,+ frame: TerminalSize,+ panes: &mut Vec<codec::ClientPaneViewport>,+) -> Option<()> {+ let stack_tabs = tab.pane_stack_tabs(visible_pane_id);+ let pane_ids = if stack_tabs.is_empty() {+ vec![visible_pane_id]+ } else {+ stack_tabs.into_iter().map(|tab| tab.pane_id).collect()+ };+ for pane_id in &pane_ids {+ let handle = Mux::get().get_pane(*pane_id)?;+ handle.downcast_ref::<ClientPane>()?;+ }+ for pane_id in pane_ids {+ let handle = Mux::get().get_pane(pane_id)?;+ handle.downcast_ref::<ClientPane>()?;+ panes.push(codec::ClientPaneViewport {+ pane_id,+ size,+ frame,+ });+ }+ Some(())+}+fn forget_native_viewport_geometry(viewport: &ClientViewport) {let ClientViewport::Native { panes, .. } = viewport else {return;@@ -1675,13 +1738,21 @@ fn begin_takeover_geometry_confirmation(let ClientViewport::Native { size, panes } = viewport else {return;};+ let visible_pane_ids = state+ .layout+ .panes+ .iter()+ .map(|visible| visible.pane_id)+ .collect::<Vec<_>>();+ let visible_panes = visible_takeover_targets(&visible_pane_ids, panes);state.takeover_geometry_confirmations.insert(cache_key,TakeoverGeometryConfirmation {epoch,screen_size,root_size: *size,- panes: panes.iter().map(|pane| (pane.pane_id, pane.size)).collect(),+ panes: visible_panes,+ acknowledged_panes: panes.iter().map(|pane| (pane.pane_id, pane.size)).collect(),access_generation,ready_since: None,},@@ -1690,6 +1761,21 @@ fn begin_takeover_geometry_confirmation(state.dirty = true;}+fn visible_takeover_targets(+ visible_pane_ids: &[PaneId],+ panes: &[codec::ClientPaneViewport],+) -> Vec<(PaneId, TerminalSize)> {+ visible_pane_ids+ .iter()+ .filter_map(|visible_pane_id| {+ panes+ .iter()+ .find(|pane| pane.pane_id == *visible_pane_id)+ .map(|pane| (pane.pane_id, pane.size))+ })+ .collect()+}+fn cancel_takeover_geometry_confirmation(state: &mut TuiState,cache_key: &(String, TabId),@@ -1867,7 +1953,7 @@ fn advance_takeover_geometry_confirmation(state: &mut TuiState) {state,&cache_key,confirmation.epoch,- Some(&confirmation.panes),+ Some(&confirmation.acknowledged_panes),);state.takeover_epochs@@ -1933,22 +2019,16 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(};let frames = tui_pane_frame_sizes(&tab, screen);let native_root = tab.get_size();- let panes = state- .layout- .panes- .iter()- .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,- frame: *frames.get(&pane.pane_id)?,- })- })- .collect();+ let mut panes = Vec::new();+ for pane in &state.layout.panes {+ let size = terminal_size(pane.rect.width as usize, pane.rect.height as usize, screen);+ let Some(frame) = frames.get(&pane.pane_id).copied() else {+ return;+ };+ if append_tui_stack_viewports(&tab, pane.pane_id, size, frame, &mut panes).is_none() {+ return;+ }+ }ClientViewport::Native {size: native_root,panes,@@ -1979,9 +2059,11 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(log::trace!("recording TUI frontend recovery intent: {err:#}");}+ let access_mode = domain.remote_access_state().map(|access| access.mode);if recovery_generation.is_some()|| (geometry_generation_is_stale && !geometry_confirmation_pending)- || state.last_viewports.get(&cache_key) != Some(&Some((viewport.clone(), owns)))+ || state.last_viewports.get(&cache_key)+ != Some(&Some((viewport.clone(), owns, access_mode))){match domain.set_client_viewport(local_tab_id, viewport.clone())@@ -1989,9 +2071,10 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>({Ok(response) => {let owns = domain.owns_remote_viewport(local_tab_id) != Some(false);- state- .last_viewports- .insert(cache_key.clone(), Some((viewport.clone(), owns)));+ state.last_viewports.insert(+ cache_key.clone(),+ Some((viewport.clone(), owns, Some(response.access.mode))),+ );adopt_local_tab_size(local_tab_id,local_tab_size(&domain, local_tab_id, size, response.canonical_size),@@ -2244,12 +2327,23 @@ fn follow_shared_view(/// 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(+ mode: Option<codec::FrontendAccessMode>,owns: Option<bool>,reported: TerminalSize,canonical: TerminalSize,) -> TerminalSize {- match owns {- Some(false) => canonical,+ match (mode, owns) {+ // Handoff gives the terminal to one renderer at a time, and the ones+ // without it are masked rather than mirroring. Adopting the owner's+ // geometry would relay out every local pane for a window this TTY does+ // not have — panes sized for a 175x43 GUI clipped onto a 157x38+ // terminal — and lay them out a second time when the terminal comes+ // back. Keep the size this TTY actually has; it is the size the mask+ // lifts onto.+ (Some(codec::FrontendAccessMode::Handoff), Some(false)) => reported,+ // A shared view is a mirror of the owner's grid, so matching its size+ // is the whole point.+ (_, Some(false)) => canonical,_ => reported,}}@@ -2261,6 +2355,7 @@ fn local_tab_size(canonical: TerminalSize,) -> TerminalSize {choose_local_tab_size(+ domain.remote_access_state().map(|access| access.mode),domain.owns_remote_viewport(local_tab_id),reported,canonical,@@ -2330,7 +2425,7 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {.last_viewports.get(&(domain_name.clone(), remote_tab_id)).and_then(|entry| entry.as_ref())- .map(|(viewport, _)| viewport.clone())+ .map(|(viewport, _, _)| viewport.clone()){Some(viewport) => viewport,None => {@@ -2385,9 +2480,10 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {);schedule_takeover_resync(domain_name.clone(), Arc::clone(&domain));}- state- .last_viewports- .insert(cache_key.clone(), Some((viewport.clone(), true)));+ state.last_viewports.insert(+ cache_key.clone(),+ Some((viewport.clone(), true, Some(claimed.access.mode))),+ );if claimed.access.mode == codec::FrontendAccessMode::Handoff {begin_takeover_geometry_confirmation(state,@@ -2443,7 +2539,7 @@ async fn set_active_frontend_access_mode(let cache_key = (domain_name, remote_tab_id);state.last_viewports- .insert(cache_key.clone(), Some((viewport, true)));+ .insert(cache_key.clone(), Some((viewport, true, Some(access.mode))));if access.mode == codec::FrontendAccessMode::Handoff {state.handoff_geometry_ready@@ -5496,6 +5592,30 @@ mod tests {assert_eq!(previews.take(&cache_key, 2).unwrap()[&10], newer);}+ #[test]+ fn hidden_stack_targets_do_not_block_visible_takeover_confirmation() {+ let visible = takeover_test_size(80, 24);+ let hidden_scaled = takeover_test_size(120, 24);+ let panes = vec![+ codec::ClientPaneViewport {+ pane_id: 10,+ size: visible,+ frame: visible,+ },+ codec::ClientPaneViewport {+ pane_id: 11,+ size: hidden_scaled,+ frame: visible,+ },+ ];++ assert_eq!(+ visible_takeover_targets(&[10], &panes),+ vec![(10, visible)],+ "the hidden sibling is acknowledged and previewed but does not need rows fetched before the mask lifts"+ );+ }+#[test]fn takeover_confirmation_rejects_a_newly_visible_pane() {let first = takeover_test_size(80, 24);@@ -5734,21 +5854,32 @@ mod tests {cols: 100,..TerminalSize::default()};+ let shared = Some(codec::FrontendAccessMode::TmuxLatest);assert_eq!(- choose_local_tab_size(Some(true), reported, echo),+ choose_local_tab_size(shared, Some(true), reported, echo),reported,"an owner must not adopt the shrunken echo");assert_eq!(- choose_local_tab_size(None, reported, echo),+ choose_local_tab_size(shared, None, reported, echo),reported,"an unknown lease is treated as ours, as it is before the first answer");assert_eq!(- choose_local_tab_size(Some(false), reported, echo),+ choose_local_tab_size(shared, Some(false), reported, echo),echo,"a viewer has no geometry of its own and draws what the panes have");+ assert_eq!(+ choose_local_tab_size(+ Some(codec::FrontendAccessMode::Handoff),+ Some(false),+ reported,+ echo+ ),+ reported,+ "a masked renderer keeps the size its own terminal will come back to"+ );}/// The loop that used to eat a row per layout, run five times.@@ -5772,7 +5903,12 @@ mod tests {let mut grid = 0;for _ in 0..5 {grid = laid_out.rows - 1;- laid_out = choose_local_tab_size(Some(true), reported, rows(grid));+ laid_out = choose_local_tab_size(+ Some(codec::FrontendAccessMode::TmuxLatest),+ Some(true),+ reported,+ rows(grid),+ );}assert_eq!(laid_out.rows, 30, "the tab is still the size we asked for");assert_eq!(grid, 29, "and the bar has cost exactly one row, once");@@ -5781,7 +5917,12 @@ mod tests {// and settles, because it never spends the row it was not asked to.let mut viewing = reported;for _ in 0..5 {- viewing = choose_local_tab_size(Some(false), reported, rows(29));+ viewing = choose_local_tab_size(+ Some(codec::FrontendAccessMode::TmuxLatest),+ Some(false),+ reported,+ rows(29),+ );}assert_eq!(viewing.rows, 29);}@@ -5937,6 +6078,7 @@ mod tests {},},true,+ Some(FrontendAccessMode::Handoff),)),);diff --git a/wezterm-client/src/pane/renderable.rs b/wezterm-client/src/pane/renderable.rsindex 71df5b13..f2121e46 100644--- a/wezterm-client/src/pane/renderable.rs+++ b/wezterm-client/src/pane/renderable.rs@@ -1091,9 +1091,14 @@ impl RenderableState {pub(crate) fn prime_frontend_geometry(&self, size: wezterm_term::TerminalSize) -> bool {let mut visible = {let mut inner = self.inner.borrow_mut();- let now = Instant::now();+ // Cancel any backoff this pane had settled into, but leave+ // `last_poll` alone so `poll` still rate-limits itself. Backdating+ // it forced a fresh render-changes RPC on *every* call, and the+ // reply emits PaneOutput, which marks the frontend dirty, which+ // draws, which calls this again: on a local socket that loop ran+ // thousands of times a second for the whole takeover window+ // instead of the ~50 the base interval allows.inner.poll_interval = BASE_POLL_INTERVAL;- inner.last_poll = now.checked_sub(BASE_POLL_INTERVAL).unwrap_or(now);if let Err(err) = inner.poll() {log::trace!("polling takeover geometry: {err:#}");}diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rsindex 24cce324..860f1f1b 100644--- a/wezterm-gui/src/termwindow/resize.rs+++ b/wezterm-gui/src/termwindow/resize.rs@@ -4,11 +4,11 @@ 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 std::collections::HashMap;+use mux::Mux;+use std::collections::{HashMap, HashSet};use std::rc::Rc;use std::sync::Arc;use std::time::{Duration, Instant};@@ -39,6 +39,17 @@ fn frontend_geometry_action(}}+fn visible_geometry_targets(+ adopted: &[(PaneId, TerminalSize)],+ visible_panes: &HashSet<PaneId>,+) -> Vec<(PaneId, TerminalSize)> {+ adopted+ .iter()+ .filter(|(pane_id, _)| visible_panes.contains(pane_id))+ .copied()+ .collect()+}+fn remote_divider_target_is_owed(in_flight: Option<&codec::ClientViewport>,acknowledged: Option<&codec::ClientViewport>,@@ -313,11 +324,16 @@ impl super::TermWindow {// PTY resize, not that the resized screen has reached this// renderer. Keep the opaque takeover state and actively fetch a// complete post-resize snapshot before revealing it.+ let visible_panes = self+ .get_panes_to_render()+ .into_iter()+ .map(|positioned| positioned.pane.pane_id())+ .collect::<HashSet<_>>();self.frontend_geometry_confirmations.insert(tab_id,super::FrontendGeometryConfirmation {epoch,- panes: adopted.to_vec(),+ panes: visible_geometry_targets(adopted, &visible_panes),ready_since: None,},);@@ -515,29 +531,15 @@ impl super::TermWindow {let mut panes = Vec::new();let mut adopted = Vec::new();for positioned in self.get_panes_to_render() {- let pane = positioned.pane.downcast_ref::<ClientPane>()?;- if pane.domain_id() != domain_id {- return None;- }- let font_scale = self.pane_font_scale(positioned.pane.pane_id());- let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {- self.render_metrics- } else {- match self.pane_font_resources(font_scale) {- Ok((_, metrics)) => metrics,- Err(err) => {- log::warn!("cannot calculate native viewport: {err:#}");- return None;- }+ for member in self.positioned_panes_for_stack(tab, &positioned)? {+ let pane = member.pane.downcast_ref::<ClientPane>()?;+ if pane.domain_id() != domain_id {+ return None;}- };- let size = self.terminal_size_for_positioned_pane(&positioned, metrics);- 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));+ let viewport = self.frontend_viewport_for_positioned_pane(&member)?;+ adopted.push((viewport.pane_id, viewport.size));+ panes.push(viewport);+ }}for (pane_id, size) in &adopted {let pane = Mux::get().get_pane(*pane_id)?;@@ -1151,33 +1153,17 @@ impl super::TermWindow {return None;}let panes = if include_panes {- self.get_panes_to_render()- .into_iter()- .filter_map(|positioned| {- let pane = positioned.pane.downcast_ref::<ClientPane>()?;+ let mut panes = Vec::new();+ for positioned in self.get_panes_to_render() {+ for member in self.positioned_panes_for_stack(tab, &positioned)? {+ let pane = member.pane.downcast_ref::<ClientPane>()?;if pane.domain_id() != domain_id {return None;}- let font_scale = self.pane_font_scale(positioned.pane.pane_id());- let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {- self.render_metrics- } else {- match self.pane_font_resources(font_scale) {- Ok((_, metrics)) => metrics,- Err(err) => {- log::warn!("cannot calculate native viewport: {err:#}");- return None;- }- }- };- let size = self.terminal_size_for_positioned_pane(&positioned, metrics);- Some(codec::ClientPaneViewport {- pane_id: positioned.pane.pane_id(),- size,- frame: self.frontend_frame_for_positioned_pane(&positioned),- })- })- .collect()+ panes.push(self.frontend_viewport_for_positioned_pane(&member)?);+ }+ }+ panes} else {Vec::new()};@@ -1578,34 +1564,30 @@ impl super::TermWindow {fn local_frontend_viewport_for_tab(&self,- _tab: &Arc<mux::tab::Tab>,+ tab: &Arc<mux::tab::Tab>,include_panes: bool,) -> mux::FrontendViewport {let panes = if include_panes {- self.get_panes_to_render()- .into_iter()- .filter(|positioned| !positioned.pane.is_remote_mirror())- .filter_map(|positioned| {- let font_scale = self.pane_font_scale(positioned.pane.pane_id());- let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {- self.render_metrics- } else {- match self.pane_font_resources(font_scale) {- Ok((_, metrics)) => metrics,- Err(err) => {- log::warn!("cannot calculate local viewport: {err:#}");- return None;- }- }+ let mut panes = Vec::new();+ for positioned in self.get_panes_to_render() {+ let Some(members) = self.positioned_panes_for_stack(tab, &positioned) else {+ continue;+ };+ for member in members {+ if member.pane.is_remote_mirror() {+ continue;+ }+ let Some(viewport) = self.frontend_viewport_for_positioned_pane(&member) else {+ continue;};- let size = self.terminal_size_for_positioned_pane(&positioned, metrics);- Some(mux::FrontendPaneViewport {- pane_id: positioned.pane.pane_id(),- size,- frame: self.frontend_frame_for_positioned_pane(&positioned),- })- })- .collect()+ panes.push(mux::FrontendPaneViewport {+ pane_id: viewport.pane_id,+ size: viewport.size,+ frame: viewport.frame,+ });+ }+ }+ panes} else {Vec::new()};@@ -1875,6 +1857,60 @@ impl super::TermWindow {}}+ /// Expand the currently visible member of a pane stack into every level-2+ /// tab that occupies the same split rectangle. Hidden members need their+ /// own PTY/render target before they become active; otherwise divider or+ /// window resize leaves them on their last visible geometry and the first+ /// frame after a level-2 switch visibly jumps.+ fn positioned_panes_for_stack(+ &self,+ tab: &Arc<mux::tab::Tab>,+ positioned: &PositionedPane,+ ) -> Option<Vec<PositionedPane>> {+ let stack_tabs = tab.pane_stack_tabs(positioned.pane.pane_id());+ if stack_tabs.is_empty() {+ return Some(vec![positioned.clone()]);+ }++ let mux = Mux::get();+ stack_tabs+ .into_iter()+ .map(|stack_tab| {+ let mut member = positioned.clone();+ member.pane = mux.get_pane(stack_tab.pane_id)?;+ member.is_active = positioned.is_active && stack_tab.is_active;+ member.is_zoomed = positioned.is_zoomed && stack_tab.is_active;+ Some(member)+ })+ .collect()+ }++ /// A stack shares a frame but not necessarily a terminal grid: pane-local+ /// font scaling means each member must convert that frame using its own+ /// cell metrics.+ fn frontend_viewport_for_positioned_pane(+ &self,+ positioned: &PositionedPane,+ ) -> Option<codec::ClientPaneViewport> {+ let font_scale = self.pane_font_scale(positioned.pane.pane_id());+ let metrics = if font_scale.to_bits() == self.fonts.get_font_scale().to_bits() {+ self.render_metrics+ } else {+ match self.pane_font_resources(font_scale) {+ Ok((_, metrics)) => metrics,+ Err(err) => {+ log::warn!("cannot calculate pane-stack viewport: {err:#}");+ return None;+ }+ }+ };+ Some(codec::ClientPaneViewport {+ pane_id: positioned.pane.pane_id(),+ size: self.terminal_size_for_positioned_pane(positioned, metrics),+ frame: self.frontend_frame_for_positioned_pane(positioned),+ })+ }+pub(crate) fn terminal_size_for_positioned_pane(&self,pos: &PositionedPane,@@ -1943,13 +1979,21 @@ impl super::TermWindow {if !self.owns_frontend_viewport() {return;}- for pos in self.get_panes_to_render() {- if let Err(err) = self.sync_positioned_pane_font_size(&pos) {- log::error!(- "failed to sync font-scaled pane size for pane {}: {:#}",- pos.pane.pane_id(),- err- );+ let Some(tab) = Mux::get().get_active_tab_for_window(self.mux_window_id) else {+ return;+ };+ for positioned in self.get_panes_to_render() {+ let Some(members) = self.positioned_panes_for_stack(&tab, &positioned) else {+ continue;+ };+ for pos in members {+ if let Err(err) = self.sync_positioned_pane_font_size(&pos) {+ log::error!(+ "failed to sync font-scaled pane size for pane {}: {:#}",+ pos.pane.pane_id(),+ err+ );+ }}}}@@ -2569,10 +2613,12 @@ pub fn effective_right_padding(config: &ConfigHandle, context: DimensionContext)#[cfg(test)]mod frontend_geometry_tests {use super::{- FRONTEND_GEOMETRY_SETTLE, FrontendGeometryAction, frontend_geometry_action,- geometry_confirmation_settled, remote_divider_can_pump, remote_divider_target_is_owed,+ frontend_geometry_action, geometry_confirmation_settled, remote_divider_can_pump,+ remote_divider_target_is_owed, visible_geometry_targets, FrontendGeometryAction,+ FRONTEND_GEOMETRY_SETTLE,};use crate::termwindow::{FrontendGeometryPhase, RemoteDividerResizeStrategy};+ use std::collections::HashSet;use std::time::{Duration, Instant};#[test]@@ -2636,6 +2682,24 @@ mod frontend_geometry_tests {));}+ #[test]+ fn hidden_stack_targets_do_not_delay_the_takeover_mask() {+ let size = |cols| wezterm_term::TerminalSize {+ cols,+ rows: 24,+ pixel_width: cols * 10,+ pixel_height: 480,+ dpi: 96,+ };+ let adopted = vec![(10, size(80)), (11, size(120))];+ let visible = HashSet::from([10]);++ assert_eq!(+ visible_geometry_targets(&adopted, &visible),+ vec![(10, size(80))]+ );+ }+#[test]fn remote_divider_stream_has_one_in_flight_and_release_gates_slow_mode() {assert!(remote_divider_can_pump(