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 frontend recovery and TUI handoff geometry
RoversXba0ebe8ba91f
diff --git a/thinkterm-tui/src/lib.rs b/thinkterm-tui/src/lib.rsindex 64667de3..285447a9 100644--- a/thinkterm-tui/src/lib.rs+++ b/thinkterm-tui/src/lib.rs@@ -81,6 +81,10 @@ const RESIZE_REDRAW_WINDOW: Duration = Duration::from_millis(1500);/// the prefetch throttle refills between attempts.const RESIZE_REDRAW_INTERVAL: Duration = Duration::from_millis(60);const TAKEOVER_RESYNC_RETRY_DELAY: Duration = Duration::from_millis(250);+/// Full-screen programs redraw after SIGWINCH asynchronously. Keep the+/// takeover surface opaque until the acknowledged grid and all of its visible+/// rows have stayed ready long enough for that redraw to land.+const TAKEOVER_GEOMETRY_SETTLE: Duration = Duration::from_millis(200);#[derive(Default)]struct TakeoverEpochs {@@ -102,6 +106,12 @@ impl TakeoverEpochs {.contains_key(&(domain_name.to_string(), tab_id))}+ fn current(&self, domain_name: &str, tab_id: TabId) -> Option<u64> {+ self.pending+ .get(&(domain_name.to_string(), tab_id))+ .copied()+ }+fn finish(&mut self, domain_name: &str, tab_id: TabId, epoch: u64) -> bool {let key = (domain_name.to_string(), tab_id);if self.pending.get(&key) != Some(&epoch) {@@ -110,6 +120,28 @@ impl TakeoverEpochs {self.pending.remove(&key);true}++ fn clear_domain(&mut self, domain_name: &str) {+ self.pending.retain(|(domain, _), _| domain != domain_name);+ }+}++#[derive(Clone, Debug)]+struct TakeoverGeometryConfirmation {+ epoch: u64,+ root_size: TerminalSize,+ panes: Vec<(PaneId, TerminalSize)>,+ access_generation: u64,+ ready_since: Option<Instant>,+}++fn takeover_geometry_settled(ready: bool, now: Instant, ready_since: &mut Option<Instant>) -> bool {+ if !ready {+ *ready_since = None;+ return false;+ }+ let started = ready_since.get_or_insert(now);+ now.duration_since(*started) >= TAKEOVER_GEOMETRY_SETTLE}fn effective_frontend_gate(@@ -679,6 +711,10 @@ struct TuiState {/// reaching the pane if the claim round-trip completed very quickly.handoff_consumed_press: bool,takeover_epochs: TakeoverEpochs,+ /// A successful ownership RPC is only the start of a handoff. Keep the+ /// locally previewed pane surfaces pinned until the server has echoed the+ /// same geometry and every visible row has been fetched.+ takeover_geometry_confirmations: HashMap<(String, TabId), TakeoverGeometryConfirmation>,/// When the panes were last asked for new content, so the loop keeps asking/// even while nothing local has changed.last_pane_poll: Instant,@@ -785,6 +821,7 @@ impl TuiState {handoff_geometry_ready: HashMap::new(),handoff_consumed_press: false,takeover_epochs: TakeoverEpochs::default(),+ takeover_geometry_confirmations: HashMap::new(),last_pane_poll: Instant::now(),shared_views: HashMap::new(),shared_view_at: HashMap::new(),@@ -876,6 +913,28 @@ impl TuiState {)}+ /// Start (or reuse) the geometry epoch that keeps an automatically granted+ /// B-mode owner opaque. Explicit claims create their epoch before sending+ /// the RPC; this covers the first renderer, which becomes owner through an+ /// ordinary viewport report instead.+ fn ensure_active_handoff_geometry_epoch(&mut self) -> Option<u64> {+ let (domain_name, domain, tab, remote_tab_id) = self.active_tab()?;+ let access = domain.remote_access_state()?;+ if access.mode != codec::FrontendAccessMode::Handoff+ || domain.owns_remote_viewport(tab.tab_id()) != Some(true)+ || self+ .handoff_geometry_ready+ .get(&(domain_name.clone(), remote_tab_id))+ == Some(&access.generation)+ {+ return None;+ }+ if let Some(epoch) = self.takeover_epochs.current(&domain_name, remote_tab_id) {+ return Some(epoch);+ }+ Some(self.takeover_epochs.begin(&domain_name, remote_tab_id))+ }+fn frontend_surface_blocked(&self) -> bool {self.frontend_gate().obscures_terminal()}@@ -1078,7 +1137,14 @@ async fn run_terminal(.pending_frontend_recovery(FrontendRecoverySlot::Primary, tab.tab_id()).is_some()});- prepare_active_native_viewport(&mut state, area, screen, recovery_pending);+ let preview_epoch = state.ensure_active_handoff_geometry_epoch();+ prepare_active_native_viewport(+ &mut state,+ area,+ screen,+ recovery_pending,+ preview_epoch,+ );}let active = state.active_tab();let local_tab = active.as_ref().map(|(_, _, tab, _)| Arc::clone(tab));@@ -1116,6 +1182,7 @@ async fn run_terminal(state.dirty = false;report_viewport_if_changed(&mut state, rendered.selected_tab, terminal.backend_mut()).await;+ advance_takeover_geometry_confirmation(&mut state);}let now = Instant::now();@@ -1311,6 +1378,7 @@ fn drain_events(receiver: &Receiver<AppEvent>, state: &mut TuiState) {&& domain.connection_generation() == Some(connection_generation)});if current {+ cancel_takeover_geometry_for_domain(state, &domain_name);connection_changed = true;state.connection_generations@@ -1417,6 +1485,7 @@ fn prepare_active_native_viewport(area: ratatui::layout::Rect,screen: ScreenSize,force: bool,+ preview_epoch: Option<u64>,) -> Option<ClientViewport> {let (_, domain, tab, _) = state.active_tab()?;if !force && domain.owns_remote_viewport(tab.tab_id()) != Some(true) {@@ -1438,14 +1507,26 @@ fn prepare_active_native_viewport(let mut panes = Vec::new();for pane in &layout.panes {let handle = Mux::get().get_pane(pane.pane_id)?;- let client = handle.downcast_ref::<ClientPane>()?;+ handle.downcast_ref::<ClientPane>()?;let size = terminal_size(pane.rect.width as usize, pane.rect.height as usize, screen);- client.adopt_frontend_geometry(size);panes.push(codec::ClientPaneViewport {pane_id: pane.pane_id,size,});}+ // Validate the complete pane set before mutating any surface. A topology+ // notification can remove one pane between the two layout passes; applying+ // half a viewport would recreate the very mixed geometry this path is+ // meant to prevent.+ for pane in &panes {+ let handle = Mux::get().get_pane(pane.pane_id)?;+ let client = handle.downcast_ref::<ClientPane>()?;+ if let Some(epoch) = preview_epoch {+ client.preview_frontend_geometry(epoch, pane.size);+ } else {+ client.adopt_frontend_geometry(pane.size);+ }+ }state.layout = layout;Some(ClientViewport::Native { size: root, panes })}@@ -1463,6 +1544,188 @@ fn forget_native_viewport_geometry(viewport: &ClientViewport) {}}+fn finish_native_viewport_preview(viewport: &ClientViewport, epoch: u64, succeeded: bool) {+ let ClientViewport::Native { panes, .. } = viewport else {+ return;+ };+ for pane in panes {+ if let Some(handle) = Mux::get().get_pane(pane.pane_id) {+ if let Some(client) = handle.downcast_ref::<ClientPane>() {+ client.finish_frontend_geometry_preview(epoch, pane.size, succeeded);+ }+ }+ }+}++fn begin_takeover_geometry_confirmation(+ state: &mut TuiState,+ cache_key: (String, TabId),+ epoch: u64,+ viewport: &ClientViewport,+ access_generation: u64,+) {+ let ClientViewport::Native { size, panes } = viewport else {+ return;+ };+ state.takeover_geometry_confirmations.insert(+ cache_key,+ TakeoverGeometryConfirmation {+ epoch,+ root_size: *size,+ panes: panes.iter().map(|pane| (pane.pane_id, pane.size)).collect(),+ access_generation,+ ready_since: None,+ },+ );+ state.redraw_until = Some(Instant::now() + RESIZE_REDRAW_WINDOW);+ state.dirty = true;+}++fn cancel_takeover_geometry_confirmation(+ state: &mut TuiState,+ cache_key: &(String, TabId),+ confirmation: &TakeoverGeometryConfirmation,+) {+ let viewport = ClientViewport::Native {+ size: confirmation.root_size,+ panes: confirmation+ .panes+ .iter()+ .map(|(pane_id, size)| codec::ClientPaneViewport {+ pane_id: *pane_id,+ size: *size,+ })+ .collect(),+ };+ finish_native_viewport_preview(&viewport, confirmation.epoch, false);+ state+ .takeover_epochs+ .finish(&cache_key.0, cache_key.1, confirmation.epoch);+ state.takeover_geometry_confirmations.remove(cache_key);+ if state.handoff_geometry_ready.get(cache_key) == Some(&confirmation.access_generation) {+ state.handoff_geometry_ready.remove(cache_key);+ }+ state.dirty = true;+}++fn cancel_takeover_geometry_for_domain(state: &mut TuiState, domain_name: &str) {+ let keys: Vec<_> = state+ .takeover_geometry_confirmations+ .keys()+ .filter(|(domain, _)| domain == domain_name)+ .cloned()+ .collect();+ for key in keys {+ if let Some(confirmation) = state.takeover_geometry_confirmations.get(&key).cloned() {+ cancel_takeover_geometry_confirmation(state, &key, &confirmation);+ }+ }+ state.takeover_epochs.clear_domain(domain_name);+}++fn active_layout_matches_takeover(+ state: &TuiState,+ tab: &Arc<Tab>,+ confirmation: &TakeoverGeometryConfirmation,+) -> bool {+ if tab.get_size() != confirmation.root_size {+ return false;+ }+ 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;+ }+ confirmation.panes.iter().all(|(pane_id, expected)| {+ state+ .layout+ .panes+ .iter()+ .find(|pane| pane.pane_id == *pane_id)+ .is_some_and(|pane| {+ terminal_size(pane.rect.width as usize, pane.rect.height as usize, screen)+ == *expected+ })+ })+}++/// Confirm the same three layers before revealing a handoff: the local split+/// tree covers this TTY, every pane surface still has the previewed size, and+/// the server has returned a complete snapshot at that size. The preview pins+/// late deltas from the prior GUI until all three agree.+fn advance_takeover_geometry_confirmation(state: &mut TuiState) {+ let Some((domain_name, domain, tab, remote_tab_id)) = state.active_tab() else {+ return;+ };+ let cache_key = (domain_name, remote_tab_id);+ let Some(mut confirmation) = state+ .takeover_geometry_confirmations+ .get(&cache_key)+ .cloned()+ else {+ return;+ };++ let access = domain.remote_access_state();+ let still_owned = domain.owns_remote_viewport(tab.tab_id()) == Some(true)+ && access.as_ref().is_some_and(|access| {+ access.mode == codec::FrontendAccessMode::Handoff+ && access.generation == confirmation.access_generation+ })+ && state.takeover_epochs.current(&cache_key.0, cache_key.1) == Some(confirmation.epoch);+ if !still_owned {+ cancel_takeover_geometry_confirmation(state, &cache_key, &confirmation);+ return;+ }++ let mut ready = active_layout_matches_takeover(state, &tab, &confirmation)+ && !confirmation.panes.is_empty();+ for (pane_id, size) in &confirmation.panes {+ let pane_ready = Mux::get()+ .get_pane(*pane_id)+ .and_then(|pane| {+ pane.downcast_ref::<ClientPane>()+ .map(|client| client.prime_frontend_geometry(*size))+ })+ .unwrap_or(false);+ ready &= pane_ready;+ }++ if !takeover_geometry_settled(ready, Instant::now(), &mut confirmation.ready_since) {+ state+ .takeover_geometry_confirmations+ .insert(cache_key, confirmation);+ return;+ }++ let viewport = ClientViewport::Native {+ size: confirmation.root_size,+ panes: confirmation+ .panes+ .iter()+ .map(|(pane_id, size)| codec::ClientPaneViewport {+ pane_id: *pane_id,+ size: *size,+ })+ .collect(),+ };+ finish_native_viewport_preview(&viewport, confirmation.epoch, true);+ state+ .takeover_epochs+ .finish(&cache_key.0, cache_key.1, confirmation.epoch);+ state+ .handoff_geometry_ready+ .insert(cache_key.clone(), confirmation.access_generation);+ state.takeover_geometry_confirmations.remove(&cache_key);+ state.dirty = true;+}+async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(state: &mut TuiState,remote_tab_id: Option<TabId>,@@ -1542,6 +1805,9 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(&& handoff_generation.is_some_and(|generation| {state.handoff_geometry_ready.get(&cache_key) != Some(&generation)});+ let geometry_confirmation_pending = state+ .takeover_geometry_confirmations+ .contains_key(&cache_key);for candidate in state.domains.values() {if candidate.domain_id() != domain.domain_id() {candidate.clear_frontend_recovery_intent(FrontendRecoverySlot::Primary);@@ -1554,7 +1820,7 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(}if recovery_generation.is_some()- || geometry_generation_is_stale+ || (geometry_generation_is_stale && !geometry_confirmation_pending)|| state.last_viewports.get(&cache_key) != Some(&Some((viewport.clone(), owns))){match domain@@ -1572,7 +1838,18 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>();if let Some(generation) = recovery_generation {if let Err(err) = domain.resync().await {- forget_native_viewport_geometry(&viewport);+ if let Some(epoch) =+ state.takeover_epochs.current(&cache_key.0, cache_key.1)+ {+ finish_native_viewport_preview(&viewport, epoch, false);+ state+ .takeover_epochs+ .finish(&cache_key.0, cache_key.1, epoch);+ state.takeover_geometry_confirmations.remove(&cache_key);+ state.handoff_geometry_ready.remove(&cache_key);+ } else {+ forget_native_viewport_geometry(&viewport);+ }domain.fail_frontend_recovery(FrontendRecoverySlot::Primary,local_tab_id,@@ -1598,11 +1875,26 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(}if owns && matches!(viewport, ClientViewport::Native { .. }) {if response.access.mode == codec::FrontendAccessMode::Handoff {- let prior = state- .handoff_geometry_ready- .insert(cache_key.clone(), response.access.generation);- if prior != Some(response.access.generation) {- state.dirty = true;+ if let Some(epoch) =+ state.takeover_epochs.current(&cache_key.0, cache_key.1)+ {+ begin_takeover_geometry_confirmation(+ state,+ cache_key.clone(),+ epoch,+ &viewport,+ response.access.generation,+ );+ } else {+ // An ordinary resize by an already-confirmed owner+ // does not obscure the terminal. Its access+ // generation is unchanged and remains ready.+ let prior = state+ .handoff_geometry_ready+ .insert(cache_key.clone(), response.access.generation);+ if prior != Some(response.access.generation) {+ state.dirty = true;+ }}}} else if owns {@@ -1613,7 +1905,16 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(}}Err(err) => {- forget_native_viewport_geometry(&viewport);+ if let Some(epoch) = state.takeover_epochs.current(&cache_key.0, cache_key.1) {+ finish_native_viewport_preview(&viewport, epoch, false);+ state+ .takeover_epochs+ .finish(&cache_key.0, cache_key.1, epoch);+ state.takeover_geometry_confirmations.remove(&cache_key);+ state.handoff_geometry_ready.remove(&cache_key);+ } else {+ forget_native_viewport_geometry(&viewport);+ }if let Some(generation) = recovery_generation {domain.fail_frontend_recovery(FrontendRecoverySlot::Primary,@@ -1860,20 +2161,35 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {let handoff = domain.remote_access_state().is_some_and(|access| access.mode == codec::FrontendAccessMode::Handoff);+ let epoch = state.takeover_epochs.begin(&domain_name, remote_tab_id);let viewport = if handoff {let area = state.layout.screen;- prepare_active_native_viewport(state, area, screen, true)- .context("viewport is not ready; retry after the terminal redraws")?+ match prepare_active_native_viewport(state, area, screen, true, Some(epoch)) {+ Some(viewport) => viewport,+ None => {+ state+ .takeover_epochs+ .finish(&domain_name, remote_tab_id, epoch);+ anyhow::bail!("viewport is not ready; retry after the terminal redraws");+ }+ }} else {- state+ match state.last_viewports.get(&(domain_name.clone(), remote_tab_id)).and_then(|entry| entry.as_ref()).map(|(viewport, _)| viewport.clone())- .context("viewport is not ready; retry after the terminal redraws")?+ {+ Some(viewport) => viewport,+ None => {+ state+ .takeover_epochs+ .finish(&domain_name, remote_tab_id, epoch);+ anyhow::bail!("viewport is not ready; retry after the terminal redraws");+ }+ }};let reported_size = viewport.size();- let epoch = state.takeover_epochs.begin(&domain_name, remote_tab_id);state.dirty = true;let claimed = match domain.claim_client_viewport(local_tab_id, viewport.clone())@@ -1881,7 +2197,11 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {{Ok(claimed) => claimed,Err(err) => {- forget_native_viewport_geometry(&viewport);+ if handoff {+ finish_native_viewport_preview(&viewport, epoch, false);+ } else {+ forget_native_viewport_geometry(&viewport);+ }state.takeover_epochs.finish(&domain_name, remote_tab_id, epoch);@@ -1889,7 +2209,11 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {}};if domain.owns_remote_viewport(local_tab_id) != Some(true) {- forget_native_viewport_geometry(&viewport);+ if handoff {+ finish_native_viewport_preview(&viewport, epoch, false);+ } else {+ forget_native_viewport_geometry(&viewport);+ }state.takeover_epochs.finish(&domain_name, remote_tab_id, epoch);@@ -1909,17 +2233,22 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {);schedule_takeover_resync(domain_name.clone(), Arc::clone(&domain));}- state- .takeover_epochs- .finish(&domain_name, remote_tab_id, epoch);let cache_key = (domain_name, remote_tab_id);state.last_viewports- .insert(cache_key.clone(), Some((viewport, true)));+ .insert(cache_key.clone(), Some((viewport.clone(), true)));if claimed.access.mode == codec::FrontendAccessMode::Handoff {+ begin_takeover_geometry_confirmation(+ state,+ cache_key.clone(),+ epoch,+ &viewport,+ claimed.access.generation,+ );+ } else {state- .handoff_geometry_ready- .insert(cache_key.clone(), claimed.access.generation);+ .takeover_epochs+ .finish(&cache_key.0, cache_key.1, epoch);}for pane in &state.layout.panes {state.ui.set_scroll_offset(pane.pane_id, 0);@@ -1954,7 +2283,7 @@ async fn set_active_frontend_access_mode(.screen_size.context("viewport is not ready; retry after the terminal redraws")?;let area = state.layout.screen;- let viewport = prepare_active_native_viewport(state, area, screen, false)+ let viewport = prepare_active_native_viewport(state, area, screen, false, None).context("viewport is not ready; retry after the terminal redraws")?;let access = domain.set_frontend_access_mode(local_tab_id, mode, viewport.clone())@@ -2163,6 +2492,7 @@ async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {retry_domain(state, &name).await?}Action::DisconnectDomain(name) => {+ cancel_takeover_geometry_for_domain(state, &name);if let Some(domain) = state.domains.get(&name) {domain.perform_detach();}@@ -4991,6 +5321,29 @@ mod tests {);}+ #[test]+ fn takeover_geometry_requires_a_quiet_ready_window() {+ let started = Instant::now();+ let mut ready_since = None;+ assert!(!takeover_geometry_settled(true, started, &mut ready_since));+ assert!(!takeover_geometry_settled(+ true,+ started + TAKEOVER_GEOMETRY_SETTLE / 2,+ &mut ready_since+ ));+ assert!(takeover_geometry_settled(+ true,+ started + TAKEOVER_GEOMETRY_SETTLE,+ &mut ready_since+ ));+ assert!(!takeover_geometry_settled(+ false,+ started + TAKEOVER_GEOMETRY_SETTLE * 2,+ &mut ready_since+ ));+ assert!(ready_since.is_none());+ }+#[test]fn handoff_reveals_each_tab_only_after_its_geometry_generation_is_ready() {let access = codec::FrontendAccessState {diff --git a/thinkterm-tui/src/render.rs b/thinkterm-tui/src/render.rsindex 5cf42620..4f91ce02 100644--- a/thinkterm-tui/src/render.rs+++ b/thinkterm-tui/src/render.rs@@ -1,7 +1,7 @@use crate::model::AppModel;use crate::settings::TuiConfig;use crate::state::{AppMode, ConnectionStatus, SelectionPoint, TextSelection, UiState, ViewClass};-use crate::view::{PaneNav, ViewLayout};+use crate::view::{PaneNav, PaneView, SplitView, ViewLayout};use mux::pane::{Pane, PaneId, SearchResult};use mux::tab::{SplitDirection, Tab, TabId};use ratatui::layout::{Alignment, Rect};@@ -305,6 +305,17 @@ fn render_panes(frame: &mut Frame<'_>, tab: &Arc<Tab>, ui: &UiState, view: &Viewelse {continue;};+ if let Some(collapsed) = pane_view.collapsed {+ paint_collapsed_pane(+ frame,+ &positioned.pane,+ pane_view,+ collapsed,+ tab.get_active_pane()+ .is_some_and(|active| active.pane_id() == pane_view.pane_id),+ );+ continue;+ }if let Some(border) = pane_view.border {let focused = tab.get_active_pane()@@ -335,14 +346,16 @@ fn render_panes(frame: &mut Frame<'_>, tab: &Arc<Tab>, ui: &UiState, view: &View// frames is a third line of chrome in a row that has two. When the frames// were not drawn — too small, or turned off — the divider is the only thing// separating them.- let framed = view.panes.iter().any(|pane| pane.border.is_some());- for split in view.splits.iter().filter(|_| !framed) {+ for split in &view.splits {let symbol = match split.direction {SplitDirection::Horizontal => "│",SplitDirection::Vertical => "─",};for y in split.rect.y..split.rect.bottom() {for x in split.rect.x..split.rect.right() {+ if !split_cell_needs_divider(view, split, x, y) {+ continue;+ }frame.buffer_mut()[(x, y)].set_symbol(symbol).set_style(chrome_border());@@ -354,7 +367,7 @@ fn render_panes(frame: &mut Frame<'_>, tab: &Arc<Tab>, ui: &UiState, view: &Viewif let Some(pane_view) = view.panes.iter()- .find(|pane| pane.pane_id == active.pane_id())+ .find(|pane| pane.pane_id == active.pane_id() && pane.collapsed.is_none()){let dims = active.get_dimensions();let offset = ui.scroll_offset(active.pane_id());@@ -375,6 +388,69 @@ fn render_panes(frame: &mut Frame<'_>, tab: &Arc<Tab>, ui: &UiState, view: &View}}+fn split_cell_needs_divider(view: &ViewLayout, split: &SplitView, x: u16, y: u16) -> bool {+ let framed_on_both_sides = match split.direction {+ SplitDirection::Horizontal => {+ let left = view.panes.iter().any(|pane| {+ pane.border.is_some_and(|border| {+ border.right() == x && y >= border.y && y < border.bottom()+ })+ });+ let right = view.panes.iter().any(|pane| {+ pane.border.is_some_and(|border| {+ border.x == x.saturating_add(1) && y >= border.y && y < border.bottom()+ })+ });+ left && right+ }+ SplitDirection::Vertical => {+ let above = view.panes.iter().any(|pane| {+ pane.border.is_some_and(|border| {+ border.bottom() == y && x >= border.x && x < border.right()+ })+ });+ let below = view.panes.iter().any(|pane| {+ pane.border.is_some_and(|border| {+ border.y == y.saturating_add(1) && x >= border.x && x < border.right()+ })+ });+ above && below+ }+ };+ !framed_on_both_sides+}++fn paint_collapsed_pane(+ frame: &mut Frame<'_>,+ pane: &Arc<dyn Pane>,+ pane_view: &PaneView,+ area: Rect,+ focused: bool,+) {+ fill(frame, area, " ", chrome());+ if let Some(nav) = &pane_view.nav {+ paint_pane_nav(frame, nav, focused);+ return;+ }+ let title = pane.get_title();+ let title = if title.trim().is_empty() {+ "shell"+ } else {+ title.trim()+ };+ let label = format!(" … {title} (pane too small) ");+ draw_text(+ frame,+ area,+ &label,+ if focused {+ chrome_accent_text().add_modifier(Modifier::BOLD)+ } else {+ chrome_dim()+ },+ );+}+/// Draw one pane's own strip: what is stacked behind it, and what can be done/// to it.///@@ -1212,6 +1288,35 @@ mod tests {static THEME_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());+ fn divider_test_pane(pane_id: PaneId, border: Option<Rect>) -> PaneView {+ PaneView {+ pane_id,+ rect: border.unwrap_or_default(),+ scrollbar: None,+ nav: None,+ border,+ collapsed: None,+ }+ }++ #[test]+ fn mixed_pane_frames_keep_the_uncovered_divider() {+ let split = SplitView {+ index: 0,+ rect: Rect::new(5, 0, 1, 4),+ direction: SplitDirection::Horizontal,+ };+ let mut view = ViewLayout::default();+ view.panes = vec![+ divider_test_pane(1, Some(Rect::new(0, 0, 5, 4))),+ divider_test_pane(2, Some(Rect::new(6, 0, 5, 4))),+ ];+ assert!(!split_cell_needs_divider(&view, &split, 5, 2));++ view.panes[1].border = None;+ assert!(split_cell_needs_divider(&view, &split, 5, 2));+ }+#[test]fn fit_text_respects_cell_width() {assert_eq!(fit_text("abc", 2), "ab");diff --git a/thinkterm-tui/src/view.rs b/thinkterm-tui/src/view.rsindex 1010ef4e..c3f58954 100644--- a/thinkterm-tui/src/view.rs+++ b/thinkterm-tui/src/view.rs@@ -177,6 +177,9 @@ pub struct PaneView {/// The frame drawn around the pane, when it has one. Encloses the grid, its/// scrollbar and its nav bar.pub border: Option<Rect>,+ /// A split branch too short to show normal chrome and a useful grid. It is+ /// painted as an explicit compact pane instead of an orphaned output row.+ pub collapsed: Option<Rect>,}#[derive(Clone, Debug)]@@ -845,6 +848,7 @@ fn compute_panes(tab: &Arc<Tab>, ui: &UiState, area: Rect, view: &mut ViewLayoutif rect.is_empty() {continue;}+ let collapsed = (pane_count > 1 && rect.height < PANE_NAV_MIN_ROWS).then_some(rect);// Only where there is another pane to be told apart from. A lone pane// already has the window's own edges; framing it spends a row and two// columns to draw a line around the only thing on screen.@@ -864,15 +868,20 @@ fn compute_panes(tab: &Arc<Tab>, ui: &UiState, area: Rect, view: &mut ViewLayout};// Above the grid, never over it, for the same reason as the scrollbar:// the row it takes is a row the terminal is then told it does not have.- let nav = compute_pane_nav(- pane_id,- &tab.pane_stack_tabs(pane_id),- positioned.is_zoomed,- ui.pane_nav_bar,- touch,- bar_area,- view,- );+ let stack = tab.pane_stack_tabs(pane_id);+ let nav = if collapsed.is_some() && ui.pane_nav_bar {+ compute_collapsed_pane_nav(pane_id, &stack, positioned.is_zoomed, touch, bar_area, view)+ } else {+ compute_pane_nav(+ pane_id,+ &stack,+ positioned.is_zoomed,+ ui.pane_nav_bar,+ touch,+ bar_area,+ view,+ )+ };let bar_rows = nav.as_ref().map_or(0, |nav| nav.rect.height);let rect = if framed {// The top edge is already spent on the bar (or is a plain edge when@@ -913,6 +922,7 @@ fn compute_panes(tab: &Arc<Tab>, ui: &UiState, area: Rect, view: &mut ViewLayoutscrollbar,nav,border,+ collapsed,});view.hits.push(HitRegion {rect,@@ -945,6 +955,63 @@ fn compute_panes(tab: &Arc<Tab>, ui: &UiState, area: Rect, view: &mut ViewLayout/// the desktop's order and deliberately so: on a phone, a pane that has just/// been split needs to be able to un-split itself by zooming far more than it/// needs to split again.+/// A two-row split cannot afford the normal pane bar and its promised two rows+/// of grid. Spend one row on a compact, zoomable identity and leave the other+/// as the PTY grid. A one-row split keeps its only row as the grid, but the+/// renderer still replaces its output with an explicit collapsed marker.+fn compute_collapsed_pane_nav(+ pane_id: PaneId,+ stack: &[PaneStackTab],+ zoomed: bool,+ touch: bool,+ rect: Rect,+ view: &mut ViewLayout,+) -> Option<PaneNav> {+ let button = if touch { 3u16 } else { 2u16 };+ if rect.height < 2 || rect.width < MIN_LABEL_COLUMNS.saturating_add(button) {+ return None;+ }+ let bar = Rect::new(rect.x, rect.y, rect.width, 1);+ let zoom = PaneTool::Zoom { zoomed };+ let tool = Rect::new(bar.right() - button, bar.y, button, 1);+ view.hits.push(HitRegion {+ rect: tool,+ target: HitTarget::PaneTool(pane_id, zoom),+ });++ let tabs = stack+ .iter()+ .find(|entry| entry.is_active)+ .or_else(|| stack.first())+ .map(|entry| {+ let title = if entry.title.trim().is_empty() {+ "shell"+ } else {+ entry.title.trim()+ };+ let tab = Rect::new(bar.x, bar.y, bar.width - button, 1);+ view.hits.push(HitRegion {+ rect: tab,+ target: HitTarget::PaneNavTab(entry.pane_id),+ });+ PaneNavTab {+ rect: tab,+ pane_id: entry.pane_id,+ label: format!(" … {title} "),+ active: true,+ close: None,+ }+ })+ .into_iter()+ .collect();++ Some(PaneNav {+ rect: bar,+ tabs,+ tools: vec![(tool, zoom)],+ })+}+fn compute_pane_nav(pane_id: PaneId,stack: &[PaneStackTab],@@ -1356,6 +1423,28 @@ mod tests {);}+ #[test]+ fn a_two_row_collapsed_pane_keeps_a_zoomable_identity() {+ let entries = stack(&["shell"], 0);+ let mut view = ViewLayout::default();+ let nav = compute_collapsed_pane_nav(+ 1,+ &entries,+ false,+ false,+ Rect::new(4, 7, 30, 2),+ &mut view,+ )+ .expect("two rows can show a compact bar and one grid row");+ assert_eq!(nav.rect, Rect::new(4, 7, 30, 1));+ assert_eq!(nav.tabs[0].label, " … shell ");+ assert_eq!(nav.tools[0].1, PaneTool::Zoom { zoomed: false });+ assert_eq!(+ view.hit(nav.tools[0].0.x, nav.tools[0].0.y),+ Some(&HitTarget::PaneTool(1, PaneTool::Zoom { zoomed: false }))+ );+ }+#[test]fn touch_targets_widen_the_pane_buttons_without_costing_a_second_row() {let entries = stack(&["shell"], 0);diff --git a/wezterm-gui/src/frontend.rs b/wezterm-gui/src/frontend.rsindex 299373a2..5d789645 100644--- a/wezterm-gui/src/frontend.rs+++ b/wezterm-gui/src/frontend.rs@@ -16,7 +16,7 @@ use std::cell::RefCell;use std::collections::{BTreeMap, HashSet};use std::rc::Rc;use std::sync::Arc;-use wezterm_client::domain::{ClientDomain, ThinkTermFrontendRecoveryTarget};+use wezterm_client::domain::{ClientDomain, FrontendRecoverySlot, ThinkTermFrontendRecoveryTarget};use wezterm_term::{Alert, ClipboardSelection};use wezterm_toast_notification::*;@@ -27,8 +27,7 @@ fn should_spawn_reconciled_gui_window(is_domain_owned: bool, workspace: &str) ->fn frontend_recovery_tab(current_generation: Option<u64>,requested_generation: u64,- mux_window_id: MuxWindowId,- slot: wezterm_client::domain::FrontendRecoverySlot,+ slot: FrontendRecoverySlot,recovery_targets: &[ThinkTermFrontendRecoveryTarget],) -> Option<TabId> {if current_generation != Some(requested_generation) {@@ -36,7 +35,7 @@ fn frontend_recovery_tab(}recovery_targets.iter()- .find(|target| target.window_id == mux_window_id && target.slot == slot)+ .find(|target| target.slot == slot).map(|target| target.tab_id)}@@ -58,7 +57,13 @@ pub fn request_thinkterm_frontend_recovery(// a failed recovery target, not a reason to leave the domain parked in// Syncing forever.for target in recovery_targets {- let Some(gui_window) = frontend.gui_window_for_mux_window(target.window_id) else {+ // A mux WindowId is process-local and can change when the remote+ // server is replaced. Locate the retained native window through+ // its stable frontend slot, then rebind that window to the fresh+ // mux id below. Looking it up by target.window_id here caused a+ // failed recovery to abort and retry forever while allocating a+ // new mux window on every generation.+ let Some(gui_window) = frontend.gui_window_for_recovery_slot(target.slot) else {if let Some(domain) = Mux::get().get_domain(domain_id) {if let Some(client) = domain.downcast_ref::<ClientDomain>() {client.fail_frontend_recovery(@@ -66,8 +71,8 @@ pub fn request_thinkterm_frontend_recovery(target.tab_id,connection_generation,format!(- "GUI window {} disappeared during mux recovery",- target.window_id+ "GUI frontend slot {:?} disappeared during mux recovery",+ target.slot),);}@@ -86,11 +91,32 @@ pub fn request_thinkterm_frontend_recovery(let tab_id = frontend_recovery_tab(current_generation,connection_generation,- term_window.mux_window_id,term_window.frontend_recovery_slot(),&[target],);if let Some(tab_id) = tab_id {+ let target_is_live = mux+ .get_window(target.window_id)+ .is_some_and(|window| window.idx_by_id(tab_id).is_some());+ if !target_is_live {+ if let Some(domain) = mux.get_domain(domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.fail_frontend_recovery(+ target.slot,+ tab_id,+ connection_generation,+ format!(+ "replacement mux window {} no longer contains tab {}",+ target.window_id, tab_id+ ),+ );+ }+ }+ return;+ }+ if term_window.mux_window_id != target.window_id {+ term_window.switch_to_mux_window(target.window_id);+ }if !term_window.sync_replacement_frontend_geometry(tab_id,target.slot,@@ -138,6 +164,10 @@ pub struct GuiFrontEnd {switching_workspaces: RefCell<usize>,spawned_mux_window: RefCell<HashSet<MuxWindowId>>,known_windows: RefCell<BTreeMap<Window, MuxWindowId>>,+ /// Stable native-window lookup used across replacement mux runtimes.+ /// Unlike `known_windows`, this is keyed by the frontend-owned slot and+ /// therefore remains valid while remote WindowIds are being replaced.+ recovery_windows: RefCell<BTreeMap<FrontendRecoverySlot, Window>>,/// Set when the LAST GUI window closed and we detached whatever client/// domains were attached at that moment. A domain whose attach was still/// in flight shows as Detached then, escapes that sweep, and completes@@ -169,6 +199,7 @@ impl GuiFrontEnd {switching_workspaces: RefCell::new(0),spawned_mux_window: RefCell::new(HashSet::new()),known_windows: RefCell::new(BTreeMap::new()),+ recovery_windows: RefCell::new(BTreeMap::new()),detach_when_windowless: std::cell::Cell::new(false),client_id: client_id.clone(),config_subscription: RefCell::new(None),@@ -751,13 +782,21 @@ impl GuiFrontEnd {self.reconcile_workspace();}- pub fn record_known_window(&self, window: Window, mux_window_id: MuxWindowId) {+ pub fn record_known_window(+ &self,+ window: Window,+ mux_window_id: MuxWindowId,+ recovery_slot: FrontendRecoverySlot,+ ) {// A GUI window exists again: any pending last-window cleanup is moot.self.detach_when_windowless.set(false);// Mark this mux window as having a GUI window so the additive reconcile// never re-creates a window for it (e.g. after the user closes it while// its mux window keeps running in the background).self.spawned_mux_window.borrow_mut().insert(mux_window_id);+ self.recovery_windows+ .borrow_mut()+ .insert(recovery_slot, window.clone());self.known_windows.borrow_mut().insert(window, mux_window_id);@@ -767,6 +806,9 @@ impl GuiFrontEnd {}pub fn forget_known_window(&self, window: &Window) {+ self.recovery_windows+ .borrow_mut()+ .retain(|_, candidate| candidate != window);let now_empty = {let mut windows = self.known_windows.borrow_mut();windows.remove(window);@@ -878,6 +920,15 @@ impl GuiFrontEnd {}None}++ pub fn gui_window_for_recovery_slot(&self, slot: FrontendRecoverySlot) -> Option<GuiWin> {+ let window = self.recovery_windows.borrow().get(&slot)?.clone();+ let mux_window_id = self.known_windows.borrow().get(&window).copied()?;+ Some(GuiWin {+ mux_window_id,+ window,+ })+ }}thread_local! {@@ -978,7 +1029,7 @@ mod tests {}#[test]- fn replacement_recovery_targets_the_retained_window_in_the_current_generation() {+ fn replacement_recovery_targets_the_stable_slot_in_the_current_generation() {let recovery_targets = [ThinkTermFrontendRecoveryTarget {slot: FrontendRecoverySlot::Window(70),@@ -995,7 +1046,6 @@ mod tests {frontend_recovery_tab(Some(7),7,- 8,FrontendRecoverySlot::Window(80),&recovery_targets,),@@ -1005,41 +1055,23 @@ mod tests {frontend_recovery_tab(Some(8),7,- 8,FrontendRecoverySlot::Window(80),&recovery_targets,),None);assert_eq!(- frontend_recovery_tab(- Some(7),- 7,- 9,- FrontendRecoverySlot::Window(80),- &recovery_targets,- ),- None- );- assert_eq!(- frontend_recovery_tab(- None,- 7,- 8,- FrontendRecoverySlot::Window(80),- &recovery_targets,- ),+ frontend_recovery_tab(None, 7, FrontendRecoverySlot::Window(80), &recovery_targets,),None);assert_eq!(frontend_recovery_tab(Some(7),7,- 8,FrontendRecoverySlot::Window(70),&recovery_targets,),- None+ Some(41));}}diff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rsindex 7ac06367..2269eff7 100644--- a/wezterm-gui/src/termwindow/mod.rs+++ b/wezterm-gui/src/termwindow/mod.rs@@ -2534,8 +2534,14 @@ impl TermWindow {// switch_to_mux_window. Recording the stale construction id would point// known_windows at a mux window the restore just orphaned (and possibly// killed), and the next reconcile would then close this brand-new window.- let adopted_mux_window_id = tw.borrow().mux_window_id;- front_end().record_known_window(window, adopted_mux_window_id);+ let (adopted_mux_window_id, recovery_slot) = {+ let term_window = tw.borrow();+ (+ term_window.mux_window_id,+ term_window.frontend_recovery_slot(),+ )+ };+ front_end().record_known_window(window, adopted_mux_window_id, recovery_slot);Ok(())}