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
Stabilize mux restart recovery and frontend geometry
RoversX3f16af2e43ce
diff --git a/Cargo.lock b/Cargo.lockindex 7b93d836..b362c2cb 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -8069,6 +8069,7 @@ dependencies = ["openssl","portable-pty","promise",+ "signal-hook","umask","wezterm-blob-leases 0.1.1","wezterm-gui-subcommands",diff --git a/thinkterm-tui/src/lib.rs b/thinkterm-tui/src/lib.rsindex 40c5a542..64667de3 100644--- a/thinkterm-tui/src/lib.rs+++ b/thinkterm-tui/src/lib.rs@@ -43,7 +43,9 @@ use termwiz::terminal::{new_terminal, ScreenSize, TerminalWaker};use uuid::Uuid;use view::{HitTarget, PaneTool, TabBarControl, TreeAction, ViewLayout};use wezterm_client::client::Client;-use wezterm_client::domain::{ClientDomain, ClientDomainConfig, RemoteFrontendGate};+use wezterm_client::domain::{+ ClientDomain, ClientDomainConfig, FrontendRecoverySlot, RemoteFrontendGate,+};use wezterm_client::pane::ClientPane;use wezterm_term::input::{MouseButton, MouseEvent, MouseEventKind};use wezterm_term::TerminalSize;@@ -121,6 +123,19 @@ fn effective_frontend_gate(}}+fn handoff_geometry_is_pending(+ remote_gate: &RemoteFrontendGate,+ access: Option<&codec::FrontendAccessState>,+ owns: Option<bool>,+ ready_generation: Option<u64>,+) -> bool {+ matches!(remote_gate, RemoteFrontendGate::Visible)+ && owns == Some(true)+ && access+ .filter(|access| access.mode == codec::FrontendAccessMode::Handoff)+ .is_some_and(|access| ready_generation != Some(access.generation))+}+#[derive(Debug, Clone)]pub struct TuiOptions {/// Configured mux client-domain names. If empty, the standard Local mux@@ -648,14 +663,18 @@ struct TuiState {dirty: bool,layout: ViewLayout,last_mouse_buttons: MouseButtons,- /// Each tab's last advertised grid, and — through the key alone — whether- /// this renderer has advertised one at all. Forgetting a size re-sends it+ /// Each tab's last advertised viewport, and — through the key alone —+ /// whether this renderer has advertised one at all. Forgetting it re-sends it/// 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<(TerminalSize, bool)>>,+ last_viewports: HashMap<(String, TabId), Option<(ClientViewport, bool)>>,+ /// 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.+ handoff_geometry_ready: HashMap<(String, TabId), u64>,/// Keep the release paired with a press on B's takeover surface from/// reaching the pane if the claim round-trip completed very quickly.handoff_consumed_press: bool,@@ -665,14 +684,18 @@ struct TuiState {last_pane_poll: Instant,/// The view last offered to the server, and when, so a flick of the wheel/// does not become a round trip per notch.- shared_view: Option<codec::ClientView>,- shared_view_at: Option<Instant>,+ shared_views: HashMap<(String, TabId), codec::ClientView>,+ shared_view_at: HashMap<(String, TabId), Instant>,/// A view change arrived inside the coalescing window and still has to go/// out once that window closes.- share_view_pending: bool,+ share_view_pending: HashSet<(String, TabId)>,/// The view last adopted from the owner, so following it is idempotent and/// does not fight this renderer's own scrolling every frame.- followed_view: Option<codec::ClientView>,+ followed_views: HashMap<(String, TabId), codec::ClientView>,+ /// Latest physical cell/pixel information from the TTY. Takeover actions+ /// run between frames, so they use this to build the same native viewport+ /// the most recent frame used.+ screen_size: Option<ScreenSize>,/// When the terminal last changed size, plus the time it has to stay still/// before that size is worth forwarding. `None` once it has been forwarded.resize_settles_at: Option<Instant>,@@ -759,13 +782,15 @@ impl TuiState {layout: ViewLayout::default(),last_mouse_buttons: MouseButtons::NONE,last_viewports: HashMap::new(),+ handoff_geometry_ready: HashMap::new(),handoff_consumed_press: false,takeover_epochs: TakeoverEpochs::default(),last_pane_poll: Instant::now(),- shared_view: None,- shared_view_at: None,- share_view_pending: false,- followed_view: None,+ shared_views: HashMap::new(),+ shared_view_at: HashMap::new(),+ share_view_pending: HashSet::new(),+ followed_views: HashMap::new(),+ screen_size: None,resize_settles_at: None,redraw_until: None,connection_generations,@@ -793,6 +818,12 @@ impl TuiState {Some((domain_name, domain, tab, remote_tab_id))}+ fn active_view_cache_key(&self) -> Option<(String, TabId)> {+ let remote_tab_id = self.model.selected_tab()?.tab_id;+ let domain_name = self.model.selected_row()?.key.domain_name.clone();+ Some((domain_name, remote_tab_id))+ }+fn active_pane(&self) -> Option<Arc<dyn Pane>> {self.active_tab()?.2.get_active_pane()}@@ -826,12 +857,22 @@ impl TuiState {}fn frontend_gate(&self) -> RemoteFrontendGate {- let Some((domain_name, domain, _, remote_tab_id)) = self.active_tab() else {+ let Some((domain_name, domain, tab, remote_tab_id)) = self.active_tab() else {return RemoteFrontendGate::Visible;};+ let remote_gate = domain.remote_frontend_gate();+ let access = domain.remote_access_state();+ let handoff_geometry_pending = handoff_geometry_is_pending(+ &remote_gate,+ access.as_ref(),+ domain.owns_remote_viewport(tab.tab_id()),+ self.handoff_geometry_ready+ .get(&(domain_name.clone(), remote_tab_id))+ .copied(),+ );effective_frontend_gate(- self.takeover_epochs.contains(&domain_name, remote_tab_id),- domain.remote_frontend_gate(),+ self.takeover_epochs.contains(&domain_name, remote_tab_id) || handoff_geometry_pending,+ remote_gate,)}@@ -1020,11 +1061,25 @@ async fn run_terminal(}}- if state.share_view_pending && share_view_is_due(&state) {- state.dirty = true;+ if let Some(cache_key) = state.active_view_cache_key() {+ if state.share_view_pending.contains(&cache_key)+ && share_view_is_due(&state, &cache_key)+ {+ state.dirty = true;+ }}if state.dirty {+ if let Ok(screen) = terminal.backend_mut().screen_size() {+ state.screen_size = Some(screen);+ let area: ratatui::layout::Rect = terminal.size()?.into();+ let recovery_pending = state.active_tab().is_some_and(|(_, domain, tab, _)| {+ domain+ .pending_frontend_recovery(FrontendRecoverySlot::Primary, tab.tab_id())+ .is_some()+ });+ prepare_active_native_viewport(&mut state, area, screen, recovery_pending);+ }let active = state.active_tab();let local_tab = active.as_ref().map(|(_, _, tab, _)| Arc::clone(tab));let viewport_status = state.viewport_status();@@ -1070,11 +1125,16 @@ async fn run_terminal(let until_poll =PANE_POLL_INTERVAL.saturating_sub(now.saturating_duration_since(state.last_pane_poll));wait = Some(wait.map_or(until_poll, |wait| wait.min(until_poll)));- if state.share_view_pending {- let until_share = state.shared_view_at.map_or(Duration::ZERO, |at| {- SHARE_VIEW_INTERVAL.saturating_sub(now.saturating_duration_since(at))- });- wait = Some(wait.map_or(until_share, |wait| wait.min(until_share)));+ if let Some(cache_key) = state.active_view_cache_key() {+ if state.share_view_pending.contains(&cache_key) {+ let until_share = state+ .shared_view_at+ .get(&cache_key)+ .map_or(Duration::ZERO, |at| {+ SHARE_VIEW_INTERVAL.saturating_sub(now.saturating_duration_since(*at))+ });+ wait = Some(wait.map_or(until_share, |wait| wait.min(until_share)));+ }}// Nothing else will wake this loop once the terminal stops changing, so// the settle deadline has to be one of the things it waits on.@@ -1260,6 +1320,21 @@ fn drain_events(receiver: &Receiver<AppEvent>, state: &mut TuiState) {state.last_viewports.retain(|(domain, _), _| domain != &domain_name);+ state+ .handoff_geometry_ready+ .retain(|(domain, _), _| domain != &domain_name);+ state+ .shared_views+ .retain(|(domain, _), _| domain != &domain_name);+ state+ .shared_view_at+ .retain(|(domain, _), _| domain != &domain_name);+ state+ .share_view_pending+ .retain(|(domain, _)| domain != &domain_name);+ state+ .followed_views+ .retain(|(domain, _), _| domain != &domain_name);state.dirty = true;}}@@ -1333,6 +1408,61 @@ async fn refresh_sessions(state: &mut TuiState) {}}+/// Reflow the selected top-level tab to this TUI and derive the pane grids from+/// that same layout pass. `force` is used by an explicit takeover while another+/// renderer still owns the tab; normal frames only preview geometry we already+/// own, so a passive renderer never disturbs the shared local mirror.+fn prepare_active_native_viewport(+ state: &mut TuiState,+ area: ratatui::layout::Rect,+ screen: ScreenSize,+ force: bool,+) -> Option<ClientViewport> {+ let (_, domain, tab, _) = state.active_tab()?;+ if !force && domain.owns_remote_viewport(tab.tab_id()) != Some(true) {+ return None;+ }++ let shell = view::compute_view(area, &state.model, &state.ui, None);+ if shell.content.width == 0 || shell.content.height == 0 {+ return None;+ }+ let root = terminal_size(+ shell.content.width as usize,+ shell.content.height as usize,+ screen,+ );+ tab.resize(root);++ let layout = view::compute_view(area, &state.model, &state.ui, Some(&tab));+ 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>()?;+ 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,+ });+ }+ state.layout = layout;+ Some(ClientViewport::Native { size: root, panes })+}++fn forget_native_viewport_geometry(viewport: &ClientViewport) {+ 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.forget_frontend_geometry(pane.size);+ }+ }+ }+}+async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(state: &mut TuiState,remote_tab_id: Option<TabId>,@@ -1370,43 +1500,135 @@ async fn report_viewport_if_changed<T: termwiz::terminal::Terminal>(return;}};+ state.screen_size = Some(screen);let size = terminal_size(content.width as usize, content.height as usize, screen);- // Reported as one grid for the whole tab, never per pane. The server owns- // how a tab divides into panes and answers with a tab-level size that this- // renderer then adopts; describing the panes as well means both sides are- // deciding the same split from different inputs, and dragging a divider- // leaves every pty a step behind the layout it was drawn for.- // Ownership is part of what was said, not just the numbers. A device that- // takes the viewport by typing changes what the server will do with the- // very same grid, and the tab this renderer lays out from is still the- // shape the *other* device left it. Keying the cache on both means the- // next frame notices and says it again — and stops as soon as the two- // agree, which reacting to the server's own publication did not: that- // published back at us and cost a thousand frames a second.- let owns = domain.owns_remote_viewport(local_tab_id) != Some(false);- let cache_key = (domain_name, remote_tab_id);- if state.last_viewports.get(&cache_key) != Some(&Some((size, owns))) {+ // A passive renderer advertises only the screen it could take over with.+ // Once it owns the tab, the pre-draw geometry pass has exact pane grids,+ // including TUI borders/nav bars, so publish them together with the root.+ // This replaces the old CellGrid-then-detached-Resize sequence whose+ // intermediate split trees were visible to a concurrently attached GUI.+ let ownership = domain.owns_remote_viewport(local_tab_id);+ let owns = ownership != Some(false);+ let recovery_generation =+ domain.pending_frontend_recovery(FrontendRecoverySlot::Primary, local_tab_id);+ let viewport = if ownership == Some(true) || recovery_generation.is_some() {+ let panes = state+ .layout+ .panes+ .iter()+ .filter_map(|pane| {+ let handle = Mux::get().get_pane(pane.pane_id)?;+ handle.downcast_ref::<ClientPane>()?;+ Some(codec::ClientPaneViewport {+ pane_id: pane.pane_id,+ size: terminal_size(+ pane.rect.width as usize,+ pane.rect.height as usize,+ screen,+ ),+ })+ })+ .collect();+ ClientViewport::Native { size, panes }+ } else {+ ClientViewport::CellGrid { size }+ };+ let cache_key = (domain_name.clone(), remote_tab_id);+ let handoff_generation = domain+ .remote_access_state()+ .filter(|access| access.mode == codec::FrontendAccessMode::Handoff)+ .map(|access| access.generation);+ let geometry_generation_is_stale = ownership == Some(true)+ && handoff_generation.is_some_and(|generation| {+ state.handoff_geometry_ready.get(&cache_key) != Some(&generation)+ });+ for candidate in state.domains.values() {+ if candidate.domain_id() != domain.domain_id() {+ candidate.clear_frontend_recovery_intent(FrontendRecoverySlot::Primary);+ }+ }+ if let Err(err) =+ domain.set_frontend_recovery_intent(FrontendRecoverySlot::Primary, local_tab_id, &viewport)+ {+ log::trace!("recording TUI frontend recovery intent: {err:#}");+ }++ if recovery_generation.is_some()+ || geometry_generation_is_stale+ || state.last_viewports.get(&cache_key) != Some(&Some((viewport.clone(), owns)))+ {match domain- .set_client_viewport(local_tab_id, ClientViewport::CellGrid { size })+ .set_client_viewport(local_tab_id, viewport.clone()).await{- Ok(viewport) => {+ Ok(response) => {let owns = domain.owns_remote_viewport(local_tab_id) != Some(false);- state.last_viewports.insert(cache_key, Some((size, owns)));+ state+ .last_viewports+ .insert(cache_key.clone(), Some((viewport.clone(), owns)));adopt_local_tab_size(local_tab_id,- local_tab_size(&domain, local_tab_id, size, viewport.canonical_size),+ local_tab_size(&domain, local_tab_id, size, response.canonical_size),);+ if let Some(generation) = recovery_generation {+ if let Err(err) = domain.resync().await {+ forget_native_viewport_geometry(&viewport);+ domain.fail_frontend_recovery(+ FrontendRecoverySlot::Primary,+ local_tab_id,+ generation,+ format!("TUI replacement topology resync failed: {err:#}"),+ );+ state.ui.status = format!("Restoring terminal: {err:#}");+ state.dirty = true;+ return;+ }+ let final_local_tab_id = domain+ .remote_to_local_tab_id(remote_tab_id)+ .unwrap_or(local_tab_id);+ adopt_local_tab_size(final_local_tab_id, response.canonical_size);+ if !domain.acknowledge_frontend_recovery(+ FrontendRecoverySlot::Primary,+ local_tab_id,+ generation,+ ) {+ state.dirty = true;+ return;+ }+ }+ 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;+ }+ }+ } else if owns {+ // The first passive advertisement may have made this TUI B's+ // initial owner. Keep the mask and draw once more so the next+ // request carries the exact pane geometry as Native.+ state.dirty = true;+ }}Err(err) => {+ forget_native_viewport_geometry(&viewport);+ if let Some(generation) = recovery_generation {+ domain.fail_frontend_recovery(+ FrontendRecoverySlot::Primary,+ local_tab_id,+ generation,+ format!("TUI replacement viewport failed: {err:#}"),+ );+ }state.ui.status = format!("Viewport: {err}");state.dirty = true;return;}}}- push_pane_sizes(state, &domain, local_tab_id, screen);- share_view_if_changed(state, &domain, local_tab_id).await;+ share_view_if_changed(state, &domain, local_tab_id, &cache_key).await;}/// Ask every pane on screen whether anything changed.@@ -1432,10 +1654,11 @@ fn poll_panes(state: &TuiState) {const SHARE_VIEW_INTERVAL: Duration = Duration::from_millis(100);/// Whether the coalescing window has closed on a deferred view change.-fn share_view_is_due(state: &TuiState) -> bool {+fn share_view_is_due(state: &TuiState, cache_key: &(String, TabId)) -> bool {state.shared_view_at- .map_or(true, |at| at.elapsed() >= SHARE_VIEW_INTERVAL)+ .get(cache_key)+ .is_none_or(|at| at.elapsed() >= SHARE_VIEW_INTERVAL)}/// Offer what this renderer is looking at, so the other renderers on this tab@@ -1452,9 +1675,10 @@ async fn share_view_if_changed(state: &mut TuiState,domain: &Arc<ClientDomain>,local_tab_id: TabId,+ cache_key: &(String, TabId),) {if domain.owns_remote_viewport(local_tab_id) == Some(false) {- follow_shared_view(state, domain, local_tab_id);+ follow_shared_view(state, domain, local_tab_id, cache_key);return;}let mut scroll = Vec::new();@@ -1477,28 +1701,33 @@ async fn share_view_if_changed(}scroll.sort_by_key(|entry| entry.pane_id);let view = codec::ClientView { scroll };- if state.shared_view.as_ref() == Some(&view) {- state.share_view_pending = false;+ if state.shared_views.get(cache_key) == Some(&view) {+ state.share_view_pending.remove(cache_key);return;}if state.shared_view_at+ .get(cache_key).is_some_and(|at| at.elapsed() < SHARE_VIEW_INTERVAL){// Deferred, not dropped. Skipping outright leaves the follower one// notch behind for good, because the last notch of a flick is exactly// the one that lands inside the window and nothing draws afterwards to// try again.- state.share_view_pending = true;+ state.share_view_pending.insert(cache_key.clone());return;}- state.shared_view_at = Some(Instant::now());- state.share_view_pending = false;+ state+ .shared_view_at+ .insert(cache_key.clone(), Instant::now());+ state.share_view_pending.remove(cache_key);match domain.set_client_view(local_tab_id, view.clone()).await {- Ok(()) => state.shared_view = Some(view),+ Ok(()) => {+ state.shared_views.insert(cache_key.clone(), view);+ }Err(err) => {log::trace!("sharing the view of tab {local_tab_id}: {err:#}");- state.share_view_pending = true;+ state.share_view_pending.insert(cache_key.clone());}}}@@ -1510,14 +1739,19 @@ async fn share_view_if_changed(/// the scrollback should sit. When nobody has offered a view — because the/// owner is a renderer that does not publish one — this leaves the follower/// exactly where it was rather than pulling it somewhere arbitrary.-fn follow_shared_view(state: &mut TuiState, domain: &Arc<ClientDomain>, local_tab_id: TabId) {+fn follow_shared_view(+ state: &mut TuiState,+ domain: &Arc<ClientDomain>,+ local_tab_id: TabId,+ cache_key: &(String, TabId),+) {let Some(remote) = domain.remote_viewport_state(local_tab_id) else {return;};let Some(view) = remote.view else {return;};- if state.followed_view.as_ref() == Some(&view) {+ if state.followed_views.get(cache_key) == Some(&view) {return;}for pane in &state.layout.panes {@@ -1538,50 +1772,10 @@ fn follow_shared_view(state: &mut TuiState, domain: &Arc<ClientDomain>, local_talet offset = offset.min(dims.scrollback_rows.saturating_sub(dims.viewport_rows));state.ui.set_scroll_offset(pane.pane_id, offset);}- state.followed_view = Some(view);+ state.followed_views.insert(cache_key.clone(), view);state.dirty = true;}-/// Tell each remote pane the size this layout actually gave its grid.-///-/// `PaneStack::resize` skips remote mirrors on purpose: only the frontend knows-/// how much of a pane's rectangle went to chrome, so sizing them is its job —-/// and it must report the grid it actually drew, not the rectangle it was-/// given, or every row spent on a pane's own nav bar goes unaccounted for.-///-/// Two guards, both copied from the GUI's `sync_active_mux_tab_pane_sizes`:-/// a renderer that does not own the viewport does not get to set sizes, and a-/// pane that already has the size it is about to be told is left alone. The-/// second is what makes this safe to run on every layout — without it, each-/// call would resize panes the server then answers with a fresh pane tree,-/// which is another layout, which resizes again.-fn push_pane_sizes(- state: &TuiState,- domain: &Arc<ClientDomain>,- local_tab_id: TabId,- screen: ScreenSize,-) {- // `Some(true)`, not "anything but no": until the server has answered, this- // renderer does not know whether it owns the grid, and guessing yes means- // its very first frame resizes panes that another device is using.- if domain.owns_remote_viewport(local_tab_id) != Some(true) {- return;- }- for pane in &state.layout.panes {- let Some(handle) = Mux::get().get_pane(pane.pane_id) else {- continue;- };- let size = terminal_size(pane.rect.width as usize, pane.rect.height as usize, screen);- let dims = handle.get_dimensions();- if dims.cols == size.cols && dims.viewport_rows == size.rows {- continue;- }- if let Err(err) = handle.resize(size) {- log::trace!("pane {} declined {size:?}: {err:#}", pane.pane_id);- }- }-}-/// Which size this renderer's own copy of the tab should be laid out at.////// `canonical_size` is the *server's* tab size, and the server derives it back@@ -1660,20 +1854,34 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {if domain.owns_remote_viewport(local_tab_id) == Some(true) {return Ok(tab);}- let size = state- .last_viewports- .get(&(domain_name.clone(), remote_tab_id))- .and_then(|entry| *entry)- .map(|(size, _)| size)+ let screen = state+ .screen_size.context("viewport is not ready; retry after the terminal redraws")?;+ let handoff = domain+ .remote_access_state()+ .is_some_and(|access| access.mode == codec::FrontendAccessMode::Handoff);+ 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")?+ } else {+ 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")?+ };+ 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, ClientViewport::CellGrid { size })+ .claim_client_viewport(local_tab_id, viewport.clone()).await{Ok(claimed) => claimed,Err(err) => {+ forget_native_viewport_geometry(&viewport);state.takeover_epochs.finish(&domain_name, remote_tab_id, epoch);@@ -1681,18 +1889,19 @@ 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);state.takeover_epochs.finish(&domain_name, remote_tab_id, epoch);anyhow::bail!("the server did not grant viewport ownership");}- adopt_local_tab_size(local_tab_id, claimed.canonical_size);+ adopt_local_tab_size(local_tab_id, reported_size);let resync = domain.resync().await;let final_local_tab_id = domain.remote_to_local_tab_id(remote_tab_id).unwrap_or(local_tab_id);- adopt_local_tab_size(final_local_tab_id, claimed.canonical_size);+ adopt_local_tab_size(final_local_tab_id, reported_size);let final_tab = Mux::get().get_tab(final_local_tab_id).unwrap_or(tab);if let Err(err) = resync {log::warn!(@@ -1703,11 +1912,22 @@ async fn claim_active_viewport(state: &mut TuiState) -> Result<Arc<Tab>> {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)));+ if claimed.access.mode == codec::FrontendAccessMode::Handoff {+ state+ .handoff_geometry_ready+ .insert(cache_key.clone(), claimed.access.generation);+ }for pane in &state.layout.panes {state.ui.set_scroll_offset(pane.pane_id, 0);}- state.shared_view = None;- state.followed_view = None;+ state.shared_views.remove(&cache_key);+ state.shared_view_at.remove(&cache_key);+ state.share_view_pending.remove(&cache_key);+ state.followed_views.remove(&cache_key);Ok(final_tab)}@@ -1730,20 +1950,31 @@ async fn set_active_frontend_access_mode(let (domain_name, domain, tab, remote_tab_id) =state.active_tab().context("no live tab selected")?;let local_tab_id = tab.tab_id();- let size = state- .last_viewports- .get(&(domain_name, remote_tab_id))- .and_then(|entry| *entry)- .map(|(size, _)| size)+ let screen = state+ .screen_size.context("viewport is not ready; retry after the terminal redraws")?;- domain- .set_frontend_access_mode(local_tab_id, mode, ClientViewport::CellGrid { size })+ let area = state.layout.screen;+ let viewport = prepare_active_native_viewport(state, area, screen, false)+ .context("viewport is not ready; retry after the terminal redraws")?;+ let access = domain+ .set_frontend_access_mode(local_tab_id, mode, viewport.clone()).await?;+ let cache_key = (domain_name, remote_tab_id);+ state+ .last_viewports+ .insert(cache_key.clone(), Some((viewport, true)));+ if access.mode == codec::FrontendAccessMode::Handoff {+ state+ .handoff_geometry_ready+ .insert(cache_key.clone(), access.generation);+ }for pane in &state.layout.panes {state.ui.set_scroll_offset(pane.pane_id, 0);}- state.shared_view = None;- state.followed_view = None;+ state.shared_views.remove(&cache_key);+ state.shared_view_at.remove(&cache_key);+ state.share_view_pending.remove(&cache_key);+ state.followed_views.remove(&cache_key);state.clear_selected_viewport_cache();Ok(())}@@ -1941,6 +2172,19 @@ async fn dispatch_action(state: &mut TuiState, action: Action) -> Result<()> {state.last_viewports.retain(|(domain, _), _| domain != &name);+ state+ .handoff_geometry_ready+ .retain(|(domain, _), _| domain != &name);+ state.shared_views.retain(|(domain, _), _| domain != &name);+ state+ .shared_view_at+ .retain(|(domain, _), _| domain != &name);+ state+ .share_view_pending+ .retain(|(domain, _)| domain != &name);+ state+ .followed_views+ .retain(|(domain, _), _| domain != &name);state.ui.mode = AppMode::Terminal;state.ui.status = format!("{name}: disconnected; remote sessions are still running");sync_connection_statuses(state);@@ -2094,7 +2338,7 @@ async fn ensure_selected_thread_live(});state.ui.status = format!("Opening terminal on {domain_name}…");let response = domain- .ensure_thinkterm_thread(preferred_thread_id, spawn_size(state))+ .ensure_thinkterm_thread(preferred_thread_id, materialize_size(state)).await.with_context(|| format!("materializing a Thread on {domain_name}"))?;if domain.state() != DomainState::Attached@@ -2779,6 +3023,16 @@ fn spawn_size(state: &TuiState) -> TerminalSize {}}+fn materialize_size(state: &TuiState) -> TerminalSize {+ TerminalSize {+ rows: state.layout.content.height.max(2) as usize,+ cols: state.layout.content.width.max(2) as usize,+ pixel_width: 0,+ pixel_height: 0,+ dpi: 96,+ }+}+/// Add a terminal to a pane's own stack: same rectangle, one more level-2 tab.////// The size is taken from the pane already sitting there rather than recomputed@@ -4737,6 +4991,49 @@ mod tests {);}+ #[test]+ fn handoff_reveals_each_tab_only_after_its_geometry_generation_is_ready() {+ let access = codec::FrontendAccessState {+ mode: codec::FrontendAccessMode::Handoff,+ owner: None,+ generation: 17,+ };+ assert!(handoff_geometry_is_pending(+ &RemoteFrontendGate::Visible,+ Some(&access),+ Some(true),+ None,+ ));+ assert!(handoff_geometry_is_pending(+ &RemoteFrontendGate::Visible,+ Some(&access),+ Some(true),+ Some(16),+ ));+ assert!(!handoff_geometry_is_pending(+ &RemoteFrontendGate::Visible,+ Some(&access),+ Some(true),+ Some(17),+ ));+ assert!(!handoff_geometry_is_pending(+ &RemoteFrontendGate::Claimable { owner: None },+ Some(&access),+ Some(false),+ None,+ ));+ let collaborative = codec::FrontendAccessState {+ mode: codec::FrontendAccessMode::TmuxLatest,+ ..access+ };+ assert!(!handoff_geometry_is_pending(+ &RemoteFrontendGate::Visible,+ Some(&collaborative),+ Some(true),+ None,+ ));+ }+fn model_for_reorder() -> AppModel {let mut model = AppModel::default();model.apply_snapshot(@@ -5061,10 +5358,12 @@ mod tests {state.last_viewports.insert(key.clone(),Some((- TerminalSize {- rows: 24,- cols: 80,- ..Default::default()+ ClientViewport::CellGrid {+ size: TerminalSize {+ rows: 24,+ cols: 80,+ ..Default::default()+ },},true,)),@@ -5075,6 +5374,31 @@ mod tests {assert_eq!(state.last_viewports.get(&key), Some(&None));}+ #[test]+ fn shared_view_debounce_and_payload_are_scoped_to_each_tab() {+ let model = model_for_reorder();+ let mut state = TuiState::new(+ BTreeMap::new(),+ vec![],+ BTreeMap::new(),+ model,+ String::new(),+ TuiConfig::default(),+ PathBuf::from("/tmp/test-tui.toml"),+ PathBuf::from("/tmp/test-tui.json"),+ );+ let first = ("server".to_string(), 7);+ let second = ("server".to_string(), 8);+ state.shared_view_at.insert(first.clone(), Instant::now());+ state+ .shared_views+ .insert(first.clone(), codec::ClientView::default());++ assert!(!share_view_is_due(&state, &first));+ assert!(share_view_is_due(&state, &second));+ assert!(!state.shared_views.contains_key(&second));+ }+/// A fingertip covers several cells and the touchscreen picks one, so a tap/// meant to focus a pane arrives as a short drag. With copy-on-select on,/// that used to hand the clipboard one stray character on every tap.diff --git a/wezterm-client/src/client.rs b/wezterm-client/src/client.rsindex cccf96dc..d89def3f 100644--- a/wezterm-client/src/client.rs+++ b/wezterm-client/src/client.rs@@ -1526,9 +1526,19 @@ impl Client {).await{- Ok(()) => {- phase.store(ClientConnectionPhase::Ready as u8, Ordering::Release);- log::info!("Reconnected and restored generation {generation}");+ Ok(mark_ready) => {+ if mark_ready {+ phase.store(+ ClientConnectionPhase::Ready as u8,+ Ordering::Release,+ );+ log::info!("Reconnected and restored generation {generation}");+ } else {+ log::info!(+ "Replacement mux topology restored for generation \+ {generation}; waiting for frontend geometry"+ );+ }reattach_ui.close();crate::domain::wake_thinkterm_frontend();}diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rsindex caf5cb1d..c010cec6 100644--- a/wezterm-client/src/domain.rs+++ b/wezterm-client/src/domain.rs@@ -17,10 +17,138 @@ use std::collections::{HashMap, HashSet};use std::sync::{Arc, Mutex};use wezterm_term::TerminalSize;+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]+pub enum FrontendRecoverySlot {+ /// A thin frontend with a single selected terminal, currently the TUI.+ Primary,+ /// A stable native GUI window identity. This is deliberately not a mux+ /// WindowId: the mux id changes when the native window switches Threads.+ Window(u64),+}++#[derive(Clone, Debug)]+struct ReconnectRecoveryTarget {+ slot: FrontendRecoverySlot,+ workspace: String,+ size: TerminalSize,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct ThinkTermFrontendRecoveryTarget {+ pub slot: FrontendRecoverySlot,+ pub window_id: WindowId,+ pub tab_id: TabId,+}++#[derive(Clone, Debug)]+struct FrontendRecoveryBarrier {+ generation: u64,+ pending: HashMap<FrontendRecoverySlot, TabId>,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum FrontendRecoveryAck {+ Ignored,+ Pending,+ Complete,+}++fn acknowledge_recovery_target(+ barrier: &mut Option<FrontendRecoveryBarrier>,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ generation: u64,+ current_generation: u64,+) -> FrontendRecoveryAck {+ let Some(active) = barrier.as_mut() else {+ return FrontendRecoveryAck::Ignored;+ };+ if active.generation != generation+ || generation != current_generation+ || active.pending.get(&slot) != Some(&local_tab_id)+ {+ return FrontendRecoveryAck::Ignored;+ }+ active.pending.remove(&slot);+ if active.pending.is_empty() {+ *barrier = None;+ FrontendRecoveryAck::Complete+ } else {+ FrontendRecoveryAck::Pending+ }+}++#[derive(Default)]+struct ServerReplacementMirrors {+ windows_by_workspace: HashMap<String, WindowId>,+ old_tabs: Vec<TabId>,+}++fn pane_node_workspace(node: &mux::tab::PaneNode) -> Option<&str> {+ match node {+ mux::tab::PaneNode::Empty => None,+ mux::tab::PaneNode::Leaf(entry) => Some(entry.workspace.as_str()),+ mux::tab::PaneNode::Stack(stack) => stack+ .panes+ .get(stack.active)+ .or_else(|| stack.panes.first())+ .map(|entry| entry.workspace.as_str()),+ mux::tab::PaneNode::Split { left, right, .. } => {+ pane_node_workspace(left).or_else(|| pane_node_workspace(right))+ }+ }+}++fn thread_id_for_workspace(tree: &codec::ThinkTermTree, workspace: &str) -> Option<String> {+ tree.projects.iter().find_map(|project| {+ project.threads.iter().find_map(|thread| {+ let thread_workspace = thread+ .materialized_workspace_name+ .as_deref()+ .or(thread.planned_workspace_name.as_deref());+ (thread_workspace == Some(workspace)).then(|| thread.id.clone())+ })+ })+}++fn server_runtime_replaced(ready_server_id: Option<&str>, observed_server_id: &str) -> bool {+ ready_server_id.is_some_and(|ready| ready != observed_server_id)+}++fn active_remote_tabs_by_workspace(state: &codec::ThinkTermSessionState) -> HashMap<String, TabId> {+ let mut active = HashMap::new();+ for project in &state.projects {+ for thread in &project.threads {+ let Some(workspace) = thread+ .materialized_workspace_name+ .as_deref()+ .or(thread.planned_workspace_name.as_deref())+ else {+ continue;+ };+ if let Some(tab) = thread+ .tabs+ .iter()+ .find(|tab| tab.is_active)+ .or_else(|| thread.tabs.first())+ {+ active.insert(workspace.to_string(), tab.tab_id);+ }+ }+ }+ active+}+fn accepts_generation(prior: Option<u64>, incoming: u64) -> bool {prior.is_none_or(|prior| incoming > prior)}+fn consistent_remote_tab_id(ids: impl IntoIterator<Item = TabId>) -> Option<TabId> {+ let mut ids = ids.into_iter();+ let first = ids.next()?;+ ids.all(|id| id == first).then_some(first)+}+fn remote_owner_matches_client(owner: Option<&mux::client::ClientId>,client_id: &mux::client::ClientId,@@ -151,6 +279,11 @@ pub struct ClientInner {/// Latest geometry this renderer actually reported for each remote tab./// Explicit claims copy this geometry into the same PDU as the owner move.reported_viewports: Mutex<HashMap<TabId, codec::ClientViewport>>,+ /// Frontend-owned recovery intents. GUI windows use independent stable+ /// slots; the TUI overwrites its single Primary slot as selection changes.+ /// This keeps every visible GUI Thread while avoiding eager restoration of+ /// every Thread a TUI visited earlier in its lifetime.+ frontend_recovery_intents: Mutex<HashMap<FrontendRecoverySlot, ReconnectRecoveryTarget>>,/// Claims on a tab are coalesced behind one request-scoped async lock. A/// second input rechecks ownership after the first request completes.frontend_claim_locks: Mutex<HashMap<TabId, Arc<futures::lock::Mutex<()>>>>,@@ -173,6 +306,24 @@ pub struct ClientInner {/// A resync arrived while a mutation was in flight; run one when the/// last mutation completes.resync_deferred: std::sync::atomic::AtomicBool,+ /// A replacement mux runtime has installed new topology but one or more+ /// frontend slots have not yet confirmed their final local geometry.+ /// Ordinary viewport RPCs never modify this barrier.+ frontend_recovery_barrier: Mutex<Option<FrontendRecoveryBarrier>>,+ /// The mux runtime whose topology and frontend geometry were last fully+ /// committed. `Client::remote_server_id` changes as soon as version+ /// bootstrap succeeds, which is too early: a later Ensure/ListPanes/+ /// viewport failure must continue to be treated as a replacement runtime+ /// on the next retry.+ ready_server_id: Mutex<Option<String>>,+ /// Recovery intent survives a failed replacement attempt even after the+ /// old remote-id maps have been cleared. It is released only when the+ /// frontend acknowledges geometry for the replacement topology.+ pending_recovery_targets: Mutex<HashMap<FrontendRecoverySlot, ReconnectRecoveryTarget>>,+ /// Stable frontend windows retained across replacement retries. Once the+ /// old remote-id maps are cleared, this is what prevents a failed retry+ /// from materializing duplicate native windows on its next attempt.+ pending_recovery_windows: Mutex<HashMap<String, WindowId>>,}/// RAII scope for a structure-mutating RPC; defers resyncs for its lifetime@@ -322,13 +473,38 @@ impl ClientInner {}fn local_to_remote_tab(&self, local_tab_id: TabId) -> Option<TabId> {- let map = self.remote_to_local_tab.lock().unwrap();- for (remote, local) in map.iter() {- if *local == local_tab_id {- return Some(*remote);+ {+ let map = self.remote_to_local_tab.lock().unwrap();+ for (remote, local) in map.iter() {+ if *local == local_tab_id {+ return Some(*remote);+ }}}- None++ // A replacement runtime installs fresh ClientPanes before the GUI is+ // allowed to publish its recovery viewport. If a concurrent topology+ // sweep dropped only the tab map, the panes still carry an+ // unambiguous, generation-bound remote tab id. Reconstruct that+ // derived index instead of leaving the frontend permanently stuck in+ // Syncing with `tab ... has no remote mapping`.+ let tab = Mux::get().get_tab(local_tab_id)?;+ let remote_server_id = self.client.remote_server_id();+ let remote_tab_id =+ consistent_remote_tab_id(tab.iter_all_panes().into_iter().filter_map(|pane| {+ pane.downcast_ref::<ClientPane>()+ .filter(|pane| {+ pane.domain_id() == self.local_domain_id+ && pane.belongs_to_remote_server(remote_server_id.as_deref())+ })+ .map(ClientPane::remote_tab_id)+ }))?;++ self.record_remote_to_local_tab_mapping(remote_tab_id, local_tab_id);+ log::info!(+ "recovered missing remote tab mapping {remote_tab_id} -> {local_tab_id} from live panes"+ );+ Some(remote_tab_id)}fn local_to_remote_window(&self, local_window_id: WindowId) -> Option<WindowId> {@@ -343,9 +519,22 @@ impl ClientInner {pub fn remote_to_local_pane_id(&self, remote_pane_id: PaneId) -> Option<TabId> {let mut pane_map = self.remote_to_local_pane.lock().unwrap();+ let remote_server_id = self.client.remote_server_id();- if let Some(id) = pane_map.get(&remote_pane_id) {- return Some(*id);+ if let Some(id) = pane_map.get(&remote_pane_id).copied() {+ let mapping_is_current = Mux::get().get_pane(id).is_some_and(|pane| {+ pane.downcast_ref::<ClientPane>().is_some_and(|pane| {+ pane.domain_id() == self.local_domain_id+ && pane.belongs_to_remote_server(remote_server_id.as_deref())+ })+ });+ if mapping_is_current {+ return Some(id);+ }+ log::debug!(+ "discarding stale remote pane mapping {remote_pane_id} -> {id} after mux runtime change"+ );+ pane_map.remove(&remote_pane_id);}let mux = Mux::get();@@ -355,7 +544,9 @@ impl ClientInner {continue;}if let Some(pane) = pane.downcast_ref::<ClientPane>() {- if pane.remote_pane_id() == remote_pane_id {+ if pane.remote_pane_id() == remote_pane_id+ && pane.belongs_to_remote_server(remote_server_id.as_deref())+ {let local_pane_id = pane.pane_id();pane_map.insert(remote_pane_id, local_pane_id);return Some(local_pane_id);@@ -454,6 +645,69 @@ impl ClientInner {self.remote_viewports.lock().unwrap().clear();*self.remote_access.lock().unwrap() = None;self.frontend_claim_locks.lock().unwrap().clear();+ *self.frontend_recovery_barrier.lock().unwrap() = None;+ }++ /// Capture only workspaces for which this frontend actually advertised a+ /// viewport. Every mux client mirrors the server's complete topology, so+ /// using every mirrored window here would eagerly restart background+ /// Threads that this device was not displaying.+ fn reconnect_recovery_targets(&self) -> Vec<ReconnectRecoveryTarget> {+ let mut targets = self+ .frontend_recovery_intents+ .lock()+ .unwrap()+ .values()+ .cloned()+ .collect::<Vec<_>>();+ targets.sort_by_key(|target| target.slot);+ targets+ }++ /// Prepare to bind a fresh mux runtime into the local windows that were+ /// already displaying it. The old tabs stay alive and opaque until the+ /// replacement topology has been installed; they are removed only after+ /// new tabs exist, so the native GUI window is never pruned mid-recovery.+ fn prepare_server_replacement(&self) -> ServerReplacementMirrors {+ let mux = Mux::get();+ let local_windows = self+ .remote_to_local_window+ .lock()+ .unwrap()+ .values()+ .copied()+ .collect::<HashSet<_>>();+ let mut mirrors = ServerReplacementMirrors {+ windows_by_workspace: self.pending_recovery_windows.lock().unwrap().clone(),+ old_tabs: Vec::new(),+ };+ for window_id in local_windows {+ let Some(window) = mux.get_window(window_id) else {+ continue;+ };+ mirrors+ .windows_by_workspace+ .entry(window.get_workspace().to_string())+ .or_insert(window_id);+ }+ // Recompute this from all retained windows so a partial prior attempt+ // is cleaned up together with the original mirror after a successful+ // retry.+ for window_id in mirrors.windows_by_workspace.values().copied() {+ if let Some(window) = mux.get_window(window_id) {+ mirrors+ .old_tabs+ .extend(window.iter().map(|tab| tab.tab_id()));+ }+ }+ *self.pending_recovery_windows.lock().unwrap() = mirrors.windows_by_workspace.clone();++ self.remote_to_local_window.lock().unwrap().clear();+ self.remote_to_local_tab.lock().unwrap().clear();+ self.remote_to_local_pane.lock().unwrap().clear();+ self.remote_to_local_stack.lock().unwrap().clear();+ self.reported_viewports.lock().unwrap().clear();+ mirrors}fn reported_viewports_for_live_tabs(&self) -> Vec<(TabId, codec::ClientViewport)> {@@ -635,6 +889,7 @@ impl ClientInner {local_echo_threshold_ms: Option<u64>,overlay_lag_indicator: bool,) -> Self {+ let ready_server_id = client.remote_server_id();Self {client,local_domain_id,@@ -646,12 +901,17 @@ impl ClientInner {remote_viewports: Mutex::new(HashMap::new()),remote_access: Mutex::new(None),reported_viewports: Mutex::new(HashMap::new()),+ frontend_recovery_intents: Mutex::new(HashMap::new()),frontend_claim_locks: Mutex::new(HashMap::new()),remote_to_local_stack: Mutex::new(HashMap::new()),focused_remote_pane_id: Mutex::new(None),focus_advised_at: Mutex::new(None),mutations_in_flight: std::sync::atomic::AtomicUsize::new(0),resync_deferred: std::sync::atomic::AtomicBool::new(false),+ frontend_recovery_barrier: Mutex::new(None),+ ready_server_id: Mutex::new(ready_server_id),+ pending_recovery_targets: Mutex::new(HashMap::new()),+ pending_recovery_windows: Mutex::new(HashMap::new()),}}}@@ -675,6 +935,98 @@ impl ClientInner {self.resync_deferred.store(true, std::sync::atomic::Ordering::SeqCst);}++ fn begin_frontend_recovery(+ &self,+ generation: u64,+ targets: impl IntoIterator<Item = (FrontendRecoverySlot, TabId)>,+ ) {+ let pending = targets.into_iter().collect::<HashMap<_, _>>();+ *self.frontend_recovery_barrier.lock().unwrap() = Some(FrontendRecoveryBarrier {+ generation,+ pending,+ });+ }++ fn ready_server_id(&self) -> Option<String> {+ self.ready_server_id.lock().unwrap().clone()+ }++ fn mark_server_recovered(&self) {+ *self.ready_server_id.lock().unwrap() = self.client.remote_server_id();+ self.pending_recovery_targets.lock().unwrap().clear();+ self.pending_recovery_windows.lock().unwrap().clear();+ }++ fn recovery_targets(&self) -> Vec<ReconnectRecoveryTarget> {+ let pending = self.pending_recovery_targets.lock().unwrap();+ if pending.is_empty() {+ drop(pending);+ self.reconnect_recovery_targets()+ } else {+ let mut targets = pending.values().cloned().collect::<Vec<_>>();+ targets.sort_by_key(|target| target.slot);+ targets+ }+ }++ fn remember_recovery_targets(&self, targets: &[ReconnectRecoveryTarget]) {+ let mut pending = self.pending_recovery_targets.lock().unwrap();+ if pending.is_empty() {+ pending.extend(targets.iter().cloned().map(|target| (target.slot, target)));+ }+ }++ fn pending_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ ) -> Option<u64> {+ let barrier = self.frontend_recovery_barrier.lock().unwrap();+ let barrier = barrier.as_ref()?;+ (barrier.generation == self.client.connection_generation()+ && barrier.pending.get(&slot) == Some(&local_tab_id))+ .then_some(barrier.generation)+ }++ fn acknowledge_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ generation: u64,+ ) -> bool {+ let ack = {+ let mut barrier = self.frontend_recovery_barrier.lock().unwrap();+ acknowledge_recovery_target(+ &mut barrier,+ slot,+ local_tab_id,+ generation,+ self.client.connection_generation(),+ )+ };+ if ack == FrontendRecoveryAck::Complete {+ self.mark_server_recovered();+ self.client.mark_ready();+ log::info!("frontend geometry restored for mux generation {generation}");+ wake_thinkterm_frontend();+ }+ ack != FrontendRecoveryAck::Ignored+ }++ fn fail_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ generation: u64,+ reason: String,+ ) -> bool {+ if self.pending_frontend_recovery(slot, local_tab_id) != Some(generation) {+ return false;+ }+ self.client.abort_connection_generation(generation, reason);+ true+ }}pub struct ClientDomain {@@ -854,11 +1206,23 @@ pub type ThinkTermConnectSink = fn(domain_name: &str, connection_generation: u64/// executor can run without a fixed polling timer.pub type ThinkTermFrontendWakeSink = fn();+/// Requests one geometry publication after a replacement mux topology has+/// been installed and its recovery barrier is armed. TabAddedToWindow is+/// emitted while the replacement is still being assembled, so a GUI can+/// otherwise publish too early and leave the barrier waiting forever when no+/// later resize or tab switch happens.+pub type ThinkTermFrontendRecoverySink = fn(+ domain_id: DomainId,+ connection_generation: u64,+ recovery_targets: Vec<ThinkTermFrontendRecoveryTarget>,+);+lazy_static::lazy_static! {static ref THINKTERM_TREE_SINK: Mutex<Option<ThinkTermTreeSink>> = Mutex::new(None);static ref THINKTERM_CONNECT_SINK: Mutex<Option<ThinkTermConnectSink>> = Mutex::new(None);static ref THINKTERM_SESSION_SINK: Mutex<Option<ThinkTermSessionSink>> = Mutex::new(None);static ref THINKTERM_FRONTEND_WAKE_SINK: Mutex<Option<ThinkTermFrontendWakeSink>> = Mutex::new(None);+ static ref THINKTERM_FRONTEND_RECOVERY_SINK: Mutex<Option<ThinkTermFrontendRecoverySink>> = Mutex::new(None);}pub fn set_thinkterm_tree_sink(sink: ThinkTermTreeSink) {@@ -877,6 +1241,13 @@ pub fn set_thinkterm_frontend_wake_sink(sink: ThinkTermFrontendWakeSink) {THINKTERM_FRONTEND_WAKE_SINK.lock().unwrap().replace(sink);}+pub fn set_thinkterm_frontend_recovery_sink(sink: ThinkTermFrontendRecoverySink) {+ THINKTERM_FRONTEND_RECOVERY_SINK+ .lock()+ .unwrap()+ .replace(sink);+}+pub(crate) fn wake_thinkterm_frontend() {let sink = *THINKTERM_FRONTEND_WAKE_SINK.lock().unwrap();if let Some(sink) = sink {@@ -884,6 +1255,17 @@ pub(crate) fn wake_thinkterm_frontend() {}}+fn request_thinkterm_frontend_recovery(+ domain_id: DomainId,+ connection_generation: u64,+ recovery_targets: Vec<ThinkTermFrontendRecoveryTarget>,+) {+ let sink = *THINKTERM_FRONTEND_RECOVERY_SINK.lock().unwrap();+ if let Some(sink) = sink {+ sink(domain_id, connection_generation, recovery_targets);+ }+}+pub(crate) fn deliver_thinkterm_tree(domain_name: &str, tree: codec::ThinkTermTree) {let sink = *THINKTERM_TREE_SINK.lock().unwrap();if let Some(sink) = sink {@@ -1012,6 +1394,80 @@ impl ClientDomain {Some(self.inner()?.client.connection_generation())}+ /// Record which terminal this frontend slot is actively presenting. This+ /// is local reconnect metadata only; it is not sent over the wire.+ pub fn set_frontend_recovery_intent(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ viewport: &codec::ClientViewport,+ ) -> anyhow::Result<()> {+ let inner = self+ .inner()+ .ok_or_else(|| anyhow!("domain is not attached"))?;+ inner+ .local_to_remote_tab(local_tab_id)+ .ok_or_else(|| anyhow!("tab {local_tab_id} has no remote mapping"))?;+ let mux = Mux::get();+ let window_id = mux+ .window_containing_tab(local_tab_id)+ .ok_or_else(|| anyhow!("tab {local_tab_id} is not attached to a window"))?;+ let workspace = mux+ .get_window(window_id)+ .map(|window| window.get_workspace().to_string())+ .ok_or_else(|| anyhow!("window {window_id} disappeared"))?;+ inner.frontend_recovery_intents.lock().unwrap().insert(+ slot,+ ReconnectRecoveryTarget {+ slot,+ workspace,+ size: viewport.size(),+ },+ );+ Ok(())+ }++ pub fn clear_frontend_recovery_intent(&self, slot: FrontendRecoverySlot) {+ if let Some(inner) = self.inner() {+ inner+ .frontend_recovery_intents+ .lock()+ .unwrap()+ .remove(&slot);+ }+ }++ pub fn pending_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ ) -> Option<u64> {+ self.inner()?.pending_frontend_recovery(slot, local_tab_id)+ }++ pub fn acknowledge_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ generation: u64,+ ) -> bool {+ self.inner().is_some_and(|inner| {+ inner.acknowledge_frontend_recovery(slot, local_tab_id, generation)+ })+ }++ pub fn fail_frontend_recovery(+ &self,+ slot: FrontendRecoverySlot,+ local_tab_id: TabId,+ generation: u64,+ reason: impl Into<String>,+ ) -> bool {+ self.inner().is_some_and(|inner| {+ inner.fail_frontend_recovery(slot, local_tab_id, generation, reason.into())+ })+ }+pub fn remote_viewport_state(&self, local_tab_id: TabId) -> Option<codec::ClientViewportState> {let inner = self.inner()?;let remote_tab_id = inner.local_to_remote_tab(local_tab_id)?;@@ -1125,18 +1581,22 @@ impl ClientDomain {domain_id: DomainId,connection_generation: u64,ui: ConnectionUI,- ) -> anyhow::Result<()> {+ ) -> anyhow::Result<bool> {let inner = Self::get_client_inner_for_domain(domain_id)?;if inner.client.connection_generation() != connection_generation {bail!("generation {connection_generation} was superseded before reattach began");}+ let prior_server_id = inner.ready_server_id();+ let recovery_targets = inner.recovery_targets();inner.begin_remote_generation();let domain = Mux::get().get_domain(domain_id).ok_or_else(|| anyhow!("domain {domain_id} disappeared during reattach"))?;ui.output_str("Checking server version and restoring client identity\n");- inner.client.verify_version_compat(&ui).await?;+ let server = inner.client.verify_version_compat(&ui).await?;+ let server_replaced =+ server_runtime_replaced(prior_server_id.as_deref(), &server.server_id);if inner.client.connection_generation() != connection_generation {bail!("generation {connection_generation} was superseded during registration");}@@ -1151,9 +1611,6 @@ impl ClientDomain {// same fetch.deliver_thinkterm_connected(domain.domain_name(), connection_generation);- let panes = inner.client.list_panes().await?;- Self::process_pane_list(Arc::clone(&inner), panes, None, true)?;-// Pull the tree exactly as a first attach does. Pushes only carry what// changes from now on, so without this the sidebar would keep showing// whatever it held when the link dropped. Ordinary RPCs remain behind@@ -1161,6 +1618,203 @@ impl ClientDomain {let client = domain.downcast_ref::<ClientDomain>().ok_or_else(|| anyhow!("domain {domain_id} changed type during reattach"))?;+ let tree = inner+ .client+ .get_thinkterm_tree()+ .await+ .with_context(|| {+ format!(+ "fetching the ThinkTerm tree after reconnecting to {}",+ client.config.name()+ )+ })?+ .tree;+ deliver_thinkterm_tree(client.config.name(), tree.clone());++ let mut restored_targets = Vec::new();+ if server_replaced {+ inner.remember_recovery_targets(&recovery_targets);+ log::info!(+ "mux runtime changed from {:?} to {}; restoring {} visible workspaces",+ prior_server_id,+ server.server_id,+ recovery_targets.len()+ );+ let mut used_fallback = false;+ let mut restored_workspaces = HashMap::<String, String>::new();+ for target in &recovery_targets {+ if let Some(restored_workspace) = restored_workspaces.get(&target.workspace) {+ restored_targets.push(ReconnectRecoveryTarget {+ slot: target.slot,+ workspace: restored_workspace.clone(),+ size: target.size,+ });+ continue;+ }+ let preferred_thread_id = thread_id_for_workspace(&tree, &target.workspace);+ if preferred_thread_id.is_none() && used_fallback {+ continue;+ }+ used_fallback |= preferred_thread_id.is_none();+ let response = inner+ .client+ .ensure_thinkterm_thread(codec::EnsureThinkTermThread {+ preferred_thread_id,+ size: target.size,+ })+ .await+ .with_context(|| {+ format!(+ "restoring visible ThinkTerm workspace {} on replacement mux",+ target.workspace+ )+ })?;+ restored_workspaces.insert(target.workspace.clone(), response.workspace.clone());+ restored_targets.push(ReconnectRecoveryTarget {+ slot: target.slot,+ workspace: response.workspace,+ size: target.size,+ });+ }+ }++ let replacement_session = if server_replaced {+ let state = inner+ .client+ .get_thinkterm_session_state()+ .await+ .context("fetching replacement mux topology snapshot")?;+ deliver_thinkterm_session(client.config.name(), connection_generation, state.clone());+ Some(state)+ } else {+ None+ };+ let panes = inner.client.list_panes().await?;+ if server_replaced && !restored_targets.is_empty() {+ let live_workspaces = panes+ .tabs+ .iter()+ .filter_map(pane_node_workspace)+ .collect::<HashSet<_>>();+ for target in &restored_targets {+ if !live_workspaces.contains(target.workspace.as_str()) {+ bail!(+ "replacement mux did not materialize restored workspace {}",+ target.workspace+ );+ }+ }+ }+ let mut replacement = None;+ if server_replaced {+ if restored_targets.is_empty() {+ bail!(+ "replacement mux has no visible frontend workspace to restore for generation {connection_generation}"+ );+ }+ // Do not discard the old id maps until every Ensure and the first+ // authoritative ListPanes have succeeded. A failure before this+ // point must leave enough information for the retry to identify+ // the frontend's selected Thread and current size.+ replacement = Some(inner.prepare_server_replacement());+ }+ Self::process_pane_list(+ Arc::clone(&inner),+ panes,+ None,+ true,+ replacement+ .as_mut()+ .map(|state| &mut state.windows_by_workspace),+ )?;++ if let Some(replacement) = replacement {+ {+ let _activity = mux::activity::Activity::new();+ let mux = Mux::get();+ for tab_id in replacement.old_tabs {+ if mux.get_tab(tab_id).is_some() {+ mux.remove_tab(tab_id);+ }+ }+ }+ Mux::get().prune_dead_windows();+ }++ if server_replaced {+ let active_remote_tabs = replacement_session+ .as_ref()+ .map(active_remote_tabs_by_workspace)+ .unwrap_or_default();+ // The old and replacement tabs briefly coexist in the retained+ // local window. Resolve both the retained local window and its+ // authoritative replacement tab only after the old mirror has+ // been removed. Passing this exact pair to the GUI is important:+ // its cached active tab can still name the removed mirror for one+ // notification turn, and merely asking "is your active tab in this+ // set?" can otherwise miss the only post-barrier geometry request.+ let mux = Mux::get();+ let mut frontend_targets = Vec::new();+ for target in &restored_targets {+ let authoritative_tab = active_remote_tabs+ .get(&target.workspace)+ .and_then(|remote_tab_id| inner.remote_to_local_tab_id(*remote_tab_id));+ let fallback_tab = || {+ mux.iter_windows_in_workspace(&target.workspace)+ .into_iter()+ .filter_map(|window_id| mux.get_window(window_id))+ .flat_map(|window| window.iter().cloned().collect::<Vec<_>>())+ .find(|tab| inner.local_to_remote_tab(tab.tab_id()).is_some())+ .map(|tab| tab.tab_id())+ };+ let Some(local_tab_id) = authoritative_tab.or_else(fallback_tab) else {+ continue;+ };+ let Some(window_id) = mux.window_containing_tab(local_tab_id) else {+ continue;+ };+ let Some(mut window) = mux.get_window_mut(window_id) else {+ continue;+ };+ if window.get_workspace() != target.workspace {+ continue;+ }+ let Some(index) = window.idx_by_id(local_tab_id) else {+ continue;+ };+ window.save_and_then_set_active(index);+ frontend_targets.push(ThinkTermFrontendRecoveryTarget {+ slot: target.slot,+ window_id,+ tab_id: local_tab_id,+ });+ }+ if frontend_targets.is_empty() {+ bail!(+ "replacement mux restored no active frontend tab for generation {connection_generation}"+ );+ }+ frontend_targets+ .sort_unstable_by_key(|target| (target.slot, target.window_id, target.tab_id));+ frontend_targets.dedup();+ let recovery_targets = frontend_targets+ .iter()+ .map(|target| (target.slot, target.tab_id));+ inner.begin_frontend_recovery(connection_generation, recovery_targets);+ if inner.client.connection_generation() != connection_generation {+ bail!("generation {connection_generation} was superseded during topology sync");+ }+ // TabAddedToWindow is emitted while process_pane_list is still+ // assembling the replacement. A fast GUI can therefore publish+ // before begin_frontend_recovery and have that ACK ignored. Make+ // one explicit post-barrier request using the replacement local+ // ids; the generation check in the frontend rejects late work.+ request_thinkterm_frontend_recovery(domain_id, connection_generation, frontend_targets);+ // The TUI uses the ordinary wake hook to break out of its blocking+ // input poll and publish its current CellGrid.+ wake_thinkterm_frontend();+ return Ok(false);+ }// SetClientId deliberately does not restore ownership. Re-advertise// the exact geometry this frontend rendered before the outage so the@@ -1172,7 +1826,7 @@ impl ClientDomain {.client.set_client_viewport(codec::SetClientViewport {tab_id: remote_tab_id,- viewport,+ viewport: viewport.clone(),}).await.with_context(|| {@@ -1189,16 +1843,11 @@ impl ClientDomain {);}- client.fetch_thinkterm_tree().await.with_context(|| {- format!(- "fetching the ThinkTerm tree after reconnecting to {}",- client.config.name()- )- })?;if inner.client.connection_generation() != connection_generation {bail!("generation {connection_generation} was superseded during topology sync");}- Ok(())+ inner.mark_server_recovered();+ Ok(true)}pub async fn resync(&self) -> anyhow::Result<()> {@@ -1218,7 +1867,7 @@ impl ClientDomain {inner.defer_resync();return Ok(());}- Self::process_pane_list(inner, panes, None, false)?;+ Self::process_pane_list(inner, panes, None, false, None)?;}Ok(())}@@ -1458,6 +2107,7 @@ impl ClientDomain {panes: ListPanesResponse,mut primary_window_id: Option<WindowId>,resend_palette: bool,+ mut replacement_windows: Option<&mut HashMap<String, WindowId>>,) -> anyhow::Result<()> {let mux = Mux::get();// A native/mux window can disappear while an attach or structural RPC@@ -1644,6 +2294,27 @@ impl ClientDomain {.remove(&remote_window_id);}+ if let (Some(workspace_name), Some(replacements)) =+ (workspace.as_ref(), replacement_windows.as_deref_mut())+ {+ if let Some(local_window_id) = replacements.remove(workspace_name) {+ if mux.get_window(local_window_id).is_some() {+ log::info!(+ "rebinding fresh remote window {} into local window {} for {}",+ remote_window_id,+ local_window_id,+ workspace_name+ );+ inner.record_remote_to_local_window_mapping(+ remote_window_id,+ local_window_id,+ );+ mux.add_tab_to_window(&tab, local_window_id)?;+ continue;+ }+ }+ }+if let Some(local_window_id) = primary_window_id {// Adopt the remote window into the local primary window// only when the workspaces agree. Adopting on the@@ -1771,7 +2442,7 @@ impl ClientDomain {guard.replace(Arc::clone(&inner));}- Self::process_pane_list(inner, panes, primary_window_id, false)?;+ Self::process_pane_list(inner, panes, primary_window_id, false, None)?;Ok(())}@@ -1780,10 +2451,14 @@ impl ClientDomain {#[cfg(test)]mod tests {use super::{- accepts_generation, owns_remote_viewport_from_states, remote_frontend_gate_from_state,- remote_move_pane_id, RemoteFrontendGate,+ accepts_generation, acknowledge_recovery_target, active_remote_tabs_by_workspace,+ consistent_remote_tab_id, owns_remote_viewport_from_states,+ remote_frontend_gate_from_state, remote_move_pane_id, server_runtime_replaced,+ thread_id_for_workspace, FrontendRecoveryAck, FrontendRecoveryBarrier,+ FrontendRecoverySlot, RemoteFrontendGate,};use crate::client::ClientConnectionPhase;+ use std::collections::HashMap;fn client_id(hostname: &str, id: usize) -> mux::client::ClientId {mux::client::ClientId {@@ -1976,6 +2651,124 @@ mod tests {fn remote_move_rejects_duplicate_local_mirrors() {assert!(remote_move_pane_id(41, 7, 42, 7, 3, 3).is_err());}++ #[test]+ fn replacement_is_compared_with_the_last_fully_recovered_runtime() {+ assert!(!server_runtime_replaced(None, "server-b"));+ assert!(!server_runtime_replaced(Some("server-b"), "server-b"));+ assert!(server_runtime_replaced(Some("server-a"), "server-b"));+ // A failed recovery must keep comparing against server-a on its next+ // attempt even though the transport has already observed server-b.+ assert!(server_runtime_replaced(Some("server-a"), "server-b"));+ }++ #[test]+ fn recovery_resolves_materialized_then_planned_thread_workspaces() {+ let tree = codec::ThinkTermTree {+ projects: vec![codec::TtProject {+ id: "project".to_string(),+ threads: vec![+ codec::TtThread {+ id: "materialized".to_string(),+ planned_workspace_name: Some("planned-old".to_string()),+ materialized_workspace_name: Some("live-workspace".to_string()),+ ..Default::default()+ },+ codec::TtThread {+ id: "planned".to_string(),+ planned_workspace_name: Some("planned-workspace".to_string()),+ ..Default::default()+ },+ ],+ ..Default::default()+ }],+ ..Default::default()+ };+ assert_eq!(+ thread_id_for_workspace(&tree, "live-workspace").as_deref(),+ Some("materialized")+ );+ assert_eq!(+ thread_id_for_workspace(&tree, "planned-workspace").as_deref(),+ Some("planned")+ );+ assert_eq!(thread_id_for_workspace(&tree, "missing"), None);+ }++ #[test]+ fn recovery_uses_the_authoritative_active_top_level_tab() {+ let state = codec::ThinkTermSessionState {+ projects: vec![codec::ThinkTermSessionProject {+ threads: vec![codec::ThinkTermSessionThread {+ materialized_workspace_name: Some("thread-workspace".to_string()),+ tabs: vec![+ codec::ThinkTermSessionTab {+ tab_id: 10,+ is_active: false,+ ..Default::default()+ },+ codec::ThinkTermSessionTab {+ tab_id: 11,+ is_active: true,+ ..Default::default()+ },+ ],+ ..Default::default()+ }],+ ..Default::default()+ }],+ ..Default::default()+ };+ assert_eq!(+ active_remote_tabs_by_workspace(&state).get("thread-workspace"),+ Some(&11)+ );+ }++ #[test]+ fn missing_tab_mapping_is_recoverable_only_from_consistent_live_panes() {+ assert_eq!(consistent_remote_tab_id([11, 11, 11]), Some(11));+ assert_eq!(consistent_remote_tab_id([]), None);+ assert_eq!(consistent_remote_tab_id([11, 12]), None);+ }++ #[test]+ fn replacement_barrier_waits_for_every_frontend_slot() {+ let mut barrier = Some(FrontendRecoveryBarrier {+ generation: 9,+ pending: HashMap::from([+ (FrontendRecoverySlot::Window(1), 41),+ (FrontendRecoverySlot::Window(2), 42),+ ]),+ });+ assert_eq!(+ acknowledge_recovery_target(&mut barrier, FrontendRecoverySlot::Window(1), 41, 9, 9,),+ FrontendRecoveryAck::Pending+ );+ assert!(barrier.is_some());+ assert_eq!(+ acknowledge_recovery_target(&mut barrier, FrontendRecoverySlot::Window(2), 42, 9, 9,),+ FrontendRecoveryAck::Complete+ );+ assert!(barrier.is_none());+ }++ #[test]+ fn replacement_barrier_rejects_stale_generation_and_wrong_tab() {+ let mut barrier = Some(FrontendRecoveryBarrier {+ generation: 9,+ pending: HashMap::from([(FrontendRecoverySlot::Primary, 41)]),+ });+ assert_eq!(+ acknowledge_recovery_target(&mut barrier, FrontendRecoverySlot::Primary, 42, 9, 9,),+ FrontendRecoveryAck::Ignored+ );+ assert_eq!(+ acknowledge_recovery_target(&mut barrier, FrontendRecoverySlot::Primary, 41, 8, 9,),+ FrontendRecoveryAck::Ignored+ );+ assert!(barrier.is_some());+ }}#[async_trait(?Send)]diff --git a/wezterm-client/src/pane/clientpane.rs b/wezterm-client/src/pane/clientpane.rsindex 27e456f7..20858f39 100644--- a/wezterm-client/src/pane/clientpane.rs+++ b/wezterm-client/src/pane/clientpane.rs@@ -175,8 +175,19 @@ impl PaletteDelivery {}}+fn remote_server_identity_matches(created: Option<&str>, current: Option<&str>) -> bool {+ created == current+}+pub struct ClientPane {client: Arc<ClientInner>,+ /// The mux runtime that allocated `remote_pane_id`.+ ///+ /// Pane ids are process-local and restart from small values when a mux+ /// server is replaced. Keeping the allocating runtime here prevents a+ /// replacement resync from mistaking a disconnected, same-numbered pane+ /// for the fresh server's pane.+ remote_server_id: Option<String>,local_pane_id: PaneId,pub remote_pane_id: PaneId,remote_tab_id: Arc<AtomicUsize>,@@ -364,6 +375,7 @@ impl ClientPane {Self {client: Arc::clone(client),+ remote_server_id: client.client.remote_server_id(),mouse,remote_pane_id,local_pane_id,@@ -529,6 +541,10 @@ impl ClientPane {Ok(())}+ pub(crate) fn belongs_to_remote_server(&self, server_id: Option<&str>) -> bool {+ remote_server_identity_matches(self.remote_server_id.as_deref(), server_id)+ }+pub fn remote_pane_id(&self) -> PaneId {self.remote_pane_id}@@ -1210,6 +1226,22 @@ mod test {}}+ #[test]+ fn remote_pane_ids_are_reusable_only_within_the_same_mux_runtime() {+ assert!(remote_server_identity_matches(+ Some("devbox:100:runtime-a"),+ Some("devbox:100:runtime-a")+ ));+ assert!(!remote_server_identity_matches(+ Some("devbox:100:runtime-a"),+ Some("devbox:200:runtime-b")+ ));+ assert!(!remote_server_identity_matches(+ None,+ Some("devbox:200:runtime-b")+ ));+ }+#[test]fn resize_decision_separates_local_convergence_from_rpc() {let target = size(120, 40, 96);diff --git a/wezterm-gui/src/frontend.rs b/wezterm-gui/src/frontend.rsindex 12163efd..299373a2 100644--- a/wezterm-gui/src/frontend.rs+++ b/wezterm-gui/src/frontend.rs@@ -7,6 +7,8 @@ use anyhow::{anyhow, Context, Error};use config::keyassignment::{KeyAssignment, SpawnCommand, SpawnTabDomain};use config::{ConfigSubscription, NotificationHandling};use mux::client::ClientId;+use mux::domain::DomainId;+use mux::tab::TabId;use mux::window::WindowId as MuxWindowId;use mux::{Mux, MuxNotification};use promise::{Future, Promise};@@ -14,6 +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_term::{Alert, ClipboardSelection};use wezterm_toast_notification::*;@@ -21,6 +24,110 @@ fn should_spawn_reconciled_gui_window(is_domain_owned: bool, workspace: &str) ->!is_domain_owned || crate::workspace_threads::is_thread_workspace_name(workspace)}+fn frontend_recovery_tab(+ current_generation: Option<u64>,+ requested_generation: u64,+ mux_window_id: MuxWindowId,+ slot: wezterm_client::domain::FrontendRecoverySlot,+ recovery_targets: &[ThinkTermFrontendRecoveryTarget],+) -> Option<TabId> {+ if current_generation != Some(requested_generation) {+ return None;+ }+ recovery_targets+ .iter()+ .find(|target| target.window_id == mux_window_id && target.slot == slot)+ .map(|target| target.tab_id)+}++/// Run exactly once after the client has installed a replacement mux+/// topology and armed its frontend recovery barrier. The normal+/// TabAddedToWindow notification is too early to serve as that barrier's+/// trigger: it is emitted while the replacement is still being assembled.+pub fn request_thinkterm_frontend_recovery(+ domain_id: DomainId,+ connection_generation: u64,+ recovery_targets: Vec<ThinkTermFrontendRecoveryTarget>,+) {+ promise::spawn::spawn_into_main_thread(async move {+ let Some(frontend) = try_front_end() else {+ return;+ };++ // Address each retained native window explicitly. A missing window is+ // 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 {+ if let Some(domain) = Mux::get().get_domain(domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.fail_frontend_recovery(+ target.slot,+ target.tab_id,+ connection_generation,+ format!(+ "GUI window {} disappeared during mux recovery",+ target.window_id+ ),+ );+ }+ }+ continue;+ };+ gui_window+ .window+ .notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ let mux = Mux::get();+ let current_generation = mux.get_domain(domain_id).and_then(|domain| {+ domain+ .downcast_ref::<ClientDomain>()+ .and_then(ClientDomain::connection_generation)+ });+ 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 {+ if !term_window.sync_replacement_frontend_geometry(+ tab_id,+ target.slot,+ connection_generation,+ ) {+ log::warn!(+ "cannot restore GUI frontend geometry for mux window {} tab {}",+ term_window.mux_window_id,+ tab_id+ );+ 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,+ "GUI recovery target could not start geometry sync",+ );+ }+ }+ }+ } else if let Some(domain) = mux.get_domain(domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.fail_frontend_recovery(+ target.slot,+ target.tab_id,+ connection_generation,+ "GUI recovery target no longer matches its native window",+ );+ }+ }+ })));+ }+ })+ .detach();+}+pub struct GuiFrontEnd {connection: Rc<Connection>,// Depth counter: > 0 means at least one window is mid-switch (materializing@@ -833,7 +940,8 @@ pub fn try_new() -> Result<Rc<GuiFrontEnd>, Error> {#[cfg(test)]mod tests {- use super::should_spawn_reconciled_gui_window;+ use super::{frontend_recovery_tab, should_spawn_reconciled_gui_window};+ use wezterm_client::domain::{FrontendRecoverySlot, ThinkTermFrontendRecoveryTarget};#[test]fn reconcile_keeps_local_windows_visible() {@@ -868,4 +976,70 @@ mod tests {"thinkterm:muxdomain-host::space::space-1:thread-2:remote-default"));}++ #[test]+ fn replacement_recovery_targets_the_retained_window_in_the_current_generation() {+ let recovery_targets = [+ ThinkTermFrontendRecoveryTarget {+ slot: FrontendRecoverySlot::Window(70),+ window_id: 7,+ tab_id: 41,+ },+ ThinkTermFrontendRecoveryTarget {+ slot: FrontendRecoverySlot::Window(80),+ window_id: 8,+ tab_id: 42,+ },+ ];+ assert_eq!(+ frontend_recovery_tab(+ Some(7),+ 7,+ 8,+ FrontendRecoverySlot::Window(80),+ &recovery_targets,+ ),+ Some(42)+ );+ assert_eq!(+ 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,+ ),+ None+ );+ assert_eq!(+ frontend_recovery_tab(+ Some(7),+ 7,+ 8,+ FrontendRecoverySlot::Window(70),+ &recovery_targets,+ ),+ None+ );+ }}diff --git a/wezterm-gui/src/main.rs b/wezterm-gui/src/main.rsindex 2c0cfdc5..0799d730 100644--- a/wezterm-gui/src/main.rs+++ b/wezterm-gui/src/main.rs@@ -425,6 +425,94 @@ pub(crate) fn connect_domain_from_ssh_host(name: &str) -> anyhow::Result<Arc<dynOk(domain)}+async fn current_gui_terminal_size(+ mux_window_id: mux::window::WindowId,+ fallback: wezterm_term::TerminalSize,+) -> wezterm_term::TerminalSize {+ let Some(gui_window) = crate::frontend::front_end().gui_window_for_mux_window(mux_window_id)+ else {+ return fallback;+ };+ let (tx, rx) = smol::channel::bounded(1);+ gui_window+ .window+ .notify(crate::termwindow::TermWindowNotif::GetTerminalSize(tx));+ rx.recv().await.unwrap_or(fallback)+}++async fn adopt_materialized_workspace_window(+ source_window_id: mux::window::WindowId,+ workspace: &str,+ domain_id: mux::domain::DomainId,+) -> anyhow::Result<()> {+ let mux = Mux::get();+ if mux.get_window(source_window_id).is_some_and(|window| {+ window.get_workspace() == workspace+ && window.iter().any(|tab| {+ tab.iter_all_panes()+ .iter()+ .any(|pane| pane.domain_id() == domain_id)+ })+ }) {+ // Initial attach may already have folded the restored remote window+ // into the claimed native window. Do not jump to a second mux window+ // in the same workspace and kill this one: that would turn local GUI+ // adoption into a remote pane close when a workspace temporarily has+ // multiple mux windows.+ return Ok(());+ }+ let Some(target_window_id) =+ mux.iter_windows_in_workspace(workspace)+ .into_iter()+ .find(|window_id| {+ *window_id != source_window_id+ && mux.get_window(*window_id).is_some_and(|window| {+ window.iter().any(|tab| {+ tab.iter_all_panes()+ .iter()+ .any(|pane| pane.domain_id() == domain_id)+ })+ })+ })+ else {+ anyhow::bail!("restored workspace {workspace} has no live window for domain {domain_id}");+ };+ let Some(gui_window) = crate::frontend::front_end().gui_window_for_mux_window(source_window_id)+ else {+ return Ok(());+ };+ crate::frontend::front_end().set_switching_workspaces(true);+ let (tx, rx) = smol::channel::bounded(1);+ gui_window+ .window+ .notify(crate::termwindow::TermWindowNotif::Apply(Box::new(+ move |term_window| {+ let switched = if term_window.mux_window_id == source_window_id {+ term_window.switch_to_mux_window(target_window_id);+ term_window.mux_window_id == target_window_id+ } else {+ false+ };+ let _ = tx.try_send(switched);+ },+ )));+ let switched = rx+ .recv()+ .await+ .context("waiting for GUI to adopt restored mux window");+ crate::frontend::front_end().set_switching_workspaces(false);+ let switched = switched?;+ if !switched+ || crate::frontend::front_end()+ .gui_window_for_mux_window(target_window_id)+ .is_none()+ {+ anyhow::bail!("GUI did not confirm adoption of restored mux window {target_window_id}");+ }+ mux.kill_window(source_window_id);+ Ok(())+}+pub(crate) async fn connect_domain_into_space(cmd: Option<CommandBuilder>,domain: Arc<dyn Domain>,@@ -571,22 +659,13 @@ pub(crate) async fn connect_domain_into_space(let settled_workspace = workspace_threads::ensure_mux_thread_workspace(&settled);workspace_threads::reconcile_remote_subtree(&domain_name);- // Spawn the thread's first shell when its workspace has no panes on the- // server. Keying this off "does the domain have any panes at all" left- // the connect window empty whenever the server had unrelated windows- // (its own startup window, other threads) — the old blind window- // adoption papered over that by grabbing one of them as a tab.- let thread_workspace_filter = Some(thread_workspace.clone());- if settled_workspace != thread_workspace {- // The invented Space is gone from the store, so the window created- // above is being re-homed onto one the server really has, and that- // path materializes the destination thread itself. Spawning here- // would strand a shell in a workspace no row on the server names.- log::info!(- "{domain_name} has its own Spaces; leaving {settled_workspace} \- to the re-home instead of spawning into {thread_workspace}"- );- } else if !have_panes_in_domain_and_ws(&domain, &thread_workspace_filter) {+ // Ordinary GUI startup always enters through EnsureThinkTermThread. It is+ // idempotent when the workspace is already live and is the only path that+ // can restore a saved multi-tab/split layout after a mux replacement.+ // In particular, do not let an unrelated server startup shell or an early+ // primary-window fold suppress recovery. An explicit custom command keeps+ // the traditional direct-spawn semantics below.+ if cmd.is_none() {let _config_subscription = config::subscribe_to_config_reload(move || {promise::spawn::spawn_into_main_thread(async move {if let Err(err) = update_mux_domains(&config::configuration()) {@@ -598,14 +677,42 @@ pub(crate) async fn connect_domain_into_space(});let dpi = config.dpi.unwrap_or_else(|| ::window::default_dpi());- let _tab = domain- .spawn(- config.initial_size(dpi as u32, Some(cell_pixel_dims(&config, dpi)?)),- cmd,- None,- window_id,- )+ let fallback_size = config.initial_size(dpi as u32, Some(cell_pixel_dims(&config, dpi)?));+ let size = current_gui_terminal_size(window_id, fallback_size).await;+ let client = domain+ .downcast_ref::<ClientDomain>()+ .ok_or_else(|| anyhow!("{domain_name} is not a multiplexing client domain"))?;+ crate::frontend::front_end().set_switching_workspaces(true);+ let ensured = client+ .ensure_thinkterm_thread(Some(settled.thread_id.clone()), size)+ .await;+ crate::frontend::front_end().set_switching_workspaces(false);+ let response = ensured.context("restore remote ThinkTerm landing layout")?;+ if response.workspace != settled_workspace {+ anyhow::bail!(+ "remote restored workspace {}, expected {}",+ response.workspace,+ settled_workspace+ );+ }+ adopt_materialized_workspace_window(window_id, &response.workspace, domain.domain_id()).await?;+ } else {+ let thread_workspace_filter = Some(thread_workspace.clone());+ if !have_panes_in_domain_and_ws(&domain, &thread_workspace_filter) {+ let _config_subscription = config::subscribe_to_config_reload(move || {+ promise::spawn::spawn_into_main_thread(async move {+ if let Err(err) = update_mux_domains(&config::configuration()) {+ log::error!("Error updating mux domains: {:#}", err);+ }+ })+ .detach();+ true+ });+ let dpi = config.dpi.unwrap_or_else(|| ::window::default_dpi());+ let size = config.initial_size(dpi as u32, Some(cell_pixel_dims(&config, dpi)?));+ let _tab = domain.spawn(size, cmd, None, window_id).await?;+ }}drop(connect_activity);trigger_and_log_gui_attached(MuxDomain(domain.domain_id())).await;@@ -1039,6 +1146,9 @@ fn run_terminal_gui(opts: StartCommand, default_domain_name: Option<String>) ->wezterm_client::domain::set_thinkterm_connect_sink(|domain_name, _connection_generation| {crate::workspace_threads::note_remote_connected(domain_name);});+ wezterm_client::domain::set_thinkterm_frontend_recovery_sink(+ crate::frontend::request_thinkterm_frontend_recovery,+ );let config = config::configuration();let need_builder = !opts.prog.is_empty() || opts.cwd.is_some();diff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rsindex 8ad52a8e..6f6ee81f 100644--- a/wezterm-gui/src/termwindow/mod.rs+++ b/wezterm-gui/src/termwindow/mod.rs@@ -68,7 +68,7 @@ use std::time::{Duration, Instant};use termwiz::hyperlink::Hyperlink;use termwiz::image::ImageData;use termwiz::surface::SequenceNo;-use wezterm_client::domain::ClientDomain;+use wezterm_client::domain::{ClientDomain, FrontendRecoverySlot};use wezterm_dynamic::Value;use wezterm_font::FontConfiguration;use wezterm_term::color::{ColorAttribute, ColorPalette};@@ -283,6 +283,7 @@ pub enum TermWindowNotif {SetLeftStatus(String),SetRightStatus(String),GetDimensions(Sender<(Dimensions, WindowState)>),+ GetTerminalSize(Sender<TerminalSize>),GetSelectionForPane {pane_id: PaneId,tx: Sender<String>,@@ -1302,6 +1303,14 @@ pub(crate) struct FrontendGeometryConfirmation {pub(crate) ready_since: Option<Instant>,}+#[derive(Debug, Clone, Copy)]+pub(crate) struct FrontendRecoveryGeometry {+ pub(crate) epoch: u64,+ pub(crate) domain_id: DomainId,+ pub(crate) slot: FrontendRecoverySlot,+ pub(crate) generation: u64,+}+pub struct TermWindow {pub window: Option<Window>,pub config: ConfigHandle,@@ -1326,6 +1335,9 @@ pub struct TermWindow {/// redraw has reached this renderer. Keep its expected pane snapshots here/// and reveal only after every visible row has been refreshed and stable.frontend_geometry_confirmations: HashMap<TabId, FrontendGeometryConfirmation>,+ /// Replacement-mux recovery is completed only after the matching geometry+ /// epoch reaches the normal local render-surface confirmation point.+ frontend_recovery_geometry: HashMap<TabId, FrontendRecoveryGeometry>,frontend_geometry_resync_after_epoch: HashSet<TabId>,next_frontend_geometry_epoch: u64,frontend_viewport_report_pending: Arc<AtomicBool>,@@ -2069,6 +2081,7 @@ impl TermWindow {let myself = Self {frontend_geometry_phases: HashMap::new(),frontend_geometry_confirmations: HashMap::new(),+ frontend_recovery_geometry: HashMap::new(),frontend_geometry_resync_after_epoch: HashSet::new(),next_frontend_geometry_epoch: 1,frontend_viewport_report_pending: Arc::new(AtomicBool::new(false)),@@ -2495,6 +2508,7 @@ impl TermWindow {match event {WindowEvent::Destroyed => {self.flush_right_sidebar_note_blocking();+ self.clear_gui_recovery_intent();// Ensure that we cancel any overlays we had running, so// that the mux can empty out, otherwise the mux keeps// the TermWindow alive via the frontend even though@@ -2884,6 +2898,11 @@ impl TermWindow {.map_err(chan_err).context("send GetDimensions response")?;}+ TermWindowNotif::GetTerminalSize(tx) => {+ tx.try_send(self.terminal_size)+ .map_err(chan_err)+ .context("send GetTerminalSize response")?;+ }TermWindowNotif::GetEffectiveConfig(tx) => {tx.try_send(self.config.clone()).map_err(chan_err)@@ -4080,7 +4099,13 @@ impl TermWindow {self.load_os_parameters();self.apply_scale_change(&dimensions, self.fonts.get_font_scale());self.apply_dimensions(&dimensions, None, &window);- self.apply_workspace_thread_font_scales();+ // Config reload may also restore a persisted per-pane font scale.+ // That changes the pane's rows/cols even when the window's overall+ // TerminalSize is unchanged, so publish a complete viewport rather+ // than limiting the update to the local render surface.+ if self.stage_workspace_thread_font_scales() {+ self.sync_active_tab_geometry_now();+ }window.config_did_change(&config);window.invalidate();}@@ -7319,6 +7344,7 @@ impl Drop for TermWindow {// from leaving its Space permanently marked as occupied.crate::workspace_threads::release_window_space(self.space_owner_id);crate::input_diagnostics::remove_gauges_for_source(self.space_owner_id);+ self.clear_gui_recovery_intent();gpu_debug(format!("drop main_window backend={} size={}x{} dpi={}",if self.webgpu.is_some() {diff --git a/wezterm-gui/src/termwindow/mouseevent.rs b/wezterm-gui/src/termwindow/mouseevent.rsindex db8f328f..a5b60997 100644--- a/wezterm-gui/src/termwindow/mouseevent.rs+++ b/wezterm-gui/src/termwindow/mouseevent.rs@@ -5126,10 +5126,7 @@ impl super::TermWindow {} else {(None, None)};- let size = self.config.initial_size(- self.dimensions.dpi as u32,- crate::cell_pixel_dims(&self.config, self.dimensions.dpi as f64).ok(),- );+ let size = self.terminal_size;let term_config: Arc<dyn wezterm_term::TerminalConfiguration> =Arc::new(TermConfig::with_config(self.config.clone()));let window = self.window.clone();@@ -5471,11 +5468,7 @@ impl super::TermWindow {)};let layout = crate::workspace_threads::thread_layout(&plan.thread_id);- let dpi = self.dimensions.dpi as u32;- let size = self.config.initial_size(- dpi,- crate::cell_pixel_dims(&self.config, self.dimensions.dpi as f64).ok(),- );+ let size = self.terminal_size;let term_config: Arc<dyn wezterm_term::TerminalConfiguration> =Arc::new(TermConfig::with_config(self.config.clone()));// Suppress the additive reconcile while we materialize the target@@ -5711,10 +5704,7 @@ impl super::TermWindow {let workspace_name = plan.workspace_name.clone();let layout = crate::workspace_threads::thread_layout(&plan.thread_id);- let size = self.config.initial_size(- self.dimensions.dpi as u32,- crate::cell_pixel_dims(&self.config, self.dimensions.dpi as f64).ok(),- );+ let size = self.terminal_size;let term_config: Arc<dyn wezterm_term::TerminalConfiguration> =Arc::new(TermConfig::with_config(self.config.clone()));diff --git a/wezterm-gui/src/termwindow/resize.rs b/wezterm-gui/src/termwindow/resize.rsindex 9f00057d..b1b2d77c 100644--- a/wezterm-gui/src/termwindow/resize.rs+++ b/wezterm-gui/src/termwindow/resize.rs@@ -12,7 +12,7 @@ use std::collections::HashMap;use std::rc::Rc;use std::sync::Arc;use std::time::Duration;-use wezterm_client::domain::{ClientDomain, RemoteFrontendGate};+use wezterm_client::domain::{ClientDomain, FrontendRecoverySlot, RemoteFrontendGate};use wezterm_client::pane::ClientPane;use wezterm_font::FontConfiguration;use wezterm_term::TerminalSize;@@ -69,6 +69,43 @@ pub enum ScaleChange {}impl super::TermWindow {+ pub(crate) fn frontend_recovery_slot(&self) -> FrontendRecoverySlot {+ FrontendRecoverySlot::Window(self.space_owner_id)+ }++ fn remember_gui_recovery_intent(+ &self,+ domain: &ClientDomain,+ tab_id: mux::tab::TabId,+ viewport: &codec::ClientViewport,+ ) {+ let slot = self.frontend_recovery_slot();+ let mux = Mux::get();+ for candidate in mux.iter_domains() {+ let Some(client) = candidate.downcast_ref::<ClientDomain>() else {+ continue;+ };+ if candidate.domain_id() != domain.domain_id() {+ client.clear_frontend_recovery_intent(slot);+ }+ }+ if let Err(err) = domain.set_frontend_recovery_intent(slot, tab_id, viewport) {+ log::trace!("recording GUI frontend recovery intent: {err:#}");+ }+ }++ pub(crate) fn clear_gui_recovery_intent(&self) {+ let slot = self.frontend_recovery_slot();+ let Some(mux) = Mux::try_get() else {+ return;+ };+ for candidate in mux.iter_domains() {+ if let Some(client) = candidate.downcast_ref::<ClientDomain>() {+ client.clear_frontend_recovery_intent(slot);+ }+ }+ }+pub(crate) fn active_frontend_access_state(&self) -> Option<mux::FrontendAccessState> {let pane = Mux::get().get_active_tab_for_window(self.mux_window_id)?@@ -211,6 +248,28 @@ impl super::TermWindow {return;}+ if !succeeded {+ if let Some(recovery) = self.frontend_recovery_geometry.remove(&tab_id) {+ if recovery.epoch == epoch {+ if let Some(domain) = Mux::get().get_domain(recovery.domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.fail_frontend_recovery(+ recovery.slot,+ tab_id,+ recovery.generation,+ format!(+ "GUI geometry recovery failed for tab {tab_id} generation {}",+ recovery.generation+ ),+ );+ }+ }+ } else {+ self.frontend_recovery_geometry.insert(tab_id, recovery);+ }+ }+ }+let mux = Mux::get();for (pane_id, size) in adopted {let Some(pane) = mux.get_pane(*pane_id) else {@@ -262,6 +321,21 @@ impl super::TermWindow {let keep_follow_up_obscured = phase.obscures_terminal();self.frontend_geometry_confirmations.remove(&tab_id);self.frontend_geometry_phases.remove(&tab_id);+ if let Some(recovery) = self.frontend_recovery_geometry.remove(&tab_id) {+ if recovery.epoch == epoch {+ if let Some(domain) = Mux::get().get_domain(recovery.domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.acknowledge_frontend_recovery(+ recovery.slot,+ tab_id,+ recovery.generation,+ );+ }+ }+ } else {+ self.frontend_recovery_geometry.insert(tab_id, recovery);+ }+ }let needs_follow_up = self.frontend_geometry_resync_after_epoch.remove(&tab_id);if needs_follow_up && self.active_tab_is(tab_id) {// Starting the follow-up synchronously keeps the tab opaque: the@@ -500,6 +574,9 @@ impl super::TermWindow {self.invalidate_window();return;};+ if let Some(client_domain) = domain.downcast_ref::<ClientDomain>() {+ self.remember_gui_recovery_intent(client_domain, tab_id, &viewport);+ }let Some(window) = self.window.as_ref().cloned() else {self.frontend_geometry_phases.remove(&tab_id);return;@@ -724,6 +801,141 @@ impl super::TermWindow {/// events (activation, tab creation, split completion and divider release)/// use this instead of the window-resize debounce so the first paint is/// already based on the current GUI geometry.+ pub(crate) fn sync_replacement_frontend_geometry(+ &mut self,+ tab_id: mux::tab::TabId,+ slot: FrontendRecoverySlot,+ generation: u64,+ ) -> bool {+ if slot != self.frontend_recovery_slot() {+ return false;+ }+ let mux = Mux::get();+ let Some(mut window) = mux.get_window_mut(self.mux_window_id) else {+ return false;+ };+ let Some(tab_idx) = window.idx_by_id(tab_id) else {+ return false;+ };+ let changed = window+ .get_active()+ .is_none_or(|active| active.tab_id() != tab_id);+ if changed {+ window.save_and_then_set_active(tab_idx);+ }+ drop(window);++ if changed {+ if let Some(tab) = mux.get_tab(tab_id) {+ if let Some(pane) = tab.get_active_pane() {+ pane.focus_changed(true);+ }+ }+ self.update_title();+ self.update_scrollbar();+ }++ let Some(tab) = mux.get_tab(tab_id) else {+ return false;+ };+ let Some(active_pane) = tab.get_active_pane() else {+ return false;+ };+ let Some(client_pane) = active_pane.downcast_ref::<ClientPane>() else {+ return false;+ };+ let Some(domain) = mux.get_domain(client_pane.domain_id()) else {+ return false;+ };+ let Some(client_domain) = domain.downcast_ref::<ClientDomain>() else {+ return false;+ };+ if client_domain.pending_frontend_recovery(slot, tab_id) != Some(generation) {+ return false;+ }++ // Another device already owns B. Confirm that state through a+ // dedicated recovery report, but do not reshape this hidden mirror.+ if client_domain.owns_remote_viewport(tab_id) == Some(false) {+ let Some((domain, viewport)) = self.client_viewport_for_tab(&tab, false) else {+ return false;+ };+ let Some(client_domain) = domain.downcast_ref::<ClientDomain>() else {+ return false;+ };+ self.remember_gui_recovery_intent(client_domain, tab_id, &viewport);+ let Some(window) = self.window.as_ref().cloned() else {+ return false;+ };+ let domain_id = client_domain.domain_id();+ let domain_for_task = Arc::clone(&domain);+ promise::spawn::spawn(async move {+ let Some(client_domain) = domain_for_task.downcast_ref::<ClientDomain>() else {+ return Ok::<(), anyhow::Error>(());+ };+ let result = client_domain.set_client_viewport(tab_id, viewport).await;+ match result {+ Ok(_) if client_domain.owns_remote_viewport(tab_id) == Some(false) => {+ client_domain.acknowledge_frontend_recovery(slot, tab_id, generation);+ }+ Ok(_) => {+ // The passive report made this client the first owner.+ // Re-enter on the GUI thread and install Native geometry+ // before acknowledging the recovery barrier.+ window.notify(TermWindowNotif::Apply(Box::new(move |term_window| {+ if !term_window+ .sync_replacement_frontend_geometry(tab_id, slot, generation)+ {+ if let Some(domain) = Mux::get().get_domain(domain_id) {+ if let Some(client) = domain.downcast_ref::<ClientDomain>() {+ client.fail_frontend_recovery(+ slot,+ tab_id,+ generation,+ "GUI could not converge replacement geometry",+ );+ }+ }+ }+ })));+ }+ Err(err) => {+ client_domain.fail_frontend_recovery(+ slot,+ tab_id,+ generation,+ format!("GUI replacement viewport failed: {err:#}"),+ );+ }+ }+ Ok::<(), anyhow::Error>(())+ })+ .detach();+ return true;+ }++ self.sync_active_tab_geometry_now();+ let Some(phase) = self.frontend_geometry_phases.get(&tab_id).copied() else {+ return false;+ };+ let epoch = phase.epoch();+ self.frontend_geometry_phases.insert(+ tab_id,+ super::FrontendGeometryPhase::TakeoverSyncing { epoch },+ );+ self.frontend_recovery_geometry.insert(+ tab_id,+ super::FrontendRecoveryGeometry {+ epoch,+ domain_id: client_pane.domain_id(),+ slot,+ generation,+ },+ );+ self.invalidate_window();+ true+ }+pub(crate) fn sync_active_tab_geometry_now(&mut self) {if self.content_view_foreground() {return;@@ -784,6 +996,9 @@ impl super::TermWindow {self.invalidate_window();return;};+ if let Some(client_domain) = domain.downcast_ref::<ClientDomain>() {+ self.remember_gui_recovery_intent(client_domain, tab_id, &viewport);+ }let Some(window) = self.window.as_ref().cloned() else {self.frontend_geometry_phases.remove(&tab_id);return;@@ -842,6 +1057,9 @@ impl super::TermWindow {let Some((domain, viewport)) = self.client_viewport_for_tab(tab, include_panes) else {return;};+ if let Some(client_domain) = domain.downcast_ref::<ClientDomain>() {+ self.remember_gui_recovery_intent(client_domain, tab_id, &viewport);+ }let adopted = match &viewport {codec::ClientViewport::Native { panes, .. } => panes.iter()@@ -1726,7 +1944,13 @@ impl super::TermWindow {}self.persist_workspace_pane_font_scales();- self.sync_pane_font_sizes();+ // A pane-local font change leaves the tab root unchanged, but changes+ // the number of rows and columns that fit inside this pane. Adopting+ // only the local ClientPane surface makes the renderer look resized+ // while the remote PTY keeps its previous geometry. Converge the+ // complete active-tab viewport so Cmd/Ctrl +/-/0, menu actions and+ // split panes all update the authoritative PTY size as one layout.+ self.sync_active_tab_geometry_now();self.quad_generation += 1;self.shape_generation += 1;self.shape_cache.borrow_mut().clear();diff --git a/wezterm-mux-server-impl/src/thinkterm_layout.rs b/wezterm-mux-server-impl/src/thinkterm_layout.rsindex f29ad5a2..4ab60496 100644--- a/wezterm-mux-server-impl/src/thinkterm_layout.rs+++ b/wezterm-mux-server-impl/src/thinkterm_layout.rs@@ -57,6 +57,11 @@ struct StoredTerminalSpec {pane_id: PaneId,cwd: Option<String>,domain: Option<String>,+ /// Older snapshots written while pane titles were intentionally omitted+ /// do not contain this field. Titles are not used to restore the layout,+ /// but continuing to write them keeps snapshots readable by older server+ /// binaries after a downgrade.+ #[serde(default)]title: String,}@@ -224,6 +229,14 @@ fn schedule_snapshot() {.detach();}+/// Persist the latest complete mux topology synchronously. The mux-server+/// calls this before controlled termination so the debounce window cannot+/// discard the user's final split/tab/focus change.+pub fn flush_now() -> Result<()> {+ let generation = CHANGE_GENERATION.fetch_add(1, Ordering::AcqRel) + 1;+ snapshot_live_layouts(generation)+}+fn thread_records(tree: &codec::ThinkTermTree) -> Vec<(String, String)> {tree.projects.iter()@@ -302,14 +315,17 @@ fn snapshot_live_layouts(_generation: u64) -> Result<()> {}fn snapshot_workspace(mux: &Mux, workspace: &str) -> Result<Option<StoredThreadLayout>> {- for window_id in mux.iter_windows_in_workspace(workspace) {+ let mut window_ids = mux.iter_windows_in_workspace(workspace);+ window_ids.sort_unstable();+ let mut windows = Vec::new();++ for window_id in window_ids {let Some(window) = mux.get_window(window_id) else {continue;};if !window.iter().any(|tab| !tab.iter_all_panes().is_empty()) {continue;}- let active_tab = window.get_active_idx();let mut terminal_specs = Vec::new();let mut tabs = Vec::new();for tab in window.iter() {@@ -317,17 +333,40 @@ fn snapshot_workspace(mux: &Mux, workspace: &str) -> Result<Option<StoredThreadLcollect_terminal_specs(mux, &node, &mut terminal_specs);tabs.push(serde_json::to_value(node).context("serialize pane tree")?);}- if tabs.is_empty() {- return Ok(None);+ windows.push((window.get_active_idx(), tabs, terminal_specs));+ }++ Ok(merge_workspace_snapshots(workspace, windows))+}++fn merge_workspace_snapshots(+ workspace: &str,+ windows: Vec<(usize, Vec<serde_json::Value>, Vec<StoredTerminalSpec>)>,+) -> Option<StoredThreadLayout> {+ let mut active_tab = 0;+ let mut saw_live_window = false;+ let mut terminal_specs = Vec::new();+ let mut tabs = Vec::new();+ for (window_active_tab, window_tabs, window_specs) in windows {+ if window_tabs.is_empty() {+ continue;}- return Ok(Some(StoredThreadLayout {- workspace: workspace.to_string(),- active_tab,- tabs,- terminal_specs,- }));+ if !saw_live_window {+ active_tab = tabs.len() + window_active_tab.min(window_tabs.len() - 1);+ saw_live_window = true;+ }+ tabs.extend(window_tabs);+ terminal_specs.extend(window_specs);}- Ok(None)+ if tabs.is_empty() {+ return None;+ }+ Some(StoredThreadLayout {+ workspace: workspace.to_string(),+ active_tab: active_tab.min(tabs.len() - 1),+ tabs,+ terminal_specs,+ })}fn collect_terminal_specs(@@ -794,6 +833,36 @@ mod tests {assert_eq!(load_from_path(&path).unwrap(), stored);}+ #[test]+ fn snapshot_without_terminal_title_remains_readable() {+ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("thinkterm_layout.json");+ let mut stored = StoredLayouts::default();+ stored+ .layouts+ .insert("thread-1".to_string(), sample_layout("workspace-1"));++ let mut json = serde_json::to_value(&stored).unwrap();+ json["layouts"]["thread-1"]["terminal_specs"][0]+ .as_object_mut()+ .unwrap()+ .remove("title");+ std::fs::write(&path, serde_json::to_vec_pretty(&json).unwrap()).unwrap();++ let loaded = load_from_path(&path).unwrap();+ assert_eq!(loaded.layouts["thread-1"].terminal_specs[0].title, "");++ // Keep emitting the field so a later downgrade to a server that still+ // requires it can read the snapshot produced by this version.+ save_to_path(&path, &loaded).unwrap();+ let rewritten: serde_json::Value =+ serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();+ assert_eq!(+ rewritten["layouts"]["thread-1"]["terminal_specs"][0]["title"],+ ""+ );+ }+#[test]fn malformed_or_unknown_layout_file_is_not_replaced() {let dir = tempfile::tempdir().unwrap();@@ -940,6 +1009,49 @@ mod tests {);}+ #[test]+ fn multiple_workspace_windows_are_merged_in_stable_order() {+ let size = TerminalSize {+ rows: 24,+ cols: 80,+ pixel_width: 0,+ pixel_height: 0,+ dpi: 96,+ };+ let tab = |pane_id| {+ serde_json::to_value(PaneNode::Leaf(pane_entry(pane_id, size, false))).unwrap()+ };+ let spec = |pane_id| StoredTerminalSpec {+ pane_id,+ cwd: None,+ domain: Some("local".to_string()),+ title: "shell".to_string(),+ };+ let merged = merge_workspace_snapshots(+ "workspace-1",+ vec![+ (1, vec![tab(10), tab(11)], vec![spec(10), spec(11)]),+ (0, vec![tab(20)], vec![spec(20)]),+ ],+ )+ .unwrap();++ assert_eq!(merged.active_tab, 1);+ assert_eq!(merged.tabs.len(), 3);+ assert_eq!(merged.terminal_specs.len(), 3);+ let panes = merged+ .tabs+ .iter()+ .map(+ |tab| match serde_json::from_value::<PaneNode>(tab.clone()).unwrap() {+ PaneNode::Leaf(entry) => entry.pane_id,+ other => panic!("unexpected tab node: {:?}", other),+ },+ )+ .collect::<Vec<_>>();+ assert_eq!(panes, vec![10, 11, 20]);+ }+#[test]fn unreadable_pane_tree_rejects_restore_without_mutating_the_snapshot() {let mut layout = sample_layout("workspace-1");diff --git a/wezterm-mux-server/Cargo.toml b/wezterm-mux-server/Cargo.tomlindex 2838cfe8..c95f37d3 100644--- a/wezterm-mux-server/Cargo.toml+++ b/wezterm-mux-server/Cargo.toml@@ -21,6 +21,7 @@ mlua.workspace = trueopenssl.workspace = trueportable-pty = { workspace=true, features = ["serde_support"]}promise.workspace = true+signal-hook.workspace = trueumask.workspace = truewezterm-blob-leases = {workspace=true, features=["simple_tempdir"]}wezterm-mux-server-impl.workspace = truediff --git a/wezterm-mux-server/src/main.rs b/wezterm-mux-server/src/main.rsindex d64dd6d8..b8e9bfff 100644--- a/wezterm-mux-server/src/main.rs+++ b/wezterm-mux-server/src/main.rs@@ -228,6 +228,8 @@ fn run() -> anyhow::Result<()> {let mux = Arc::new(mux::Mux::new(Some(domain.clone())));Mux::set_mux(&mux);+ install_shutdown_signal_handler()?;+let executor = promise::spawn::SimpleExecutor::new();spawn_listener().map_err(|e| {@@ -302,9 +304,37 @@ async fn async_run(cmd: Option<CommandBuilder>) -> anyhow::Result<()> {fn terminate_with_error(err: anyhow::Error) -> ! {log::error!("{:#}; terminating", err);+ if let Err(flush_err) = wezterm_mux_server_impl::thinkterm_layout::flush_now() {+ log::error!("flushing ThinkTerm layouts before termination: {flush_err:#}");+ }std::process::exit(1);}+#[cfg(unix)]+fn install_shutdown_signal_handler() -> anyhow::Result<()> {+ use signal_hook::consts::signal::{SIGINT, SIGTERM};+ use signal_hook::iterator::Signals;++ let mut signals = Signals::new([SIGINT, SIGTERM])?;+ thread::spawn(move || {+ if signals.forever().next().is_some() {+ promise::spawn::spawn_into_main_thread(async move {+ if let Err(err) = wezterm_mux_server_impl::thinkterm_layout::flush_now() {+ log::error!("flushing ThinkTerm layouts before shutdown: {err:#}");+ }+ std::process::exit(0);+ })+ .detach();+ }+ });+ Ok(())+}++#[cfg(not(unix))]+fn install_shutdown_signal_handler() -> anyhow::Result<()> {+ Ok(())+}+mod ossl;pub fn spawn_listener() -> anyhow::Result<()> {